/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: 2012-05-20 14:37:17 UTC
  • mfrom: (237.4.31 release)
  • Revision ID: teddy@recompile.se-20120520143717-48406ypmuwgwl32f
Merge from release branch.

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-2011 Teddy Hogeborn
15
 
# Copyright © 2008-2011 Björn Påhlsson
 
14
# Copyright © 2008-2012 Teddy Hogeborn
 
15
# Copyright © 2008-2012 Björn Påhlsson
16
16
17
17
# This program is free software: you can redistribute it and/or modify
18
18
# it under the terms of the GNU General Public License as published by
34
34
from __future__ import (division, absolute_import, print_function,
35
35
                        unicode_literals)
36
36
 
 
37
from future_builtins import *
 
38
 
37
39
import SocketServer as socketserver
38
40
import socket
39
41
import argparse
63
65
import cPickle as pickle
64
66
import multiprocessing
65
67
import types
 
68
import binascii
 
69
import tempfile
 
70
import itertools
66
71
 
67
72
import dbus
68
73
import dbus.service
73
78
import ctypes.util
74
79
import xml.dom.minidom
75
80
import inspect
 
81
import GnuPGInterface
76
82
 
77
83
try:
78
84
    SO_BINDTODEVICE = socket.SO_BINDTODEVICE
82
88
    except ImportError:
83
89
        SO_BINDTODEVICE = None
84
90
 
85
 
 
86
 
version = "1.4.1"
87
 
 
88
 
#logger = logging.getLogger('mandos')
89
 
logger = logging.Logger('mandos')
 
91
version = "1.5.4"
 
92
stored_state_file = "clients.pickle"
 
93
 
 
94
logger = logging.getLogger()
90
95
syslogger = (logging.handlers.SysLogHandler
91
96
             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
92
97
              address = str("/dev/log")))
93
 
syslogger.setFormatter(logging.Formatter
94
 
                       ('Mandos [%(process)d]: %(levelname)s:'
95
 
                        ' %(message)s'))
96
 
logger.addHandler(syslogger)
97
 
 
98
 
console = logging.StreamHandler()
99
 
console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'
100
 
                                       ' %(levelname)s:'
101
 
                                       ' %(message)s'))
102
 
logger.addHandler(console)
 
98
 
 
99
try:
 
100
    if_nametoindex = (ctypes.cdll.LoadLibrary
 
101
                      (ctypes.util.find_library("c"))
 
102
                      .if_nametoindex)
 
103
except (OSError, AttributeError):
 
104
    def if_nametoindex(interface):
 
105
        "Get an interface index the hard way, i.e. using fcntl()"
 
106
        SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
 
107
        with contextlib.closing(socket.socket()) as s:
 
108
            ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
 
109
                                struct.pack(str("16s16x"),
 
110
                                            interface))
 
111
        interface_index = struct.unpack(str("I"),
 
112
                                        ifreq[16:20])[0]
 
113
        return interface_index
 
114
 
 
115
 
 
116
def initlogger(debug, level=logging.WARNING):
 
117
    """init logger and add loglevel"""
 
118
    
 
119
    syslogger.setFormatter(logging.Formatter
 
120
                           ('Mandos [%(process)d]: %(levelname)s:'
 
121
                            ' %(message)s'))
 
122
    logger.addHandler(syslogger)
 
123
    
 
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)
 
131
    logger.setLevel(level)
 
132
 
 
133
 
 
134
class PGPError(Exception):
 
135
    """Exception if encryption/decryption fails"""
 
136
    pass
 
137
 
 
138
 
 
139
class PGPEngine(object):
 
140
    """A simple class for OpenPGP symmetric encryption & decryption"""
 
141
    def __init__(self):
 
142
        self.gnupg = GnuPGInterface.GnuPG()
 
143
        self.tempdir = tempfile.mkdtemp(prefix="mandos-")
 
144
        self.gnupg = GnuPGInterface.GnuPG()
 
145
        self.gnupg.options.meta_interactive = False
 
146
        self.gnupg.options.homedir = self.tempdir
 
147
        self.gnupg.options.extra_args.extend(['--force-mdc',
 
148
                                              '--quiet',
 
149
                                              '--no-use-agent'])
 
150
    
 
151
    def __enter__(self):
 
152
        return self
 
153
    
 
154
    def __exit__ (self, exc_type, exc_value, traceback):
 
155
        self._cleanup()
 
156
        return False
 
157
    
 
158
    def __del__(self):
 
159
        self._cleanup()
 
160
    
 
161
    def _cleanup(self):
 
162
        if self.tempdir is not None:
 
163
            # Delete contents of tempdir
 
164
            for root, dirs, files in os.walk(self.tempdir,
 
165
                                             topdown = False):
 
166
                for filename in files:
 
167
                    os.remove(os.path.join(root, filename))
 
168
                for dirname in dirs:
 
169
                    os.rmdir(os.path.join(root, dirname))
 
170
            # Remove tempdir
 
171
            os.rmdir(self.tempdir)
 
172
            self.tempdir = None
 
173
    
 
174
    def password_encode(self, password):
 
175
        # Passphrase can not be empty and can not contain newlines or
 
176
        # NUL bytes.  So we prefix it and hex encode it.
 
177
        return b"mandos" + binascii.hexlify(password)
 
178
    
 
179
    def encrypt(self, data, password):
 
180
        self.gnupg.passphrase = self.password_encode(password)
 
181
        with open(os.devnull, "w") as devnull:
 
182
            try:
 
183
                proc = self.gnupg.run(['--symmetric'],
 
184
                                      create_fhs=['stdin', 'stdout'],
 
185
                                      attach_fhs={'stderr': devnull})
 
186
                with contextlib.closing(proc.handles['stdin']) as f:
 
187
                    f.write(data)
 
188
                with contextlib.closing(proc.handles['stdout']) as f:
 
189
                    ciphertext = f.read()
 
190
                proc.wait()
 
191
            except IOError as e:
 
192
                raise PGPError(e)
 
193
        self.gnupg.passphrase = None
 
194
        return ciphertext
 
195
    
 
196
    def decrypt(self, data, password):
 
197
        self.gnupg.passphrase = self.password_encode(password)
 
198
        with open(os.devnull, "w") as devnull:
 
199
            try:
 
200
                proc = self.gnupg.run(['--decrypt'],
 
201
                                      create_fhs=['stdin', 'stdout'],
 
202
                                      attach_fhs={'stderr': devnull})
 
203
                with contextlib.closing(proc.handles['stdin']) as f:
 
204
                    f.write(data)
 
205
                with contextlib.closing(proc.handles['stdout']) as f:
 
206
                    decrypted_plaintext = f.read()
 
207
                proc.wait()
 
208
            except IOError as e:
 
209
                raise PGPError(e)
 
210
        self.gnupg.passphrase = None
 
211
        return decrypted_plaintext
 
212
 
103
213
 
104
214
class AvahiError(Exception):
105
215
    def __init__(self, value, *args, **kwargs):
135
245
    server: D-Bus Server
136
246
    bus: dbus.SystemBus()
137
247
    """
 
248
    
138
249
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
139
250
                 servicetype = None, port = None, TXT = None,
140
251
                 domain = "", host = "", max_renames = 32768,
153
264
        self.server = None
154
265
        self.bus = bus
155
266
        self.entry_group_state_changed_match = None
 
267
    
156
268
    def rename(self):
157
269
        """Derived from the Avahi example code"""
158
270
        if self.rename_count >= self.max_renames:
164
276
                            .GetAlternativeServiceName(self.name))
165
277
        logger.info("Changing Zeroconf service name to %r ...",
166
278
                    self.name)
167
 
        syslogger.setFormatter(logging.Formatter
168
 
                               ('Mandos (%s) [%%(process)d]:'
169
 
                                ' %%(levelname)s: %%(message)s'
170
 
                                % self.name))
171
279
        self.remove()
172
280
        try:
173
281
            self.add()
174
282
        except dbus.exceptions.DBusException as error:
175
 
            logger.critical("DBusException: %s", error)
 
283
            logger.critical("D-Bus Exception", exc_info=error)
176
284
            self.cleanup()
177
285
            os._exit(1)
178
286
        self.rename_count += 1
 
287
    
179
288
    def remove(self):
180
289
        """Derived from the Avahi example code"""
181
290
        if self.entry_group_state_changed_match is not None:
183
292
            self.entry_group_state_changed_match = None
184
293
        if self.group is not None:
185
294
            self.group.Reset()
 
295
    
186
296
    def add(self):
187
297
        """Derived from the Avahi example code"""
188
298
        self.remove()
193
303
                avahi.DBUS_INTERFACE_ENTRY_GROUP)
194
304
        self.entry_group_state_changed_match = (
195
305
            self.group.connect_to_signal(
196
 
                'StateChanged', self .entry_group_state_changed))
 
306
                'StateChanged', self.entry_group_state_changed))
197
307
        logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
198
308
                     self.name, self.type)
199
309
        self.group.AddService(
205
315
            dbus.UInt16(self.port),
206
316
            avahi.string_array_to_txt_array(self.TXT))
207
317
        self.group.Commit()
 
318
    
208
319
    def entry_group_state_changed(self, state, error):
209
320
        """Derived from the Avahi example code"""
210
321
        logger.debug("Avahi entry group state change: %i", state)
217
328
        elif state == avahi.ENTRY_GROUP_FAILURE:
218
329
            logger.critical("Avahi: Error in group state changed %s",
219
330
                            unicode(error))
220
 
            raise AvahiGroupError("State changed: %s"
221
 
                                  % unicode(error))
 
331
            raise AvahiGroupError("State changed: {0!s}"
 
332
                                  .format(error))
 
333
    
222
334
    def cleanup(self):
223
335
        """Derived from the Avahi example code"""
224
336
        if self.group is not None:
225
337
            try:
226
338
                self.group.Free()
227
339
            except (dbus.exceptions.UnknownMethodException,
228
 
                    dbus.exceptions.DBusException) as e:
 
340
                    dbus.exceptions.DBusException):
229
341
                pass
230
342
            self.group = None
231
343
        self.remove()
 
344
    
232
345
    def server_state_changed(self, state, error=None):
233
346
        """Derived from the Avahi example code"""
234
347
        logger.debug("Avahi server state change: %i", state)
253
366
                logger.debug("Unknown state: %r", state)
254
367
            else:
255
368
                logger.debug("Unknown state: %r: %r", state, error)
 
369
    
256
370
    def activate(self):
257
371
        """Derived from the Avahi example code"""
258
372
        if self.server is None:
266
380
        self.server_state_changed(self.server.GetState())
267
381
 
268
382
 
269
 
def _timedelta_to_milliseconds(td):
 
383
class AvahiServiceToSyslog(AvahiService):
 
384
    def rename(self):
 
385
        """Add the new name to the syslog messages"""
 
386
        ret = AvahiService.rename(self)
 
387
        syslogger.setFormatter(logging.Formatter
 
388
                               ('Mandos ({0}) [%(process)d]:'
 
389
                                ' %(levelname)s: %(message)s'
 
390
                                .format(self.name)))
 
391
        return ret
 
392
 
 
393
 
 
394
def timedelta_to_milliseconds(td):
270
395
    "Convert a datetime.timedelta() to milliseconds"
271
396
    return ((td.days * 24 * 60 * 60 * 1000)
272
397
            + (td.seconds * 1000)
273
398
            + (td.microseconds // 1000))
274
 
        
 
399
 
 
400
 
275
401
class Client(object):
276
402
    """A representation of a client host served by this server.
277
403
    
278
404
    Attributes:
279
 
    _approved:   bool(); 'None' if not yet approved/disapproved
 
405
    approved:   bool(); 'None' if not yet approved/disapproved
280
406
    approval_delay: datetime.timedelta(); Time to wait for approval
281
407
    approval_duration: datetime.timedelta(); Duration of one approval
282
408
    checker:    subprocess.Popen(); a running checker process used
289
415
                     instance %(name)s can be used in the command.
290
416
    checker_initiator_tag: a gobject event source tag, or None
291
417
    created:    datetime.datetime(); (UTC) object creation
 
418
    client_structure: Object describing what attributes a client has
 
419
                      and is used for storing the client at exit
292
420
    current_checker_command: string; current running checker_command
293
 
    disable_hook:  If set, called by disable() as disable_hook(self)
294
421
    disable_initiator_tag: a gobject event source tag, or None
295
422
    enabled:    bool()
296
423
    fingerprint: string (40 or 32 hexadecimal digits); used to
299
426
    interval:   datetime.timedelta(); How often to start a new checker
300
427
    last_approval_request: datetime.datetime(); (UTC) or None
301
428
    last_checked_ok: datetime.datetime(); (UTC) or None
302
 
    last_enabled: datetime.datetime(); (UTC)
 
429
    last_checker_status: integer between 0 and 255 reflecting exit
 
430
                         status of last checker. -1 reflects crashed
 
431
                         checker, -2 means no checker completed yet.
 
432
    last_enabled: datetime.datetime(); (UTC) or None
303
433
    name:       string; from the config file, used in log messages and
304
434
                        D-Bus identifiers
305
435
    secret:     bytestring; sent verbatim (over TLS) to client
306
436
    timeout:    datetime.timedelta(); How long from last_checked_ok
307
437
                                      until this client is disabled
308
 
    extended_timeout:   extra long timeout when password has been sent
 
438
    extended_timeout:   extra long timeout when secret has been sent
309
439
    runtime_expansions: Allowed attributes for runtime expansion.
310
440
    expires:    datetime.datetime(); time (UTC) when a client will be
311
441
                disabled, or None
312
442
    """
313
443
    
314
444
    runtime_expansions = ("approval_delay", "approval_duration",
315
 
                          "created", "enabled", "fingerprint",
316
 
                          "host", "interval", "last_checked_ok",
 
445
                          "created", "enabled", "expires",
 
446
                          "fingerprint", "host", "interval",
 
447
                          "last_approval_request", "last_checked_ok",
317
448
                          "last_enabled", "name", "timeout")
 
449
    client_defaults = { "timeout": "5m",
 
450
                        "extended_timeout": "15m",
 
451
                        "interval": "2m",
 
452
                        "checker": "fping -q -- %%(host)s",
 
453
                        "host": "",
 
454
                        "approval_delay": "0s",
 
455
                        "approval_duration": "1s",
 
456
                        "approved_by_default": "True",
 
457
                        "enabled": "True",
 
458
                        }
318
459
    
319
460
    def timeout_milliseconds(self):
320
461
        "Return the 'timeout' attribute in milliseconds"
321
 
        return _timedelta_to_milliseconds(self.timeout)
 
462
        return timedelta_to_milliseconds(self.timeout)
322
463
    
323
464
    def extended_timeout_milliseconds(self):
324
465
        "Return the 'extended_timeout' attribute in milliseconds"
325
 
        return _timedelta_to_milliseconds(self.extended_timeout)
 
466
        return timedelta_to_milliseconds(self.extended_timeout)
326
467
    
327
468
    def interval_milliseconds(self):
328
469
        "Return the 'interval' attribute in milliseconds"
329
 
        return _timedelta_to_milliseconds(self.interval)
 
470
        return timedelta_to_milliseconds(self.interval)
330
471
    
331
472
    def approval_delay_milliseconds(self):
332
 
        return _timedelta_to_milliseconds(self.approval_delay)
333
 
    
334
 
    def __init__(self, name = None, disable_hook=None, config=None):
335
 
        """Note: the 'checker' key in 'config' sets the
336
 
        'checker_command' attribute and *not* the 'checker'
337
 
        attribute."""
 
473
        return timedelta_to_milliseconds(self.approval_delay)
 
474
    
 
475
    @staticmethod
 
476
    def config_parser(config):
 
477
        """Construct a new dict of client settings of this form:
 
478
        { client_name: {setting_name: value, ...}, ...}
 
479
        with exceptions for any special settings as defined above.
 
480
        NOTE: Must be a pure function. Must return the same result
 
481
        value given the same arguments.
 
482
        """
 
483
        settings = {}
 
484
        for client_name in config.sections():
 
485
            section = dict(config.items(client_name))
 
486
            client = settings[client_name] = {}
 
487
            
 
488
            client["host"] = section["host"]
 
489
            # Reformat values from string types to Python types
 
490
            client["approved_by_default"] = config.getboolean(
 
491
                client_name, "approved_by_default")
 
492
            client["enabled"] = config.getboolean(client_name,
 
493
                                                  "enabled")
 
494
            
 
495
            client["fingerprint"] = (section["fingerprint"].upper()
 
496
                                     .replace(" ", ""))
 
497
            if "secret" in section:
 
498
                client["secret"] = section["secret"].decode("base64")
 
499
            elif "secfile" in section:
 
500
                with open(os.path.expanduser(os.path.expandvars
 
501
                                             (section["secfile"])),
 
502
                          "rb") as secfile:
 
503
                    client["secret"] = secfile.read()
 
504
            else:
 
505
                raise TypeError("No secret or secfile for section {0}"
 
506
                                .format(section))
 
507
            client["timeout"] = string_to_delta(section["timeout"])
 
508
            client["extended_timeout"] = string_to_delta(
 
509
                section["extended_timeout"])
 
510
            client["interval"] = string_to_delta(section["interval"])
 
511
            client["approval_delay"] = string_to_delta(
 
512
                section["approval_delay"])
 
513
            client["approval_duration"] = string_to_delta(
 
514
                section["approval_duration"])
 
515
            client["checker_command"] = section["checker"]
 
516
            client["last_approval_request"] = None
 
517
            client["last_checked_ok"] = None
 
518
            client["last_checker_status"] = -2
 
519
        
 
520
        return settings
 
521
    
 
522
    def __init__(self, settings, name = None):
338
523
        self.name = name
339
 
        if config is None:
340
 
            config = {}
 
524
        # adding all client settings
 
525
        for setting, value in settings.iteritems():
 
526
            setattr(self, setting, value)
 
527
        
 
528
        if self.enabled:
 
529
            if not hasattr(self, "last_enabled"):
 
530
                self.last_enabled = datetime.datetime.utcnow()
 
531
            if not hasattr(self, "expires"):
 
532
                self.expires = (datetime.datetime.utcnow()
 
533
                                + self.timeout)
 
534
        else:
 
535
            self.last_enabled = None
 
536
            self.expires = None
 
537
        
341
538
        logger.debug("Creating client %r", self.name)
342
539
        # Uppercase and remove spaces from fingerprint for later
343
540
        # comparison purposes with return value from the fingerprint()
344
541
        # function
345
 
        self.fingerprint = (config["fingerprint"].upper()
346
 
                            .replace(" ", ""))
347
542
        logger.debug("  Fingerprint: %s", self.fingerprint)
348
 
        if "secret" in config:
349
 
            self.secret = config["secret"].decode("base64")
350
 
        elif "secfile" in config:
351
 
            with open(os.path.expanduser(os.path.expandvars
352
 
                                         (config["secfile"])),
353
 
                      "rb") as secfile:
354
 
                self.secret = secfile.read()
355
 
        else:
356
 
            raise TypeError("No secret or secfile for client %s"
357
 
                            % self.name)
358
 
        self.host = config.get("host", "")
359
 
        self.created = datetime.datetime.utcnow()
360
 
        self.enabled = False
361
 
        self.last_approval_request = None
362
 
        self.last_enabled = None
363
 
        self.last_checked_ok = None
364
 
        self.timeout = string_to_delta(config["timeout"])
365
 
        self.extended_timeout = string_to_delta(config
366
 
                                                ["extended_timeout"])
367
 
        self.interval = string_to_delta(config["interval"])
368
 
        self.disable_hook = disable_hook
 
543
        self.created = settings.get("created",
 
544
                                    datetime.datetime.utcnow())
 
545
        
 
546
        # attributes specific for this server instance
369
547
        self.checker = None
370
548
        self.checker_initiator_tag = None
371
549
        self.disable_initiator_tag = None
372
 
        self.expires = None
373
550
        self.checker_callback_tag = None
374
 
        self.checker_command = config["checker"]
375
551
        self.current_checker_command = None
376
 
        self.last_connect = None
377
 
        self._approved = None
378
 
        self.approved_by_default = config.get("approved_by_default",
379
 
                                              True)
 
552
        self.approved = None
380
553
        self.approvals_pending = 0
381
 
        self.approval_delay = string_to_delta(
382
 
            config["approval_delay"])
383
 
        self.approval_duration = string_to_delta(
384
 
            config["approval_duration"])
385
554
        self.changedstate = (multiprocessing_manager
386
555
                             .Condition(multiprocessing_manager
387
556
                                        .Lock()))
 
557
        self.client_structure = [attr for attr in
 
558
                                 self.__dict__.iterkeys()
 
559
                                 if not attr.startswith("_")]
 
560
        self.client_structure.append("client_structure")
 
561
        
 
562
        for name, t in inspect.getmembers(type(self),
 
563
                                          lambda obj:
 
564
                                              isinstance(obj,
 
565
                                                         property)):
 
566
            if not name.startswith("_"):
 
567
                self.client_structure.append(name)
388
568
    
 
569
    # Send notice to process children that client state has changed
389
570
    def send_changedstate(self):
390
 
        self.changedstate.acquire()
391
 
        self.changedstate.notify_all()
392
 
        self.changedstate.release()
 
571
        with self.changedstate:
 
572
            self.changedstate.notify_all()
393
573
    
394
574
    def enable(self):
395
575
        """Start this client's checker and timeout hooks"""
396
576
        if getattr(self, "enabled", False):
397
577
            # Already enabled
398
578
            return
 
579
        self.expires = datetime.datetime.utcnow() + self.timeout
 
580
        self.enabled = True
 
581
        self.last_enabled = datetime.datetime.utcnow()
 
582
        self.init_checker()
399
583
        self.send_changedstate()
 
584
    
 
585
    def disable(self, quiet=True):
 
586
        """Disable this client."""
 
587
        if not getattr(self, "enabled", False):
 
588
            return False
 
589
        if not quiet:
 
590
            logger.info("Disabling client %s", self.name)
 
591
        if getattr(self, "disable_initiator_tag", None) is not None:
 
592
            gobject.source_remove(self.disable_initiator_tag)
 
593
            self.disable_initiator_tag = None
 
594
        self.expires = None
 
595
        if getattr(self, "checker_initiator_tag", None) is not None:
 
596
            gobject.source_remove(self.checker_initiator_tag)
 
597
            self.checker_initiator_tag = None
 
598
        self.stop_checker()
 
599
        self.enabled = False
 
600
        if not quiet:
 
601
            self.send_changedstate()
 
602
        # Do not run this again if called by a gobject.timeout_add
 
603
        return False
 
604
    
 
605
    def __del__(self):
 
606
        self.disable()
 
607
    
 
608
    def init_checker(self):
400
609
        # Schedule a new checker to be started an 'interval' from now,
401
610
        # and every interval from then on.
 
611
        if self.checker_initiator_tag is not None:
 
612
            gobject.source_remove(self.checker_initiator_tag)
402
613
        self.checker_initiator_tag = (gobject.timeout_add
403
614
                                      (self.interval_milliseconds(),
404
615
                                       self.start_checker))
405
616
        # Schedule a disable() when 'timeout' has passed
406
 
        self.expires = datetime.datetime.utcnow() + self.timeout
 
617
        if self.disable_initiator_tag is not None:
 
618
            gobject.source_remove(self.disable_initiator_tag)
407
619
        self.disable_initiator_tag = (gobject.timeout_add
408
620
                                   (self.timeout_milliseconds(),
409
621
                                    self.disable))
410
 
        self.enabled = True
411
 
        self.last_enabled = datetime.datetime.utcnow()
412
622
        # Also start a new checker *right now*.
413
623
        self.start_checker()
414
624
    
415
 
    def disable(self, quiet=True):
416
 
        """Disable this client."""
417
 
        if not getattr(self, "enabled", False):
418
 
            return False
419
 
        if not quiet:
420
 
            self.send_changedstate()
421
 
        if not quiet:
422
 
            logger.info("Disabling client %s", self.name)
423
 
        if getattr(self, "disable_initiator_tag", False):
424
 
            gobject.source_remove(self.disable_initiator_tag)
425
 
            self.disable_initiator_tag = None
426
 
        self.expires = None
427
 
        if getattr(self, "checker_initiator_tag", False):
428
 
            gobject.source_remove(self.checker_initiator_tag)
429
 
            self.checker_initiator_tag = None
430
 
        self.stop_checker()
431
 
        if self.disable_hook:
432
 
            self.disable_hook(self)
433
 
        self.enabled = False
434
 
        # Do not run this again if called by a gobject.timeout_add
435
 
        return False
436
 
    
437
 
    def __del__(self):
438
 
        self.disable_hook = None
439
 
        self.disable()
440
 
    
441
625
    def checker_callback(self, pid, condition, command):
442
626
        """The checker has completed, so take appropriate actions."""
443
627
        self.checker_callback_tag = None
444
628
        self.checker = None
445
629
        if os.WIFEXITED(condition):
446
 
            exitstatus = os.WEXITSTATUS(condition)
447
 
            if exitstatus == 0:
 
630
            self.last_checker_status = os.WEXITSTATUS(condition)
 
631
            if self.last_checker_status == 0:
448
632
                logger.info("Checker for %(name)s succeeded",
449
633
                            vars(self))
450
634
                self.checked_ok()
452
636
                logger.info("Checker for %(name)s failed",
453
637
                            vars(self))
454
638
        else:
 
639
            self.last_checker_status = -1
455
640
            logger.warning("Checker for %(name)s crashed?",
456
641
                           vars(self))
457
642
    
458
 
    def checked_ok(self, timeout=None):
459
 
        """Bump up the timeout for this client.
460
 
        
461
 
        This should only be called when the client has been seen,
462
 
        alive and well.
463
 
        """
 
643
    def checked_ok(self):
 
644
        """Assert that the client has been seen, alive and well."""
 
645
        self.last_checked_ok = datetime.datetime.utcnow()
 
646
        self.last_checker_status = 0
 
647
        self.bump_timeout()
 
648
    
 
649
    def bump_timeout(self, timeout=None):
 
650
        """Bump up the timeout for this client."""
464
651
        if timeout is None:
465
652
            timeout = self.timeout
466
 
        self.last_checked_ok = datetime.datetime.utcnow()
467
653
        if self.disable_initiator_tag is not None:
468
654
            gobject.source_remove(self.disable_initiator_tag)
 
655
            self.disable_initiator_tag = None
469
656
        if getattr(self, "enabled", False):
470
657
            self.disable_initiator_tag = (gobject.timeout_add
471
 
                                          (_timedelta_to_milliseconds
 
658
                                          (timedelta_to_milliseconds
472
659
                                           (timeout), self.disable))
473
660
            self.expires = datetime.datetime.utcnow() + timeout
474
661
    
481
668
        If a checker already exists, leave it running and do
482
669
        nothing."""
483
670
        # The reason for not killing a running checker is that if we
484
 
        # did that, then if a checker (for some reason) started
485
 
        # running slowly and taking more than 'interval' time, the
486
 
        # client would inevitably timeout, since no checker would get
487
 
        # a chance to run to completion.  If we instead leave running
 
671
        # did that, and if a checker (for some reason) started running
 
672
        # slowly and taking more than 'interval' time, then the client
 
673
        # would inevitably timeout, since no checker would get a
 
674
        # chance to run to completion.  If we instead leave running
488
675
        # checkers alone, the checker would have to take more time
489
676
        # than 'timeout' for the client to be disabled, which is as it
490
677
        # should be.
504
691
                                      self.current_checker_command)
505
692
        # Start a new checker if needed
506
693
        if self.checker is None:
 
694
            # Escape attributes for the shell
 
695
            escaped_attrs = dict(
 
696
                (attr, re.escape(unicode(getattr(self, attr))))
 
697
                for attr in
 
698
                self.runtime_expansions)
507
699
            try:
508
 
                # In case checker_command has exactly one % operator
509
 
                command = self.checker_command % self.host
510
 
            except TypeError:
511
 
                # Escape attributes for the shell
512
 
                escaped_attrs = dict(
513
 
                    (attr,
514
 
                     re.escape(unicode(str(getattr(self, attr, "")),
515
 
                                       errors=
516
 
                                       'replace')))
517
 
                    for attr in
518
 
                    self.runtime_expansions)
519
 
                
520
 
                try:
521
 
                    command = self.checker_command % escaped_attrs
522
 
                except TypeError as error:
523
 
                    logger.error('Could not format string "%s":'
524
 
                                 ' %s', self.checker_command, error)
525
 
                    return True # Try again later
 
700
                command = self.checker_command % escaped_attrs
 
701
            except TypeError as error:
 
702
                logger.error('Could not format string "%s"',
 
703
                             self.checker_command, exc_info=error)
 
704
                return True # Try again later
526
705
            self.current_checker_command = command
527
706
            try:
528
707
                logger.info("Starting checker %r for %s",
534
713
                self.checker = subprocess.Popen(command,
535
714
                                                close_fds=True,
536
715
                                                shell=True, cwd="/")
537
 
                self.checker_callback_tag = (gobject.child_watch_add
538
 
                                             (self.checker.pid,
539
 
                                              self.checker_callback,
540
 
                                              data=command))
541
 
                # The checker may have completed before the gobject
542
 
                # watch was added.  Check for this.
543
 
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
544
 
                if pid:
545
 
                    gobject.source_remove(self.checker_callback_tag)
546
 
                    self.checker_callback(pid, status, command)
547
716
            except OSError as error:
548
 
                logger.error("Failed to start subprocess: %s",
549
 
                             error)
 
717
                logger.error("Failed to start subprocess",
 
718
                             exc_info=error)
 
719
            self.checker_callback_tag = (gobject.child_watch_add
 
720
                                         (self.checker.pid,
 
721
                                          self.checker_callback,
 
722
                                          data=command))
 
723
            # The checker may have completed before the gobject
 
724
            # watch was added.  Check for this.
 
725
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
726
            if pid:
 
727
                gobject.source_remove(self.checker_callback_tag)
 
728
                self.checker_callback(pid, status, command)
550
729
        # Re-run this periodically if run by gobject.timeout_add
551
730
        return True
552
731
    
559
738
            return
560
739
        logger.debug("Stopping checker for %(name)s", vars(self))
561
740
        try:
562
 
            os.kill(self.checker.pid, signal.SIGTERM)
 
741
            self.checker.terminate()
563
742
            #time.sleep(0.5)
564
743
            #if self.checker.poll() is None:
565
 
            #    os.kill(self.checker.pid, signal.SIGKILL)
 
744
            #    self.checker.kill()
566
745
        except OSError as error:
567
746
            if error.errno != errno.ESRCH: # No such process
568
747
                raise
585
764
    # "Set" method, so we fail early here:
586
765
    if byte_arrays and signature != "ay":
587
766
        raise ValueError("Byte arrays not supported for non-'ay'"
588
 
                         " signature %r" % signature)
 
767
                         " signature {0!r}".format(signature))
589
768
    def decorator(func):
590
769
        func._dbus_is_property = True
591
770
        func._dbus_interface = dbus_interface
599
778
    return decorator
600
779
 
601
780
 
 
781
def dbus_interface_annotations(dbus_interface):
 
782
    """Decorator for marking functions returning interface annotations
 
783
    
 
784
    Usage:
 
785
    
 
786
    @dbus_interface_annotations("org.example.Interface")
 
787
    def _foo(self):  # Function name does not matter
 
788
        return {"org.freedesktop.DBus.Deprecated": "true",
 
789
                "org.freedesktop.DBus.Property.EmitsChangedSignal":
 
790
                    "false"}
 
791
    """
 
792
    def decorator(func):
 
793
        func._dbus_is_interface = True
 
794
        func._dbus_interface = dbus_interface
 
795
        func._dbus_name = dbus_interface
 
796
        return func
 
797
    return decorator
 
798
 
 
799
 
 
800
def dbus_annotations(annotations):
 
801
    """Decorator to annotate D-Bus methods, signals or properties
 
802
    Usage:
 
803
    
 
804
    @dbus_service_property("org.example.Interface", signature="b",
 
805
                           access="r")
 
806
    @dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
 
807
                        "org.freedesktop.DBus.Property."
 
808
                        "EmitsChangedSignal": "false"})
 
809
    def Property_dbus_property(self):
 
810
        return dbus.Boolean(False)
 
811
    """
 
812
    def decorator(func):
 
813
        func._dbus_annotations = annotations
 
814
        return func
 
815
    return decorator
 
816
 
 
817
 
602
818
class DBusPropertyException(dbus.exceptions.DBusException):
603
819
    """A base class for D-Bus property-related exceptions
604
820
    """
627
843
    """
628
844
    
629
845
    @staticmethod
630
 
    def _is_dbus_property(obj):
631
 
        return getattr(obj, "_dbus_is_property", False)
 
846
    def _is_dbus_thing(thing):
 
847
        """Returns a function testing if an attribute is a D-Bus thing
 
848
        
 
849
        If called like _is_dbus_thing("method") it returns a function
 
850
        suitable for use as predicate to inspect.getmembers().
 
851
        """
 
852
        return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
 
853
                                   False)
632
854
    
633
 
    def _get_all_dbus_properties(self):
 
855
    def _get_all_dbus_things(self, thing):
634
856
        """Returns a generator of (name, attribute) pairs
635
857
        """
636
 
        return ((prop.__get__(self)._dbus_name, prop.__get__(self))
 
858
        return ((getattr(athing.__get__(self), "_dbus_name",
 
859
                         name),
 
860
                 athing.__get__(self))
637
861
                for cls in self.__class__.__mro__
638
 
                for name, prop in
639
 
                inspect.getmembers(cls, self._is_dbus_property))
 
862
                for name, athing in
 
863
                inspect.getmembers(cls,
 
864
                                   self._is_dbus_thing(thing)))
640
865
    
641
866
    def _get_dbus_property(self, interface_name, property_name):
642
867
        """Returns a bound method if one exists which is a D-Bus
644
869
        """
645
870
        for cls in  self.__class__.__mro__:
646
871
            for name, value in (inspect.getmembers
647
 
                                (cls, self._is_dbus_property)):
 
872
                                (cls,
 
873
                                 self._is_dbus_thing("property"))):
648
874
                if (value._dbus_name == property_name
649
875
                    and value._dbus_interface == interface_name):
650
876
                    return value.__get__(self)
679
905
            # signatures other than "ay".
680
906
            if prop._dbus_signature != "ay":
681
907
                raise ValueError
682
 
            value = dbus.ByteArray(''.join(unichr(byte)
683
 
                                           for byte in value))
 
908
            value = dbus.ByteArray(b''.join(chr(byte)
 
909
                                            for byte in value))
684
910
        prop(value)
685
911
    
686
912
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
691
917
        
692
918
        Note: Will not include properties with access="write".
693
919
        """
694
 
        all = {}
695
 
        for name, prop in self._get_all_dbus_properties():
 
920
        properties = {}
 
921
        for name, prop in self._get_all_dbus_things("property"):
696
922
            if (interface_name
697
923
                and interface_name != prop._dbus_interface):
698
924
                # Interface non-empty but did not match
702
928
                continue
703
929
            value = prop()
704
930
            if not hasattr(value, "variant_level"):
705
 
                all[name] = value
 
931
                properties[name] = value
706
932
                continue
707
 
            all[name] = type(value)(value, variant_level=
708
 
                                    value.variant_level+1)
709
 
        return dbus.Dictionary(all, signature="sv")
 
933
            properties[name] = type(value)(value, variant_level=
 
934
                                           value.variant_level+1)
 
935
        return dbus.Dictionary(properties, signature="sv")
710
936
    
711
937
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
712
938
                         out_signature="s",
713
939
                         path_keyword='object_path',
714
940
                         connection_keyword='connection')
715
941
    def Introspect(self, object_path, connection):
716
 
        """Standard D-Bus method, overloaded to insert property tags.
 
942
        """Overloading of standard D-Bus method.
 
943
        
 
944
        Inserts property tags and interface annotation tags.
717
945
        """
718
946
        xmlstring = dbus.service.Object.Introspect(self, object_path,
719
947
                                                   connection)
726
954
                e.setAttribute("access", prop._dbus_access)
727
955
                return e
728
956
            for if_tag in document.getElementsByTagName("interface"):
 
957
                # Add property tags
729
958
                for tag in (make_tag(document, name, prop)
730
959
                            for name, prop
731
 
                            in self._get_all_dbus_properties()
 
960
                            in self._get_all_dbus_things("property")
732
961
                            if prop._dbus_interface
733
962
                            == if_tag.getAttribute("name")):
734
963
                    if_tag.appendChild(tag)
 
964
                # Add annotation tags
 
965
                for typ in ("method", "signal", "property"):
 
966
                    for tag in if_tag.getElementsByTagName(typ):
 
967
                        annots = dict()
 
968
                        for name, prop in (self.
 
969
                                           _get_all_dbus_things(typ)):
 
970
                            if (name == tag.getAttribute("name")
 
971
                                and prop._dbus_interface
 
972
                                == if_tag.getAttribute("name")):
 
973
                                annots.update(getattr
 
974
                                              (prop,
 
975
                                               "_dbus_annotations",
 
976
                                               {}))
 
977
                        for name, value in annots.iteritems():
 
978
                            ann_tag = document.createElement(
 
979
                                "annotation")
 
980
                            ann_tag.setAttribute("name", name)
 
981
                            ann_tag.setAttribute("value", value)
 
982
                            tag.appendChild(ann_tag)
 
983
                # Add interface annotation tags
 
984
                for annotation, value in dict(
 
985
                    itertools.chain.from_iterable(
 
986
                        annotations().iteritems()
 
987
                        for name, annotations in
 
988
                        self._get_all_dbus_things("interface")
 
989
                        if name == if_tag.getAttribute("name")
 
990
                        )).iteritems():
 
991
                    ann_tag = document.createElement("annotation")
 
992
                    ann_tag.setAttribute("name", annotation)
 
993
                    ann_tag.setAttribute("value", value)
 
994
                    if_tag.appendChild(ann_tag)
735
995
                # Add the names to the return values for the
736
996
                # "org.freedesktop.DBus.Properties" methods
737
997
                if (if_tag.getAttribute("name")
752
1012
        except (AttributeError, xml.dom.DOMException,
753
1013
                xml.parsers.expat.ExpatError) as error:
754
1014
            logger.error("Failed to override Introspection method",
755
 
                         error)
 
1015
                         exc_info=error)
756
1016
        return xmlstring
757
1017
 
758
1018
 
763
1023
    return dbus.String(dt.isoformat(),
764
1024
                       variant_level=variant_level)
765
1025
 
766
 
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
767
 
                                  .__metaclass__):
768
 
    """Applied to an empty subclass of a D-Bus object, this metaclass
769
 
    will add additional D-Bus attributes matching a certain pattern.
 
1026
 
 
1027
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
 
1028
    """A class decorator; applied to a subclass of
 
1029
    dbus.service.Object, it will add alternate D-Bus attributes with
 
1030
    interface names according to the "alt_interface_names" mapping.
 
1031
    Usage:
 
1032
    
 
1033
    @alternate_dbus_names({"org.example.Interface":
 
1034
                               "net.example.AlternateInterface"})
 
1035
    class SampleDBusObject(dbus.service.Object):
 
1036
        @dbus.service.method("org.example.Interface")
 
1037
        def SampleDBusMethod():
 
1038
            pass
 
1039
    
 
1040
    The above "SampleDBusMethod" on "SampleDBusObject" will be
 
1041
    reachable via two interfaces: "org.example.Interface" and
 
1042
    "net.example.AlternateInterface", the latter of which will have
 
1043
    its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
 
1044
    "true", unless "deprecate" is passed with a False value.
 
1045
    
 
1046
    This works for methods and signals, and also for D-Bus properties
 
1047
    (from DBusObjectWithProperties) and interfaces (from the
 
1048
    dbus_interface_annotations decorator).
770
1049
    """
771
 
    def __new__(mcs, name, bases, attr):
772
 
        # Go through all the base classes which could have D-Bus
773
 
        # methods, signals, or properties in them
774
 
        for base in (b for b in bases
775
 
                     if issubclass(b, dbus.service.Object)):
776
 
            # Go though all attributes of the base class
777
 
            for attrname, attribute in inspect.getmembers(base):
 
1050
    def wrapper(cls):
 
1051
        for orig_interface_name, alt_interface_name in (
 
1052
            alt_interface_names.iteritems()):
 
1053
            attr = {}
 
1054
            interface_names = set()
 
1055
            # Go though all attributes of the class
 
1056
            for attrname, attribute in inspect.getmembers(cls):
778
1057
                # Ignore non-D-Bus attributes, and D-Bus attributes
779
1058
                # with the wrong interface name
780
1059
                if (not hasattr(attribute, "_dbus_interface")
781
1060
                    or not attribute._dbus_interface
782
 
                    .startswith("se.recompile.Mandos")):
 
1061
                    .startswith(orig_interface_name)):
783
1062
                    continue
784
1063
                # Create an alternate D-Bus interface name based on
785
1064
                # the current name
786
1065
                alt_interface = (attribute._dbus_interface
787
 
                                 .replace("se.recompile.Mandos",
788
 
                                          "se.bsnet.fukt.Mandos"))
 
1066
                                 .replace(orig_interface_name,
 
1067
                                          alt_interface_name))
 
1068
                interface_names.add(alt_interface)
789
1069
                # Is this a D-Bus signal?
790
1070
                if getattr(attribute, "_dbus_is_signal", False):
791
1071
                    # Extract the original non-method function by
806
1086
                                nonmethod_func.func_name,
807
1087
                                nonmethod_func.func_defaults,
808
1088
                                nonmethod_func.func_closure)))
 
1089
                    # Copy annotations, if any
 
1090
                    try:
 
1091
                        new_function._dbus_annotations = (
 
1092
                            dict(attribute._dbus_annotations))
 
1093
                    except AttributeError:
 
1094
                        pass
809
1095
                    # Define a creator of a function to call both the
810
 
                    # old and new functions, so both the old and new
811
 
                    # signals gets sent when the function is called
 
1096
                    # original and alternate functions, so both the
 
1097
                    # original and alternate signals gets sent when
 
1098
                    # the function is called
812
1099
                    def fixscope(func1, func2):
813
1100
                        """This function is a scope container to pass
814
1101
                        func1 and func2 to the "call_both" function
821
1108
                        return call_both
822
1109
                    # Create the "call_both" function and add it to
823
1110
                    # the class
824
 
                    attr[attrname] = fixscope(attribute,
825
 
                                              new_function)
 
1111
                    attr[attrname] = fixscope(attribute, new_function)
826
1112
                # Is this a D-Bus method?
827
1113
                elif getattr(attribute, "_dbus_is_method", False):
828
1114
                    # Create a new, but exactly alike, function
839
1125
                                        attribute.func_name,
840
1126
                                        attribute.func_defaults,
841
1127
                                        attribute.func_closure)))
 
1128
                    # Copy annotations, if any
 
1129
                    try:
 
1130
                        attr[attrname]._dbus_annotations = (
 
1131
                            dict(attribute._dbus_annotations))
 
1132
                    except AttributeError:
 
1133
                        pass
842
1134
                # Is this a D-Bus property?
843
1135
                elif getattr(attribute, "_dbus_is_property", False):
844
1136
                    # Create a new, but exactly alike, function
858
1150
                                        attribute.func_name,
859
1151
                                        attribute.func_defaults,
860
1152
                                        attribute.func_closure)))
861
 
        return type.__new__(mcs, name, bases, attr)
862
 
 
 
1153
                    # Copy annotations, if any
 
1154
                    try:
 
1155
                        attr[attrname]._dbus_annotations = (
 
1156
                            dict(attribute._dbus_annotations))
 
1157
                    except AttributeError:
 
1158
                        pass
 
1159
                # Is this a D-Bus interface?
 
1160
                elif getattr(attribute, "_dbus_is_interface", False):
 
1161
                    # Create a new, but exactly alike, function
 
1162
                    # object.  Decorate it to be a new D-Bus interface
 
1163
                    # with the alternate D-Bus interface name.  Add it
 
1164
                    # to the class.
 
1165
                    attr[attrname] = (dbus_interface_annotations
 
1166
                                      (alt_interface)
 
1167
                                      (types.FunctionType
 
1168
                                       (attribute.func_code,
 
1169
                                        attribute.func_globals,
 
1170
                                        attribute.func_name,
 
1171
                                        attribute.func_defaults,
 
1172
                                        attribute.func_closure)))
 
1173
            if deprecate:
 
1174
                # Deprecate all alternate interfaces
 
1175
                iname="_AlternateDBusNames_interface_annotation{0}"
 
1176
                for interface_name in interface_names:
 
1177
                    @dbus_interface_annotations(interface_name)
 
1178
                    def func(self):
 
1179
                        return { "org.freedesktop.DBus.Deprecated":
 
1180
                                     "true" }
 
1181
                    # Find an unused name
 
1182
                    for aname in (iname.format(i)
 
1183
                                  for i in itertools.count()):
 
1184
                        if aname not in attr:
 
1185
                            attr[aname] = func
 
1186
                            break
 
1187
            if interface_names:
 
1188
                # Replace the class with a new subclass of it with
 
1189
                # methods, signals, etc. as created above.
 
1190
                cls = type(b"{0}Alternate".format(cls.__name__),
 
1191
                           (cls,), attr)
 
1192
        return cls
 
1193
    return wrapper
 
1194
 
 
1195
 
 
1196
@alternate_dbus_interfaces({"se.recompile.Mandos":
 
1197
                                "se.bsnet.fukt.Mandos"})
863
1198
class ClientDBus(Client, DBusObjectWithProperties):
864
1199
    """A Client class using D-Bus
865
1200
    
874
1209
    # dbus.service.Object doesn't use super(), so we can't either.
875
1210
    
876
1211
    def __init__(self, bus = None, *args, **kwargs):
877
 
        self._approvals_pending = 0
878
1212
        self.bus = bus
879
1213
        Client.__init__(self, *args, **kwargs)
880
1214
        # Only now, when this client is initialized, can it show up on
886
1220
                                 ("/clients/" + client_object_name))
887
1221
        DBusObjectWithProperties.__init__(self, self.bus,
888
1222
                                          self.dbus_object_path)
889
 
        
 
1223
    
890
1224
    def notifychangeproperty(transform_func,
891
1225
                             dbus_name, type_func=lambda x: x,
892
1226
                             variant_level=1):
893
1227
        """ Modify a variable so that it's a property which announces
894
1228
        its changes to DBus.
895
 
 
 
1229
        
896
1230
        transform_fun: Function that takes a value and a variant_level
897
1231
                       and transforms it to a D-Bus type.
898
1232
        dbus_name: D-Bus name of the variable
915
1249
        
916
1250
        return property(lambda self: getattr(self, attrname), setter)
917
1251
    
918
 
    
919
1252
    expires = notifychangeproperty(datetime_to_dbus, "Expires")
920
1253
    approvals_pending = notifychangeproperty(dbus.Boolean,
921
1254
                                             "ApprovalPending",
928
1261
                                       checker is not None)
929
1262
    last_checked_ok = notifychangeproperty(datetime_to_dbus,
930
1263
                                           "LastCheckedOK")
 
1264
    last_checker_status = notifychangeproperty(dbus.Int16,
 
1265
                                               "LastCheckerStatus")
931
1266
    last_approval_request = notifychangeproperty(
932
1267
        datetime_to_dbus, "LastApprovalRequest")
933
1268
    approved_by_default = notifychangeproperty(dbus.Boolean,
934
1269
                                               "ApprovedByDefault")
935
 
    approval_delay = notifychangeproperty(dbus.UInt16,
 
1270
    approval_delay = notifychangeproperty(dbus.UInt64,
936
1271
                                          "ApprovalDelay",
937
1272
                                          type_func =
938
 
                                          _timedelta_to_milliseconds)
 
1273
                                          timedelta_to_milliseconds)
939
1274
    approval_duration = notifychangeproperty(
940
 
        dbus.UInt16, "ApprovalDuration",
941
 
        type_func = _timedelta_to_milliseconds)
 
1275
        dbus.UInt64, "ApprovalDuration",
 
1276
        type_func = timedelta_to_milliseconds)
942
1277
    host = notifychangeproperty(dbus.String, "Host")
943
 
    timeout = notifychangeproperty(dbus.UInt16, "Timeout",
 
1278
    timeout = notifychangeproperty(dbus.UInt64, "Timeout",
944
1279
                                   type_func =
945
 
                                   _timedelta_to_milliseconds)
 
1280
                                   timedelta_to_milliseconds)
946
1281
    extended_timeout = notifychangeproperty(
947
 
        dbus.UInt16, "ExtendedTimeout",
948
 
        type_func = _timedelta_to_milliseconds)
949
 
    interval = notifychangeproperty(dbus.UInt16,
 
1282
        dbus.UInt64, "ExtendedTimeout",
 
1283
        type_func = timedelta_to_milliseconds)
 
1284
    interval = notifychangeproperty(dbus.UInt64,
950
1285
                                    "Interval",
951
1286
                                    type_func =
952
 
                                    _timedelta_to_milliseconds)
 
1287
                                    timedelta_to_milliseconds)
953
1288
    checker_command = notifychangeproperty(dbus.String, "Checker")
954
1289
    
955
1290
    del notifychangeproperty
997
1332
        return r
998
1333
    
999
1334
    def _reset_approved(self):
1000
 
        self._approved = None
 
1335
        self.approved = None
1001
1336
        return False
1002
1337
    
1003
1338
    def approve(self, value=True):
1004
 
        self.send_changedstate()
1005
 
        self._approved = value
1006
 
        gobject.timeout_add(_timedelta_to_milliseconds
 
1339
        self.approved = value
 
1340
        gobject.timeout_add(timedelta_to_milliseconds
1007
1341
                            (self.approval_duration),
1008
1342
                            self._reset_approved)
1009
 
    
 
1343
        self.send_changedstate()
1010
1344
    
1011
1345
    ## D-Bus methods, signals & properties
1012
1346
    _interface = "se.recompile.Mandos.Client"
1013
1347
    
 
1348
    ## Interfaces
 
1349
    
 
1350
    @dbus_interface_annotations(_interface)
 
1351
    def _foo(self):
 
1352
        return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
 
1353
                     "false"}
 
1354
    
1014
1355
    ## Signals
1015
1356
    
1016
1357
    # CheckerCompleted - signal
1115
1456
                           access="readwrite")
1116
1457
    def ApprovalDuration_dbus_property(self, value=None):
1117
1458
        if value is None:       # get
1118
 
            return dbus.UInt64(_timedelta_to_milliseconds(
 
1459
            return dbus.UInt64(timedelta_to_milliseconds(
1119
1460
                    self.approval_duration))
1120
1461
        self.approval_duration = datetime.timedelta(0, 0, 0, value)
1121
1462
    
1135
1476
    def Host_dbus_property(self, value=None):
1136
1477
        if value is None:       # get
1137
1478
            return dbus.String(self.host)
1138
 
        self.host = value
 
1479
        self.host = unicode(value)
1139
1480
    
1140
1481
    # Created - property
1141
1482
    @dbus_service_property(_interface, signature="s", access="read")
1142
1483
    def Created_dbus_property(self):
1143
 
        return dbus.String(datetime_to_dbus(self.created))
 
1484
        return datetime_to_dbus(self.created)
1144
1485
    
1145
1486
    # LastEnabled - property
1146
1487
    @dbus_service_property(_interface, signature="s", access="read")
1167
1508
            return
1168
1509
        return datetime_to_dbus(self.last_checked_ok)
1169
1510
    
 
1511
    # LastCheckerStatus - property
 
1512
    @dbus_service_property(_interface, signature="n",
 
1513
                           access="read")
 
1514
    def LastCheckerStatus_dbus_property(self):
 
1515
        return dbus.Int16(self.last_checker_status)
 
1516
    
1170
1517
    # Expires - property
1171
1518
    @dbus_service_property(_interface, signature="s", access="read")
1172
1519
    def Expires_dbus_property(self):
1183
1530
    def Timeout_dbus_property(self, value=None):
1184
1531
        if value is None:       # get
1185
1532
            return dbus.UInt64(self.timeout_milliseconds())
 
1533
        old_timeout = self.timeout
1186
1534
        self.timeout = datetime.timedelta(0, 0, 0, value)
1187
 
        if getattr(self, "disable_initiator_tag", None) is None:
1188
 
            return
1189
 
        # Reschedule timeout
1190
 
        gobject.source_remove(self.disable_initiator_tag)
1191
 
        self.disable_initiator_tag = None
1192
 
        self.expires = None
1193
 
        time_to_die = _timedelta_to_milliseconds((self
1194
 
                                                  .last_checked_ok
1195
 
                                                  + self.timeout)
1196
 
                                                 - datetime.datetime
1197
 
                                                 .utcnow())
1198
 
        if time_to_die <= 0:
1199
 
            # The timeout has passed
1200
 
            self.disable()
1201
 
        else:
1202
 
            self.expires = (datetime.datetime.utcnow()
1203
 
                            + datetime.timedelta(milliseconds =
1204
 
                                                 time_to_die))
1205
 
            self.disable_initiator_tag = (gobject.timeout_add
1206
 
                                          (time_to_die, self.disable))
 
1535
        # Reschedule disabling
 
1536
        if self.enabled:
 
1537
            now = datetime.datetime.utcnow()
 
1538
            self.expires += self.timeout - old_timeout
 
1539
            if self.expires <= now:
 
1540
                # The timeout has passed
 
1541
                self.disable()
 
1542
            else:
 
1543
                if (getattr(self, "disable_initiator_tag", None)
 
1544
                    is None):
 
1545
                    return
 
1546
                gobject.source_remove(self.disable_initiator_tag)
 
1547
                self.disable_initiator_tag = (
 
1548
                    gobject.timeout_add(
 
1549
                        timedelta_to_milliseconds(self.expires - now),
 
1550
                        self.disable))
1207
1551
    
1208
1552
    # ExtendedTimeout - property
1209
1553
    @dbus_service_property(_interface, signature="t",
1222
1566
        self.interval = datetime.timedelta(0, 0, 0, value)
1223
1567
        if getattr(self, "checker_initiator_tag", None) is None:
1224
1568
            return
1225
 
        # Reschedule checker run
1226
 
        gobject.source_remove(self.checker_initiator_tag)
1227
 
        self.checker_initiator_tag = (gobject.timeout_add
1228
 
                                      (value, self.start_checker))
1229
 
        self.start_checker()    # Start one now, too
 
1569
        if self.enabled:
 
1570
            # Reschedule checker run
 
1571
            gobject.source_remove(self.checker_initiator_tag)
 
1572
            self.checker_initiator_tag = (gobject.timeout_add
 
1573
                                          (value, self.start_checker))
 
1574
            self.start_checker()    # Start one now, too
1230
1575
    
1231
1576
    # Checker - property
1232
1577
    @dbus_service_property(_interface, signature="s",
1234
1579
    def Checker_dbus_property(self, value=None):
1235
1580
        if value is None:       # get
1236
1581
            return dbus.String(self.checker_command)
1237
 
        self.checker_command = value
 
1582
        self.checker_command = unicode(value)
1238
1583
    
1239
1584
    # CheckerRunning - property
1240
1585
    @dbus_service_property(_interface, signature="b",
1269
1614
            raise KeyError()
1270
1615
    
1271
1616
    def __getattribute__(self, name):
1272
 
        if(name == '_pipe'):
 
1617
        if name == '_pipe':
1273
1618
            return super(ProxyClient, self).__getattribute__(name)
1274
1619
        self._pipe.send(('getattr', name))
1275
1620
        data = self._pipe.recv()
1282
1627
            return func
1283
1628
    
1284
1629
    def __setattr__(self, name, value):
1285
 
        if(name == '_pipe'):
 
1630
        if name == '_pipe':
1286
1631
            return super(ProxyClient, self).__setattr__(name, value)
1287
1632
        self._pipe.send(('setattr', name, value))
1288
1633
 
1289
 
class ClientDBusTransitional(ClientDBus):
1290
 
    __metaclass__ = AlternateDBusNamesMetaclass
1291
1634
 
1292
1635
class ClientHandler(socketserver.BaseRequestHandler, object):
1293
1636
    """A class to handle client connections.
1376
1719
                            client.Rejected("Disabled")
1377
1720
                        return
1378
1721
                    
1379
 
                    if client._approved or not client.approval_delay:
 
1722
                    if client.approved or not client.approval_delay:
1380
1723
                        #We are approved or approval is disabled
1381
1724
                        break
1382
 
                    elif client._approved is None:
 
1725
                    elif client.approved is None:
1383
1726
                        logger.info("Client %s needs approval",
1384
1727
                                    client.name)
1385
1728
                        if self.server.use_dbus:
1398
1741
                    #wait until timeout or approved
1399
1742
                    time = datetime.datetime.now()
1400
1743
                    client.changedstate.acquire()
1401
 
                    (client.changedstate.wait
1402
 
                     (float(client._timedelta_to_milliseconds(delay)
1403
 
                            / 1000)))
 
1744
                    client.changedstate.wait(
 
1745
                        float(timedelta_to_milliseconds(delay)
 
1746
                              / 1000))
1404
1747
                    client.changedstate.release()
1405
1748
                    time2 = datetime.datetime.now()
1406
1749
                    if (time2 - time) >= delay:
1422
1765
                    try:
1423
1766
                        sent = session.send(client.secret[sent_size:])
1424
1767
                    except gnutls.errors.GNUTLSError as error:
1425
 
                        logger.warning("gnutls send failed")
 
1768
                        logger.warning("gnutls send failed",
 
1769
                                       exc_info=error)
1426
1770
                        return
1427
1771
                    logger.debug("Sent: %d, remaining: %d",
1428
1772
                                 sent, len(client.secret)
1431
1775
                
1432
1776
                logger.info("Sending secret to %s", client.name)
1433
1777
                # bump the timeout using extended_timeout
1434
 
                client.checked_ok(client.extended_timeout)
 
1778
                client.bump_timeout(client.extended_timeout)
1435
1779
                if self.server.use_dbus:
1436
1780
                    # Emit D-Bus signal
1437
1781
                    client.GotSecret()
1442
1786
                try:
1443
1787
                    session.bye()
1444
1788
                except gnutls.errors.GNUTLSError as error:
1445
 
                    logger.warning("GnuTLS bye failed")
 
1789
                    logger.warning("GnuTLS bye failed",
 
1790
                                   exc_info=error)
1446
1791
    
1447
1792
    @staticmethod
1448
1793
    def peer_certificate(session):
1504
1849
        # Convert the buffer to a Python bytestring
1505
1850
        fpr = ctypes.string_at(buf, buf_len.value)
1506
1851
        # Convert the bytestring to hexadecimal notation
1507
 
        hex_fpr = ''.join("%02X" % ord(char) for char in fpr)
 
1852
        hex_fpr = binascii.hexlify(fpr).upper()
1508
1853
        return hex_fpr
1509
1854
 
1510
1855
 
1513
1858
    def sub_process_main(self, request, address):
1514
1859
        try:
1515
1860
            self.finish_request(request, address)
1516
 
        except:
 
1861
        except Exception:
1517
1862
            self.handle_error(request, address)
1518
1863
        self.close_request(request)
1519
1864
    
1520
1865
    def process_request(self, request, address):
1521
1866
        """Start a new process to process the request."""
1522
1867
        proc = multiprocessing.Process(target = self.sub_process_main,
1523
 
                                       args = (request,
1524
 
                                               address))
 
1868
                                       args = (request, address))
1525
1869
        proc.start()
1526
1870
        return proc
1527
1871
 
1577
1921
                                           str(self.interface
1578
1922
                                               + '\0'))
1579
1923
                except socket.error as error:
1580
 
                    if error[0] == errno.EPERM:
 
1924
                    if error.errno == errno.EPERM:
1581
1925
                        logger.error("No permission to"
1582
1926
                                     " bind to interface %s",
1583
1927
                                     self.interface)
1584
 
                    elif error[0] == errno.ENOPROTOOPT:
 
1928
                    elif error.errno == errno.ENOPROTOOPT:
1585
1929
                        logger.error("SO_BINDTODEVICE not available;"
1586
1930
                                     " cannot bind to interface %s",
1587
1931
                                     self.interface)
 
1932
                    elif error.errno == errno.ENODEV:
 
1933
                        logger.error("Interface %s does not"
 
1934
                                     " exist, cannot bind",
 
1935
                                     self.interface)
1588
1936
                    else:
1589
1937
                        raise
1590
1938
        # Only bind(2) the socket if we really need to.
1624
1972
        self.enabled = False
1625
1973
        self.clients = clients
1626
1974
        if self.clients is None:
1627
 
            self.clients = set()
 
1975
            self.clients = {}
1628
1976
        self.use_dbus = use_dbus
1629
1977
        self.gnutls_priority = gnutls_priority
1630
1978
        IPv6_TCPServer.__init__(self, server_address,
1649
1997
    
1650
1998
    def handle_ipc(self, source, condition, parent_pipe=None,
1651
1999
                   proc = None, client_object=None):
1652
 
        condition_names = {
1653
 
            gobject.IO_IN: "IN",   # There is data to read.
1654
 
            gobject.IO_OUT: "OUT", # Data can be written (without
1655
 
                                    # blocking).
1656
 
            gobject.IO_PRI: "PRI", # There is urgent data to read.
1657
 
            gobject.IO_ERR: "ERR", # Error condition.
1658
 
            gobject.IO_HUP: "HUP"  # Hung up (the connection has been
1659
 
                                    # broken, usually for pipes and
1660
 
                                    # sockets).
1661
 
            }
1662
 
        conditions_string = ' | '.join(name
1663
 
                                       for cond, name in
1664
 
                                       condition_names.iteritems()
1665
 
                                       if cond & condition)
1666
2000
        # error, or the other end of multiprocessing.Pipe has closed
1667
 
        if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
 
2001
        if condition & (gobject.IO_ERR | gobject.IO_HUP):
1668
2002
            # Wait for other process to exit
1669
2003
            proc.join()
1670
2004
            return False
1677
2011
            fpr = request[1]
1678
2012
            address = request[2]
1679
2013
            
1680
 
            for c in self.clients:
 
2014
            for c in self.clients.itervalues():
1681
2015
                if c.fingerprint == fpr:
1682
2016
                    client = c
1683
2017
                    break
1760
2094
            elif suffix == "w":
1761
2095
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1762
2096
            else:
1763
 
                raise ValueError("Unknown suffix %r" % suffix)
 
2097
                raise ValueError("Unknown suffix {0!r}"
 
2098
                                 .format(suffix))
1764
2099
        except (ValueError, IndexError) as e:
1765
2100
            raise ValueError(*(e.args))
1766
2101
        timevalue += delta
1767
2102
    return timevalue
1768
2103
 
1769
2104
 
1770
 
def if_nametoindex(interface):
1771
 
    """Call the C function if_nametoindex(), or equivalent
1772
 
    
1773
 
    Note: This function cannot accept a unicode string."""
1774
 
    global if_nametoindex
1775
 
    try:
1776
 
        if_nametoindex = (ctypes.cdll.LoadLibrary
1777
 
                          (ctypes.util.find_library("c"))
1778
 
                          .if_nametoindex)
1779
 
    except (OSError, AttributeError):
1780
 
        logger.warning("Doing if_nametoindex the hard way")
1781
 
        def if_nametoindex(interface):
1782
 
            "Get an interface index the hard way, i.e. using fcntl()"
1783
 
            SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
1784
 
            with contextlib.closing(socket.socket()) as s:
1785
 
                ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1786
 
                                    struct.pack(str("16s16x"),
1787
 
                                                interface))
1788
 
            interface_index = struct.unpack(str("I"),
1789
 
                                            ifreq[16:20])[0]
1790
 
            return interface_index
1791
 
    return if_nametoindex(interface)
1792
 
 
1793
 
 
1794
2105
def daemon(nochdir = False, noclose = False):
1795
2106
    """See daemon(3).  Standard BSD Unix function.
1796
2107
    
1804
2115
        sys.exit()
1805
2116
    if not noclose:
1806
2117
        # Close all standard open file descriptors
1807
 
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
 
2118
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1808
2119
        if not stat.S_ISCHR(os.fstat(null).st_mode):
1809
2120
            raise OSError(errno.ENODEV,
1810
 
                          "%s not a character device"
1811
 
                          % os.path.devnull)
 
2121
                          "{0} not a character device"
 
2122
                          .format(os.devnull))
1812
2123
        os.dup2(null, sys.stdin.fileno())
1813
2124
        os.dup2(null, sys.stdout.fileno())
1814
2125
        os.dup2(null, sys.stderr.fileno())
1823
2134
    
1824
2135
    parser = argparse.ArgumentParser()
1825
2136
    parser.add_argument("-v", "--version", action="version",
1826
 
                        version = "%%(prog)s %s" % version,
 
2137
                        version = "%(prog)s {0}".format(version),
1827
2138
                        help="show version number and exit")
1828
2139
    parser.add_argument("-i", "--interface", metavar="IF",
1829
2140
                        help="Bind to interface IF")
1851
2162
                        " system bus interface")
1852
2163
    parser.add_argument("--no-ipv6", action="store_false",
1853
2164
                        dest="use_ipv6", help="Do not use IPv6")
 
2165
    parser.add_argument("--no-restore", action="store_false",
 
2166
                        dest="restore", help="Do not restore stored"
 
2167
                        " state")
 
2168
    parser.add_argument("--statedir", metavar="DIR",
 
2169
                        help="Directory to save/restore state in")
 
2170
    
1854
2171
    options = parser.parse_args()
1855
2172
    
1856
2173
    if options.check:
1869
2186
                        "use_dbus": "True",
1870
2187
                        "use_ipv6": "True",
1871
2188
                        "debuglevel": "",
 
2189
                        "restore": "True",
 
2190
                        "statedir": "/var/lib/mandos"
1872
2191
                        }
1873
2192
    
1874
2193
    # Parse config file for server-global settings
1891
2210
    # options, if set.
1892
2211
    for option in ("interface", "address", "port", "debug",
1893
2212
                   "priority", "servicename", "configdir",
1894
 
                   "use_dbus", "use_ipv6", "debuglevel"):
 
2213
                   "use_dbus", "use_ipv6", "debuglevel", "restore",
 
2214
                   "statedir"):
1895
2215
        value = getattr(options, option)
1896
2216
        if value is not None:
1897
2217
            server_settings[option] = value
1909
2229
    debuglevel = server_settings["debuglevel"]
1910
2230
    use_dbus = server_settings["use_dbus"]
1911
2231
    use_ipv6 = server_settings["use_ipv6"]
 
2232
    stored_state_path = os.path.join(server_settings["statedir"],
 
2233
                                     stored_state_file)
 
2234
    
 
2235
    if debug:
 
2236
        initlogger(debug, logging.DEBUG)
 
2237
    else:
 
2238
        if not debuglevel:
 
2239
            initlogger(debug)
 
2240
        else:
 
2241
            level = getattr(logging, debuglevel.upper())
 
2242
            initlogger(debug, level)
1912
2243
    
1913
2244
    if server_settings["servicename"] != "Mandos":
1914
2245
        syslogger.setFormatter(logging.Formatter
1915
 
                               ('Mandos (%s) [%%(process)d]:'
1916
 
                                ' %%(levelname)s: %%(message)s'
1917
 
                                % server_settings["servicename"]))
 
2246
                               ('Mandos ({0}) [%(process)d]:'
 
2247
                                ' %(levelname)s: %(message)s'
 
2248
                                .format(server_settings
 
2249
                                        ["servicename"])))
1918
2250
    
1919
2251
    # Parse config file with clients
1920
 
    client_defaults = { "timeout": "5m",
1921
 
                        "extended_timeout": "15m",
1922
 
                        "interval": "2m",
1923
 
                        "checker": "fping -q -- %%(host)s",
1924
 
                        "host": "",
1925
 
                        "approval_delay": "0s",
1926
 
                        "approval_duration": "1s",
1927
 
                        }
1928
 
    client_config = configparser.SafeConfigParser(client_defaults)
 
2252
    client_config = configparser.SafeConfigParser(Client
 
2253
                                                  .client_defaults)
1929
2254
    client_config.read(os.path.join(server_settings["configdir"],
1930
2255
                                    "clients.conf"))
1931
2256
    
1945
2270
        pidfilename = "/var/run/mandos.pid"
1946
2271
        try:
1947
2272
            pidfile = open(pidfilename, "w")
1948
 
        except IOError:
1949
 
            logger.error("Could not open file %r", pidfilename)
 
2273
        except IOError as e:
 
2274
            logger.error("Could not open file %r", pidfilename,
 
2275
                         exc_info=e)
1950
2276
    
1951
 
    try:
1952
 
        uid = pwd.getpwnam("_mandos").pw_uid
1953
 
        gid = pwd.getpwnam("_mandos").pw_gid
1954
 
    except KeyError:
 
2277
    for name in ("_mandos", "mandos", "nobody"):
1955
2278
        try:
1956
 
            uid = pwd.getpwnam("mandos").pw_uid
1957
 
            gid = pwd.getpwnam("mandos").pw_gid
 
2279
            uid = pwd.getpwnam(name).pw_uid
 
2280
            gid = pwd.getpwnam(name).pw_gid
 
2281
            break
1958
2282
        except KeyError:
1959
 
            try:
1960
 
                uid = pwd.getpwnam("nobody").pw_uid
1961
 
                gid = pwd.getpwnam("nobody").pw_gid
1962
 
            except KeyError:
1963
 
                uid = 65534
1964
 
                gid = 65534
 
2283
            continue
 
2284
    else:
 
2285
        uid = 65534
 
2286
        gid = 65534
1965
2287
    try:
1966
2288
        os.setgid(gid)
1967
2289
        os.setuid(uid)
1968
2290
    except OSError as error:
1969
 
        if error[0] != errno.EPERM:
 
2291
        if error.errno != errno.EPERM:
1970
2292
            raise error
1971
2293
    
1972
 
    if not debug and not debuglevel:
1973
 
        syslogger.setLevel(logging.WARNING)
1974
 
        console.setLevel(logging.WARNING)
1975
 
    if debuglevel:
1976
 
        level = getattr(logging, debuglevel.upper())
1977
 
        syslogger.setLevel(level)
1978
 
        console.setLevel(level)
1979
 
    
1980
2294
    if debug:
1981
2295
        # Enable all possible GnuTLS debugging
1982
2296
        
1992
2306
         .gnutls_global_set_log_function(debug_gnutls))
1993
2307
        
1994
2308
        # Redirect stdin so all checkers get /dev/null
1995
 
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
 
2309
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1996
2310
        os.dup2(null, sys.stdin.fileno())
1997
2311
        if null > 2:
1998
2312
            os.close(null)
1999
 
    else:
2000
 
        # No console logging
2001
 
        logger.removeHandler(console)
2002
2313
    
2003
2314
    # Need to fork before connecting to D-Bus
2004
2315
    if not debug:
2005
2316
        # Close all input and output, do double fork, etc.
2006
2317
        daemon()
2007
2318
    
 
2319
    gobject.threads_init()
 
2320
    
2008
2321
    global main_loop
2009
2322
    # From the Avahi example code
2010
 
    DBusGMainLoop(set_as_default=True )
 
2323
    DBusGMainLoop(set_as_default=True)
2011
2324
    main_loop = gobject.MainLoop()
2012
2325
    bus = dbus.SystemBus()
2013
2326
    # End of Avahi example code
2019
2332
                            ("se.bsnet.fukt.Mandos", bus,
2020
2333
                             do_not_queue=True))
2021
2334
        except dbus.exceptions.NameExistsException as e:
2022
 
            logger.error(unicode(e) + ", disabling D-Bus")
 
2335
            logger.error("Disabling D-Bus:", exc_info=e)
2023
2336
            use_dbus = False
2024
2337
            server_settings["use_dbus"] = False
2025
2338
            tcp_server.use_dbus = False
2026
2339
    protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2027
 
    service = AvahiService(name = server_settings["servicename"],
2028
 
                           servicetype = "_mandos._tcp",
2029
 
                           protocol = protocol, bus = bus)
 
2340
    service = AvahiServiceToSyslog(name =
 
2341
                                   server_settings["servicename"],
 
2342
                                   servicetype = "_mandos._tcp",
 
2343
                                   protocol = protocol, bus = bus)
2030
2344
    if server_settings["interface"]:
2031
2345
        service.interface = (if_nametoindex
2032
2346
                             (str(server_settings["interface"])))
2036
2350
    
2037
2351
    client_class = Client
2038
2352
    if use_dbus:
2039
 
        client_class = functools.partial(ClientDBusTransitional,
2040
 
                                         bus = bus)
2041
 
    def client_config_items(config, section):
2042
 
        special_settings = {
2043
 
            "approved_by_default":
2044
 
                lambda: config.getboolean(section,
2045
 
                                          "approved_by_default"),
2046
 
            }
2047
 
        for name, value in config.items(section):
 
2353
        client_class = functools.partial(ClientDBus, bus = bus)
 
2354
    
 
2355
    client_settings = Client.config_parser(client_config)
 
2356
    old_client_settings = {}
 
2357
    clients_data = {}
 
2358
    
 
2359
    # Get client data and settings from last running state.
 
2360
    if server_settings["restore"]:
 
2361
        try:
 
2362
            with open(stored_state_path, "rb") as stored_state:
 
2363
                clients_data, old_client_settings = (pickle.load
 
2364
                                                     (stored_state))
 
2365
            os.remove(stored_state_path)
 
2366
        except IOError as e:
 
2367
            if e.errno == errno.ENOENT:
 
2368
                logger.warning("Could not load persistent state: {0}"
 
2369
                                .format(os.strerror(e.errno)))
 
2370
            else:
 
2371
                logger.critical("Could not load persistent state:",
 
2372
                                exc_info=e)
 
2373
                raise
 
2374
        except EOFError as e:
 
2375
            logger.warning("Could not load persistent state: "
 
2376
                           "EOFError:", exc_info=e)
 
2377
    
 
2378
    with PGPEngine() as pgp:
 
2379
        for client_name, client in clients_data.iteritems():
 
2380
            # Decide which value to use after restoring saved state.
 
2381
            # We have three different values: Old config file,
 
2382
            # new config file, and saved state.
 
2383
            # New config value takes precedence if it differs from old
 
2384
            # config value, otherwise use saved state.
 
2385
            for name, value in client_settings[client_name].items():
 
2386
                try:
 
2387
                    # For each value in new config, check if it
 
2388
                    # differs from the old config value (Except for
 
2389
                    # the "secret" attribute)
 
2390
                    if (name != "secret" and
 
2391
                        value != old_client_settings[client_name]
 
2392
                        [name]):
 
2393
                        client[name] = value
 
2394
                except KeyError:
 
2395
                    pass
 
2396
            
 
2397
            # Clients who has passed its expire date can still be
 
2398
            # enabled if its last checker was successful.  Clients
 
2399
            # whose checker succeeded before we stored its state is
 
2400
            # assumed to have successfully run all checkers during
 
2401
            # downtime.
 
2402
            if client["enabled"]:
 
2403
                if datetime.datetime.utcnow() >= client["expires"]:
 
2404
                    if not client["last_checked_ok"]:
 
2405
                        logger.warning(
 
2406
                            "disabling client {0} - Client never "
 
2407
                            "performed a successful checker"
 
2408
                            .format(client_name))
 
2409
                        client["enabled"] = False
 
2410
                    elif client["last_checker_status"] != 0:
 
2411
                        logger.warning(
 
2412
                            "disabling client {0} - Client "
 
2413
                            "last checker failed with error code {1}"
 
2414
                            .format(client_name,
 
2415
                                    client["last_checker_status"]))
 
2416
                        client["enabled"] = False
 
2417
                    else:
 
2418
                        client["expires"] = (datetime.datetime
 
2419
                                             .utcnow()
 
2420
                                             + client["timeout"])
 
2421
                        logger.debug("Last checker succeeded,"
 
2422
                                     " keeping {0} enabled"
 
2423
                                     .format(client_name))
2048
2424
            try:
2049
 
                yield (name, special_settings[name]())
2050
 
            except KeyError:
2051
 
                yield (name, value)
2052
 
    
2053
 
    tcp_server.clients.update(set(
2054
 
            client_class(name = section,
2055
 
                         config= dict(client_config_items(
2056
 
                        client_config, section)))
2057
 
            for section in client_config.sections()))
 
2425
                client["secret"] = (
 
2426
                    pgp.decrypt(client["encrypted_secret"],
 
2427
                                client_settings[client_name]
 
2428
                                ["secret"]))
 
2429
            except PGPError:
 
2430
                # If decryption fails, we use secret from new settings
 
2431
                logger.debug("Failed to decrypt {0} old secret"
 
2432
                             .format(client_name))
 
2433
                client["secret"] = (
 
2434
                    client_settings[client_name]["secret"])
 
2435
    
 
2436
    # Add/remove clients based on new changes made to config
 
2437
    for client_name in (set(old_client_settings)
 
2438
                        - set(client_settings)):
 
2439
        del clients_data[client_name]
 
2440
    for client_name in (set(client_settings)
 
2441
                        - set(old_client_settings)):
 
2442
        clients_data[client_name] = client_settings[client_name]
 
2443
    
 
2444
    # Create all client objects
 
2445
    for client_name, client in clients_data.iteritems():
 
2446
        tcp_server.clients[client_name] = client_class(
 
2447
            name = client_name, settings = client)
 
2448
    
2058
2449
    if not tcp_server.clients:
2059
2450
        logger.warning("No clients defined")
2060
 
        
 
2451
    
2061
2452
    if not debug:
2062
2453
        try:
2063
2454
            with pidfile:
2071
2462
            # "pidfile" was never created
2072
2463
            pass
2073
2464
        del pidfilename
2074
 
        
2075
 
        signal.signal(signal.SIGINT, signal.SIG_IGN)
2076
2465
    
2077
2466
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2078
2467
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2079
2468
    
2080
2469
    if use_dbus:
2081
 
        class MandosDBusService(dbus.service.Object):
 
2470
        @alternate_dbus_interfaces({"se.recompile.Mandos":
 
2471
                                        "se.bsnet.fukt.Mandos"})
 
2472
        class MandosDBusService(DBusObjectWithProperties):
2082
2473
            """A D-Bus proxy object"""
2083
2474
            def __init__(self):
2084
2475
                dbus.service.Object.__init__(self, bus, "/")
2085
2476
            _interface = "se.recompile.Mandos"
2086
2477
            
 
2478
            @dbus_interface_annotations(_interface)
 
2479
            def _foo(self):
 
2480
                return { "org.freedesktop.DBus.Property"
 
2481
                         ".EmitsChangedSignal":
 
2482
                             "false"}
 
2483
            
2087
2484
            @dbus.service.signal(_interface, signature="o")
2088
2485
            def ClientAdded(self, objpath):
2089
2486
                "D-Bus signal"
2103
2500
            def GetAllClients(self):
2104
2501
                "D-Bus method"
2105
2502
                return dbus.Array(c.dbus_object_path
2106
 
                                  for c in tcp_server.clients)
 
2503
                                  for c in
 
2504
                                  tcp_server.clients.itervalues())
2107
2505
            
2108
2506
            @dbus.service.method(_interface,
2109
2507
                                 out_signature="a{oa{sv}}")
2111
2509
                "D-Bus method"
2112
2510
                return dbus.Dictionary(
2113
2511
                    ((c.dbus_object_path, c.GetAll(""))
2114
 
                     for c in tcp_server.clients),
 
2512
                     for c in tcp_server.clients.itervalues()),
2115
2513
                    signature="oa{sv}")
2116
2514
            
2117
2515
            @dbus.service.method(_interface, in_signature="o")
2118
2516
            def RemoveClient(self, object_path):
2119
2517
                "D-Bus method"
2120
 
                for c in tcp_server.clients:
 
2518
                for c in tcp_server.clients.itervalues():
2121
2519
                    if c.dbus_object_path == object_path:
2122
 
                        tcp_server.clients.remove(c)
 
2520
                        del tcp_server.clients[c.name]
2123
2521
                        c.remove_from_connection()
2124
2522
                        # Don't signal anything except ClientRemoved
2125
2523
                        c.disable(quiet=True)
2130
2528
            
2131
2529
            del _interface
2132
2530
        
2133
 
        class MandosDBusServiceTransitional(MandosDBusService):
2134
 
            __metaclass__ = AlternateDBusNamesMetaclass
2135
 
        mandos_dbus_service = MandosDBusServiceTransitional()
 
2531
        mandos_dbus_service = MandosDBusService()
2136
2532
    
2137
2533
    def cleanup():
2138
2534
        "Cleanup function; run on exit"
2139
2535
        service.cleanup()
2140
2536
        
2141
2537
        multiprocessing.active_children()
 
2538
        if not (tcp_server.clients or client_settings):
 
2539
            return
 
2540
        
 
2541
        # Store client before exiting. Secrets are encrypted with key
 
2542
        # based on what config file has. If config file is
 
2543
        # removed/edited, old secret will thus be unrecovable.
 
2544
        clients = {}
 
2545
        with PGPEngine() as pgp:
 
2546
            for client in tcp_server.clients.itervalues():
 
2547
                key = client_settings[client.name]["secret"]
 
2548
                client.encrypted_secret = pgp.encrypt(client.secret,
 
2549
                                                      key)
 
2550
                client_dict = {}
 
2551
                
 
2552
                # A list of attributes that can not be pickled
 
2553
                # + secret.
 
2554
                exclude = set(("bus", "changedstate", "secret",
 
2555
                               "checker"))
 
2556
                for name, typ in (inspect.getmembers
 
2557
                                  (dbus.service.Object)):
 
2558
                    exclude.add(name)
 
2559
                
 
2560
                client_dict["encrypted_secret"] = (client
 
2561
                                                   .encrypted_secret)
 
2562
                for attr in client.client_structure:
 
2563
                    if attr not in exclude:
 
2564
                        client_dict[attr] = getattr(client, attr)
 
2565
                
 
2566
                clients[client.name] = client_dict
 
2567
                del client_settings[client.name]["secret"]
 
2568
        
 
2569
        try:
 
2570
            with (tempfile.NamedTemporaryFile
 
2571
                  (mode='wb', suffix=".pickle", prefix='clients-',
 
2572
                   dir=os.path.dirname(stored_state_path),
 
2573
                   delete=False)) as stored_state:
 
2574
                pickle.dump((clients, client_settings), stored_state)
 
2575
                tempname=stored_state.name
 
2576
            os.rename(tempname, stored_state_path)
 
2577
        except (IOError, OSError) as e:
 
2578
            if not debug:
 
2579
                try:
 
2580
                    os.remove(tempname)
 
2581
                except NameError:
 
2582
                    pass
 
2583
            if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
 
2584
                logger.warning("Could not save persistent state: {0}"
 
2585
                               .format(os.strerror(e.errno)))
 
2586
            else:
 
2587
                logger.warning("Could not save persistent state:",
 
2588
                               exc_info=e)
 
2589
                raise e
 
2590
        
 
2591
        # Delete all clients, and settings from config
2142
2592
        while tcp_server.clients:
2143
 
            client = tcp_server.clients.pop()
 
2593
            name, client = tcp_server.clients.popitem()
2144
2594
            if use_dbus:
2145
2595
                client.remove_from_connection()
2146
 
            client.disable_hook = None
2147
2596
            # Don't signal anything except ClientRemoved
2148
2597
            client.disable(quiet=True)
2149
2598
            if use_dbus:
2151
2600
                mandos_dbus_service.ClientRemoved(client
2152
2601
                                                  .dbus_object_path,
2153
2602
                                                  client.name)
 
2603
        client_settings.clear()
2154
2604
    
2155
2605
    atexit.register(cleanup)
2156
2606
    
2157
 
    for client in tcp_server.clients:
 
2607
    for client in tcp_server.clients.itervalues():
2158
2608
        if use_dbus:
2159
2609
            # Emit D-Bus signal
2160
2610
            mandos_dbus_service.ClientAdded(client.dbus_object_path)
2161
 
        client.enable()
 
2611
        # Need to initiate checking of clients
 
2612
        if client.enabled:
 
2613
            client.init_checker()
2162
2614
    
2163
2615
    tcp_server.enable()
2164
2616
    tcp_server.server_activate()
2167
2619
    service.port = tcp_server.socket.getsockname()[1]
2168
2620
    if use_ipv6:
2169
2621
        logger.info("Now listening on address %r, port %d,"
2170
 
                    " flowinfo %d, scope_id %d"
2171
 
                    % tcp_server.socket.getsockname())
 
2622
                    " flowinfo %d, scope_id %d",
 
2623
                    *tcp_server.socket.getsockname())
2172
2624
    else:                       # IPv4
2173
 
        logger.info("Now listening on address %r, port %d"
2174
 
                    % tcp_server.socket.getsockname())
 
2625
        logger.info("Now listening on address %r, port %d",
 
2626
                    *tcp_server.socket.getsockname())
2175
2627
    
2176
2628
    #service.interface = tcp_server.socket.getsockname()[3]
2177
2629
    
2180
2632
        try:
2181
2633
            service.activate()
2182
2634
        except dbus.exceptions.DBusException as error:
2183
 
            logger.critical("DBusException: %s", error)
 
2635
            logger.critical("D-Bus Exception", exc_info=error)
2184
2636
            cleanup()
2185
2637
            sys.exit(1)
2186
2638
        # End of Avahi example code
2193
2645
        logger.debug("Starting main loop")
2194
2646
        main_loop.run()
2195
2647
    except AvahiError as error:
2196
 
        logger.critical("AvahiError: %s", error)
 
2648
        logger.critical("Avahi Error", exc_info=error)
2197
2649
        cleanup()
2198
2650
        sys.exit(1)
2199
2651
    except KeyboardInterrupt:
2204
2656
    # Must run before the D-Bus bus name gets deregistered
2205
2657
    cleanup()
2206
2658
 
2207
 
 
2208
2659
if __name__ == '__main__':
2209
2660
    main()