/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: 2015-07-06 20:29:34 UTC
  • mfrom: (738.1.6 route-external)
  • Revision ID: teddy@recompile.se-20150706202934-09j06jm2fiw1bn80
Merge change to add local route when network is "unreachable".

Show diffs side-by-side

added added

removed removed

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