/mandos/trunk

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2011-11-26 23:08:17 UTC
  • mto: (518.1.8 mandos-persistent)
  • mto: This revision was merged to the branch mainline in revision 524.
  • Revision ID: teddy@recompile.se-20111126230817-tv08v831s2yltbkd
Make "enabled" a client config option.

* DBUS-API: Fix wording on "Expires" option.
* clients.conf (enabled): New.
* mandos (Client): "last_enabled" can now be None.
  (Client.__init__): Get "enabled" from config.  Only set
                     "last_enabled" and "expires" if enabled.
  (ClientDBus.Created_dbus_property): Removed redundant dbus.String().
  (ClientDBus.Interval_dbus_property): If changed, only reschedule
                                       checker if enabled.
  (main/special_settings): Added "enabled".
* mandos-clients.conf (OPTIONS): Added "enabled".

Show diffs side-by-side

added added

removed removed

Lines of Context:
11
11
# "AvahiService" class, and some lines in "main".
12
12
13
13
# Everything else is
14
 
# Copyright © 2008-2013 Teddy Hogeborn
15
 
# Copyright © 2008-2013 Björn Påhlsson
 
14
# Copyright © 2008-2011 Teddy Hogeborn
 
15
# Copyright © 2008-2011 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
 
 
39
37
import SocketServer as socketserver
40
38
import socket
41
39
import argparse
67
65
import types
68
66
import binascii
69
67
import tempfile
70
 
import itertools
71
 
import collections
72
68
 
73
69
import dbus
74
70
import dbus.service
79
75
import ctypes.util
80
76
import xml.dom.minidom
81
77
import inspect
 
78
import GnuPGInterface
82
79
 
83
80
try:
84
81
    SO_BINDTODEVICE = socket.SO_BINDTODEVICE
88
85
    except ImportError:
89
86
        SO_BINDTODEVICE = None
90
87
 
91
 
version = "1.6.2"
 
88
 
 
89
version = "1.4.1"
92
90
stored_state_file = "clients.pickle"
93
91
 
94
92
logger = logging.getLogger()
113
111
        return interface_index
114
112
 
115
113
 
116
 
def initlogger(debug, level=logging.WARNING):
 
114
def initlogger(level=logging.WARNING):
117
115
    """init logger and add loglevel"""
118
116
    
119
117
    syslogger.setFormatter(logging.Formatter
121
119
                            ' %(message)s'))
122
120
    logger.addHandler(syslogger)
123
121
    
124
 
    if debug:
125
 
        console = logging.StreamHandler()
126
 
        console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
127
 
                                               ' [%(process)d]:'
128
 
                                               ' %(levelname)s:'
129
 
                                               ' %(message)s'))
130
 
        logger.addHandler(console)
 
122
    console = logging.StreamHandler()
 
123
    console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
 
124
                                           ' [%(process)d]:'
 
125
                                           ' %(levelname)s:'
 
126
                                           ' %(message)s'))
 
127
    logger.addHandler(console)
131
128
    logger.setLevel(level)
132
129
 
133
130
 
134
 
class PGPError(Exception):
135
 
    """Exception if encryption/decryption fails"""
 
131
class CryptoError(Exception):
136
132
    pass
137
133
 
138
134
 
139
 
class PGPEngine(object):
 
135
class Crypto(object):
140
136
    """A simple class for OpenPGP symmetric encryption & decryption"""
141
137
    def __init__(self):
 
138
        self.gnupg = GnuPGInterface.GnuPG()
142
139
        self.tempdir = tempfile.mkdtemp(prefix="mandos-")
143
 
        self.gnupgargs = ['--batch',
144
 
                          '--home', self.tempdir,
145
 
                          '--force-mdc',
146
 
                          '--quiet',
147
 
                          '--no-use-agent']
 
140
        self.gnupg = GnuPGInterface.GnuPG()
 
141
        self.gnupg.options.meta_interactive = False
 
142
        self.gnupg.options.homedir = self.tempdir
 
143
        self.gnupg.options.extra_args.extend(['--force-mdc',
 
144
                                              '--quiet'])
148
145
    
149
146
    def __enter__(self):
150
147
        return self
151
148
    
152
 
    def __exit__(self, exc_type, exc_value, traceback):
 
149
    def __exit__ (self, exc_type, exc_value, traceback):
153
150
        self._cleanup()
154
151
        return False
155
152
    
172
169
    def password_encode(self, password):
173
170
        # Passphrase can not be empty and can not contain newlines or
174
171
        # NUL bytes.  So we prefix it and hex encode it.
175
 
        encoded = b"mandos" + binascii.hexlify(password)
176
 
        if len(encoded) > 2048:
177
 
            # GnuPG can't handle long passwords, so encode differently
178
 
            encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
179
 
                       .replace(b"\n", b"\\n")
180
 
                       .replace(b"\0", b"\\x00"))
181
 
        return encoded
 
172
        return b"mandos" + binascii.hexlify(password)
182
173
    
183
174
    def encrypt(self, data, password):
184
 
        passphrase = self.password_encode(password)
185
 
        with tempfile.NamedTemporaryFile(dir=self.tempdir
186
 
                                         ) as passfile:
187
 
            passfile.write(passphrase)
188
 
            passfile.flush()
189
 
            proc = subprocess.Popen(['gpg', '--symmetric',
190
 
                                     '--passphrase-file',
191
 
                                     passfile.name]
192
 
                                    + self.gnupgargs,
193
 
                                    stdin = subprocess.PIPE,
194
 
                                    stdout = subprocess.PIPE,
195
 
                                    stderr = subprocess.PIPE)
196
 
            ciphertext, err = proc.communicate(input = data)
197
 
        if proc.returncode != 0:
198
 
            raise PGPError(err)
 
175
        self.gnupg.passphrase = self.password_encode(password)
 
176
        with open(os.devnull) as devnull:
 
177
            try:
 
178
                proc = self.gnupg.run(['--symmetric'],
 
179
                                      create_fhs=['stdin', 'stdout'],
 
180
                                      attach_fhs={'stderr': devnull})
 
181
                with contextlib.closing(proc.handles['stdin']) as f:
 
182
                    f.write(data)
 
183
                with contextlib.closing(proc.handles['stdout']) as f:
 
184
                    ciphertext = f.read()
 
185
                proc.wait()
 
186
            except IOError as e:
 
187
                raise CryptoError(e)
 
188
        self.gnupg.passphrase = None
199
189
        return ciphertext
200
190
    
201
191
    def decrypt(self, data, password):
202
 
        passphrase = self.password_encode(password)
203
 
        with tempfile.NamedTemporaryFile(dir = self.tempdir
204
 
                                         ) as passfile:
205
 
            passfile.write(passphrase)
206
 
            passfile.flush()
207
 
            proc = subprocess.Popen(['gpg', '--decrypt',
208
 
                                     '--passphrase-file',
209
 
                                     passfile.name]
210
 
                                    + self.gnupgargs,
211
 
                                    stdin = subprocess.PIPE,
212
 
                                    stdout = subprocess.PIPE,
213
 
                                    stderr = subprocess.PIPE)
214
 
            decrypted_plaintext, err = proc.communicate(input
215
 
                                                        = data)
216
 
        if proc.returncode != 0:
217
 
            raise PGPError(err)
 
192
        self.gnupg.passphrase = self.password_encode(password)
 
193
        with open(os.devnull) as devnull:
 
194
            try:
 
195
                proc = self.gnupg.run(['--decrypt'],
 
196
                                      create_fhs=['stdin', 'stdout'],
 
197
                                      attach_fhs={'stderr': devnull})
 
198
                with contextlib.closing(proc.handles['stdin'] ) as f:
 
199
                    f.write(data)
 
200
                with contextlib.closing(proc.handles['stdout']) as f:
 
201
                    decrypted_plaintext = f.read()
 
202
                proc.wait()
 
203
            except IOError as e:
 
204
                raise CryptoError(e)
 
205
        self.gnupg.passphrase = None
218
206
        return decrypted_plaintext
219
207
 
220
208
 
 
209
 
221
210
class AvahiError(Exception):
222
211
    def __init__(self, value, *args, **kwargs):
223
212
        self.value = value
240
229
               Used to optionally bind to the specified interface.
241
230
    name: string; Example: 'Mandos'
242
231
    type: string; Example: '_mandos._tcp'.
243
 
     See <https://www.iana.org/assignments/service-names-port-numbers>
 
232
                  See <http://www.dns-sd.org/ServiceTypes.html>
244
233
    port: integer; what port to announce
245
234
    TXT: list of strings; TXT record for the service
246
235
    domain: string; Domain to publish on, default to .local if empty.
252
241
    server: D-Bus Server
253
242
    bus: dbus.SystemBus()
254
243
    """
255
 
    
256
244
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
257
245
                 servicetype = None, port = None, TXT = None,
258
246
                 domain = "", host = "", max_renames = 32768,
271
259
        self.server = None
272
260
        self.bus = bus
273
261
        self.entry_group_state_changed_match = None
274
 
    
275
262
    def rename(self):
276
263
        """Derived from the Avahi example code"""
277
264
        if self.rename_count >= self.max_renames:
287
274
        try:
288
275
            self.add()
289
276
        except dbus.exceptions.DBusException as error:
290
 
            logger.critical("D-Bus Exception", exc_info=error)
 
277
            logger.critical("DBusException: %s", error)
291
278
            self.cleanup()
292
279
            os._exit(1)
293
280
        self.rename_count += 1
294
 
    
295
281
    def remove(self):
296
282
        """Derived from the Avahi example code"""
297
283
        if self.entry_group_state_changed_match is not None:
299
285
            self.entry_group_state_changed_match = None
300
286
        if self.group is not None:
301
287
            self.group.Reset()
302
 
    
303
288
    def add(self):
304
289
        """Derived from the Avahi example code"""
305
290
        self.remove()
322
307
            dbus.UInt16(self.port),
323
308
            avahi.string_array_to_txt_array(self.TXT))
324
309
        self.group.Commit()
325
 
    
326
310
    def entry_group_state_changed(self, state, error):
327
311
        """Derived from the Avahi example code"""
328
312
        logger.debug("Avahi entry group state change: %i", state)
335
319
        elif state == avahi.ENTRY_GROUP_FAILURE:
336
320
            logger.critical("Avahi: Error in group state changed %s",
337
321
                            unicode(error))
338
 
            raise AvahiGroupError("State changed: {0!s}"
339
 
                                  .format(error))
340
 
    
 
322
            raise AvahiGroupError("State changed: %s"
 
323
                                  % unicode(error))
341
324
    def cleanup(self):
342
325
        """Derived from the Avahi example code"""
343
326
        if self.group is not None:
348
331
                pass
349
332
            self.group = None
350
333
        self.remove()
351
 
    
352
334
    def server_state_changed(self, state, error=None):
353
335
        """Derived from the Avahi example code"""
354
336
        logger.debug("Avahi server state change: %i", state)
373
355
                logger.debug("Unknown state: %r", state)
374
356
            else:
375
357
                logger.debug("Unknown state: %r: %r", state, error)
376
 
    
377
358
    def activate(self):
378
359
        """Derived from the Avahi example code"""
379
360
        if self.server is None:
386
367
                                 self.server_state_changed)
387
368
        self.server_state_changed(self.server.GetState())
388
369
 
389
 
 
390
370
class AvahiServiceToSyslog(AvahiService):
391
371
    def rename(self):
392
372
        """Add the new name to the syslog messages"""
393
373
        ret = AvahiService.rename(self)
394
374
        syslogger.setFormatter(logging.Formatter
395
 
                               ('Mandos ({0}) [%(process)d]:'
396
 
                                ' %(levelname)s: %(message)s'
397
 
                                .format(self.name)))
 
375
                               ('Mandos (%s) [%%(process)d]:'
 
376
                                ' %%(levelname)s: %%(message)s'
 
377
                                % self.name))
398
378
        return ret
399
379
 
400
 
 
401
 
def timedelta_to_milliseconds(td):
 
380
def _timedelta_to_milliseconds(td):
402
381
    "Convert a datetime.timedelta() to milliseconds"
403
382
    return ((td.days * 24 * 60 * 60 * 1000)
404
383
            + (td.seconds * 1000)
405
384
            + (td.microseconds // 1000))
406
 
 
407
 
 
 
385
        
408
386
class Client(object):
409
387
    """A representation of a client host served by this server.
410
388
    
411
389
    Attributes:
412
 
    approved:   bool(); 'None' if not yet approved/disapproved
 
390
    _approved:   bool(); 'None' if not yet approved/disapproved
413
391
    approval_delay: datetime.timedelta(); Time to wait for approval
414
392
    approval_duration: datetime.timedelta(); Duration of one approval
415
393
    checker:    subprocess.Popen(); a running checker process used
433
411
    interval:   datetime.timedelta(); How often to start a new checker
434
412
    last_approval_request: datetime.datetime(); (UTC) or None
435
413
    last_checked_ok: datetime.datetime(); (UTC) or None
 
414
 
436
415
    last_checker_status: integer between 0 and 255 reflecting exit
437
416
                         status of last checker. -1 reflects crashed
438
 
                         checker, -2 means no checker completed yet.
 
417
                         checker, or None.
439
418
    last_enabled: datetime.datetime(); (UTC) or None
440
419
    name:       string; from the config file, used in log messages and
441
420
                        D-Bus identifiers
442
421
    secret:     bytestring; sent verbatim (over TLS) to client
443
422
    timeout:    datetime.timedelta(); How long from last_checked_ok
444
423
                                      until this client is disabled
445
 
    extended_timeout:   extra long timeout when secret has been sent
 
424
    extended_timeout:   extra long timeout when password has been sent
446
425
    runtime_expansions: Allowed attributes for runtime expansion.
447
426
    expires:    datetime.datetime(); time (UTC) when a client will be
448
427
                disabled, or None
449
 
    server_settings: The server_settings dict from main()
450
428
    """
451
429
    
452
430
    runtime_expansions = ("approval_delay", "approval_duration",
453
 
                          "created", "enabled", "expires",
454
 
                          "fingerprint", "host", "interval",
455
 
                          "last_approval_request", "last_checked_ok",
 
431
                          "created", "enabled", "fingerprint",
 
432
                          "host", "interval", "last_checked_ok",
456
433
                          "last_enabled", "name", "timeout")
457
 
    client_defaults = { "timeout": "PT5M",
458
 
                        "extended_timeout": "PT15M",
459
 
                        "interval": "PT2M",
460
 
                        "checker": "fping -q -- %%(host)s",
461
 
                        "host": "",
462
 
                        "approval_delay": "PT0S",
463
 
                        "approval_duration": "PT1S",
464
 
                        "approved_by_default": "True",
465
 
                        "enabled": "True",
466
 
                        }
467
434
    
468
435
    def timeout_milliseconds(self):
469
436
        "Return the 'timeout' attribute in milliseconds"
470
 
        return timedelta_to_milliseconds(self.timeout)
 
437
        return _timedelta_to_milliseconds(self.timeout)
471
438
    
472
439
    def extended_timeout_milliseconds(self):
473
440
        "Return the 'extended_timeout' attribute in milliseconds"
474
 
        return timedelta_to_milliseconds(self.extended_timeout)
 
441
        return _timedelta_to_milliseconds(self.extended_timeout)
475
442
    
476
443
    def interval_milliseconds(self):
477
444
        "Return the 'interval' attribute in milliseconds"
478
 
        return timedelta_to_milliseconds(self.interval)
 
445
        return _timedelta_to_milliseconds(self.interval)
479
446
    
480
447
    def approval_delay_milliseconds(self):
481
 
        return timedelta_to_milliseconds(self.approval_delay)
482
 
    
483
 
    @staticmethod
484
 
    def config_parser(config):
485
 
        """Construct a new dict of client settings of this form:
486
 
        { client_name: {setting_name: value, ...}, ...}
487
 
        with exceptions for any special settings as defined above.
488
 
        NOTE: Must be a pure function. Must return the same result
489
 
        value given the same arguments.
490
 
        """
491
 
        settings = {}
492
 
        for client_name in config.sections():
493
 
            section = dict(config.items(client_name))
494
 
            client = settings[client_name] = {}
495
 
            
496
 
            client["host"] = section["host"]
497
 
            # Reformat values from string types to Python types
498
 
            client["approved_by_default"] = config.getboolean(
499
 
                client_name, "approved_by_default")
500
 
            client["enabled"] = config.getboolean(client_name,
501
 
                                                  "enabled")
502
 
            
503
 
            client["fingerprint"] = (section["fingerprint"].upper()
504
 
                                     .replace(" ", ""))
505
 
            if "secret" in section:
506
 
                client["secret"] = section["secret"].decode("base64")
507
 
            elif "secfile" in section:
508
 
                with open(os.path.expanduser(os.path.expandvars
509
 
                                             (section["secfile"])),
510
 
                          "rb") as secfile:
511
 
                    client["secret"] = secfile.read()
512
 
            else:
513
 
                raise TypeError("No secret or secfile for section {0}"
514
 
                                .format(section))
515
 
            client["timeout"] = string_to_delta(section["timeout"])
516
 
            client["extended_timeout"] = string_to_delta(
517
 
                section["extended_timeout"])
518
 
            client["interval"] = string_to_delta(section["interval"])
519
 
            client["approval_delay"] = string_to_delta(
520
 
                section["approval_delay"])
521
 
            client["approval_duration"] = string_to_delta(
522
 
                section["approval_duration"])
523
 
            client["checker_command"] = section["checker"]
524
 
            client["last_approval_request"] = None
525
 
            client["last_checked_ok"] = None
526
 
            client["last_checker_status"] = -2
527
 
        
528
 
        return settings
529
 
    
530
 
    def __init__(self, settings, name = None, server_settings=None):
 
448
        return _timedelta_to_milliseconds(self.approval_delay)
 
449
    
 
450
    def __init__(self, name = None, config=None):
 
451
        """Note: the 'checker' key in 'config' sets the
 
452
        'checker_command' attribute and *not* the 'checker'
 
453
        attribute."""
531
454
        self.name = name
532
 
        if server_settings is None:
533
 
            server_settings = {}
534
 
        self.server_settings = server_settings
535
 
        # adding all client settings
536
 
        for setting, value in settings.iteritems():
537
 
            setattr(self, setting, value)
538
 
        
539
 
        if self.enabled:
540
 
            if not hasattr(self, "last_enabled"):
541
 
                self.last_enabled = datetime.datetime.utcnow()
542
 
            if not hasattr(self, "expires"):
543
 
                self.expires = (datetime.datetime.utcnow()
544
 
                                + self.timeout)
545
 
        else:
546
 
            self.last_enabled = None
547
 
            self.expires = None
548
 
        
 
455
        if config is None:
 
456
            config = {}
549
457
        logger.debug("Creating client %r", self.name)
550
458
        # Uppercase and remove spaces from fingerprint for later
551
459
        # comparison purposes with return value from the fingerprint()
552
460
        # function
 
461
        self.fingerprint = (config["fingerprint"].upper()
 
462
                            .replace(" ", ""))
553
463
        logger.debug("  Fingerprint: %s", self.fingerprint)
554
 
        self.created = settings.get("created",
555
 
                                    datetime.datetime.utcnow())
556
 
        
557
 
        # attributes specific for this server instance
 
464
        if "secret" in config:
 
465
            self.secret = config["secret"].decode("base64")
 
466
        elif "secfile" in config:
 
467
            with open(os.path.expanduser(os.path.expandvars
 
468
                                         (config["secfile"])),
 
469
                      "rb") as secfile:
 
470
                self.secret = secfile.read()
 
471
        else:
 
472
            raise TypeError("No secret or secfile for client %s"
 
473
                            % self.name)
 
474
        self.host = config.get("host", "")
 
475
        self.created = datetime.datetime.utcnow()
 
476
        self.enabled = config.get("enabled", True)
 
477
        self.last_approval_request = None
 
478
        if self.enabled:
 
479
            self.last_enabled = datetime.datetime.utcnow()
 
480
        else:
 
481
            self.last_enabled = None
 
482
        self.last_checked_ok = None
 
483
        self.last_checker_status = None
 
484
        self.timeout = string_to_delta(config["timeout"])
 
485
        self.extended_timeout = string_to_delta(config
 
486
                                                ["extended_timeout"])
 
487
        self.interval = string_to_delta(config["interval"])
558
488
        self.checker = None
559
489
        self.checker_initiator_tag = None
560
490
        self.disable_initiator_tag = None
 
491
        if self.enabled:
 
492
            self.expires = datetime.datetime.utcnow() + self.timeout
 
493
        else:
 
494
            self.expires = None
561
495
        self.checker_callback_tag = None
 
496
        self.checker_command = config["checker"]
562
497
        self.current_checker_command = None
563
 
        self.approved = None
 
498
        self._approved = None
 
499
        self.approved_by_default = config.get("approved_by_default",
 
500
                                              True)
564
501
        self.approvals_pending = 0
 
502
        self.approval_delay = string_to_delta(
 
503
            config["approval_delay"])
 
504
        self.approval_duration = string_to_delta(
 
505
            config["approval_duration"])
565
506
        self.changedstate = (multiprocessing_manager
566
507
                             .Condition(multiprocessing_manager
567
508
                                        .Lock()))
587
528
        if getattr(self, "enabled", False):
588
529
            # Already enabled
589
530
            return
 
531
        self.send_changedstate()
590
532
        self.expires = datetime.datetime.utcnow() + self.timeout
591
533
        self.enabled = True
592
534
        self.last_enabled = datetime.datetime.utcnow()
593
535
        self.init_checker()
594
 
        self.send_changedstate()
595
536
    
596
537
    def disable(self, quiet=True):
597
538
        """Disable this client."""
598
539
        if not getattr(self, "enabled", False):
599
540
            return False
600
541
        if not quiet:
 
542
            self.send_changedstate()
 
543
        if not quiet:
601
544
            logger.info("Disabling client %s", self.name)
602
 
        if getattr(self, "disable_initiator_tag", None) is not None:
 
545
        if getattr(self, "disable_initiator_tag", False):
603
546
            gobject.source_remove(self.disable_initiator_tag)
604
547
            self.disable_initiator_tag = None
605
548
        self.expires = None
606
 
        if getattr(self, "checker_initiator_tag", None) is not None:
 
549
        if getattr(self, "checker_initiator_tag", False):
607
550
            gobject.source_remove(self.checker_initiator_tag)
608
551
            self.checker_initiator_tag = None
609
552
        self.stop_checker()
610
553
        self.enabled = False
611
 
        if not quiet:
612
 
            self.send_changedstate()
613
554
        # Do not run this again if called by a gobject.timeout_add
614
555
        return False
615
556
    
619
560
    def init_checker(self):
620
561
        # Schedule a new checker to be started an 'interval' from now,
621
562
        # and every interval from then on.
622
 
        if self.checker_initiator_tag is not None:
623
 
            gobject.source_remove(self.checker_initiator_tag)
624
563
        self.checker_initiator_tag = (gobject.timeout_add
625
564
                                      (self.interval_milliseconds(),
626
565
                                       self.start_checker))
627
566
        # Schedule a disable() when 'timeout' has passed
628
 
        if self.disable_initiator_tag is not None:
629
 
            gobject.source_remove(self.disable_initiator_tag)
630
567
        self.disable_initiator_tag = (gobject.timeout_add
631
568
                                   (self.timeout_milliseconds(),
632
569
                                    self.disable))
638
575
        self.checker_callback_tag = None
639
576
        self.checker = None
640
577
        if os.WIFEXITED(condition):
641
 
            self.last_checker_status = os.WEXITSTATUS(condition)
 
578
            self.last_checker_status =  os.WEXITSTATUS(condition)
642
579
            if self.last_checker_status == 0:
643
580
                logger.info("Checker for %(name)s succeeded",
644
581
                            vars(self))
651
588
            logger.warning("Checker for %(name)s crashed?",
652
589
                           vars(self))
653
590
    
654
 
    def checked_ok(self):
655
 
        """Assert that the client has been seen, alive and well."""
656
 
        self.last_checked_ok = datetime.datetime.utcnow()
657
 
        self.last_checker_status = 0
658
 
        self.bump_timeout()
659
 
    
660
 
    def bump_timeout(self, timeout=None):
661
 
        """Bump up the timeout for this client."""
 
591
    def checked_ok(self, timeout=None):
 
592
        """Bump up the timeout for this client.
 
593
        
 
594
        This should only be called when the client has been seen,
 
595
        alive and well.
 
596
        """
662
597
        if timeout is None:
663
598
            timeout = self.timeout
 
599
        self.last_checked_ok = datetime.datetime.utcnow()
664
600
        if self.disable_initiator_tag is not None:
665
601
            gobject.source_remove(self.disable_initiator_tag)
666
 
            self.disable_initiator_tag = None
667
602
        if getattr(self, "enabled", False):
668
603
            self.disable_initiator_tag = (gobject.timeout_add
669
 
                                          (timedelta_to_milliseconds
 
604
                                          (_timedelta_to_milliseconds
670
605
                                           (timeout), self.disable))
671
606
            self.expires = datetime.datetime.utcnow() + timeout
672
607
    
679
614
        If a checker already exists, leave it running and do
680
615
        nothing."""
681
616
        # The reason for not killing a running checker is that if we
682
 
        # did that, and if a checker (for some reason) started running
683
 
        # slowly and taking more than 'interval' time, then the client
684
 
        # would inevitably timeout, since no checker would get a
685
 
        # chance to run to completion.  If we instead leave running
 
617
        # did that, then if a checker (for some reason) started
 
618
        # running slowly and taking more than 'interval' time, the
 
619
        # client would inevitably timeout, since no checker would get
 
620
        # a chance to run to completion.  If we instead leave running
686
621
        # checkers alone, the checker would have to take more time
687
622
        # than 'timeout' for the client to be disabled, which is as it
688
623
        # should be.
702
637
                                      self.current_checker_command)
703
638
        # Start a new checker if needed
704
639
        if self.checker is None:
705
 
            # Escape attributes for the shell
706
 
            escaped_attrs = dict(
707
 
                (attr, re.escape(unicode(getattr(self, attr))))
708
 
                for attr in
709
 
                self.runtime_expansions)
710
640
            try:
711
 
                command = self.checker_command % escaped_attrs
712
 
            except TypeError as error:
713
 
                logger.error('Could not format string "%s"',
714
 
                             self.checker_command, exc_info=error)
715
 
                return True # Try again later
 
641
                # In case checker_command has exactly one % operator
 
642
                command = self.checker_command % self.host
 
643
            except TypeError:
 
644
                # Escape attributes for the shell
 
645
                escaped_attrs = dict(
 
646
                    (attr,
 
647
                     re.escape(unicode(str(getattr(self, attr, "")),
 
648
                                       errors=
 
649
                                       'replace')))
 
650
                    for attr in
 
651
                    self.runtime_expansions)
 
652
                
 
653
                try:
 
654
                    command = self.checker_command % escaped_attrs
 
655
                except TypeError as error:
 
656
                    logger.error('Could not format string "%s":'
 
657
                                 ' %s', self.checker_command, error)
 
658
                    return True # Try again later
716
659
            self.current_checker_command = command
717
660
            try:
718
661
                logger.info("Starting checker %r for %s",
721
664
                # in normal mode, that is already done by daemon(),
722
665
                # and in debug mode we don't want to.  (Stdin is
723
666
                # always replaced by /dev/null.)
724
 
                # The exception is when not debugging but nevertheless
725
 
                # running in the foreground; use the previously
726
 
                # created wnull.
727
 
                popen_args = {}
728
 
                if (not self.server_settings["debug"]
729
 
                    and self.server_settings["foreground"]):
730
 
                    popen_args.update({"stdout": wnull,
731
 
                                       "stderr": wnull })
732
667
                self.checker = subprocess.Popen(command,
733
668
                                                close_fds=True,
734
 
                                                shell=True, cwd="/",
735
 
                                                **popen_args)
736
 
            except OSError as error:
737
 
                logger.error("Failed to start subprocess",
738
 
                             exc_info=error)
739
 
                return True
740
 
            self.checker_callback_tag = (gobject.child_watch_add
741
 
                                         (self.checker.pid,
742
 
                                          self.checker_callback,
743
 
                                          data=command))
744
 
            # The checker may have completed before the gobject
745
 
            # watch was added.  Check for this.
746
 
            try:
 
669
                                                shell=True, cwd="/")
 
670
                self.checker_callback_tag = (gobject.child_watch_add
 
671
                                             (self.checker.pid,
 
672
                                              self.checker_callback,
 
673
                                              data=command))
 
674
                # The checker may have completed before the gobject
 
675
                # watch was added.  Check for this.
747
676
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
677
                if pid:
 
678
                    gobject.source_remove(self.checker_callback_tag)
 
679
                    self.checker_callback(pid, status, command)
748
680
            except OSError as error:
749
 
                if error.errno == errno.ECHILD:
750
 
                    # This should never happen
751
 
                    logger.error("Child process vanished",
752
 
                                 exc_info=error)
753
 
                    return True
754
 
                raise
755
 
            if pid:
756
 
                gobject.source_remove(self.checker_callback_tag)
757
 
                self.checker_callback(pid, status, command)
 
681
                logger.error("Failed to start subprocess: %s",
 
682
                             error)
758
683
        # Re-run this periodically if run by gobject.timeout_add
759
684
        return True
760
685
    
767
692
            return
768
693
        logger.debug("Stopping checker for %(name)s", vars(self))
769
694
        try:
770
 
            self.checker.terminate()
 
695
            os.kill(self.checker.pid, signal.SIGTERM)
771
696
            #time.sleep(0.5)
772
697
            #if self.checker.poll() is None:
773
 
            #    self.checker.kill()
 
698
            #    os.kill(self.checker.pid, signal.SIGKILL)
774
699
        except OSError as error:
775
700
            if error.errno != errno.ESRCH: # No such process
776
701
                raise
793
718
    # "Set" method, so we fail early here:
794
719
    if byte_arrays and signature != "ay":
795
720
        raise ValueError("Byte arrays not supported for non-'ay'"
796
 
                         " signature {0!r}".format(signature))
 
721
                         " signature %r" % signature)
797
722
    def decorator(func):
798
723
        func._dbus_is_property = True
799
724
        func._dbus_interface = dbus_interface
807
732
    return decorator
808
733
 
809
734
 
810
 
def dbus_interface_annotations(dbus_interface):
811
 
    """Decorator for marking functions returning interface annotations
812
 
    
813
 
    Usage:
814
 
    
815
 
    @dbus_interface_annotations("org.example.Interface")
816
 
    def _foo(self):  # Function name does not matter
817
 
        return {"org.freedesktop.DBus.Deprecated": "true",
818
 
                "org.freedesktop.DBus.Property.EmitsChangedSignal":
819
 
                    "false"}
820
 
    """
821
 
    def decorator(func):
822
 
        func._dbus_is_interface = True
823
 
        func._dbus_interface = dbus_interface
824
 
        func._dbus_name = dbus_interface
825
 
        return func
826
 
    return decorator
827
 
 
828
 
 
829
 
def dbus_annotations(annotations):
830
 
    """Decorator to annotate D-Bus methods, signals or properties
831
 
    Usage:
832
 
    
833
 
    @dbus_service_property("org.example.Interface", signature="b",
834
 
                           access="r")
835
 
    @dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
836
 
                        "org.freedesktop.DBus.Property."
837
 
                        "EmitsChangedSignal": "false"})
838
 
    def Property_dbus_property(self):
839
 
        return dbus.Boolean(False)
840
 
    """
841
 
    def decorator(func):
842
 
        func._dbus_annotations = annotations
843
 
        return func
844
 
    return decorator
845
 
 
846
 
 
847
735
class DBusPropertyException(dbus.exceptions.DBusException):
848
736
    """A base class for D-Bus property-related exceptions
849
737
    """
872
760
    """
873
761
    
874
762
    @staticmethod
875
 
    def _is_dbus_thing(thing):
876
 
        """Returns a function testing if an attribute is a D-Bus thing
877
 
        
878
 
        If called like _is_dbus_thing("method") it returns a function
879
 
        suitable for use as predicate to inspect.getmembers().
880
 
        """
881
 
        return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
882
 
                                   False)
 
763
    def _is_dbus_property(obj):
 
764
        return getattr(obj, "_dbus_is_property", False)
883
765
    
884
 
    def _get_all_dbus_things(self, thing):
 
766
    def _get_all_dbus_properties(self):
885
767
        """Returns a generator of (name, attribute) pairs
886
768
        """
887
 
        return ((getattr(athing.__get__(self), "_dbus_name",
888
 
                         name),
889
 
                 athing.__get__(self))
 
769
        return ((prop.__get__(self)._dbus_name, prop.__get__(self))
890
770
                for cls in self.__class__.__mro__
891
 
                for name, athing in
892
 
                inspect.getmembers(cls,
893
 
                                   self._is_dbus_thing(thing)))
 
771
                for name, prop in
 
772
                inspect.getmembers(cls, self._is_dbus_property))
894
773
    
895
774
    def _get_dbus_property(self, interface_name, property_name):
896
775
        """Returns a bound method if one exists which is a D-Bus
898
777
        """
899
778
        for cls in  self.__class__.__mro__:
900
779
            for name, value in (inspect.getmembers
901
 
                                (cls,
902
 
                                 self._is_dbus_thing("property"))):
 
780
                                (cls, self._is_dbus_property)):
903
781
                if (value._dbus_name == property_name
904
782
                    and value._dbus_interface == interface_name):
905
783
                    return value.__get__(self)
934
812
            # signatures other than "ay".
935
813
            if prop._dbus_signature != "ay":
936
814
                raise ValueError
937
 
            value = dbus.ByteArray(b''.join(chr(byte)
938
 
                                            for byte in value))
 
815
            value = dbus.ByteArray(''.join(unichr(byte)
 
816
                                           for byte in value))
939
817
        prop(value)
940
818
    
941
819
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
947
825
        Note: Will not include properties with access="write".
948
826
        """
949
827
        properties = {}
950
 
        for name, prop in self._get_all_dbus_things("property"):
 
828
        for name, prop in self._get_all_dbus_properties():
951
829
            if (interface_name
952
830
                and interface_name != prop._dbus_interface):
953
831
                # Interface non-empty but did not match
968
846
                         path_keyword='object_path',
969
847
                         connection_keyword='connection')
970
848
    def Introspect(self, object_path, connection):
971
 
        """Overloading of standard D-Bus method.
972
 
        
973
 
        Inserts property tags and interface annotation tags.
 
849
        """Standard D-Bus method, overloaded to insert property tags.
974
850
        """
975
851
        xmlstring = dbus.service.Object.Introspect(self, object_path,
976
852
                                                   connection)
983
859
                e.setAttribute("access", prop._dbus_access)
984
860
                return e
985
861
            for if_tag in document.getElementsByTagName("interface"):
986
 
                # Add property tags
987
862
                for tag in (make_tag(document, name, prop)
988
863
                            for name, prop
989
 
                            in self._get_all_dbus_things("property")
 
864
                            in self._get_all_dbus_properties()
990
865
                            if prop._dbus_interface
991
866
                            == if_tag.getAttribute("name")):
992
867
                    if_tag.appendChild(tag)
993
 
                # Add annotation tags
994
 
                for typ in ("method", "signal", "property"):
995
 
                    for tag in if_tag.getElementsByTagName(typ):
996
 
                        annots = dict()
997
 
                        for name, prop in (self.
998
 
                                           _get_all_dbus_things(typ)):
999
 
                            if (name == tag.getAttribute("name")
1000
 
                                and prop._dbus_interface
1001
 
                                == if_tag.getAttribute("name")):
1002
 
                                annots.update(getattr
1003
 
                                              (prop,
1004
 
                                               "_dbus_annotations",
1005
 
                                               {}))
1006
 
                        for name, value in annots.iteritems():
1007
 
                            ann_tag = document.createElement(
1008
 
                                "annotation")
1009
 
                            ann_tag.setAttribute("name", name)
1010
 
                            ann_tag.setAttribute("value", value)
1011
 
                            tag.appendChild(ann_tag)
1012
 
                # Add interface annotation tags
1013
 
                for annotation, value in dict(
1014
 
                    itertools.chain.from_iterable(
1015
 
                        annotations().iteritems()
1016
 
                        for name, annotations in
1017
 
                        self._get_all_dbus_things("interface")
1018
 
                        if name == if_tag.getAttribute("name")
1019
 
                        )).iteritems():
1020
 
                    ann_tag = document.createElement("annotation")
1021
 
                    ann_tag.setAttribute("name", annotation)
1022
 
                    ann_tag.setAttribute("value", value)
1023
 
                    if_tag.appendChild(ann_tag)
1024
868
                # Add the names to the return values for the
1025
869
                # "org.freedesktop.DBus.Properties" methods
1026
870
                if (if_tag.getAttribute("name")
1041
885
        except (AttributeError, xml.dom.DOMException,
1042
886
                xml.parsers.expat.ExpatError) as error:
1043
887
            logger.error("Failed to override Introspection method",
1044
 
                         exc_info=error)
 
888
                         error)
1045
889
        return xmlstring
1046
890
 
1047
891
 
1048
 
def datetime_to_dbus(dt, variant_level=0):
 
892
def datetime_to_dbus (dt, variant_level=0):
1049
893
    """Convert a UTC datetime.datetime() to a D-Bus type."""
1050
894
    if dt is None:
1051
895
        return dbus.String("", variant_level = variant_level)
1053
897
                       variant_level=variant_level)
1054
898
 
1055
899
 
1056
 
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1057
 
    """A class decorator; applied to a subclass of
1058
 
    dbus.service.Object, it will add alternate D-Bus attributes with
1059
 
    interface names according to the "alt_interface_names" mapping.
1060
 
    Usage:
1061
 
    
1062
 
    @alternate_dbus_interfaces({"org.example.Interface":
1063
 
                                    "net.example.AlternateInterface"})
1064
 
    class SampleDBusObject(dbus.service.Object):
1065
 
        @dbus.service.method("org.example.Interface")
1066
 
        def SampleDBusMethod():
1067
 
            pass
1068
 
    
1069
 
    The above "SampleDBusMethod" on "SampleDBusObject" will be
1070
 
    reachable via two interfaces: "org.example.Interface" and
1071
 
    "net.example.AlternateInterface", the latter of which will have
1072
 
    its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1073
 
    "true", unless "deprecate" is passed with a False value.
1074
 
    
1075
 
    This works for methods and signals, and also for D-Bus properties
1076
 
    (from DBusObjectWithProperties) and interfaces (from the
1077
 
    dbus_interface_annotations decorator).
 
900
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
 
901
                                  .__metaclass__):
 
902
    """Applied to an empty subclass of a D-Bus object, this metaclass
 
903
    will add additional D-Bus attributes matching a certain pattern.
1078
904
    """
1079
 
    def wrapper(cls):
1080
 
        for orig_interface_name, alt_interface_name in (
1081
 
            alt_interface_names.iteritems()):
1082
 
            attr = {}
1083
 
            interface_names = set()
1084
 
            # Go though all attributes of the class
1085
 
            for attrname, attribute in inspect.getmembers(cls):
 
905
    def __new__(mcs, name, bases, attr):
 
906
        # Go through all the base classes which could have D-Bus
 
907
        # methods, signals, or properties in them
 
908
        for base in (b for b in bases
 
909
                     if issubclass(b, dbus.service.Object)):
 
910
            # Go though all attributes of the base class
 
911
            for attrname, attribute in inspect.getmembers(base):
1086
912
                # Ignore non-D-Bus attributes, and D-Bus attributes
1087
913
                # with the wrong interface name
1088
914
                if (not hasattr(attribute, "_dbus_interface")
1089
915
                    or not attribute._dbus_interface
1090
 
                    .startswith(orig_interface_name)):
 
916
                    .startswith("se.recompile.Mandos")):
1091
917
                    continue
1092
918
                # Create an alternate D-Bus interface name based on
1093
919
                # the current name
1094
920
                alt_interface = (attribute._dbus_interface
1095
 
                                 .replace(orig_interface_name,
1096
 
                                          alt_interface_name))
1097
 
                interface_names.add(alt_interface)
 
921
                                 .replace("se.recompile.Mandos",
 
922
                                          "se.bsnet.fukt.Mandos"))
1098
923
                # Is this a D-Bus signal?
1099
924
                if getattr(attribute, "_dbus_is_signal", False):
1100
 
                    # Extract the original non-method undecorated
1101
 
                    # function by black magic
 
925
                    # Extract the original non-method function by
 
926
                    # black magic
1102
927
                    nonmethod_func = (dict(
1103
928
                            zip(attribute.func_code.co_freevars,
1104
929
                                attribute.__closure__))["func"]
1115
940
                                nonmethod_func.func_name,
1116
941
                                nonmethod_func.func_defaults,
1117
942
                                nonmethod_func.func_closure)))
1118
 
                    # Copy annotations, if any
1119
 
                    try:
1120
 
                        new_function._dbus_annotations = (
1121
 
                            dict(attribute._dbus_annotations))
1122
 
                    except AttributeError:
1123
 
                        pass
1124
943
                    # Define a creator of a function to call both the
1125
 
                    # original and alternate functions, so both the
1126
 
                    # original and alternate signals gets sent when
1127
 
                    # the function is called
 
944
                    # old and new functions, so both the old and new
 
945
                    # signals gets sent when the function is called
1128
946
                    def fixscope(func1, func2):
1129
947
                        """This function is a scope container to pass
1130
948
                        func1 and func2 to the "call_both" function
1137
955
                        return call_both
1138
956
                    # Create the "call_both" function and add it to
1139
957
                    # the class
1140
 
                    attr[attrname] = fixscope(attribute, new_function)
 
958
                    attr[attrname] = fixscope(attribute,
 
959
                                              new_function)
1141
960
                # Is this a D-Bus method?
1142
961
                elif getattr(attribute, "_dbus_is_method", False):
1143
962
                    # Create a new, but exactly alike, function
1154
973
                                        attribute.func_name,
1155
974
                                        attribute.func_defaults,
1156
975
                                        attribute.func_closure)))
1157
 
                    # Copy annotations, if any
1158
 
                    try:
1159
 
                        attr[attrname]._dbus_annotations = (
1160
 
                            dict(attribute._dbus_annotations))
1161
 
                    except AttributeError:
1162
 
                        pass
1163
976
                # Is this a D-Bus property?
1164
977
                elif getattr(attribute, "_dbus_is_property", False):
1165
978
                    # Create a new, but exactly alike, function
1179
992
                                        attribute.func_name,
1180
993
                                        attribute.func_defaults,
1181
994
                                        attribute.func_closure)))
1182
 
                    # Copy annotations, if any
1183
 
                    try:
1184
 
                        attr[attrname]._dbus_annotations = (
1185
 
                            dict(attribute._dbus_annotations))
1186
 
                    except AttributeError:
1187
 
                        pass
1188
 
                # Is this a D-Bus interface?
1189
 
                elif getattr(attribute, "_dbus_is_interface", False):
1190
 
                    # Create a new, but exactly alike, function
1191
 
                    # object.  Decorate it to be a new D-Bus interface
1192
 
                    # with the alternate D-Bus interface name.  Add it
1193
 
                    # to the class.
1194
 
                    attr[attrname] = (dbus_interface_annotations
1195
 
                                      (alt_interface)
1196
 
                                      (types.FunctionType
1197
 
                                       (attribute.func_code,
1198
 
                                        attribute.func_globals,
1199
 
                                        attribute.func_name,
1200
 
                                        attribute.func_defaults,
1201
 
                                        attribute.func_closure)))
1202
 
            if deprecate:
1203
 
                # Deprecate all alternate interfaces
1204
 
                iname="_AlternateDBusNames_interface_annotation{0}"
1205
 
                for interface_name in interface_names:
1206
 
                    @dbus_interface_annotations(interface_name)
1207
 
                    def func(self):
1208
 
                        return { "org.freedesktop.DBus.Deprecated":
1209
 
                                     "true" }
1210
 
                    # Find an unused name
1211
 
                    for aname in (iname.format(i)
1212
 
                                  for i in itertools.count()):
1213
 
                        if aname not in attr:
1214
 
                            attr[aname] = func
1215
 
                            break
1216
 
            if interface_names:
1217
 
                # Replace the class with a new subclass of it with
1218
 
                # methods, signals, etc. as created above.
1219
 
                cls = type(b"{0}Alternate".format(cls.__name__),
1220
 
                           (cls,), attr)
1221
 
        return cls
1222
 
    return wrapper
1223
 
 
1224
 
 
1225
 
@alternate_dbus_interfaces({"se.recompile.Mandos":
1226
 
                                "se.bsnet.fukt.Mandos"})
 
995
        return type.__new__(mcs, name, bases, attr)
 
996
 
 
997
 
1227
998
class ClientDBus(Client, DBusObjectWithProperties):
1228
999
    """A Client class using D-Bus
1229
1000
    
1240
1011
    def __init__(self, bus = None, *args, **kwargs):
1241
1012
        self.bus = bus
1242
1013
        Client.__init__(self, *args, **kwargs)
 
1014
        
 
1015
        self._approvals_pending = 0
1243
1016
        # Only now, when this client is initialized, can it show up on
1244
1017
        # the D-Bus
1245
1018
        client_object_name = unicode(self.name).translate(
1249
1022
                                 ("/clients/" + client_object_name))
1250
1023
        DBusObjectWithProperties.__init__(self, self.bus,
1251
1024
                                          self.dbus_object_path)
1252
 
    
 
1025
        
1253
1026
    def notifychangeproperty(transform_func,
1254
1027
                             dbus_name, type_func=lambda x: x,
1255
1028
                             variant_level=1):
1278
1051
        
1279
1052
        return property(lambda self: getattr(self, attrname), setter)
1280
1053
    
 
1054
    
1281
1055
    expires = notifychangeproperty(datetime_to_dbus, "Expires")
1282
1056
    approvals_pending = notifychangeproperty(dbus.Boolean,
1283
1057
                                             "ApprovalPending",
1290
1064
                                       checker is not None)
1291
1065
    last_checked_ok = notifychangeproperty(datetime_to_dbus,
1292
1066
                                           "LastCheckedOK")
1293
 
    last_checker_status = notifychangeproperty(dbus.Int16,
1294
 
                                               "LastCheckerStatus")
1295
1067
    last_approval_request = notifychangeproperty(
1296
1068
        datetime_to_dbus, "LastApprovalRequest")
1297
1069
    approved_by_default = notifychangeproperty(dbus.Boolean,
1298
1070
                                               "ApprovedByDefault")
1299
 
    approval_delay = notifychangeproperty(dbus.UInt64,
 
1071
    approval_delay = notifychangeproperty(dbus.UInt16,
1300
1072
                                          "ApprovalDelay",
1301
1073
                                          type_func =
1302
 
                                          timedelta_to_milliseconds)
 
1074
                                          _timedelta_to_milliseconds)
1303
1075
    approval_duration = notifychangeproperty(
1304
 
        dbus.UInt64, "ApprovalDuration",
1305
 
        type_func = timedelta_to_milliseconds)
 
1076
        dbus.UInt16, "ApprovalDuration",
 
1077
        type_func = _timedelta_to_milliseconds)
1306
1078
    host = notifychangeproperty(dbus.String, "Host")
1307
 
    timeout = notifychangeproperty(dbus.UInt64, "Timeout",
 
1079
    timeout = notifychangeproperty(dbus.UInt16, "Timeout",
1308
1080
                                   type_func =
1309
 
                                   timedelta_to_milliseconds)
 
1081
                                   _timedelta_to_milliseconds)
1310
1082
    extended_timeout = notifychangeproperty(
1311
 
        dbus.UInt64, "ExtendedTimeout",
1312
 
        type_func = timedelta_to_milliseconds)
1313
 
    interval = notifychangeproperty(dbus.UInt64,
 
1083
        dbus.UInt16, "ExtendedTimeout",
 
1084
        type_func = _timedelta_to_milliseconds)
 
1085
    interval = notifychangeproperty(dbus.UInt16,
1314
1086
                                    "Interval",
1315
1087
                                    type_func =
1316
 
                                    timedelta_to_milliseconds)
 
1088
                                    _timedelta_to_milliseconds)
1317
1089
    checker_command = notifychangeproperty(dbus.String, "Checker")
1318
1090
    
1319
1091
    del notifychangeproperty
1361
1133
        return r
1362
1134
    
1363
1135
    def _reset_approved(self):
1364
 
        self.approved = None
 
1136
        self._approved = None
1365
1137
        return False
1366
1138
    
1367
1139
    def approve(self, value=True):
1368
 
        self.approved = value
1369
 
        gobject.timeout_add(timedelta_to_milliseconds
 
1140
        self.send_changedstate()
 
1141
        self._approved = value
 
1142
        gobject.timeout_add(_timedelta_to_milliseconds
1370
1143
                            (self.approval_duration),
1371
1144
                            self._reset_approved)
1372
 
        self.send_changedstate()
 
1145
    
1373
1146
    
1374
1147
    ## D-Bus methods, signals & properties
1375
1148
    _interface = "se.recompile.Mandos.Client"
1376
1149
    
1377
 
    ## Interfaces
1378
 
    
1379
 
    @dbus_interface_annotations(_interface)
1380
 
    def _foo(self):
1381
 
        return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
1382
 
                     "false"}
1383
 
    
1384
1150
    ## Signals
1385
1151
    
1386
1152
    # CheckerCompleted - signal
1422
1188
        "D-Bus signal"
1423
1189
        return self.need_approval()
1424
1190
    
 
1191
    # NeRwequest - signal
 
1192
    @dbus.service.signal(_interface, signature="s")
 
1193
    def NewRequest(self, ip):
 
1194
        """D-Bus signal
 
1195
        Is sent after a client request a password.
 
1196
        """
 
1197
        pass
 
1198
    
1425
1199
    ## Methods
1426
1200
    
1427
1201
    # Approve - method
1485
1259
                           access="readwrite")
1486
1260
    def ApprovalDuration_dbus_property(self, value=None):
1487
1261
        if value is None:       # get
1488
 
            return dbus.UInt64(timedelta_to_milliseconds(
 
1262
            return dbus.UInt64(_timedelta_to_milliseconds(
1489
1263
                    self.approval_duration))
1490
1264
        self.approval_duration = datetime.timedelta(0, 0, 0, value)
1491
1265
    
1505
1279
    def Host_dbus_property(self, value=None):
1506
1280
        if value is None:       # get
1507
1281
            return dbus.String(self.host)
1508
 
        self.host = unicode(value)
 
1282
        self.host = value
1509
1283
    
1510
1284
    # Created - property
1511
1285
    @dbus_service_property(_interface, signature="s", access="read")
1537
1311
            return
1538
1312
        return datetime_to_dbus(self.last_checked_ok)
1539
1313
    
1540
 
    # LastCheckerStatus - property
1541
 
    @dbus_service_property(_interface, signature="n",
1542
 
                           access="read")
1543
 
    def LastCheckerStatus_dbus_property(self):
1544
 
        return dbus.Int16(self.last_checker_status)
1545
 
    
1546
1314
    # Expires - property
1547
1315
    @dbus_service_property(_interface, signature="s", access="read")
1548
1316
    def Expires_dbus_property(self):
1559
1327
    def Timeout_dbus_property(self, value=None):
1560
1328
        if value is None:       # get
1561
1329
            return dbus.UInt64(self.timeout_milliseconds())
1562
 
        old_timeout = self.timeout
1563
1330
        self.timeout = datetime.timedelta(0, 0, 0, value)
1564
 
        # Reschedule disabling
1565
 
        if self.enabled:
1566
 
            now = datetime.datetime.utcnow()
1567
 
            self.expires += self.timeout - old_timeout
1568
 
            if self.expires <= now:
1569
 
                # The timeout has passed
1570
 
                self.disable()
1571
 
            else:
1572
 
                if (getattr(self, "disable_initiator_tag", None)
1573
 
                    is None):
1574
 
                    return
1575
 
                gobject.source_remove(self.disable_initiator_tag)
1576
 
                self.disable_initiator_tag = (
1577
 
                    gobject.timeout_add(
1578
 
                        timedelta_to_milliseconds(self.expires - now),
1579
 
                        self.disable))
 
1331
        if getattr(self, "disable_initiator_tag", None) is None:
 
1332
            return
 
1333
        # Reschedule timeout
 
1334
        gobject.source_remove(self.disable_initiator_tag)
 
1335
        self.disable_initiator_tag = None
 
1336
        self.expires = None
 
1337
        time_to_die = _timedelta_to_milliseconds((self
 
1338
                                                  .last_checked_ok
 
1339
                                                  + self.timeout)
 
1340
                                                 - datetime.datetime
 
1341
                                                 .utcnow())
 
1342
        if time_to_die <= 0:
 
1343
            # The timeout has passed
 
1344
            self.disable()
 
1345
        else:
 
1346
            self.expires = (datetime.datetime.utcnow()
 
1347
                            + datetime.timedelta(milliseconds =
 
1348
                                                 time_to_die))
 
1349
            self.disable_initiator_tag = (gobject.timeout_add
 
1350
                                          (time_to_die, self.disable))
1580
1351
    
1581
1352
    # ExtendedTimeout - property
1582
1353
    @dbus_service_property(_interface, signature="t",
1608
1379
    def Checker_dbus_property(self, value=None):
1609
1380
        if value is None:       # get
1610
1381
            return dbus.String(self.checker_command)
1611
 
        self.checker_command = unicode(value)
 
1382
        self.checker_command = value
1612
1383
    
1613
1384
    # CheckerRunning - property
1614
1385
    @dbus_service_property(_interface, signature="b",
1643
1414
            raise KeyError()
1644
1415
    
1645
1416
    def __getattribute__(self, name):
1646
 
        if name == '_pipe':
 
1417
        if(name == '_pipe'):
1647
1418
            return super(ProxyClient, self).__getattribute__(name)
1648
1419
        self._pipe.send(('getattr', name))
1649
1420
        data = self._pipe.recv()
1656
1427
            return func
1657
1428
    
1658
1429
    def __setattr__(self, name, value):
1659
 
        if name == '_pipe':
 
1430
        if(name == '_pipe'):
1660
1431
            return super(ProxyClient, self).__setattr__(name, value)
1661
1432
        self._pipe.send(('setattr', name, value))
1662
1433
 
1663
1434
 
 
1435
class ClientDBusTransitional(ClientDBus):
 
1436
    __metaclass__ = AlternateDBusNamesMetaclass
 
1437
 
 
1438
 
1664
1439
class ClientHandler(socketserver.BaseRequestHandler, object):
1665
1440
    """A class to handle client connections.
1666
1441
    
1727
1502
                    logger.warning("Bad certificate: %s", error)
1728
1503
                    return
1729
1504
                logger.debug("Fingerprint: %s", fpr)
 
1505
                if self.server.use_dbus:
 
1506
                    # Emit D-Bus signal
 
1507
                    client.NewRequest(str(self.client_address))
1730
1508
                
1731
1509
                try:
1732
1510
                    client = ProxyClient(child_pipe, fpr,
1748
1526
                            client.Rejected("Disabled")
1749
1527
                        return
1750
1528
                    
1751
 
                    if client.approved or not client.approval_delay:
 
1529
                    if client._approved or not client.approval_delay:
1752
1530
                        #We are approved or approval is disabled
1753
1531
                        break
1754
 
                    elif client.approved is None:
 
1532
                    elif client._approved is None:
1755
1533
                        logger.info("Client %s needs approval",
1756
1534
                                    client.name)
1757
1535
                        if self.server.use_dbus:
1770
1548
                    #wait until timeout or approved
1771
1549
                    time = datetime.datetime.now()
1772
1550
                    client.changedstate.acquire()
1773
 
                    client.changedstate.wait(
1774
 
                        float(timedelta_to_milliseconds(delay)
1775
 
                              / 1000))
 
1551
                    (client.changedstate.wait
 
1552
                     (float(client._timedelta_to_milliseconds(delay)
 
1553
                            / 1000)))
1776
1554
                    client.changedstate.release()
1777
1555
                    time2 = datetime.datetime.now()
1778
1556
                    if (time2 - time) >= delay:
1794
1572
                    try:
1795
1573
                        sent = session.send(client.secret[sent_size:])
1796
1574
                    except gnutls.errors.GNUTLSError as error:
1797
 
                        logger.warning("gnutls send failed",
1798
 
                                       exc_info=error)
 
1575
                        logger.warning("gnutls send failed")
1799
1576
                        return
1800
1577
                    logger.debug("Sent: %d, remaining: %d",
1801
1578
                                 sent, len(client.secret)
1804
1581
                
1805
1582
                logger.info("Sending secret to %s", client.name)
1806
1583
                # bump the timeout using extended_timeout
1807
 
                client.bump_timeout(client.extended_timeout)
 
1584
                client.checked_ok(client.extended_timeout)
1808
1585
                if self.server.use_dbus:
1809
1586
                    # Emit D-Bus signal
1810
1587
                    client.GotSecret()
1815
1592
                try:
1816
1593
                    session.bye()
1817
1594
                except gnutls.errors.GNUTLSError as error:
1818
 
                    logger.warning("GnuTLS bye failed",
1819
 
                                   exc_info=error)
 
1595
                    logger.warning("GnuTLS bye failed")
1820
1596
    
1821
1597
    @staticmethod
1822
1598
    def peer_certificate(session):
1887
1663
    def sub_process_main(self, request, address):
1888
1664
        try:
1889
1665
            self.finish_request(request, address)
1890
 
        except Exception:
 
1666
        except:
1891
1667
            self.handle_error(request, address)
1892
1668
        self.close_request(request)
1893
1669
    
1894
1670
    def process_request(self, request, address):
1895
1671
        """Start a new process to process the request."""
1896
1672
        proc = multiprocessing.Process(target = self.sub_process_main,
1897
 
                                       args = (request, address))
 
1673
                                       args = (request,
 
1674
                                               address))
1898
1675
        proc.start()
1899
1676
        return proc
1900
1677
 
1928
1705
        use_ipv6:       Boolean; to use IPv6 or not
1929
1706
    """
1930
1707
    def __init__(self, server_address, RequestHandlerClass,
1931
 
                 interface=None, use_ipv6=True, socketfd=None):
1932
 
        """If socketfd is set, use that file descriptor instead of
1933
 
        creating a new one with socket.socket().
1934
 
        """
 
1708
                 interface=None, use_ipv6=True):
1935
1709
        self.interface = interface
1936
1710
        if use_ipv6:
1937
1711
            self.address_family = socket.AF_INET6
1938
 
        if socketfd is not None:
1939
 
            # Save the file descriptor
1940
 
            self.socketfd = socketfd
1941
 
            # Save the original socket.socket() function
1942
 
            self.socket_socket = socket.socket
1943
 
            # To implement --socket, we monkey patch socket.socket.
1944
 
            # 
1945
 
            # (When socketserver.TCPServer is a new-style class, we
1946
 
            # could make self.socket into a property instead of monkey
1947
 
            # patching socket.socket.)
1948
 
            # 
1949
 
            # Create a one-time-only replacement for socket.socket()
1950
 
            @functools.wraps(socket.socket)
1951
 
            def socket_wrapper(*args, **kwargs):
1952
 
                # Restore original function so subsequent calls are
1953
 
                # not affected.
1954
 
                socket.socket = self.socket_socket
1955
 
                del self.socket_socket
1956
 
                # This time only, return a new socket object from the
1957
 
                # saved file descriptor.
1958
 
                return socket.fromfd(self.socketfd, *args, **kwargs)
1959
 
            # Replace socket.socket() function with wrapper
1960
 
            socket.socket = socket_wrapper
1961
 
        # The socketserver.TCPServer.__init__ will call
1962
 
        # socket.socket(), which might be our replacement,
1963
 
        # socket_wrapper(), if socketfd was set.
1964
1712
        socketserver.TCPServer.__init__(self, server_address,
1965
1713
                                        RequestHandlerClass)
1966
 
    
1967
1714
    def server_bind(self):
1968
1715
        """This overrides the normal server_bind() function
1969
1716
        to bind to an interface if one was specified, and also NOT to
1977
1724
                try:
1978
1725
                    self.socket.setsockopt(socket.SOL_SOCKET,
1979
1726
                                           SO_BINDTODEVICE,
1980
 
                                           str(self.interface + '\0'))
 
1727
                                           str(self.interface
 
1728
                                               + '\0'))
1981
1729
                except socket.error as error:
1982
 
                    if error.errno == errno.EPERM:
1983
 
                        logger.error("No permission to bind to"
1984
 
                                     " interface %s", self.interface)
1985
 
                    elif error.errno == errno.ENOPROTOOPT:
 
1730
                    if error[0] == errno.EPERM:
 
1731
                        logger.error("No permission to"
 
1732
                                     " bind to interface %s",
 
1733
                                     self.interface)
 
1734
                    elif error[0] == errno.ENOPROTOOPT:
1986
1735
                        logger.error("SO_BINDTODEVICE not available;"
1987
1736
                                     " cannot bind to interface %s",
1988
1737
                                     self.interface)
1989
 
                    elif error.errno == errno.ENODEV:
1990
 
                        logger.error("Interface %s does not exist,"
1991
 
                                     " cannot bind", self.interface)
1992
1738
                    else:
1993
1739
                        raise
1994
1740
        # Only bind(2) the socket if we really need to.
1997
1743
                if self.address_family == socket.AF_INET6:
1998
1744
                    any_address = "::" # in6addr_any
1999
1745
                else:
2000
 
                    any_address = "0.0.0.0" # INADDR_ANY
 
1746
                    any_address = socket.INADDR_ANY
2001
1747
                self.server_address = (any_address,
2002
1748
                                       self.server_address[1])
2003
1749
            elif not self.server_address[1]:
2024
1770
    """
2025
1771
    def __init__(self, server_address, RequestHandlerClass,
2026
1772
                 interface=None, use_ipv6=True, clients=None,
2027
 
                 gnutls_priority=None, use_dbus=True, socketfd=None):
 
1773
                 gnutls_priority=None, use_dbus=True):
2028
1774
        self.enabled = False
2029
1775
        self.clients = clients
2030
1776
        if self.clients is None:
2034
1780
        IPv6_TCPServer.__init__(self, server_address,
2035
1781
                                RequestHandlerClass,
2036
1782
                                interface = interface,
2037
 
                                use_ipv6 = use_ipv6,
2038
 
                                socketfd = socketfd)
 
1783
                                use_ipv6 = use_ipv6)
2039
1784
    def server_activate(self):
2040
1785
        if self.enabled:
2041
1786
            return socketserver.TCPServer.server_activate(self)
2054
1799
    
2055
1800
    def handle_ipc(self, source, condition, parent_pipe=None,
2056
1801
                   proc = None, client_object=None):
 
1802
        condition_names = {
 
1803
            gobject.IO_IN: "IN",   # There is data to read.
 
1804
            gobject.IO_OUT: "OUT", # Data can be written (without
 
1805
                                    # blocking).
 
1806
            gobject.IO_PRI: "PRI", # There is urgent data to read.
 
1807
            gobject.IO_ERR: "ERR", # Error condition.
 
1808
            gobject.IO_HUP: "HUP"  # Hung up (the connection has been
 
1809
                                    # broken, usually for pipes and
 
1810
                                    # sockets).
 
1811
            }
 
1812
        conditions_string = ' | '.join(name
 
1813
                                       for cond, name in
 
1814
                                       condition_names.iteritems()
 
1815
                                       if cond & condition)
2057
1816
        # error, or the other end of multiprocessing.Pipe has closed
2058
 
        if condition & (gobject.IO_ERR | gobject.IO_HUP):
 
1817
        if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
2059
1818
            # Wait for other process to exit
2060
1819
            proc.join()
2061
1820
            return False
2119
1878
        return True
2120
1879
 
2121
1880
 
2122
 
def rfc3339_duration_to_delta(duration):
2123
 
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2124
 
    
2125
 
    >>> rfc3339_duration_to_delta("P7D")
2126
 
    datetime.timedelta(7)
2127
 
    >>> rfc3339_duration_to_delta("PT60S")
2128
 
    datetime.timedelta(0, 60)
2129
 
    >>> rfc3339_duration_to_delta("PT60M")
2130
 
    datetime.timedelta(0, 3600)
2131
 
    >>> rfc3339_duration_to_delta("PT24H")
2132
 
    datetime.timedelta(1)
2133
 
    >>> rfc3339_duration_to_delta("P1W")
2134
 
    datetime.timedelta(7)
2135
 
    >>> rfc3339_duration_to_delta("PT5M30S")
2136
 
    datetime.timedelta(0, 330)
2137
 
    >>> rfc3339_duration_to_delta("P1DT3M20S")
2138
 
    datetime.timedelta(1, 200)
2139
 
    """
2140
 
    
2141
 
    # Parsing an RFC 3339 duration with regular expressions is not
2142
 
    # possible - there would have to be multiple places for the same
2143
 
    # values, like seconds.  The current code, while more esoteric, is
2144
 
    # cleaner without depending on a parsing library.  If Python had a
2145
 
    # built-in library for parsing we would use it, but we'd like to
2146
 
    # avoid excessive use of external libraries.
2147
 
    
2148
 
    # New type for defining tokens, syntax, and semantics all-in-one
2149
 
    Token = collections.namedtuple("Token",
2150
 
                                   ("regexp", # To match token; if
2151
 
                                              # "value" is not None,
2152
 
                                              # must have a "group"
2153
 
                                              # containing digits
2154
 
                                    "value",  # datetime.timedelta or
2155
 
                                              # None
2156
 
                                    "followers")) # Tokens valid after
2157
 
                                                  # this token
2158
 
    # RFC 3339 "duration" tokens, syntax, and semantics; taken from
2159
 
    # the "duration" ABNF definition in RFC 3339, Appendix A.
2160
 
    token_end = Token(re.compile(r"$"), None, frozenset())
2161
 
    token_second = Token(re.compile(r"(\d+)S"),
2162
 
                         datetime.timedelta(seconds=1),
2163
 
                         frozenset((token_end,)))
2164
 
    token_minute = Token(re.compile(r"(\d+)M"),
2165
 
                         datetime.timedelta(minutes=1),
2166
 
                         frozenset((token_second, token_end)))
2167
 
    token_hour = Token(re.compile(r"(\d+)H"),
2168
 
                       datetime.timedelta(hours=1),
2169
 
                       frozenset((token_minute, token_end)))
2170
 
    token_time = Token(re.compile(r"T"),
2171
 
                       None,
2172
 
                       frozenset((token_hour, token_minute,
2173
 
                                  token_second)))
2174
 
    token_day = Token(re.compile(r"(\d+)D"),
2175
 
                      datetime.timedelta(days=1),
2176
 
                      frozenset((token_time, token_end)))
2177
 
    token_month = Token(re.compile(r"(\d+)M"),
2178
 
                        datetime.timedelta(weeks=4),
2179
 
                        frozenset((token_day, token_end)))
2180
 
    token_year = Token(re.compile(r"(\d+)Y"),
2181
 
                       datetime.timedelta(weeks=52),
2182
 
                       frozenset((token_month, token_end)))
2183
 
    token_week = Token(re.compile(r"(\d+)W"),
2184
 
                       datetime.timedelta(weeks=1),
2185
 
                       frozenset((token_end,)))
2186
 
    token_duration = Token(re.compile(r"P"), None,
2187
 
                           frozenset((token_year, token_month,
2188
 
                                      token_day, token_time,
2189
 
                                      token_week))),
2190
 
    # Define starting values
2191
 
    value = datetime.timedelta() # Value so far
2192
 
    found_token = None
2193
 
    followers = frozenset(token_duration,) # Following valid tokens
2194
 
    s = duration                # String left to parse
2195
 
    # Loop until end token is found
2196
 
    while found_token is not token_end:
2197
 
        # Search for any currently valid tokens
2198
 
        for token in followers:
2199
 
            match = token.regexp.match(s)
2200
 
            if match is not None:
2201
 
                # Token found
2202
 
                if token.value is not None:
2203
 
                    # Value found, parse digits
2204
 
                    factor = int(match.group(1), 10)
2205
 
                    # Add to value so far
2206
 
                    value += factor * token.value
2207
 
                # Strip token from string
2208
 
                s = token.regexp.sub("", s, 1)
2209
 
                # Go to found token
2210
 
                found_token = token
2211
 
                # Set valid next tokens
2212
 
                followers = found_token.followers
2213
 
                break
2214
 
        else:
2215
 
            # No currently valid tokens were found
2216
 
            raise ValueError("Invalid RFC 3339 duration")
2217
 
    # End token found
2218
 
    return value
2219
 
 
2220
 
 
2221
1881
def string_to_delta(interval):
2222
1882
    """Parse a string and return a datetime.timedelta
2223
1883
    
2234
1894
    >>> string_to_delta('5m 30s')
2235
1895
    datetime.timedelta(0, 330)
2236
1896
    """
2237
 
    
2238
 
    try:
2239
 
        return rfc3339_duration_to_delta(interval)
2240
 
    except ValueError:
2241
 
        pass
2242
 
    
2243
1897
    timevalue = datetime.timedelta(0)
2244
1898
    for s in interval.split():
2245
1899
        try:
2256
1910
            elif suffix == "w":
2257
1911
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2258
1912
            else:
2259
 
                raise ValueError("Unknown suffix {0!r}"
2260
 
                                 .format(suffix))
 
1913
                raise ValueError("Unknown suffix %r" % suffix)
2261
1914
        except (ValueError, IndexError) as e:
2262
1915
            raise ValueError(*(e.args))
2263
1916
        timevalue += delta
2277
1930
        sys.exit()
2278
1931
    if not noclose:
2279
1932
        # Close all standard open file descriptors
2280
 
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
 
1933
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2281
1934
        if not stat.S_ISCHR(os.fstat(null).st_mode):
2282
1935
            raise OSError(errno.ENODEV,
2283
 
                          "{0} not a character device"
2284
 
                          .format(os.devnull))
 
1936
                          "%s not a character device"
 
1937
                          % os.path.devnull)
2285
1938
        os.dup2(null, sys.stdin.fileno())
2286
1939
        os.dup2(null, sys.stdout.fileno())
2287
1940
        os.dup2(null, sys.stderr.fileno())
2296
1949
    
2297
1950
    parser = argparse.ArgumentParser()
2298
1951
    parser.add_argument("-v", "--version", action="version",
2299
 
                        version = "%(prog)s {0}".format(version),
 
1952
                        version = "%%(prog)s %s" % version,
2300
1953
                        help="show version number and exit")
2301
1954
    parser.add_argument("-i", "--interface", metavar="IF",
2302
1955
                        help="Bind to interface IF")
2308
1961
                        help="Run self-test")
2309
1962
    parser.add_argument("--debug", action="store_true",
2310
1963
                        help="Debug mode; run in foreground and log"
2311
 
                        " to terminal", default=None)
 
1964
                        " to terminal")
2312
1965
    parser.add_argument("--debuglevel", metavar="LEVEL",
2313
1966
                        help="Debug level for stdout output")
2314
1967
    parser.add_argument("--priority", help="GnuTLS"
2321
1974
                        " files")
2322
1975
    parser.add_argument("--no-dbus", action="store_false",
2323
1976
                        dest="use_dbus", help="Do not provide D-Bus"
2324
 
                        " system bus interface", default=None)
 
1977
                        " system bus interface")
2325
1978
    parser.add_argument("--no-ipv6", action="store_false",
2326
 
                        dest="use_ipv6", help="Do not use IPv6",
2327
 
                        default=None)
 
1979
                        dest="use_ipv6", help="Do not use IPv6")
2328
1980
    parser.add_argument("--no-restore", action="store_false",
2329
1981
                        dest="restore", help="Do not restore stored"
2330
 
                        " state", default=None)
2331
 
    parser.add_argument("--socket", type=int,
2332
 
                        help="Specify a file descriptor to a network"
2333
 
                        " socket to use instead of creating one")
 
1982
                        " state")
2334
1983
    parser.add_argument("--statedir", metavar="DIR",
2335
1984
                        help="Directory to save/restore state in")
2336
 
    parser.add_argument("--foreground", action="store_true",
2337
 
                        help="Run in foreground", default=None)
2338
1985
    
2339
1986
    options = parser.parse_args()
2340
1987
    
2349
1996
                        "port": "",
2350
1997
                        "debug": "False",
2351
1998
                        "priority":
2352
 
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
 
1999
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2353
2000
                        "servicename": "Mandos",
2354
2001
                        "use_dbus": "True",
2355
2002
                        "use_ipv6": "True",
2356
2003
                        "debuglevel": "",
2357
2004
                        "restore": "True",
2358
 
                        "socket": "",
2359
 
                        "statedir": "/var/lib/mandos",
2360
 
                        "foreground": "False",
 
2005
                        "statedir": "/var/lib/mandos"
2361
2006
                        }
2362
2007
    
2363
2008
    # Parse config file for server-global settings
2368
2013
    # Convert the SafeConfigParser object to a dict
2369
2014
    server_settings = server_config.defaults()
2370
2015
    # Use the appropriate methods on the non-string config options
2371
 
    for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
 
2016
    for option in ("debug", "use_dbus", "use_ipv6"):
2372
2017
        server_settings[option] = server_config.getboolean("DEFAULT",
2373
2018
                                                           option)
2374
2019
    if server_settings["port"]:
2375
2020
        server_settings["port"] = server_config.getint("DEFAULT",
2376
2021
                                                       "port")
2377
 
    if server_settings["socket"]:
2378
 
        server_settings["socket"] = server_config.getint("DEFAULT",
2379
 
                                                         "socket")
2380
 
        # Later, stdin will, and stdout and stderr might, be dup'ed
2381
 
        # over with an opened os.devnull.  But we don't want this to
2382
 
        # happen with a supplied network socket.
2383
 
        if 0 <= server_settings["socket"] <= 2:
2384
 
            server_settings["socket"] = os.dup(server_settings
2385
 
                                               ["socket"])
2386
2022
    del server_config
2387
2023
    
2388
2024
    # Override the settings from the config file with command line
2390
2026
    for option in ("interface", "address", "port", "debug",
2391
2027
                   "priority", "servicename", "configdir",
2392
2028
                   "use_dbus", "use_ipv6", "debuglevel", "restore",
2393
 
                   "statedir", "socket", "foreground"):
 
2029
                   "statedir"):
2394
2030
        value = getattr(options, option)
2395
2031
        if value is not None:
2396
2032
            server_settings[option] = value
2399
2035
    for option in server_settings.keys():
2400
2036
        if type(server_settings[option]) is str:
2401
2037
            server_settings[option] = unicode(server_settings[option])
2402
 
    # Force all boolean options to be boolean
2403
 
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
2404
 
                   "foreground"):
2405
 
        server_settings[option] = bool(server_settings[option])
2406
 
    # Debug implies foreground
2407
 
    if server_settings["debug"]:
2408
 
        server_settings["foreground"] = True
2409
2038
    # Now we have our good server settings in "server_settings"
2410
2039
    
2411
2040
    ##################################################################
2417
2046
    use_ipv6 = server_settings["use_ipv6"]
2418
2047
    stored_state_path = os.path.join(server_settings["statedir"],
2419
2048
                                     stored_state_file)
2420
 
    foreground = server_settings["foreground"]
2421
2049
    
2422
2050
    if debug:
2423
 
        initlogger(debug, logging.DEBUG)
 
2051
        initlogger(logging.DEBUG)
2424
2052
    else:
2425
2053
        if not debuglevel:
2426
 
            initlogger(debug)
 
2054
            initlogger()
2427
2055
        else:
2428
2056
            level = getattr(logging, debuglevel.upper())
2429
 
            initlogger(debug, level)
 
2057
            initlogger(level)
2430
2058
    
2431
2059
    if server_settings["servicename"] != "Mandos":
2432
2060
        syslogger.setFormatter(logging.Formatter
2433
 
                               ('Mandos ({0}) [%(process)d]:'
2434
 
                                ' %(levelname)s: %(message)s'
2435
 
                                .format(server_settings
2436
 
                                        ["servicename"])))
 
2061
                               ('Mandos (%s) [%%(process)d]:'
 
2062
                                ' %%(levelname)s: %%(message)s'
 
2063
                                % server_settings["servicename"]))
2437
2064
    
2438
2065
    # Parse config file with clients
2439
 
    client_config = configparser.SafeConfigParser(Client
2440
 
                                                  .client_defaults)
 
2066
    client_defaults = { "timeout": "5m",
 
2067
                        "extended_timeout": "15m",
 
2068
                        "interval": "2m",
 
2069
                        "checker": "fping -q -- %%(host)s",
 
2070
                        "host": "",
 
2071
                        "approval_delay": "0s",
 
2072
                        "approval_duration": "1s",
 
2073
                        }
 
2074
    client_config = configparser.SafeConfigParser(client_defaults)
2441
2075
    client_config.read(os.path.join(server_settings["configdir"],
2442
2076
                                    "clients.conf"))
2443
2077
    
2452
2086
                              use_ipv6=use_ipv6,
2453
2087
                              gnutls_priority=
2454
2088
                              server_settings["priority"],
2455
 
                              use_dbus=use_dbus,
2456
 
                              socketfd=(server_settings["socket"]
2457
 
                                        or None))
2458
 
    if not foreground:
2459
 
        pidfilename = "/run/mandos.pid"
2460
 
        if not os.path.isdir("/run/."):
2461
 
            pidfilename = "/var/run/mandos.pid"
2462
 
        pidfile = None
 
2089
                              use_dbus=use_dbus)
 
2090
    if not debug:
 
2091
        pidfilename = "/var/run/mandos.pid"
2463
2092
        try:
2464
2093
            pidfile = open(pidfilename, "w")
2465
 
        except IOError as e:
2466
 
            logger.error("Could not open file %r", pidfilename,
2467
 
                         exc_info=e)
 
2094
        except IOError:
 
2095
            logger.error("Could not open file %r", pidfilename)
2468
2096
    
2469
 
    for name in ("_mandos", "mandos", "nobody"):
 
2097
    try:
 
2098
        uid = pwd.getpwnam("_mandos").pw_uid
 
2099
        gid = pwd.getpwnam("_mandos").pw_gid
 
2100
    except KeyError:
2470
2101
        try:
2471
 
            uid = pwd.getpwnam(name).pw_uid
2472
 
            gid = pwd.getpwnam(name).pw_gid
2473
 
            break
 
2102
            uid = pwd.getpwnam("mandos").pw_uid
 
2103
            gid = pwd.getpwnam("mandos").pw_gid
2474
2104
        except KeyError:
2475
 
            continue
2476
 
    else:
2477
 
        uid = 65534
2478
 
        gid = 65534
 
2105
            try:
 
2106
                uid = pwd.getpwnam("nobody").pw_uid
 
2107
                gid = pwd.getpwnam("nobody").pw_gid
 
2108
            except KeyError:
 
2109
                uid = 65534
 
2110
                gid = 65534
2479
2111
    try:
2480
2112
        os.setgid(gid)
2481
2113
        os.setuid(uid)
2482
2114
    except OSError as error:
2483
 
        if error.errno != errno.EPERM:
 
2115
        if error[0] != errno.EPERM:
2484
2116
            raise error
2485
2117
    
2486
2118
    if debug:
2498
2130
         .gnutls_global_set_log_function(debug_gnutls))
2499
2131
        
2500
2132
        # Redirect stdin so all checkers get /dev/null
2501
 
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
 
2133
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2502
2134
        os.dup2(null, sys.stdin.fileno())
2503
2135
        if null > 2:
2504
2136
            os.close(null)
 
2137
    else:
 
2138
        # No console logging
 
2139
        logger.removeHandler(console)
2505
2140
    
2506
2141
    # Need to fork before connecting to D-Bus
2507
 
    if not foreground:
 
2142
    if not debug:
2508
2143
        # Close all input and output, do double fork, etc.
2509
2144
        daemon()
2510
2145
    
2511
 
    # multiprocessing will use threads, so before we use gobject we
2512
 
    # need to inform gobject that threads will be used.
2513
 
    gobject.threads_init()
2514
 
    
2515
2146
    global main_loop
2516
2147
    # From the Avahi example code
2517
 
    DBusGMainLoop(set_as_default=True)
 
2148
    DBusGMainLoop(set_as_default=True )
2518
2149
    main_loop = gobject.MainLoop()
2519
2150
    bus = dbus.SystemBus()
2520
2151
    # End of Avahi example code
2526
2157
                            ("se.bsnet.fukt.Mandos", bus,
2527
2158
                             do_not_queue=True))
2528
2159
        except dbus.exceptions.NameExistsException as e:
2529
 
            logger.error("Disabling D-Bus:", exc_info=e)
 
2160
            logger.error(unicode(e) + ", disabling D-Bus")
2530
2161
            use_dbus = False
2531
2162
            server_settings["use_dbus"] = False
2532
2163
            tcp_server.use_dbus = False
2544
2175
    
2545
2176
    client_class = Client
2546
2177
    if use_dbus:
2547
 
        client_class = functools.partial(ClientDBus, bus = bus)
2548
 
    
2549
 
    client_settings = Client.config_parser(client_config)
 
2178
        client_class = functools.partial(ClientDBusTransitional,
 
2179
                                         bus = bus)
 
2180
    
 
2181
    special_settings = {
 
2182
        # Some settings need to be accessd by special methods;
 
2183
        # booleans need .getboolean(), etc.  Here is a list of them:
 
2184
        "approved_by_default":
 
2185
            lambda section:
 
2186
            client_config.getboolean(section, "approved_by_default"),
 
2187
        "enabled":
 
2188
            lambda section:
 
2189
            client_config.getboolean(section, "enabled"),
 
2190
        }
 
2191
    # Construct a new dict of client settings of this form:
 
2192
    # { client_name: {setting_name: value, ...}, ...}
 
2193
    # with exceptions for any special settings as defined above
 
2194
    client_settings = dict((clientname,
 
2195
                           dict((setting,
 
2196
                                 (value
 
2197
                                  if setting not in special_settings
 
2198
                                  else special_settings[setting]
 
2199
                                  (clientname)))
 
2200
                                for setting, value in
 
2201
                                client_config.items(clientname)))
 
2202
                          for clientname in client_config.sections())
 
2203
    
2550
2204
    old_client_settings = {}
2551
 
    clients_data = {}
2552
 
    
2553
 
    # This is used to redirect stdout and stderr for checker processes
2554
 
    global wnull
2555
 
    wnull = open(os.devnull, "w") # A writable /dev/null
2556
 
    # Only used if server is running in foreground but not in debug
2557
 
    # mode
2558
 
    if debug or not foreground:
2559
 
        wnull.close()
 
2205
    clients_data = []
2560
2206
    
2561
2207
    # Get client data and settings from last running state.
2562
2208
    if server_settings["restore"]:
2566
2212
                                                     (stored_state))
2567
2213
            os.remove(stored_state_path)
2568
2214
        except IOError as e:
2569
 
            if e.errno == errno.ENOENT:
2570
 
                logger.warning("Could not load persistent state: {0}"
2571
 
                                .format(os.strerror(e.errno)))
2572
 
            else:
2573
 
                logger.critical("Could not load persistent state:",
2574
 
                                exc_info=e)
 
2215
            logger.warning("Could not load persistent state: {0}"
 
2216
                           .format(e))
 
2217
            if e.errno != errno.ENOENT:
2575
2218
                raise
2576
 
        except EOFError as e:
2577
 
            logger.warning("Could not load persistent state: "
2578
 
                           "EOFError:", exc_info=e)
2579
2219
    
2580
 
    with PGPEngine() as pgp:
2581
 
        for client_name, client in clients_data.iteritems():
2582
 
            # Skip removed clients
2583
 
            if client_name not in client_settings:
2584
 
                continue
 
2220
    with Crypto() as crypt:
 
2221
        for client in clients_data:
 
2222
            client_name = client["name"]
2585
2223
            
2586
2224
            # Decide which value to use after restoring saved state.
2587
2225
            # We have three different values: Old config file,
2596
2234
                    if (name != "secret" and
2597
2235
                        value != old_client_settings[client_name]
2598
2236
                        [name]):
2599
 
                        client[name] = value
 
2237
                        setattr(client, name, value)
2600
2238
                except KeyError:
2601
2239
                    pass
2602
2240
            
2603
2241
            # Clients who has passed its expire date can still be
2604
 
            # enabled if its last checker was successful.  Clients
2605
 
            # whose checker succeeded before we stored its state is
2606
 
            # assumed to have successfully run all checkers during
2607
 
            # downtime.
2608
 
            if client["enabled"]:
2609
 
                if datetime.datetime.utcnow() >= client["expires"]:
2610
 
                    if not client["last_checked_ok"]:
2611
 
                        logger.warning(
2612
 
                            "disabling client {0} - Client never "
2613
 
                            "performed a successful checker"
2614
 
                            .format(client_name))
2615
 
                        client["enabled"] = False
2616
 
                    elif client["last_checker_status"] != 0:
2617
 
                        logger.warning(
2618
 
                            "disabling client {0} - Client "
2619
 
                            "last checker failed with error code {1}"
2620
 
                            .format(client_name,
2621
 
                                    client["last_checker_status"]))
 
2242
            # enabled if its last checker was sucessful.  Clients
 
2243
            # whose checker failed before we stored its state is
 
2244
            # assumed to have failed all checkers during downtime.
 
2245
            if client["enabled"] and client["last_checked_ok"]:
 
2246
                if ((datetime.datetime.utcnow()
 
2247
                     - client["last_checked_ok"])
 
2248
                    > client["interval"]):
 
2249
                    if client["last_checker_status"] != 0:
2622
2250
                        client["enabled"] = False
2623
2251
                    else:
2624
2252
                        client["expires"] = (datetime.datetime
2625
2253
                                             .utcnow()
2626
2254
                                             + client["timeout"])
2627
 
                        logger.debug("Last checker succeeded,"
2628
 
                                     " keeping {0} enabled"
2629
 
                                     .format(client_name))
 
2255
            
 
2256
            client["changedstate"] = (multiprocessing_manager
 
2257
                                      .Condition
 
2258
                                      (multiprocessing_manager
 
2259
                                       .Lock()))
 
2260
            if use_dbus:
 
2261
                new_client = (ClientDBusTransitional.__new__
 
2262
                              (ClientDBusTransitional))
 
2263
                tcp_server.clients[client_name] = new_client
 
2264
                new_client.bus = bus
 
2265
                for name, value in client.iteritems():
 
2266
                    setattr(new_client, name, value)
 
2267
                client_object_name = unicode(client_name).translate(
 
2268
                    {ord("."): ord("_"),
 
2269
                     ord("-"): ord("_")})
 
2270
                new_client.dbus_object_path = (dbus.ObjectPath
 
2271
                                               ("/clients/"
 
2272
                                                + client_object_name))
 
2273
                DBusObjectWithProperties.__init__(new_client,
 
2274
                                                  new_client.bus,
 
2275
                                                  new_client
 
2276
                                                  .dbus_object_path)
 
2277
            else:
 
2278
                tcp_server.clients[client_name] = (Client.__new__
 
2279
                                                   (Client))
 
2280
                for name, value in client.iteritems():
 
2281
                    setattr(tcp_server.clients[client_name],
 
2282
                            name, value)
 
2283
            
2630
2284
            try:
2631
 
                client["secret"] = (
2632
 
                    pgp.decrypt(client["encrypted_secret"],
2633
 
                                client_settings[client_name]
2634
 
                                ["secret"]))
2635
 
            except PGPError:
 
2285
                tcp_server.clients[client_name].secret = (
 
2286
                    crypt.decrypt(tcp_server.clients[client_name]
 
2287
                                  .encrypted_secret,
 
2288
                                  client_settings[client_name]
 
2289
                                  ["secret"]))
 
2290
            except CryptoError:
2636
2291
                # If decryption fails, we use secret from new settings
2637
 
                logger.debug("Failed to decrypt {0} old secret"
2638
 
                             .format(client_name))
2639
 
                client["secret"] = (
 
2292
                tcp_server.clients[client_name].secret = (
2640
2293
                    client_settings[client_name]["secret"])
2641
2294
    
2642
 
    # Add/remove clients based on new changes made to config
2643
 
    for client_name in (set(old_client_settings)
2644
 
                        - set(client_settings)):
2645
 
        del clients_data[client_name]
2646
 
    for client_name in (set(client_settings)
2647
 
                        - set(old_client_settings)):
2648
 
        clients_data[client_name] = client_settings[client_name]
2649
 
    
2650
 
    # Create all client objects
2651
 
    for client_name, client in clients_data.iteritems():
2652
 
        tcp_server.clients[client_name] = client_class(
2653
 
            name = client_name, settings = client,
2654
 
            server_settings = server_settings)
 
2295
    # Create/remove clients based on new changes made to config
 
2296
    for clientname in set(old_client_settings) - set(client_settings):
 
2297
        del tcp_server.clients[clientname]
 
2298
    for clientname in set(client_settings) - set(old_client_settings):
 
2299
        tcp_server.clients[clientname] = (client_class(name
 
2300
                                                       = clientname,
 
2301
                                                       config =
 
2302
                                                       client_settings
 
2303
                                                       [clientname]))
2655
2304
    
2656
2305
    if not tcp_server.clients:
2657
2306
        logger.warning("No clients defined")
2658
 
    
2659
 
    if not foreground:
2660
 
        if pidfile is not None:
2661
 
            try:
2662
 
                with pidfile:
2663
 
                    pid = os.getpid()
2664
 
                    pidfile.write(str(pid) + "\n".encode("utf-8"))
2665
 
            except IOError:
2666
 
                logger.error("Could not write to file %r with PID %d",
2667
 
                             pidfilename, pid)
2668
 
        del pidfile
 
2307
        
 
2308
    if not debug:
 
2309
        try:
 
2310
            with pidfile:
 
2311
                pid = os.getpid()
 
2312
                pidfile.write(str(pid) + "\n".encode("utf-8"))
 
2313
            del pidfile
 
2314
        except IOError:
 
2315
            logger.error("Could not write to file %r with PID %d",
 
2316
                         pidfilename, pid)
 
2317
        except NameError:
 
2318
            # "pidfile" was never created
 
2319
            pass
2669
2320
        del pidfilename
 
2321
        
 
2322
        signal.signal(signal.SIGINT, signal.SIG_IGN)
2670
2323
    
2671
2324
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2672
2325
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2673
2326
    
2674
2327
    if use_dbus:
2675
 
        @alternate_dbus_interfaces({"se.recompile.Mandos":
2676
 
                                        "se.bsnet.fukt.Mandos"})
2677
 
        class MandosDBusService(DBusObjectWithProperties):
 
2328
        class MandosDBusService(dbus.service.Object):
2678
2329
            """A D-Bus proxy object"""
2679
2330
            def __init__(self):
2680
2331
                dbus.service.Object.__init__(self, bus, "/")
2681
2332
            _interface = "se.recompile.Mandos"
2682
2333
            
2683
 
            @dbus_interface_annotations(_interface)
2684
 
            def _foo(self):
2685
 
                return { "org.freedesktop.DBus.Property"
2686
 
                         ".EmitsChangedSignal":
2687
 
                             "false"}
2688
 
            
2689
2334
            @dbus.service.signal(_interface, signature="o")
2690
2335
            def ClientAdded(self, objpath):
2691
2336
                "D-Bus signal"
2733
2378
            
2734
2379
            del _interface
2735
2380
        
2736
 
        mandos_dbus_service = MandosDBusService()
 
2381
        class MandosDBusServiceTransitional(MandosDBusService):
 
2382
            __metaclass__ = AlternateDBusNamesMetaclass
 
2383
        mandos_dbus_service = MandosDBusServiceTransitional()
2737
2384
    
2738
2385
    def cleanup():
2739
2386
        "Cleanup function; run on exit"
2740
2387
        service.cleanup()
2741
2388
        
2742
2389
        multiprocessing.active_children()
2743
 
        wnull.close()
2744
2390
        if not (tcp_server.clients or client_settings):
2745
2391
            return
2746
2392
        
2747
2393
        # Store client before exiting. Secrets are encrypted with key
2748
2394
        # based on what config file has. If config file is
2749
2395
        # removed/edited, old secret will thus be unrecovable.
2750
 
        clients = {}
2751
 
        with PGPEngine() as pgp:
 
2396
        clients = []
 
2397
        with Crypto() as crypt:
2752
2398
            for client in tcp_server.clients.itervalues():
2753
2399
                key = client_settings[client.name]["secret"]
2754
 
                client.encrypted_secret = pgp.encrypt(client.secret,
2755
 
                                                      key)
 
2400
                client.encrypted_secret = crypt.encrypt(client.secret,
 
2401
                                                        key)
2756
2402
                client_dict = {}
2757
2403
                
2758
 
                # A list of attributes that can not be pickled
2759
 
                # + secret.
2760
 
                exclude = set(("bus", "changedstate", "secret",
2761
 
                               "checker", "server_settings"))
 
2404
                # A list of attributes that will not be stored when
 
2405
                # shutting down.
 
2406
                exclude = set(("bus", "changedstate", "secret"))
2762
2407
                for name, typ in (inspect.getmembers
2763
2408
                                  (dbus.service.Object)):
2764
2409
                    exclude.add(name)
2769
2414
                    if attr not in exclude:
2770
2415
                        client_dict[attr] = getattr(client, attr)
2771
2416
                
2772
 
                clients[client.name] = client_dict
 
2417
                clients.append(client_dict)
2773
2418
                del client_settings[client.name]["secret"]
2774
2419
        
2775
2420
        try:
2776
 
            with (tempfile.NamedTemporaryFile
2777
 
                  (mode='wb', suffix=".pickle", prefix='clients-',
2778
 
                   dir=os.path.dirname(stored_state_path),
2779
 
                   delete=False)) as stored_state:
 
2421
            with os.fdopen(os.open(stored_state_path,
 
2422
                                   os.O_CREAT|os.O_WRONLY|os.O_TRUNC,
 
2423
                                   0600), "wb") as stored_state:
2780
2424
                pickle.dump((clients, client_settings), stored_state)
2781
 
                tempname=stored_state.name
2782
 
            os.rename(tempname, stored_state_path)
2783
2425
        except (IOError, OSError) as e:
2784
 
            if not debug:
2785
 
                try:
2786
 
                    os.remove(tempname)
2787
 
                except NameError:
2788
 
                    pass
2789
 
            if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2790
 
                logger.warning("Could not save persistent state: {0}"
2791
 
                               .format(os.strerror(e.errno)))
2792
 
            else:
2793
 
                logger.warning("Could not save persistent state:",
2794
 
                               exc_info=e)
2795
 
                raise e
 
2426
            logger.warning("Could not save persistent state: {0}"
 
2427
                           .format(e))
 
2428
            if e.errno not in (errno.ENOENT, errno.EACCES):
 
2429
                raise
2796
2430
        
2797
2431
        # Delete all clients, and settings from config
2798
2432
        while tcp_server.clients:
2825
2459
    service.port = tcp_server.socket.getsockname()[1]
2826
2460
    if use_ipv6:
2827
2461
        logger.info("Now listening on address %r, port %d,"
2828
 
                    " flowinfo %d, scope_id %d",
2829
 
                    *tcp_server.socket.getsockname())
 
2462
                    " flowinfo %d, scope_id %d"
 
2463
                    % tcp_server.socket.getsockname())
2830
2464
    else:                       # IPv4
2831
 
        logger.info("Now listening on address %r, port %d",
2832
 
                    *tcp_server.socket.getsockname())
 
2465
        logger.info("Now listening on address %r, port %d"
 
2466
                    % tcp_server.socket.getsockname())
2833
2467
    
2834
2468
    #service.interface = tcp_server.socket.getsockname()[3]
2835
2469
    
2838
2472
        try:
2839
2473
            service.activate()
2840
2474
        except dbus.exceptions.DBusException as error:
2841
 
            logger.critical("D-Bus Exception", exc_info=error)
 
2475
            logger.critical("DBusException: %s", error)
2842
2476
            cleanup()
2843
2477
            sys.exit(1)
2844
2478
        # End of Avahi example code
2851
2485
        logger.debug("Starting main loop")
2852
2486
        main_loop.run()
2853
2487
    except AvahiError as error:
2854
 
        logger.critical("Avahi Error", exc_info=error)
 
2488
        logger.critical("AvahiError: %s", error)
2855
2489
        cleanup()
2856
2490
        sys.exit(1)
2857
2491
    except KeyboardInterrupt:
2862
2496
    # Must run before the D-Bus bus name gets deregistered
2863
2497
    cleanup()
2864
2498
 
 
2499
 
2865
2500
if __name__ == '__main__':
2866
2501
    main()