/mandos/release

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2014-08-20 21:46:38 UTC
  • mto: (237.7.304 trunk)
  • mto: This revision was merged to the branch mainline in revision 323.
  • Revision ID: teddy@recompile.se-20140820214638-k4naueej6hffdgfg
mandos-client: Bug fix: Check fork() return value.

When executing network hook scripts, check fork() return value.

* plugins.d/mandos-client.c (run_network_hooks): Bug fix: check if
                                                 fork() returns -1.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#!/usr/bin/python
 
1
#!/usr/bin/python2.7
2
2
# -*- mode: python; coding: utf-8 -*-
3
3
4
4
# Mandos server - give out binary blobs to connecting clients.
11
11
# "AvahiService" class, and some lines in "main".
12
12
13
13
# Everything else is
14
 
# Copyright © 2008-2011 Teddy Hogeborn
15
 
# Copyright © 2008-2011 Björn Påhlsson
 
14
# Copyright © 2008-2014 Teddy Hogeborn
 
15
# Copyright © 2008-2014 Björn Påhlsson
16
16
17
17
# This program is free software: you can redistribute it and/or modify
18
18
# it under the terms of the GNU General Public License as published by
34
34
from __future__ import (division, absolute_import, print_function,
35
35
                        unicode_literals)
36
36
 
 
37
from future_builtins import *
 
38
 
37
39
import SocketServer as socketserver
38
40
import socket
39
41
import argparse
63
65
import cPickle as pickle
64
66
import multiprocessing
65
67
import types
 
68
import binascii
 
69
import tempfile
 
70
import itertools
 
71
import collections
66
72
 
67
73
import dbus
68
74
import dbus.service
82
88
    except ImportError:
83
89
        SO_BINDTODEVICE = None
84
90
 
85
 
 
86
 
version = "1.3.1"
87
 
 
88
 
#logger = logging.getLogger('mandos')
89
 
logger = logging.Logger('mandos')
90
 
syslogger = (logging.handlers.SysLogHandler
91
 
             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
92
 
              address = str("/dev/log")))
93
 
syslogger.setFormatter(logging.Formatter
94
 
                       ('Mandos [%(process)d]: %(levelname)s:'
95
 
                        ' %(message)s'))
96
 
logger.addHandler(syslogger)
97
 
 
98
 
console = logging.StreamHandler()
99
 
console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'
100
 
                                       ' %(levelname)s:'
101
 
                                       ' %(message)s'))
102
 
logger.addHandler(console)
 
91
if sys.version_info.major == 2:
 
92
    str = unicode
 
93
 
 
94
version = "1.6.8"
 
95
stored_state_file = "clients.pickle"
 
96
 
 
97
logger = logging.getLogger()
 
98
syslogger = None
 
99
 
 
100
try:
 
101
    if_nametoindex = (ctypes.cdll.LoadLibrary
 
102
                      (ctypes.util.find_library("c"))
 
103
                      .if_nametoindex)
 
104
except (OSError, AttributeError):
 
105
    def if_nametoindex(interface):
 
106
        "Get an interface index the hard way, i.e. using fcntl()"
 
107
        SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
 
108
        with contextlib.closing(socket.socket()) as s:
 
109
            ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
 
110
                                struct.pack(b"16s16x", interface))
 
111
        interface_index = struct.unpack("I", ifreq[16:20])[0]
 
112
        return interface_index
 
113
 
 
114
 
 
115
def initlogger(debug, level=logging.WARNING):
 
116
    """init logger and add loglevel"""
 
117
    
 
118
    global syslogger
 
119
    syslogger = (logging.handlers.SysLogHandler
 
120
                 (facility =
 
121
                  logging.handlers.SysLogHandler.LOG_DAEMON,
 
122
                  address = "/dev/log"))
 
123
    syslogger.setFormatter(logging.Formatter
 
124
                           ('Mandos [%(process)d]: %(levelname)s:'
 
125
                            ' %(message)s'))
 
126
    logger.addHandler(syslogger)
 
127
    
 
128
    if debug:
 
129
        console = logging.StreamHandler()
 
130
        console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
 
131
                                               ' [%(process)d]:'
 
132
                                               ' %(levelname)s:'
 
133
                                               ' %(message)s'))
 
134
        logger.addHandler(console)
 
135
    logger.setLevel(level)
 
136
 
 
137
 
 
138
class PGPError(Exception):
 
139
    """Exception if encryption/decryption fails"""
 
140
    pass
 
141
 
 
142
 
 
143
class PGPEngine(object):
 
144
    """A simple class for OpenPGP symmetric encryption & decryption"""
 
145
    def __init__(self):
 
146
        self.tempdir = tempfile.mkdtemp(prefix="mandos-")
 
147
        self.gnupgargs = ['--batch',
 
148
                          '--home', self.tempdir,
 
149
                          '--force-mdc',
 
150
                          '--quiet',
 
151
                          '--no-use-agent']
 
152
    
 
153
    def __enter__(self):
 
154
        return self
 
155
    
 
156
    def __exit__(self, exc_type, exc_value, traceback):
 
157
        self._cleanup()
 
158
        return False
 
159
    
 
160
    def __del__(self):
 
161
        self._cleanup()
 
162
    
 
163
    def _cleanup(self):
 
164
        if self.tempdir is not None:
 
165
            # Delete contents of tempdir
 
166
            for root, dirs, files in os.walk(self.tempdir,
 
167
                                             topdown = False):
 
168
                for filename in files:
 
169
                    os.remove(os.path.join(root, filename))
 
170
                for dirname in dirs:
 
171
                    os.rmdir(os.path.join(root, dirname))
 
172
            # Remove tempdir
 
173
            os.rmdir(self.tempdir)
 
174
            self.tempdir = None
 
175
    
 
176
    def password_encode(self, password):
 
177
        # Passphrase can not be empty and can not contain newlines or
 
178
        # NUL bytes.  So we prefix it and hex encode it.
 
179
        encoded = b"mandos" + binascii.hexlify(password)
 
180
        if len(encoded) > 2048:
 
181
            # GnuPG can't handle long passwords, so encode differently
 
182
            encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
 
183
                       .replace(b"\n", b"\\n")
 
184
                       .replace(b"\0", b"\\x00"))
 
185
        return encoded
 
186
    
 
187
    def encrypt(self, data, password):
 
188
        passphrase = self.password_encode(password)
 
189
        with tempfile.NamedTemporaryFile(dir=self.tempdir
 
190
                                         ) as passfile:
 
191
            passfile.write(passphrase)
 
192
            passfile.flush()
 
193
            proc = subprocess.Popen(['gpg', '--symmetric',
 
194
                                     '--passphrase-file',
 
195
                                     passfile.name]
 
196
                                    + self.gnupgargs,
 
197
                                    stdin = subprocess.PIPE,
 
198
                                    stdout = subprocess.PIPE,
 
199
                                    stderr = subprocess.PIPE)
 
200
            ciphertext, err = proc.communicate(input = data)
 
201
        if proc.returncode != 0:
 
202
            raise PGPError(err)
 
203
        return ciphertext
 
204
    
 
205
    def decrypt(self, data, password):
 
206
        passphrase = self.password_encode(password)
 
207
        with tempfile.NamedTemporaryFile(dir = self.tempdir
 
208
                                         ) as passfile:
 
209
            passfile.write(passphrase)
 
210
            passfile.flush()
 
211
            proc = subprocess.Popen(['gpg', '--decrypt',
 
212
                                     '--passphrase-file',
 
213
                                     passfile.name]
 
214
                                    + self.gnupgargs,
 
215
                                    stdin = subprocess.PIPE,
 
216
                                    stdout = subprocess.PIPE,
 
217
                                    stderr = subprocess.PIPE)
 
218
            decrypted_plaintext, err = proc.communicate(input
 
219
                                                        = data)
 
220
        if proc.returncode != 0:
 
221
            raise PGPError(err)
 
222
        return decrypted_plaintext
 
223
 
103
224
 
104
225
class AvahiError(Exception):
105
226
    def __init__(self, value, *args, **kwargs):
106
227
        self.value = value
107
 
        super(AvahiError, self).__init__(value, *args, **kwargs)
108
 
    def __unicode__(self):
109
 
        return unicode(repr(self.value))
 
228
        return super(AvahiError, self).__init__(value, *args,
 
229
                                                **kwargs)
110
230
 
111
231
class AvahiServiceError(AvahiError):
112
232
    pass
123
243
               Used to optionally bind to the specified interface.
124
244
    name: string; Example: 'Mandos'
125
245
    type: string; Example: '_mandos._tcp'.
126
 
                  See <http://www.dns-sd.org/ServiceTypes.html>
 
246
     See <https://www.iana.org/assignments/service-names-port-numbers>
127
247
    port: integer; what port to announce
128
248
    TXT: list of strings; TXT record for the service
129
249
    domain: string; Domain to publish on, default to .local if empty.
135
255
    server: D-Bus Server
136
256
    bus: dbus.SystemBus()
137
257
    """
 
258
    
138
259
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
139
260
                 servicetype = None, port = None, TXT = None,
140
261
                 domain = "", host = "", max_renames = 32768,
153
274
        self.server = None
154
275
        self.bus = bus
155
276
        self.entry_group_state_changed_match = None
 
277
    
156
278
    def rename(self):
157
279
        """Derived from the Avahi example code"""
158
280
        if self.rename_count >= self.max_renames:
160
282
                            " after %i retries, exiting.",
161
283
                            self.rename_count)
162
284
            raise AvahiServiceError("Too many renames")
163
 
        self.name = unicode(self.server.GetAlternativeServiceName(self.name))
 
285
        self.name = str(self.server
 
286
                        .GetAlternativeServiceName(self.name))
164
287
        logger.info("Changing Zeroconf service name to %r ...",
165
288
                    self.name)
166
 
        syslogger.setFormatter(logging.Formatter
167
 
                               ('Mandos (%s) [%%(process)d]:'
168
 
                                ' %%(levelname)s: %%(message)s'
169
 
                                % self.name))
170
289
        self.remove()
171
290
        try:
172
291
            self.add()
173
292
        except dbus.exceptions.DBusException as error:
174
 
            logger.critical("DBusException: %s", error)
 
293
            logger.critical("D-Bus Exception", exc_info=error)
175
294
            self.cleanup()
176
295
            os._exit(1)
177
296
        self.rename_count += 1
 
297
    
178
298
    def remove(self):
179
299
        """Derived from the Avahi example code"""
180
300
        if self.entry_group_state_changed_match is not None:
182
302
            self.entry_group_state_changed_match = None
183
303
        if self.group is not None:
184
304
            self.group.Reset()
 
305
    
185
306
    def add(self):
186
307
        """Derived from the Avahi example code"""
187
308
        self.remove()
192
313
                avahi.DBUS_INTERFACE_ENTRY_GROUP)
193
314
        self.entry_group_state_changed_match = (
194
315
            self.group.connect_to_signal(
195
 
                'StateChanged', self .entry_group_state_changed))
 
316
                'StateChanged', self.entry_group_state_changed))
196
317
        logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
197
318
                     self.name, self.type)
198
319
        self.group.AddService(
204
325
            dbus.UInt16(self.port),
205
326
            avahi.string_array_to_txt_array(self.TXT))
206
327
        self.group.Commit()
 
328
    
207
329
    def entry_group_state_changed(self, state, error):
208
330
        """Derived from the Avahi example code"""
209
331
        logger.debug("Avahi entry group state change: %i", state)
215
337
            self.rename()
216
338
        elif state == avahi.ENTRY_GROUP_FAILURE:
217
339
            logger.critical("Avahi: Error in group state changed %s",
218
 
                            unicode(error))
219
 
            raise AvahiGroupError("State changed: %s"
220
 
                                  % unicode(error))
 
340
                            str(error))
 
341
            raise AvahiGroupError("State changed: {!s}"
 
342
                                  .format(error))
 
343
    
221
344
    def cleanup(self):
222
345
        """Derived from the Avahi example code"""
223
346
        if self.group is not None:
224
347
            try:
225
348
                self.group.Free()
226
349
            except (dbus.exceptions.UnknownMethodException,
227
 
                    dbus.exceptions.DBusException) as e:
 
350
                    dbus.exceptions.DBusException):
228
351
                pass
229
352
            self.group = None
230
353
        self.remove()
 
354
    
231
355
    def server_state_changed(self, state, error=None):
232
356
        """Derived from the Avahi example code"""
233
357
        logger.debug("Avahi server state change: %i", state)
252
376
                logger.debug("Unknown state: %r", state)
253
377
            else:
254
378
                logger.debug("Unknown state: %r: %r", state, error)
 
379
    
255
380
    def activate(self):
256
381
        """Derived from the Avahi example code"""
257
382
        if self.server is None:
265
390
        self.server_state_changed(self.server.GetState())
266
391
 
267
392
 
268
 
def _timedelta_to_milliseconds(td):
269
 
    "Convert a datetime.timedelta() to milliseconds"
270
 
    return ((td.days * 24 * 60 * 60 * 1000)
271
 
            + (td.seconds * 1000)
272
 
            + (td.microseconds // 1000))
273
 
        
 
393
class AvahiServiceToSyslog(AvahiService):
 
394
    def rename(self):
 
395
        """Add the new name to the syslog messages"""
 
396
        ret = AvahiService.rename(self)
 
397
        syslogger.setFormatter(logging.Formatter
 
398
                               ('Mandos ({}) [%(process)d]:'
 
399
                                ' %(levelname)s: %(message)s'
 
400
                                .format(self.name)))
 
401
        return ret
 
402
 
 
403
 
274
404
class Client(object):
275
405
    """A representation of a client host served by this server.
276
406
    
277
407
    Attributes:
278
 
    _approved:   bool(); 'None' if not yet approved/disapproved
 
408
    approved:   bool(); 'None' if not yet approved/disapproved
279
409
    approval_delay: datetime.timedelta(); Time to wait for approval
280
410
    approval_duration: datetime.timedelta(); Duration of one approval
281
411
    checker:    subprocess.Popen(); a running checker process used
288
418
                     instance %(name)s can be used in the command.
289
419
    checker_initiator_tag: a gobject event source tag, or None
290
420
    created:    datetime.datetime(); (UTC) object creation
 
421
    client_structure: Object describing what attributes a client has
 
422
                      and is used for storing the client at exit
291
423
    current_checker_command: string; current running checker_command
292
 
    disable_hook:  If set, called by disable() as disable_hook(self)
293
424
    disable_initiator_tag: a gobject event source tag, or None
294
425
    enabled:    bool()
295
426
    fingerprint: string (40 or 32 hexadecimal digits); used to
298
429
    interval:   datetime.timedelta(); How often to start a new checker
299
430
    last_approval_request: datetime.datetime(); (UTC) or None
300
431
    last_checked_ok: datetime.datetime(); (UTC) or None
301
 
    last_enabled: datetime.datetime(); (UTC)
 
432
    last_checker_status: integer between 0 and 255 reflecting exit
 
433
                         status of last checker. -1 reflects crashed
 
434
                         checker, -2 means no checker completed yet.
 
435
    last_enabled: datetime.datetime(); (UTC) or None
302
436
    name:       string; from the config file, used in log messages and
303
437
                        D-Bus identifiers
304
438
    secret:     bytestring; sent verbatim (over TLS) to client
305
439
    timeout:    datetime.timedelta(); How long from last_checked_ok
306
440
                                      until this client is disabled
307
 
    extended_timeout:   extra long timeout when password has been sent
 
441
    extended_timeout:   extra long timeout when secret has been sent
308
442
    runtime_expansions: Allowed attributes for runtime expansion.
309
443
    expires:    datetime.datetime(); time (UTC) when a client will be
310
444
                disabled, or None
 
445
    server_settings: The server_settings dict from main()
311
446
    """
312
447
    
313
448
    runtime_expansions = ("approval_delay", "approval_duration",
314
 
                          "created", "enabled", "fingerprint",
315
 
                          "host", "interval", "last_checked_ok",
 
449
                          "created", "enabled", "expires",
 
450
                          "fingerprint", "host", "interval",
 
451
                          "last_approval_request", "last_checked_ok",
316
452
                          "last_enabled", "name", "timeout")
317
 
    
318
 
    def timeout_milliseconds(self):
319
 
        "Return the 'timeout' attribute in milliseconds"
320
 
        return _timedelta_to_milliseconds(self.timeout)
321
 
    
322
 
    def extended_timeout_milliseconds(self):
323
 
        "Return the 'extended_timeout' attribute in milliseconds"
324
 
        return _timedelta_to_milliseconds(self.extended_timeout)    
325
 
    
326
 
    def interval_milliseconds(self):
327
 
        "Return the 'interval' attribute in milliseconds"
328
 
        return _timedelta_to_milliseconds(self.interval)
329
 
    
330
 
    def approval_delay_milliseconds(self):
331
 
        return _timedelta_to_milliseconds(self.approval_delay)
332
 
    
333
 
    def __init__(self, name = None, disable_hook=None, config=None):
334
 
        """Note: the 'checker' key in 'config' sets the
335
 
        'checker_command' attribute and *not* the 'checker'
336
 
        attribute."""
 
453
    client_defaults = { "timeout": "PT5M",
 
454
                        "extended_timeout": "PT15M",
 
455
                        "interval": "PT2M",
 
456
                        "checker": "fping -q -- %%(host)s",
 
457
                        "host": "",
 
458
                        "approval_delay": "PT0S",
 
459
                        "approval_duration": "PT1S",
 
460
                        "approved_by_default": "True",
 
461
                        "enabled": "True",
 
462
                        }
 
463
    
 
464
    @staticmethod
 
465
    def config_parser(config):
 
466
        """Construct a new dict of client settings of this form:
 
467
        { client_name: {setting_name: value, ...}, ...}
 
468
        with exceptions for any special settings as defined above.
 
469
        NOTE: Must be a pure function. Must return the same result
 
470
        value given the same arguments.
 
471
        """
 
472
        settings = {}
 
473
        for client_name in config.sections():
 
474
            section = dict(config.items(client_name))
 
475
            client = settings[client_name] = {}
 
476
            
 
477
            client["host"] = section["host"]
 
478
            # Reformat values from string types to Python types
 
479
            client["approved_by_default"] = config.getboolean(
 
480
                client_name, "approved_by_default")
 
481
            client["enabled"] = config.getboolean(client_name,
 
482
                                                  "enabled")
 
483
            
 
484
            client["fingerprint"] = (section["fingerprint"].upper()
 
485
                                     .replace(" ", ""))
 
486
            if "secret" in section:
 
487
                client["secret"] = section["secret"].decode("base64")
 
488
            elif "secfile" in section:
 
489
                with open(os.path.expanduser(os.path.expandvars
 
490
                                             (section["secfile"])),
 
491
                          "rb") as secfile:
 
492
                    client["secret"] = secfile.read()
 
493
            else:
 
494
                raise TypeError("No secret or secfile for section {}"
 
495
                                .format(section))
 
496
            client["timeout"] = string_to_delta(section["timeout"])
 
497
            client["extended_timeout"] = string_to_delta(
 
498
                section["extended_timeout"])
 
499
            client["interval"] = string_to_delta(section["interval"])
 
500
            client["approval_delay"] = string_to_delta(
 
501
                section["approval_delay"])
 
502
            client["approval_duration"] = string_to_delta(
 
503
                section["approval_duration"])
 
504
            client["checker_command"] = section["checker"]
 
505
            client["last_approval_request"] = None
 
506
            client["last_checked_ok"] = None
 
507
            client["last_checker_status"] = -2
 
508
        
 
509
        return settings
 
510
    
 
511
    def __init__(self, settings, name = None, server_settings=None):
337
512
        self.name = name
338
 
        if config is None:
339
 
            config = {}
 
513
        if server_settings is None:
 
514
            server_settings = {}
 
515
        self.server_settings = server_settings
 
516
        # adding all client settings
 
517
        for setting, value in settings.items():
 
518
            setattr(self, setting, value)
 
519
        
 
520
        if self.enabled:
 
521
            if not hasattr(self, "last_enabled"):
 
522
                self.last_enabled = datetime.datetime.utcnow()
 
523
            if not hasattr(self, "expires"):
 
524
                self.expires = (datetime.datetime.utcnow()
 
525
                                + self.timeout)
 
526
        else:
 
527
            self.last_enabled = None
 
528
            self.expires = None
 
529
        
340
530
        logger.debug("Creating client %r", self.name)
341
531
        # Uppercase and remove spaces from fingerprint for later
342
532
        # comparison purposes with return value from the fingerprint()
343
533
        # function
344
 
        self.fingerprint = (config["fingerprint"].upper()
345
 
                            .replace(" ", ""))
346
534
        logger.debug("  Fingerprint: %s", self.fingerprint)
347
 
        if "secret" in config:
348
 
            self.secret = config["secret"].decode("base64")
349
 
        elif "secfile" in config:
350
 
            with open(os.path.expanduser(os.path.expandvars
351
 
                                         (config["secfile"])),
352
 
                      "rb") as secfile:
353
 
                self.secret = secfile.read()
354
 
        else:
355
 
            raise TypeError("No secret or secfile for client %s"
356
 
                            % self.name)
357
 
        self.host = config.get("host", "")
358
 
        self.created = datetime.datetime.utcnow()
359
 
        self.enabled = False
360
 
        self.last_approval_request = None
361
 
        self.last_enabled = None
362
 
        self.last_checked_ok = None
363
 
        self.timeout = string_to_delta(config["timeout"])
364
 
        self.extended_timeout = string_to_delta(config["extended_timeout"])
365
 
        self.interval = string_to_delta(config["interval"])
366
 
        self.disable_hook = disable_hook
 
535
        self.created = settings.get("created",
 
536
                                    datetime.datetime.utcnow())
 
537
        
 
538
        # attributes specific for this server instance
367
539
        self.checker = None
368
540
        self.checker_initiator_tag = None
369
541
        self.disable_initiator_tag = None
370
 
        self.expires = None
371
542
        self.checker_callback_tag = None
372
 
        self.checker_command = config["checker"]
373
543
        self.current_checker_command = None
374
 
        self.last_connect = None
375
 
        self._approved = None
376
 
        self.approved_by_default = config.get("approved_by_default",
377
 
                                              True)
 
544
        self.approved = None
378
545
        self.approvals_pending = 0
379
 
        self.approval_delay = string_to_delta(
380
 
            config["approval_delay"])
381
 
        self.approval_duration = string_to_delta(
382
 
            config["approval_duration"])
383
 
        self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
 
546
        self.changedstate = (multiprocessing_manager
 
547
                             .Condition(multiprocessing_manager
 
548
                                        .Lock()))
 
549
        self.client_structure = [attr for attr in
 
550
                                 self.__dict__.iterkeys()
 
551
                                 if not attr.startswith("_")]
 
552
        self.client_structure.append("client_structure")
 
553
        
 
554
        for name, t in inspect.getmembers(type(self),
 
555
                                          lambda obj:
 
556
                                              isinstance(obj,
 
557
                                                         property)):
 
558
            if not name.startswith("_"):
 
559
                self.client_structure.append(name)
384
560
    
 
561
    # Send notice to process children that client state has changed
385
562
    def send_changedstate(self):
386
 
        self.changedstate.acquire()
387
 
        self.changedstate.notify_all()
388
 
        self.changedstate.release()
389
 
        
 
563
        with self.changedstate:
 
564
            self.changedstate.notify_all()
 
565
    
390
566
    def enable(self):
391
567
        """Start this client's checker and timeout hooks"""
392
568
        if getattr(self, "enabled", False):
393
569
            # Already enabled
394
570
            return
395
 
        self.send_changedstate()
396
 
        # Schedule a new checker to be started an 'interval' from now,
397
 
        # and every interval from then on.
398
 
        self.checker_initiator_tag = (gobject.timeout_add
399
 
                                      (self.interval_milliseconds(),
400
 
                                       self.start_checker))
401
 
        # Schedule a disable() when 'timeout' has passed
402
571
        self.expires = datetime.datetime.utcnow() + self.timeout
403
 
        self.disable_initiator_tag = (gobject.timeout_add
404
 
                                   (self.timeout_milliseconds(),
405
 
                                    self.disable))
406
572
        self.enabled = True
407
573
        self.last_enabled = datetime.datetime.utcnow()
408
 
        # Also start a new checker *right now*.
409
 
        self.start_checker()
 
574
        self.init_checker()
 
575
        self.send_changedstate()
410
576
    
411
577
    def disable(self, quiet=True):
412
578
        """Disable this client."""
413
579
        if not getattr(self, "enabled", False):
414
580
            return False
415
581
        if not quiet:
416
 
            self.send_changedstate()
417
 
        if not quiet:
418
582
            logger.info("Disabling client %s", self.name)
419
 
        if getattr(self, "disable_initiator_tag", False):
 
583
        if getattr(self, "disable_initiator_tag", None) is not None:
420
584
            gobject.source_remove(self.disable_initiator_tag)
421
585
            self.disable_initiator_tag = None
422
586
        self.expires = None
423
 
        if getattr(self, "checker_initiator_tag", False):
 
587
        if getattr(self, "checker_initiator_tag", None) is not None:
424
588
            gobject.source_remove(self.checker_initiator_tag)
425
589
            self.checker_initiator_tag = None
426
590
        self.stop_checker()
427
 
        if self.disable_hook:
428
 
            self.disable_hook(self)
429
591
        self.enabled = False
 
592
        if not quiet:
 
593
            self.send_changedstate()
430
594
        # Do not run this again if called by a gobject.timeout_add
431
595
        return False
432
596
    
433
597
    def __del__(self):
434
 
        self.disable_hook = None
435
598
        self.disable()
436
599
    
 
600
    def init_checker(self):
 
601
        # Schedule a new checker to be started an 'interval' from now,
 
602
        # and every interval from then on.
 
603
        if self.checker_initiator_tag is not None:
 
604
            gobject.source_remove(self.checker_initiator_tag)
 
605
        self.checker_initiator_tag = (gobject.timeout_add
 
606
                                      (int(self.interval
 
607
                                           .total_seconds() * 1000),
 
608
                                       self.start_checker))
 
609
        # Schedule a disable() when 'timeout' has passed
 
610
        if self.disable_initiator_tag is not None:
 
611
            gobject.source_remove(self.disable_initiator_tag)
 
612
        self.disable_initiator_tag = (gobject.timeout_add
 
613
                                      (int(self.timeout
 
614
                                           .total_seconds() * 1000),
 
615
                                       self.disable))
 
616
        # Also start a new checker *right now*.
 
617
        self.start_checker()
 
618
    
437
619
    def checker_callback(self, pid, condition, command):
438
620
        """The checker has completed, so take appropriate actions."""
439
621
        self.checker_callback_tag = None
440
622
        self.checker = None
441
623
        if os.WIFEXITED(condition):
442
 
            exitstatus = os.WEXITSTATUS(condition)
443
 
            if exitstatus == 0:
 
624
            self.last_checker_status = os.WEXITSTATUS(condition)
 
625
            if self.last_checker_status == 0:
444
626
                logger.info("Checker for %(name)s succeeded",
445
627
                            vars(self))
446
628
                self.checked_ok()
448
630
                logger.info("Checker for %(name)s failed",
449
631
                            vars(self))
450
632
        else:
 
633
            self.last_checker_status = -1
451
634
            logger.warning("Checker for %(name)s crashed?",
452
635
                           vars(self))
453
636
    
454
 
    def checked_ok(self, timeout=None):
455
 
        """Bump up the timeout for this client.
456
 
        
457
 
        This should only be called when the client has been seen,
458
 
        alive and well.
459
 
        """
 
637
    def checked_ok(self):
 
638
        """Assert that the client has been seen, alive and well."""
 
639
        self.last_checked_ok = datetime.datetime.utcnow()
 
640
        self.last_checker_status = 0
 
641
        self.bump_timeout()
 
642
    
 
643
    def bump_timeout(self, timeout=None):
 
644
        """Bump up the timeout for this client."""
460
645
        if timeout is None:
461
646
            timeout = self.timeout
462
 
        self.last_checked_ok = datetime.datetime.utcnow()
463
 
        gobject.source_remove(self.disable_initiator_tag)
464
 
        self.expires = datetime.datetime.utcnow() + timeout
465
 
        self.disable_initiator_tag = (gobject.timeout_add
466
 
                                      (_timedelta_to_milliseconds(timeout),
467
 
                                       self.disable))
 
647
        if self.disable_initiator_tag is not None:
 
648
            gobject.source_remove(self.disable_initiator_tag)
 
649
            self.disable_initiator_tag = None
 
650
        if getattr(self, "enabled", False):
 
651
            self.disable_initiator_tag = (gobject.timeout_add
 
652
                                          (int(timeout.total_seconds()
 
653
                                               * 1000), self.disable))
 
654
            self.expires = datetime.datetime.utcnow() + timeout
468
655
    
469
656
    def need_approval(self):
470
657
        self.last_approval_request = datetime.datetime.utcnow()
475
662
        If a checker already exists, leave it running and do
476
663
        nothing."""
477
664
        # The reason for not killing a running checker is that if we
478
 
        # did that, then if a checker (for some reason) started
479
 
        # running slowly and taking more than 'interval' time, the
480
 
        # client would inevitably timeout, since no checker would get
481
 
        # a chance to run to completion.  If we instead leave running
 
665
        # did that, and if a checker (for some reason) started running
 
666
        # slowly and taking more than 'interval' time, then the client
 
667
        # would inevitably timeout, since no checker would get a
 
668
        # chance to run to completion.  If we instead leave running
482
669
        # checkers alone, the checker would have to take more time
483
670
        # than 'timeout' for the client to be disabled, which is as it
484
671
        # should be.
486
673
        # If a checker exists, make sure it is not a zombie
487
674
        try:
488
675
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
489
 
        except (AttributeError, OSError) as error:
490
 
            if (isinstance(error, OSError)
491
 
                and error.errno != errno.ECHILD):
492
 
                raise error
 
676
        except AttributeError:
 
677
            pass
 
678
        except OSError as error:
 
679
            if error.errno != errno.ECHILD:
 
680
                raise
493
681
        else:
494
682
            if pid:
495
683
                logger.warning("Checker was a zombie")
498
686
                                      self.current_checker_command)
499
687
        # Start a new checker if needed
500
688
        if self.checker is None:
 
689
            # Escape attributes for the shell
 
690
            escaped_attrs = { attr:
 
691
                                  re.escape(str(getattr(self, attr)))
 
692
                              for attr in self.runtime_expansions }
501
693
            try:
502
 
                # In case checker_command has exactly one % operator
503
 
                command = self.checker_command % self.host
504
 
            except TypeError:
505
 
                # Escape attributes for the shell
506
 
                escaped_attrs = dict(
507
 
                    (attr,
508
 
                     re.escape(unicode(str(getattr(self, attr, "")),
509
 
                                       errors=
510
 
                                       'replace')))
511
 
                    for attr in
512
 
                    self.runtime_expansions)
513
 
                
514
 
                try:
515
 
                    command = self.checker_command % escaped_attrs
516
 
                except TypeError as error:
517
 
                    logger.error('Could not format string "%s":'
518
 
                                 ' %s', self.checker_command, error)
519
 
                    return True # Try again later
 
694
                command = self.checker_command % escaped_attrs
 
695
            except TypeError as error:
 
696
                logger.error('Could not format string "%s"',
 
697
                             self.checker_command, exc_info=error)
 
698
                return True # Try again later
520
699
            self.current_checker_command = command
521
700
            try:
522
701
                logger.info("Starting checker %r for %s",
525
704
                # in normal mode, that is already done by daemon(),
526
705
                # and in debug mode we don't want to.  (Stdin is
527
706
                # always replaced by /dev/null.)
 
707
                # The exception is when not debugging but nevertheless
 
708
                # running in the foreground; use the previously
 
709
                # created wnull.
 
710
                popen_args = {}
 
711
                if (not self.server_settings["debug"]
 
712
                    and self.server_settings["foreground"]):
 
713
                    popen_args.update({"stdout": wnull,
 
714
                                       "stderr": wnull })
528
715
                self.checker = subprocess.Popen(command,
529
716
                                                close_fds=True,
530
 
                                                shell=True, cwd="/")
531
 
                self.checker_callback_tag = (gobject.child_watch_add
532
 
                                             (self.checker.pid,
533
 
                                              self.checker_callback,
534
 
                                              data=command))
535
 
                # The checker may have completed before the gobject
536
 
                # watch was added.  Check for this.
 
717
                                                shell=True, cwd="/",
 
718
                                                **popen_args)
 
719
            except OSError as error:
 
720
                logger.error("Failed to start subprocess",
 
721
                             exc_info=error)
 
722
                return True
 
723
            self.checker_callback_tag = (gobject.child_watch_add
 
724
                                         (self.checker.pid,
 
725
                                          self.checker_callback,
 
726
                                          data=command))
 
727
            # The checker may have completed before the gobject
 
728
            # watch was added.  Check for this.
 
729
            try:
537
730
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
538
 
                if pid:
539
 
                    gobject.source_remove(self.checker_callback_tag)
540
 
                    self.checker_callback(pid, status, command)
541
731
            except OSError as error:
542
 
                logger.error("Failed to start subprocess: %s",
543
 
                             error)
 
732
                if error.errno == errno.ECHILD:
 
733
                    # This should never happen
 
734
                    logger.error("Child process vanished",
 
735
                                 exc_info=error)
 
736
                    return True
 
737
                raise
 
738
            if pid:
 
739
                gobject.source_remove(self.checker_callback_tag)
 
740
                self.checker_callback(pid, status, command)
544
741
        # Re-run this periodically if run by gobject.timeout_add
545
742
        return True
546
743
    
553
750
            return
554
751
        logger.debug("Stopping checker for %(name)s", vars(self))
555
752
        try:
556
 
            os.kill(self.checker.pid, signal.SIGTERM)
 
753
            self.checker.terminate()
557
754
            #time.sleep(0.5)
558
755
            #if self.checker.poll() is None:
559
 
            #    os.kill(self.checker.pid, signal.SIGKILL)
 
756
            #    self.checker.kill()
560
757
        except OSError as error:
561
758
            if error.errno != errno.ESRCH: # No such process
562
759
                raise
579
776
    # "Set" method, so we fail early here:
580
777
    if byte_arrays and signature != "ay":
581
778
        raise ValueError("Byte arrays not supported for non-'ay'"
582
 
                         " signature %r" % signature)
 
779
                         " signature {!r}".format(signature))
583
780
    def decorator(func):
584
781
        func._dbus_is_property = True
585
782
        func._dbus_interface = dbus_interface
593
790
    return decorator
594
791
 
595
792
 
 
793
def dbus_interface_annotations(dbus_interface):
 
794
    """Decorator for marking functions returning interface annotations
 
795
    
 
796
    Usage:
 
797
    
 
798
    @dbus_interface_annotations("org.example.Interface")
 
799
    def _foo(self):  # Function name does not matter
 
800
        return {"org.freedesktop.DBus.Deprecated": "true",
 
801
                "org.freedesktop.DBus.Property.EmitsChangedSignal":
 
802
                    "false"}
 
803
    """
 
804
    def decorator(func):
 
805
        func._dbus_is_interface = True
 
806
        func._dbus_interface = dbus_interface
 
807
        func._dbus_name = dbus_interface
 
808
        return func
 
809
    return decorator
 
810
 
 
811
 
 
812
def dbus_annotations(annotations):
 
813
    """Decorator to annotate D-Bus methods, signals or properties
 
814
    Usage:
 
815
    
 
816
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
 
817
                       "org.freedesktop.DBus.Property."
 
818
                       "EmitsChangedSignal": "false"})
 
819
    @dbus_service_property("org.example.Interface", signature="b",
 
820
                           access="r")
 
821
    def Property_dbus_property(self):
 
822
        return dbus.Boolean(False)
 
823
    """
 
824
    def decorator(func):
 
825
        func._dbus_annotations = annotations
 
826
        return func
 
827
    return decorator
 
828
 
 
829
 
596
830
class DBusPropertyException(dbus.exceptions.DBusException):
597
831
    """A base class for D-Bus property-related exceptions
598
832
    """
599
 
    def __unicode__(self):
600
 
        return unicode(str(self))
601
 
 
 
833
    pass
602
834
 
603
835
class DBusPropertyAccessException(DBusPropertyException):
604
836
    """A property's access permissions disallows an operation.
621
853
    """
622
854
    
623
855
    @staticmethod
624
 
    def _is_dbus_property(obj):
625
 
        return getattr(obj, "_dbus_is_property", False)
 
856
    def _is_dbus_thing(thing):
 
857
        """Returns a function testing if an attribute is a D-Bus thing
 
858
        
 
859
        If called like _is_dbus_thing("method") it returns a function
 
860
        suitable for use as predicate to inspect.getmembers().
 
861
        """
 
862
        return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
 
863
                                   False)
626
864
    
627
 
    def _get_all_dbus_properties(self):
 
865
    def _get_all_dbus_things(self, thing):
628
866
        """Returns a generator of (name, attribute) pairs
629
867
        """
630
 
        return ((prop.__get__(self)._dbus_name, prop.__get__(self))
 
868
        return ((getattr(athing.__get__(self), "_dbus_name",
 
869
                         name),
 
870
                 athing.__get__(self))
631
871
                for cls in self.__class__.__mro__
632
 
                for name, prop in inspect.getmembers(cls, self._is_dbus_property))
 
872
                for name, athing in
 
873
                inspect.getmembers(cls,
 
874
                                   self._is_dbus_thing(thing)))
633
875
    
634
876
    def _get_dbus_property(self, interface_name, property_name):
635
877
        """Returns a bound method if one exists which is a D-Bus
636
878
        property with the specified name and interface.
637
879
        """
638
880
        for cls in  self.__class__.__mro__:
639
 
            for name, value in inspect.getmembers(cls, self._is_dbus_property):
640
 
                if value._dbus_name == property_name and value._dbus_interface == interface_name:
 
881
            for name, value in (inspect.getmembers
 
882
                                (cls,
 
883
                                 self._is_dbus_thing("property"))):
 
884
                if (value._dbus_name == property_name
 
885
                    and value._dbus_interface == interface_name):
641
886
                    return value.__get__(self)
642
887
        
643
888
        # No such property
669
914
            # The byte_arrays option is not supported yet on
670
915
            # signatures other than "ay".
671
916
            if prop._dbus_signature != "ay":
672
 
                raise ValueError
673
 
            value = dbus.ByteArray(''.join(unichr(byte)
674
 
                                           for byte in value))
 
917
                raise ValueError("Byte arrays not supported for non-"
 
918
                                 "'ay' signature {!r}"
 
919
                                 .format(prop._dbus_signature))
 
920
            value = dbus.ByteArray(b''.join(chr(byte)
 
921
                                            for byte in value))
675
922
        prop(value)
676
923
    
677
924
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
682
929
        
683
930
        Note: Will not include properties with access="write".
684
931
        """
685
 
        all = {}
686
 
        for name, prop in self._get_all_dbus_properties():
 
932
        properties = {}
 
933
        for name, prop in self._get_all_dbus_things("property"):
687
934
            if (interface_name
688
935
                and interface_name != prop._dbus_interface):
689
936
                # Interface non-empty but did not match
693
940
                continue
694
941
            value = prop()
695
942
            if not hasattr(value, "variant_level"):
696
 
                all[name] = value
 
943
                properties[name] = value
697
944
                continue
698
 
            all[name] = type(value)(value, variant_level=
699
 
                                    value.variant_level+1)
700
 
        return dbus.Dictionary(all, signature="sv")
 
945
            properties[name] = type(value)(value, variant_level=
 
946
                                           value.variant_level+1)
 
947
        return dbus.Dictionary(properties, signature="sv")
 
948
    
 
949
    @dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
 
950
    def PropertiesChanged(self, interface_name, changed_properties,
 
951
                          invalidated_properties):
 
952
        """Standard D-Bus PropertiesChanged() signal, see D-Bus
 
953
        standard.
 
954
        """
 
955
        pass
701
956
    
702
957
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
703
958
                         out_signature="s",
704
959
                         path_keyword='object_path',
705
960
                         connection_keyword='connection')
706
961
    def Introspect(self, object_path, connection):
707
 
        """Standard D-Bus method, overloaded to insert property tags.
 
962
        """Overloading of standard D-Bus method.
 
963
        
 
964
        Inserts property tags and interface annotation tags.
708
965
        """
709
966
        xmlstring = dbus.service.Object.Introspect(self, object_path,
710
967
                                                   connection)
717
974
                e.setAttribute("access", prop._dbus_access)
718
975
                return e
719
976
            for if_tag in document.getElementsByTagName("interface"):
 
977
                # Add property tags
720
978
                for tag in (make_tag(document, name, prop)
721
979
                            for name, prop
722
 
                            in self._get_all_dbus_properties()
 
980
                            in self._get_all_dbus_things("property")
723
981
                            if prop._dbus_interface
724
982
                            == if_tag.getAttribute("name")):
725
983
                    if_tag.appendChild(tag)
 
984
                # Add annotation tags
 
985
                for typ in ("method", "signal", "property"):
 
986
                    for tag in if_tag.getElementsByTagName(typ):
 
987
                        annots = dict()
 
988
                        for name, prop in (self.
 
989
                                           _get_all_dbus_things(typ)):
 
990
                            if (name == tag.getAttribute("name")
 
991
                                and prop._dbus_interface
 
992
                                == if_tag.getAttribute("name")):
 
993
                                annots.update(getattr
 
994
                                              (prop,
 
995
                                               "_dbus_annotations",
 
996
                                               {}))
 
997
                        for name, value in annots.items():
 
998
                            ann_tag = document.createElement(
 
999
                                "annotation")
 
1000
                            ann_tag.setAttribute("name", name)
 
1001
                            ann_tag.setAttribute("value", value)
 
1002
                            tag.appendChild(ann_tag)
 
1003
                # Add interface annotation tags
 
1004
                for annotation, value in dict(
 
1005
                    itertools.chain.from_iterable(
 
1006
                        annotations().items()
 
1007
                        for name, annotations in
 
1008
                        self._get_all_dbus_things("interface")
 
1009
                        if name == if_tag.getAttribute("name")
 
1010
                        )).items():
 
1011
                    ann_tag = document.createElement("annotation")
 
1012
                    ann_tag.setAttribute("name", annotation)
 
1013
                    ann_tag.setAttribute("value", value)
 
1014
                    if_tag.appendChild(ann_tag)
726
1015
                # Add the names to the return values for the
727
1016
                # "org.freedesktop.DBus.Properties" methods
728
1017
                if (if_tag.getAttribute("name")
743
1032
        except (AttributeError, xml.dom.DOMException,
744
1033
                xml.parsers.expat.ExpatError) as error:
745
1034
            logger.error("Failed to override Introspection method",
746
 
                         error)
 
1035
                         exc_info=error)
747
1036
        return xmlstring
748
1037
 
749
1038
 
750
 
def datetime_to_dbus (dt, variant_level=0):
 
1039
def datetime_to_dbus(dt, variant_level=0):
751
1040
    """Convert a UTC datetime.datetime() to a D-Bus type."""
752
1041
    if dt is None:
753
1042
        return dbus.String("", variant_level = variant_level)
754
1043
    return dbus.String(dt.isoformat(),
755
1044
                       variant_level=variant_level)
756
1045
 
757
 
class AlternateDBusNamesMetaclass(DBusObjectWithProperties.__metaclass__):
758
 
    """Applied to an empty subclass of a D-Bus object, this metaclass
759
 
    will add additional D-Bus attributes matching a certain pattern.
 
1046
 
 
1047
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
 
1048
    """A class decorator; applied to a subclass of
 
1049
    dbus.service.Object, it will add alternate D-Bus attributes with
 
1050
    interface names according to the "alt_interface_names" mapping.
 
1051
    Usage:
 
1052
    
 
1053
    @alternate_dbus_interfaces({"org.example.Interface":
 
1054
                                    "net.example.AlternateInterface"})
 
1055
    class SampleDBusObject(dbus.service.Object):
 
1056
        @dbus.service.method("org.example.Interface")
 
1057
        def SampleDBusMethod():
 
1058
            pass
 
1059
    
 
1060
    The above "SampleDBusMethod" on "SampleDBusObject" will be
 
1061
    reachable via two interfaces: "org.example.Interface" and
 
1062
    "net.example.AlternateInterface", the latter of which will have
 
1063
    its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
 
1064
    "true", unless "deprecate" is passed with a False value.
 
1065
    
 
1066
    This works for methods and signals, and also for D-Bus properties
 
1067
    (from DBusObjectWithProperties) and interfaces (from the
 
1068
    dbus_interface_annotations decorator).
760
1069
    """
761
 
    def __new__(mcs, name, bases, attr):
762
 
        # Go through all the base classes which could have D-Bus
763
 
        # methods, signals, or properties in them
764
 
        for base in (b for b in bases
765
 
                     if issubclass(b, dbus.service.Object)):
766
 
            # Go though all attributes of the base class
767
 
            for attrname, attribute in inspect.getmembers(base):
 
1070
    def wrapper(cls):
 
1071
        for orig_interface_name, alt_interface_name in (
 
1072
            alt_interface_names.items()):
 
1073
            attr = {}
 
1074
            interface_names = set()
 
1075
            # Go though all attributes of the class
 
1076
            for attrname, attribute in inspect.getmembers(cls):
768
1077
                # Ignore non-D-Bus attributes, and D-Bus attributes
769
1078
                # with the wrong interface name
770
1079
                if (not hasattr(attribute, "_dbus_interface")
771
1080
                    or not attribute._dbus_interface
772
 
                    .startswith("se.recompile.Mandos")):
 
1081
                    .startswith(orig_interface_name)):
773
1082
                    continue
774
1083
                # Create an alternate D-Bus interface name based on
775
1084
                # the current name
776
1085
                alt_interface = (attribute._dbus_interface
777
 
                                 .replace("se.recompile.Mandos",
778
 
                                          "se.bsnet.fukt.Mandos"))
 
1086
                                 .replace(orig_interface_name,
 
1087
                                          alt_interface_name))
 
1088
                interface_names.add(alt_interface)
779
1089
                # Is this a D-Bus signal?
780
1090
                if getattr(attribute, "_dbus_is_signal", False):
781
 
                    # Extract the original non-method function by
782
 
                    # black magic
 
1091
                    # Extract the original non-method undecorated
 
1092
                    # function by black magic
783
1093
                    nonmethod_func = (dict(
784
1094
                            zip(attribute.func_code.co_freevars,
785
1095
                                attribute.__closure__))["func"]
796
1106
                                nonmethod_func.func_name,
797
1107
                                nonmethod_func.func_defaults,
798
1108
                                nonmethod_func.func_closure)))
 
1109
                    # Copy annotations, if any
 
1110
                    try:
 
1111
                        new_function._dbus_annotations = (
 
1112
                            dict(attribute._dbus_annotations))
 
1113
                    except AttributeError:
 
1114
                        pass
799
1115
                    # Define a creator of a function to call both the
800
 
                    # old and new functions, so both the old and new
801
 
                    # signals gets sent when the function is called
 
1116
                    # original and alternate functions, so both the
 
1117
                    # original and alternate signals gets sent when
 
1118
                    # the function is called
802
1119
                    def fixscope(func1, func2):
803
1120
                        """This function is a scope container to pass
804
1121
                        func1 and func2 to the "call_both" function
811
1128
                        return call_both
812
1129
                    # Create the "call_both" function and add it to
813
1130
                    # the class
814
 
                    attr[attrname] = fixscope(attribute,
815
 
                                              new_function)
 
1131
                    attr[attrname] = fixscope(attribute, new_function)
816
1132
                # Is this a D-Bus method?
817
1133
                elif getattr(attribute, "_dbus_is_method", False):
818
1134
                    # Create a new, but exactly alike, function
829
1145
                                        attribute.func_name,
830
1146
                                        attribute.func_defaults,
831
1147
                                        attribute.func_closure)))
 
1148
                    # Copy annotations, if any
 
1149
                    try:
 
1150
                        attr[attrname]._dbus_annotations = (
 
1151
                            dict(attribute._dbus_annotations))
 
1152
                    except AttributeError:
 
1153
                        pass
832
1154
                # Is this a D-Bus property?
833
1155
                elif getattr(attribute, "_dbus_is_property", False):
834
1156
                    # Create a new, but exactly alike, function
848
1170
                                        attribute.func_name,
849
1171
                                        attribute.func_defaults,
850
1172
                                        attribute.func_closure)))
851
 
        return type.__new__(mcs, name, bases, attr)
852
 
 
 
1173
                    # Copy annotations, if any
 
1174
                    try:
 
1175
                        attr[attrname]._dbus_annotations = (
 
1176
                            dict(attribute._dbus_annotations))
 
1177
                    except AttributeError:
 
1178
                        pass
 
1179
                # Is this a D-Bus interface?
 
1180
                elif getattr(attribute, "_dbus_is_interface", False):
 
1181
                    # Create a new, but exactly alike, function
 
1182
                    # object.  Decorate it to be a new D-Bus interface
 
1183
                    # with the alternate D-Bus interface name.  Add it
 
1184
                    # to the class.
 
1185
                    attr[attrname] = (dbus_interface_annotations
 
1186
                                      (alt_interface)
 
1187
                                      (types.FunctionType
 
1188
                                       (attribute.func_code,
 
1189
                                        attribute.func_globals,
 
1190
                                        attribute.func_name,
 
1191
                                        attribute.func_defaults,
 
1192
                                        attribute.func_closure)))
 
1193
            if deprecate:
 
1194
                # Deprecate all alternate interfaces
 
1195
                iname="_AlternateDBusNames_interface_annotation{}"
 
1196
                for interface_name in interface_names:
 
1197
                    @dbus_interface_annotations(interface_name)
 
1198
                    def func(self):
 
1199
                        return { "org.freedesktop.DBus.Deprecated":
 
1200
                                     "true" }
 
1201
                    # Find an unused name
 
1202
                    for aname in (iname.format(i)
 
1203
                                  for i in itertools.count()):
 
1204
                        if aname not in attr:
 
1205
                            attr[aname] = func
 
1206
                            break
 
1207
            if interface_names:
 
1208
                # Replace the class with a new subclass of it with
 
1209
                # methods, signals, etc. as created above.
 
1210
                cls = type(b"{}Alternate".format(cls.__name__),
 
1211
                           (cls,), attr)
 
1212
        return cls
 
1213
    return wrapper
 
1214
 
 
1215
 
 
1216
@alternate_dbus_interfaces({"se.recompile.Mandos":
 
1217
                                "se.bsnet.fukt.Mandos"})
853
1218
class ClientDBus(Client, DBusObjectWithProperties):
854
1219
    """A Client class using D-Bus
855
1220
    
861
1226
    runtime_expansions = (Client.runtime_expansions
862
1227
                          + ("dbus_object_path",))
863
1228
    
 
1229
    _interface = "se.recompile.Mandos.Client"
 
1230
    
864
1231
    # dbus.service.Object doesn't use super(), so we can't either.
865
1232
    
866
1233
    def __init__(self, bus = None, *args, **kwargs):
867
 
        self._approvals_pending = 0
868
1234
        self.bus = bus
869
1235
        Client.__init__(self, *args, **kwargs)
870
1236
        # Only now, when this client is initialized, can it show up on
871
1237
        # the D-Bus
872
 
        client_object_name = unicode(self.name).translate(
 
1238
        client_object_name = str(self.name).translate(
873
1239
            {ord("."): ord("_"),
874
1240
             ord("-"): ord("_")})
875
1241
        self.dbus_object_path = (dbus.ObjectPath
876
1242
                                 ("/clients/" + client_object_name))
877
1243
        DBusObjectWithProperties.__init__(self, self.bus,
878
1244
                                          self.dbus_object_path)
879
 
        
 
1245
    
880
1246
    def notifychangeproperty(transform_func,
881
1247
                             dbus_name, type_func=lambda x: x,
882
 
                             variant_level=1):
 
1248
                             variant_level=1, invalidate_only=False,
 
1249
                             _interface=_interface):
883
1250
        """ Modify a variable so that it's a property which announces
884
1251
        its changes to DBus.
885
 
 
886
 
        transform_fun: Function that takes a value and transforms it
887
 
                       to a D-Bus type.
 
1252
        
 
1253
        transform_fun: Function that takes a value and a variant_level
 
1254
                       and transforms it to a D-Bus type.
888
1255
        dbus_name: D-Bus name of the variable
889
1256
        type_func: Function that transform the value before sending it
890
1257
                   to the D-Bus.  Default: no transform
891
1258
        variant_level: D-Bus variant level.  Default: 1
892
1259
        """
893
 
        real_value = [None,]
 
1260
        attrname = "_{}".format(dbus_name)
894
1261
        def setter(self, value):
895
 
            old_value = real_value[0]
896
 
            real_value[0] = value
897
1262
            if hasattr(self, "dbus_object_path"):
898
 
                if type_func(old_value) != type_func(real_value[0]):
899
 
                    dbus_value = transform_func(type_func(real_value[0]),
900
 
                                                variant_level)
901
 
                    self.PropertyChanged(dbus.String(dbus_name),
902
 
                                         dbus_value)
 
1263
                if (not hasattr(self, attrname) or
 
1264
                    type_func(getattr(self, attrname, None))
 
1265
                    != type_func(value)):
 
1266
                    if invalidate_only:
 
1267
                        self.PropertiesChanged(_interface,
 
1268
                                               dbus.Dictionary(),
 
1269
                                               dbus.Array
 
1270
                                               ((dbus_name,)))
 
1271
                    else:
 
1272
                        dbus_value = transform_func(type_func(value),
 
1273
                                                    variant_level
 
1274
                                                    =variant_level)
 
1275
                        self.PropertyChanged(dbus.String(dbus_name),
 
1276
                                             dbus_value)
 
1277
                        self.PropertiesChanged(_interface,
 
1278
                                               dbus.Dictionary({
 
1279
                                    dbus.String(dbus_name):
 
1280
                                        dbus_value }), dbus.Array())
 
1281
            setattr(self, attrname, value)
903
1282
        
904
 
        return property(lambda self: real_value[0], setter)
905
 
    
 
1283
        return property(lambda self: getattr(self, attrname), setter)
906
1284
    
907
1285
    expires = notifychangeproperty(datetime_to_dbus, "Expires")
908
1286
    approvals_pending = notifychangeproperty(dbus.Boolean,
912
1290
    last_enabled = notifychangeproperty(datetime_to_dbus,
913
1291
                                        "LastEnabled")
914
1292
    checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
915
 
                                   type_func = lambda checker: checker is not None)
 
1293
                                   type_func = lambda checker:
 
1294
                                       checker is not None)
916
1295
    last_checked_ok = notifychangeproperty(datetime_to_dbus,
917
1296
                                           "LastCheckedOK")
918
 
    last_approval_request = notifychangeproperty(datetime_to_dbus,
919
 
                                                 "LastApprovalRequest")
 
1297
    last_checker_status = notifychangeproperty(dbus.Int16,
 
1298
                                               "LastCheckerStatus")
 
1299
    last_approval_request = notifychangeproperty(
 
1300
        datetime_to_dbus, "LastApprovalRequest")
920
1301
    approved_by_default = notifychangeproperty(dbus.Boolean,
921
1302
                                               "ApprovedByDefault")
922
 
    approval_delay = notifychangeproperty(dbus.UInt16, "ApprovalDelay",
923
 
                                          type_func = _timedelta_to_milliseconds)
924
 
    approval_duration = notifychangeproperty(dbus.UInt16, "ApprovalDuration",
925
 
                                             type_func = _timedelta_to_milliseconds)
 
1303
    approval_delay = notifychangeproperty(dbus.UInt64,
 
1304
                                          "ApprovalDelay",
 
1305
                                          type_func =
 
1306
                                          lambda td: td.total_seconds()
 
1307
                                          * 1000)
 
1308
    approval_duration = notifychangeproperty(
 
1309
        dbus.UInt64, "ApprovalDuration",
 
1310
        type_func = lambda td: td.total_seconds() * 1000)
926
1311
    host = notifychangeproperty(dbus.String, "Host")
927
 
    timeout = notifychangeproperty(dbus.UInt16, "Timeout",
928
 
                                   type_func = _timedelta_to_milliseconds)
929
 
    extended_timeout = notifychangeproperty(dbus.UInt16, "ExtendedTimeout",
930
 
                                            type_func = _timedelta_to_milliseconds)
931
 
    interval = notifychangeproperty(dbus.UInt16, "Interval",
932
 
                                    type_func = _timedelta_to_milliseconds)
 
1312
    timeout = notifychangeproperty(dbus.UInt64, "Timeout",
 
1313
                                   type_func = lambda td:
 
1314
                                       td.total_seconds() * 1000)
 
1315
    extended_timeout = notifychangeproperty(
 
1316
        dbus.UInt64, "ExtendedTimeout",
 
1317
        type_func = lambda td: td.total_seconds() * 1000)
 
1318
    interval = notifychangeproperty(dbus.UInt64,
 
1319
                                    "Interval",
 
1320
                                    type_func =
 
1321
                                    lambda td: td.total_seconds()
 
1322
                                    * 1000)
933
1323
    checker_command = notifychangeproperty(dbus.String, "Checker")
 
1324
    secret = notifychangeproperty(dbus.ByteArray, "Secret",
 
1325
                                  invalidate_only=True)
934
1326
    
935
1327
    del notifychangeproperty
936
1328
    
963
1355
                                       *args, **kwargs)
964
1356
    
965
1357
    def start_checker(self, *args, **kwargs):
966
 
        old_checker = self.checker
967
 
        if self.checker is not None:
968
 
            old_checker_pid = self.checker.pid
969
 
        else:
970
 
            old_checker_pid = None
 
1358
        old_checker_pid = getattr(self.checker, "pid", None)
971
1359
        r = Client.start_checker(self, *args, **kwargs)
972
1360
        # Only if new checker process was started
973
1361
        if (self.checker is not None
977
1365
        return r
978
1366
    
979
1367
    def _reset_approved(self):
980
 
        self._approved = None
 
1368
        self.approved = None
981
1369
        return False
982
1370
    
983
1371
    def approve(self, value=True):
 
1372
        self.approved = value
 
1373
        gobject.timeout_add(int(self.approval_duration.total_seconds()
 
1374
                                * 1000), self._reset_approved)
984
1375
        self.send_changedstate()
985
 
        self._approved = value
986
 
        gobject.timeout_add(_timedelta_to_milliseconds
987
 
                            (self.approval_duration),
988
 
                            self._reset_approved)
989
 
    
990
1376
    
991
1377
    ## D-Bus methods, signals & properties
992
 
    _interface = "se.recompile.Mandos.Client"
 
1378
    
 
1379
    ## Interfaces
993
1380
    
994
1381
    ## Signals
995
1382
    
1006
1393
        pass
1007
1394
    
1008
1395
    # PropertyChanged - signal
 
1396
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1009
1397
    @dbus.service.signal(_interface, signature="sv")
1010
1398
    def PropertyChanged(self, property, value):
1011
1399
        "D-Bus signal"
1087
1475
                           access="readwrite")
1088
1476
    def ApprovalDelay_dbus_property(self, value=None):
1089
1477
        if value is None:       # get
1090
 
            return dbus.UInt64(self.approval_delay_milliseconds())
 
1478
            return dbus.UInt64(self.approval_delay.total_seconds()
 
1479
                               * 1000)
1091
1480
        self.approval_delay = datetime.timedelta(0, 0, 0, value)
1092
1481
    
1093
1482
    # ApprovalDuration - property
1095
1484
                           access="readwrite")
1096
1485
    def ApprovalDuration_dbus_property(self, value=None):
1097
1486
        if value is None:       # get
1098
 
            return dbus.UInt64(_timedelta_to_milliseconds(
1099
 
                    self.approval_duration))
 
1487
            return dbus.UInt64(self.approval_duration.total_seconds()
 
1488
                               * 1000)
1100
1489
        self.approval_duration = datetime.timedelta(0, 0, 0, value)
1101
1490
    
1102
1491
    # Name - property
1115
1504
    def Host_dbus_property(self, value=None):
1116
1505
        if value is None:       # get
1117
1506
            return dbus.String(self.host)
1118
 
        self.host = value
 
1507
        self.host = str(value)
1119
1508
    
1120
1509
    # Created - property
1121
1510
    @dbus_service_property(_interface, signature="s", access="read")
1122
1511
    def Created_dbus_property(self):
1123
 
        return dbus.String(datetime_to_dbus(self.created))
 
1512
        return datetime_to_dbus(self.created)
1124
1513
    
1125
1514
    # LastEnabled - property
1126
1515
    @dbus_service_property(_interface, signature="s", access="read")
1147
1536
            return
1148
1537
        return datetime_to_dbus(self.last_checked_ok)
1149
1538
    
 
1539
    # LastCheckerStatus - property
 
1540
    @dbus_service_property(_interface, signature="n",
 
1541
                           access="read")
 
1542
    def LastCheckerStatus_dbus_property(self):
 
1543
        return dbus.Int16(self.last_checker_status)
 
1544
    
1150
1545
    # Expires - property
1151
1546
    @dbus_service_property(_interface, signature="s", access="read")
1152
1547
    def Expires_dbus_property(self):
1162
1557
                           access="readwrite")
1163
1558
    def Timeout_dbus_property(self, value=None):
1164
1559
        if value is None:       # get
1165
 
            return dbus.UInt64(self.timeout_milliseconds())
 
1560
            return dbus.UInt64(self.timeout.total_seconds() * 1000)
 
1561
        old_timeout = self.timeout
1166
1562
        self.timeout = datetime.timedelta(0, 0, 0, value)
1167
 
        if getattr(self, "disable_initiator_tag", None) is None:
1168
 
            return
1169
 
        # Reschedule timeout
1170
 
        gobject.source_remove(self.disable_initiator_tag)
1171
 
        self.disable_initiator_tag = None
1172
 
        self.expires = None
1173
 
        time_to_die = (self.
1174
 
                       _timedelta_to_milliseconds((self
1175
 
                                                   .last_checked_ok
1176
 
                                                   + self.timeout)
1177
 
                                                  - datetime.datetime
1178
 
                                                  .utcnow()))
1179
 
        if time_to_die <= 0:
1180
 
            # The timeout has passed
1181
 
            self.disable()
1182
 
        else:
1183
 
            self.expires = (datetime.datetime.utcnow()
1184
 
                            + datetime.timedelta(milliseconds = time_to_die))
1185
 
            self.disable_initiator_tag = (gobject.timeout_add
1186
 
                                          (time_to_die, self.disable))
 
1563
        # Reschedule disabling
 
1564
        if self.enabled:
 
1565
            now = datetime.datetime.utcnow()
 
1566
            self.expires += self.timeout - old_timeout
 
1567
            if self.expires <= now:
 
1568
                # The timeout has passed
 
1569
                self.disable()
 
1570
            else:
 
1571
                if (getattr(self, "disable_initiator_tag", None)
 
1572
                    is None):
 
1573
                    return
 
1574
                gobject.source_remove(self.disable_initiator_tag)
 
1575
                self.disable_initiator_tag = (
 
1576
                    gobject.timeout_add(
 
1577
                        int((self.expires - now).total_seconds()
 
1578
                            * 1000), self.disable))
1187
1579
    
1188
1580
    # ExtendedTimeout - property
1189
1581
    @dbus_service_property(_interface, signature="t",
1190
1582
                           access="readwrite")
1191
1583
    def ExtendedTimeout_dbus_property(self, value=None):
1192
1584
        if value is None:       # get
1193
 
            return dbus.UInt64(self.extended_timeout_milliseconds())
 
1585
            return dbus.UInt64(self.extended_timeout.total_seconds()
 
1586
                               * 1000)
1194
1587
        self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1195
1588
    
1196
1589
    # Interval - property
1198
1591
                           access="readwrite")
1199
1592
    def Interval_dbus_property(self, value=None):
1200
1593
        if value is None:       # get
1201
 
            return dbus.UInt64(self.interval_milliseconds())
 
1594
            return dbus.UInt64(self.interval.total_seconds() * 1000)
1202
1595
        self.interval = datetime.timedelta(0, 0, 0, value)
1203
1596
        if getattr(self, "checker_initiator_tag", None) is None:
1204
1597
            return
1205
 
        # Reschedule checker run
1206
 
        gobject.source_remove(self.checker_initiator_tag)
1207
 
        self.checker_initiator_tag = (gobject.timeout_add
1208
 
                                      (value, self.start_checker))
1209
 
        self.start_checker()    # Start one now, too
 
1598
        if self.enabled:
 
1599
            # Reschedule checker run
 
1600
            gobject.source_remove(self.checker_initiator_tag)
 
1601
            self.checker_initiator_tag = (gobject.timeout_add
 
1602
                                          (value, self.start_checker))
 
1603
            self.start_checker()    # Start one now, too
1210
1604
    
1211
1605
    # Checker - property
1212
1606
    @dbus_service_property(_interface, signature="s",
1214
1608
    def Checker_dbus_property(self, value=None):
1215
1609
        if value is None:       # get
1216
1610
            return dbus.String(self.checker_command)
1217
 
        self.checker_command = value
 
1611
        self.checker_command = str(value)
1218
1612
    
1219
1613
    # CheckerRunning - property
1220
1614
    @dbus_service_property(_interface, signature="b",
1236
1630
    @dbus_service_property(_interface, signature="ay",
1237
1631
                           access="write", byte_arrays=True)
1238
1632
    def Secret_dbus_property(self, value):
1239
 
        self.secret = str(value)
 
1633
        self.secret = bytes(value)
1240
1634
    
1241
1635
    del _interface
1242
1636
 
1249
1643
            raise KeyError()
1250
1644
    
1251
1645
    def __getattribute__(self, name):
1252
 
        if(name == '_pipe'):
 
1646
        if name == '_pipe':
1253
1647
            return super(ProxyClient, self).__getattribute__(name)
1254
1648
        self._pipe.send(('getattr', name))
1255
1649
        data = self._pipe.recv()
1262
1656
            return func
1263
1657
    
1264
1658
    def __setattr__(self, name, value):
1265
 
        if(name == '_pipe'):
 
1659
        if name == '_pipe':
1266
1660
            return super(ProxyClient, self).__setattr__(name, value)
1267
1661
        self._pipe.send(('setattr', name, value))
1268
1662
 
1269
 
class ClientDBusTransitional(ClientDBus):
1270
 
    __metaclass__ = AlternateDBusNamesMetaclass
1271
1663
 
1272
1664
class ClientHandler(socketserver.BaseRequestHandler, object):
1273
1665
    """A class to handle client connections.
1278
1670
    def handle(self):
1279
1671
        with contextlib.closing(self.server.child_pipe) as child_pipe:
1280
1672
            logger.info("TCP connection from: %s",
1281
 
                        unicode(self.client_address))
 
1673
                        str(self.client_address))
1282
1674
            logger.debug("Pipe FD: %d",
1283
1675
                         self.server.child_pipe.fileno())
1284
1676
            
1310
1702
            logger.debug("Protocol version: %r", line)
1311
1703
            try:
1312
1704
                if int(line.strip().split()[0]) > 1:
1313
 
                    raise RuntimeError
 
1705
                    raise RuntimeError(line)
1314
1706
            except (ValueError, IndexError, RuntimeError) as error:
1315
1707
                logger.error("Unknown protocol version: %s", error)
1316
1708
                return
1353
1745
                                       client.name)
1354
1746
                        if self.server.use_dbus:
1355
1747
                            # Emit D-Bus signal
1356
 
                            client.Rejected("Disabled")                    
 
1748
                            client.Rejected("Disabled")
1357
1749
                        return
1358
1750
                    
1359
 
                    if client._approved or not client.approval_delay:
 
1751
                    if client.approved or not client.approval_delay:
1360
1752
                        #We are approved or approval is disabled
1361
1753
                        break
1362
 
                    elif client._approved is None:
 
1754
                    elif client.approved is None:
1363
1755
                        logger.info("Client %s needs approval",
1364
1756
                                    client.name)
1365
1757
                        if self.server.use_dbus:
1366
1758
                            # Emit D-Bus signal
1367
1759
                            client.NeedApproval(
1368
 
                                client.approval_delay_milliseconds(),
1369
 
                                client.approved_by_default)
 
1760
                                client.approval_delay.total_seconds()
 
1761
                                * 1000, client.approved_by_default)
1370
1762
                    else:
1371
1763
                        logger.warning("Client %s was not approved",
1372
1764
                                       client.name)
1376
1768
                        return
1377
1769
                    
1378
1770
                    #wait until timeout or approved
1379
 
                    #x = float(client._timedelta_to_milliseconds(delay))
1380
1771
                    time = datetime.datetime.now()
1381
1772
                    client.changedstate.acquire()
1382
 
                    client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))
 
1773
                    client.changedstate.wait(delay.total_seconds())
1383
1774
                    client.changedstate.release()
1384
1775
                    time2 = datetime.datetime.now()
1385
1776
                    if (time2 - time) >= delay:
1401
1792
                    try:
1402
1793
                        sent = session.send(client.secret[sent_size:])
1403
1794
                    except gnutls.errors.GNUTLSError as error:
1404
 
                        logger.warning("gnutls send failed")
 
1795
                        logger.warning("gnutls send failed",
 
1796
                                       exc_info=error)
1405
1797
                        return
1406
1798
                    logger.debug("Sent: %d, remaining: %d",
1407
1799
                                 sent, len(client.secret)
1409
1801
                    sent_size += sent
1410
1802
                
1411
1803
                logger.info("Sending secret to %s", client.name)
1412
 
                # bump the timeout as if seen
1413
 
                client.checked_ok(client.extended_timeout)
 
1804
                # bump the timeout using extended_timeout
 
1805
                client.bump_timeout(client.extended_timeout)
1414
1806
                if self.server.use_dbus:
1415
1807
                    # Emit D-Bus signal
1416
1808
                    client.GotSecret()
1421
1813
                try:
1422
1814
                    session.bye()
1423
1815
                except gnutls.errors.GNUTLSError as error:
1424
 
                    logger.warning("GnuTLS bye failed")
 
1816
                    logger.warning("GnuTLS bye failed",
 
1817
                                   exc_info=error)
1425
1818
    
1426
1819
    @staticmethod
1427
1820
    def peer_certificate(session):
1483
1876
        # Convert the buffer to a Python bytestring
1484
1877
        fpr = ctypes.string_at(buf, buf_len.value)
1485
1878
        # Convert the bytestring to hexadecimal notation
1486
 
        hex_fpr = ''.join("%02X" % ord(char) for char in fpr)
 
1879
        hex_fpr = binascii.hexlify(fpr).upper()
1487
1880
        return hex_fpr
1488
1881
 
1489
1882
 
1492
1885
    def sub_process_main(self, request, address):
1493
1886
        try:
1494
1887
            self.finish_request(request, address)
1495
 
        except:
 
1888
        except Exception:
1496
1889
            self.handle_error(request, address)
1497
1890
        self.close_request(request)
1498
 
            
 
1891
    
1499
1892
    def process_request(self, request, address):
1500
1893
        """Start a new process to process the request."""
1501
 
        multiprocessing.Process(target = self.sub_process_main,
1502
 
                                args = (request, address)).start()
 
1894
        proc = multiprocessing.Process(target = self.sub_process_main,
 
1895
                                       args = (request, address))
 
1896
        proc.start()
 
1897
        return proc
1503
1898
 
1504
1899
 
1505
1900
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1511
1906
        """
1512
1907
        parent_pipe, self.child_pipe = multiprocessing.Pipe()
1513
1908
        
1514
 
        super(MultiprocessingMixInWithPipe,
1515
 
              self).process_request(request, client_address)
 
1909
        proc = MultiprocessingMixIn.process_request(self, request,
 
1910
                                                    client_address)
1516
1911
        self.child_pipe.close()
1517
 
        self.add_pipe(parent_pipe)
 
1912
        self.add_pipe(parent_pipe, proc)
1518
1913
    
1519
 
    def add_pipe(self, parent_pipe):
 
1914
    def add_pipe(self, parent_pipe, proc):
1520
1915
        """Dummy function; override as necessary"""
1521
 
        raise NotImplementedError
 
1916
        raise NotImplementedError()
1522
1917
 
1523
1918
 
1524
1919
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1531
1926
        use_ipv6:       Boolean; to use IPv6 or not
1532
1927
    """
1533
1928
    def __init__(self, server_address, RequestHandlerClass,
1534
 
                 interface=None, use_ipv6=True):
 
1929
                 interface=None, use_ipv6=True, socketfd=None):
 
1930
        """If socketfd is set, use that file descriptor instead of
 
1931
        creating a new one with socket.socket().
 
1932
        """
1535
1933
        self.interface = interface
1536
1934
        if use_ipv6:
1537
1935
            self.address_family = socket.AF_INET6
 
1936
        if socketfd is not None:
 
1937
            # Save the file descriptor
 
1938
            self.socketfd = socketfd
 
1939
            # Save the original socket.socket() function
 
1940
            self.socket_socket = socket.socket
 
1941
            # To implement --socket, we monkey patch socket.socket.
 
1942
            # 
 
1943
            # (When socketserver.TCPServer is a new-style class, we
 
1944
            # could make self.socket into a property instead of monkey
 
1945
            # patching socket.socket.)
 
1946
            # 
 
1947
            # Create a one-time-only replacement for socket.socket()
 
1948
            @functools.wraps(socket.socket)
 
1949
            def socket_wrapper(*args, **kwargs):
 
1950
                # Restore original function so subsequent calls are
 
1951
                # not affected.
 
1952
                socket.socket = self.socket_socket
 
1953
                del self.socket_socket
 
1954
                # This time only, return a new socket object from the
 
1955
                # saved file descriptor.
 
1956
                return socket.fromfd(self.socketfd, *args, **kwargs)
 
1957
            # Replace socket.socket() function with wrapper
 
1958
            socket.socket = socket_wrapper
 
1959
        # The socketserver.TCPServer.__init__ will call
 
1960
        # socket.socket(), which might be our replacement,
 
1961
        # socket_wrapper(), if socketfd was set.
1538
1962
        socketserver.TCPServer.__init__(self, server_address,
1539
1963
                                        RequestHandlerClass)
 
1964
    
1540
1965
    def server_bind(self):
1541
1966
        """This overrides the normal server_bind() function
1542
1967
        to bind to an interface if one was specified, and also NOT to
1550
1975
                try:
1551
1976
                    self.socket.setsockopt(socket.SOL_SOCKET,
1552
1977
                                           SO_BINDTODEVICE,
1553
 
                                           str(self.interface
1554
 
                                               + '\0'))
 
1978
                                           (self.interface + "\0")
 
1979
                                           .encode("utf-8"))
1555
1980
                except socket.error as error:
1556
 
                    if error[0] == errno.EPERM:
1557
 
                        logger.error("No permission to"
1558
 
                                     " bind to interface %s",
1559
 
                                     self.interface)
1560
 
                    elif error[0] == errno.ENOPROTOOPT:
 
1981
                    if error.errno == errno.EPERM:
 
1982
                        logger.error("No permission to bind to"
 
1983
                                     " interface %s", self.interface)
 
1984
                    elif error.errno == errno.ENOPROTOOPT:
1561
1985
                        logger.error("SO_BINDTODEVICE not available;"
1562
1986
                                     " cannot bind to interface %s",
1563
1987
                                     self.interface)
 
1988
                    elif error.errno == errno.ENODEV:
 
1989
                        logger.error("Interface %s does not exist,"
 
1990
                                     " cannot bind", self.interface)
1564
1991
                    else:
1565
1992
                        raise
1566
1993
        # Only bind(2) the socket if we really need to.
1569
1996
                if self.address_family == socket.AF_INET6:
1570
1997
                    any_address = "::" # in6addr_any
1571
1998
                else:
1572
 
                    any_address = socket.INADDR_ANY
 
1999
                    any_address = "0.0.0.0" # INADDR_ANY
1573
2000
                self.server_address = (any_address,
1574
2001
                                       self.server_address[1])
1575
2002
            elif not self.server_address[1]:
1596
2023
    """
1597
2024
    def __init__(self, server_address, RequestHandlerClass,
1598
2025
                 interface=None, use_ipv6=True, clients=None,
1599
 
                 gnutls_priority=None, use_dbus=True):
 
2026
                 gnutls_priority=None, use_dbus=True, socketfd=None):
1600
2027
        self.enabled = False
1601
2028
        self.clients = clients
1602
2029
        if self.clients is None:
1603
 
            self.clients = set()
 
2030
            self.clients = {}
1604
2031
        self.use_dbus = use_dbus
1605
2032
        self.gnutls_priority = gnutls_priority
1606
2033
        IPv6_TCPServer.__init__(self, server_address,
1607
2034
                                RequestHandlerClass,
1608
2035
                                interface = interface,
1609
 
                                use_ipv6 = use_ipv6)
 
2036
                                use_ipv6 = use_ipv6,
 
2037
                                socketfd = socketfd)
1610
2038
    def server_activate(self):
1611
2039
        if self.enabled:
1612
2040
            return socketserver.TCPServer.server_activate(self)
 
2041
    
1613
2042
    def enable(self):
1614
2043
        self.enabled = True
1615
 
    def add_pipe(self, parent_pipe):
 
2044
    
 
2045
    def add_pipe(self, parent_pipe, proc):
1616
2046
        # Call "handle_ipc" for both data and EOF events
1617
2047
        gobject.io_add_watch(parent_pipe.fileno(),
1618
2048
                             gobject.IO_IN | gobject.IO_HUP,
1619
2049
                             functools.partial(self.handle_ipc,
1620
 
                                               parent_pipe = parent_pipe))
1621
 
        
 
2050
                                               parent_pipe =
 
2051
                                               parent_pipe,
 
2052
                                               proc = proc))
 
2053
    
1622
2054
    def handle_ipc(self, source, condition, parent_pipe=None,
1623
 
                   client_object=None):
1624
 
        condition_names = {
1625
 
            gobject.IO_IN: "IN",   # There is data to read.
1626
 
            gobject.IO_OUT: "OUT", # Data can be written (without
1627
 
                                    # blocking).
1628
 
            gobject.IO_PRI: "PRI", # There is urgent data to read.
1629
 
            gobject.IO_ERR: "ERR", # Error condition.
1630
 
            gobject.IO_HUP: "HUP"  # Hung up (the connection has been
1631
 
                                    # broken, usually for pipes and
1632
 
                                    # sockets).
1633
 
            }
1634
 
        conditions_string = ' | '.join(name
1635
 
                                       for cond, name in
1636
 
                                       condition_names.iteritems()
1637
 
                                       if cond & condition)
1638
 
        # error or the other end of multiprocessing.Pipe has closed
1639
 
        if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
 
2055
                   proc = None, client_object=None):
 
2056
        # error, or the other end of multiprocessing.Pipe has closed
 
2057
        if condition & (gobject.IO_ERR | gobject.IO_HUP):
 
2058
            # Wait for other process to exit
 
2059
            proc.join()
1640
2060
            return False
1641
2061
        
1642
2062
        # Read a request from the child
1647
2067
            fpr = request[1]
1648
2068
            address = request[2]
1649
2069
            
1650
 
            for c in self.clients:
 
2070
            for c in self.clients.itervalues():
1651
2071
                if c.fingerprint == fpr:
1652
2072
                    client = c
1653
2073
                    break
1656
2076
                            "dress: %s", fpr, address)
1657
2077
                if self.use_dbus:
1658
2078
                    # Emit D-Bus signal
1659
 
                    mandos_dbus_service.ClientNotFound(fpr, address[0])
 
2079
                    mandos_dbus_service.ClientNotFound(fpr,
 
2080
                                                       address[0])
1660
2081
                parent_pipe.send(False)
1661
2082
                return False
1662
2083
            
1663
2084
            gobject.io_add_watch(parent_pipe.fileno(),
1664
2085
                                 gobject.IO_IN | gobject.IO_HUP,
1665
2086
                                 functools.partial(self.handle_ipc,
1666
 
                                                   parent_pipe = parent_pipe,
1667
 
                                                   client_object = client))
 
2087
                                                   parent_pipe =
 
2088
                                                   parent_pipe,
 
2089
                                                   proc = proc,
 
2090
                                                   client_object =
 
2091
                                                   client))
1668
2092
            parent_pipe.send(True)
1669
 
            # remove the old hook in favor of the new above hook on same fileno
 
2093
            # remove the old hook in favor of the new above hook on
 
2094
            # same fileno
1670
2095
            return False
1671
2096
        if command == 'funcall':
1672
2097
            funcname = request[1]
1673
2098
            args = request[2]
1674
2099
            kwargs = request[3]
1675
2100
            
1676
 
            parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))
 
2101
            parent_pipe.send(('data', getattr(client_object,
 
2102
                                              funcname)(*args,
 
2103
                                                         **kwargs)))
1677
2104
        
1678
2105
        if command == 'getattr':
1679
2106
            attrname = request[1]
1680
2107
            if callable(client_object.__getattribute__(attrname)):
1681
2108
                parent_pipe.send(('function',))
1682
2109
            else:
1683
 
                parent_pipe.send(('data', client_object.__getattribute__(attrname)))
 
2110
                parent_pipe.send(('data', client_object
 
2111
                                  .__getattribute__(attrname)))
1684
2112
        
1685
2113
        if command == 'setattr':
1686
2114
            attrname = request[1]
1690
2118
        return True
1691
2119
 
1692
2120
 
 
2121
def rfc3339_duration_to_delta(duration):
 
2122
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
 
2123
    
 
2124
    >>> rfc3339_duration_to_delta("P7D")
 
2125
    datetime.timedelta(7)
 
2126
    >>> rfc3339_duration_to_delta("PT60S")
 
2127
    datetime.timedelta(0, 60)
 
2128
    >>> rfc3339_duration_to_delta("PT60M")
 
2129
    datetime.timedelta(0, 3600)
 
2130
    >>> rfc3339_duration_to_delta("PT24H")
 
2131
    datetime.timedelta(1)
 
2132
    >>> rfc3339_duration_to_delta("P1W")
 
2133
    datetime.timedelta(7)
 
2134
    >>> rfc3339_duration_to_delta("PT5M30S")
 
2135
    datetime.timedelta(0, 330)
 
2136
    >>> rfc3339_duration_to_delta("P1DT3M20S")
 
2137
    datetime.timedelta(1, 200)
 
2138
    """
 
2139
    
 
2140
    # Parsing an RFC 3339 duration with regular expressions is not
 
2141
    # possible - there would have to be multiple places for the same
 
2142
    # values, like seconds.  The current code, while more esoteric, is
 
2143
    # cleaner without depending on a parsing library.  If Python had a
 
2144
    # built-in library for parsing we would use it, but we'd like to
 
2145
    # avoid excessive use of external libraries.
 
2146
    
 
2147
    # New type for defining tokens, syntax, and semantics all-in-one
 
2148
    Token = collections.namedtuple("Token",
 
2149
                                   ("regexp", # To match token; if
 
2150
                                              # "value" is not None,
 
2151
                                              # must have a "group"
 
2152
                                              # containing digits
 
2153
                                    "value",  # datetime.timedelta or
 
2154
                                              # None
 
2155
                                    "followers")) # Tokens valid after
 
2156
                                                  # this token
 
2157
    # RFC 3339 "duration" tokens, syntax, and semantics; taken from
 
2158
    # the "duration" ABNF definition in RFC 3339, Appendix A.
 
2159
    token_end = Token(re.compile(r"$"), None, frozenset())
 
2160
    token_second = Token(re.compile(r"(\d+)S"),
 
2161
                         datetime.timedelta(seconds=1),
 
2162
                         frozenset((token_end,)))
 
2163
    token_minute = Token(re.compile(r"(\d+)M"),
 
2164
                         datetime.timedelta(minutes=1),
 
2165
                         frozenset((token_second, token_end)))
 
2166
    token_hour = Token(re.compile(r"(\d+)H"),
 
2167
                       datetime.timedelta(hours=1),
 
2168
                       frozenset((token_minute, token_end)))
 
2169
    token_time = Token(re.compile(r"T"),
 
2170
                       None,
 
2171
                       frozenset((token_hour, token_minute,
 
2172
                                  token_second)))
 
2173
    token_day = Token(re.compile(r"(\d+)D"),
 
2174
                      datetime.timedelta(days=1),
 
2175
                      frozenset((token_time, token_end)))
 
2176
    token_month = Token(re.compile(r"(\d+)M"),
 
2177
                        datetime.timedelta(weeks=4),
 
2178
                        frozenset((token_day, token_end)))
 
2179
    token_year = Token(re.compile(r"(\d+)Y"),
 
2180
                       datetime.timedelta(weeks=52),
 
2181
                       frozenset((token_month, token_end)))
 
2182
    token_week = Token(re.compile(r"(\d+)W"),
 
2183
                       datetime.timedelta(weeks=1),
 
2184
                       frozenset((token_end,)))
 
2185
    token_duration = Token(re.compile(r"P"), None,
 
2186
                           frozenset((token_year, token_month,
 
2187
                                      token_day, token_time,
 
2188
                                      token_week)))
 
2189
    # Define starting values
 
2190
    value = datetime.timedelta() # Value so far
 
2191
    found_token = None
 
2192
    followers = frozenset((token_duration,)) # Following valid tokens
 
2193
    s = duration                # String left to parse
 
2194
    # Loop until end token is found
 
2195
    while found_token is not token_end:
 
2196
        # Search for any currently valid tokens
 
2197
        for token in followers:
 
2198
            match = token.regexp.match(s)
 
2199
            if match is not None:
 
2200
                # Token found
 
2201
                if token.value is not None:
 
2202
                    # Value found, parse digits
 
2203
                    factor = int(match.group(1), 10)
 
2204
                    # Add to value so far
 
2205
                    value += factor * token.value
 
2206
                # Strip token from string
 
2207
                s = token.regexp.sub("", s, 1)
 
2208
                # Go to found token
 
2209
                found_token = token
 
2210
                # Set valid next tokens
 
2211
                followers = found_token.followers
 
2212
                break
 
2213
        else:
 
2214
            # No currently valid tokens were found
 
2215
            raise ValueError("Invalid RFC 3339 duration")
 
2216
    # End token found
 
2217
    return value
 
2218
 
 
2219
 
1693
2220
def string_to_delta(interval):
1694
2221
    """Parse a string and return a datetime.timedelta
1695
2222
    
1706
2233
    >>> string_to_delta('5m 30s')
1707
2234
    datetime.timedelta(0, 330)
1708
2235
    """
 
2236
    
 
2237
    try:
 
2238
        return rfc3339_duration_to_delta(interval)
 
2239
    except ValueError:
 
2240
        pass
 
2241
    
1709
2242
    timevalue = datetime.timedelta(0)
1710
2243
    for s in interval.split():
1711
2244
        try:
1712
 
            suffix = unicode(s[-1])
 
2245
            suffix = s[-1]
1713
2246
            value = int(s[:-1])
1714
2247
            if suffix == "d":
1715
2248
                delta = datetime.timedelta(value)
1722
2255
            elif suffix == "w":
1723
2256
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1724
2257
            else:
1725
 
                raise ValueError("Unknown suffix %r" % suffix)
1726
 
        except (ValueError, IndexError) as e:
 
2258
                raise ValueError("Unknown suffix {!r}"
 
2259
                                 .format(suffix))
 
2260
        except IndexError as e:
1727
2261
            raise ValueError(*(e.args))
1728
2262
        timevalue += delta
1729
2263
    return timevalue
1730
2264
 
1731
2265
 
1732
 
def if_nametoindex(interface):
1733
 
    """Call the C function if_nametoindex(), or equivalent
1734
 
    
1735
 
    Note: This function cannot accept a unicode string."""
1736
 
    global if_nametoindex
1737
 
    try:
1738
 
        if_nametoindex = (ctypes.cdll.LoadLibrary
1739
 
                          (ctypes.util.find_library("c"))
1740
 
                          .if_nametoindex)
1741
 
    except (OSError, AttributeError):
1742
 
        logger.warning("Doing if_nametoindex the hard way")
1743
 
        def if_nametoindex(interface):
1744
 
            "Get an interface index the hard way, i.e. using fcntl()"
1745
 
            SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
1746
 
            with contextlib.closing(socket.socket()) as s:
1747
 
                ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1748
 
                                    struct.pack(str("16s16x"),
1749
 
                                                interface))
1750
 
            interface_index = struct.unpack(str("I"),
1751
 
                                            ifreq[16:20])[0]
1752
 
            return interface_index
1753
 
    return if_nametoindex(interface)
1754
 
 
1755
 
 
1756
2266
def daemon(nochdir = False, noclose = False):
1757
2267
    """See daemon(3).  Standard BSD Unix function.
1758
2268
    
1766
2276
        sys.exit()
1767
2277
    if not noclose:
1768
2278
        # Close all standard open file descriptors
1769
 
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
 
2279
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1770
2280
        if not stat.S_ISCHR(os.fstat(null).st_mode):
1771
 
            raise OSError(errno.ENODEV,
1772
 
                          "%s not a character device"
1773
 
                          % os.path.devnull)
 
2281
            raise OSError(errno.ENODEV, "{} not a character device"
 
2282
                          .format(os.devnull))
1774
2283
        os.dup2(null, sys.stdin.fileno())
1775
2284
        os.dup2(null, sys.stdout.fileno())
1776
2285
        os.dup2(null, sys.stderr.fileno())
1785
2294
    
1786
2295
    parser = argparse.ArgumentParser()
1787
2296
    parser.add_argument("-v", "--version", action="version",
1788
 
                        version = "%%(prog)s %s" % version,
 
2297
                        version = "%(prog)s {}".format(version),
1789
2298
                        help="show version number and exit")
1790
2299
    parser.add_argument("-i", "--interface", metavar="IF",
1791
2300
                        help="Bind to interface IF")
1797
2306
                        help="Run self-test")
1798
2307
    parser.add_argument("--debug", action="store_true",
1799
2308
                        help="Debug mode; run in foreground and log"
1800
 
                        " to terminal")
 
2309
                        " to terminal", default=None)
1801
2310
    parser.add_argument("--debuglevel", metavar="LEVEL",
1802
2311
                        help="Debug level for stdout output")
1803
2312
    parser.add_argument("--priority", help="GnuTLS"
1810
2319
                        " files")
1811
2320
    parser.add_argument("--no-dbus", action="store_false",
1812
2321
                        dest="use_dbus", help="Do not provide D-Bus"
1813
 
                        " system bus interface")
 
2322
                        " system bus interface", default=None)
1814
2323
    parser.add_argument("--no-ipv6", action="store_false",
1815
 
                        dest="use_ipv6", help="Do not use IPv6")
 
2324
                        dest="use_ipv6", help="Do not use IPv6",
 
2325
                        default=None)
 
2326
    parser.add_argument("--no-restore", action="store_false",
 
2327
                        dest="restore", help="Do not restore stored"
 
2328
                        " state", default=None)
 
2329
    parser.add_argument("--socket", type=int,
 
2330
                        help="Specify a file descriptor to a network"
 
2331
                        " socket to use instead of creating one")
 
2332
    parser.add_argument("--statedir", metavar="DIR",
 
2333
                        help="Directory to save/restore state in")
 
2334
    parser.add_argument("--foreground", action="store_true",
 
2335
                        help="Run in foreground", default=None)
 
2336
    parser.add_argument("--no-zeroconf", action="store_false",
 
2337
                        dest="zeroconf", help="Do not use Zeroconf",
 
2338
                        default=None)
 
2339
    
1816
2340
    options = parser.parse_args()
1817
2341
    
1818
2342
    if options.check:
1819
2343
        import doctest
1820
 
        doctest.testmod()
1821
 
        sys.exit()
 
2344
        fail_count, test_count = doctest.testmod()
 
2345
        sys.exit(os.EX_OK if fail_count == 0 else 1)
1822
2346
    
1823
2347
    # Default values for config file for server-global settings
1824
2348
    server_defaults = { "interface": "",
1826
2350
                        "port": "",
1827
2351
                        "debug": "False",
1828
2352
                        "priority":
1829
 
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
 
2353
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
1830
2354
                        "servicename": "Mandos",
1831
2355
                        "use_dbus": "True",
1832
2356
                        "use_ipv6": "True",
1833
2357
                        "debuglevel": "",
 
2358
                        "restore": "True",
 
2359
                        "socket": "",
 
2360
                        "statedir": "/var/lib/mandos",
 
2361
                        "foreground": "False",
 
2362
                        "zeroconf": "True",
1834
2363
                        }
1835
2364
    
1836
2365
    # Parse config file for server-global settings
1841
2370
    # Convert the SafeConfigParser object to a dict
1842
2371
    server_settings = server_config.defaults()
1843
2372
    # Use the appropriate methods on the non-string config options
1844
 
    for option in ("debug", "use_dbus", "use_ipv6"):
 
2373
    for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
1845
2374
        server_settings[option] = server_config.getboolean("DEFAULT",
1846
2375
                                                           option)
1847
2376
    if server_settings["port"]:
1848
2377
        server_settings["port"] = server_config.getint("DEFAULT",
1849
2378
                                                       "port")
 
2379
    if server_settings["socket"]:
 
2380
        server_settings["socket"] = server_config.getint("DEFAULT",
 
2381
                                                         "socket")
 
2382
        # Later, stdin will, and stdout and stderr might, be dup'ed
 
2383
        # over with an opened os.devnull.  But we don't want this to
 
2384
        # happen with a supplied network socket.
 
2385
        if 0 <= server_settings["socket"] <= 2:
 
2386
            server_settings["socket"] = os.dup(server_settings
 
2387
                                               ["socket"])
1850
2388
    del server_config
1851
2389
    
1852
2390
    # Override the settings from the config file with command line
1853
2391
    # options, if set.
1854
2392
    for option in ("interface", "address", "port", "debug",
1855
2393
                   "priority", "servicename", "configdir",
1856
 
                   "use_dbus", "use_ipv6", "debuglevel"):
 
2394
                   "use_dbus", "use_ipv6", "debuglevel", "restore",
 
2395
                   "statedir", "socket", "foreground", "zeroconf"):
1857
2396
        value = getattr(options, option)
1858
2397
        if value is not None:
1859
2398
            server_settings[option] = value
1860
2399
    del options
1861
2400
    # Force all strings to be unicode
1862
2401
    for option in server_settings.keys():
1863
 
        if type(server_settings[option]) is str:
1864
 
            server_settings[option] = unicode(server_settings[option])
 
2402
        if isinstance(server_settings[option], bytes):
 
2403
            server_settings[option] = (server_settings[option]
 
2404
                                       .decode("utf-8"))
 
2405
    # Force all boolean options to be boolean
 
2406
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
 
2407
                   "foreground", "zeroconf"):
 
2408
        server_settings[option] = bool(server_settings[option])
 
2409
    # Debug implies foreground
 
2410
    if server_settings["debug"]:
 
2411
        server_settings["foreground"] = True
1865
2412
    # Now we have our good server settings in "server_settings"
1866
2413
    
1867
2414
    ##################################################################
1868
2415
    
 
2416
    if (not server_settings["zeroconf"] and
 
2417
        not (server_settings["port"]
 
2418
             or server_settings["socket"] != "")):
 
2419
            parser.error("Needs port or socket to work without"
 
2420
                         " Zeroconf")
 
2421
    
1869
2422
    # For convenience
1870
2423
    debug = server_settings["debug"]
1871
2424
    debuglevel = server_settings["debuglevel"]
1872
2425
    use_dbus = server_settings["use_dbus"]
1873
2426
    use_ipv6 = server_settings["use_ipv6"]
 
2427
    stored_state_path = os.path.join(server_settings["statedir"],
 
2428
                                     stored_state_file)
 
2429
    foreground = server_settings["foreground"]
 
2430
    zeroconf = server_settings["zeroconf"]
 
2431
    
 
2432
    if debug:
 
2433
        initlogger(debug, logging.DEBUG)
 
2434
    else:
 
2435
        if not debuglevel:
 
2436
            initlogger(debug)
 
2437
        else:
 
2438
            level = getattr(logging, debuglevel.upper())
 
2439
            initlogger(debug, level)
1874
2440
    
1875
2441
    if server_settings["servicename"] != "Mandos":
1876
2442
        syslogger.setFormatter(logging.Formatter
1877
 
                               ('Mandos (%s) [%%(process)d]:'
1878
 
                                ' %%(levelname)s: %%(message)s'
1879
 
                                % server_settings["servicename"]))
 
2443
                               ('Mandos ({}) [%(process)d]:'
 
2444
                                ' %(levelname)s: %(message)s'
 
2445
                                .format(server_settings
 
2446
                                        ["servicename"])))
1880
2447
    
1881
2448
    # Parse config file with clients
1882
 
    client_defaults = { "timeout": "5m",
1883
 
                        "extended_timeout": "15m",
1884
 
                        "interval": "2m",
1885
 
                        "checker": "fping -q -- %%(host)s",
1886
 
                        "host": "",
1887
 
                        "approval_delay": "0s",
1888
 
                        "approval_duration": "1s",
1889
 
                        }
1890
 
    client_config = configparser.SafeConfigParser(client_defaults)
 
2449
    client_config = configparser.SafeConfigParser(Client
 
2450
                                                  .client_defaults)
1891
2451
    client_config.read(os.path.join(server_settings["configdir"],
1892
2452
                                    "clients.conf"))
1893
2453
    
1894
2454
    global mandos_dbus_service
1895
2455
    mandos_dbus_service = None
1896
2456
    
 
2457
    socketfd = None
 
2458
    if server_settings["socket"] != "":
 
2459
        socketfd = server_settings["socket"]
1897
2460
    tcp_server = MandosServer((server_settings["address"],
1898
2461
                               server_settings["port"]),
1899
2462
                              ClientHandler,
1902
2465
                              use_ipv6=use_ipv6,
1903
2466
                              gnutls_priority=
1904
2467
                              server_settings["priority"],
1905
 
                              use_dbus=use_dbus)
1906
 
    if not debug:
1907
 
        pidfilename = "/var/run/mandos.pid"
 
2468
                              use_dbus=use_dbus,
 
2469
                              socketfd=socketfd)
 
2470
    if not foreground:
 
2471
        pidfilename = "/run/mandos.pid"
 
2472
        if not os.path.isdir("/run/."):
 
2473
            pidfilename = "/var/run/mandos.pid"
 
2474
        pidfile = None
1908
2475
        try:
1909
2476
            pidfile = open(pidfilename, "w")
1910
 
        except IOError:
1911
 
            logger.error("Could not open file %r", pidfilename)
 
2477
        except IOError as e:
 
2478
            logger.error("Could not open file %r", pidfilename,
 
2479
                         exc_info=e)
1912
2480
    
1913
 
    try:
1914
 
        uid = pwd.getpwnam("_mandos").pw_uid
1915
 
        gid = pwd.getpwnam("_mandos").pw_gid
1916
 
    except KeyError:
 
2481
    for name in ("_mandos", "mandos", "nobody"):
1917
2482
        try:
1918
 
            uid = pwd.getpwnam("mandos").pw_uid
1919
 
            gid = pwd.getpwnam("mandos").pw_gid
 
2483
            uid = pwd.getpwnam(name).pw_uid
 
2484
            gid = pwd.getpwnam(name).pw_gid
 
2485
            break
1920
2486
        except KeyError:
1921
 
            try:
1922
 
                uid = pwd.getpwnam("nobody").pw_uid
1923
 
                gid = pwd.getpwnam("nobody").pw_gid
1924
 
            except KeyError:
1925
 
                uid = 65534
1926
 
                gid = 65534
 
2487
            continue
 
2488
    else:
 
2489
        uid = 65534
 
2490
        gid = 65534
1927
2491
    try:
1928
2492
        os.setgid(gid)
1929
2493
        os.setuid(uid)
1930
2494
    except OSError as error:
1931
 
        if error[0] != errno.EPERM:
1932
 
            raise error
1933
 
    
1934
 
    if not debug and not debuglevel:
1935
 
        syslogger.setLevel(logging.WARNING)
1936
 
        console.setLevel(logging.WARNING)
1937
 
    if debuglevel:
1938
 
        level = getattr(logging, debuglevel.upper())
1939
 
        syslogger.setLevel(level)
1940
 
        console.setLevel(level)
 
2495
        if error.errno != errno.EPERM:
 
2496
            raise
1941
2497
    
1942
2498
    if debug:
1943
2499
        # Enable all possible GnuTLS debugging
1954
2510
         .gnutls_global_set_log_function(debug_gnutls))
1955
2511
        
1956
2512
        # Redirect stdin so all checkers get /dev/null
1957
 
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
 
2513
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1958
2514
        os.dup2(null, sys.stdin.fileno())
1959
2515
        if null > 2:
1960
2516
            os.close(null)
1961
 
    else:
1962
 
        # No console logging
1963
 
        logger.removeHandler(console)
1964
2517
    
1965
2518
    # Need to fork before connecting to D-Bus
1966
 
    if not debug:
 
2519
    if not foreground:
1967
2520
        # Close all input and output, do double fork, etc.
1968
2521
        daemon()
1969
2522
    
 
2523
    # multiprocessing will use threads, so before we use gobject we
 
2524
    # need to inform gobject that threads will be used.
 
2525
    gobject.threads_init()
 
2526
    
1970
2527
    global main_loop
1971
2528
    # From the Avahi example code
1972
 
    DBusGMainLoop(set_as_default=True )
 
2529
    DBusGMainLoop(set_as_default=True)
1973
2530
    main_loop = gobject.MainLoop()
1974
2531
    bus = dbus.SystemBus()
1975
2532
    # End of Avahi example code
1977
2534
        try:
1978
2535
            bus_name = dbus.service.BusName("se.recompile.Mandos",
1979
2536
                                            bus, do_not_queue=True)
1980
 
            old_bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",
1981
 
                                                bus, do_not_queue=True)
 
2537
            old_bus_name = (dbus.service.BusName
 
2538
                            ("se.bsnet.fukt.Mandos", bus,
 
2539
                             do_not_queue=True))
1982
2540
        except dbus.exceptions.NameExistsException as e:
1983
 
            logger.error(unicode(e) + ", disabling D-Bus")
 
2541
            logger.error("Disabling D-Bus:", exc_info=e)
1984
2542
            use_dbus = False
1985
2543
            server_settings["use_dbus"] = False
1986
2544
            tcp_server.use_dbus = False
1987
 
    protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1988
 
    service = AvahiService(name = server_settings["servicename"],
1989
 
                           servicetype = "_mandos._tcp",
1990
 
                           protocol = protocol, bus = bus)
1991
 
    if server_settings["interface"]:
1992
 
        service.interface = (if_nametoindex
1993
 
                             (str(server_settings["interface"])))
 
2545
    if zeroconf:
 
2546
        protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
 
2547
        service = AvahiServiceToSyslog(name =
 
2548
                                       server_settings["servicename"],
 
2549
                                       servicetype = "_mandos._tcp",
 
2550
                                       protocol = protocol, bus = bus)
 
2551
        if server_settings["interface"]:
 
2552
            service.interface = (if_nametoindex
 
2553
                                 (server_settings["interface"]
 
2554
                                  .encode("utf-8")))
1994
2555
    
1995
2556
    global multiprocessing_manager
1996
2557
    multiprocessing_manager = multiprocessing.Manager()
1997
2558
    
1998
2559
    client_class = Client
1999
2560
    if use_dbus:
2000
 
        client_class = functools.partial(ClientDBusTransitional, bus = bus)        
2001
 
    def client_config_items(config, section):
2002
 
        special_settings = {
2003
 
            "approved_by_default":
2004
 
                lambda: config.getboolean(section,
2005
 
                                          "approved_by_default"),
2006
 
            }
2007
 
        for name, value in config.items(section):
 
2561
        client_class = functools.partial(ClientDBus, bus = bus)
 
2562
    
 
2563
    client_settings = Client.config_parser(client_config)
 
2564
    old_client_settings = {}
 
2565
    clients_data = {}
 
2566
    
 
2567
    # This is used to redirect stdout and stderr for checker processes
 
2568
    global wnull
 
2569
    wnull = open(os.devnull, "w") # A writable /dev/null
 
2570
    # Only used if server is running in foreground but not in debug
 
2571
    # mode
 
2572
    if debug or not foreground:
 
2573
        wnull.close()
 
2574
    
 
2575
    # Get client data and settings from last running state.
 
2576
    if server_settings["restore"]:
 
2577
        try:
 
2578
            with open(stored_state_path, "rb") as stored_state:
 
2579
                clients_data, old_client_settings = (pickle.load
 
2580
                                                     (stored_state))
 
2581
            os.remove(stored_state_path)
 
2582
        except IOError as e:
 
2583
            if e.errno == errno.ENOENT:
 
2584
                logger.warning("Could not load persistent state: {}"
 
2585
                                .format(os.strerror(e.errno)))
 
2586
            else:
 
2587
                logger.critical("Could not load persistent state:",
 
2588
                                exc_info=e)
 
2589
                raise
 
2590
        except EOFError as e:
 
2591
            logger.warning("Could not load persistent state: "
 
2592
                           "EOFError:", exc_info=e)
 
2593
    
 
2594
    with PGPEngine() as pgp:
 
2595
        for client_name, client in clients_data.items():
 
2596
            # Skip removed clients
 
2597
            if client_name not in client_settings:
 
2598
                continue
 
2599
            
 
2600
            # Decide which value to use after restoring saved state.
 
2601
            # We have three different values: Old config file,
 
2602
            # new config file, and saved state.
 
2603
            # New config value takes precedence if it differs from old
 
2604
            # config value, otherwise use saved state.
 
2605
            for name, value in client_settings[client_name].items():
 
2606
                try:
 
2607
                    # For each value in new config, check if it
 
2608
                    # differs from the old config value (Except for
 
2609
                    # the "secret" attribute)
 
2610
                    if (name != "secret" and
 
2611
                        value != old_client_settings[client_name]
 
2612
                        [name]):
 
2613
                        client[name] = value
 
2614
                except KeyError:
 
2615
                    pass
 
2616
            
 
2617
            # Clients who has passed its expire date can still be
 
2618
            # enabled if its last checker was successful.  Clients
 
2619
            # whose checker succeeded before we stored its state is
 
2620
            # assumed to have successfully run all checkers during
 
2621
            # downtime.
 
2622
            if client["enabled"]:
 
2623
                if datetime.datetime.utcnow() >= client["expires"]:
 
2624
                    if not client["last_checked_ok"]:
 
2625
                        logger.warning(
 
2626
                            "disabling client {} - Client never "
 
2627
                            "performed a successful checker"
 
2628
                            .format(client_name))
 
2629
                        client["enabled"] = False
 
2630
                    elif client["last_checker_status"] != 0:
 
2631
                        logger.warning(
 
2632
                            "disabling client {} - Client last"
 
2633
                            " checker failed with error code {}"
 
2634
                            .format(client_name,
 
2635
                                    client["last_checker_status"]))
 
2636
                        client["enabled"] = False
 
2637
                    else:
 
2638
                        client["expires"] = (datetime.datetime
 
2639
                                             .utcnow()
 
2640
                                             + client["timeout"])
 
2641
                        logger.debug("Last checker succeeded,"
 
2642
                                     " keeping {} enabled"
 
2643
                                     .format(client_name))
2008
2644
            try:
2009
 
                yield (name, special_settings[name]())
2010
 
            except KeyError:
2011
 
                yield (name, value)
2012
 
    
2013
 
    tcp_server.clients.update(set(
2014
 
            client_class(name = section,
2015
 
                         config= dict(client_config_items(
2016
 
                        client_config, section)))
2017
 
            for section in client_config.sections()))
 
2645
                client["secret"] = (
 
2646
                    pgp.decrypt(client["encrypted_secret"],
 
2647
                                client_settings[client_name]
 
2648
                                ["secret"]))
 
2649
            except PGPError:
 
2650
                # If decryption fails, we use secret from new settings
 
2651
                logger.debug("Failed to decrypt {} old secret"
 
2652
                             .format(client_name))
 
2653
                client["secret"] = (
 
2654
                    client_settings[client_name]["secret"])
 
2655
    
 
2656
    # Add/remove clients based on new changes made to config
 
2657
    for client_name in (set(old_client_settings)
 
2658
                        - set(client_settings)):
 
2659
        del clients_data[client_name]
 
2660
    for client_name in (set(client_settings)
 
2661
                        - set(old_client_settings)):
 
2662
        clients_data[client_name] = client_settings[client_name]
 
2663
    
 
2664
    # Create all client objects
 
2665
    for client_name, client in clients_data.items():
 
2666
        tcp_server.clients[client_name] = client_class(
 
2667
            name = client_name, settings = client,
 
2668
            server_settings = server_settings)
 
2669
    
2018
2670
    if not tcp_server.clients:
2019
2671
        logger.warning("No clients defined")
2020
 
        
2021
 
    if not debug:
2022
 
        try:
2023
 
            with pidfile:
2024
 
                pid = os.getpid()
2025
 
                pidfile.write(str(pid) + "\n".encode("utf-8"))
2026
 
            del pidfile
2027
 
        except IOError:
2028
 
            logger.error("Could not write to file %r with PID %d",
2029
 
                         pidfilename, pid)
2030
 
        except NameError:
2031
 
            # "pidfile" was never created
2032
 
            pass
 
2672
    
 
2673
    if not foreground:
 
2674
        if pidfile is not None:
 
2675
            try:
 
2676
                with pidfile:
 
2677
                    pid = os.getpid()
 
2678
                    pidfile.write("{}\n".format(pid).encode("utf-8"))
 
2679
            except IOError:
 
2680
                logger.error("Could not write to file %r with PID %d",
 
2681
                             pidfilename, pid)
 
2682
        del pidfile
2033
2683
        del pidfilename
2034
 
        
2035
 
        signal.signal(signal.SIGINT, signal.SIG_IGN)
2036
2684
    
2037
2685
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2038
2686
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2039
2687
    
2040
2688
    if use_dbus:
2041
 
        class MandosDBusService(dbus.service.Object):
 
2689
        @alternate_dbus_interfaces({"se.recompile.Mandos":
 
2690
                                        "se.bsnet.fukt.Mandos"})
 
2691
        class MandosDBusService(DBusObjectWithProperties):
2042
2692
            """A D-Bus proxy object"""
2043
2693
            def __init__(self):
2044
2694
                dbus.service.Object.__init__(self, bus, "/")
2045
2695
            _interface = "se.recompile.Mandos"
2046
2696
            
 
2697
            @dbus_interface_annotations(_interface)
 
2698
            def _foo(self):
 
2699
                return { "org.freedesktop.DBus.Property"
 
2700
                         ".EmitsChangedSignal":
 
2701
                             "false"}
 
2702
            
2047
2703
            @dbus.service.signal(_interface, signature="o")
2048
2704
            def ClientAdded(self, objpath):
2049
2705
                "D-Bus signal"
2063
2719
            def GetAllClients(self):
2064
2720
                "D-Bus method"
2065
2721
                return dbus.Array(c.dbus_object_path
2066
 
                                  for c in tcp_server.clients)
 
2722
                                  for c in
 
2723
                                  tcp_server.clients.itervalues())
2067
2724
            
2068
2725
            @dbus.service.method(_interface,
2069
2726
                                 out_signature="a{oa{sv}}")
2070
2727
            def GetAllClientsWithProperties(self):
2071
2728
                "D-Bus method"
2072
2729
                return dbus.Dictionary(
2073
 
                    ((c.dbus_object_path, c.GetAll(""))
2074
 
                     for c in tcp_server.clients),
 
2730
                    { c.dbus_object_path: c.GetAll("")
 
2731
                      for c in tcp_server.clients.itervalues() },
2075
2732
                    signature="oa{sv}")
2076
2733
            
2077
2734
            @dbus.service.method(_interface, in_signature="o")
2078
2735
            def RemoveClient(self, object_path):
2079
2736
                "D-Bus method"
2080
 
                for c in tcp_server.clients:
 
2737
                for c in tcp_server.clients.itervalues():
2081
2738
                    if c.dbus_object_path == object_path:
2082
 
                        tcp_server.clients.remove(c)
 
2739
                        del tcp_server.clients[c.name]
2083
2740
                        c.remove_from_connection()
2084
2741
                        # Don't signal anything except ClientRemoved
2085
2742
                        c.disable(quiet=True)
2090
2747
            
2091
2748
            del _interface
2092
2749
        
2093
 
        class MandosDBusServiceTransitional(MandosDBusService):
2094
 
            __metaclass__ = AlternateDBusNamesMetaclass
2095
 
        mandos_dbus_service = MandosDBusServiceTransitional()
 
2750
        mandos_dbus_service = MandosDBusService()
2096
2751
    
2097
2752
    def cleanup():
2098
2753
        "Cleanup function; run on exit"
2099
 
        service.cleanup()
2100
 
        
 
2754
        if zeroconf:
 
2755
            service.cleanup()
 
2756
        
 
2757
        multiprocessing.active_children()
 
2758
        wnull.close()
 
2759
        if not (tcp_server.clients or client_settings):
 
2760
            return
 
2761
        
 
2762
        # Store client before exiting. Secrets are encrypted with key
 
2763
        # based on what config file has. If config file is
 
2764
        # removed/edited, old secret will thus be unrecovable.
 
2765
        clients = {}
 
2766
        with PGPEngine() as pgp:
 
2767
            for client in tcp_server.clients.itervalues():
 
2768
                key = client_settings[client.name]["secret"]
 
2769
                client.encrypted_secret = pgp.encrypt(client.secret,
 
2770
                                                      key)
 
2771
                client_dict = {}
 
2772
                
 
2773
                # A list of attributes that can not be pickled
 
2774
                # + secret.
 
2775
                exclude = { "bus", "changedstate", "secret",
 
2776
                            "checker", "server_settings" }
 
2777
                for name, typ in (inspect.getmembers
 
2778
                                  (dbus.service.Object)):
 
2779
                    exclude.add(name)
 
2780
                
 
2781
                client_dict["encrypted_secret"] = (client
 
2782
                                                   .encrypted_secret)
 
2783
                for attr in client.client_structure:
 
2784
                    if attr not in exclude:
 
2785
                        client_dict[attr] = getattr(client, attr)
 
2786
                
 
2787
                clients[client.name] = client_dict
 
2788
                del client_settings[client.name]["secret"]
 
2789
        
 
2790
        try:
 
2791
            with (tempfile.NamedTemporaryFile
 
2792
                  (mode='wb', suffix=".pickle", prefix='clients-',
 
2793
                   dir=os.path.dirname(stored_state_path),
 
2794
                   delete=False)) as stored_state:
 
2795
                pickle.dump((clients, client_settings), stored_state)
 
2796
                tempname=stored_state.name
 
2797
            os.rename(tempname, stored_state_path)
 
2798
        except (IOError, OSError) as e:
 
2799
            if not debug:
 
2800
                try:
 
2801
                    os.remove(tempname)
 
2802
                except NameError:
 
2803
                    pass
 
2804
            if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
 
2805
                logger.warning("Could not save persistent state: {}"
 
2806
                               .format(os.strerror(e.errno)))
 
2807
            else:
 
2808
                logger.warning("Could not save persistent state:",
 
2809
                               exc_info=e)
 
2810
                raise
 
2811
        
 
2812
        # Delete all clients, and settings from config
2101
2813
        while tcp_server.clients:
2102
 
            client = tcp_server.clients.pop()
 
2814
            name, client = tcp_server.clients.popitem()
2103
2815
            if use_dbus:
2104
2816
                client.remove_from_connection()
2105
 
            client.disable_hook = None
2106
2817
            # Don't signal anything except ClientRemoved
2107
2818
            client.disable(quiet=True)
2108
2819
            if use_dbus:
2109
2820
                # Emit D-Bus signal
2110
 
                mandos_dbus_service.ClientRemoved(client.dbus_object_path,
 
2821
                mandos_dbus_service.ClientRemoved(client
 
2822
                                                  .dbus_object_path,
2111
2823
                                                  client.name)
 
2824
        client_settings.clear()
2112
2825
    
2113
2826
    atexit.register(cleanup)
2114
2827
    
2115
 
    for client in tcp_server.clients:
 
2828
    for client in tcp_server.clients.itervalues():
2116
2829
        if use_dbus:
2117
2830
            # Emit D-Bus signal
2118
2831
            mandos_dbus_service.ClientAdded(client.dbus_object_path)
2119
 
        client.enable()
 
2832
        # Need to initiate checking of clients
 
2833
        if client.enabled:
 
2834
            client.init_checker()
2120
2835
    
2121
2836
    tcp_server.enable()
2122
2837
    tcp_server.server_activate()
2123
2838
    
2124
2839
    # Find out what port we got
2125
 
    service.port = tcp_server.socket.getsockname()[1]
 
2840
    if zeroconf:
 
2841
        service.port = tcp_server.socket.getsockname()[1]
2126
2842
    if use_ipv6:
2127
2843
        logger.info("Now listening on address %r, port %d,"
2128
 
                    " flowinfo %d, scope_id %d"
2129
 
                    % tcp_server.socket.getsockname())
 
2844
                    " flowinfo %d, scope_id %d",
 
2845
                    *tcp_server.socket.getsockname())
2130
2846
    else:                       # IPv4
2131
 
        logger.info("Now listening on address %r, port %d"
2132
 
                    % tcp_server.socket.getsockname())
 
2847
        logger.info("Now listening on address %r, port %d",
 
2848
                    *tcp_server.socket.getsockname())
2133
2849
    
2134
2850
    #service.interface = tcp_server.socket.getsockname()[3]
2135
2851
    
2136
2852
    try:
2137
 
        # From the Avahi example code
2138
 
        try:
2139
 
            service.activate()
2140
 
        except dbus.exceptions.DBusException as error:
2141
 
            logger.critical("DBusException: %s", error)
2142
 
            cleanup()
2143
 
            sys.exit(1)
2144
 
        # End of Avahi example code
 
2853
        if zeroconf:
 
2854
            # From the Avahi example code
 
2855
            try:
 
2856
                service.activate()
 
2857
            except dbus.exceptions.DBusException as error:
 
2858
                logger.critical("D-Bus Exception", exc_info=error)
 
2859
                cleanup()
 
2860
                sys.exit(1)
 
2861
            # End of Avahi example code
2145
2862
        
2146
2863
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2147
2864
                             lambda *args, **kwargs:
2151
2868
        logger.debug("Starting main loop")
2152
2869
        main_loop.run()
2153
2870
    except AvahiError as error:
2154
 
        logger.critical("AvahiError: %s", error)
 
2871
        logger.critical("Avahi Error", exc_info=error)
2155
2872
        cleanup()
2156
2873
        sys.exit(1)
2157
2874
    except KeyboardInterrupt:
2162
2879
    # Must run before the D-Bus bus name gets deregistered
2163
2880
    cleanup()
2164
2881
 
2165
 
 
2166
2882
if __name__ == '__main__':
2167
2883
    main()