/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: 2018-02-08 12:25:31 UTC
  • Revision ID: teddy@recompile.se-20180208122531-v3xrzi5xafudv2pc
Eliminate unnecessary shell commands in Debian package rules

* debian/rules (override_dh_fixperms-arch): Use the DEB_HOST_MULTIARCH
  variable directly instead of shelling out to "dpkg-architecture".

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
1
1
#!/usr/bin/python
2
2
# -*- mode: python; coding: utf-8 -*-
3
 
# 
 
3
#
4
4
# Mandos server - give out binary blobs to connecting clients.
5
 
# 
 
5
#
6
6
# This program is partly derived from an example program for an Avahi
7
7
# service publisher, downloaded from
8
8
# <http://avahi.org/wiki/PythonPublishExample>.  This includes the
9
9
# methods "add", "remove", "server_state_changed",
10
10
# "entry_group_state_changed", "cleanup", and "activate" in the
11
11
# "AvahiService" class, and some lines in "main".
12
 
# 
 
12
#
13
13
# Everything else is
14
 
# Copyright © 2008-2012 Teddy Hogeborn
15
 
# Copyright © 2008-2012 Björn Påhlsson
16
 
# 
17
 
# This program is free software: you can redistribute it and/or modify
18
 
# it under the terms of the GNU General Public License as published by
 
14
# Copyright © 2008-2018 Teddy Hogeborn
 
15
# Copyright © 2008-2018 Björn Påhlsson
 
16
#
 
17
# This file is part of Mandos.
 
18
#
 
19
# Mandos is free software: you can redistribute it and/or modify it
 
20
# under the terms of the GNU General Public License as published by
19
21
# the Free Software Foundation, either version 3 of the License, or
20
22
# (at your option) any later version.
21
23
#
22
 
#     This program is distributed in the hope that it will be useful,
23
 
#     but WITHOUT ANY WARRANTY; without even the implied warranty of
 
24
#     Mandos is distributed in the hope that it will be useful, but
 
25
#     WITHOUT ANY WARRANTY; without even the implied warranty of
24
26
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
25
27
#     GNU General Public License for more details.
26
 
# 
 
28
#
27
29
# You should have received a copy of the GNU General Public License
28
 
# along with this program.  If not, see
29
 
# <http://www.gnu.org/licenses/>.
30
 
# 
 
30
# along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
 
31
#
31
32
# Contact the authors at <mandos@recompile.se>.
32
 
# 
 
33
#
33
34
 
34
35
from __future__ import (division, absolute_import, print_function,
35
36
                        unicode_literals)
36
37
 
37
 
import SocketServer as socketserver
 
38
try:
 
39
    from future_builtins import *
 
40
except ImportError:
 
41
    pass
 
42
 
 
43
try:
 
44
    import SocketServer as socketserver
 
45
except ImportError:
 
46
    import socketserver
38
47
import socket
39
48
import argparse
40
49
import datetime
41
50
import errno
42
 
import gnutls.crypto
43
 
import gnutls.connection
44
 
import gnutls.errors
45
 
import gnutls.library.functions
46
 
import gnutls.library.constants
47
 
import gnutls.library.types
48
 
import ConfigParser as configparser
 
51
try:
 
52
    import ConfigParser as configparser
 
53
except ImportError:
 
54
    import configparser
49
55
import sys
50
56
import re
51
57
import os
60
66
import struct
61
67
import fcntl
62
68
import functools
63
 
import cPickle as pickle
 
69
try:
 
70
    import cPickle as pickle
 
71
except ImportError:
 
72
    import pickle
64
73
import multiprocessing
65
74
import types
66
75
import binascii
67
76
import tempfile
68
77
import itertools
 
78
import collections
 
79
import codecs
69
80
 
70
81
import dbus
71
82
import dbus.service
72
 
import gobject
73
 
import avahi
 
83
from gi.repository import GLib
74
84
from dbus.mainloop.glib import DBusGMainLoop
75
85
import ctypes
76
86
import ctypes.util
77
87
import xml.dom.minidom
78
88
import inspect
79
 
import GnuPGInterface
80
89
 
 
90
# Try to find the value of SO_BINDTODEVICE:
81
91
try:
 
92
    # This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
 
93
    # newer, and it is also the most natural place for it:
82
94
    SO_BINDTODEVICE = socket.SO_BINDTODEVICE
83
95
except AttributeError:
84
96
    try:
 
97
        # This is where SO_BINDTODEVICE was up to and including Python
 
98
        # 2.6, and also 3.2:
85
99
        from IN import SO_BINDTODEVICE
86
100
    except ImportError:
87
 
        SO_BINDTODEVICE = None
88
 
 
89
 
version = "1.5.3"
 
101
        # In Python 2.7 it seems to have been removed entirely.
 
102
        # Try running the C preprocessor:
 
103
        try:
 
104
            cc = subprocess.Popen(["cc", "--language=c", "-E",
 
105
                                   "/dev/stdin"],
 
106
                                  stdin=subprocess.PIPE,
 
107
                                  stdout=subprocess.PIPE)
 
108
            stdout = cc.communicate(
 
109
                "#include <sys/socket.h>\nSO_BINDTODEVICE\n")[0]
 
110
            SO_BINDTODEVICE = int(stdout.splitlines()[-1])
 
111
        except (OSError, ValueError, IndexError):
 
112
            # No value found
 
113
            SO_BINDTODEVICE = None
 
114
 
 
115
if sys.version_info.major == 2:
 
116
    str = unicode
 
117
 
 
118
version = "1.7.16"
90
119
stored_state_file = "clients.pickle"
91
120
 
92
121
logger = logging.getLogger()
93
 
syslogger = (logging.handlers.SysLogHandler
94
 
             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
95
 
              address = str("/dev/log")))
 
122
syslogger = None
96
123
 
97
124
try:
98
 
    if_nametoindex = (ctypes.cdll.LoadLibrary
99
 
                      (ctypes.util.find_library("c"))
100
 
                      .if_nametoindex)
 
125
    if_nametoindex = ctypes.cdll.LoadLibrary(
 
126
        ctypes.util.find_library("c")).if_nametoindex
101
127
except (OSError, AttributeError):
 
128
 
102
129
    def if_nametoindex(interface):
103
130
        "Get an interface index the hard way, i.e. using fcntl()"
104
131
        SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
105
132
        with contextlib.closing(socket.socket()) as s:
106
133
            ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
107
 
                                struct.pack(str("16s16x"),
108
 
                                            interface))
109
 
        interface_index = struct.unpack(str("I"),
110
 
                                        ifreq[16:20])[0]
 
134
                                struct.pack(b"16s16x", interface))
 
135
        interface_index = struct.unpack("I", ifreq[16:20])[0]
111
136
        return interface_index
112
137
 
113
138
 
 
139
def copy_function(func):
 
140
    """Make a copy of a function"""
 
141
    if sys.version_info.major == 2:
 
142
        return types.FunctionType(func.func_code,
 
143
                                  func.func_globals,
 
144
                                  func.func_name,
 
145
                                  func.func_defaults,
 
146
                                  func.func_closure)
 
147
    else:
 
148
        return types.FunctionType(func.__code__,
 
149
                                  func.__globals__,
 
150
                                  func.__name__,
 
151
                                  func.__defaults__,
 
152
                                  func.__closure__)
 
153
 
 
154
 
114
155
def initlogger(debug, level=logging.WARNING):
115
156
    """init logger and add loglevel"""
116
 
    
 
157
 
 
158
    global syslogger
 
159
    syslogger = (logging.handlers.SysLogHandler(
 
160
        facility=logging.handlers.SysLogHandler.LOG_DAEMON,
 
161
        address="/dev/log"))
117
162
    syslogger.setFormatter(logging.Formatter
118
163
                           ('Mandos [%(process)d]: %(levelname)s:'
119
164
                            ' %(message)s'))
120
165
    logger.addHandler(syslogger)
121
 
    
 
166
 
122
167
    if debug:
123
168
        console = logging.StreamHandler()
124
169
        console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
136
181
 
137
182
class PGPEngine(object):
138
183
    """A simple class for OpenPGP symmetric encryption & decryption"""
 
184
 
139
185
    def __init__(self):
140
 
        self.gnupg = GnuPGInterface.GnuPG()
141
186
        self.tempdir = tempfile.mkdtemp(prefix="mandos-")
142
 
        self.gnupg = GnuPGInterface.GnuPG()
143
 
        self.gnupg.options.meta_interactive = False
144
 
        self.gnupg.options.homedir = self.tempdir
145
 
        self.gnupg.options.extra_args.extend(['--force-mdc',
146
 
                                              '--quiet',
147
 
                                              '--no-use-agent'])
148
 
    
 
187
        self.gpg = "gpg"
 
188
        try:
 
189
            output = subprocess.check_output(["gpgconf"])
 
190
            for line in output.splitlines():
 
191
                name, text, path = line.split(b":")
 
192
                if name == "gpg":
 
193
                    self.gpg = path
 
194
                    break
 
195
        except OSError as e:
 
196
            if e.errno != errno.ENOENT:
 
197
                raise
 
198
        self.gnupgargs = ['--batch',
 
199
                          '--homedir', self.tempdir,
 
200
                          '--force-mdc',
 
201
                          '--quiet']
 
202
        # Only GPG version 1 has the --no-use-agent option.
 
203
        if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
 
204
            self.gnupgargs.append("--no-use-agent")
 
205
 
149
206
    def __enter__(self):
150
207
        return self
151
 
    
152
 
    def __exit__ (self, exc_type, exc_value, traceback):
 
208
 
 
209
    def __exit__(self, exc_type, exc_value, traceback):
153
210
        self._cleanup()
154
211
        return False
155
 
    
 
212
 
156
213
    def __del__(self):
157
214
        self._cleanup()
158
 
    
 
215
 
159
216
    def _cleanup(self):
160
217
        if self.tempdir is not None:
161
218
            # Delete contents of tempdir
162
219
            for root, dirs, files in os.walk(self.tempdir,
163
 
                                             topdown = False):
 
220
                                             topdown=False):
164
221
                for filename in files:
165
222
                    os.remove(os.path.join(root, filename))
166
223
                for dirname in dirs:
168
225
            # Remove tempdir
169
226
            os.rmdir(self.tempdir)
170
227
            self.tempdir = None
171
 
    
 
228
 
172
229
    def password_encode(self, password):
173
230
        # Passphrase can not be empty and can not contain newlines or
174
231
        # NUL bytes.  So we prefix it and hex encode it.
175
 
        return b"mandos" + binascii.hexlify(password)
176
 
    
 
232
        encoded = b"mandos" + binascii.hexlify(password)
 
233
        if len(encoded) > 2048:
 
234
            # GnuPG can't handle long passwords, so encode differently
 
235
            encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
 
236
                       .replace(b"\n", b"\\n")
 
237
                       .replace(b"\0", b"\\x00"))
 
238
        return encoded
 
239
 
177
240
    def encrypt(self, data, password):
178
 
        self.gnupg.passphrase = self.password_encode(password)
179
 
        with open(os.devnull, "w") as devnull:
180
 
            try:
181
 
                proc = self.gnupg.run(['--symmetric'],
182
 
                                      create_fhs=['stdin', 'stdout'],
183
 
                                      attach_fhs={'stderr': devnull})
184
 
                with contextlib.closing(proc.handles['stdin']) as f:
185
 
                    f.write(data)
186
 
                with contextlib.closing(proc.handles['stdout']) as f:
187
 
                    ciphertext = f.read()
188
 
                proc.wait()
189
 
            except IOError as e:
190
 
                raise PGPError(e)
191
 
        self.gnupg.passphrase = None
 
241
        passphrase = self.password_encode(password)
 
242
        with tempfile.NamedTemporaryFile(
 
243
                dir=self.tempdir) as passfile:
 
244
            passfile.write(passphrase)
 
245
            passfile.flush()
 
246
            proc = subprocess.Popen([self.gpg, '--symmetric',
 
247
                                     '--passphrase-file',
 
248
                                     passfile.name]
 
249
                                    + self.gnupgargs,
 
250
                                    stdin=subprocess.PIPE,
 
251
                                    stdout=subprocess.PIPE,
 
252
                                    stderr=subprocess.PIPE)
 
253
            ciphertext, err = proc.communicate(input=data)
 
254
        if proc.returncode != 0:
 
255
            raise PGPError(err)
192
256
        return ciphertext
193
 
    
 
257
 
194
258
    def decrypt(self, data, password):
195
 
        self.gnupg.passphrase = self.password_encode(password)
196
 
        with open(os.devnull, "w") as devnull:
197
 
            try:
198
 
                proc = self.gnupg.run(['--decrypt'],
199
 
                                      create_fhs=['stdin', 'stdout'],
200
 
                                      attach_fhs={'stderr': devnull})
201
 
                with contextlib.closing(proc.handles['stdin']) as f:
202
 
                    f.write(data)
203
 
                with contextlib.closing(proc.handles['stdout']) as f:
204
 
                    decrypted_plaintext = f.read()
205
 
                proc.wait()
206
 
            except IOError as e:
207
 
                raise PGPError(e)
208
 
        self.gnupg.passphrase = None
 
259
        passphrase = self.password_encode(password)
 
260
        with tempfile.NamedTemporaryFile(
 
261
                dir=self.tempdir) as passfile:
 
262
            passfile.write(passphrase)
 
263
            passfile.flush()
 
264
            proc = subprocess.Popen([self.gpg, '--decrypt',
 
265
                                     '--passphrase-file',
 
266
                                     passfile.name]
 
267
                                    + self.gnupgargs,
 
268
                                    stdin=subprocess.PIPE,
 
269
                                    stdout=subprocess.PIPE,
 
270
                                    stderr=subprocess.PIPE)
 
271
            decrypted_plaintext, err = proc.communicate(input=data)
 
272
        if proc.returncode != 0:
 
273
            raise PGPError(err)
209
274
        return decrypted_plaintext
210
275
 
211
276
 
 
277
# Pretend that we have an Avahi module
 
278
class Avahi(object):
 
279
    """This isn't so much a class as it is a module-like namespace.
 
280
    It is instantiated once, and simulates having an Avahi module."""
 
281
    IF_UNSPEC = -1               # avahi-common/address.h
 
282
    PROTO_UNSPEC = -1            # avahi-common/address.h
 
283
    PROTO_INET = 0               # avahi-common/address.h
 
284
    PROTO_INET6 = 1              # avahi-common/address.h
 
285
    DBUS_NAME = "org.freedesktop.Avahi"
 
286
    DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"
 
287
    DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
 
288
    DBUS_PATH_SERVER = "/"
 
289
 
 
290
    def string_array_to_txt_array(self, t):
 
291
        return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
 
292
                           for s in t), signature="ay")
 
293
    ENTRY_GROUP_ESTABLISHED = 2  # avahi-common/defs.h
 
294
    ENTRY_GROUP_COLLISION = 3    # avahi-common/defs.h
 
295
    ENTRY_GROUP_FAILURE = 4      # avahi-common/defs.h
 
296
    SERVER_INVALID = 0           # avahi-common/defs.h
 
297
    SERVER_REGISTERING = 1       # avahi-common/defs.h
 
298
    SERVER_RUNNING = 2           # avahi-common/defs.h
 
299
    SERVER_COLLISION = 3         # avahi-common/defs.h
 
300
    SERVER_FAILURE = 4           # avahi-common/defs.h
 
301
avahi = Avahi()
 
302
 
212
303
 
213
304
class AvahiError(Exception):
214
305
    def __init__(self, value, *args, **kwargs):
215
306
        self.value = value
216
 
        super(AvahiError, self).__init__(value, *args, **kwargs)
217
 
    def __unicode__(self):
218
 
        return unicode(repr(self.value))
 
307
        return super(AvahiError, self).__init__(value, *args,
 
308
                                                **kwargs)
 
309
 
219
310
 
220
311
class AvahiServiceError(AvahiError):
221
312
    pass
222
313
 
 
314
 
223
315
class AvahiGroupError(AvahiError):
224
316
    pass
225
317
 
226
318
 
227
319
class AvahiService(object):
228
320
    """An Avahi (Zeroconf) service.
229
 
    
 
321
 
230
322
    Attributes:
231
323
    interface: integer; avahi.IF_UNSPEC or an interface index.
232
324
               Used to optionally bind to the specified interface.
233
325
    name: string; Example: 'Mandos'
234
326
    type: string; Example: '_mandos._tcp'.
235
 
                  See <http://www.dns-sd.org/ServiceTypes.html>
 
327
     See <https://www.iana.org/assignments/service-names-port-numbers>
236
328
    port: integer; what port to announce
237
329
    TXT: list of strings; TXT record for the service
238
330
    domain: string; Domain to publish on, default to .local if empty.
244
336
    server: D-Bus Server
245
337
    bus: dbus.SystemBus()
246
338
    """
247
 
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
248
 
                 servicetype = None, port = None, TXT = None,
249
 
                 domain = "", host = "", max_renames = 32768,
250
 
                 protocol = avahi.PROTO_UNSPEC, bus = None):
 
339
 
 
340
    def __init__(self,
 
341
                 interface=avahi.IF_UNSPEC,
 
342
                 name=None,
 
343
                 servicetype=None,
 
344
                 port=None,
 
345
                 TXT=None,
 
346
                 domain="",
 
347
                 host="",
 
348
                 max_renames=32768,
 
349
                 protocol=avahi.PROTO_UNSPEC,
 
350
                 bus=None):
251
351
        self.interface = interface
252
352
        self.name = name
253
353
        self.type = servicetype
262
362
        self.server = None
263
363
        self.bus = bus
264
364
        self.entry_group_state_changed_match = None
265
 
    def rename(self):
 
365
 
 
366
    def rename(self, remove=True):
266
367
        """Derived from the Avahi example code"""
267
368
        if self.rename_count >= self.max_renames:
268
369
            logger.critical("No suitable Zeroconf service name found"
269
370
                            " after %i retries, exiting.",
270
371
                            self.rename_count)
271
372
            raise AvahiServiceError("Too many renames")
272
 
        self.name = unicode(self.server
273
 
                            .GetAlternativeServiceName(self.name))
 
373
        self.name = str(
 
374
            self.server.GetAlternativeServiceName(self.name))
 
375
        self.rename_count += 1
274
376
        logger.info("Changing Zeroconf service name to %r ...",
275
377
                    self.name)
276
 
        self.remove()
 
378
        if remove:
 
379
            self.remove()
277
380
        try:
278
381
            self.add()
279
382
        except dbus.exceptions.DBusException as error:
280
 
            logger.critical("D-Bus Exception", exc_info=error)
281
 
            self.cleanup()
282
 
            os._exit(1)
283
 
        self.rename_count += 1
 
383
            if (error.get_dbus_name()
 
384
                == "org.freedesktop.Avahi.CollisionError"):
 
385
                logger.info("Local Zeroconf service name collision.")
 
386
                return self.rename(remove=False)
 
387
            else:
 
388
                logger.critical("D-Bus Exception", exc_info=error)
 
389
                self.cleanup()
 
390
                os._exit(1)
 
391
 
284
392
    def remove(self):
285
393
        """Derived from the Avahi example code"""
286
394
        if self.entry_group_state_changed_match is not None:
288
396
            self.entry_group_state_changed_match = None
289
397
        if self.group is not None:
290
398
            self.group.Reset()
 
399
 
291
400
    def add(self):
292
401
        """Derived from the Avahi example code"""
293
402
        self.remove()
310
419
            dbus.UInt16(self.port),
311
420
            avahi.string_array_to_txt_array(self.TXT))
312
421
        self.group.Commit()
 
422
 
313
423
    def entry_group_state_changed(self, state, error):
314
424
        """Derived from the Avahi example code"""
315
425
        logger.debug("Avahi entry group state change: %i", state)
316
 
        
 
426
 
317
427
        if state == avahi.ENTRY_GROUP_ESTABLISHED:
318
428
            logger.debug("Zeroconf service established.")
319
429
        elif state == avahi.ENTRY_GROUP_COLLISION:
321
431
            self.rename()
322
432
        elif state == avahi.ENTRY_GROUP_FAILURE:
323
433
            logger.critical("Avahi: Error in group state changed %s",
324
 
                            unicode(error))
325
 
            raise AvahiGroupError("State changed: %s"
326
 
                                  % unicode(error))
 
434
                            str(error))
 
435
            raise AvahiGroupError("State changed: {!s}".format(error))
 
436
 
327
437
    def cleanup(self):
328
438
        """Derived from the Avahi example code"""
329
439
        if self.group is not None:
334
444
                pass
335
445
            self.group = None
336
446
        self.remove()
 
447
 
337
448
    def server_state_changed(self, state, error=None):
338
449
        """Derived from the Avahi example code"""
339
450
        logger.debug("Avahi server state change: %i", state)
340
 
        bad_states = { avahi.SERVER_INVALID:
341
 
                           "Zeroconf server invalid",
342
 
                       avahi.SERVER_REGISTERING: None,
343
 
                       avahi.SERVER_COLLISION:
344
 
                           "Zeroconf server name collision",
345
 
                       avahi.SERVER_FAILURE:
346
 
                           "Zeroconf server failure" }
 
451
        bad_states = {
 
452
            avahi.SERVER_INVALID: "Zeroconf server invalid",
 
453
            avahi.SERVER_REGISTERING: None,
 
454
            avahi.SERVER_COLLISION: "Zeroconf server name collision",
 
455
            avahi.SERVER_FAILURE: "Zeroconf server failure",
 
456
        }
347
457
        if state in bad_states:
348
458
            if bad_states[state] is not None:
349
459
                if error is None:
352
462
                    logger.error(bad_states[state] + ": %r", error)
353
463
            self.cleanup()
354
464
        elif state == avahi.SERVER_RUNNING:
355
 
            self.add()
 
465
            try:
 
466
                self.add()
 
467
            except dbus.exceptions.DBusException as error:
 
468
                if (error.get_dbus_name()
 
469
                    == "org.freedesktop.Avahi.CollisionError"):
 
470
                    logger.info("Local Zeroconf service name"
 
471
                                " collision.")
 
472
                    return self.rename(remove=False)
 
473
                else:
 
474
                    logger.critical("D-Bus Exception", exc_info=error)
 
475
                    self.cleanup()
 
476
                    os._exit(1)
356
477
        else:
357
478
            if error is None:
358
479
                logger.debug("Unknown state: %r", state)
359
480
            else:
360
481
                logger.debug("Unknown state: %r: %r", state, error)
 
482
 
361
483
    def activate(self):
362
484
        """Derived from the Avahi example code"""
363
485
        if self.server is None:
367
489
                                    follow_name_owner_changes=True),
368
490
                avahi.DBUS_INTERFACE_SERVER)
369
491
        self.server.connect_to_signal("StateChanged",
370
 
                                 self.server_state_changed)
 
492
                                      self.server_state_changed)
371
493
        self.server_state_changed(self.server.GetState())
372
494
 
 
495
 
373
496
class AvahiServiceToSyslog(AvahiService):
374
 
    def rename(self):
 
497
    def rename(self, *args, **kwargs):
375
498
        """Add the new name to the syslog messages"""
376
 
        ret = AvahiService.rename(self)
377
 
        syslogger.setFormatter(logging.Formatter
378
 
                               ('Mandos (%s) [%%(process)d]:'
379
 
                                ' %%(levelname)s: %%(message)s'
380
 
                                % self.name))
 
499
        ret = super(AvahiServiceToSyslog, self).rename(self, *args,
 
500
                                                       **kwargs)
 
501
        syslogger.setFormatter(logging.Formatter(
 
502
            'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
 
503
            .format(self.name)))
381
504
        return ret
382
505
 
383
 
def timedelta_to_milliseconds(td):
384
 
    "Convert a datetime.timedelta() to milliseconds"
385
 
    return ((td.days * 24 * 60 * 60 * 1000)
386
 
            + (td.seconds * 1000)
387
 
            + (td.microseconds // 1000))
388
 
        
 
506
 
 
507
# Pretend that we have a GnuTLS module
 
508
class GnuTLS(object):
 
509
    """This isn't so much a class as it is a module-like namespace.
 
510
    It is instantiated once, and simulates having a GnuTLS module."""
 
511
 
 
512
    library = ctypes.util.find_library("gnutls")
 
513
    if library is None:
 
514
        library = ctypes.util.find_library("gnutls-deb0")
 
515
    _library = ctypes.cdll.LoadLibrary(library)
 
516
    del library
 
517
    _need_version = b"3.3.0"
 
518
 
 
519
    def __init__(self):
 
520
        # Need to use "self" here, since this method is called before
 
521
        # the assignment to the "gnutls" global variable happens.
 
522
        if self.check_version(self._need_version) is None:
 
523
            raise self.Error("Needs GnuTLS {} or later"
 
524
                             .format(self._need_version))
 
525
 
 
526
    # Unless otherwise indicated, the constants and types below are
 
527
    # all from the gnutls/gnutls.h C header file.
 
528
 
 
529
    # Constants
 
530
    E_SUCCESS = 0
 
531
    E_INTERRUPTED = -52
 
532
    E_AGAIN = -28
 
533
    CRT_OPENPGP = 2
 
534
    CLIENT = 2
 
535
    SHUT_RDWR = 0
 
536
    CRD_CERTIFICATE = 1
 
537
    E_NO_CERTIFICATE_FOUND = -49
 
538
    OPENPGP_FMT_RAW = 0         # gnutls/openpgp.h
 
539
 
 
540
    # Types
 
541
    class session_int(ctypes.Structure):
 
542
        _fields_ = []
 
543
    session_t = ctypes.POINTER(session_int)
 
544
 
 
545
    class certificate_credentials_st(ctypes.Structure):
 
546
        _fields_ = []
 
547
    certificate_credentials_t = ctypes.POINTER(
 
548
        certificate_credentials_st)
 
549
    certificate_type_t = ctypes.c_int
 
550
 
 
551
    class datum_t(ctypes.Structure):
 
552
        _fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
 
553
                    ('size', ctypes.c_uint)]
 
554
 
 
555
    class openpgp_crt_int(ctypes.Structure):
 
556
        _fields_ = []
 
557
    openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
 
558
    openpgp_crt_fmt_t = ctypes.c_int  # gnutls/openpgp.h
 
559
    log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
 
560
    credentials_type_t = ctypes.c_int
 
561
    transport_ptr_t = ctypes.c_void_p
 
562
    close_request_t = ctypes.c_int
 
563
 
 
564
    # Exceptions
 
565
    class Error(Exception):
 
566
        # We need to use the class name "GnuTLS" here, since this
 
567
        # exception might be raised from within GnuTLS.__init__,
 
568
        # which is called before the assignment to the "gnutls"
 
569
        # global variable has happened.
 
570
        def __init__(self, message=None, code=None, args=()):
 
571
            # Default usage is by a message string, but if a return
 
572
            # code is passed, convert it to a string with
 
573
            # gnutls.strerror()
 
574
            self.code = code
 
575
            if message is None and code is not None:
 
576
                message = GnuTLS.strerror(code)
 
577
            return super(GnuTLS.Error, self).__init__(
 
578
                message, *args)
 
579
 
 
580
    class CertificateSecurityError(Error):
 
581
        pass
 
582
 
 
583
    # Classes
 
584
    class Credentials(object):
 
585
        def __init__(self):
 
586
            self._c_object = gnutls.certificate_credentials_t()
 
587
            gnutls.certificate_allocate_credentials(
 
588
                ctypes.byref(self._c_object))
 
589
            self.type = gnutls.CRD_CERTIFICATE
 
590
 
 
591
        def __del__(self):
 
592
            gnutls.certificate_free_credentials(self._c_object)
 
593
 
 
594
    class ClientSession(object):
 
595
        def __init__(self, socket, credentials=None):
 
596
            self._c_object = gnutls.session_t()
 
597
            gnutls.init(ctypes.byref(self._c_object), gnutls.CLIENT)
 
598
            gnutls.set_default_priority(self._c_object)
 
599
            gnutls.transport_set_ptr(self._c_object, socket.fileno())
 
600
            gnutls.handshake_set_private_extensions(self._c_object,
 
601
                                                    True)
 
602
            self.socket = socket
 
603
            if credentials is None:
 
604
                credentials = gnutls.Credentials()
 
605
            gnutls.credentials_set(self._c_object, credentials.type,
 
606
                                   ctypes.cast(credentials._c_object,
 
607
                                               ctypes.c_void_p))
 
608
            self.credentials = credentials
 
609
 
 
610
        def __del__(self):
 
611
            gnutls.deinit(self._c_object)
 
612
 
 
613
        def handshake(self):
 
614
            return gnutls.handshake(self._c_object)
 
615
 
 
616
        def send(self, data):
 
617
            data = bytes(data)
 
618
            data_len = len(data)
 
619
            while data_len > 0:
 
620
                data_len -= gnutls.record_send(self._c_object,
 
621
                                               data[-data_len:],
 
622
                                               data_len)
 
623
 
 
624
        def bye(self):
 
625
            return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
 
626
 
 
627
    # Error handling functions
 
628
    def _error_code(result):
 
629
        """A function to raise exceptions on errors, suitable
 
630
        for the 'restype' attribute on ctypes functions"""
 
631
        if result >= 0:
 
632
            return result
 
633
        if result == gnutls.E_NO_CERTIFICATE_FOUND:
 
634
            raise gnutls.CertificateSecurityError(code=result)
 
635
        raise gnutls.Error(code=result)
 
636
 
 
637
    def _retry_on_error(result, func, arguments):
 
638
        """A function to retry on some errors, suitable
 
639
        for the 'errcheck' attribute on ctypes functions"""
 
640
        while result < 0:
 
641
            if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
 
642
                return _error_code(result)
 
643
            result = func(*arguments)
 
644
        return result
 
645
 
 
646
    # Unless otherwise indicated, the function declarations below are
 
647
    # all from the gnutls/gnutls.h C header file.
 
648
 
 
649
    # Functions
 
650
    priority_set_direct = _library.gnutls_priority_set_direct
 
651
    priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
 
652
                                    ctypes.POINTER(ctypes.c_char_p)]
 
653
    priority_set_direct.restype = _error_code
 
654
 
 
655
    init = _library.gnutls_init
 
656
    init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
 
657
    init.restype = _error_code
 
658
 
 
659
    set_default_priority = _library.gnutls_set_default_priority
 
660
    set_default_priority.argtypes = [session_t]
 
661
    set_default_priority.restype = _error_code
 
662
 
 
663
    record_send = _library.gnutls_record_send
 
664
    record_send.argtypes = [session_t, ctypes.c_void_p,
 
665
                            ctypes.c_size_t]
 
666
    record_send.restype = ctypes.c_ssize_t
 
667
    record_send.errcheck = _retry_on_error
 
668
 
 
669
    certificate_allocate_credentials = (
 
670
        _library.gnutls_certificate_allocate_credentials)
 
671
    certificate_allocate_credentials.argtypes = [
 
672
        ctypes.POINTER(certificate_credentials_t)]
 
673
    certificate_allocate_credentials.restype = _error_code
 
674
 
 
675
    certificate_free_credentials = (
 
676
        _library.gnutls_certificate_free_credentials)
 
677
    certificate_free_credentials.argtypes = [
 
678
        certificate_credentials_t]
 
679
    certificate_free_credentials.restype = None
 
680
 
 
681
    handshake_set_private_extensions = (
 
682
        _library.gnutls_handshake_set_private_extensions)
 
683
    handshake_set_private_extensions.argtypes = [session_t,
 
684
                                                 ctypes.c_int]
 
685
    handshake_set_private_extensions.restype = None
 
686
 
 
687
    credentials_set = _library.gnutls_credentials_set
 
688
    credentials_set.argtypes = [session_t, credentials_type_t,
 
689
                                ctypes.c_void_p]
 
690
    credentials_set.restype = _error_code
 
691
 
 
692
    strerror = _library.gnutls_strerror
 
693
    strerror.argtypes = [ctypes.c_int]
 
694
    strerror.restype = ctypes.c_char_p
 
695
 
 
696
    certificate_type_get = _library.gnutls_certificate_type_get
 
697
    certificate_type_get.argtypes = [session_t]
 
698
    certificate_type_get.restype = _error_code
 
699
 
 
700
    certificate_get_peers = _library.gnutls_certificate_get_peers
 
701
    certificate_get_peers.argtypes = [session_t,
 
702
                                      ctypes.POINTER(ctypes.c_uint)]
 
703
    certificate_get_peers.restype = ctypes.POINTER(datum_t)
 
704
 
 
705
    global_set_log_level = _library.gnutls_global_set_log_level
 
706
    global_set_log_level.argtypes = [ctypes.c_int]
 
707
    global_set_log_level.restype = None
 
708
 
 
709
    global_set_log_function = _library.gnutls_global_set_log_function
 
710
    global_set_log_function.argtypes = [log_func]
 
711
    global_set_log_function.restype = None
 
712
 
 
713
    deinit = _library.gnutls_deinit
 
714
    deinit.argtypes = [session_t]
 
715
    deinit.restype = None
 
716
 
 
717
    handshake = _library.gnutls_handshake
 
718
    handshake.argtypes = [session_t]
 
719
    handshake.restype = _error_code
 
720
    handshake.errcheck = _retry_on_error
 
721
 
 
722
    transport_set_ptr = _library.gnutls_transport_set_ptr
 
723
    transport_set_ptr.argtypes = [session_t, transport_ptr_t]
 
724
    transport_set_ptr.restype = None
 
725
 
 
726
    bye = _library.gnutls_bye
 
727
    bye.argtypes = [session_t, close_request_t]
 
728
    bye.restype = _error_code
 
729
    bye.errcheck = _retry_on_error
 
730
 
 
731
    check_version = _library.gnutls_check_version
 
732
    check_version.argtypes = [ctypes.c_char_p]
 
733
    check_version.restype = ctypes.c_char_p
 
734
 
 
735
    # All the function declarations below are from gnutls/openpgp.h
 
736
 
 
737
    openpgp_crt_init = _library.gnutls_openpgp_crt_init
 
738
    openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
 
739
    openpgp_crt_init.restype = _error_code
 
740
 
 
741
    openpgp_crt_import = _library.gnutls_openpgp_crt_import
 
742
    openpgp_crt_import.argtypes = [openpgp_crt_t,
 
743
                                   ctypes.POINTER(datum_t),
 
744
                                   openpgp_crt_fmt_t]
 
745
    openpgp_crt_import.restype = _error_code
 
746
 
 
747
    openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
 
748
    openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
 
749
                                        ctypes.POINTER(ctypes.c_uint)]
 
750
    openpgp_crt_verify_self.restype = _error_code
 
751
 
 
752
    openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
 
753
    openpgp_crt_deinit.argtypes = [openpgp_crt_t]
 
754
    openpgp_crt_deinit.restype = None
 
755
 
 
756
    openpgp_crt_get_fingerprint = (
 
757
        _library.gnutls_openpgp_crt_get_fingerprint)
 
758
    openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
 
759
                                            ctypes.c_void_p,
 
760
                                            ctypes.POINTER(
 
761
                                                ctypes.c_size_t)]
 
762
    openpgp_crt_get_fingerprint.restype = _error_code
 
763
 
 
764
    # Remove non-public functions
 
765
    del _error_code, _retry_on_error
 
766
# Create the global "gnutls" object, simulating a module
 
767
gnutls = GnuTLS()
 
768
 
 
769
 
 
770
def call_pipe(connection,       # : multiprocessing.Connection
 
771
              func, *args, **kwargs):
 
772
    """This function is meant to be called by multiprocessing.Process
 
773
 
 
774
    This function runs func(*args, **kwargs), and writes the resulting
 
775
    return value on the provided multiprocessing.Connection.
 
776
    """
 
777
    connection.send(func(*args, **kwargs))
 
778
    connection.close()
 
779
 
 
780
 
389
781
class Client(object):
390
782
    """A representation of a client host served by this server.
391
 
    
 
783
 
392
784
    Attributes:
393
785
    approved:   bool(); 'None' if not yet approved/disapproved
394
786
    approval_delay: datetime.timedelta(); Time to wait for approval
396
788
    checker:    subprocess.Popen(); a running checker process used
397
789
                                    to see if the client lives.
398
790
                                    'None' if no process is running.
399
 
    checker_callback_tag: a gobject event source tag, or None
 
791
    checker_callback_tag: a GLib event source tag, or None
400
792
    checker_command: string; External command which is run to check
401
793
                     if client lives.  %() expansions are done at
402
794
                     runtime with vars(self) as dict, so that for
403
795
                     instance %(name)s can be used in the command.
404
 
    checker_initiator_tag: a gobject event source tag, or None
 
796
    checker_initiator_tag: a GLib event source tag, or None
405
797
    created:    datetime.datetime(); (UTC) object creation
406
798
    client_structure: Object describing what attributes a client has
407
799
                      and is used for storing the client at exit
408
800
    current_checker_command: string; current running checker_command
409
 
    disable_initiator_tag: a gobject event source tag, or None
 
801
    disable_initiator_tag: a GLib event source tag, or None
410
802
    enabled:    bool()
411
803
    fingerprint: string (40 or 32 hexadecimal digits); used to
412
804
                 uniquely identify the client
417
809
    last_checker_status: integer between 0 and 255 reflecting exit
418
810
                         status of last checker. -1 reflects crashed
419
811
                         checker, -2 means no checker completed yet.
 
812
    last_checker_signal: The signal which killed the last checker, if
 
813
                         last_checker_status is -1
420
814
    last_enabled: datetime.datetime(); (UTC) or None
421
815
    name:       string; from the config file, used in log messages and
422
816
                        D-Bus identifiers
427
821
    runtime_expansions: Allowed attributes for runtime expansion.
428
822
    expires:    datetime.datetime(); time (UTC) when a client will be
429
823
                disabled, or None
 
824
    server_settings: The server_settings dict from main()
430
825
    """
431
 
    
 
826
 
432
827
    runtime_expansions = ("approval_delay", "approval_duration",
433
 
                          "created", "enabled", "fingerprint",
434
 
                          "host", "interval", "last_checked_ok",
 
828
                          "created", "enabled", "expires",
 
829
                          "fingerprint", "host", "interval",
 
830
                          "last_approval_request", "last_checked_ok",
435
831
                          "last_enabled", "name", "timeout")
436
 
    client_defaults = { "timeout": "5m",
437
 
                        "extended_timeout": "15m",
438
 
                        "interval": "2m",
439
 
                        "checker": "fping -q -- %%(host)s",
440
 
                        "host": "",
441
 
                        "approval_delay": "0s",
442
 
                        "approval_duration": "1s",
443
 
                        "approved_by_default": "True",
444
 
                        "enabled": "True",
445
 
                        }
446
 
    
447
 
    def timeout_milliseconds(self):
448
 
        "Return the 'timeout' attribute in milliseconds"
449
 
        return timedelta_to_milliseconds(self.timeout)
450
 
    
451
 
    def extended_timeout_milliseconds(self):
452
 
        "Return the 'extended_timeout' attribute in milliseconds"
453
 
        return timedelta_to_milliseconds(self.extended_timeout)
454
 
    
455
 
    def interval_milliseconds(self):
456
 
        "Return the 'interval' attribute in milliseconds"
457
 
        return timedelta_to_milliseconds(self.interval)
458
 
    
459
 
    def approval_delay_milliseconds(self):
460
 
        return timedelta_to_milliseconds(self.approval_delay)
 
832
    client_defaults = {
 
833
        "timeout": "PT5M",
 
834
        "extended_timeout": "PT15M",
 
835
        "interval": "PT2M",
 
836
        "checker": "fping -q -- %%(host)s",
 
837
        "host": "",
 
838
        "approval_delay": "PT0S",
 
839
        "approval_duration": "PT1S",
 
840
        "approved_by_default": "True",
 
841
        "enabled": "True",
 
842
    }
461
843
 
462
844
    @staticmethod
463
845
    def config_parser(config):
471
853
        for client_name in config.sections():
472
854
            section = dict(config.items(client_name))
473
855
            client = settings[client_name] = {}
474
 
            
 
856
 
475
857
            client["host"] = section["host"]
476
858
            # Reformat values from string types to Python types
477
859
            client["approved_by_default"] = config.getboolean(
478
860
                client_name, "approved_by_default")
479
861
            client["enabled"] = config.getboolean(client_name,
480
862
                                                  "enabled")
481
 
            
 
863
 
 
864
            # Uppercase and remove spaces from fingerprint for later
 
865
            # comparison purposes with return value from the
 
866
            # fingerprint() function
482
867
            client["fingerprint"] = (section["fingerprint"].upper()
483
868
                                     .replace(" ", ""))
484
869
            if "secret" in section:
485
 
                client["secret"] = section["secret"].decode("base64")
 
870
                client["secret"] = codecs.decode(section["secret"]
 
871
                                                 .encode("utf-8"),
 
872
                                                 "base64")
486
873
            elif "secfile" in section:
487
874
                with open(os.path.expanduser(os.path.expandvars
488
875
                                             (section["secfile"])),
489
876
                          "rb") as secfile:
490
877
                    client["secret"] = secfile.read()
491
878
            else:
492
 
                raise TypeError("No secret or secfile for section %s"
493
 
                                % section)
 
879
                raise TypeError("No secret or secfile for section {}"
 
880
                                .format(section))
494
881
            client["timeout"] = string_to_delta(section["timeout"])
495
882
            client["extended_timeout"] = string_to_delta(
496
883
                section["extended_timeout"])
503
890
            client["last_approval_request"] = None
504
891
            client["last_checked_ok"] = None
505
892
            client["last_checker_status"] = -2
506
 
        
 
893
 
507
894
        return settings
508
 
        
509
 
        
510
 
    def __init__(self, settings, name = None):
511
 
        """Note: the 'checker' key in 'config' sets the
512
 
        'checker_command' attribute and *not* the 'checker'
513
 
        attribute."""
 
895
 
 
896
    def __init__(self, settings, name=None, server_settings=None):
514
897
        self.name = name
 
898
        if server_settings is None:
 
899
            server_settings = {}
 
900
        self.server_settings = server_settings
515
901
        # adding all client settings
516
 
        for setting, value in settings.iteritems():
 
902
        for setting, value in settings.items():
517
903
            setattr(self, setting, value)
518
 
        
 
904
 
519
905
        if self.enabled:
520
906
            if not hasattr(self, "last_enabled"):
521
907
                self.last_enabled = datetime.datetime.utcnow()
525
911
        else:
526
912
            self.last_enabled = None
527
913
            self.expires = None
528
 
       
 
914
 
529
915
        logger.debug("Creating client %r", self.name)
530
 
        # Uppercase and remove spaces from fingerprint for later
531
 
        # comparison purposes with return value from the fingerprint()
532
 
        # function
533
916
        logger.debug("  Fingerprint: %s", self.fingerprint)
534
917
        self.created = settings.get("created",
535
918
                                    datetime.datetime.utcnow())
542
925
        self.current_checker_command = None
543
926
        self.approved = None
544
927
        self.approvals_pending = 0
545
 
        self.changedstate = (multiprocessing_manager
546
 
                             .Condition(multiprocessing_manager
547
 
                                        .Lock()))
548
 
        self.client_structure = [attr for attr in
549
 
                                 self.__dict__.iterkeys()
 
928
        self.changedstate = multiprocessing_manager.Condition(
 
929
            multiprocessing_manager.Lock())
 
930
        self.client_structure = [attr
 
931
                                 for attr in self.__dict__.keys()
550
932
                                 if not attr.startswith("_")]
551
933
        self.client_structure.append("client_structure")
552
 
        
553
 
        for name, t in inspect.getmembers(type(self),
554
 
                                          lambda obj:
555
 
                                              isinstance(obj,
556
 
                                                         property)):
 
934
 
 
935
        for name, t in inspect.getmembers(
 
936
                type(self), lambda obj: isinstance(obj, property)):
557
937
            if not name.startswith("_"):
558
938
                self.client_structure.append(name)
559
 
    
 
939
 
560
940
    # Send notice to process children that client state has changed
561
941
    def send_changedstate(self):
562
942
        with self.changedstate:
563
943
            self.changedstate.notify_all()
564
 
    
 
944
 
565
945
    def enable(self):
566
946
        """Start this client's checker and timeout hooks"""
567
947
        if getattr(self, "enabled", False):
568
948
            # Already enabled
569
949
            return
570
 
        self.send_changedstate()
571
950
        self.expires = datetime.datetime.utcnow() + self.timeout
572
951
        self.enabled = True
573
952
        self.last_enabled = datetime.datetime.utcnow()
574
953
        self.init_checker()
575
 
    
 
954
        self.send_changedstate()
 
955
 
576
956
    def disable(self, quiet=True):
577
957
        """Disable this client."""
578
958
        if not getattr(self, "enabled", False):
579
959
            return False
580
960
        if not quiet:
581
 
            self.send_changedstate()
582
 
        if not quiet:
583
961
            logger.info("Disabling client %s", self.name)
584
 
        if getattr(self, "disable_initiator_tag", False):
585
 
            gobject.source_remove(self.disable_initiator_tag)
 
962
        if getattr(self, "disable_initiator_tag", None) is not None:
 
963
            GLib.source_remove(self.disable_initiator_tag)
586
964
            self.disable_initiator_tag = None
587
965
        self.expires = None
588
 
        if getattr(self, "checker_initiator_tag", False):
589
 
            gobject.source_remove(self.checker_initiator_tag)
 
966
        if getattr(self, "checker_initiator_tag", None) is not None:
 
967
            GLib.source_remove(self.checker_initiator_tag)
590
968
            self.checker_initiator_tag = None
591
969
        self.stop_checker()
592
970
        self.enabled = False
593
 
        # Do not run this again if called by a gobject.timeout_add
 
971
        if not quiet:
 
972
            self.send_changedstate()
 
973
        # Do not run this again if called by a GLib.timeout_add
594
974
        return False
595
 
    
 
975
 
596
976
    def __del__(self):
597
977
        self.disable()
598
 
    
 
978
 
599
979
    def init_checker(self):
600
980
        # Schedule a new checker to be started an 'interval' from now,
601
981
        # and every interval from then on.
602
 
        self.checker_initiator_tag = (gobject.timeout_add
603
 
                                      (self.interval_milliseconds(),
604
 
                                       self.start_checker))
 
982
        if self.checker_initiator_tag is not None:
 
983
            GLib.source_remove(self.checker_initiator_tag)
 
984
        self.checker_initiator_tag = GLib.timeout_add(
 
985
            int(self.interval.total_seconds() * 1000),
 
986
            self.start_checker)
605
987
        # Schedule a disable() when 'timeout' has passed
606
 
        self.disable_initiator_tag = (gobject.timeout_add
607
 
                                   (self.timeout_milliseconds(),
608
 
                                    self.disable))
 
988
        if self.disable_initiator_tag is not None:
 
989
            GLib.source_remove(self.disable_initiator_tag)
 
990
        self.disable_initiator_tag = GLib.timeout_add(
 
991
            int(self.timeout.total_seconds() * 1000), self.disable)
609
992
        # Also start a new checker *right now*.
610
993
        self.start_checker()
611
 
    
612
 
    def checker_callback(self, pid, condition, command):
 
994
 
 
995
    def checker_callback(self, source, condition, connection,
 
996
                         command):
613
997
        """The checker has completed, so take appropriate actions."""
614
998
        self.checker_callback_tag = None
615
999
        self.checker = None
616
 
        if os.WIFEXITED(condition):
617
 
            self.last_checker_status = os.WEXITSTATUS(condition)
 
1000
        # Read return code from connection (see call_pipe)
 
1001
        returncode = connection.recv()
 
1002
        connection.close()
 
1003
 
 
1004
        if returncode >= 0:
 
1005
            self.last_checker_status = returncode
 
1006
            self.last_checker_signal = None
618
1007
            if self.last_checker_status == 0:
619
1008
                logger.info("Checker for %(name)s succeeded",
620
1009
                            vars(self))
621
1010
                self.checked_ok()
622
1011
            else:
623
 
                logger.info("Checker for %(name)s failed",
624
 
                            vars(self))
 
1012
                logger.info("Checker for %(name)s failed", vars(self))
625
1013
        else:
626
1014
            self.last_checker_status = -1
 
1015
            self.last_checker_signal = -returncode
627
1016
            logger.warning("Checker for %(name)s crashed?",
628
1017
                           vars(self))
629
 
    
 
1018
        return False
 
1019
 
630
1020
    def checked_ok(self):
631
1021
        """Assert that the client has been seen, alive and well."""
632
1022
        self.last_checked_ok = datetime.datetime.utcnow()
633
1023
        self.last_checker_status = 0
 
1024
        self.last_checker_signal = None
634
1025
        self.bump_timeout()
635
 
    
 
1026
 
636
1027
    def bump_timeout(self, timeout=None):
637
1028
        """Bump up the timeout for this client."""
638
1029
        if timeout is None:
639
1030
            timeout = self.timeout
640
1031
        if self.disable_initiator_tag is not None:
641
 
            gobject.source_remove(self.disable_initiator_tag)
 
1032
            GLib.source_remove(self.disable_initiator_tag)
 
1033
            self.disable_initiator_tag = None
642
1034
        if getattr(self, "enabled", False):
643
 
            self.disable_initiator_tag = (gobject.timeout_add
644
 
                                          (timedelta_to_milliseconds
645
 
                                           (timeout), self.disable))
 
1035
            self.disable_initiator_tag = GLib.timeout_add(
 
1036
                int(timeout.total_seconds() * 1000), self.disable)
646
1037
            self.expires = datetime.datetime.utcnow() + timeout
647
 
    
 
1038
 
648
1039
    def need_approval(self):
649
1040
        self.last_approval_request = datetime.datetime.utcnow()
650
 
    
 
1041
 
651
1042
    def start_checker(self):
652
1043
        """Start a new checker subprocess if one is not running.
653
 
        
 
1044
 
654
1045
        If a checker already exists, leave it running and do
655
1046
        nothing."""
656
1047
        # The reason for not killing a running checker is that if we
657
 
        # did that, then if a checker (for some reason) started
658
 
        # running slowly and taking more than 'interval' time, the
659
 
        # client would inevitably timeout, since no checker would get
660
 
        # a chance to run to completion.  If we instead leave running
 
1048
        # did that, and if a checker (for some reason) started running
 
1049
        # slowly and taking more than 'interval' time, then the client
 
1050
        # would inevitably timeout, since no checker would get a
 
1051
        # chance to run to completion.  If we instead leave running
661
1052
        # checkers alone, the checker would have to take more time
662
1053
        # than 'timeout' for the client to be disabled, which is as it
663
1054
        # should be.
664
 
        
665
 
        # If a checker exists, make sure it is not a zombie
666
 
        try:
667
 
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
668
 
        except (AttributeError, OSError) as error:
669
 
            if (isinstance(error, OSError)
670
 
                and error.errno != errno.ECHILD):
671
 
                raise error
672
 
        else:
673
 
            if pid:
674
 
                logger.warning("Checker was a zombie")
675
 
                gobject.source_remove(self.checker_callback_tag)
676
 
                self.checker_callback(pid, status,
677
 
                                      self.current_checker_command)
 
1055
 
 
1056
        if self.checker is not None and not self.checker.is_alive():
 
1057
            logger.warning("Checker was not alive; joining")
 
1058
            self.checker.join()
 
1059
            self.checker = None
678
1060
        # Start a new checker if needed
679
1061
        if self.checker is None:
 
1062
            # Escape attributes for the shell
 
1063
            escaped_attrs = {
 
1064
                attr: re.escape(str(getattr(self, attr)))
 
1065
                for attr in self.runtime_expansions}
680
1066
            try:
681
 
                # In case checker_command has exactly one % operator
682
 
                command = self.checker_command % self.host
683
 
            except TypeError:
684
 
                # Escape attributes for the shell
685
 
                escaped_attrs = dict(
686
 
                    (attr,
687
 
                     re.escape(unicode(str(getattr(self, attr, "")),
688
 
                                       errors=
689
 
                                       'replace')))
690
 
                    for attr in
691
 
                    self.runtime_expansions)
692
 
                
693
 
                try:
694
 
                    command = self.checker_command % escaped_attrs
695
 
                except TypeError as error:
696
 
                    logger.error('Could not format string "%s"',
697
 
                                 self.checker_command, exc_info=error)
698
 
                    return True # Try again later
 
1067
                command = self.checker_command % escaped_attrs
 
1068
            except TypeError as error:
 
1069
                logger.error('Could not format string "%s"',
 
1070
                             self.checker_command,
 
1071
                             exc_info=error)
 
1072
                return True     # Try again later
699
1073
            self.current_checker_command = command
700
 
            try:
701
 
                logger.info("Starting checker %r for %s",
702
 
                            command, self.name)
703
 
                # We don't need to redirect stdout and stderr, since
704
 
                # in normal mode, that is already done by daemon(),
705
 
                # and in debug mode we don't want to.  (Stdin is
706
 
                # always replaced by /dev/null.)
707
 
                self.checker = subprocess.Popen(command,
708
 
                                                close_fds=True,
709
 
                                                shell=True, cwd="/")
710
 
                self.checker_callback_tag = (gobject.child_watch_add
711
 
                                             (self.checker.pid,
712
 
                                              self.checker_callback,
713
 
                                              data=command))
714
 
                # The checker may have completed before the gobject
715
 
                # watch was added.  Check for this.
716
 
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
717
 
                if pid:
718
 
                    gobject.source_remove(self.checker_callback_tag)
719
 
                    self.checker_callback(pid, status, command)
720
 
            except OSError as error:
721
 
                logger.error("Failed to start subprocess",
722
 
                             exc_info=error)
723
 
        # Re-run this periodically if run by gobject.timeout_add
 
1074
            logger.info("Starting checker %r for %s", command,
 
1075
                        self.name)
 
1076
            # We don't need to redirect stdout and stderr, since
 
1077
            # in normal mode, that is already done by daemon(),
 
1078
            # and in debug mode we don't want to.  (Stdin is
 
1079
            # always replaced by /dev/null.)
 
1080
            # The exception is when not debugging but nevertheless
 
1081
            # running in the foreground; use the previously
 
1082
            # created wnull.
 
1083
            popen_args = {"close_fds": True,
 
1084
                          "shell": True,
 
1085
                          "cwd": "/"}
 
1086
            if (not self.server_settings["debug"]
 
1087
                and self.server_settings["foreground"]):
 
1088
                popen_args.update({"stdout": wnull,
 
1089
                                   "stderr": wnull})
 
1090
            pipe = multiprocessing.Pipe(duplex=False)
 
1091
            self.checker = multiprocessing.Process(
 
1092
                target=call_pipe,
 
1093
                args=(pipe[1], subprocess.call, command),
 
1094
                kwargs=popen_args)
 
1095
            self.checker.start()
 
1096
            self.checker_callback_tag = GLib.io_add_watch(
 
1097
                pipe[0].fileno(), GLib.IO_IN,
 
1098
                self.checker_callback, pipe[0], command)
 
1099
        # Re-run this periodically if run by GLib.timeout_add
724
1100
        return True
725
 
    
 
1101
 
726
1102
    def stop_checker(self):
727
1103
        """Force the checker process, if any, to stop."""
728
1104
        if self.checker_callback_tag:
729
 
            gobject.source_remove(self.checker_callback_tag)
 
1105
            GLib.source_remove(self.checker_callback_tag)
730
1106
            self.checker_callback_tag = None
731
1107
        if getattr(self, "checker", None) is None:
732
1108
            return
733
1109
        logger.debug("Stopping checker for %(name)s", vars(self))
734
 
        try:
735
 
            self.checker.terminate()
736
 
            #time.sleep(0.5)
737
 
            #if self.checker.poll() is None:
738
 
            #    self.checker.kill()
739
 
        except OSError as error:
740
 
            if error.errno != errno.ESRCH: # No such process
741
 
                raise
 
1110
        self.checker.terminate()
742
1111
        self.checker = None
743
1112
 
744
1113
 
745
 
def dbus_service_property(dbus_interface, signature="v",
746
 
                          access="readwrite", byte_arrays=False):
 
1114
def dbus_service_property(dbus_interface,
 
1115
                          signature="v",
 
1116
                          access="readwrite",
 
1117
                          byte_arrays=False):
747
1118
    """Decorators for marking methods of a DBusObjectWithProperties to
748
1119
    become properties on the D-Bus.
749
 
    
 
1120
 
750
1121
    The decorated method will be called with no arguments by "Get"
751
1122
    and with one argument by "Set".
752
 
    
 
1123
 
753
1124
    The parameters, where they are supported, are the same as
754
1125
    dbus.service.method, except there is only "signature", since the
755
1126
    type from Get() and the type sent to Set() is the same.
758
1129
    # "Set" method, so we fail early here:
759
1130
    if byte_arrays and signature != "ay":
760
1131
        raise ValueError("Byte arrays not supported for non-'ay'"
761
 
                         " signature %r" % signature)
 
1132
                         " signature {!r}".format(signature))
 
1133
 
762
1134
    def decorator(func):
763
1135
        func._dbus_is_property = True
764
1136
        func._dbus_interface = dbus_interface
767
1139
        func._dbus_name = func.__name__
768
1140
        if func._dbus_name.endswith("_dbus_property"):
769
1141
            func._dbus_name = func._dbus_name[:-14]
770
 
        func._dbus_get_args_options = {'byte_arrays': byte_arrays }
 
1142
        func._dbus_get_args_options = {'byte_arrays': byte_arrays}
771
1143
        return func
 
1144
 
772
1145
    return decorator
773
1146
 
774
1147
 
775
1148
def dbus_interface_annotations(dbus_interface):
776
 
    """Decorator for marking functions returning interface annotations.
777
 
    
 
1149
    """Decorator for marking functions returning interface annotations
 
1150
 
778
1151
    Usage:
779
 
    
 
1152
 
780
1153
    @dbus_interface_annotations("org.example.Interface")
781
1154
    def _foo(self):  # Function name does not matter
782
1155
        return {"org.freedesktop.DBus.Deprecated": "true",
783
1156
                "org.freedesktop.DBus.Property.EmitsChangedSignal":
784
1157
                    "false"}
785
1158
    """
 
1159
 
786
1160
    def decorator(func):
787
1161
        func._dbus_is_interface = True
788
1162
        func._dbus_interface = dbus_interface
789
1163
        func._dbus_name = dbus_interface
790
1164
        return func
 
1165
 
791
1166
    return decorator
792
1167
 
793
1168
 
794
1169
def dbus_annotations(annotations):
795
1170
    """Decorator to annotate D-Bus methods, signals or properties
796
1171
    Usage:
797
 
    
 
1172
 
 
1173
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
 
1174
                       "org.freedesktop.DBus.Property."
 
1175
                       "EmitsChangedSignal": "false"})
798
1176
    @dbus_service_property("org.example.Interface", signature="b",
799
1177
                           access="r")
800
 
    @dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
801
 
                        "org.freedesktop.DBus.Property."
802
 
                        "EmitsChangedSignal": "false"})
803
1178
    def Property_dbus_property(self):
804
1179
        return dbus.Boolean(False)
 
1180
 
 
1181
    See also the DBusObjectWithAnnotations class.
805
1182
    """
 
1183
 
806
1184
    def decorator(func):
807
1185
        func._dbus_annotations = annotations
808
1186
        return func
 
1187
 
809
1188
    return decorator
810
1189
 
811
1190
 
812
1191
class DBusPropertyException(dbus.exceptions.DBusException):
813
1192
    """A base class for D-Bus property-related exceptions
814
1193
    """
815
 
    def __unicode__(self):
816
 
        return unicode(str(self))
 
1194
    pass
817
1195
 
818
1196
 
819
1197
class DBusPropertyAccessException(DBusPropertyException):
828
1206
    pass
829
1207
 
830
1208
 
831
 
class DBusObjectWithProperties(dbus.service.Object):
832
 
    """A D-Bus object with properties.
833
 
    
834
 
    Classes inheriting from this can use the dbus_service_property
835
 
    decorator to expose methods as D-Bus properties.  It exposes the
836
 
    standard Get(), Set(), and GetAll() methods on the D-Bus.
 
1209
class DBusObjectWithAnnotations(dbus.service.Object):
 
1210
    """A D-Bus object with annotations.
 
1211
 
 
1212
    Classes inheriting from this can use the dbus_annotations
 
1213
    decorator to add annotations to methods or signals.
837
1214
    """
838
 
    
 
1215
 
839
1216
    @staticmethod
840
1217
    def _is_dbus_thing(thing):
841
1218
        """Returns a function testing if an attribute is a D-Bus thing
842
 
        
 
1219
 
843
1220
        If called like _is_dbus_thing("method") it returns a function
844
1221
        suitable for use as predicate to inspect.getmembers().
845
1222
        """
846
 
        return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
 
1223
        return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
847
1224
                                   False)
848
 
    
 
1225
 
849
1226
    def _get_all_dbus_things(self, thing):
850
1227
        """Returns a generator of (name, attribute) pairs
851
1228
        """
852
 
        return ((getattr(athing.__get__(self), "_dbus_name",
853
 
                         name),
 
1229
        return ((getattr(athing.__get__(self), "_dbus_name", name),
854
1230
                 athing.__get__(self))
855
1231
                for cls in self.__class__.__mro__
856
1232
                for name, athing in
857
 
                inspect.getmembers(cls,
858
 
                                   self._is_dbus_thing(thing)))
859
 
    
 
1233
                inspect.getmembers(cls, self._is_dbus_thing(thing)))
 
1234
 
 
1235
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
 
1236
                         out_signature="s",
 
1237
                         path_keyword='object_path',
 
1238
                         connection_keyword='connection')
 
1239
    def Introspect(self, object_path, connection):
 
1240
        """Overloading of standard D-Bus method.
 
1241
 
 
1242
        Inserts annotation tags on methods and signals.
 
1243
        """
 
1244
        xmlstring = dbus.service.Object.Introspect(self, object_path,
 
1245
                                                   connection)
 
1246
        try:
 
1247
            document = xml.dom.minidom.parseString(xmlstring)
 
1248
 
 
1249
            for if_tag in document.getElementsByTagName("interface"):
 
1250
                # Add annotation tags
 
1251
                for typ in ("method", "signal"):
 
1252
                    for tag in if_tag.getElementsByTagName(typ):
 
1253
                        annots = dict()
 
1254
                        for name, prop in (self.
 
1255
                                           _get_all_dbus_things(typ)):
 
1256
                            if (name == tag.getAttribute("name")
 
1257
                                and prop._dbus_interface
 
1258
                                == if_tag.getAttribute("name")):
 
1259
                                annots.update(getattr(
 
1260
                                    prop, "_dbus_annotations", {}))
 
1261
                        for name, value in annots.items():
 
1262
                            ann_tag = document.createElement(
 
1263
                                "annotation")
 
1264
                            ann_tag.setAttribute("name", name)
 
1265
                            ann_tag.setAttribute("value", value)
 
1266
                            tag.appendChild(ann_tag)
 
1267
                # Add interface annotation tags
 
1268
                for annotation, value in dict(
 
1269
                    itertools.chain.from_iterable(
 
1270
                        annotations().items()
 
1271
                        for name, annotations
 
1272
                        in self._get_all_dbus_things("interface")
 
1273
                        if name == if_tag.getAttribute("name")
 
1274
                        )).items():
 
1275
                    ann_tag = document.createElement("annotation")
 
1276
                    ann_tag.setAttribute("name", annotation)
 
1277
                    ann_tag.setAttribute("value", value)
 
1278
                    if_tag.appendChild(ann_tag)
 
1279
                # Fix argument name for the Introspect method itself
 
1280
                if (if_tag.getAttribute("name")
 
1281
                    == dbus.INTROSPECTABLE_IFACE):
 
1282
                    for cn in if_tag.getElementsByTagName("method"):
 
1283
                        if cn.getAttribute("name") == "Introspect":
 
1284
                            for arg in cn.getElementsByTagName("arg"):
 
1285
                                if (arg.getAttribute("direction")
 
1286
                                    == "out"):
 
1287
                                    arg.setAttribute("name",
 
1288
                                                     "xml_data")
 
1289
            xmlstring = document.toxml("utf-8")
 
1290
            document.unlink()
 
1291
        except (AttributeError, xml.dom.DOMException,
 
1292
                xml.parsers.expat.ExpatError) as error:
 
1293
            logger.error("Failed to override Introspection method",
 
1294
                         exc_info=error)
 
1295
        return xmlstring
 
1296
 
 
1297
 
 
1298
class DBusObjectWithProperties(DBusObjectWithAnnotations):
 
1299
    """A D-Bus object with properties.
 
1300
 
 
1301
    Classes inheriting from this can use the dbus_service_property
 
1302
    decorator to expose methods as D-Bus properties.  It exposes the
 
1303
    standard Get(), Set(), and GetAll() methods on the D-Bus.
 
1304
    """
 
1305
 
860
1306
    def _get_dbus_property(self, interface_name, property_name):
861
1307
        """Returns a bound method if one exists which is a D-Bus
862
1308
        property with the specified name and interface.
863
1309
        """
864
 
        for cls in  self.__class__.__mro__:
865
 
            for name, value in (inspect.getmembers
866
 
                                (cls,
867
 
                                 self._is_dbus_thing("property"))):
 
1310
        for cls in self.__class__.__mro__:
 
1311
            for name, value in inspect.getmembers(
 
1312
                    cls, self._is_dbus_thing("property")):
868
1313
                if (value._dbus_name == property_name
869
1314
                    and value._dbus_interface == interface_name):
870
1315
                    return value.__get__(self)
871
 
        
 
1316
 
872
1317
        # No such property
873
 
        raise DBusPropertyNotFound(self.dbus_object_path + ":"
874
 
                                   + interface_name + "."
875
 
                                   + property_name)
876
 
    
877
 
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
 
1318
        raise DBusPropertyNotFound("{}:{}.{}".format(
 
1319
            self.dbus_object_path, interface_name, property_name))
 
1320
 
 
1321
    @classmethod
 
1322
    def _get_all_interface_names(cls):
 
1323
        """Get a sequence of all interfaces supported by an object"""
 
1324
        return (name for name in set(getattr(getattr(x, attr),
 
1325
                                             "_dbus_interface", None)
 
1326
                                     for x in (inspect.getmro(cls))
 
1327
                                     for attr in dir(x))
 
1328
                if name is not None)
 
1329
 
 
1330
    @dbus.service.method(dbus.PROPERTIES_IFACE,
 
1331
                         in_signature="ss",
878
1332
                         out_signature="v")
879
1333
    def Get(self, interface_name, property_name):
880
1334
        """Standard D-Bus property Get() method, see D-Bus standard.
886
1340
        if not hasattr(value, "variant_level"):
887
1341
            return value
888
1342
        return type(value)(value, variant_level=value.variant_level+1)
889
 
    
 
1343
 
890
1344
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
891
1345
    def Set(self, interface_name, property_name, value):
892
1346
        """Standard D-Bus property Set() method, see D-Bus standard.
898
1352
            # The byte_arrays option is not supported yet on
899
1353
            # signatures other than "ay".
900
1354
            if prop._dbus_signature != "ay":
901
 
                raise ValueError
 
1355
                raise ValueError("Byte arrays not supported for non-"
 
1356
                                 "'ay' signature {!r}"
 
1357
                                 .format(prop._dbus_signature))
902
1358
            value = dbus.ByteArray(b''.join(chr(byte)
903
1359
                                            for byte in value))
904
1360
        prop(value)
905
 
    
906
 
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
 
1361
 
 
1362
    @dbus.service.method(dbus.PROPERTIES_IFACE,
 
1363
                         in_signature="s",
907
1364
                         out_signature="a{sv}")
908
1365
    def GetAll(self, interface_name):
909
1366
        """Standard D-Bus property GetAll() method, see D-Bus
910
1367
        standard.
911
 
        
 
1368
 
912
1369
        Note: Will not include properties with access="write".
913
1370
        """
914
1371
        properties = {}
924
1381
            if not hasattr(value, "variant_level"):
925
1382
                properties[name] = value
926
1383
                continue
927
 
            properties[name] = type(value)(value, variant_level=
928
 
                                           value.variant_level+1)
 
1384
            properties[name] = type(value)(
 
1385
                value, variant_level=value.variant_level + 1)
929
1386
        return dbus.Dictionary(properties, signature="sv")
930
 
    
 
1387
 
 
1388
    @dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
 
1389
    def PropertiesChanged(self, interface_name, changed_properties,
 
1390
                          invalidated_properties):
 
1391
        """Standard D-Bus PropertiesChanged() signal, see D-Bus
 
1392
        standard.
 
1393
        """
 
1394
        pass
 
1395
 
931
1396
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
932
1397
                         out_signature="s",
933
1398
                         path_keyword='object_path',
934
1399
                         connection_keyword='connection')
935
1400
    def Introspect(self, object_path, connection):
936
1401
        """Overloading of standard D-Bus method.
937
 
        
 
1402
 
938
1403
        Inserts property tags and interface annotation tags.
939
1404
        """
940
 
        xmlstring = dbus.service.Object.Introspect(self, object_path,
941
 
                                                   connection)
 
1405
        xmlstring = DBusObjectWithAnnotations.Introspect(self,
 
1406
                                                         object_path,
 
1407
                                                         connection)
942
1408
        try:
943
1409
            document = xml.dom.minidom.parseString(xmlstring)
 
1410
 
944
1411
            def make_tag(document, name, prop):
945
1412
                e = document.createElement("property")
946
1413
                e.setAttribute("name", name)
947
1414
                e.setAttribute("type", prop._dbus_signature)
948
1415
                e.setAttribute("access", prop._dbus_access)
949
1416
                return e
 
1417
 
950
1418
            for if_tag in document.getElementsByTagName("interface"):
951
1419
                # Add property tags
952
1420
                for tag in (make_tag(document, name, prop)
955
1423
                            if prop._dbus_interface
956
1424
                            == if_tag.getAttribute("name")):
957
1425
                    if_tag.appendChild(tag)
958
 
                # Add annotation tags
959
 
                for typ in ("method", "signal", "property"):
960
 
                    for tag in if_tag.getElementsByTagName(typ):
961
 
                        annots = dict()
962
 
                        for name, prop in (self.
963
 
                                           _get_all_dbus_things(typ)):
964
 
                            if (name == tag.getAttribute("name")
965
 
                                and prop._dbus_interface
966
 
                                == if_tag.getAttribute("name")):
967
 
                                annots.update(getattr
968
 
                                              (prop,
969
 
                                               "_dbus_annotations",
970
 
                                               {}))
971
 
                        for name, value in annots.iteritems():
972
 
                            ann_tag = document.createElement(
973
 
                                "annotation")
974
 
                            ann_tag.setAttribute("name", name)
975
 
                            ann_tag.setAttribute("value", value)
976
 
                            tag.appendChild(ann_tag)
977
 
                # Add interface annotation tags
978
 
                for annotation, value in dict(
979
 
                    itertools.chain(
980
 
                        *(annotations().iteritems()
981
 
                          for name, annotations in
982
 
                          self._get_all_dbus_things("interface")
983
 
                          if name == if_tag.getAttribute("name")
984
 
                          ))).iteritems():
985
 
                    ann_tag = document.createElement("annotation")
986
 
                    ann_tag.setAttribute("name", annotation)
987
 
                    ann_tag.setAttribute("value", value)
988
 
                    if_tag.appendChild(ann_tag)
 
1426
                # Add annotation tags for properties
 
1427
                for tag in if_tag.getElementsByTagName("property"):
 
1428
                    annots = dict()
 
1429
                    for name, prop in self._get_all_dbus_things(
 
1430
                            "property"):
 
1431
                        if (name == tag.getAttribute("name")
 
1432
                            and prop._dbus_interface
 
1433
                            == if_tag.getAttribute("name")):
 
1434
                            annots.update(getattr(
 
1435
                                prop, "_dbus_annotations", {}))
 
1436
                    for name, value in annots.items():
 
1437
                        ann_tag = document.createElement(
 
1438
                            "annotation")
 
1439
                        ann_tag.setAttribute("name", name)
 
1440
                        ann_tag.setAttribute("value", value)
 
1441
                        tag.appendChild(ann_tag)
989
1442
                # Add the names to the return values for the
990
1443
                # "org.freedesktop.DBus.Properties" methods
991
1444
                if (if_tag.getAttribute("name")
1010
1463
        return xmlstring
1011
1464
 
1012
1465
 
1013
 
def datetime_to_dbus (dt, variant_level=0):
 
1466
try:
 
1467
    dbus.OBJECT_MANAGER_IFACE
 
1468
except AttributeError:
 
1469
    dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
 
1470
 
 
1471
 
 
1472
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
 
1473
    """A D-Bus object with an ObjectManager.
 
1474
 
 
1475
    Classes inheriting from this exposes the standard
 
1476
    GetManagedObjects call and the InterfacesAdded and
 
1477
    InterfacesRemoved signals on the standard
 
1478
    "org.freedesktop.DBus.ObjectManager" interface.
 
1479
 
 
1480
    Note: No signals are sent automatically; they must be sent
 
1481
    manually.
 
1482
    """
 
1483
    @dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
 
1484
                         out_signature="a{oa{sa{sv}}}")
 
1485
    def GetManagedObjects(self):
 
1486
        """This function must be overridden"""
 
1487
        raise NotImplementedError()
 
1488
 
 
1489
    @dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
 
1490
                         signature="oa{sa{sv}}")
 
1491
    def InterfacesAdded(self, object_path, interfaces_and_properties):
 
1492
        pass
 
1493
 
 
1494
    @dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")
 
1495
    def InterfacesRemoved(self, object_path, interfaces):
 
1496
        pass
 
1497
 
 
1498
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
 
1499
                         out_signature="s",
 
1500
                         path_keyword='object_path',
 
1501
                         connection_keyword='connection')
 
1502
    def Introspect(self, object_path, connection):
 
1503
        """Overloading of standard D-Bus method.
 
1504
 
 
1505
        Override return argument name of GetManagedObjects to be
 
1506
        "objpath_interfaces_and_properties"
 
1507
        """
 
1508
        xmlstring = DBusObjectWithAnnotations.Introspect(self,
 
1509
                                                         object_path,
 
1510
                                                         connection)
 
1511
        try:
 
1512
            document = xml.dom.minidom.parseString(xmlstring)
 
1513
 
 
1514
            for if_tag in document.getElementsByTagName("interface"):
 
1515
                # Fix argument name for the GetManagedObjects method
 
1516
                if (if_tag.getAttribute("name")
 
1517
                    == dbus.OBJECT_MANAGER_IFACE):
 
1518
                    for cn in if_tag.getElementsByTagName("method"):
 
1519
                        if (cn.getAttribute("name")
 
1520
                            == "GetManagedObjects"):
 
1521
                            for arg in cn.getElementsByTagName("arg"):
 
1522
                                if (arg.getAttribute("direction")
 
1523
                                    == "out"):
 
1524
                                    arg.setAttribute(
 
1525
                                        "name",
 
1526
                                        "objpath_interfaces"
 
1527
                                        "_and_properties")
 
1528
            xmlstring = document.toxml("utf-8")
 
1529
            document.unlink()
 
1530
        except (AttributeError, xml.dom.DOMException,
 
1531
                xml.parsers.expat.ExpatError) as error:
 
1532
            logger.error("Failed to override Introspection method",
 
1533
                         exc_info=error)
 
1534
        return xmlstring
 
1535
 
 
1536
 
 
1537
def datetime_to_dbus(dt, variant_level=0):
1014
1538
    """Convert a UTC datetime.datetime() to a D-Bus type."""
1015
1539
    if dt is None:
1016
 
        return dbus.String("", variant_level = variant_level)
1017
 
    return dbus.String(dt.isoformat(),
1018
 
                       variant_level=variant_level)
1019
 
 
1020
 
 
1021
 
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
1022
 
                                  .__metaclass__):
1023
 
    """Applied to an empty subclass of a D-Bus object, this metaclass
1024
 
    will add additional D-Bus attributes matching a certain pattern.
 
1540
        return dbus.String("", variant_level=variant_level)
 
1541
    return dbus.String(dt.isoformat(), variant_level=variant_level)
 
1542
 
 
1543
 
 
1544
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
 
1545
    """A class decorator; applied to a subclass of
 
1546
    dbus.service.Object, it will add alternate D-Bus attributes with
 
1547
    interface names according to the "alt_interface_names" mapping.
 
1548
    Usage:
 
1549
 
 
1550
    @alternate_dbus_interfaces({"org.example.Interface":
 
1551
                                    "net.example.AlternateInterface"})
 
1552
    class SampleDBusObject(dbus.service.Object):
 
1553
        @dbus.service.method("org.example.Interface")
 
1554
        def SampleDBusMethod():
 
1555
            pass
 
1556
 
 
1557
    The above "SampleDBusMethod" on "SampleDBusObject" will be
 
1558
    reachable via two interfaces: "org.example.Interface" and
 
1559
    "net.example.AlternateInterface", the latter of which will have
 
1560
    its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
 
1561
    "true", unless "deprecate" is passed with a False value.
 
1562
 
 
1563
    This works for methods and signals, and also for D-Bus properties
 
1564
    (from DBusObjectWithProperties) and interfaces (from the
 
1565
    dbus_interface_annotations decorator).
1025
1566
    """
1026
 
    def __new__(mcs, name, bases, attr):
1027
 
        # Go through all the base classes which could have D-Bus
1028
 
        # methods, signals, or properties in them
1029
 
        old_interface_names = []
1030
 
        for base in (b for b in bases
1031
 
                     if issubclass(b, dbus.service.Object)):
1032
 
            # Go though all attributes of the base class
1033
 
            for attrname, attribute in inspect.getmembers(base):
 
1567
 
 
1568
    def wrapper(cls):
 
1569
        for orig_interface_name, alt_interface_name in (
 
1570
                alt_interface_names.items()):
 
1571
            attr = {}
 
1572
            interface_names = set()
 
1573
            # Go though all attributes of the class
 
1574
            for attrname, attribute in inspect.getmembers(cls):
1034
1575
                # Ignore non-D-Bus attributes, and D-Bus attributes
1035
1576
                # with the wrong interface name
1036
1577
                if (not hasattr(attribute, "_dbus_interface")
1037
 
                    or not attribute._dbus_interface
1038
 
                    .startswith("se.recompile.Mandos")):
 
1578
                    or not attribute._dbus_interface.startswith(
 
1579
                        orig_interface_name)):
1039
1580
                    continue
1040
1581
                # Create an alternate D-Bus interface name based on
1041
1582
                # the current name
1042
 
                alt_interface = (attribute._dbus_interface
1043
 
                                 .replace("se.recompile.Mandos",
1044
 
                                          "se.bsnet.fukt.Mandos"))
1045
 
                if alt_interface != attribute._dbus_interface:
1046
 
                    old_interface_names.append(alt_interface)
 
1583
                alt_interface = attribute._dbus_interface.replace(
 
1584
                    orig_interface_name, alt_interface_name)
 
1585
                interface_names.add(alt_interface)
1047
1586
                # Is this a D-Bus signal?
1048
1587
                if getattr(attribute, "_dbus_is_signal", False):
1049
 
                    # Extract the original non-method function by
1050
 
                    # black magic
1051
 
                    nonmethod_func = (dict(
 
1588
                    # Extract the original non-method undecorated
 
1589
                    # function by black magic
 
1590
                    if sys.version_info.major == 2:
 
1591
                        nonmethod_func = (dict(
1052
1592
                            zip(attribute.func_code.co_freevars,
1053
 
                                attribute.__closure__))["func"]
1054
 
                                      .cell_contents)
 
1593
                                attribute.__closure__))
 
1594
                                          ["func"].cell_contents)
 
1595
                    else:
 
1596
                        nonmethod_func = (dict(
 
1597
                            zip(attribute.__code__.co_freevars,
 
1598
                                attribute.__closure__))
 
1599
                                          ["func"].cell_contents)
1055
1600
                    # Create a new, but exactly alike, function
1056
1601
                    # object, and decorate it to be a new D-Bus signal
1057
1602
                    # with the alternate D-Bus interface name
1058
 
                    new_function = (dbus.service.signal
1059
 
                                    (alt_interface,
1060
 
                                     attribute._dbus_signature)
1061
 
                                    (types.FunctionType(
1062
 
                                nonmethod_func.func_code,
1063
 
                                nonmethod_func.func_globals,
1064
 
                                nonmethod_func.func_name,
1065
 
                                nonmethod_func.func_defaults,
1066
 
                                nonmethod_func.func_closure)))
 
1603
                    new_function = copy_function(nonmethod_func)
 
1604
                    new_function = (dbus.service.signal(
 
1605
                        alt_interface,
 
1606
                        attribute._dbus_signature)(new_function))
1067
1607
                    # Copy annotations, if any
1068
1608
                    try:
1069
 
                        new_function._dbus_annotations = (
1070
 
                            dict(attribute._dbus_annotations))
 
1609
                        new_function._dbus_annotations = dict(
 
1610
                            attribute._dbus_annotations)
1071
1611
                    except AttributeError:
1072
1612
                        pass
 
1613
 
1073
1614
                    # Define a creator of a function to call both the
1074
 
                    # old and new functions, so both the old and new
1075
 
                    # signals gets sent when the function is called
 
1615
                    # original and alternate functions, so both the
 
1616
                    # original and alternate signals gets sent when
 
1617
                    # the function is called
1076
1618
                    def fixscope(func1, func2):
1077
1619
                        """This function is a scope container to pass
1078
1620
                        func1 and func2 to the "call_both" function
1079
1621
                        outside of its arguments"""
 
1622
 
 
1623
                        @functools.wraps(func2)
1080
1624
                        def call_both(*args, **kwargs):
1081
1625
                            """This function will emit two D-Bus
1082
1626
                            signals by calling func1 and func2"""
1083
1627
                            func1(*args, **kwargs)
1084
1628
                            func2(*args, **kwargs)
 
1629
                        # Make wrapper function look like a D-Bus
 
1630
                        # signal
 
1631
                        for name, attr in inspect.getmembers(func2):
 
1632
                            if name.startswith("_dbus_"):
 
1633
                                setattr(call_both, name, attr)
 
1634
 
1085
1635
                        return call_both
1086
1636
                    # Create the "call_both" function and add it to
1087
1637
                    # the class
1088
 
                    attr[attrname] = fixscope(attribute,
1089
 
                                              new_function)
 
1638
                    attr[attrname] = fixscope(attribute, new_function)
1090
1639
                # Is this a D-Bus method?
1091
1640
                elif getattr(attribute, "_dbus_is_method", False):
1092
1641
                    # Create a new, but exactly alike, function
1093
1642
                    # object.  Decorate it to be a new D-Bus method
1094
1643
                    # with the alternate D-Bus interface name.  Add it
1095
1644
                    # to the class.
1096
 
                    attr[attrname] = (dbus.service.method
1097
 
                                      (alt_interface,
1098
 
                                       attribute._dbus_in_signature,
1099
 
                                       attribute._dbus_out_signature)
1100
 
                                      (types.FunctionType
1101
 
                                       (attribute.func_code,
1102
 
                                        attribute.func_globals,
1103
 
                                        attribute.func_name,
1104
 
                                        attribute.func_defaults,
1105
 
                                        attribute.func_closure)))
 
1645
                    attr[attrname] = (
 
1646
                        dbus.service.method(
 
1647
                            alt_interface,
 
1648
                            attribute._dbus_in_signature,
 
1649
                            attribute._dbus_out_signature)
 
1650
                        (copy_function(attribute)))
1106
1651
                    # Copy annotations, if any
1107
1652
                    try:
1108
 
                        attr[attrname]._dbus_annotations = (
1109
 
                            dict(attribute._dbus_annotations))
 
1653
                        attr[attrname]._dbus_annotations = dict(
 
1654
                            attribute._dbus_annotations)
1110
1655
                    except AttributeError:
1111
1656
                        pass
1112
1657
                # Is this a D-Bus property?
1115
1660
                    # object, and decorate it to be a new D-Bus
1116
1661
                    # property with the alternate D-Bus interface
1117
1662
                    # name.  Add it to the class.
1118
 
                    attr[attrname] = (dbus_service_property
1119
 
                                      (alt_interface,
1120
 
                                       attribute._dbus_signature,
1121
 
                                       attribute._dbus_access,
1122
 
                                       attribute
1123
 
                                       ._dbus_get_args_options
1124
 
                                       ["byte_arrays"])
1125
 
                                      (types.FunctionType
1126
 
                                       (attribute.func_code,
1127
 
                                        attribute.func_globals,
1128
 
                                        attribute.func_name,
1129
 
                                        attribute.func_defaults,
1130
 
                                        attribute.func_closure)))
 
1663
                    attr[attrname] = (dbus_service_property(
 
1664
                        alt_interface, attribute._dbus_signature,
 
1665
                        attribute._dbus_access,
 
1666
                        attribute._dbus_get_args_options
 
1667
                        ["byte_arrays"])
 
1668
                                      (copy_function(attribute)))
1131
1669
                    # Copy annotations, if any
1132
1670
                    try:
1133
 
                        attr[attrname]._dbus_annotations = (
1134
 
                            dict(attribute._dbus_annotations))
 
1671
                        attr[attrname]._dbus_annotations = dict(
 
1672
                            attribute._dbus_annotations)
1135
1673
                    except AttributeError:
1136
1674
                        pass
1137
1675
                # Is this a D-Bus interface?
1140
1678
                    # object.  Decorate it to be a new D-Bus interface
1141
1679
                    # with the alternate D-Bus interface name.  Add it
1142
1680
                    # to the class.
1143
 
                    attr[attrname] = (dbus_interface_annotations
1144
 
                                      (alt_interface)
1145
 
                                      (types.FunctionType
1146
 
                                       (attribute.func_code,
1147
 
                                        attribute.func_globals,
1148
 
                                        attribute.func_name,
1149
 
                                        attribute.func_defaults,
1150
 
                                        attribute.func_closure)))
1151
 
        # Deprecate all old interfaces
1152
 
        basename="_AlternateDBusNamesMetaclass_interface_annotation{0}"
1153
 
        for old_interface_name in old_interface_names:
1154
 
            @dbus_interface_annotations(old_interface_name)
1155
 
            def func(self):
1156
 
                return { "org.freedesktop.DBus.Deprecated": "true" }
1157
 
            # Find an unused name
1158
 
            for aname in (basename.format(i) for i in
1159
 
                          itertools.count()):
1160
 
                if aname not in attr:
1161
 
                    attr[aname] = func
1162
 
                    break
1163
 
        return type.__new__(mcs, name, bases, attr)
1164
 
 
1165
 
 
 
1681
                    attr[attrname] = (
 
1682
                        dbus_interface_annotations(alt_interface)
 
1683
                        (copy_function(attribute)))
 
1684
            if deprecate:
 
1685
                # Deprecate all alternate interfaces
 
1686
                iname = "_AlternateDBusNames_interface_annotation{}"
 
1687
                for interface_name in interface_names:
 
1688
 
 
1689
                    @dbus_interface_annotations(interface_name)
 
1690
                    def func(self):
 
1691
                        return {"org.freedesktop.DBus.Deprecated":
 
1692
                                "true"}
 
1693
                    # Find an unused name
 
1694
                    for aname in (iname.format(i)
 
1695
                                  for i in itertools.count()):
 
1696
                        if aname not in attr:
 
1697
                            attr[aname] = func
 
1698
                            break
 
1699
            if interface_names:
 
1700
                # Replace the class with a new subclass of it with
 
1701
                # methods, signals, etc. as created above.
 
1702
                if sys.version_info.major == 2:
 
1703
                    cls = type(b"{}Alternate".format(cls.__name__),
 
1704
                               (cls, ), attr)
 
1705
                else:
 
1706
                    cls = type("{}Alternate".format(cls.__name__),
 
1707
                               (cls, ), attr)
 
1708
        return cls
 
1709
 
 
1710
    return wrapper
 
1711
 
 
1712
 
 
1713
@alternate_dbus_interfaces({"se.recompile.Mandos":
 
1714
                            "se.bsnet.fukt.Mandos"})
1166
1715
class ClientDBus(Client, DBusObjectWithProperties):
1167
1716
    """A Client class using D-Bus
1168
 
    
 
1717
 
1169
1718
    Attributes:
1170
1719
    dbus_object_path: dbus.ObjectPath
1171
1720
    bus: dbus.SystemBus()
1172
1721
    """
1173
 
    
 
1722
 
1174
1723
    runtime_expansions = (Client.runtime_expansions
1175
 
                          + ("dbus_object_path",))
1176
 
    
 
1724
                          + ("dbus_object_path", ))
 
1725
 
 
1726
    _interface = "se.recompile.Mandos.Client"
 
1727
 
1177
1728
    # dbus.service.Object doesn't use super(), so we can't either.
1178
 
    
1179
 
    def __init__(self, bus = None, *args, **kwargs):
 
1729
 
 
1730
    def __init__(self, bus=None, *args, **kwargs):
1180
1731
        self.bus = bus
1181
1732
        Client.__init__(self, *args, **kwargs)
1182
1733
        # Only now, when this client is initialized, can it show up on
1183
1734
        # the D-Bus
1184
 
        client_object_name = unicode(self.name).translate(
 
1735
        client_object_name = str(self.name).translate(
1185
1736
            {ord("."): ord("_"),
1186
1737
             ord("-"): ord("_")})
1187
 
        self.dbus_object_path = (dbus.ObjectPath
1188
 
                                 ("/clients/" + client_object_name))
 
1738
        self.dbus_object_path = dbus.ObjectPath(
 
1739
            "/clients/" + client_object_name)
1189
1740
        DBusObjectWithProperties.__init__(self, self.bus,
1190
1741
                                          self.dbus_object_path)
1191
 
        
1192
 
    def notifychangeproperty(transform_func,
1193
 
                             dbus_name, type_func=lambda x: x,
1194
 
                             variant_level=1):
 
1742
 
 
1743
    def notifychangeproperty(transform_func, dbus_name,
 
1744
                             type_func=lambda x: x,
 
1745
                             variant_level=1,
 
1746
                             invalidate_only=False,
 
1747
                             _interface=_interface):
1195
1748
        """ Modify a variable so that it's a property which announces
1196
1749
        its changes to DBus.
1197
 
        
 
1750
 
1198
1751
        transform_fun: Function that takes a value and a variant_level
1199
1752
                       and transforms it to a D-Bus type.
1200
1753
        dbus_name: D-Bus name of the variable
1202
1755
                   to the D-Bus.  Default: no transform
1203
1756
        variant_level: D-Bus variant level.  Default: 1
1204
1757
        """
1205
 
        attrname = "_{0}".format(dbus_name)
 
1758
        attrname = "_{}".format(dbus_name)
 
1759
 
1206
1760
        def setter(self, value):
1207
1761
            if hasattr(self, "dbus_object_path"):
1208
1762
                if (not hasattr(self, attrname) or
1209
1763
                    type_func(getattr(self, attrname, None))
1210
1764
                    != type_func(value)):
1211
 
                    dbus_value = transform_func(type_func(value),
1212
 
                                                variant_level
1213
 
                                                =variant_level)
1214
 
                    self.PropertyChanged(dbus.String(dbus_name),
1215
 
                                         dbus_value)
 
1765
                    if invalidate_only:
 
1766
                        self.PropertiesChanged(
 
1767
                            _interface, dbus.Dictionary(),
 
1768
                            dbus.Array((dbus_name, )))
 
1769
                    else:
 
1770
                        dbus_value = transform_func(
 
1771
                            type_func(value),
 
1772
                            variant_level=variant_level)
 
1773
                        self.PropertyChanged(dbus.String(dbus_name),
 
1774
                                             dbus_value)
 
1775
                        self.PropertiesChanged(
 
1776
                            _interface,
 
1777
                            dbus.Dictionary({dbus.String(dbus_name):
 
1778
                                             dbus_value}),
 
1779
                            dbus.Array())
1216
1780
            setattr(self, attrname, value)
1217
 
        
 
1781
 
1218
1782
        return property(lambda self: getattr(self, attrname), setter)
1219
 
    
1220
 
    
 
1783
 
1221
1784
    expires = notifychangeproperty(datetime_to_dbus, "Expires")
1222
1785
    approvals_pending = notifychangeproperty(dbus.Boolean,
1223
1786
                                             "ApprovalPending",
1224
 
                                             type_func = bool)
 
1787
                                             type_func=bool)
1225
1788
    enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1226
1789
    last_enabled = notifychangeproperty(datetime_to_dbus,
1227
1790
                                        "LastEnabled")
1228
 
    checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
1229
 
                                   type_func = lambda checker:
1230
 
                                       checker is not None)
 
1791
    checker = notifychangeproperty(
 
1792
        dbus.Boolean, "CheckerRunning",
 
1793
        type_func=lambda checker: checker is not None)
1231
1794
    last_checked_ok = notifychangeproperty(datetime_to_dbus,
1232
1795
                                           "LastCheckedOK")
1233
1796
    last_checker_status = notifychangeproperty(dbus.Int16,
1236
1799
        datetime_to_dbus, "LastApprovalRequest")
1237
1800
    approved_by_default = notifychangeproperty(dbus.Boolean,
1238
1801
                                               "ApprovedByDefault")
1239
 
    approval_delay = notifychangeproperty(dbus.UInt64,
1240
 
                                          "ApprovalDelay",
1241
 
                                          type_func =
1242
 
                                          timedelta_to_milliseconds)
 
1802
    approval_delay = notifychangeproperty(
 
1803
        dbus.UInt64, "ApprovalDelay",
 
1804
        type_func=lambda td: td.total_seconds() * 1000)
1243
1805
    approval_duration = notifychangeproperty(
1244
1806
        dbus.UInt64, "ApprovalDuration",
1245
 
        type_func = timedelta_to_milliseconds)
 
1807
        type_func=lambda td: td.total_seconds() * 1000)
1246
1808
    host = notifychangeproperty(dbus.String, "Host")
1247
 
    timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1248
 
                                   type_func =
1249
 
                                   timedelta_to_milliseconds)
 
1809
    timeout = notifychangeproperty(
 
1810
        dbus.UInt64, "Timeout",
 
1811
        type_func=lambda td: td.total_seconds() * 1000)
1250
1812
    extended_timeout = notifychangeproperty(
1251
1813
        dbus.UInt64, "ExtendedTimeout",
1252
 
        type_func = timedelta_to_milliseconds)
1253
 
    interval = notifychangeproperty(dbus.UInt64,
1254
 
                                    "Interval",
1255
 
                                    type_func =
1256
 
                                    timedelta_to_milliseconds)
 
1814
        type_func=lambda td: td.total_seconds() * 1000)
 
1815
    interval = notifychangeproperty(
 
1816
        dbus.UInt64, "Interval",
 
1817
        type_func=lambda td: td.total_seconds() * 1000)
1257
1818
    checker_command = notifychangeproperty(dbus.String, "Checker")
1258
 
    
 
1819
    secret = notifychangeproperty(dbus.ByteArray, "Secret",
 
1820
                                  invalidate_only=True)
 
1821
 
1259
1822
    del notifychangeproperty
1260
 
    
 
1823
 
1261
1824
    def __del__(self, *args, **kwargs):
1262
1825
        try:
1263
1826
            self.remove_from_connection()
1266
1829
        if hasattr(DBusObjectWithProperties, "__del__"):
1267
1830
            DBusObjectWithProperties.__del__(self, *args, **kwargs)
1268
1831
        Client.__del__(self, *args, **kwargs)
1269
 
    
1270
 
    def checker_callback(self, pid, condition, command,
1271
 
                         *args, **kwargs):
1272
 
        self.checker_callback_tag = None
1273
 
        self.checker = None
1274
 
        if os.WIFEXITED(condition):
1275
 
            exitstatus = os.WEXITSTATUS(condition)
 
1832
 
 
1833
    def checker_callback(self, source, condition,
 
1834
                         connection, command, *args, **kwargs):
 
1835
        ret = Client.checker_callback(self, source, condition,
 
1836
                                      connection, command, *args,
 
1837
                                      **kwargs)
 
1838
        exitstatus = self.last_checker_status
 
1839
        if exitstatus >= 0:
1276
1840
            # Emit D-Bus signal
1277
1841
            self.CheckerCompleted(dbus.Int16(exitstatus),
1278
 
                                  dbus.Int64(condition),
 
1842
                                  # This is specific to GNU libC
 
1843
                                  dbus.Int64(exitstatus << 8),
1279
1844
                                  dbus.String(command))
1280
1845
        else:
1281
1846
            # Emit D-Bus signal
1282
1847
            self.CheckerCompleted(dbus.Int16(-1),
1283
 
                                  dbus.Int64(condition),
 
1848
                                  dbus.Int64(
 
1849
                                      # This is specific to GNU libC
 
1850
                                      (exitstatus << 8)
 
1851
                                      | self.last_checker_signal),
1284
1852
                                  dbus.String(command))
1285
 
        
1286
 
        return Client.checker_callback(self, pid, condition, command,
1287
 
                                       *args, **kwargs)
1288
 
    
 
1853
        return ret
 
1854
 
1289
1855
    def start_checker(self, *args, **kwargs):
1290
 
        old_checker = self.checker
1291
 
        if self.checker is not None:
1292
 
            old_checker_pid = self.checker.pid
1293
 
        else:
1294
 
            old_checker_pid = None
 
1856
        old_checker_pid = getattr(self.checker, "pid", None)
1295
1857
        r = Client.start_checker(self, *args, **kwargs)
1296
1858
        # Only if new checker process was started
1297
1859
        if (self.checker is not None
1299
1861
            # Emit D-Bus signal
1300
1862
            self.CheckerStarted(self.current_checker_command)
1301
1863
        return r
1302
 
    
 
1864
 
1303
1865
    def _reset_approved(self):
1304
1866
        self.approved = None
1305
1867
        return False
1306
 
    
 
1868
 
1307
1869
    def approve(self, value=True):
1308
 
        self.send_changedstate()
1309
1870
        self.approved = value
1310
 
        gobject.timeout_add(timedelta_to_milliseconds
1311
 
                            (self.approval_duration),
1312
 
                            self._reset_approved)
1313
 
    
1314
 
    
1315
 
    ## D-Bus methods, signals & properties
1316
 
    _interface = "se.recompile.Mandos.Client"
1317
 
    
1318
 
    ## Interfaces
1319
 
    
1320
 
    @dbus_interface_annotations(_interface)
1321
 
    def _foo(self):
1322
 
        return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
1323
 
                     "false"}
1324
 
    
1325
 
    ## Signals
1326
 
    
 
1871
        GLib.timeout_add(int(self.approval_duration.total_seconds()
 
1872
                             * 1000), self._reset_approved)
 
1873
        self.send_changedstate()
 
1874
 
 
1875
    #  D-Bus methods, signals & properties
 
1876
 
 
1877
    #  Interfaces
 
1878
 
 
1879
    #  Signals
 
1880
 
1327
1881
    # CheckerCompleted - signal
1328
1882
    @dbus.service.signal(_interface, signature="nxs")
1329
1883
    def CheckerCompleted(self, exitcode, waitstatus, command):
1330
1884
        "D-Bus signal"
1331
1885
        pass
1332
 
    
 
1886
 
1333
1887
    # CheckerStarted - signal
1334
1888
    @dbus.service.signal(_interface, signature="s")
1335
1889
    def CheckerStarted(self, command):
1336
1890
        "D-Bus signal"
1337
1891
        pass
1338
 
    
 
1892
 
1339
1893
    # PropertyChanged - signal
 
1894
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1340
1895
    @dbus.service.signal(_interface, signature="sv")
1341
1896
    def PropertyChanged(self, property, value):
1342
1897
        "D-Bus signal"
1343
1898
        pass
1344
 
    
 
1899
 
1345
1900
    # GotSecret - signal
1346
1901
    @dbus.service.signal(_interface)
1347
1902
    def GotSecret(self):
1350
1905
        server to mandos-client
1351
1906
        """
1352
1907
        pass
1353
 
    
 
1908
 
1354
1909
    # Rejected - signal
1355
1910
    @dbus.service.signal(_interface, signature="s")
1356
1911
    def Rejected(self, reason):
1357
1912
        "D-Bus signal"
1358
1913
        pass
1359
 
    
 
1914
 
1360
1915
    # NeedApproval - signal
1361
1916
    @dbus.service.signal(_interface, signature="tb")
1362
1917
    def NeedApproval(self, timeout, default):
1363
1918
        "D-Bus signal"
1364
1919
        return self.need_approval()
1365
 
    
1366
 
    ## Methods
1367
 
    
 
1920
 
 
1921
    #  Methods
 
1922
 
1368
1923
    # Approve - method
1369
1924
    @dbus.service.method(_interface, in_signature="b")
1370
1925
    def Approve(self, value):
1371
1926
        self.approve(value)
1372
 
    
 
1927
 
1373
1928
    # CheckedOK - method
1374
1929
    @dbus.service.method(_interface)
1375
1930
    def CheckedOK(self):
1376
1931
        self.checked_ok()
1377
 
    
 
1932
 
1378
1933
    # Enable - method
 
1934
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1379
1935
    @dbus.service.method(_interface)
1380
1936
    def Enable(self):
1381
1937
        "D-Bus method"
1382
1938
        self.enable()
1383
 
    
 
1939
 
1384
1940
    # StartChecker - method
 
1941
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1385
1942
    @dbus.service.method(_interface)
1386
1943
    def StartChecker(self):
1387
1944
        "D-Bus method"
1388
1945
        self.start_checker()
1389
 
    
 
1946
 
1390
1947
    # Disable - method
 
1948
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1391
1949
    @dbus.service.method(_interface)
1392
1950
    def Disable(self):
1393
1951
        "D-Bus method"
1394
1952
        self.disable()
1395
 
    
 
1953
 
1396
1954
    # StopChecker - method
 
1955
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1397
1956
    @dbus.service.method(_interface)
1398
1957
    def StopChecker(self):
1399
1958
        self.stop_checker()
1400
 
    
1401
 
    ## Properties
1402
 
    
 
1959
 
 
1960
    #  Properties
 
1961
 
1403
1962
    # ApprovalPending - property
1404
1963
    @dbus_service_property(_interface, signature="b", access="read")
1405
1964
    def ApprovalPending_dbus_property(self):
1406
1965
        return dbus.Boolean(bool(self.approvals_pending))
1407
 
    
 
1966
 
1408
1967
    # ApprovedByDefault - property
1409
 
    @dbus_service_property(_interface, signature="b",
 
1968
    @dbus_service_property(_interface,
 
1969
                           signature="b",
1410
1970
                           access="readwrite")
1411
1971
    def ApprovedByDefault_dbus_property(self, value=None):
1412
1972
        if value is None:       # get
1413
1973
            return dbus.Boolean(self.approved_by_default)
1414
1974
        self.approved_by_default = bool(value)
1415
 
    
 
1975
 
1416
1976
    # ApprovalDelay - property
1417
 
    @dbus_service_property(_interface, signature="t",
 
1977
    @dbus_service_property(_interface,
 
1978
                           signature="t",
1418
1979
                           access="readwrite")
1419
1980
    def ApprovalDelay_dbus_property(self, value=None):
1420
1981
        if value is None:       # get
1421
 
            return dbus.UInt64(self.approval_delay_milliseconds())
 
1982
            return dbus.UInt64(self.approval_delay.total_seconds()
 
1983
                               * 1000)
1422
1984
        self.approval_delay = datetime.timedelta(0, 0, 0, value)
1423
 
    
 
1985
 
1424
1986
    # ApprovalDuration - property
1425
 
    @dbus_service_property(_interface, signature="t",
 
1987
    @dbus_service_property(_interface,
 
1988
                           signature="t",
1426
1989
                           access="readwrite")
1427
1990
    def ApprovalDuration_dbus_property(self, value=None):
1428
1991
        if value is None:       # get
1429
 
            return dbus.UInt64(timedelta_to_milliseconds(
1430
 
                    self.approval_duration))
 
1992
            return dbus.UInt64(self.approval_duration.total_seconds()
 
1993
                               * 1000)
1431
1994
        self.approval_duration = datetime.timedelta(0, 0, 0, value)
1432
 
    
 
1995
 
1433
1996
    # Name - property
 
1997
    @dbus_annotations(
 
1998
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1434
1999
    @dbus_service_property(_interface, signature="s", access="read")
1435
2000
    def Name_dbus_property(self):
1436
2001
        return dbus.String(self.name)
1437
 
    
 
2002
 
1438
2003
    # Fingerprint - property
 
2004
    @dbus_annotations(
 
2005
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1439
2006
    @dbus_service_property(_interface, signature="s", access="read")
1440
2007
    def Fingerprint_dbus_property(self):
1441
2008
        return dbus.String(self.fingerprint)
1442
 
    
 
2009
 
1443
2010
    # Host - property
1444
 
    @dbus_service_property(_interface, signature="s",
 
2011
    @dbus_service_property(_interface,
 
2012
                           signature="s",
1445
2013
                           access="readwrite")
1446
2014
    def Host_dbus_property(self, value=None):
1447
2015
        if value is None:       # get
1448
2016
            return dbus.String(self.host)
1449
 
        self.host = unicode(value)
1450
 
    
 
2017
        self.host = str(value)
 
2018
 
1451
2019
    # Created - property
 
2020
    @dbus_annotations(
 
2021
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1452
2022
    @dbus_service_property(_interface, signature="s", access="read")
1453
2023
    def Created_dbus_property(self):
1454
2024
        return datetime_to_dbus(self.created)
1455
 
    
 
2025
 
1456
2026
    # LastEnabled - property
1457
2027
    @dbus_service_property(_interface, signature="s", access="read")
1458
2028
    def LastEnabled_dbus_property(self):
1459
2029
        return datetime_to_dbus(self.last_enabled)
1460
 
    
 
2030
 
1461
2031
    # Enabled - property
1462
 
    @dbus_service_property(_interface, signature="b",
 
2032
    @dbus_service_property(_interface,
 
2033
                           signature="b",
1463
2034
                           access="readwrite")
1464
2035
    def Enabled_dbus_property(self, value=None):
1465
2036
        if value is None:       # get
1468
2039
            self.enable()
1469
2040
        else:
1470
2041
            self.disable()
1471
 
    
 
2042
 
1472
2043
    # LastCheckedOK - property
1473
 
    @dbus_service_property(_interface, signature="s",
 
2044
    @dbus_service_property(_interface,
 
2045
                           signature="s",
1474
2046
                           access="readwrite")
1475
2047
    def LastCheckedOK_dbus_property(self, value=None):
1476
2048
        if value is not None:
1477
2049
            self.checked_ok()
1478
2050
            return
1479
2051
        return datetime_to_dbus(self.last_checked_ok)
1480
 
    
 
2052
 
1481
2053
    # LastCheckerStatus - property
1482
 
    @dbus_service_property(_interface, signature="n",
1483
 
                           access="read")
 
2054
    @dbus_service_property(_interface, signature="n", access="read")
1484
2055
    def LastCheckerStatus_dbus_property(self):
1485
2056
        return dbus.Int16(self.last_checker_status)
1486
 
    
 
2057
 
1487
2058
    # Expires - property
1488
2059
    @dbus_service_property(_interface, signature="s", access="read")
1489
2060
    def Expires_dbus_property(self):
1490
2061
        return datetime_to_dbus(self.expires)
1491
 
    
 
2062
 
1492
2063
    # LastApprovalRequest - property
1493
2064
    @dbus_service_property(_interface, signature="s", access="read")
1494
2065
    def LastApprovalRequest_dbus_property(self):
1495
2066
        return datetime_to_dbus(self.last_approval_request)
1496
 
    
 
2067
 
1497
2068
    # Timeout - property
1498
 
    @dbus_service_property(_interface, signature="t",
 
2069
    @dbus_service_property(_interface,
 
2070
                           signature="t",
1499
2071
                           access="readwrite")
1500
2072
    def Timeout_dbus_property(self, value=None):
1501
2073
        if value is None:       # get
1502
 
            return dbus.UInt64(self.timeout_milliseconds())
 
2074
            return dbus.UInt64(self.timeout.total_seconds() * 1000)
 
2075
        old_timeout = self.timeout
1503
2076
        self.timeout = datetime.timedelta(0, 0, 0, value)
1504
 
        # Reschedule timeout
 
2077
        # Reschedule disabling
1505
2078
        if self.enabled:
1506
2079
            now = datetime.datetime.utcnow()
1507
 
            time_to_die = timedelta_to_milliseconds(
1508
 
                (self.last_checked_ok + self.timeout) - now)
1509
 
            if time_to_die <= 0:
 
2080
            self.expires += self.timeout - old_timeout
 
2081
            if self.expires <= now:
1510
2082
                # The timeout has passed
1511
2083
                self.disable()
1512
2084
            else:
1513
 
                self.expires = (now +
1514
 
                                datetime.timedelta(milliseconds =
1515
 
                                                   time_to_die))
1516
2085
                if (getattr(self, "disable_initiator_tag", None)
1517
2086
                    is None):
1518
2087
                    return
1519
 
                gobject.source_remove(self.disable_initiator_tag)
1520
 
                self.disable_initiator_tag = (gobject.timeout_add
1521
 
                                              (time_to_die,
1522
 
                                               self.disable))
1523
 
    
 
2088
                GLib.source_remove(self.disable_initiator_tag)
 
2089
                self.disable_initiator_tag = GLib.timeout_add(
 
2090
                    int((self.expires - now).total_seconds() * 1000),
 
2091
                    self.disable)
 
2092
 
1524
2093
    # ExtendedTimeout - property
1525
 
    @dbus_service_property(_interface, signature="t",
 
2094
    @dbus_service_property(_interface,
 
2095
                           signature="t",
1526
2096
                           access="readwrite")
1527
2097
    def ExtendedTimeout_dbus_property(self, value=None):
1528
2098
        if value is None:       # get
1529
 
            return dbus.UInt64(self.extended_timeout_milliseconds())
 
2099
            return dbus.UInt64(self.extended_timeout.total_seconds()
 
2100
                               * 1000)
1530
2101
        self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1531
 
    
 
2102
 
1532
2103
    # Interval - property
1533
 
    @dbus_service_property(_interface, signature="t",
 
2104
    @dbus_service_property(_interface,
 
2105
                           signature="t",
1534
2106
                           access="readwrite")
1535
2107
    def Interval_dbus_property(self, value=None):
1536
2108
        if value is None:       # get
1537
 
            return dbus.UInt64(self.interval_milliseconds())
 
2109
            return dbus.UInt64(self.interval.total_seconds() * 1000)
1538
2110
        self.interval = datetime.timedelta(0, 0, 0, value)
1539
2111
        if getattr(self, "checker_initiator_tag", None) is None:
1540
2112
            return
1541
2113
        if self.enabled:
1542
2114
            # Reschedule checker run
1543
 
            gobject.source_remove(self.checker_initiator_tag)
1544
 
            self.checker_initiator_tag = (gobject.timeout_add
1545
 
                                          (value, self.start_checker))
1546
 
            self.start_checker()    # Start one now, too
1547
 
    
 
2115
            GLib.source_remove(self.checker_initiator_tag)
 
2116
            self.checker_initiator_tag = GLib.timeout_add(
 
2117
                value, self.start_checker)
 
2118
            self.start_checker()  # Start one now, too
 
2119
 
1548
2120
    # Checker - property
1549
 
    @dbus_service_property(_interface, signature="s",
 
2121
    @dbus_service_property(_interface,
 
2122
                           signature="s",
1550
2123
                           access="readwrite")
1551
2124
    def Checker_dbus_property(self, value=None):
1552
2125
        if value is None:       # get
1553
2126
            return dbus.String(self.checker_command)
1554
 
        self.checker_command = unicode(value)
1555
 
    
 
2127
        self.checker_command = str(value)
 
2128
 
1556
2129
    # CheckerRunning - property
1557
 
    @dbus_service_property(_interface, signature="b",
 
2130
    @dbus_service_property(_interface,
 
2131
                           signature="b",
1558
2132
                           access="readwrite")
1559
2133
    def CheckerRunning_dbus_property(self, value=None):
1560
2134
        if value is None:       # get
1563
2137
            self.start_checker()
1564
2138
        else:
1565
2139
            self.stop_checker()
1566
 
    
 
2140
 
1567
2141
    # ObjectPath - property
 
2142
    @dbus_annotations(
 
2143
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",
 
2144
         "org.freedesktop.DBus.Deprecated": "true"})
1568
2145
    @dbus_service_property(_interface, signature="o", access="read")
1569
2146
    def ObjectPath_dbus_property(self):
1570
 
        return self.dbus_object_path # is already a dbus.ObjectPath
1571
 
    
 
2147
        return self.dbus_object_path  # is already a dbus.ObjectPath
 
2148
 
1572
2149
    # Secret = property
1573
 
    @dbus_service_property(_interface, signature="ay",
1574
 
                           access="write", byte_arrays=True)
 
2150
    @dbus_annotations(
 
2151
        {"org.freedesktop.DBus.Property.EmitsChangedSignal":
 
2152
         "invalidates"})
 
2153
    @dbus_service_property(_interface,
 
2154
                           signature="ay",
 
2155
                           access="write",
 
2156
                           byte_arrays=True)
1575
2157
    def Secret_dbus_property(self, value):
1576
 
        self.secret = str(value)
1577
 
    
 
2158
        self.secret = bytes(value)
 
2159
 
1578
2160
    del _interface
1579
2161
 
1580
2162
 
1583
2165
        self._pipe = child_pipe
1584
2166
        self._pipe.send(('init', fpr, address))
1585
2167
        if not self._pipe.recv():
1586
 
            raise KeyError()
1587
 
    
 
2168
            raise KeyError(fpr)
 
2169
 
1588
2170
    def __getattribute__(self, name):
1589
2171
        if name == '_pipe':
1590
2172
            return super(ProxyClient, self).__getattribute__(name)
1593
2175
        if data[0] == 'data':
1594
2176
            return data[1]
1595
2177
        if data[0] == 'function':
 
2178
 
1596
2179
            def func(*args, **kwargs):
1597
2180
                self._pipe.send(('funcall', name, args, kwargs))
1598
2181
                return self._pipe.recv()[1]
 
2182
 
1599
2183
            return func
1600
 
    
 
2184
 
1601
2185
    def __setattr__(self, name, value):
1602
2186
        if name == '_pipe':
1603
2187
            return super(ProxyClient, self).__setattr__(name, value)
1604
2188
        self._pipe.send(('setattr', name, value))
1605
2189
 
1606
2190
 
1607
 
class ClientDBusTransitional(ClientDBus):
1608
 
    __metaclass__ = AlternateDBusNamesMetaclass
1609
 
 
1610
 
 
1611
2191
class ClientHandler(socketserver.BaseRequestHandler, object):
1612
2192
    """A class to handle client connections.
1613
 
    
 
2193
 
1614
2194
    Instantiated once for each connection to handle it.
1615
2195
    Note: This will run in its own forked process."""
1616
 
    
 
2196
 
1617
2197
    def handle(self):
1618
2198
        with contextlib.closing(self.server.child_pipe) as child_pipe:
1619
2199
            logger.info("TCP connection from: %s",
1620
 
                        unicode(self.client_address))
 
2200
                        str(self.client_address))
1621
2201
            logger.debug("Pipe FD: %d",
1622
2202
                         self.server.child_pipe.fileno())
1623
 
            
1624
 
            session = (gnutls.connection
1625
 
                       .ClientSession(self.request,
1626
 
                                      gnutls.connection
1627
 
                                      .X509Credentials()))
1628
 
            
1629
 
            # Note: gnutls.connection.X509Credentials is really a
1630
 
            # generic GnuTLS certificate credentials object so long as
1631
 
            # no X.509 keys are added to it.  Therefore, we can use it
1632
 
            # here despite using OpenPGP certificates.
1633
 
            
1634
 
            #priority = ':'.join(("NONE", "+VERS-TLS1.1",
1635
 
            #                      "+AES-256-CBC", "+SHA1",
1636
 
            #                      "+COMP-NULL", "+CTYPE-OPENPGP",
1637
 
            #                      "+DHE-DSS"))
 
2203
 
 
2204
            session = gnutls.ClientSession(self.request)
 
2205
 
 
2206
            # priority = ':'.join(("NONE", "+VERS-TLS1.1",
 
2207
            #                       "+AES-256-CBC", "+SHA1",
 
2208
            #                       "+COMP-NULL", "+CTYPE-OPENPGP",
 
2209
            #                       "+DHE-DSS"))
1638
2210
            # Use a fallback default, since this MUST be set.
1639
2211
            priority = self.server.gnutls_priority
1640
2212
            if priority is None:
1641
2213
                priority = "NORMAL"
1642
 
            (gnutls.library.functions
1643
 
             .gnutls_priority_set_direct(session._c_object,
1644
 
                                         priority, None))
1645
 
            
 
2214
            gnutls.priority_set_direct(session._c_object,
 
2215
                                       priority.encode("utf-8"),
 
2216
                                       None)
 
2217
 
1646
2218
            # Start communication using the Mandos protocol
1647
2219
            # Get protocol number
1648
2220
            line = self.request.makefile().readline()
1649
2221
            logger.debug("Protocol version: %r", line)
1650
2222
            try:
1651
2223
                if int(line.strip().split()[0]) > 1:
1652
 
                    raise RuntimeError
 
2224
                    raise RuntimeError(line)
1653
2225
            except (ValueError, IndexError, RuntimeError) as error:
1654
2226
                logger.error("Unknown protocol version: %s", error)
1655
2227
                return
1656
 
            
 
2228
 
1657
2229
            # Start GnuTLS connection
1658
2230
            try:
1659
2231
                session.handshake()
1660
 
            except gnutls.errors.GNUTLSError as error:
 
2232
            except gnutls.Error as error:
1661
2233
                logger.warning("Handshake failed: %s", error)
1662
2234
                # Do not run session.bye() here: the session is not
1663
2235
                # established.  Just abandon the request.
1664
2236
                return
1665
2237
            logger.debug("Handshake succeeded")
1666
 
            
 
2238
 
1667
2239
            approval_required = False
1668
2240
            try:
1669
2241
                try:
1670
 
                    fpr = self.fingerprint(self.peer_certificate
1671
 
                                           (session))
1672
 
                except (TypeError,
1673
 
                        gnutls.errors.GNUTLSError) as error:
 
2242
                    fpr = self.fingerprint(
 
2243
                        self.peer_certificate(session))
 
2244
                except (TypeError, gnutls.Error) as error:
1674
2245
                    logger.warning("Bad certificate: %s", error)
1675
2246
                    return
1676
2247
                logger.debug("Fingerprint: %s", fpr)
1677
 
                
 
2248
 
1678
2249
                try:
1679
2250
                    client = ProxyClient(child_pipe, fpr,
1680
2251
                                         self.client_address)
1681
2252
                except KeyError:
1682
2253
                    return
1683
 
                
 
2254
 
1684
2255
                if client.approval_delay:
1685
2256
                    delay = client.approval_delay
1686
2257
                    client.approvals_pending += 1
1687
2258
                    approval_required = True
1688
 
                
 
2259
 
1689
2260
                while True:
1690
2261
                    if not client.enabled:
1691
2262
                        logger.info("Client %s is disabled",
1692
 
                                       client.name)
 
2263
                                    client.name)
1693
2264
                        if self.server.use_dbus:
1694
2265
                            # Emit D-Bus signal
1695
2266
                            client.Rejected("Disabled")
1696
2267
                        return
1697
 
                    
 
2268
 
1698
2269
                    if client.approved or not client.approval_delay:
1699
 
                        #We are approved or approval is disabled
 
2270
                        # We are approved or approval is disabled
1700
2271
                        break
1701
2272
                    elif client.approved is None:
1702
2273
                        logger.info("Client %s needs approval",
1704
2275
                        if self.server.use_dbus:
1705
2276
                            # Emit D-Bus signal
1706
2277
                            client.NeedApproval(
1707
 
                                client.approval_delay_milliseconds(),
1708
 
                                client.approved_by_default)
 
2278
                                client.approval_delay.total_seconds()
 
2279
                                * 1000, client.approved_by_default)
1709
2280
                    else:
1710
2281
                        logger.warning("Client %s was not approved",
1711
2282
                                       client.name)
1713
2284
                            # Emit D-Bus signal
1714
2285
                            client.Rejected("Denied")
1715
2286
                        return
1716
 
                    
1717
 
                    #wait until timeout or approved
 
2287
 
 
2288
                    # wait until timeout or approved
1718
2289
                    time = datetime.datetime.now()
1719
2290
                    client.changedstate.acquire()
1720
 
                    (client.changedstate.wait
1721
 
                     (float(client.timedelta_to_milliseconds(delay)
1722
 
                            / 1000)))
 
2291
                    client.changedstate.wait(delay.total_seconds())
1723
2292
                    client.changedstate.release()
1724
2293
                    time2 = datetime.datetime.now()
1725
2294
                    if (time2 - time) >= delay:
1735
2304
                            break
1736
2305
                    else:
1737
2306
                        delay -= time2 - time
1738
 
                
1739
 
                sent_size = 0
1740
 
                while sent_size < len(client.secret):
1741
 
                    try:
1742
 
                        sent = session.send(client.secret[sent_size:])
1743
 
                    except gnutls.errors.GNUTLSError as error:
1744
 
                        logger.warning("gnutls send failed")
1745
 
                        return
1746
 
                    logger.debug("Sent: %d, remaining: %d",
1747
 
                                 sent, len(client.secret)
1748
 
                                 - (sent_size + sent))
1749
 
                    sent_size += sent
1750
 
                
 
2307
 
 
2308
                try:
 
2309
                    session.send(client.secret)
 
2310
                except gnutls.Error as error:
 
2311
                    logger.warning("gnutls send failed",
 
2312
                                   exc_info=error)
 
2313
                    return
 
2314
 
1751
2315
                logger.info("Sending secret to %s", client.name)
1752
2316
                # bump the timeout using extended_timeout
1753
2317
                client.bump_timeout(client.extended_timeout)
1754
2318
                if self.server.use_dbus:
1755
2319
                    # Emit D-Bus signal
1756
2320
                    client.GotSecret()
1757
 
            
 
2321
 
1758
2322
            finally:
1759
2323
                if approval_required:
1760
2324
                    client.approvals_pending -= 1
1761
2325
                try:
1762
2326
                    session.bye()
1763
 
                except gnutls.errors.GNUTLSError as error:
1764
 
                    logger.warning("GnuTLS bye failed")
1765
 
    
 
2327
                except gnutls.Error as error:
 
2328
                    logger.warning("GnuTLS bye failed",
 
2329
                                   exc_info=error)
 
2330
 
1766
2331
    @staticmethod
1767
2332
    def peer_certificate(session):
1768
2333
        "Return the peer's OpenPGP certificate as a bytestring"
1769
2334
        # If not an OpenPGP certificate...
1770
 
        if (gnutls.library.functions
1771
 
            .gnutls_certificate_type_get(session._c_object)
1772
 
            != gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1773
 
            # ...do the normal thing
1774
 
            return session.peer_certificate
 
2335
        if (gnutls.certificate_type_get(session._c_object)
 
2336
            != gnutls.CRT_OPENPGP):
 
2337
            # ...return invalid data
 
2338
            return b""
1775
2339
        list_size = ctypes.c_uint(1)
1776
 
        cert_list = (gnutls.library.functions
1777
 
                     .gnutls_certificate_get_peers
 
2340
        cert_list = (gnutls.certificate_get_peers
1778
2341
                     (session._c_object, ctypes.byref(list_size)))
1779
2342
        if not bool(cert_list) and list_size.value != 0:
1780
 
            raise gnutls.errors.GNUTLSError("error getting peer"
1781
 
                                            " certificate")
 
2343
            raise gnutls.Error("error getting peer certificate")
1782
2344
        if list_size.value == 0:
1783
2345
            return None
1784
2346
        cert = cert_list[0]
1785
2347
        return ctypes.string_at(cert.data, cert.size)
1786
 
    
 
2348
 
1787
2349
    @staticmethod
1788
2350
    def fingerprint(openpgp):
1789
2351
        "Convert an OpenPGP bytestring to a hexdigit fingerprint"
1790
2352
        # New GnuTLS "datum" with the OpenPGP public key
1791
 
        datum = (gnutls.library.types
1792
 
                 .gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1793
 
                                             ctypes.POINTER
1794
 
                                             (ctypes.c_ubyte)),
1795
 
                                 ctypes.c_uint(len(openpgp))))
 
2353
        datum = gnutls.datum_t(
 
2354
            ctypes.cast(ctypes.c_char_p(openpgp),
 
2355
                        ctypes.POINTER(ctypes.c_ubyte)),
 
2356
            ctypes.c_uint(len(openpgp)))
1796
2357
        # New empty GnuTLS certificate
1797
 
        crt = gnutls.library.types.gnutls_openpgp_crt_t()
1798
 
        (gnutls.library.functions
1799
 
         .gnutls_openpgp_crt_init(ctypes.byref(crt)))
 
2358
        crt = gnutls.openpgp_crt_t()
 
2359
        gnutls.openpgp_crt_init(ctypes.byref(crt))
1800
2360
        # Import the OpenPGP public key into the certificate
1801
 
        (gnutls.library.functions
1802
 
         .gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1803
 
                                    gnutls.library.constants
1804
 
                                    .GNUTLS_OPENPGP_FMT_RAW))
 
2361
        gnutls.openpgp_crt_import(crt, ctypes.byref(datum),
 
2362
                                  gnutls.OPENPGP_FMT_RAW)
1805
2363
        # Verify the self signature in the key
1806
2364
        crtverify = ctypes.c_uint()
1807
 
        (gnutls.library.functions
1808
 
         .gnutls_openpgp_crt_verify_self(crt, 0,
1809
 
                                         ctypes.byref(crtverify)))
 
2365
        gnutls.openpgp_crt_verify_self(crt, 0,
 
2366
                                       ctypes.byref(crtverify))
1810
2367
        if crtverify.value != 0:
1811
 
            gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1812
 
            raise (gnutls.errors.CertificateSecurityError
1813
 
                   ("Verify failed"))
 
2368
            gnutls.openpgp_crt_deinit(crt)
 
2369
            raise gnutls.CertificateSecurityError("Verify failed")
1814
2370
        # New buffer for the fingerprint
1815
2371
        buf = ctypes.create_string_buffer(20)
1816
2372
        buf_len = ctypes.c_size_t()
1817
2373
        # Get the fingerprint from the certificate into the buffer
1818
 
        (gnutls.library.functions
1819
 
         .gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1820
 
                                             ctypes.byref(buf_len)))
 
2374
        gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
 
2375
                                           ctypes.byref(buf_len))
1821
2376
        # Deinit the certificate
1822
 
        gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
 
2377
        gnutls.openpgp_crt_deinit(crt)
1823
2378
        # Convert the buffer to a Python bytestring
1824
2379
        fpr = ctypes.string_at(buf, buf_len.value)
1825
2380
        # Convert the bytestring to hexadecimal notation
1829
2384
 
1830
2385
class MultiprocessingMixIn(object):
1831
2386
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
 
2387
 
1832
2388
    def sub_process_main(self, request, address):
1833
2389
        try:
1834
2390
            self.finish_request(request, address)
1835
2391
        except Exception:
1836
2392
            self.handle_error(request, address)
1837
2393
        self.close_request(request)
1838
 
    
 
2394
 
1839
2395
    def process_request(self, request, address):
1840
2396
        """Start a new process to process the request."""
1841
 
        proc = multiprocessing.Process(target = self.sub_process_main,
1842
 
                                       args = (request,
1843
 
                                               address))
 
2397
        proc = multiprocessing.Process(target=self.sub_process_main,
 
2398
                                       args=(request, address))
1844
2399
        proc.start()
1845
2400
        return proc
1846
2401
 
1847
2402
 
1848
2403
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1849
2404
    """ adds a pipe to the MixIn """
 
2405
 
1850
2406
    def process_request(self, request, client_address):
1851
2407
        """Overrides and wraps the original process_request().
1852
 
        
 
2408
 
1853
2409
        This function creates a new pipe in self.pipe
1854
2410
        """
1855
2411
        parent_pipe, self.child_pipe = multiprocessing.Pipe()
1856
 
        
 
2412
 
1857
2413
        proc = MultiprocessingMixIn.process_request(self, request,
1858
2414
                                                    client_address)
1859
2415
        self.child_pipe.close()
1860
2416
        self.add_pipe(parent_pipe, proc)
1861
 
    
 
2417
 
1862
2418
    def add_pipe(self, parent_pipe, proc):
1863
2419
        """Dummy function; override as necessary"""
1864
 
        raise NotImplementedError
 
2420
        raise NotImplementedError()
1865
2421
 
1866
2422
 
1867
2423
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1868
2424
                     socketserver.TCPServer, object):
1869
2425
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
1870
 
    
 
2426
 
1871
2427
    Attributes:
1872
2428
        enabled:        Boolean; whether this server is activated yet
1873
2429
        interface:      None or a network interface name (string)
1874
2430
        use_ipv6:       Boolean; to use IPv6 or not
1875
2431
    """
 
2432
 
1876
2433
    def __init__(self, server_address, RequestHandlerClass,
1877
 
                 interface=None, use_ipv6=True):
 
2434
                 interface=None,
 
2435
                 use_ipv6=True,
 
2436
                 socketfd=None):
 
2437
        """If socketfd is set, use that file descriptor instead of
 
2438
        creating a new one with socket.socket().
 
2439
        """
1878
2440
        self.interface = interface
1879
2441
        if use_ipv6:
1880
2442
            self.address_family = socket.AF_INET6
 
2443
        if socketfd is not None:
 
2444
            # Save the file descriptor
 
2445
            self.socketfd = socketfd
 
2446
            # Save the original socket.socket() function
 
2447
            self.socket_socket = socket.socket
 
2448
 
 
2449
            # To implement --socket, we monkey patch socket.socket.
 
2450
            #
 
2451
            # (When socketserver.TCPServer is a new-style class, we
 
2452
            # could make self.socket into a property instead of monkey
 
2453
            # patching socket.socket.)
 
2454
            #
 
2455
            # Create a one-time-only replacement for socket.socket()
 
2456
            @functools.wraps(socket.socket)
 
2457
            def socket_wrapper(*args, **kwargs):
 
2458
                # Restore original function so subsequent calls are
 
2459
                # not affected.
 
2460
                socket.socket = self.socket_socket
 
2461
                del self.socket_socket
 
2462
                # This time only, return a new socket object from the
 
2463
                # saved file descriptor.
 
2464
                return socket.fromfd(self.socketfd, *args, **kwargs)
 
2465
            # Replace socket.socket() function with wrapper
 
2466
            socket.socket = socket_wrapper
 
2467
        # The socketserver.TCPServer.__init__ will call
 
2468
        # socket.socket(), which might be our replacement,
 
2469
        # socket_wrapper(), if socketfd was set.
1881
2470
        socketserver.TCPServer.__init__(self, server_address,
1882
2471
                                        RequestHandlerClass)
 
2472
 
1883
2473
    def server_bind(self):
1884
2474
        """This overrides the normal server_bind() function
1885
2475
        to bind to an interface if one was specified, and also NOT to
1886
2476
        bind to an address or port if they were not specified."""
 
2477
        global SO_BINDTODEVICE
1887
2478
        if self.interface is not None:
1888
2479
            if SO_BINDTODEVICE is None:
1889
 
                logger.error("SO_BINDTODEVICE does not exist;"
1890
 
                             " cannot bind to interface %s",
1891
 
                             self.interface)
1892
 
            else:
1893
 
                try:
1894
 
                    self.socket.setsockopt(socket.SOL_SOCKET,
1895
 
                                           SO_BINDTODEVICE,
1896
 
                                           str(self.interface
1897
 
                                               + '\0'))
1898
 
                except socket.error as error:
1899
 
                    if error[0] == errno.EPERM:
1900
 
                        logger.error("No permission to"
1901
 
                                     " bind to interface %s",
1902
 
                                     self.interface)
1903
 
                    elif error[0] == errno.ENOPROTOOPT:
1904
 
                        logger.error("SO_BINDTODEVICE not available;"
1905
 
                                     " cannot bind to interface %s",
1906
 
                                     self.interface)
1907
 
                    else:
1908
 
                        raise
 
2480
                # Fall back to a hard-coded value which seems to be
 
2481
                # common enough.
 
2482
                logger.warning("SO_BINDTODEVICE not found, trying 25")
 
2483
                SO_BINDTODEVICE = 25
 
2484
            try:
 
2485
                self.socket.setsockopt(
 
2486
                    socket.SOL_SOCKET, SO_BINDTODEVICE,
 
2487
                    (self.interface + "\0").encode("utf-8"))
 
2488
            except socket.error as error:
 
2489
                if error.errno == errno.EPERM:
 
2490
                    logger.error("No permission to bind to"
 
2491
                                 " interface %s", self.interface)
 
2492
                elif error.errno == errno.ENOPROTOOPT:
 
2493
                    logger.error("SO_BINDTODEVICE not available;"
 
2494
                                 " cannot bind to interface %s",
 
2495
                                 self.interface)
 
2496
                elif error.errno == errno.ENODEV:
 
2497
                    logger.error("Interface %s does not exist,"
 
2498
                                 " cannot bind", self.interface)
 
2499
                else:
 
2500
                    raise
1909
2501
        # Only bind(2) the socket if we really need to.
1910
2502
        if self.server_address[0] or self.server_address[1]:
1911
2503
            if not self.server_address[0]:
1912
2504
                if self.address_family == socket.AF_INET6:
1913
 
                    any_address = "::" # in6addr_any
 
2505
                    any_address = "::"  # in6addr_any
1914
2506
                else:
1915
 
                    any_address = socket.INADDR_ANY
 
2507
                    any_address = "0.0.0.0"  # INADDR_ANY
1916
2508
                self.server_address = (any_address,
1917
2509
                                       self.server_address[1])
1918
2510
            elif not self.server_address[1]:
1919
 
                self.server_address = (self.server_address[0],
1920
 
                                       0)
 
2511
                self.server_address = (self.server_address[0], 0)
1921
2512
#                 if self.interface:
1922
2513
#                     self.server_address = (self.server_address[0],
1923
2514
#                                            0, # port
1929
2520
 
1930
2521
class MandosServer(IPv6_TCPServer):
1931
2522
    """Mandos server.
1932
 
    
 
2523
 
1933
2524
    Attributes:
1934
2525
        clients:        set of Client objects
1935
2526
        gnutls_priority GnuTLS priority string
1936
2527
        use_dbus:       Boolean; to emit D-Bus signals or not
1937
 
    
1938
 
    Assumes a gobject.MainLoop event loop.
 
2528
 
 
2529
    Assumes a GLib.MainLoop event loop.
1939
2530
    """
 
2531
 
1940
2532
    def __init__(self, server_address, RequestHandlerClass,
1941
 
                 interface=None, use_ipv6=True, clients=None,
1942
 
                 gnutls_priority=None, use_dbus=True):
 
2533
                 interface=None,
 
2534
                 use_ipv6=True,
 
2535
                 clients=None,
 
2536
                 gnutls_priority=None,
 
2537
                 use_dbus=True,
 
2538
                 socketfd=None):
1943
2539
        self.enabled = False
1944
2540
        self.clients = clients
1945
2541
        if self.clients is None:
1948
2544
        self.gnutls_priority = gnutls_priority
1949
2545
        IPv6_TCPServer.__init__(self, server_address,
1950
2546
                                RequestHandlerClass,
1951
 
                                interface = interface,
1952
 
                                use_ipv6 = use_ipv6)
 
2547
                                interface=interface,
 
2548
                                use_ipv6=use_ipv6,
 
2549
                                socketfd=socketfd)
 
2550
 
1953
2551
    def server_activate(self):
1954
2552
        if self.enabled:
1955
2553
            return socketserver.TCPServer.server_activate(self)
1956
 
    
 
2554
 
1957
2555
    def enable(self):
1958
2556
        self.enabled = True
1959
 
    
 
2557
 
1960
2558
    def add_pipe(self, parent_pipe, proc):
1961
2559
        # Call "handle_ipc" for both data and EOF events
1962
 
        gobject.io_add_watch(parent_pipe.fileno(),
1963
 
                             gobject.IO_IN | gobject.IO_HUP,
1964
 
                             functools.partial(self.handle_ipc,
1965
 
                                               parent_pipe =
1966
 
                                               parent_pipe,
1967
 
                                               proc = proc))
1968
 
    
1969
 
    def handle_ipc(self, source, condition, parent_pipe=None,
1970
 
                   proc = None, client_object=None):
1971
 
        condition_names = {
1972
 
            gobject.IO_IN: "IN",   # There is data to read.
1973
 
            gobject.IO_OUT: "OUT", # Data can be written (without
1974
 
                                    # blocking).
1975
 
            gobject.IO_PRI: "PRI", # There is urgent data to read.
1976
 
            gobject.IO_ERR: "ERR", # Error condition.
1977
 
            gobject.IO_HUP: "HUP"  # Hung up (the connection has been
1978
 
                                    # broken, usually for pipes and
1979
 
                                    # sockets).
1980
 
            }
1981
 
        conditions_string = ' | '.join(name
1982
 
                                       for cond, name in
1983
 
                                       condition_names.iteritems()
1984
 
                                       if cond & condition)
 
2560
        GLib.io_add_watch(
 
2561
            parent_pipe.fileno(),
 
2562
            GLib.IO_IN | GLib.IO_HUP,
 
2563
            functools.partial(self.handle_ipc,
 
2564
                              parent_pipe=parent_pipe,
 
2565
                              proc=proc))
 
2566
 
 
2567
    def handle_ipc(self, source, condition,
 
2568
                   parent_pipe=None,
 
2569
                   proc=None,
 
2570
                   client_object=None):
1985
2571
        # error, or the other end of multiprocessing.Pipe has closed
1986
 
        if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
 
2572
        if condition & (GLib.IO_ERR | GLib.IO_HUP):
1987
2573
            # Wait for other process to exit
1988
2574
            proc.join()
1989
2575
            return False
1990
 
        
 
2576
 
1991
2577
        # Read a request from the child
1992
2578
        request = parent_pipe.recv()
1993
2579
        command = request[0]
1994
 
        
 
2580
 
1995
2581
        if command == 'init':
1996
 
            fpr = request[1]
 
2582
            fpr = request[1].decode("ascii")
1997
2583
            address = request[2]
1998
 
            
1999
 
            for c in self.clients.itervalues():
 
2584
 
 
2585
            for c in self.clients.values():
2000
2586
                if c.fingerprint == fpr:
2001
2587
                    client = c
2002
2588
                    break
2009
2595
                                                       address[0])
2010
2596
                parent_pipe.send(False)
2011
2597
                return False
2012
 
            
2013
 
            gobject.io_add_watch(parent_pipe.fileno(),
2014
 
                                 gobject.IO_IN | gobject.IO_HUP,
2015
 
                                 functools.partial(self.handle_ipc,
2016
 
                                                   parent_pipe =
2017
 
                                                   parent_pipe,
2018
 
                                                   proc = proc,
2019
 
                                                   client_object =
2020
 
                                                   client))
 
2598
 
 
2599
            GLib.io_add_watch(
 
2600
                parent_pipe.fileno(),
 
2601
                GLib.IO_IN | GLib.IO_HUP,
 
2602
                functools.partial(self.handle_ipc,
 
2603
                                  parent_pipe=parent_pipe,
 
2604
                                  proc=proc,
 
2605
                                  client_object=client))
2021
2606
            parent_pipe.send(True)
2022
2607
            # remove the old hook in favor of the new above hook on
2023
2608
            # same fileno
2026
2611
            funcname = request[1]
2027
2612
            args = request[2]
2028
2613
            kwargs = request[3]
2029
 
            
 
2614
 
2030
2615
            parent_pipe.send(('data', getattr(client_object,
2031
2616
                                              funcname)(*args,
2032
 
                                                         **kwargs)))
2033
 
        
 
2617
                                                        **kwargs)))
 
2618
 
2034
2619
        if command == 'getattr':
2035
2620
            attrname = request[1]
2036
 
            if callable(client_object.__getattribute__(attrname)):
2037
 
                parent_pipe.send(('function',))
 
2621
            if isinstance(client_object.__getattribute__(attrname),
 
2622
                          collections.Callable):
 
2623
                parent_pipe.send(('function', ))
2038
2624
            else:
2039
 
                parent_pipe.send(('data', client_object
2040
 
                                  .__getattribute__(attrname)))
2041
 
        
 
2625
                parent_pipe.send((
 
2626
                    'data', client_object.__getattribute__(attrname)))
 
2627
 
2042
2628
        if command == 'setattr':
2043
2629
            attrname = request[1]
2044
2630
            value = request[2]
2045
2631
            setattr(client_object, attrname, value)
2046
 
        
 
2632
 
2047
2633
        return True
2048
2634
 
2049
2635
 
 
2636
def rfc3339_duration_to_delta(duration):
 
2637
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
 
2638
 
 
2639
    >>> rfc3339_duration_to_delta("P7D")
 
2640
    datetime.timedelta(7)
 
2641
    >>> rfc3339_duration_to_delta("PT60S")
 
2642
    datetime.timedelta(0, 60)
 
2643
    >>> rfc3339_duration_to_delta("PT60M")
 
2644
    datetime.timedelta(0, 3600)
 
2645
    >>> rfc3339_duration_to_delta("PT24H")
 
2646
    datetime.timedelta(1)
 
2647
    >>> rfc3339_duration_to_delta("P1W")
 
2648
    datetime.timedelta(7)
 
2649
    >>> rfc3339_duration_to_delta("PT5M30S")
 
2650
    datetime.timedelta(0, 330)
 
2651
    >>> rfc3339_duration_to_delta("P1DT3M20S")
 
2652
    datetime.timedelta(1, 200)
 
2653
    """
 
2654
 
 
2655
    # Parsing an RFC 3339 duration with regular expressions is not
 
2656
    # possible - there would have to be multiple places for the same
 
2657
    # values, like seconds.  The current code, while more esoteric, is
 
2658
    # cleaner without depending on a parsing library.  If Python had a
 
2659
    # built-in library for parsing we would use it, but we'd like to
 
2660
    # avoid excessive use of external libraries.
 
2661
 
 
2662
    # New type for defining tokens, syntax, and semantics all-in-one
 
2663
    Token = collections.namedtuple("Token", (
 
2664
        "regexp",  # To match token; if "value" is not None, must have
 
2665
                   # a "group" containing digits
 
2666
        "value",   # datetime.timedelta or None
 
2667
        "followers"))           # Tokens valid after this token
 
2668
    # RFC 3339 "duration" tokens, syntax, and semantics; taken from
 
2669
    # the "duration" ABNF definition in RFC 3339, Appendix A.
 
2670
    token_end = Token(re.compile(r"$"), None, frozenset())
 
2671
    token_second = Token(re.compile(r"(\d+)S"),
 
2672
                         datetime.timedelta(seconds=1),
 
2673
                         frozenset((token_end, )))
 
2674
    token_minute = Token(re.compile(r"(\d+)M"),
 
2675
                         datetime.timedelta(minutes=1),
 
2676
                         frozenset((token_second, token_end)))
 
2677
    token_hour = Token(re.compile(r"(\d+)H"),
 
2678
                       datetime.timedelta(hours=1),
 
2679
                       frozenset((token_minute, token_end)))
 
2680
    token_time = Token(re.compile(r"T"),
 
2681
                       None,
 
2682
                       frozenset((token_hour, token_minute,
 
2683
                                  token_second)))
 
2684
    token_day = Token(re.compile(r"(\d+)D"),
 
2685
                      datetime.timedelta(days=1),
 
2686
                      frozenset((token_time, token_end)))
 
2687
    token_month = Token(re.compile(r"(\d+)M"),
 
2688
                        datetime.timedelta(weeks=4),
 
2689
                        frozenset((token_day, token_end)))
 
2690
    token_year = Token(re.compile(r"(\d+)Y"),
 
2691
                       datetime.timedelta(weeks=52),
 
2692
                       frozenset((token_month, token_end)))
 
2693
    token_week = Token(re.compile(r"(\d+)W"),
 
2694
                       datetime.timedelta(weeks=1),
 
2695
                       frozenset((token_end, )))
 
2696
    token_duration = Token(re.compile(r"P"), None,
 
2697
                           frozenset((token_year, token_month,
 
2698
                                      token_day, token_time,
 
2699
                                      token_week)))
 
2700
    # Define starting values:
 
2701
    # Value so far
 
2702
    value = datetime.timedelta()
 
2703
    found_token = None
 
2704
    # Following valid tokens
 
2705
    followers = frozenset((token_duration, ))
 
2706
    # String left to parse
 
2707
    s = duration
 
2708
    # Loop until end token is found
 
2709
    while found_token is not token_end:
 
2710
        # Search for any currently valid tokens
 
2711
        for token in followers:
 
2712
            match = token.regexp.match(s)
 
2713
            if match is not None:
 
2714
                # Token found
 
2715
                if token.value is not None:
 
2716
                    # Value found, parse digits
 
2717
                    factor = int(match.group(1), 10)
 
2718
                    # Add to value so far
 
2719
                    value += factor * token.value
 
2720
                # Strip token from string
 
2721
                s = token.regexp.sub("", s, 1)
 
2722
                # Go to found token
 
2723
                found_token = token
 
2724
                # Set valid next tokens
 
2725
                followers = found_token.followers
 
2726
                break
 
2727
        else:
 
2728
            # No currently valid tokens were found
 
2729
            raise ValueError("Invalid RFC 3339 duration: {!r}"
 
2730
                             .format(duration))
 
2731
    # End token found
 
2732
    return value
 
2733
 
 
2734
 
2050
2735
def string_to_delta(interval):
2051
2736
    """Parse a string and return a datetime.timedelta
2052
 
    
 
2737
 
2053
2738
    >>> string_to_delta('7d')
2054
2739
    datetime.timedelta(7)
2055
2740
    >>> string_to_delta('60s')
2063
2748
    >>> string_to_delta('5m 30s')
2064
2749
    datetime.timedelta(0, 330)
2065
2750
    """
 
2751
 
 
2752
    try:
 
2753
        return rfc3339_duration_to_delta(interval)
 
2754
    except ValueError:
 
2755
        pass
 
2756
 
2066
2757
    timevalue = datetime.timedelta(0)
2067
2758
    for s in interval.split():
2068
2759
        try:
2069
 
            suffix = unicode(s[-1])
 
2760
            suffix = s[-1]
2070
2761
            value = int(s[:-1])
2071
2762
            if suffix == "d":
2072
2763
                delta = datetime.timedelta(value)
2079
2770
            elif suffix == "w":
2080
2771
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2081
2772
            else:
2082
 
                raise ValueError("Unknown suffix %r" % suffix)
2083
 
        except (ValueError, IndexError) as e:
 
2773
                raise ValueError("Unknown suffix {!r}".format(suffix))
 
2774
        except IndexError as e:
2084
2775
            raise ValueError(*(e.args))
2085
2776
        timevalue += delta
2086
2777
    return timevalue
2087
2778
 
2088
2779
 
2089
 
def daemon(nochdir = False, noclose = False):
 
2780
def daemon(nochdir=False, noclose=False):
2090
2781
    """See daemon(3).  Standard BSD Unix function.
2091
 
    
 
2782
 
2092
2783
    This should really exist as os.daemon, but it doesn't (yet)."""
2093
2784
    if os.fork():
2094
2785
        sys.exit()
2102
2793
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2103
2794
        if not stat.S_ISCHR(os.fstat(null).st_mode):
2104
2795
            raise OSError(errno.ENODEV,
2105
 
                          "%s not a character device"
2106
 
                          % os.devnull)
 
2796
                          "{} not a character device"
 
2797
                          .format(os.devnull))
2107
2798
        os.dup2(null, sys.stdin.fileno())
2108
2799
        os.dup2(null, sys.stdout.fileno())
2109
2800
        os.dup2(null, sys.stderr.fileno())
2112
2803
 
2113
2804
 
2114
2805
def main():
2115
 
    
 
2806
 
2116
2807
    ##################################################################
2117
2808
    # Parsing of options, both command line and config file
2118
 
    
 
2809
 
2119
2810
    parser = argparse.ArgumentParser()
2120
2811
    parser.add_argument("-v", "--version", action="version",
2121
 
                        version = "%%(prog)s %s" % version,
 
2812
                        version="%(prog)s {}".format(version),
2122
2813
                        help="show version number and exit")
2123
2814
    parser.add_argument("-i", "--interface", metavar="IF",
2124
2815
                        help="Bind to interface IF")
2130
2821
                        help="Run self-test")
2131
2822
    parser.add_argument("--debug", action="store_true",
2132
2823
                        help="Debug mode; run in foreground and log"
2133
 
                        " to terminal")
 
2824
                        " to terminal", default=None)
2134
2825
    parser.add_argument("--debuglevel", metavar="LEVEL",
2135
2826
                        help="Debug level for stdout output")
2136
2827
    parser.add_argument("--priority", help="GnuTLS"
2143
2834
                        " files")
2144
2835
    parser.add_argument("--no-dbus", action="store_false",
2145
2836
                        dest="use_dbus", help="Do not provide D-Bus"
2146
 
                        " system bus interface")
 
2837
                        " system bus interface", default=None)
2147
2838
    parser.add_argument("--no-ipv6", action="store_false",
2148
 
                        dest="use_ipv6", help="Do not use IPv6")
 
2839
                        dest="use_ipv6", help="Do not use IPv6",
 
2840
                        default=None)
2149
2841
    parser.add_argument("--no-restore", action="store_false",
2150
2842
                        dest="restore", help="Do not restore stored"
2151
 
                        " state")
 
2843
                        " state", default=None)
 
2844
    parser.add_argument("--socket", type=int,
 
2845
                        help="Specify a file descriptor to a network"
 
2846
                        " socket to use instead of creating one")
2152
2847
    parser.add_argument("--statedir", metavar="DIR",
2153
2848
                        help="Directory to save/restore state in")
2154
 
    
 
2849
    parser.add_argument("--foreground", action="store_true",
 
2850
                        help="Run in foreground", default=None)
 
2851
    parser.add_argument("--no-zeroconf", action="store_false",
 
2852
                        dest="zeroconf", help="Do not use Zeroconf",
 
2853
                        default=None)
 
2854
 
2155
2855
    options = parser.parse_args()
2156
 
    
 
2856
 
2157
2857
    if options.check:
2158
2858
        import doctest
2159
 
        doctest.testmod()
2160
 
        sys.exit()
2161
 
    
 
2859
        fail_count, test_count = doctest.testmod()
 
2860
        sys.exit(os.EX_OK if fail_count == 0 else 1)
 
2861
 
2162
2862
    # Default values for config file for server-global settings
2163
 
    server_defaults = { "interface": "",
2164
 
                        "address": "",
2165
 
                        "port": "",
2166
 
                        "debug": "False",
2167
 
                        "priority":
2168
 
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2169
 
                        "servicename": "Mandos",
2170
 
                        "use_dbus": "True",
2171
 
                        "use_ipv6": "True",
2172
 
                        "debuglevel": "",
2173
 
                        "restore": "True",
2174
 
                        "statedir": "/var/lib/mandos"
2175
 
                        }
2176
 
    
 
2863
    server_defaults = {"interface": "",
 
2864
                       "address": "",
 
2865
                       "port": "",
 
2866
                       "debug": "False",
 
2867
                       "priority":
 
2868
                       "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
 
2869
                       ":+SIGN-DSA-SHA256",
 
2870
                       "servicename": "Mandos",
 
2871
                       "use_dbus": "True",
 
2872
                       "use_ipv6": "True",
 
2873
                       "debuglevel": "",
 
2874
                       "restore": "True",
 
2875
                       "socket": "",
 
2876
                       "statedir": "/var/lib/mandos",
 
2877
                       "foreground": "False",
 
2878
                       "zeroconf": "True",
 
2879
                       }
 
2880
 
2177
2881
    # Parse config file for server-global settings
2178
2882
    server_config = configparser.SafeConfigParser(server_defaults)
2179
2883
    del server_defaults
2180
 
    server_config.read(os.path.join(options.configdir,
2181
 
                                    "mandos.conf"))
 
2884
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
2182
2885
    # Convert the SafeConfigParser object to a dict
2183
2886
    server_settings = server_config.defaults()
2184
2887
    # Use the appropriate methods on the non-string config options
2185
 
    for option in ("debug", "use_dbus", "use_ipv6"):
 
2888
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
 
2889
                   "foreground", "zeroconf"):
2186
2890
        server_settings[option] = server_config.getboolean("DEFAULT",
2187
2891
                                                           option)
2188
2892
    if server_settings["port"]:
2189
2893
        server_settings["port"] = server_config.getint("DEFAULT",
2190
2894
                                                       "port")
 
2895
    if server_settings["socket"]:
 
2896
        server_settings["socket"] = server_config.getint("DEFAULT",
 
2897
                                                         "socket")
 
2898
        # Later, stdin will, and stdout and stderr might, be dup'ed
 
2899
        # over with an opened os.devnull.  But we don't want this to
 
2900
        # happen with a supplied network socket.
 
2901
        if 0 <= server_settings["socket"] <= 2:
 
2902
            server_settings["socket"] = os.dup(server_settings
 
2903
                                               ["socket"])
2191
2904
    del server_config
2192
 
    
 
2905
 
2193
2906
    # Override the settings from the config file with command line
2194
2907
    # options, if set.
2195
2908
    for option in ("interface", "address", "port", "debug",
2196
 
                   "priority", "servicename", "configdir",
2197
 
                   "use_dbus", "use_ipv6", "debuglevel", "restore",
2198
 
                   "statedir"):
 
2909
                   "priority", "servicename", "configdir", "use_dbus",
 
2910
                   "use_ipv6", "debuglevel", "restore", "statedir",
 
2911
                   "socket", "foreground", "zeroconf"):
2199
2912
        value = getattr(options, option)
2200
2913
        if value is not None:
2201
2914
            server_settings[option] = value
2202
2915
    del options
2203
2916
    # Force all strings to be unicode
2204
2917
    for option in server_settings.keys():
2205
 
        if type(server_settings[option]) is str:
2206
 
            server_settings[option] = unicode(server_settings[option])
 
2918
        if isinstance(server_settings[option], bytes):
 
2919
            server_settings[option] = (server_settings[option]
 
2920
                                       .decode("utf-8"))
 
2921
    # Force all boolean options to be boolean
 
2922
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
 
2923
                   "foreground", "zeroconf"):
 
2924
        server_settings[option] = bool(server_settings[option])
 
2925
    # Debug implies foreground
 
2926
    if server_settings["debug"]:
 
2927
        server_settings["foreground"] = True
2207
2928
    # Now we have our good server settings in "server_settings"
2208
 
    
 
2929
 
2209
2930
    ##################################################################
2210
 
    
 
2931
 
 
2932
    if (not server_settings["zeroconf"]
 
2933
        and not (server_settings["port"]
 
2934
                 or server_settings["socket"] != "")):
 
2935
        parser.error("Needs port or socket to work without Zeroconf")
 
2936
 
2211
2937
    # For convenience
2212
2938
    debug = server_settings["debug"]
2213
2939
    debuglevel = server_settings["debuglevel"]
2215
2941
    use_ipv6 = server_settings["use_ipv6"]
2216
2942
    stored_state_path = os.path.join(server_settings["statedir"],
2217
2943
                                     stored_state_file)
2218
 
    
 
2944
    foreground = server_settings["foreground"]
 
2945
    zeroconf = server_settings["zeroconf"]
 
2946
 
2219
2947
    if debug:
2220
2948
        initlogger(debug, logging.DEBUG)
2221
2949
    else:
2224
2952
        else:
2225
2953
            level = getattr(logging, debuglevel.upper())
2226
2954
            initlogger(debug, level)
2227
 
    
 
2955
 
2228
2956
    if server_settings["servicename"] != "Mandos":
2229
 
        syslogger.setFormatter(logging.Formatter
2230
 
                               ('Mandos (%s) [%%(process)d]:'
2231
 
                                ' %%(levelname)s: %%(message)s'
2232
 
                                % server_settings["servicename"]))
2233
 
    
 
2957
        syslogger.setFormatter(
 
2958
            logging.Formatter('Mandos ({}) [%(process)d]:'
 
2959
                              ' %(levelname)s: %(message)s'.format(
 
2960
                                  server_settings["servicename"])))
 
2961
 
2234
2962
    # Parse config file with clients
2235
2963
    client_config = configparser.SafeConfigParser(Client
2236
2964
                                                  .client_defaults)
2237
2965
    client_config.read(os.path.join(server_settings["configdir"],
2238
2966
                                    "clients.conf"))
2239
 
    
 
2967
 
2240
2968
    global mandos_dbus_service
2241
2969
    mandos_dbus_service = None
2242
 
    
2243
 
    tcp_server = MandosServer((server_settings["address"],
2244
 
                               server_settings["port"]),
2245
 
                              ClientHandler,
2246
 
                              interface=(server_settings["interface"]
2247
 
                                         or None),
2248
 
                              use_ipv6=use_ipv6,
2249
 
                              gnutls_priority=
2250
 
                              server_settings["priority"],
2251
 
                              use_dbus=use_dbus)
2252
 
    if not debug:
2253
 
        pidfilename = "/var/run/mandos.pid"
 
2970
 
 
2971
    socketfd = None
 
2972
    if server_settings["socket"] != "":
 
2973
        socketfd = server_settings["socket"]
 
2974
    tcp_server = MandosServer(
 
2975
        (server_settings["address"], server_settings["port"]),
 
2976
        ClientHandler,
 
2977
        interface=(server_settings["interface"] or None),
 
2978
        use_ipv6=use_ipv6,
 
2979
        gnutls_priority=server_settings["priority"],
 
2980
        use_dbus=use_dbus,
 
2981
        socketfd=socketfd)
 
2982
    if not foreground:
 
2983
        pidfilename = "/run/mandos.pid"
 
2984
        if not os.path.isdir("/run/."):
 
2985
            pidfilename = "/var/run/mandos.pid"
 
2986
        pidfile = None
2254
2987
        try:
2255
 
            pidfile = open(pidfilename, "w")
2256
 
        except IOError:
2257
 
            logger.error("Could not open file %r", pidfilename)
2258
 
    
2259
 
    for name in ("_mandos", "mandos", "nobody"):
 
2988
            pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
 
2989
        except IOError as e:
 
2990
            logger.error("Could not open file %r", pidfilename,
 
2991
                         exc_info=e)
 
2992
 
 
2993
    for name, group in (("_mandos", "_mandos"),
 
2994
                        ("mandos", "mandos"),
 
2995
                        ("nobody", "nogroup")):
2260
2996
        try:
2261
2997
            uid = pwd.getpwnam(name).pw_uid
2262
 
            gid = pwd.getpwnam(name).pw_gid
 
2998
            gid = pwd.getpwnam(group).pw_gid
2263
2999
            break
2264
3000
        except KeyError:
2265
3001
            continue
2269
3005
    try:
2270
3006
        os.setgid(gid)
2271
3007
        os.setuid(uid)
 
3008
        if debug:
 
3009
            logger.debug("Did setuid/setgid to {}:{}".format(uid,
 
3010
                                                             gid))
2272
3011
    except OSError as error:
2273
 
        if error[0] != errno.EPERM:
2274
 
            raise error
2275
 
    
 
3012
        logger.warning("Failed to setuid/setgid to {}:{}: {}"
 
3013
                       .format(uid, gid, os.strerror(error.errno)))
 
3014
        if error.errno != errno.EPERM:
 
3015
            raise
 
3016
 
2276
3017
    if debug:
2277
3018
        # Enable all possible GnuTLS debugging
2278
 
        
 
3019
 
2279
3020
        # "Use a log level over 10 to enable all debugging options."
2280
3021
        # - GnuTLS manual
2281
 
        gnutls.library.functions.gnutls_global_set_log_level(11)
2282
 
        
2283
 
        @gnutls.library.types.gnutls_log_func
 
3022
        gnutls.global_set_log_level(11)
 
3023
 
 
3024
        @gnutls.log_func
2284
3025
        def debug_gnutls(level, string):
2285
3026
            logger.debug("GnuTLS: %s", string[:-1])
2286
 
        
2287
 
        (gnutls.library.functions
2288
 
         .gnutls_global_set_log_function(debug_gnutls))
2289
 
        
 
3027
 
 
3028
        gnutls.global_set_log_function(debug_gnutls)
 
3029
 
2290
3030
        # Redirect stdin so all checkers get /dev/null
2291
3031
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2292
3032
        os.dup2(null, sys.stdin.fileno())
2293
3033
        if null > 2:
2294
3034
            os.close(null)
2295
 
    
 
3035
 
2296
3036
    # Need to fork before connecting to D-Bus
2297
 
    if not debug:
 
3037
    if not foreground:
2298
3038
        # Close all input and output, do double fork, etc.
2299
3039
        daemon()
2300
 
    
2301
 
    gobject.threads_init()
2302
 
    
 
3040
 
 
3041
    # multiprocessing will use threads, so before we use GLib we need
 
3042
    # to inform GLib that threads will be used.
 
3043
    GLib.threads_init()
 
3044
 
2303
3045
    global main_loop
2304
3046
    # From the Avahi example code
2305
3047
    DBusGMainLoop(set_as_default=True)
2306
 
    main_loop = gobject.MainLoop()
 
3048
    main_loop = GLib.MainLoop()
2307
3049
    bus = dbus.SystemBus()
2308
3050
    # End of Avahi example code
2309
3051
    if use_dbus:
2310
3052
        try:
2311
3053
            bus_name = dbus.service.BusName("se.recompile.Mandos",
2312
 
                                            bus, do_not_queue=True)
2313
 
            old_bus_name = (dbus.service.BusName
2314
 
                            ("se.bsnet.fukt.Mandos", bus,
2315
 
                             do_not_queue=True))
2316
 
        except dbus.exceptions.NameExistsException as e:
2317
 
            logger.error(unicode(e) + ", disabling D-Bus")
 
3054
                                            bus,
 
3055
                                            do_not_queue=True)
 
3056
            old_bus_name = dbus.service.BusName(
 
3057
                "se.bsnet.fukt.Mandos", bus,
 
3058
                do_not_queue=True)
 
3059
        except dbus.exceptions.DBusException as e:
 
3060
            logger.error("Disabling D-Bus:", exc_info=e)
2318
3061
            use_dbus = False
2319
3062
            server_settings["use_dbus"] = False
2320
3063
            tcp_server.use_dbus = False
2321
 
    protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2322
 
    service = AvahiServiceToSyslog(name =
2323
 
                                   server_settings["servicename"],
2324
 
                                   servicetype = "_mandos._tcp",
2325
 
                                   protocol = protocol, bus = bus)
2326
 
    if server_settings["interface"]:
2327
 
        service.interface = (if_nametoindex
2328
 
                             (str(server_settings["interface"])))
2329
 
    
 
3064
    if zeroconf:
 
3065
        protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
 
3066
        service = AvahiServiceToSyslog(
 
3067
            name=server_settings["servicename"],
 
3068
            servicetype="_mandos._tcp",
 
3069
            protocol=protocol,
 
3070
            bus=bus)
 
3071
        if server_settings["interface"]:
 
3072
            service.interface = if_nametoindex(
 
3073
                server_settings["interface"].encode("utf-8"))
 
3074
 
2330
3075
    global multiprocessing_manager
2331
3076
    multiprocessing_manager = multiprocessing.Manager()
2332
 
    
 
3077
 
2333
3078
    client_class = Client
2334
3079
    if use_dbus:
2335
 
        client_class = functools.partial(ClientDBusTransitional,
2336
 
                                         bus = bus)
2337
 
    
 
3080
        client_class = functools.partial(ClientDBus, bus=bus)
 
3081
 
2338
3082
    client_settings = Client.config_parser(client_config)
2339
3083
    old_client_settings = {}
2340
3084
    clients_data = {}
2341
 
    
 
3085
 
 
3086
    # This is used to redirect stdout and stderr for checker processes
 
3087
    global wnull
 
3088
    wnull = open(os.devnull, "w")  # A writable /dev/null
 
3089
    # Only used if server is running in foreground but not in debug
 
3090
    # mode
 
3091
    if debug or not foreground:
 
3092
        wnull.close()
 
3093
 
2342
3094
    # Get client data and settings from last running state.
2343
3095
    if server_settings["restore"]:
2344
3096
        try:
2345
3097
            with open(stored_state_path, "rb") as stored_state:
2346
 
                clients_data, old_client_settings = (pickle.load
2347
 
                                                     (stored_state))
 
3098
                if sys.version_info.major == 2:
 
3099
                    clients_data, old_client_settings = pickle.load(
 
3100
                        stored_state)
 
3101
                else:
 
3102
                    bytes_clients_data, bytes_old_client_settings = (
 
3103
                        pickle.load(stored_state, encoding="bytes"))
 
3104
                    #   Fix bytes to strings
 
3105
                    #  clients_data
 
3106
                    # .keys()
 
3107
                    clients_data = {(key.decode("utf-8")
 
3108
                                     if isinstance(key, bytes)
 
3109
                                     else key): value
 
3110
                                    for key, value in
 
3111
                                    bytes_clients_data.items()}
 
3112
                    del bytes_clients_data
 
3113
                    for key in clients_data:
 
3114
                        value = {(k.decode("utf-8")
 
3115
                                  if isinstance(k, bytes) else k): v
 
3116
                                 for k, v in
 
3117
                                 clients_data[key].items()}
 
3118
                        clients_data[key] = value
 
3119
                        # .client_structure
 
3120
                        value["client_structure"] = [
 
3121
                            (s.decode("utf-8")
 
3122
                             if isinstance(s, bytes)
 
3123
                             else s) for s in
 
3124
                            value["client_structure"]]
 
3125
                        # .name & .host
 
3126
                        for k in ("name", "host"):
 
3127
                            if isinstance(value[k], bytes):
 
3128
                                value[k] = value[k].decode("utf-8")
 
3129
                    #  old_client_settings
 
3130
                    # .keys()
 
3131
                    old_client_settings = {
 
3132
                        (key.decode("utf-8")
 
3133
                         if isinstance(key, bytes)
 
3134
                         else key): value
 
3135
                        for key, value in
 
3136
                        bytes_old_client_settings.items()}
 
3137
                    del bytes_old_client_settings
 
3138
                    # .host
 
3139
                    for value in old_client_settings.values():
 
3140
                        if isinstance(value["host"], bytes):
 
3141
                            value["host"] = (value["host"]
 
3142
                                             .decode("utf-8"))
2348
3143
            os.remove(stored_state_path)
2349
3144
        except IOError as e:
2350
 
            logger.warning("Could not load persistent state: {0}"
2351
 
                           .format(e))
2352
 
            if e.errno != errno.ENOENT:
 
3145
            if e.errno == errno.ENOENT:
 
3146
                logger.warning("Could not load persistent state:"
 
3147
                               " {}".format(os.strerror(e.errno)))
 
3148
            else:
 
3149
                logger.critical("Could not load persistent state:",
 
3150
                                exc_info=e)
2353
3151
                raise
2354
3152
        except EOFError as e:
2355
3153
            logger.warning("Could not load persistent state: "
2356
 
                           "EOFError: {0}".format(e))
2357
 
    
 
3154
                           "EOFError:",
 
3155
                           exc_info=e)
 
3156
 
2358
3157
    with PGPEngine() as pgp:
2359
 
        for client_name, client in clients_data.iteritems():
 
3158
        for client_name, client in clients_data.items():
 
3159
            # Skip removed clients
 
3160
            if client_name not in client_settings:
 
3161
                continue
 
3162
 
2360
3163
            # Decide which value to use after restoring saved state.
2361
3164
            # We have three different values: Old config file,
2362
3165
            # new config file, and saved state.
2367
3170
                    # For each value in new config, check if it
2368
3171
                    # differs from the old config value (Except for
2369
3172
                    # the "secret" attribute)
2370
 
                    if (name != "secret" and
2371
 
                        value != old_client_settings[client_name]
2372
 
                        [name]):
 
3173
                    if (name != "secret"
 
3174
                        and (value !=
 
3175
                             old_client_settings[client_name][name])):
2373
3176
                        client[name] = value
2374
3177
                except KeyError:
2375
3178
                    pass
2376
 
            
 
3179
 
2377
3180
            # Clients who has passed its expire date can still be
2378
 
            # enabled if its last checker was successful.  Clients
 
3181
            # enabled if its last checker was successful.  A Client
2379
3182
            # whose checker succeeded before we stored its state is
2380
3183
            # assumed to have successfully run all checkers during
2381
3184
            # downtime.
2383
3186
                if datetime.datetime.utcnow() >= client["expires"]:
2384
3187
                    if not client["last_checked_ok"]:
2385
3188
                        logger.warning(
2386
 
                            "disabling client {0} - Client never "
2387
 
                            "performed a successful checker"
2388
 
                            .format(client_name))
 
3189
                            "disabling client {} - Client never "
 
3190
                            "performed a successful checker".format(
 
3191
                                client_name))
2389
3192
                        client["enabled"] = False
2390
3193
                    elif client["last_checker_status"] != 0:
2391
3194
                        logger.warning(
2392
 
                            "disabling client {0} - Client "
2393
 
                            "last checker failed with error code {1}"
2394
 
                            .format(client_name,
2395
 
                                    client["last_checker_status"]))
 
3195
                            "disabling client {} - Client last"
 
3196
                            " checker failed with error code"
 
3197
                            " {}".format(
 
3198
                                client_name,
 
3199
                                client["last_checker_status"]))
2396
3200
                        client["enabled"] = False
2397
3201
                    else:
2398
 
                        client["expires"] = (datetime.datetime
2399
 
                                             .utcnow()
2400
 
                                             + client["timeout"])
 
3202
                        client["expires"] = (
 
3203
                            datetime.datetime.utcnow()
 
3204
                            + client["timeout"])
2401
3205
                        logger.debug("Last checker succeeded,"
2402
 
                                     " keeping {0} enabled"
2403
 
                                     .format(client_name))
 
3206
                                     " keeping {} enabled".format(
 
3207
                                         client_name))
2404
3208
            try:
2405
 
                client["secret"] = (
2406
 
                    pgp.decrypt(client["encrypted_secret"],
2407
 
                                client_settings[client_name]
2408
 
                                ["secret"]))
 
3209
                client["secret"] = pgp.decrypt(
 
3210
                    client["encrypted_secret"],
 
3211
                    client_settings[client_name]["secret"])
2409
3212
            except PGPError:
2410
3213
                # If decryption fails, we use secret from new settings
2411
 
                logger.debug("Failed to decrypt {0} old secret"
2412
 
                             .format(client_name))
2413
 
                client["secret"] = (
2414
 
                    client_settings[client_name]["secret"])
 
3214
                logger.debug("Failed to decrypt {} old secret".format(
 
3215
                    client_name))
 
3216
                client["secret"] = (client_settings[client_name]
 
3217
                                    ["secret"])
2415
3218
 
2416
 
    
2417
3219
    # Add/remove clients based on new changes made to config
2418
3220
    for client_name in (set(old_client_settings)
2419
3221
                        - set(client_settings)):
2423
3225
        clients_data[client_name] = client_settings[client_name]
2424
3226
 
2425
3227
    # Create all client objects
2426
 
    for client_name, client in clients_data.iteritems():
 
3228
    for client_name, client in clients_data.items():
2427
3229
        tcp_server.clients[client_name] = client_class(
2428
 
            name = client_name, settings = client)
2429
 
    
 
3230
            name=client_name,
 
3231
            settings=client,
 
3232
            server_settings=server_settings)
 
3233
 
2430
3234
    if not tcp_server.clients:
2431
3235
        logger.warning("No clients defined")
2432
 
        
2433
 
    if not debug:
2434
 
        try:
2435
 
            with pidfile:
2436
 
                pid = os.getpid()
2437
 
                pidfile.write(str(pid) + "\n".encode("utf-8"))
2438
 
            del pidfile
2439
 
        except IOError:
2440
 
            logger.error("Could not write to file %r with PID %d",
2441
 
                         pidfilename, pid)
2442
 
        except NameError:
2443
 
            # "pidfile" was never created
2444
 
            pass
 
3236
 
 
3237
    if not foreground:
 
3238
        if pidfile is not None:
 
3239
            pid = os.getpid()
 
3240
            try:
 
3241
                with pidfile:
 
3242
                    print(pid, file=pidfile)
 
3243
            except IOError:
 
3244
                logger.error("Could not write to file %r with PID %d",
 
3245
                             pidfilename, pid)
 
3246
        del pidfile
2445
3247
        del pidfilename
2446
 
        signal.signal(signal.SIGINT, signal.SIG_IGN)
2447
 
    
2448
 
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2449
 
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2450
 
    
 
3248
 
 
3249
    for termsig in (signal.SIGHUP, signal.SIGTERM):
 
3250
        GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
 
3251
                             lambda: main_loop.quit() and False)
 
3252
 
2451
3253
    if use_dbus:
2452
 
        class MandosDBusService(DBusObjectWithProperties):
 
3254
 
 
3255
        @alternate_dbus_interfaces(
 
3256
            {"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
 
3257
        class MandosDBusService(DBusObjectWithObjectManager):
2453
3258
            """A D-Bus proxy object"""
 
3259
 
2454
3260
            def __init__(self):
2455
3261
                dbus.service.Object.__init__(self, bus, "/")
 
3262
 
2456
3263
            _interface = "se.recompile.Mandos"
2457
 
            
2458
 
            @dbus_interface_annotations(_interface)
2459
 
            def _foo(self):
2460
 
                return { "org.freedesktop.DBus.Property"
2461
 
                         ".EmitsChangedSignal":
2462
 
                             "false"}
2463
 
            
 
3264
 
2464
3265
            @dbus.service.signal(_interface, signature="o")
2465
3266
            def ClientAdded(self, objpath):
2466
3267
                "D-Bus signal"
2467
3268
                pass
2468
 
            
 
3269
 
2469
3270
            @dbus.service.signal(_interface, signature="ss")
2470
3271
            def ClientNotFound(self, fingerprint, address):
2471
3272
                "D-Bus signal"
2472
3273
                pass
2473
 
            
 
3274
 
 
3275
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
 
3276
                               "true"})
2474
3277
            @dbus.service.signal(_interface, signature="os")
2475
3278
            def ClientRemoved(self, objpath, name):
2476
3279
                "D-Bus signal"
2477
3280
                pass
2478
 
            
 
3281
 
 
3282
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
 
3283
                               "true"})
2479
3284
            @dbus.service.method(_interface, out_signature="ao")
2480
3285
            def GetAllClients(self):
2481
3286
                "D-Bus method"
2482
 
                return dbus.Array(c.dbus_object_path
2483
 
                                  for c in
2484
 
                                  tcp_server.clients.itervalues())
2485
 
            
 
3287
                return dbus.Array(c.dbus_object_path for c in
 
3288
                                  tcp_server.clients.values())
 
3289
 
 
3290
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
 
3291
                               "true"})
2486
3292
            @dbus.service.method(_interface,
2487
3293
                                 out_signature="a{oa{sv}}")
2488
3294
            def GetAllClientsWithProperties(self):
2489
3295
                "D-Bus method"
2490
3296
                return dbus.Dictionary(
2491
 
                    ((c.dbus_object_path, c.GetAll(""))
2492
 
                     for c in tcp_server.clients.itervalues()),
 
3297
                    {c.dbus_object_path: c.GetAll(
 
3298
                        "se.recompile.Mandos.Client")
 
3299
                     for c in tcp_server.clients.values()},
2493
3300
                    signature="oa{sv}")
2494
 
            
 
3301
 
2495
3302
            @dbus.service.method(_interface, in_signature="o")
2496
3303
            def RemoveClient(self, object_path):
2497
3304
                "D-Bus method"
2498
 
                for c in tcp_server.clients.itervalues():
 
3305
                for c in tcp_server.clients.values():
2499
3306
                    if c.dbus_object_path == object_path:
2500
3307
                        del tcp_server.clients[c.name]
2501
3308
                        c.remove_from_connection()
2502
 
                        # Don't signal anything except ClientRemoved
 
3309
                        # Don't signal the disabling
2503
3310
                        c.disable(quiet=True)
2504
 
                        # Emit D-Bus signal
2505
 
                        self.ClientRemoved(object_path, c.name)
 
3311
                        # Emit D-Bus signal for removal
 
3312
                        self.client_removed_signal(c)
2506
3313
                        return
2507
3314
                raise KeyError(object_path)
2508
 
            
 
3315
 
2509
3316
            del _interface
2510
 
        
2511
 
        class MandosDBusServiceTransitional(MandosDBusService):
2512
 
            __metaclass__ = AlternateDBusNamesMetaclass
2513
 
        mandos_dbus_service = MandosDBusServiceTransitional()
2514
 
    
 
3317
 
 
3318
            @dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
 
3319
                                 out_signature="a{oa{sa{sv}}}")
 
3320
            def GetManagedObjects(self):
 
3321
                """D-Bus method"""
 
3322
                return dbus.Dictionary(
 
3323
                    {client.dbus_object_path:
 
3324
                     dbus.Dictionary(
 
3325
                         {interface: client.GetAll(interface)
 
3326
                          for interface in
 
3327
                          client._get_all_interface_names()})
 
3328
                     for client in tcp_server.clients.values()})
 
3329
 
 
3330
            def client_added_signal(self, client):
 
3331
                """Send the new standard signal and the old signal"""
 
3332
                if use_dbus:
 
3333
                    # New standard signal
 
3334
                    self.InterfacesAdded(
 
3335
                        client.dbus_object_path,
 
3336
                        dbus.Dictionary(
 
3337
                            {interface: client.GetAll(interface)
 
3338
                             for interface in
 
3339
                             client._get_all_interface_names()}))
 
3340
                    # Old signal
 
3341
                    self.ClientAdded(client.dbus_object_path)
 
3342
 
 
3343
            def client_removed_signal(self, client):
 
3344
                """Send the new standard signal and the old signal"""
 
3345
                if use_dbus:
 
3346
                    # New standard signal
 
3347
                    self.InterfacesRemoved(
 
3348
                        client.dbus_object_path,
 
3349
                        client._get_all_interface_names())
 
3350
                    # Old signal
 
3351
                    self.ClientRemoved(client.dbus_object_path,
 
3352
                                       client.name)
 
3353
 
 
3354
        mandos_dbus_service = MandosDBusService()
 
3355
 
 
3356
    # Save modules to variables to exempt the modules from being
 
3357
    # unloaded before the function registered with atexit() is run.
 
3358
    mp = multiprocessing
 
3359
    wn = wnull
 
3360
 
2515
3361
    def cleanup():
2516
3362
        "Cleanup function; run on exit"
2517
 
        service.cleanup()
2518
 
        
2519
 
        multiprocessing.active_children()
 
3363
        if zeroconf:
 
3364
            service.cleanup()
 
3365
 
 
3366
        mp.active_children()
 
3367
        wn.close()
2520
3368
        if not (tcp_server.clients or client_settings):
2521
3369
            return
2522
 
        
 
3370
 
2523
3371
        # Store client before exiting. Secrets are encrypted with key
2524
3372
        # based on what config file has. If config file is
2525
3373
        # removed/edited, old secret will thus be unrecovable.
2526
3374
        clients = {}
2527
3375
        with PGPEngine() as pgp:
2528
 
            for client in tcp_server.clients.itervalues():
 
3376
            for client in tcp_server.clients.values():
2529
3377
                key = client_settings[client.name]["secret"]
2530
3378
                client.encrypted_secret = pgp.encrypt(client.secret,
2531
3379
                                                      key)
2532
3380
                client_dict = {}
2533
 
                
 
3381
 
2534
3382
                # A list of attributes that can not be pickled
2535
3383
                # + secret.
2536
 
                exclude = set(("bus", "changedstate", "secret",
2537
 
                               "checker"))
2538
 
                for name, typ in (inspect.getmembers
2539
 
                                  (dbus.service.Object)):
 
3384
                exclude = {"bus", "changedstate", "secret",
 
3385
                           "checker", "server_settings"}
 
3386
                for name, typ in inspect.getmembers(dbus.service
 
3387
                                                    .Object):
2540
3388
                    exclude.add(name)
2541
 
                
 
3389
 
2542
3390
                client_dict["encrypted_secret"] = (client
2543
3391
                                                   .encrypted_secret)
2544
3392
                for attr in client.client_structure:
2545
3393
                    if attr not in exclude:
2546
3394
                        client_dict[attr] = getattr(client, attr)
2547
 
                
 
3395
 
2548
3396
                clients[client.name] = client_dict
2549
3397
                del client_settings[client.name]["secret"]
2550
 
        
 
3398
 
2551
3399
        try:
2552
 
            tempfd, tempname = tempfile.mkstemp(suffix=".pickle",
2553
 
                                                prefix="clients-",
2554
 
                                                dir=os.path.dirname
2555
 
                                                (stored_state_path))
2556
 
            with os.fdopen(tempfd, "wb") as stored_state:
2557
 
                pickle.dump((clients, client_settings), stored_state)
 
3400
            with tempfile.NamedTemporaryFile(
 
3401
                    mode='wb',
 
3402
                    suffix=".pickle",
 
3403
                    prefix='clients-',
 
3404
                    dir=os.path.dirname(stored_state_path),
 
3405
                    delete=False) as stored_state:
 
3406
                pickle.dump((clients, client_settings), stored_state,
 
3407
                            protocol=2)
 
3408
                tempname = stored_state.name
2558
3409
            os.rename(tempname, stored_state_path)
2559
3410
        except (IOError, OSError) as e:
2560
 
            logger.warning("Could not save persistent state: {0}"
2561
 
                           .format(e))
2562
3411
            if not debug:
2563
3412
                try:
2564
3413
                    os.remove(tempname)
2565
3414
                except NameError:
2566
3415
                    pass
2567
 
            if e.errno not in set((errno.ENOENT, errno.EACCES,
2568
 
                                   errno.EEXIST)):
2569
 
                raise e
2570
 
        
 
3416
            if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
 
3417
                logger.warning("Could not save persistent state: {}"
 
3418
                               .format(os.strerror(e.errno)))
 
3419
            else:
 
3420
                logger.warning("Could not save persistent state:",
 
3421
                               exc_info=e)
 
3422
                raise
 
3423
 
2571
3424
        # Delete all clients, and settings from config
2572
3425
        while tcp_server.clients:
2573
3426
            name, client = tcp_server.clients.popitem()
2574
3427
            if use_dbus:
2575
3428
                client.remove_from_connection()
2576
 
            # Don't signal anything except ClientRemoved
 
3429
            # Don't signal the disabling
2577
3430
            client.disable(quiet=True)
 
3431
            # Emit D-Bus signal for removal
2578
3432
            if use_dbus:
2579
 
                # Emit D-Bus signal
2580
 
                mandos_dbus_service.ClientRemoved(client
2581
 
                                                  .dbus_object_path,
2582
 
                                                  client.name)
 
3433
                mandos_dbus_service.client_removed_signal(client)
2583
3434
        client_settings.clear()
2584
 
    
 
3435
 
2585
3436
    atexit.register(cleanup)
2586
 
    
2587
 
    for client in tcp_server.clients.itervalues():
 
3437
 
 
3438
    for client in tcp_server.clients.values():
2588
3439
        if use_dbus:
2589
 
            # Emit D-Bus signal
2590
 
            mandos_dbus_service.ClientAdded(client.dbus_object_path)
 
3440
            # Emit D-Bus signal for adding
 
3441
            mandos_dbus_service.client_added_signal(client)
2591
3442
        # Need to initiate checking of clients
2592
3443
        if client.enabled:
2593
3444
            client.init_checker()
2594
 
    
 
3445
 
2595
3446
    tcp_server.enable()
2596
3447
    tcp_server.server_activate()
2597
 
    
 
3448
 
2598
3449
    # Find out what port we got
2599
 
    service.port = tcp_server.socket.getsockname()[1]
 
3450
    if zeroconf:
 
3451
        service.port = tcp_server.socket.getsockname()[1]
2600
3452
    if use_ipv6:
2601
3453
        logger.info("Now listening on address %r, port %d,"
2602
 
                    " flowinfo %d, scope_id %d"
2603
 
                    % tcp_server.socket.getsockname())
 
3454
                    " flowinfo %d, scope_id %d",
 
3455
                    *tcp_server.socket.getsockname())
2604
3456
    else:                       # IPv4
2605
 
        logger.info("Now listening on address %r, port %d"
2606
 
                    % tcp_server.socket.getsockname())
2607
 
    
2608
 
    #service.interface = tcp_server.socket.getsockname()[3]
2609
 
    
 
3457
        logger.info("Now listening on address %r, port %d",
 
3458
                    *tcp_server.socket.getsockname())
 
3459
 
 
3460
    # service.interface = tcp_server.socket.getsockname()[3]
 
3461
 
2610
3462
    try:
2611
 
        # From the Avahi example code
2612
 
        try:
2613
 
            service.activate()
2614
 
        except dbus.exceptions.DBusException as error:
2615
 
            logger.critical("D-Bus Exception", exc_info=error)
2616
 
            cleanup()
2617
 
            sys.exit(1)
2618
 
        # End of Avahi example code
2619
 
        
2620
 
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2621
 
                             lambda *args, **kwargs:
2622
 
                             (tcp_server.handle_request
2623
 
                              (*args[2:], **kwargs) or True))
2624
 
        
 
3463
        if zeroconf:
 
3464
            # From the Avahi example code
 
3465
            try:
 
3466
                service.activate()
 
3467
            except dbus.exceptions.DBusException as error:
 
3468
                logger.critical("D-Bus Exception", exc_info=error)
 
3469
                cleanup()
 
3470
                sys.exit(1)
 
3471
            # End of Avahi example code
 
3472
 
 
3473
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
 
3474
                          lambda *args, **kwargs:
 
3475
                          (tcp_server.handle_request
 
3476
                           (*args[2:], **kwargs) or True))
 
3477
 
2625
3478
        logger.debug("Starting main loop")
2626
3479
        main_loop.run()
2627
3480
    except AvahiError as error:
2636
3489
    # Must run before the D-Bus bus name gets deregistered
2637
3490
    cleanup()
2638
3491
 
 
3492
 
2639
3493
if __name__ == '__main__':
2640
3494
    main()