/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: 2009-04-16 22:51:36 UTC
  • Revision ID: teddy@fukt.bsnet.se-20090416225136-wz8p0nsuteiasxn2
Code cleanup.

* mandos (ForkingMixInWithPipe.process_request): Call "self.add_pipe".
  (ForkingMixInWithPipe.handle_ipc): Removed.
  (ForkingMixInWithPipe.add_pipe): New.
  (MandosServer.add_pipe): New.

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-2010 Teddy Hogeborn
15
 
# Copyright © 2008-2010 Björn Påhlsson
 
14
# Copyright © 2008,2009 Teddy Hogeborn
 
15
# Copyright © 2008,2009 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
55
55
import logging
56
56
import logging.handlers
57
57
import pwd
58
 
import contextlib
 
58
from contextlib import closing
59
59
import struct
60
60
import fcntl
61
61
import functools
62
 
import cPickle as pickle
63
 
import multiprocessing
64
62
 
65
63
import dbus
66
64
import dbus.service
69
67
from dbus.mainloop.glib import DBusGMainLoop
70
68
import ctypes
71
69
import ctypes.util
72
 
import xml.dom.minidom
73
 
import inspect
74
70
 
75
71
try:
76
72
    SO_BINDTODEVICE = socket.SO_BINDTODEVICE
81
77
        SO_BINDTODEVICE = None
82
78
 
83
79
 
84
 
version = "1.2.3"
 
80
version = "1.0.8"
85
81
 
86
 
#logger = logging.getLogger(u'mandos')
87
82
logger = logging.Logger(u'mandos')
88
83
syslogger = (logging.handlers.SysLogHandler
89
84
             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
157
152
                            u" after %i retries, exiting.",
158
153
                            self.rename_count)
159
154
            raise AvahiServiceError(u"Too many renames")
160
 
        self.name = unicode(self.server.GetAlternativeServiceName(self.name))
 
155
        self.name = self.server.GetAlternativeServiceName(self.name)
161
156
        logger.info(u"Changing Zeroconf service name to %r ...",
162
 
                    self.name)
 
157
                    unicode(self.name))
163
158
        syslogger.setFormatter(logging.Formatter
164
159
                               (u'Mandos (%s) [%%(process)d]:'
165
160
                                u' %%(levelname)s: %%(message)s'
166
161
                                % self.name))
167
162
        self.remove()
168
 
        try:
169
 
            self.add()
170
 
        except dbus.exceptions.DBusException, error:
171
 
            logger.critical(u"DBusException: %s", error)
172
 
            self.cleanup()
173
 
            os._exit(1)
 
163
        self.add()
174
164
        self.rename_count += 1
175
165
    def remove(self):
176
166
        """Derived from the Avahi example code"""
184
174
                                    self.server.EntryGroupNew()),
185
175
                avahi.DBUS_INTERFACE_ENTRY_GROUP)
186
176
            self.group.connect_to_signal('StateChanged',
187
 
                                         self
188
 
                                         .entry_group_state_changed)
 
177
                                         self.entry_group_state_changed)
189
178
        logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
190
179
                     self.name, self.type)
191
180
        self.group.AddService(
199
188
        self.group.Commit()
200
189
    def entry_group_state_changed(self, state, error):
201
190
        """Derived from the Avahi example code"""
202
 
        logger.debug(u"Avahi entry group state change: %i", state)
 
191
        logger.debug(u"Avahi state change: %i", state)
203
192
        
204
193
        if state == avahi.ENTRY_GROUP_ESTABLISHED:
205
194
            logger.debug(u"Zeroconf service established.")
206
195
        elif state == avahi.ENTRY_GROUP_COLLISION:
207
 
            logger.info(u"Zeroconf service name collision.")
 
196
            logger.warning(u"Zeroconf service name collision.")
208
197
            self.rename()
209
198
        elif state == avahi.ENTRY_GROUP_FAILURE:
210
199
            logger.critical(u"Avahi: Error in group state changed %s",
218
207
            self.group = None
219
208
    def server_state_changed(self, state):
220
209
        """Derived from the Avahi example code"""
221
 
        logger.debug(u"Avahi server state change: %i", state)
222
210
        if state == avahi.SERVER_COLLISION:
223
211
            logger.error(u"Zeroconf server name collision")
224
212
            self.remove()
240
228
    """A representation of a client host served by this server.
241
229
    
242
230
    Attributes:
243
 
    _approved:   bool(); 'None' if not yet approved/disapproved
244
 
    approval_delay: datetime.timedelta(); Time to wait for approval
245
 
    approval_duration: datetime.timedelta(); Duration of one approval
 
231
    name:       string; from the config file, used in log messages and
 
232
                        D-Bus identifiers
 
233
    fingerprint: string (40 or 32 hexadecimal digits); used to
 
234
                 uniquely identify the client
 
235
    secret:     bytestring; sent verbatim (over TLS) to client
 
236
    host:       string; available for use by the checker command
 
237
    created:    datetime.datetime(); (UTC) object creation
 
238
    last_enabled: datetime.datetime(); (UTC)
 
239
    enabled:    bool()
 
240
    last_checked_ok: datetime.datetime(); (UTC) or None
 
241
    timeout:    datetime.timedelta(); How long from last_checked_ok
 
242
                                      until this client is invalid
 
243
    interval:   datetime.timedelta(); How often to start a new checker
 
244
    disable_hook:  If set, called by disable() as disable_hook(self)
246
245
    checker:    subprocess.Popen(); a running checker process used
247
246
                                    to see if the client lives.
248
247
                                    'None' if no process is running.
249
 
    checker_callback_tag: a gobject event source tag, or None
250
 
    checker_command: string; External command which is run to check
251
 
                     if client lives.  %() expansions are done at
 
248
    checker_initiator_tag: a gobject event source tag, or None
 
249
    disable_initiator_tag:    - '' -
 
250
    checker_callback_tag:  - '' -
 
251
    checker_command: string; External command which is run to check if
 
252
                     client lives.  %() expansions are done at
252
253
                     runtime with vars(self) as dict, so that for
253
254
                     instance %(name)s can be used in the command.
254
 
    checker_initiator_tag: a gobject event source tag, or None
255
 
    created:    datetime.datetime(); (UTC) object creation
256
255
    current_checker_command: string; current running checker_command
257
 
    disable_hook:  If set, called by disable() as disable_hook(self)
258
 
    disable_initiator_tag: a gobject event source tag, or None
259
 
    enabled:    bool()
260
 
    fingerprint: string (40 or 32 hexadecimal digits); used to
261
 
                 uniquely identify the client
262
 
    host:       string; available for use by the checker command
263
 
    interval:   datetime.timedelta(); How often to start a new checker
264
 
    last_approval_request: datetime.datetime(); (UTC) or None
265
 
    last_checked_ok: datetime.datetime(); (UTC) or None
266
 
    last_enabled: datetime.datetime(); (UTC)
267
 
    name:       string; from the config file, used in log messages and
268
 
                        D-Bus identifiers
269
 
    secret:     bytestring; sent verbatim (over TLS) to client
270
 
    timeout:    datetime.timedelta(); How long from last_checked_ok
271
 
                                      until this client is disabled
272
 
    runtime_expansions: Allowed attributes for runtime expansion.
273
256
    """
274
257
    
275
 
    runtime_expansions = (u"approval_delay", u"approval_duration",
276
 
                          u"created", u"enabled", u"fingerprint",
277
 
                          u"host", u"interval", u"last_checked_ok",
278
 
                          u"last_enabled", u"name", u"timeout")
279
 
    
280
258
    @staticmethod
281
 
    def _timedelta_to_milliseconds(td):
282
 
        "Convert a datetime.timedelta() to milliseconds"
283
 
        return ((td.days * 24 * 60 * 60 * 1000)
284
 
                + (td.seconds * 1000)
285
 
                + (td.microseconds // 1000))
 
259
    def _datetime_to_milliseconds(dt):
 
260
        "Convert a datetime.datetime() to milliseconds"
 
261
        return ((dt.days * 24 * 60 * 60 * 1000)
 
262
                + (dt.seconds * 1000)
 
263
                + (dt.microseconds // 1000))
286
264
    
287
265
    def timeout_milliseconds(self):
288
266
        "Return the 'timeout' attribute in milliseconds"
289
 
        return self._timedelta_to_milliseconds(self.timeout)
 
267
        return self._datetime_to_milliseconds(self.timeout)
290
268
    
291
269
    def interval_milliseconds(self):
292
270
        "Return the 'interval' attribute in milliseconds"
293
 
        return self._timedelta_to_milliseconds(self.interval)
294
 
 
295
 
    def approval_delay_milliseconds(self):
296
 
        return self._timedelta_to_milliseconds(self.approval_delay)
 
271
        return self._datetime_to_milliseconds(self.interval)
297
272
    
298
273
    def __init__(self, name = None, disable_hook=None, config=None):
299
274
        """Note: the 'checker' key in 'config' sets the
312
287
        if u"secret" in config:
313
288
            self.secret = config[u"secret"].decode(u"base64")
314
289
        elif u"secfile" in config:
315
 
            with open(os.path.expanduser(os.path.expandvars
316
 
                                         (config[u"secfile"])),
317
 
                      "rb") as secfile:
 
290
            with closing(open(os.path.expanduser
 
291
                              (os.path.expandvars
 
292
                               (config[u"secfile"])))) as secfile:
318
293
                self.secret = secfile.read()
319
294
        else:
320
295
            raise TypeError(u"No secret or secfile for client %s"
322
297
        self.host = config.get(u"host", u"")
323
298
        self.created = datetime.datetime.utcnow()
324
299
        self.enabled = False
325
 
        self.last_approval_request = None
326
300
        self.last_enabled = None
327
301
        self.last_checked_ok = None
328
302
        self.timeout = string_to_delta(config[u"timeout"])
335
309
        self.checker_command = config[u"checker"]
336
310
        self.current_checker_command = None
337
311
        self.last_connect = None
338
 
        self._approved = None
339
 
        self.approved_by_default = config.get(u"approved_by_default",
340
 
                                              True)
341
 
        self.approvals_pending = 0
342
 
        self.approval_delay = string_to_delta(
343
 
            config[u"approval_delay"])
344
 
        self.approval_duration = string_to_delta(
345
 
            config[u"approval_duration"])
346
 
        self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
347
312
    
348
 
    def send_changedstate(self):
349
 
        self.changedstate.acquire()
350
 
        self.changedstate.notify_all()
351
 
        self.changedstate.release()
352
 
        
353
313
    def enable(self):
354
314
        """Start this client's checker and timeout hooks"""
355
 
        if getattr(self, u"enabled", False):
356
 
            # Already enabled
357
 
            return
358
 
        self.send_changedstate()
359
315
        self.last_enabled = datetime.datetime.utcnow()
360
316
        # Schedule a new checker to be started an 'interval' from now,
361
317
        # and every interval from then on.
362
318
        self.checker_initiator_tag = (gobject.timeout_add
363
319
                                      (self.interval_milliseconds(),
364
320
                                       self.start_checker))
 
321
        # Also start a new checker *right now*.
 
322
        self.start_checker()
365
323
        # Schedule a disable() when 'timeout' has passed
366
324
        self.disable_initiator_tag = (gobject.timeout_add
367
325
                                   (self.timeout_milliseconds(),
368
326
                                    self.disable))
369
327
        self.enabled = True
370
 
        # Also start a new checker *right now*.
371
 
        self.start_checker()
372
328
    
373
 
    def disable(self, quiet=True):
 
329
    def disable(self):
374
330
        """Disable this client."""
375
331
        if not getattr(self, "enabled", False):
376
332
            return False
377
 
        if not quiet:
378
 
            self.send_changedstate()
379
 
        if not quiet:
380
 
            logger.info(u"Disabling client %s", self.name)
 
333
        logger.info(u"Disabling client %s", self.name)
381
334
        if getattr(self, u"disable_initiator_tag", False):
382
335
            gobject.source_remove(self.disable_initiator_tag)
383
336
            self.disable_initiator_tag = None
424
377
                                      (self.timeout_milliseconds(),
425
378
                                       self.disable))
426
379
    
427
 
    def need_approval(self):
428
 
        self.last_approval_request = datetime.datetime.utcnow()
429
 
    
430
380
    def start_checker(self):
431
381
        """Start a new checker subprocess if one is not running.
432
382
        
438
388
        # client would inevitably timeout, since no checker would get
439
389
        # a chance to run to completion.  If we instead leave running
440
390
        # checkers alone, the checker would have to take more time
441
 
        # than 'timeout' for the client to be disabled, which is as it
442
 
        # should be.
 
391
        # than 'timeout' for the client to be declared invalid, which
 
392
        # is as it should be.
443
393
        
444
394
        # If a checker exists, make sure it is not a zombie
445
 
        try:
 
395
        if self.checker is not None:
446
396
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
447
 
        except (AttributeError, OSError), error:
448
 
            if (isinstance(error, OSError)
449
 
                and error.errno != errno.ECHILD):
450
 
                raise error
451
 
        else:
452
397
            if pid:
453
398
                logger.warning(u"Checker was a zombie")
454
399
                gobject.source_remove(self.checker_callback_tag)
461
406
                command = self.checker_command % self.host
462
407
            except TypeError:
463
408
                # Escape attributes for the shell
464
 
                escaped_attrs = dict(
465
 
                    (attr,
466
 
                     re.escape(unicode(str(getattr(self, attr, u"")),
467
 
                                       errors=
468
 
                                       u'replace')))
469
 
                    for attr in
470
 
                    self.runtime_expansions)
471
 
 
 
409
                escaped_attrs = dict((key,
 
410
                                      re.escape(unicode(str(val),
 
411
                                                        errors=
 
412
                                                        u'replace')))
 
413
                                     for key, val in
 
414
                                     vars(self).iteritems())
472
415
                try:
473
416
                    command = self.checker_command % escaped_attrs
474
417
                except TypeError, error:
512
455
        logger.debug(u"Stopping checker for %(name)s", vars(self))
513
456
        try:
514
457
            os.kill(self.checker.pid, signal.SIGTERM)
515
 
            #time.sleep(0.5)
 
458
            #os.sleep(0.5)
516
459
            #if self.checker.poll() is None:
517
460
            #    os.kill(self.checker.pid, signal.SIGKILL)
518
461
        except OSError, error:
519
462
            if error.errno != errno.ESRCH: # No such process
520
463
                raise
521
464
        self.checker = None
522
 
 
523
 
def dbus_service_property(dbus_interface, signature=u"v",
524
 
                          access=u"readwrite", byte_arrays=False):
525
 
    """Decorators for marking methods of a DBusObjectWithProperties to
526
 
    become properties on the D-Bus.
527
 
    
528
 
    The decorated method will be called with no arguments by "Get"
529
 
    and with one argument by "Set".
530
 
    
531
 
    The parameters, where they are supported, are the same as
532
 
    dbus.service.method, except there is only "signature", since the
533
 
    type from Get() and the type sent to Set() is the same.
534
 
    """
535
 
    # Encoding deeply encoded byte arrays is not supported yet by the
536
 
    # "Set" method, so we fail early here:
537
 
    if byte_arrays and signature != u"ay":
538
 
        raise ValueError(u"Byte arrays not supported for non-'ay'"
539
 
                         u" signature %r" % signature)
540
 
    def decorator(func):
541
 
        func._dbus_is_property = True
542
 
        func._dbus_interface = dbus_interface
543
 
        func._dbus_signature = signature
544
 
        func._dbus_access = access
545
 
        func._dbus_name = func.__name__
546
 
        if func._dbus_name.endswith(u"_dbus_property"):
547
 
            func._dbus_name = func._dbus_name[:-14]
548
 
        func._dbus_get_args_options = {u'byte_arrays': byte_arrays }
549
 
        return func
550
 
    return decorator
551
 
 
552
 
 
553
 
class DBusPropertyException(dbus.exceptions.DBusException):
554
 
    """A base class for D-Bus property-related exceptions
555
 
    """
556
 
    def __unicode__(self):
557
 
        return unicode(str(self))
558
 
 
559
 
 
560
 
class DBusPropertyAccessException(DBusPropertyException):
561
 
    """A property's access permissions disallows an operation.
562
 
    """
563
 
    pass
564
 
 
565
 
 
566
 
class DBusPropertyNotFound(DBusPropertyException):
567
 
    """An attempt was made to access a non-existing property.
568
 
    """
569
 
    pass
570
 
 
571
 
 
572
 
class DBusObjectWithProperties(dbus.service.Object):
573
 
    """A D-Bus object with properties.
574
 
 
575
 
    Classes inheriting from this can use the dbus_service_property
576
 
    decorator to expose methods as D-Bus properties.  It exposes the
577
 
    standard Get(), Set(), and GetAll() methods on the D-Bus.
578
 
    """
579
 
    
580
 
    @staticmethod
581
 
    def _is_dbus_property(obj):
582
 
        return getattr(obj, u"_dbus_is_property", False)
583
 
    
584
 
    def _get_all_dbus_properties(self):
585
 
        """Returns a generator of (name, attribute) pairs
586
 
        """
587
 
        return ((prop._dbus_name, prop)
588
 
                for name, prop in
589
 
                inspect.getmembers(self, self._is_dbus_property))
590
 
    
591
 
    def _get_dbus_property(self, interface_name, property_name):
592
 
        """Returns a bound method if one exists which is a D-Bus
593
 
        property with the specified name and interface.
594
 
        """
595
 
        for name in (property_name,
596
 
                     property_name + u"_dbus_property"):
597
 
            prop = getattr(self, name, None)
598
 
            if (prop is None
599
 
                or not self._is_dbus_property(prop)
600
 
                or prop._dbus_name != property_name
601
 
                or (interface_name and prop._dbus_interface
602
 
                    and interface_name != prop._dbus_interface)):
603
 
                continue
604
 
            return prop
605
 
        # No such property
606
 
        raise DBusPropertyNotFound(self.dbus_object_path + u":"
607
 
                                   + interface_name + u"."
608
 
                                   + property_name)
609
 
    
610
 
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
611
 
                         out_signature=u"v")
612
 
    def Get(self, interface_name, property_name):
613
 
        """Standard D-Bus property Get() method, see D-Bus standard.
614
 
        """
615
 
        prop = self._get_dbus_property(interface_name, property_name)
616
 
        if prop._dbus_access == u"write":
617
 
            raise DBusPropertyAccessException(property_name)
618
 
        value = prop()
619
 
        if not hasattr(value, u"variant_level"):
620
 
            return value
621
 
        return type(value)(value, variant_level=value.variant_level+1)
622
 
    
623
 
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
624
 
    def Set(self, interface_name, property_name, value):
625
 
        """Standard D-Bus property Set() method, see D-Bus standard.
626
 
        """
627
 
        prop = self._get_dbus_property(interface_name, property_name)
628
 
        if prop._dbus_access == u"read":
629
 
            raise DBusPropertyAccessException(property_name)
630
 
        if prop._dbus_get_args_options[u"byte_arrays"]:
631
 
            # The byte_arrays option is not supported yet on
632
 
            # signatures other than "ay".
633
 
            if prop._dbus_signature != u"ay":
634
 
                raise ValueError
635
 
            value = dbus.ByteArray(''.join(unichr(byte)
636
 
                                           for byte in value))
637
 
        prop(value)
638
 
    
639
 
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
640
 
                         out_signature=u"a{sv}")
641
 
    def GetAll(self, interface_name):
642
 
        """Standard D-Bus property GetAll() method, see D-Bus
643
 
        standard.
644
 
 
645
 
        Note: Will not include properties with access="write".
646
 
        """
647
 
        all = {}
648
 
        for name, prop in self._get_all_dbus_properties():
649
 
            if (interface_name
650
 
                and interface_name != prop._dbus_interface):
651
 
                # Interface non-empty but did not match
652
 
                continue
653
 
            # Ignore write-only properties
654
 
            if prop._dbus_access == u"write":
655
 
                continue
656
 
            value = prop()
657
 
            if not hasattr(value, u"variant_level"):
658
 
                all[name] = value
659
 
                continue
660
 
            all[name] = type(value)(value, variant_level=
661
 
                                    value.variant_level+1)
662
 
        return dbus.Dictionary(all, signature=u"sv")
663
 
    
664
 
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
665
 
                         out_signature=u"s",
666
 
                         path_keyword='object_path',
667
 
                         connection_keyword='connection')
668
 
    def Introspect(self, object_path, connection):
669
 
        """Standard D-Bus method, overloaded to insert property tags.
670
 
        """
671
 
        xmlstring = dbus.service.Object.Introspect(self, object_path,
672
 
                                                   connection)
673
 
        try:
674
 
            document = xml.dom.minidom.parseString(xmlstring)
675
 
            def make_tag(document, name, prop):
676
 
                e = document.createElement(u"property")
677
 
                e.setAttribute(u"name", name)
678
 
                e.setAttribute(u"type", prop._dbus_signature)
679
 
                e.setAttribute(u"access", prop._dbus_access)
680
 
                return e
681
 
            for if_tag in document.getElementsByTagName(u"interface"):
682
 
                for tag in (make_tag(document, name, prop)
683
 
                            for name, prop
684
 
                            in self._get_all_dbus_properties()
685
 
                            if prop._dbus_interface
686
 
                            == if_tag.getAttribute(u"name")):
687
 
                    if_tag.appendChild(tag)
688
 
                # Add the names to the return values for the
689
 
                # "org.freedesktop.DBus.Properties" methods
690
 
                if (if_tag.getAttribute(u"name")
691
 
                    == u"org.freedesktop.DBus.Properties"):
692
 
                    for cn in if_tag.getElementsByTagName(u"method"):
693
 
                        if cn.getAttribute(u"name") == u"Get":
694
 
                            for arg in cn.getElementsByTagName(u"arg"):
695
 
                                if (arg.getAttribute(u"direction")
696
 
                                    == u"out"):
697
 
                                    arg.setAttribute(u"name", u"value")
698
 
                        elif cn.getAttribute(u"name") == u"GetAll":
699
 
                            for arg in cn.getElementsByTagName(u"arg"):
700
 
                                if (arg.getAttribute(u"direction")
701
 
                                    == u"out"):
702
 
                                    arg.setAttribute(u"name", u"props")
703
 
            xmlstring = document.toxml(u"utf-8")
704
 
            document.unlink()
705
 
        except (AttributeError, xml.dom.DOMException,
706
 
                xml.parsers.expat.ExpatError), error:
707
 
            logger.error(u"Failed to override Introspection method",
708
 
                         error)
709
 
        return xmlstring
710
 
 
711
 
 
712
 
class ClientDBus(Client, DBusObjectWithProperties):
 
465
    
 
466
    def still_valid(self):
 
467
        """Has the timeout not yet passed for this client?"""
 
468
        if not getattr(self, u"enabled", False):
 
469
            return False
 
470
        now = datetime.datetime.utcnow()
 
471
        if self.last_checked_ok is None:
 
472
            return now < (self.created + self.timeout)
 
473
        else:
 
474
            return now < (self.last_checked_ok + self.timeout)
 
475
 
 
476
 
 
477
class ClientDBus(Client, dbus.service.Object):
713
478
    """A Client class using D-Bus
714
479
    
715
480
    Attributes:
716
481
    dbus_object_path: dbus.ObjectPath
717
482
    bus: dbus.SystemBus()
718
483
    """
719
 
    
720
 
    runtime_expansions = (Client.runtime_expansions
721
 
                          + (u"dbus_object_path",))
722
 
    
723
484
    # dbus.service.Object doesn't use super(), so we can't either.
724
485
    
725
486
    def __init__(self, bus = None, *args, **kwargs):
726
 
        self._approvals_pending = 0
727
487
        self.bus = bus
728
488
        Client.__init__(self, *args, **kwargs)
729
489
        # Only now, when this client is initialized, can it show up on
730
490
        # the D-Bus
731
 
        client_object_name = unicode(self.name).translate(
732
 
            {ord(u"."): ord(u"_"),
733
 
             ord(u"-"): ord(u"_")})
734
491
        self.dbus_object_path = (dbus.ObjectPath
735
 
                                 (u"/clients/" + client_object_name))
736
 
        DBusObjectWithProperties.__init__(self, self.bus,
737
 
                                          self.dbus_object_path)
738
 
        
739
 
    def _get_approvals_pending(self):
740
 
        return self._approvals_pending
741
 
    def _set_approvals_pending(self, value):
742
 
        old_value = self._approvals_pending
743
 
        self._approvals_pending = value
744
 
        bval = bool(value)
745
 
        if (hasattr(self, "dbus_object_path")
746
 
            and bval is not bool(old_value)):
747
 
            dbus_bool = dbus.Boolean(bval, variant_level=1)
748
 
            self.PropertyChanged(dbus.String(u"ApprovalPending"),
749
 
                                 dbus_bool)
750
 
 
751
 
    approvals_pending = property(_get_approvals_pending,
752
 
                                 _set_approvals_pending)
753
 
    del _get_approvals_pending, _set_approvals_pending
 
492
                                 (u"/clients/"
 
493
                                  + self.name.replace(u".", u"_")))
 
494
        dbus.service.Object.__init__(self, self.bus,
 
495
                                     self.dbus_object_path)
754
496
    
755
497
    @staticmethod
756
498
    def _datetime_to_dbus(dt, variant_level=0):
763
505
        r = Client.enable(self)
764
506
        if oldstate != self.enabled:
765
507
            # Emit D-Bus signals
766
 
            self.PropertyChanged(dbus.String(u"Enabled"),
 
508
            self.PropertyChanged(dbus.String(u"enabled"),
767
509
                                 dbus.Boolean(True, variant_level=1))
768
510
            self.PropertyChanged(
769
 
                dbus.String(u"LastEnabled"),
 
511
                dbus.String(u"last_enabled"),
770
512
                self._datetime_to_dbus(self.last_enabled,
771
513
                                       variant_level=1))
772
514
        return r
773
515
    
774
 
    def disable(self, quiet = False):
 
516
    def disable(self, signal = True):
775
517
        oldstate = getattr(self, u"enabled", False)
776
 
        r = Client.disable(self, quiet=quiet)
777
 
        if not quiet and oldstate != self.enabled:
 
518
        r = Client.disable(self)
 
519
        if signal and oldstate != self.enabled:
778
520
            # Emit D-Bus signal
779
 
            self.PropertyChanged(dbus.String(u"Enabled"),
 
521
            self.PropertyChanged(dbus.String(u"enabled"),
780
522
                                 dbus.Boolean(False, variant_level=1))
781
523
        return r
782
524
    
785
527
            self.remove_from_connection()
786
528
        except LookupError:
787
529
            pass
788
 
        if hasattr(DBusObjectWithProperties, u"__del__"):
789
 
            DBusObjectWithProperties.__del__(self, *args, **kwargs)
 
530
        if hasattr(dbus.service.Object, u"__del__"):
 
531
            dbus.service.Object.__del__(self, *args, **kwargs)
790
532
        Client.__del__(self, *args, **kwargs)
791
533
    
792
534
    def checker_callback(self, pid, condition, command,
794
536
        self.checker_callback_tag = None
795
537
        self.checker = None
796
538
        # Emit D-Bus signal
797
 
        self.PropertyChanged(dbus.String(u"CheckerRunning"),
 
539
        self.PropertyChanged(dbus.String(u"checker_running"),
798
540
                             dbus.Boolean(False, variant_level=1))
799
541
        if os.WIFEXITED(condition):
800
542
            exitstatus = os.WEXITSTATUS(condition)
815
557
        r = Client.checked_ok(self, *args, **kwargs)
816
558
        # Emit D-Bus signal
817
559
        self.PropertyChanged(
818
 
            dbus.String(u"LastCheckedOK"),
 
560
            dbus.String(u"last_checked_ok"),
819
561
            (self._datetime_to_dbus(self.last_checked_ok,
820
562
                                    variant_level=1)))
821
563
        return r
822
564
    
823
 
    def need_approval(self, *args, **kwargs):
824
 
        r = Client.need_approval(self, *args, **kwargs)
825
 
        # Emit D-Bus signal
826
 
        self.PropertyChanged(
827
 
            dbus.String(u"LastApprovalRequest"),
828
 
            (self._datetime_to_dbus(self.last_approval_request,
829
 
                                    variant_level=1)))
830
 
        return r
831
 
    
832
565
    def start_checker(self, *args, **kwargs):
833
566
        old_checker = self.checker
834
567
        if self.checker is not None:
842
575
            # Emit D-Bus signal
843
576
            self.CheckerStarted(self.current_checker_command)
844
577
            self.PropertyChanged(
845
 
                dbus.String(u"CheckerRunning"),
 
578
                dbus.String(u"checker_running"),
846
579
                dbus.Boolean(True, variant_level=1))
847
580
        return r
848
581
    
851
584
        r = Client.stop_checker(self, *args, **kwargs)
852
585
        if (old_checker is not None
853
586
            and getattr(self, u"checker", None) is None):
854
 
            self.PropertyChanged(dbus.String(u"CheckerRunning"),
 
587
            self.PropertyChanged(dbus.String(u"checker_running"),
855
588
                                 dbus.Boolean(False, variant_level=1))
856
589
        return r
857
 
 
858
 
    def _reset_approved(self):
859
 
        self._approved = None
860
 
        return False
861
 
    
862
 
    def approve(self, value=True):
863
 
        self.send_changedstate()
864
 
        self._approved = value
865
 
        gobject.timeout_add(self._timedelta_to_milliseconds
866
 
                            (self.approval_duration),
867
 
                            self._reset_approved)
868
 
    
869
 
    
870
 
    ## D-Bus methods, signals & properties
 
590
    
 
591
    ## D-Bus methods & signals
871
592
    _interface = u"se.bsnet.fukt.Mandos.Client"
872
593
    
873
 
    ## Signals
 
594
    # CheckedOK - method
 
595
    @dbus.service.method(_interface)
 
596
    def CheckedOK(self):
 
597
        return self.checked_ok()
874
598
    
875
599
    # CheckerCompleted - signal
876
600
    @dbus.service.signal(_interface, signature=u"nxs")
884
608
        "D-Bus signal"
885
609
        pass
886
610
    
 
611
    # GetAllProperties - method
 
612
    @dbus.service.method(_interface, out_signature=u"a{sv}")
 
613
    def GetAllProperties(self):
 
614
        "D-Bus method"
 
615
        return dbus.Dictionary({
 
616
                dbus.String(u"name"):
 
617
                    dbus.String(self.name, variant_level=1),
 
618
                dbus.String(u"fingerprint"):
 
619
                    dbus.String(self.fingerprint, variant_level=1),
 
620
                dbus.String(u"host"):
 
621
                    dbus.String(self.host, variant_level=1),
 
622
                dbus.String(u"created"):
 
623
                    self._datetime_to_dbus(self.created,
 
624
                                           variant_level=1),
 
625
                dbus.String(u"last_enabled"):
 
626
                    (self._datetime_to_dbus(self.last_enabled,
 
627
                                            variant_level=1)
 
628
                     if self.last_enabled is not None
 
629
                     else dbus.Boolean(False, variant_level=1)),
 
630
                dbus.String(u"enabled"):
 
631
                    dbus.Boolean(self.enabled, variant_level=1),
 
632
                dbus.String(u"last_checked_ok"):
 
633
                    (self._datetime_to_dbus(self.last_checked_ok,
 
634
                                            variant_level=1)
 
635
                     if self.last_checked_ok is not None
 
636
                     else dbus.Boolean (False, variant_level=1)),
 
637
                dbus.String(u"timeout"):
 
638
                    dbus.UInt64(self.timeout_milliseconds(),
 
639
                                variant_level=1),
 
640
                dbus.String(u"interval"):
 
641
                    dbus.UInt64(self.interval_milliseconds(),
 
642
                                variant_level=1),
 
643
                dbus.String(u"checker"):
 
644
                    dbus.String(self.checker_command,
 
645
                                variant_level=1),
 
646
                dbus.String(u"checker_running"):
 
647
                    dbus.Boolean(self.checker is not None,
 
648
                                 variant_level=1),
 
649
                dbus.String(u"object_path"):
 
650
                    dbus.ObjectPath(self.dbus_object_path,
 
651
                                    variant_level=1)
 
652
                }, signature=u"sv")
 
653
    
 
654
    # IsStillValid - method
 
655
    @dbus.service.method(_interface, out_signature=u"b")
 
656
    def IsStillValid(self):
 
657
        return self.still_valid()
 
658
    
887
659
    # PropertyChanged - signal
888
660
    @dbus.service.signal(_interface, signature=u"sv")
889
661
    def PropertyChanged(self, property, value):
890
662
        "D-Bus signal"
891
663
        pass
892
664
    
893
 
    # GotSecret - signal
 
665
    # ReceivedSecret - signal
894
666
    @dbus.service.signal(_interface)
895
 
    def GotSecret(self):
896
 
        """D-Bus signal
897
 
        Is sent after a successful transfer of secret from the Mandos
898
 
        server to mandos-client
899
 
        """
 
667
    def ReceivedSecret(self):
 
668
        "D-Bus signal"
900
669
        pass
901
670
    
902
671
    # Rejected - signal
903
 
    @dbus.service.signal(_interface, signature=u"s")
904
 
    def Rejected(self, reason):
 
672
    @dbus.service.signal(_interface)
 
673
    def Rejected(self):
905
674
        "D-Bus signal"
906
675
        pass
907
676
    
908
 
    # NeedApproval - signal
909
 
    @dbus.service.signal(_interface, signature=u"tb")
910
 
    def NeedApproval(self, timeout, default):
911
 
        "D-Bus signal"
912
 
        return self.need_approval()
913
 
    
914
 
    ## Methods
915
 
    
916
 
    # Approve - method
917
 
    @dbus.service.method(_interface, in_signature=u"b")
918
 
    def Approve(self, value):
919
 
        self.approve(value)
920
 
    
921
 
    # CheckedOK - method
922
 
    @dbus.service.method(_interface)
923
 
    def CheckedOK(self):
924
 
        return self.checked_ok()
 
677
    # SetChecker - method
 
678
    @dbus.service.method(_interface, in_signature=u"s")
 
679
    def SetChecker(self, checker):
 
680
        "D-Bus setter method"
 
681
        self.checker_command = checker
 
682
        # Emit D-Bus signal
 
683
        self.PropertyChanged(dbus.String(u"checker"),
 
684
                             dbus.String(self.checker_command,
 
685
                                         variant_level=1))
 
686
    
 
687
    # SetHost - method
 
688
    @dbus.service.method(_interface, in_signature=u"s")
 
689
    def SetHost(self, host):
 
690
        "D-Bus setter method"
 
691
        self.host = host
 
692
        # Emit D-Bus signal
 
693
        self.PropertyChanged(dbus.String(u"host"),
 
694
                             dbus.String(self.host, variant_level=1))
 
695
    
 
696
    # SetInterval - method
 
697
    @dbus.service.method(_interface, in_signature=u"t")
 
698
    def SetInterval(self, milliseconds):
 
699
        self.interval = datetime.timedelta(0, 0, 0, milliseconds)
 
700
        # Emit D-Bus signal
 
701
        self.PropertyChanged(dbus.String(u"interval"),
 
702
                             (dbus.UInt64(self.interval_milliseconds(),
 
703
                                          variant_level=1)))
 
704
    
 
705
    # SetSecret - method
 
706
    @dbus.service.method(_interface, in_signature=u"ay",
 
707
                         byte_arrays=True)
 
708
    def SetSecret(self, secret):
 
709
        "D-Bus setter method"
 
710
        self.secret = str(secret)
 
711
    
 
712
    # SetTimeout - method
 
713
    @dbus.service.method(_interface, in_signature=u"t")
 
714
    def SetTimeout(self, milliseconds):
 
715
        self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
 
716
        # Emit D-Bus signal
 
717
        self.PropertyChanged(dbus.String(u"timeout"),
 
718
                             (dbus.UInt64(self.timeout_milliseconds(),
 
719
                                          variant_level=1)))
925
720
    
926
721
    # Enable - method
927
722
    @dbus.service.method(_interface)
946
741
    def StopChecker(self):
947
742
        self.stop_checker()
948
743
    
949
 
    ## Properties
950
 
    
951
 
    # ApprovalPending - property
952
 
    @dbus_service_property(_interface, signature=u"b", access=u"read")
953
 
    def ApprovalPending_dbus_property(self):
954
 
        return dbus.Boolean(bool(self.approvals_pending))
955
 
    
956
 
    # ApprovedByDefault - property
957
 
    @dbus_service_property(_interface, signature=u"b",
958
 
                           access=u"readwrite")
959
 
    def ApprovedByDefault_dbus_property(self, value=None):
960
 
        if value is None:       # get
961
 
            return dbus.Boolean(self.approved_by_default)
962
 
        self.approved_by_default = bool(value)
963
 
        # Emit D-Bus signal
964
 
        self.PropertyChanged(dbus.String(u"ApprovedByDefault"),
965
 
                             dbus.Boolean(value, variant_level=1))
966
 
    
967
 
    # ApprovalDelay - property
968
 
    @dbus_service_property(_interface, signature=u"t",
969
 
                           access=u"readwrite")
970
 
    def ApprovalDelay_dbus_property(self, value=None):
971
 
        if value is None:       # get
972
 
            return dbus.UInt64(self.approval_delay_milliseconds())
973
 
        self.approval_delay = datetime.timedelta(0, 0, 0, value)
974
 
        # Emit D-Bus signal
975
 
        self.PropertyChanged(dbus.String(u"ApprovalDelay"),
976
 
                             dbus.UInt64(value, variant_level=1))
977
 
    
978
 
    # ApprovalDuration - property
979
 
    @dbus_service_property(_interface, signature=u"t",
980
 
                           access=u"readwrite")
981
 
    def ApprovalDuration_dbus_property(self, value=None):
982
 
        if value is None:       # get
983
 
            return dbus.UInt64(self._timedelta_to_milliseconds(
984
 
                    self.approval_duration))
985
 
        self.approval_duration = datetime.timedelta(0, 0, 0, value)
986
 
        # Emit D-Bus signal
987
 
        self.PropertyChanged(dbus.String(u"ApprovalDuration"),
988
 
                             dbus.UInt64(value, variant_level=1))
989
 
    
990
 
    # Name - property
991
 
    @dbus_service_property(_interface, signature=u"s", access=u"read")
992
 
    def Name_dbus_property(self):
993
 
        return dbus.String(self.name)
994
 
    
995
 
    # Fingerprint - property
996
 
    @dbus_service_property(_interface, signature=u"s", access=u"read")
997
 
    def Fingerprint_dbus_property(self):
998
 
        return dbus.String(self.fingerprint)
999
 
    
1000
 
    # Host - property
1001
 
    @dbus_service_property(_interface, signature=u"s",
1002
 
                           access=u"readwrite")
1003
 
    def Host_dbus_property(self, value=None):
1004
 
        if value is None:       # get
1005
 
            return dbus.String(self.host)
1006
 
        self.host = value
1007
 
        # Emit D-Bus signal
1008
 
        self.PropertyChanged(dbus.String(u"Host"),
1009
 
                             dbus.String(value, variant_level=1))
1010
 
    
1011
 
    # Created - property
1012
 
    @dbus_service_property(_interface, signature=u"s", access=u"read")
1013
 
    def Created_dbus_property(self):
1014
 
        return dbus.String(self._datetime_to_dbus(self.created))
1015
 
    
1016
 
    # LastEnabled - property
1017
 
    @dbus_service_property(_interface, signature=u"s", access=u"read")
1018
 
    def LastEnabled_dbus_property(self):
1019
 
        if self.last_enabled is None:
1020
 
            return dbus.String(u"")
1021
 
        return dbus.String(self._datetime_to_dbus(self.last_enabled))
1022
 
    
1023
 
    # Enabled - property
1024
 
    @dbus_service_property(_interface, signature=u"b",
1025
 
                           access=u"readwrite")
1026
 
    def Enabled_dbus_property(self, value=None):
1027
 
        if value is None:       # get
1028
 
            return dbus.Boolean(self.enabled)
1029
 
        if value:
1030
 
            self.enable()
1031
 
        else:
1032
 
            self.disable()
1033
 
    
1034
 
    # LastCheckedOK - property
1035
 
    @dbus_service_property(_interface, signature=u"s",
1036
 
                           access=u"readwrite")
1037
 
    def LastCheckedOK_dbus_property(self, value=None):
1038
 
        if value is not None:
1039
 
            self.checked_ok()
1040
 
            return
1041
 
        if self.last_checked_ok is None:
1042
 
            return dbus.String(u"")
1043
 
        return dbus.String(self._datetime_to_dbus(self
1044
 
                                                  .last_checked_ok))
1045
 
    
1046
 
    # LastApprovalRequest - property
1047
 
    @dbus_service_property(_interface, signature=u"s", access=u"read")
1048
 
    def LastApprovalRequest_dbus_property(self):
1049
 
        if self.last_approval_request is None:
1050
 
            return dbus.String(u"")
1051
 
        return dbus.String(self.
1052
 
                           _datetime_to_dbus(self
1053
 
                                             .last_approval_request))
1054
 
    
1055
 
    # Timeout - property
1056
 
    @dbus_service_property(_interface, signature=u"t",
1057
 
                           access=u"readwrite")
1058
 
    def Timeout_dbus_property(self, value=None):
1059
 
        if value is None:       # get
1060
 
            return dbus.UInt64(self.timeout_milliseconds())
1061
 
        self.timeout = datetime.timedelta(0, 0, 0, value)
1062
 
        # Emit D-Bus signal
1063
 
        self.PropertyChanged(dbus.String(u"Timeout"),
1064
 
                             dbus.UInt64(value, variant_level=1))
1065
 
        if getattr(self, u"disable_initiator_tag", None) is None:
1066
 
            return
1067
 
        # Reschedule timeout
1068
 
        gobject.source_remove(self.disable_initiator_tag)
1069
 
        self.disable_initiator_tag = None
1070
 
        time_to_die = (self.
1071
 
                       _timedelta_to_milliseconds((self
1072
 
                                                   .last_checked_ok
1073
 
                                                   + self.timeout)
1074
 
                                                  - datetime.datetime
1075
 
                                                  .utcnow()))
1076
 
        if time_to_die <= 0:
1077
 
            # The timeout has passed
1078
 
            self.disable()
1079
 
        else:
1080
 
            self.disable_initiator_tag = (gobject.timeout_add
1081
 
                                          (time_to_die, self.disable))
1082
 
    
1083
 
    # Interval - property
1084
 
    @dbus_service_property(_interface, signature=u"t",
1085
 
                           access=u"readwrite")
1086
 
    def Interval_dbus_property(self, value=None):
1087
 
        if value is None:       # get
1088
 
            return dbus.UInt64(self.interval_milliseconds())
1089
 
        self.interval = datetime.timedelta(0, 0, 0, value)
1090
 
        # Emit D-Bus signal
1091
 
        self.PropertyChanged(dbus.String(u"Interval"),
1092
 
                             dbus.UInt64(value, variant_level=1))
1093
 
        if getattr(self, u"checker_initiator_tag", None) is None:
1094
 
            return
1095
 
        # Reschedule checker run
1096
 
        gobject.source_remove(self.checker_initiator_tag)
1097
 
        self.checker_initiator_tag = (gobject.timeout_add
1098
 
                                      (value, self.start_checker))
1099
 
        self.start_checker()    # Start one now, too
1100
 
 
1101
 
    # Checker - property
1102
 
    @dbus_service_property(_interface, signature=u"s",
1103
 
                           access=u"readwrite")
1104
 
    def Checker_dbus_property(self, value=None):
1105
 
        if value is None:       # get
1106
 
            return dbus.String(self.checker_command)
1107
 
        self.checker_command = value
1108
 
        # Emit D-Bus signal
1109
 
        self.PropertyChanged(dbus.String(u"Checker"),
1110
 
                             dbus.String(self.checker_command,
1111
 
                                         variant_level=1))
1112
 
    
1113
 
    # CheckerRunning - property
1114
 
    @dbus_service_property(_interface, signature=u"b",
1115
 
                           access=u"readwrite")
1116
 
    def CheckerRunning_dbus_property(self, value=None):
1117
 
        if value is None:       # get
1118
 
            return dbus.Boolean(self.checker is not None)
1119
 
        if value:
1120
 
            self.start_checker()
1121
 
        else:
1122
 
            self.stop_checker()
1123
 
    
1124
 
    # ObjectPath - property
1125
 
    @dbus_service_property(_interface, signature=u"o", access=u"read")
1126
 
    def ObjectPath_dbus_property(self):
1127
 
        return self.dbus_object_path # is already a dbus.ObjectPath
1128
 
    
1129
 
    # Secret = property
1130
 
    @dbus_service_property(_interface, signature=u"ay",
1131
 
                           access=u"write", byte_arrays=True)
1132
 
    def Secret_dbus_property(self, value):
1133
 
        self.secret = str(value)
1134
 
    
1135
744
    del _interface
1136
745
 
1137
746
 
1138
 
class ProxyClient(object):
1139
 
    def __init__(self, child_pipe, fpr, address):
1140
 
        self._pipe = child_pipe
1141
 
        self._pipe.send(('init', fpr, address))
1142
 
        if not self._pipe.recv():
1143
 
            raise KeyError()
1144
 
 
1145
 
    def __getattribute__(self, name):
1146
 
        if(name == '_pipe'):
1147
 
            return super(ProxyClient, self).__getattribute__(name)
1148
 
        self._pipe.send(('getattr', name))
1149
 
        data = self._pipe.recv()
1150
 
        if data[0] == 'data':
1151
 
            return data[1]
1152
 
        if data[0] == 'function':
1153
 
            def func(*args, **kwargs):
1154
 
                self._pipe.send(('funcall', name, args, kwargs))
1155
 
                return self._pipe.recv()[1]
1156
 
            return func
1157
 
 
1158
 
    def __setattr__(self, name, value):
1159
 
        if(name == '_pipe'):
1160
 
            return super(ProxyClient, self).__setattr__(name, value)
1161
 
        self._pipe.send(('setattr', name, value))
1162
 
 
1163
 
 
1164
747
class ClientHandler(socketserver.BaseRequestHandler, object):
1165
748
    """A class to handle client connections.
1166
749
    
1168
751
    Note: This will run in its own forked process."""
1169
752
    
1170
753
    def handle(self):
1171
 
        with contextlib.closing(self.server.child_pipe) as child_pipe:
1172
 
            logger.info(u"TCP connection from: %s",
1173
 
                        unicode(self.client_address))
1174
 
            logger.debug(u"Pipe FD: %d",
1175
 
                         self.server.child_pipe.fileno())
1176
 
 
 
754
        logger.info(u"TCP connection from: %s",
 
755
                    unicode(self.client_address))
 
756
        logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])
 
757
        # Open IPC pipe to parent process
 
758
        with closing(os.fdopen(self.server.pipe[1], u"w", 1)) as ipc:
1177
759
            session = (gnutls.connection
1178
760
                       .ClientSession(self.request,
1179
761
                                      gnutls.connection
1180
762
                                      .X509Credentials()))
1181
 
 
 
763
            
 
764
            line = self.request.makefile().readline()
 
765
            logger.debug(u"Protocol version: %r", line)
 
766
            try:
 
767
                if int(line.strip().split()[0]) > 1:
 
768
                    raise RuntimeError
 
769
            except (ValueError, IndexError, RuntimeError), error:
 
770
                logger.error(u"Unknown protocol version: %s", error)
 
771
                return
 
772
            
1182
773
            # Note: gnutls.connection.X509Credentials is really a
1183
774
            # generic GnuTLS certificate credentials object so long as
1184
775
            # no X.509 keys are added to it.  Therefore, we can use it
1185
776
            # here despite using OpenPGP certificates.
1186
 
 
 
777
            
1187
778
            #priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
1188
779
            #                      u"+AES-256-CBC", u"+SHA1",
1189
780
            #                      u"+COMP-NULL", u"+CTYPE-OPENPGP",
1195
786
            (gnutls.library.functions
1196
787
             .gnutls_priority_set_direct(session._c_object,
1197
788
                                         priority, None))
1198
 
 
1199
 
            # Start communication using the Mandos protocol
1200
 
            # Get protocol number
1201
 
            line = self.request.makefile().readline()
1202
 
            logger.debug(u"Protocol version: %r", line)
1203
 
            try:
1204
 
                if int(line.strip().split()[0]) > 1:
1205
 
                    raise RuntimeError
1206
 
            except (ValueError, IndexError, RuntimeError), error:
1207
 
                logger.error(u"Unknown protocol version: %s", error)
1208
 
                return
1209
 
 
1210
 
            # Start GnuTLS connection
 
789
            
1211
790
            try:
1212
791
                session.handshake()
1213
792
            except gnutls.errors.GNUTLSError, error:
1216
795
                # established.  Just abandon the request.
1217
796
                return
1218
797
            logger.debug(u"Handshake succeeded")
1219
 
 
1220
 
            approval_required = False
1221
798
            try:
1222
 
                try:
1223
 
                    fpr = self.fingerprint(self.peer_certificate
1224
 
                                           (session))
1225
 
                except (TypeError, gnutls.errors.GNUTLSError), error:
1226
 
                    logger.warning(u"Bad certificate: %s", error)
1227
 
                    return
1228
 
                logger.debug(u"Fingerprint: %s", fpr)
1229
 
 
1230
 
                try:
1231
 
                    client = ProxyClient(child_pipe, fpr,
1232
 
                                         self.client_address)
1233
 
                except KeyError:
1234
 
                    return
1235
 
                
1236
 
                if client.approval_delay:
1237
 
                    delay = client.approval_delay
1238
 
                    client.approvals_pending += 1
1239
 
                    approval_required = True
1240
 
                
1241
 
                while True:
1242
 
                    if not client.enabled:
1243
 
                        logger.warning(u"Client %s is disabled",
1244
 
                                       client.name)
1245
 
                        if self.server.use_dbus:
1246
 
                            # Emit D-Bus signal
1247
 
                            client.Rejected("Disabled")                    
1248
 
                        return
1249
 
                    
1250
 
                    if client._approved or not client.approval_delay:
1251
 
                        #We are approved or approval is disabled
1252
 
                        break
1253
 
                    elif client._approved is None:
1254
 
                        logger.info(u"Client %s needs approval",
1255
 
                                    client.name)
1256
 
                        if self.server.use_dbus:
1257
 
                            # Emit D-Bus signal
1258
 
                            client.NeedApproval(
1259
 
                                client.approval_delay_milliseconds(),
1260
 
                                client.approved_by_default)
1261
 
                    else:
1262
 
                        logger.warning(u"Client %s was not approved",
1263
 
                                       client.name)
1264
 
                        if self.server.use_dbus:
1265
 
                            # Emit D-Bus signal
1266
 
                            client.Rejected("Denied")
1267
 
                        return
1268
 
                    
1269
 
                    #wait until timeout or approved
1270
 
                    #x = float(client._timedelta_to_milliseconds(delay))
1271
 
                    time = datetime.datetime.now()
1272
 
                    client.changedstate.acquire()
1273
 
                    client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))
1274
 
                    client.changedstate.release()
1275
 
                    time2 = datetime.datetime.now()
1276
 
                    if (time2 - time) >= delay:
1277
 
                        if not client.approved_by_default:
1278
 
                            logger.warning("Client %s timed out while"
1279
 
                                           " waiting for approval",
1280
 
                                           client.name)
1281
 
                            if self.server.use_dbus:
1282
 
                                # Emit D-Bus signal
1283
 
                                client.Rejected("Approval timed out")
1284
 
                            return
1285
 
                        else:
1286
 
                            break
1287
 
                    else:
1288
 
                        delay -= time2 - time
1289
 
                
1290
 
                sent_size = 0
1291
 
                while sent_size < len(client.secret):
1292
 
                    try:
1293
 
                        sent = session.send(client.secret[sent_size:])
1294
 
                    except (gnutls.errors.GNUTLSError), error:
1295
 
                        logger.warning("gnutls send failed")
1296
 
                        return
1297
 
                    logger.debug(u"Sent: %d, remaining: %d",
1298
 
                                 sent, len(client.secret)
1299
 
                                 - (sent_size + sent))
1300
 
                    sent_size += sent
1301
 
 
1302
 
                logger.info(u"Sending secret to %s", client.name)
1303
 
                # bump the timeout as if seen
1304
 
                client.checked_ok()
1305
 
                if self.server.use_dbus:
1306
 
                    # Emit D-Bus signal
1307
 
                    client.GotSecret()
 
799
                fpr = self.fingerprint(self.peer_certificate(session))
 
800
            except (TypeError, gnutls.errors.GNUTLSError), error:
 
801
                logger.warning(u"Bad certificate: %s", error)
 
802
                session.bye()
 
803
                return
 
804
            logger.debug(u"Fingerprint: %s", fpr)
1308
805
            
1309
 
            finally:
1310
 
                if approval_required:
1311
 
                    client.approvals_pending -= 1
1312
 
                try:
1313
 
                    session.bye()
1314
 
                except (gnutls.errors.GNUTLSError), error:
1315
 
                    logger.warning("GnuTLS bye failed")
 
806
            for c in self.server.clients:
 
807
                if c.fingerprint == fpr:
 
808
                    client = c
 
809
                    break
 
810
            else:
 
811
                ipc.write(u"NOTFOUND %s\n" % fpr)
 
812
                session.bye()
 
813
                return
 
814
            # Have to check if client.still_valid(), since it is
 
815
            # possible that the client timed out while establishing
 
816
            # the GnuTLS session.
 
817
            if not client.still_valid():
 
818
                ipc.write(u"INVALID %s\n" % client.name)
 
819
                session.bye()
 
820
                return
 
821
            ipc.write(u"SENDING %s\n" % client.name)
 
822
            sent_size = 0
 
823
            while sent_size < len(client.secret):
 
824
                sent = session.send(client.secret[sent_size:])
 
825
                logger.debug(u"Sent: %d, remaining: %d",
 
826
                             sent, len(client.secret)
 
827
                             - (sent_size + sent))
 
828
                sent_size += sent
 
829
            session.bye()
1316
830
    
1317
831
    @staticmethod
1318
832
    def peer_certificate(session):
1378
892
        return hex_fpr
1379
893
 
1380
894
 
1381
 
class MultiprocessingMixIn(object):
1382
 
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
1383
 
    def sub_process_main(self, request, address):
1384
 
        try:
1385
 
            self.finish_request(request, address)
1386
 
        except:
1387
 
            self.handle_error(request, address)
1388
 
        self.close_request(request)
1389
 
            
1390
 
    def process_request(self, request, address):
1391
 
        """Start a new process to process the request."""
1392
 
        multiprocessing.Process(target = self.sub_process_main,
1393
 
                                args = (request, address)).start()
1394
 
 
1395
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1396
 
    """ adds a pipe to the MixIn """
 
895
class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):
 
896
    """Like socketserver.ForkingMixIn, but also pass a pipe."""
1397
897
    def process_request(self, request, client_address):
1398
898
        """Overrides and wraps the original process_request().
1399
899
        
1400
 
        This function creates a new pipe in self.pipe
 
900
        This function creates a new pipe in self.pipe 
1401
901
        """
1402
 
        parent_pipe, self.child_pipe = multiprocessing.Pipe()
1403
 
 
1404
 
        super(MultiprocessingMixInWithPipe,
 
902
        self.pipe = os.pipe()
 
903
        super(ForkingMixInWithPipe,
1405
904
              self).process_request(request, client_address)
1406
 
        self.child_pipe.close()
1407
 
        self.add_pipe(parent_pipe)
1408
 
 
1409
 
    def add_pipe(self, parent_pipe):
 
905
        os.close(self.pipe[1])  # close write end
 
906
        self.add_pipe(self.pipe[0])
 
907
    def add_pipe(self, pipe):
1410
908
        """Dummy function; override as necessary"""
1411
 
        pass
1412
 
 
1413
 
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
 
909
        os.close(pipe)
 
910
 
 
911
 
 
912
class IPv6_TCPServer(ForkingMixInWithPipe,
1414
913
                     socketserver.TCPServer, object):
1415
914
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
1416
915
    
1480
979
        clients:        set of Client objects
1481
980
        gnutls_priority GnuTLS priority string
1482
981
        use_dbus:       Boolean; to emit D-Bus signals or not
 
982
        clients:        set of Client objects
 
983
        gnutls_priority GnuTLS priority string
 
984
        use_dbus:       Boolean; to emit D-Bus signals or not
1483
985
    
1484
986
    Assumes a gobject.MainLoop event loop.
1485
987
    """
1488
990
                 gnutls_priority=None, use_dbus=True):
1489
991
        self.enabled = False
1490
992
        self.clients = clients
1491
 
        if self.clients is None:
1492
 
            self.clients = set()
1493
993
        self.use_dbus = use_dbus
1494
994
        self.gnutls_priority = gnutls_priority
1495
995
        IPv6_TCPServer.__init__(self, server_address,
1501
1001
            return socketserver.TCPServer.server_activate(self)
1502
1002
    def enable(self):
1503
1003
        self.enabled = True
1504
 
    def add_pipe(self, parent_pipe):
 
1004
    def add_pipe(self, pipe):
1505
1005
        # Call "handle_ipc" for both data and EOF events
1506
 
        gobject.io_add_watch(parent_pipe.fileno(),
1507
 
                             gobject.IO_IN | gobject.IO_HUP,
1508
 
                             functools.partial(self.handle_ipc,
1509
 
                                               parent_pipe = parent_pipe))
1510
 
        
1511
 
    def handle_ipc(self, source, condition, parent_pipe=None,
1512
 
                   client_object=None):
 
1006
        gobject.io_add_watch(pipe, gobject.IO_IN | gobject.IO_HUP,
 
1007
                             self.handle_ipc)
 
1008
    def handle_ipc(self, source, condition, file_objects={}):
1513
1009
        condition_names = {
1514
1010
            gobject.IO_IN: u"IN",   # There is data to read.
1515
1011
            gobject.IO_OUT: u"OUT", # Data can be written (without
1524
1020
                                       for cond, name in
1525
1021
                                       condition_names.iteritems()
1526
1022
                                       if cond & condition)
1527
 
        # error or the other end of multiprocessing.Pipe has closed
1528
 
        if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1529
 
            return False
1530
 
        
1531
 
        # Read a request from the child
1532
 
        request = parent_pipe.recv()
1533
 
        command = request[0]
1534
 
        
1535
 
        if command == 'init':
1536
 
            fpr = request[1]
1537
 
            address = request[2]
1538
 
            
1539
 
            for c in self.clients:
1540
 
                if c.fingerprint == fpr:
1541
 
                    client = c
1542
 
                    break
1543
 
            else:
1544
 
                logger.warning(u"Client not found for fingerprint: %s, ad"
1545
 
                               u"dress: %s", fpr, address)
1546
 
                if self.use_dbus:
1547
 
                    # Emit D-Bus signal
1548
 
                    mandos_dbus_service.ClientNotFound(fpr, address[0])
1549
 
                parent_pipe.send(False)
1550
 
                return False
1551
 
            
1552
 
            gobject.io_add_watch(parent_pipe.fileno(),
1553
 
                                 gobject.IO_IN | gobject.IO_HUP,
1554
 
                                 functools.partial(self.handle_ipc,
1555
 
                                                   parent_pipe = parent_pipe,
1556
 
                                                   client_object = client))
1557
 
            parent_pipe.send(True)
1558
 
            # remove the old hook in favor of the new above hook on same fileno
1559
 
            return False
1560
 
        if command == 'funcall':
1561
 
            funcname = request[1]
1562
 
            args = request[2]
1563
 
            kwargs = request[3]
1564
 
            
1565
 
            parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))
1566
 
 
1567
 
        if command == 'getattr':
1568
 
            attrname = request[1]
1569
 
            if callable(client_object.__getattribute__(attrname)):
1570
 
                parent_pipe.send(('function',))
1571
 
            else:
1572
 
                parent_pipe.send(('data', client_object.__getattribute__(attrname)))
1573
 
        
1574
 
        if command == 'setattr':
1575
 
            attrname = request[1]
1576
 
            value = request[2]
1577
 
            setattr(client_object, attrname, value)
1578
 
 
 
1023
        logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
 
1024
                     conditions_string)
 
1025
        
 
1026
        # Turn the pipe file descriptor into a Python file object
 
1027
        if source not in file_objects:
 
1028
            file_objects[source] = os.fdopen(source, u"r", 1)
 
1029
        
 
1030
        # Read a line from the file object
 
1031
        cmdline = file_objects[source].readline()
 
1032
        if not cmdline:             # Empty line means end of file
 
1033
            # close the IPC pipe
 
1034
            file_objects[source].close()
 
1035
            del file_objects[source]
 
1036
            
 
1037
            # Stop calling this function
 
1038
            return False
 
1039
        
 
1040
        logger.debug(u"IPC command: %r", cmdline)
 
1041
        
 
1042
        # Parse and act on command
 
1043
        cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)
 
1044
        
 
1045
        if cmd == u"NOTFOUND":
 
1046
            logger.warning(u"Client not found for fingerprint: %s",
 
1047
                           args)
 
1048
            if self.use_dbus:
 
1049
                # Emit D-Bus signal
 
1050
                mandos_dbus_service.ClientNotFound(args)
 
1051
        elif cmd == u"INVALID":
 
1052
            for client in self.clients:
 
1053
                if client.name == args:
 
1054
                    logger.warning(u"Client %s is invalid", args)
 
1055
                    if self.use_dbus:
 
1056
                        # Emit D-Bus signal
 
1057
                        client.Rejected()
 
1058
                    break
 
1059
            else:
 
1060
                logger.error(u"Unknown client %s is invalid", args)
 
1061
        elif cmd == u"SENDING":
 
1062
            for client in self.clients:
 
1063
                if client.name == args:
 
1064
                    logger.info(u"Sending secret to %s", client.name)
 
1065
                    client.checked_ok()
 
1066
                    if self.use_dbus:
 
1067
                        # Emit D-Bus signal
 
1068
                        client.ReceivedSecret()
 
1069
                    break
 
1070
            else:
 
1071
                logger.error(u"Sending secret to unknown client %s",
 
1072
                             args)
 
1073
        else:
 
1074
            logger.error(u"Unknown IPC command: %r", cmdline)
 
1075
        
 
1076
        # Keep calling this function
1579
1077
        return True
1580
1078
 
1581
1079
 
1611
1109
            elif suffix == u"w":
1612
1110
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1613
1111
            else:
1614
 
                raise ValueError(u"Unknown suffix %r" % suffix)
1615
 
        except (ValueError, IndexError), e:
1616
 
            raise ValueError(e.message)
 
1112
                raise ValueError
 
1113
        except (ValueError, IndexError):
 
1114
            raise ValueError
1617
1115
        timevalue += delta
1618
1116
    return timevalue
1619
1117
 
1632
1130
        def if_nametoindex(interface):
1633
1131
            "Get an interface index the hard way, i.e. using fcntl()"
1634
1132
            SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
1635
 
            with contextlib.closing(socket.socket()) as s:
 
1133
            with closing(socket.socket()) as s:
1636
1134
                ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1637
1135
                                    struct.pack(str(u"16s16x"),
1638
1136
                                                interface))
1658
1156
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1659
1157
        if not stat.S_ISCHR(os.fstat(null).st_mode):
1660
1158
            raise OSError(errno.ENODEV,
1661
 
                          u"%s not a character device"
1662
 
                          % os.path.devnull)
 
1159
                          u"/dev/null not a character device")
1663
1160
        os.dup2(null, sys.stdin.fileno())
1664
1161
        os.dup2(null, sys.stdout.fileno())
1665
1162
        os.dup2(null, sys.stderr.fileno())
1669
1166
 
1670
1167
def main():
1671
1168
    
1672
 
    ##################################################################
 
1169
    ######################################################################
1673
1170
    # Parsing of options, both command line and config file
1674
1171
    
1675
1172
    parser = optparse.OptionParser(version = "%%prog %s" % version)
1684
1181
    parser.add_option("--debug", action=u"store_true",
1685
1182
                      help=u"Debug mode; run in foreground and log to"
1686
1183
                      u" terminal")
1687
 
    parser.add_option("--debuglevel", type=u"string", metavar="LEVEL",
1688
 
                      help=u"Debug level for stdout output")
1689
1184
    parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1690
1185
                      u" priority string (see GnuTLS documentation)")
1691
1186
    parser.add_option("--servicename", type=u"string",
1716
1211
                        u"servicename": u"Mandos",
1717
1212
                        u"use_dbus": u"True",
1718
1213
                        u"use_ipv6": u"True",
1719
 
                        u"debuglevel": u"",
1720
1214
                        }
1721
1215
    
1722
1216
    # Parse config file for server-global settings
1739
1233
    # options, if set.
1740
1234
    for option in (u"interface", u"address", u"port", u"debug",
1741
1235
                   u"priority", u"servicename", u"configdir",
1742
 
                   u"use_dbus", u"use_ipv6", u"debuglevel"):
 
1236
                   u"use_dbus", u"use_ipv6"):
1743
1237
        value = getattr(options, option)
1744
1238
        if value is not None:
1745
1239
            server_settings[option] = value
1754
1248
    
1755
1249
    # For convenience
1756
1250
    debug = server_settings[u"debug"]
1757
 
    debuglevel = server_settings[u"debuglevel"]
1758
1251
    use_dbus = server_settings[u"use_dbus"]
1759
1252
    use_ipv6 = server_settings[u"use_ipv6"]
1760
 
 
 
1253
    
 
1254
    if not debug:
 
1255
        syslogger.setLevel(logging.WARNING)
 
1256
        console.setLevel(logging.WARNING)
 
1257
    
1761
1258
    if server_settings[u"servicename"] != u"Mandos":
1762
1259
        syslogger.setFormatter(logging.Formatter
1763
1260
                               (u'Mandos (%s) [%%(process)d]:'
1769
1266
                        u"interval": u"5m",
1770
1267
                        u"checker": u"fping -q -- %%(host)s",
1771
1268
                        u"host": u"",
1772
 
                        u"approval_delay": u"0s",
1773
 
                        u"approval_duration": u"1s",
1774
1269
                        }
1775
1270
    client_config = configparser.SafeConfigParser(client_defaults)
1776
1271
    client_config.read(os.path.join(server_settings[u"configdir"],
1779
1274
    global mandos_dbus_service
1780
1275
    mandos_dbus_service = None
1781
1276
    
 
1277
    clients = set()
1782
1278
    tcp_server = MandosServer((server_settings[u"address"],
1783
1279
                               server_settings[u"port"]),
1784
1280
                              ClientHandler,
1785
 
                              interface=(server_settings[u"interface"]
1786
 
                                         or None),
 
1281
                              interface=server_settings[u"interface"],
1787
1282
                              use_ipv6=use_ipv6,
 
1283
                              clients=clients,
1788
1284
                              gnutls_priority=
1789
1285
                              server_settings[u"priority"],
1790
1286
                              use_dbus=use_dbus)
1791
 
    if not debug:
1792
 
        pidfilename = u"/var/run/mandos.pid"
1793
 
        try:
1794
 
            pidfile = open(pidfilename, u"w")
1795
 
        except IOError:
1796
 
            logger.error(u"Could not open file %r", pidfilename)
 
1287
    pidfilename = u"/var/run/mandos.pid"
 
1288
    try:
 
1289
        pidfile = open(pidfilename, u"w")
 
1290
    except IOError:
 
1291
        logger.error(u"Could not open file %r", pidfilename)
1797
1292
    
1798
1293
    try:
1799
1294
        uid = pwd.getpwnam(u"_mandos").pw_uid
1816
1311
        if error[0] != errno.EPERM:
1817
1312
            raise error
1818
1313
    
1819
 
    if not debug and not debuglevel:
1820
 
        syslogger.setLevel(logging.WARNING)
1821
 
        console.setLevel(logging.WARNING)
1822
 
    if debuglevel:
1823
 
        level = getattr(logging, debuglevel.upper())
1824
 
        syslogger.setLevel(level)
1825
 
        console.setLevel(level)
1826
 
 
 
1314
    # Enable all possible GnuTLS debugging
1827
1315
    if debug:
1828
 
        # Enable all possible GnuTLS debugging
1829
 
        
1830
1316
        # "Use a log level over 10 to enable all debugging options."
1831
1317
        # - GnuTLS manual
1832
1318
        gnutls.library.functions.gnutls_global_set_log_level(11)
1837
1323
        
1838
1324
        (gnutls.library.functions
1839
1325
         .gnutls_global_set_log_function(debug_gnutls))
1840
 
        
1841
 
        # Redirect stdin so all checkers get /dev/null
1842
 
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1843
 
        os.dup2(null, sys.stdin.fileno())
1844
 
        if null > 2:
1845
 
            os.close(null)
1846
 
    else:
1847
 
        # No console logging
1848
 
        logger.removeHandler(console)
1849
 
    
1850
 
    # Need to fork before connecting to D-Bus
1851
 
    if not debug:
1852
 
        # Close all input and output, do double fork, etc.
1853
 
        daemon()
1854
1326
    
1855
1327
    global main_loop
1856
1328
    # From the Avahi example code
1859
1331
    bus = dbus.SystemBus()
1860
1332
    # End of Avahi example code
1861
1333
    if use_dbus:
1862
 
        try:
1863
 
            bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
1864
 
                                            bus, do_not_queue=True)
1865
 
        except dbus.exceptions.NameExistsException, e:
1866
 
            logger.error(unicode(e) + u", disabling D-Bus")
1867
 
            use_dbus = False
1868
 
            server_settings[u"use_dbus"] = False
1869
 
            tcp_server.use_dbus = False
 
1334
        bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
1870
1335
    protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1871
1336
    service = AvahiService(name = server_settings[u"servicename"],
1872
1337
                           servicetype = u"_mandos._tcp",
1875
1340
        service.interface = (if_nametoindex
1876
1341
                             (str(server_settings[u"interface"])))
1877
1342
    
1878
 
    global multiprocessing_manager
1879
 
    multiprocessing_manager = multiprocessing.Manager()
1880
 
    
1881
1343
    client_class = Client
1882
1344
    if use_dbus:
1883
1345
        client_class = functools.partial(ClientDBus, bus = bus)
1884
 
    def client_config_items(config, section):
1885
 
        special_settings = {
1886
 
            "approved_by_default":
1887
 
                lambda: config.getboolean(section,
1888
 
                                          "approved_by_default"),
1889
 
            }
1890
 
        for name, value in config.items(section):
1891
 
            try:
1892
 
                yield (name, special_settings[name]())
1893
 
            except KeyError:
1894
 
                yield (name, value)
1895
 
    
1896
 
    tcp_server.clients.update(set(
 
1346
    clients.update(set(
1897
1347
            client_class(name = section,
1898
 
                         config= dict(client_config_items(
1899
 
                        client_config, section)))
 
1348
                         config= dict(client_config.items(section)))
1900
1349
            for section in client_config.sections()))
1901
 
    if not tcp_server.clients:
 
1350
    if not clients:
1902
1351
        logger.warning(u"No clients defined")
 
1352
    
 
1353
    if debug:
 
1354
        # Redirect stdin so all checkers get /dev/null
 
1355
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
 
1356
        os.dup2(null, sys.stdin.fileno())
 
1357
        if null > 2:
 
1358
            os.close(null)
 
1359
    else:
 
1360
        # No console logging
 
1361
        logger.removeHandler(console)
 
1362
        # Close all input and output, do double fork, etc.
 
1363
        daemon()
 
1364
    
 
1365
    try:
 
1366
        with closing(pidfile):
 
1367
            pid = os.getpid()
 
1368
            pidfile.write(str(pid) + "\n")
 
1369
        del pidfile
 
1370
    except IOError:
 
1371
        logger.error(u"Could not write to file %r with PID %d",
 
1372
                     pidfilename, pid)
 
1373
    except NameError:
 
1374
        # "pidfile" was never created
 
1375
        pass
 
1376
    del pidfilename
 
1377
    
 
1378
    def cleanup():
 
1379
        "Cleanup function; run on exit"
 
1380
        service.cleanup()
1903
1381
        
 
1382
        while clients:
 
1383
            client = clients.pop()
 
1384
            client.disable_hook = None
 
1385
            client.disable()
 
1386
    
 
1387
    atexit.register(cleanup)
 
1388
    
1904
1389
    if not debug:
1905
 
        try:
1906
 
            with pidfile:
1907
 
                pid = os.getpid()
1908
 
                pidfile.write(str(pid) + "\n")
1909
 
            del pidfile
1910
 
        except IOError:
1911
 
            logger.error(u"Could not write to file %r with PID %d",
1912
 
                         pidfilename, pid)
1913
 
        except NameError:
1914
 
            # "pidfile" was never created
1915
 
            pass
1916
 
        del pidfilename
1917
 
        
1918
1390
        signal.signal(signal.SIGINT, signal.SIG_IGN)
1919
 
 
1920
1391
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1921
1392
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1922
1393
    
1927
1398
                dbus.service.Object.__init__(self, bus, u"/")
1928
1399
            _interface = u"se.bsnet.fukt.Mandos"
1929
1400
            
1930
 
            @dbus.service.signal(_interface, signature=u"o")
1931
 
            def ClientAdded(self, objpath):
 
1401
            @dbus.service.signal(_interface, signature=u"oa{sv}")
 
1402
            def ClientAdded(self, objpath, properties):
1932
1403
                "D-Bus signal"
1933
1404
                pass
1934
1405
            
1935
 
            @dbus.service.signal(_interface, signature=u"ss")
1936
 
            def ClientNotFound(self, fingerprint, address):
 
1406
            @dbus.service.signal(_interface, signature=u"s")
 
1407
            def ClientNotFound(self, fingerprint):
1937
1408
                "D-Bus signal"
1938
1409
                pass
1939
1410
            
1945
1416
            @dbus.service.method(_interface, out_signature=u"ao")
1946
1417
            def GetAllClients(self):
1947
1418
                "D-Bus method"
1948
 
                return dbus.Array(c.dbus_object_path
1949
 
                                  for c in tcp_server.clients)
 
1419
                return dbus.Array(c.dbus_object_path for c in clients)
1950
1420
            
1951
1421
            @dbus.service.method(_interface,
1952
1422
                                 out_signature=u"a{oa{sv}}")
1953
1423
            def GetAllClientsWithProperties(self):
1954
1424
                "D-Bus method"
1955
1425
                return dbus.Dictionary(
1956
 
                    ((c.dbus_object_path, c.GetAll(u""))
1957
 
                     for c in tcp_server.clients),
 
1426
                    ((c.dbus_object_path, c.GetAllProperties())
 
1427
                     for c in clients),
1958
1428
                    signature=u"oa{sv}")
1959
1429
            
1960
1430
            @dbus.service.method(_interface, in_signature=u"o")
1961
1431
            def RemoveClient(self, object_path):
1962
1432
                "D-Bus method"
1963
 
                for c in tcp_server.clients:
 
1433
                for c in clients:
1964
1434
                    if c.dbus_object_path == object_path:
1965
 
                        tcp_server.clients.remove(c)
 
1435
                        clients.remove(c)
1966
1436
                        c.remove_from_connection()
1967
1437
                        # Don't signal anything except ClientRemoved
1968
 
                        c.disable(quiet=True)
 
1438
                        c.disable(signal=False)
1969
1439
                        # Emit D-Bus signal
1970
1440
                        self.ClientRemoved(object_path, c.name)
1971
1441
                        return
1972
 
                raise KeyError(object_path)
 
1442
                raise KeyError
1973
1443
            
1974
1444
            del _interface
1975
1445
        
1976
1446
        mandos_dbus_service = MandosDBusService()
1977
1447
    
1978
 
    def cleanup():
1979
 
        "Cleanup function; run on exit"
1980
 
        service.cleanup()
1981
 
        
1982
 
        while tcp_server.clients:
1983
 
            client = tcp_server.clients.pop()
1984
 
            if use_dbus:
1985
 
                client.remove_from_connection()
1986
 
            client.disable_hook = None
1987
 
            # Don't signal anything except ClientRemoved
1988
 
            client.disable(quiet=True)
1989
 
            if use_dbus:
1990
 
                # Emit D-Bus signal
1991
 
                mandos_dbus_service.ClientRemoved(client.dbus_object_path,
1992
 
                                                  client.name)
1993
 
    
1994
 
    atexit.register(cleanup)
1995
 
    
1996
 
    for client in tcp_server.clients:
 
1448
    for client in clients:
1997
1449
        if use_dbus:
1998
1450
            # Emit D-Bus signal
1999
 
            mandos_dbus_service.ClientAdded(client.dbus_object_path)
 
1451
            mandos_dbus_service.ClientAdded(client.dbus_object_path,
 
1452
                                            client.GetAllProperties())
2000
1453
        client.enable()
2001
1454
    
2002
1455
    tcp_server.enable()
2020
1473
            service.activate()
2021
1474
        except dbus.exceptions.DBusException, error:
2022
1475
            logger.critical(u"DBusException: %s", error)
2023
 
            cleanup()
2024
1476
            sys.exit(1)
2025
1477
        # End of Avahi example code
2026
1478
        
2033
1485
        main_loop.run()
2034
1486
    except AvahiError, error:
2035
1487
        logger.critical(u"AvahiError: %s", error)
2036
 
        cleanup()
2037
1488
        sys.exit(1)
2038
1489
    except KeyboardInterrupt:
2039
1490
        if debug:
2040
1491
            print >> sys.stderr
2041
1492
        logger.debug(u"Server received KeyboardInterrupt")
2042
1493
    logger.debug(u"Server exiting")
2043
 
    # Must run before the D-Bus bus name gets deregistered
2044
 
    cleanup()
2045
1494
 
2046
1495
if __name__ == '__main__':
2047
1496
    main()