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
- browse files at revision 524
- compare with another revision
- download diff
- download tarball
- view history from revision 524
- Committer: Björn Påhlsson
- Date: 2011-12-21 00:29:33 UTC
- mfrom: (518.1.15 mandos-persistent)
- Revision ID: belorn@recompile.se-20111221002933-6sc0a64o1ns2s2s8
Working persistant state
- files removed:
- debian/mandos-client.examples
- network-hooks.d
- files modified:
- .bzrignore
added
removed
mandos
11
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2008-2014 Teddy Hogeborn
15
# Copyright © 2008-2014 Björn Påhlsson
14
# Copyright © 2008-2011 Teddy Hogeborn
15
# Copyright © 2008-2011 Björn Påhlsson
16
16
#
17
17
# This program is free software: you can redistribute it and/or modify
18
18
# it under the terms of the GNU General Public License as published by
34
34
from __future__ import (division, absolute_import, print_function,
35
35
unicode_literals)
36
36
37
from future_builtins import *
38
39
37
import SocketServer as socketserver
40
38
import socket
41
39
import argparse
67
65
import types
68
66
import binascii
69
67
import tempfile
70
import itertools
71
import collections
72
68
73
69
import dbus
74
70
import dbus.service
79
75
import ctypes.util
80
76
import xml.dom.minidom
81
77
import inspect
78
import GnuPGInterface
82
79
83
80
try:
84
81
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
88
85
except ImportError:
89
86
SO_BINDTODEVICE = None
90
87
91
version = "1.6.4"
88
version = "1.4.1"
92
89
stored_state_file = "clients.pickle"
93
90
94
91
logger = logging.getLogger()
95
syslogger = None
92
syslogger = (logging.handlers.SysLogHandler
93
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
94
address = str("/dev/log")))
96
95
97
96
try:
98
97
if_nametoindex = (ctypes.cdll.LoadLibrary
111
110
return interface_index
112
111
113
112
114
def initlogger(debug, level=logging.WARNING):
113
def initlogger(level=logging.WARNING):
115
114
"""init logger and add loglevel"""
116
115
117
syslogger = (logging.handlers.SysLogHandler
118
(facility =
119
logging.handlers.SysLogHandler.LOG_DAEMON,
120
address = str("/dev/log")))
121
116
syslogger.setFormatter(logging.Formatter
122
117
('Mandos [%(process)d]: %(levelname)s:'
123
118
' %(message)s'))
124
119
logger.addHandler(syslogger)
125
120
126
if debug:
127
console = logging.StreamHandler()
128
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
129
' [%(process)d]:'
130
' %(levelname)s:'
131
' %(message)s'))
132
logger.addHandler(console)
121
console = logging.StreamHandler()
122
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
123
' [%(process)d]:'
124
' %(levelname)s:'
125
' %(message)s'))
126
logger.addHandler(console)
133
127
logger.setLevel(level)
134
128
135
129
141
135
class PGPEngine(object):
142
136
"""A simple class for OpenPGP symmetric encryption & decryption"""
143
137
def __init__(self):
138
self.gnupg = GnuPGInterface.GnuPG()
144
139
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
145
self.gnupgargs = ['--batch',
146
'--home', self.tempdir,
147
'--force-mdc',
148
'--quiet',
149
'--no-use-agent']
140
self.gnupg = GnuPGInterface.GnuPG()
141
self.gnupg.options.meta_interactive = False
142
self.gnupg.options.homedir = self.tempdir
143
self.gnupg.options.extra_args.extend(['--force-mdc',
144
'--quiet'])
150
145
151
146
def __enter__(self):
152
147
return self
153
148
154
def __exit__(self, exc_type, exc_value, traceback):
149
def __exit__ (self, exc_type, exc_value, traceback):
155
150
self._cleanup()
156
151
return False
157
152
174
169
def password_encode(self, password):
175
170
# Passphrase can not be empty and can not contain newlines or
176
171
# NUL bytes. So we prefix it and hex encode it.
177
encoded = b"mandos" + binascii.hexlify(password)
178
if len(encoded) > 2048:
179
# GnuPG can't handle long passwords, so encode differently
180
encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
181
.replace(b"\n", b"\\n")
182
.replace(b"\0", b"\\x00"))
183
return encoded
172
return b"mandos" + binascii.hexlify(password)
184
173
185
174
def encrypt(self, data, password):
186
passphrase = self.password_encode(password)
187
with tempfile.NamedTemporaryFile(dir=self.tempdir
188
) as passfile:
189
passfile.write(passphrase)
190
passfile.flush()
191
proc = subprocess.Popen(['gpg', '--symmetric',
192
'--passphrase-file',
193
passfile.name]
194
+ self.gnupgargs,
195
stdin = subprocess.PIPE,
196
stdout = subprocess.PIPE,
197
stderr = subprocess.PIPE)
198
ciphertext, err = proc.communicate(input = data)
199
if proc.returncode != 0:
200
raise PGPError(err)
175
self.gnupg.passphrase = self.password_encode(password)
176
with open(os.devnull) as devnull:
177
try:
178
proc = self.gnupg.run(['--symmetric'],
179
create_fhs=['stdin', 'stdout'],
180
attach_fhs={'stderr': devnull})
181
with contextlib.closing(proc.handles['stdin']) as f:
182
f.write(data)
183
with contextlib.closing(proc.handles['stdout']) as f:
184
ciphertext = f.read()
185
proc.wait()
186
except IOError as e:
187
raise PGPError(e)
188
self.gnupg.passphrase = None
201
189
return ciphertext
202
190
203
191
def decrypt(self, data, password):
204
passphrase = self.password_encode(password)
205
with tempfile.NamedTemporaryFile(dir = self.tempdir
206
) as passfile:
207
passfile.write(passphrase)
208
passfile.flush()
209
proc = subprocess.Popen(['gpg', '--decrypt',
210
'--passphrase-file',
211
passfile.name]
212
+ self.gnupgargs,
213
stdin = subprocess.PIPE,
214
stdout = subprocess.PIPE,
215
stderr = subprocess.PIPE)
216
decrypted_plaintext, err = proc.communicate(input
217
= data)
218
if proc.returncode != 0:
219
raise PGPError(err)
192
self.gnupg.passphrase = self.password_encode(password)
193
with open(os.devnull) as devnull:
194
try:
195
proc = self.gnupg.run(['--decrypt'],
196
create_fhs=['stdin', 'stdout'],
197
attach_fhs={'stderr': devnull})
198
with contextlib.closing(proc.handles['stdin'] ) as f:
199
f.write(data)
200
with contextlib.closing(proc.handles['stdout']) as f:
201
decrypted_plaintext = f.read()
202
proc.wait()
203
except IOError as e:
204
raise PGPError(e)
205
self.gnupg.passphrase = None
220
206
return decrypted_plaintext
221
207
222
208
209
223
210
class AvahiError(Exception):
224
211
def __init__(self, value, *args, **kwargs):
225
212
self.value = value
242
229
Used to optionally bind to the specified interface.
243
230
name: string; Example: 'Mandos'
244
231
type: string; Example: '_mandos._tcp'.
245
See <https://www.iana.org/assignments/service-names-port-numbers>
232
See <http://www.dns-sd.org/ServiceTypes.html>
246
233
port: integer; what port to announce
247
234
TXT: list of strings; TXT record for the service
248
235
domain: string; Domain to publish on, default to .local if empty.
254
241
server: D-Bus Server
255
242
bus: dbus.SystemBus()
256
243
"""
257
258
244
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
259
245
servicetype = None, port = None, TXT = None,
260
246
domain = "", host = "", max_renames = 32768,
273
259
self.server = None
274
260
self.bus = bus
275
261
self.entry_group_state_changed_match = None
276
277
262
def rename(self):
278
263
"""Derived from the Avahi example code"""
279
264
if self.rename_count >= self.max_renames:
289
274
try:
290
275
self.add()
291
276
except dbus.exceptions.DBusException as error:
292
logger.critical("D-Bus Exception", exc_info=error)
277
logger.critical("DBusException: %s", error)
293
278
self.cleanup()
294
279
os._exit(1)
295
280
self.rename_count += 1
296
297
281
def remove(self):
298
282
"""Derived from the Avahi example code"""
299
283
if self.entry_group_state_changed_match is not None:
301
285
self.entry_group_state_changed_match = None
302
286
if self.group is not None:
303
287
self.group.Reset()
304
305
288
def add(self):
306
289
"""Derived from the Avahi example code"""
307
290
self.remove()
324
307
dbus.UInt16(self.port),
325
308
avahi.string_array_to_txt_array(self.TXT))
326
309
self.group.Commit()
327
328
310
def entry_group_state_changed(self, state, error):
329
311
"""Derived from the Avahi example code"""
330
312
logger.debug("Avahi entry group state change: %i", state)
337
319
elif state == avahi.ENTRY_GROUP_FAILURE:
338
320
logger.critical("Avahi: Error in group state changed %s",
339
321
unicode(error))
340
raise AvahiGroupError("State changed: {0!s}"
341
.format(error))
342
322
raise AvahiGroupError("State changed: %s"
323
% unicode(error))
343
324
def cleanup(self):
344
325
"""Derived from the Avahi example code"""
345
326
if self.group is not None:
350
331
pass
351
332
self.group = None
352
333
self.remove()
353
354
334
def server_state_changed(self, state, error=None):
355
335
"""Derived from the Avahi example code"""
356
336
logger.debug("Avahi server state change: %i", state)
375
355
logger.debug("Unknown state: %r", state)
376
356
else:
377
357
logger.debug("Unknown state: %r: %r", state, error)
378
379
358
def activate(self):
380
359
"""Derived from the Avahi example code"""
381
360
if self.server is None:
388
367
self.server_state_changed)
389
368
self.server_state_changed(self.server.GetState())
390
369
391
392
370
class AvahiServiceToSyslog(AvahiService):
393
371
def rename(self):
394
372
"""Add the new name to the syslog messages"""
395
373
ret = AvahiService.rename(self)
396
374
syslogger.setFormatter(logging.Formatter
397
('Mandos ({0}) [%(process)d]:'
398
' %(levelname)s: %(message)s'
399
.format(self.name)))
375
('Mandos (%s) [%%(process)d]:'
376
' %%(levelname)s: %%(message)s'
377
% self.name))
400
378
return ret
401
379
402
403
380
def timedelta_to_milliseconds(td):
404
381
"Convert a datetime.timedelta() to milliseconds"
405
382
return ((td.days * 24 * 60 * 60 * 1000)
406
383
+ (td.seconds * 1000)
407
384
+ (td.microseconds // 1000))
408
409
385
410
386
class Client(object):
411
387
"""A representation of a client host served by this server.
412
388
437
413
last_checked_ok: datetime.datetime(); (UTC) or None
438
414
last_checker_status: integer between 0 and 255 reflecting exit
439
415
status of last checker. -1 reflects crashed
440
checker, -2 means no checker completed yet.
416
checker, or None.
441
417
last_enabled: datetime.datetime(); (UTC) or None
442
418
name: string; from the config file, used in log messages and
443
419
D-Bus identifiers
444
420
secret: bytestring; sent verbatim (over TLS) to client
445
421
timeout: datetime.timedelta(); How long from last_checked_ok
446
422
until this client is disabled
447
extended_timeout: extra long timeout when secret has been sent
423
extended_timeout: extra long timeout when password has been sent
448
424
runtime_expansions: Allowed attributes for runtime expansion.
449
425
expires: datetime.datetime(); time (UTC) when a client will be
450
426
disabled, or None
451
server_settings: The server_settings dict from main()
452
427
"""
453
428
454
429
runtime_expansions = ("approval_delay", "approval_duration",
455
"created", "enabled", "expires",
456
"fingerprint", "host", "interval",
457
"last_approval_request", "last_checked_ok",
430
"created", "enabled", "fingerprint",
431
"host", "interval", "last_checked_ok",
458
432
"last_enabled", "name", "timeout")
459
client_defaults = { "timeout": "PT5M",
460
"extended_timeout": "PT15M",
461
"interval": "PT2M",
433
client_defaults = { "timeout": "5m",
434
"extended_timeout": "15m",
435
"interval": "2m",
462
436
"checker": "fping -q -- %%(host)s",
463
437
"host": "",
464
"approval_delay": "PT0S",
465
"approval_duration": "PT1S",
438
"approval_delay": "0s",
439
"approval_duration": "1s",
466
440
"approved_by_default": "True",
467
441
"enabled": "True",
468
442
}
481
455
482
456
def approval_delay_milliseconds(self):
483
457
return timedelta_to_milliseconds(self.approval_delay)
484
458
485
459
@staticmethod
486
460
def config_parser(config):
487
"""Construct a new dict of client settings of this form:
461
""" Construct a new dict of client settings of this form:
488
462
{ client_name: {setting_name: value, ...}, ...}
489
with exceptions for any special settings as defined above.
490
NOTE: Must be a pure function. Must return the same result
491
value given the same arguments.
492
"""
463
with exceptions for any special settings as defined above"""
493
464
settings = {}
494
465
for client_name in config.sections():
495
466
section = dict(config.items(client_name))
499
470
# Reformat values from string types to Python types
500
471
client["approved_by_default"] = config.getboolean(
501
472
client_name, "approved_by_default")
502
client["enabled"] = config.getboolean(client_name,
503
"enabled")
473
client["enabled"] = config.getboolean(client_name, "enabled")
504
474
505
475
client["fingerprint"] = (section["fingerprint"].upper()
506
476
.replace(" ", ""))
512
482
"rb") as secfile:
513
483
client["secret"] = secfile.read()
514
484
else:
515
raise TypeError("No secret or secfile for section {0}"
516
.format(section))
485
raise TypeError("No secret or secfile for section %s"
486
% section)
517
487
client["timeout"] = string_to_delta(section["timeout"])
518
488
client["extended_timeout"] = string_to_delta(
519
489
section["extended_timeout"])
525
495
client["checker_command"] = section["checker"]
526
496
client["last_approval_request"] = None
527
497
client["last_checked_ok"] = None
528
client["last_checker_status"] = -2
529
498
client["last_checker_status"] = None
499
if client["enabled"]:
500
client["last_enabled"] = datetime.datetime.utcnow()
501
client["expires"] = (datetime.datetime.utcnow()
502
+ client["timeout"])
503
else:
504
client["last_enabled"] = None
505
client["expires"] = None
506
530
507
return settings
531
532
def __init__(self, settings, name = None, server_settings=None):
508
509
510
def __init__(self, settings, name = None):
511
"""Note: the 'checker' key in 'config' sets the
512
'checker_command' attribute and *not* the 'checker'
513
attribute."""
533
514
self.name = name
534
if server_settings is None:
535
server_settings = {}
536
self.server_settings = server_settings
537
515
# adding all client settings
538
516
for setting, value in settings.iteritems():
539
517
setattr(self, setting, value)
540
518
541
if self.enabled:
542
if not hasattr(self, "last_enabled"):
543
self.last_enabled = datetime.datetime.utcnow()
544
if not hasattr(self, "expires"):
545
self.expires = (datetime.datetime.utcnow()
546
+ self.timeout)
547
else:
548
self.last_enabled = None
549
self.expires = None
550
551
519
logger.debug("Creating client %r", self.name)
552
520
# Uppercase and remove spaces from fingerprint for later
553
521
# comparison purposes with return value from the fingerprint()
554
522
# function
555
523
logger.debug(" Fingerprint: %s", self.fingerprint)
556
self.created = settings.get("created",
557
datetime.datetime.utcnow())
558
524
self.created = settings.get("created", datetime.datetime.utcnow())
525
559
526
# attributes specific for this server instance
560
527
self.checker = None
561
528
self.checker_initiator_tag = None
589
556
if getattr(self, "enabled", False):
590
557
# Already enabled
591
558
return
559
self.send_changedstate()
592
560
self.expires = datetime.datetime.utcnow() + self.timeout
593
561
self.enabled = True
594
562
self.last_enabled = datetime.datetime.utcnow()
595
563
self.init_checker()
596
self.send_changedstate()
597
564
598
565
def disable(self, quiet=True):
599
566
"""Disable this client."""
600
567
if not getattr(self, "enabled", False):
601
568
return False
602
569
if not quiet:
570
self.send_changedstate()
571
if not quiet:
603
572
logger.info("Disabling client %s", self.name)
604
if getattr(self, "disable_initiator_tag", None) is not None:
573
if getattr(self, "disable_initiator_tag", False):
605
574
gobject.source_remove(self.disable_initiator_tag)
606
575
self.disable_initiator_tag = None
607
576
self.expires = None
608
if getattr(self, "checker_initiator_tag", None) is not None:
577
if getattr(self, "checker_initiator_tag", False):
609
578
gobject.source_remove(self.checker_initiator_tag)
610
579
self.checker_initiator_tag = None
611
580
self.stop_checker()
612
581
self.enabled = False
613
if not quiet:
614
self.send_changedstate()
615
582
# Do not run this again if called by a gobject.timeout_add
616
583
return False
617
584
621
588
def init_checker(self):
622
589
# Schedule a new checker to be started an 'interval' from now,
623
590
# and every interval from then on.
624
if self.checker_initiator_tag is not None:
625
gobject.source_remove(self.checker_initiator_tag)
626
591
self.checker_initiator_tag = (gobject.timeout_add
627
592
(self.interval_milliseconds(),
628
593
self.start_checker))
629
594
# Schedule a disable() when 'timeout' has passed
630
if self.disable_initiator_tag is not None:
631
gobject.source_remove(self.disable_initiator_tag)
632
595
self.disable_initiator_tag = (gobject.timeout_add
633
596
(self.timeout_milliseconds(),
634
597
self.disable))
653
616
logger.warning("Checker for %(name)s crashed?",
654
617
vars(self))
655
618
656
def checked_ok(self):
657
"""Assert that the client has been seen, alive and well."""
658
self.last_checked_ok = datetime.datetime.utcnow()
659
self.last_checker_status = 0
660
self.bump_timeout()
661
662
def bump_timeout(self, timeout=None):
663
"""Bump up the timeout for this client."""
619
def checked_ok(self, timeout=None):
620
"""Bump up the timeout for this client.
621
622
This should only be called when the client has been seen,
623
alive and well.
624
"""
664
625
if timeout is None:
665
626
timeout = self.timeout
627
self.last_checked_ok = datetime.datetime.utcnow()
666
628
if self.disable_initiator_tag is not None:
667
629
gobject.source_remove(self.disable_initiator_tag)
668
self.disable_initiator_tag = None
669
630
if getattr(self, "enabled", False):
670
631
self.disable_initiator_tag = (gobject.timeout_add
671
632
(timedelta_to_milliseconds
681
642
If a checker already exists, leave it running and do
682
643
nothing."""
683
644
# The reason for not killing a running checker is that if we
684
# did that, and if a checker (for some reason) started running
685
# slowly and taking more than 'interval' time, then the client
686
# would inevitably timeout, since no checker would get a
687
# chance to run to completion. If we instead leave running
645
# did that, then if a checker (for some reason) started
646
# running slowly and taking more than 'interval' time, the
647
# client would inevitably timeout, since no checker would get
648
# a chance to run to completion. If we instead leave running
688
649
# checkers alone, the checker would have to take more time
689
650
# than 'timeout' for the client to be disabled, which is as it
690
651
# should be.
692
653
# If a checker exists, make sure it is not a zombie
693
654
try:
694
655
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
695
except AttributeError:
696
pass
697
except OSError as error:
698
if error.errno != errno.ECHILD:
699
raise
656
except (AttributeError, OSError) as error:
657
if (isinstance(error, OSError)
658
and error.errno != errno.ECHILD):
659
raise error
700
660
else:
701
661
if pid:
702
662
logger.warning("Checker was a zombie")
705
665
self.current_checker_command)
706
666
# Start a new checker if needed
707
667
if self.checker is None:
708
# Escape attributes for the shell
709
escaped_attrs = dict(
710
(attr, re.escape(unicode(getattr(self, attr))))
711
for attr in
712
self.runtime_expansions)
713
668
try:
714
command = self.checker_command % escaped_attrs
715
except TypeError as error:
716
logger.error('Could not format string "%s"',
717
self.checker_command, exc_info=error)
718
return True # Try again later
669
# In case checker_command has exactly one % operator
670
command = self.checker_command % self.host
671
except TypeError:
672
# Escape attributes for the shell
673
escaped_attrs = dict(
674
(attr,
675
re.escape(unicode(str(getattr(self, attr, "")),
676
errors=
677
'replace')))
678
for attr in
679
self.runtime_expansions)
680
681
try:
682
command = self.checker_command % escaped_attrs
683
except TypeError as error:
684
logger.error('Could not format string "%s":'
685
' %s', self.checker_command, error)
686
return True # Try again later
719
687
self.current_checker_command = command
720
688
try:
721
689
logger.info("Starting checker %r for %s",
724
692
# in normal mode, that is already done by daemon(),
725
693
# and in debug mode we don't want to. (Stdin is
726
694
# always replaced by /dev/null.)
727
# The exception is when not debugging but nevertheless
728
# running in the foreground; use the previously
729
# created wnull.
730
popen_args = {}
731
if (not self.server_settings["debug"]
732
and self.server_settings["foreground"]):
733
popen_args.update({"stdout": wnull,
734
"stderr": wnull })
735
695
self.checker = subprocess.Popen(command,
736
696
close_fds=True,
737
shell=True, cwd="/",
738
**popen_args)
739
except OSError as error:
740
logger.error("Failed to start subprocess",
741
exc_info=error)
742
return True
743
self.checker_callback_tag = (gobject.child_watch_add
744
(self.checker.pid,
745
self.checker_callback,
746
data=command))
747
# The checker may have completed before the gobject
748
# watch was added. Check for this.
749
try:
697
shell=True, cwd="/")
698
self.checker_callback_tag = (gobject.child_watch_add
699
(self.checker.pid,
700
self.checker_callback,
701
data=command))
702
# The checker may have completed before the gobject
703
# watch was added. Check for this.
750
704
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
705
if pid:
706
gobject.source_remove(self.checker_callback_tag)
707
self.checker_callback(pid, status, command)
751
708
except OSError as error:
752
if error.errno == errno.ECHILD:
753
# This should never happen
754
logger.error("Child process vanished",
755
exc_info=error)
756
return True
757
raise
758
if pid:
759
gobject.source_remove(self.checker_callback_tag)
760
self.checker_callback(pid, status, command)
709
logger.error("Failed to start subprocess: %s",
710
error)
761
711
# Re-run this periodically if run by gobject.timeout_add
762
712
return True
763
713
770
720
return
771
721
logger.debug("Stopping checker for %(name)s", vars(self))
772
722
try:
773
self.checker.terminate()
723
os.kill(self.checker.pid, signal.SIGTERM)
774
724
#time.sleep(0.5)
775
725
#if self.checker.poll() is None:
776
# self.checker.kill()
726
# os.kill(self.checker.pid, signal.SIGKILL)
777
727
except OSError as error:
778
728
if error.errno != errno.ESRCH: # No such process
779
729
raise
796
746
# "Set" method, so we fail early here:
797
747
if byte_arrays and signature != "ay":
798
748
raise ValueError("Byte arrays not supported for non-'ay'"
799
" signature {0!r}".format(signature))
749
" signature %r" % signature)
800
750
def decorator(func):
801
751
func._dbus_is_property = True
802
752
func._dbus_interface = dbus_interface
810
760
return decorator
811
761
812
762
813
def dbus_interface_annotations(dbus_interface):
814
"""Decorator for marking functions returning interface annotations
815
816
Usage:
817
818
@dbus_interface_annotations("org.example.Interface")
819
def _foo(self): # Function name does not matter
820
return {"org.freedesktop.DBus.Deprecated": "true",
821
"org.freedesktop.DBus.Property.EmitsChangedSignal":
822
"false"}
823
"""
824
def decorator(func):
825
func._dbus_is_interface = True
826
func._dbus_interface = dbus_interface
827
func._dbus_name = dbus_interface
828
return func
829
return decorator
830
831
832
def dbus_annotations(annotations):
833
"""Decorator to annotate D-Bus methods, signals or properties
834
Usage:
835
836
@dbus_service_property("org.example.Interface", signature="b",
837
access="r")
838
@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
839
"org.freedesktop.DBus.Property."
840
"EmitsChangedSignal": "false"})
841
def Property_dbus_property(self):
842
return dbus.Boolean(False)
843
"""
844
def decorator(func):
845
func._dbus_annotations = annotations
846
return func
847
return decorator
848
849
850
763
class DBusPropertyException(dbus.exceptions.DBusException):
851
764
"""A base class for D-Bus property-related exceptions
852
765
"""
875
788
"""
876
789
877
790
@staticmethod
878
def _is_dbus_thing(thing):
879
"""Returns a function testing if an attribute is a D-Bus thing
880
881
If called like _is_dbus_thing("method") it returns a function
882
suitable for use as predicate to inspect.getmembers().
883
"""
884
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
885
False)
791
def _is_dbus_property(obj):
792
return getattr(obj, "_dbus_is_property", False)
886
793
887
def _get_all_dbus_things(self, thing):
794
def _get_all_dbus_properties(self):
888
795
"""Returns a generator of (name, attribute) pairs
889
796
"""
890
return ((getattr(athing.__get__(self), "_dbus_name",
891
name),
892
athing.__get__(self))
797
return ((prop.__get__(self)._dbus_name, prop.__get__(self))
893
798
for cls in self.__class__.__mro__
894
for name, athing in
895
inspect.getmembers(cls,
896
self._is_dbus_thing(thing)))
799
for name, prop in
800
inspect.getmembers(cls, self._is_dbus_property))
897
801
898
802
def _get_dbus_property(self, interface_name, property_name):
899
803
"""Returns a bound method if one exists which is a D-Bus
901
805
"""
902
806
for cls in self.__class__.__mro__:
903
807
for name, value in (inspect.getmembers
904
(cls,
905
self._is_dbus_thing("property"))):
808
(cls, self._is_dbus_property)):
906
809
if (value._dbus_name == property_name
907
810
and value._dbus_interface == interface_name):
908
811
return value.__get__(self)
936
839
# The byte_arrays option is not supported yet on
937
840
# signatures other than "ay".
938
841
if prop._dbus_signature != "ay":
939
raise ValueError("Byte arrays not supported for non-"
940
"'ay' signature {0!r}"
941
.format(prop._dbus_signature))
942
value = dbus.ByteArray(b''.join(chr(byte)
943
for byte in value))
842
raise ValueError
843
value = dbus.ByteArray(''.join(unichr(byte)
844
for byte in value))
944
845
prop(value)
945
846
946
847
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
952
853
Note: Will not include properties with access="write".
953
854
"""
954
855
properties = {}
955
for name, prop in self._get_all_dbus_things("property"):
856
for name, prop in self._get_all_dbus_properties():
956
857
if (interface_name
957
858
and interface_name != prop._dbus_interface):
958
859
# Interface non-empty but did not match
973
874
path_keyword='object_path',
974
875
connection_keyword='connection')
975
876
def Introspect(self, object_path, connection):
976
"""Overloading of standard D-Bus method.
977
978
Inserts property tags and interface annotation tags.
877
"""Standard D-Bus method, overloaded to insert property tags.
979
878
"""
980
879
xmlstring = dbus.service.Object.Introspect(self, object_path,
981
880
connection)
988
887
e.setAttribute("access", prop._dbus_access)
989
888
return e
990
889
for if_tag in document.getElementsByTagName("interface"):
991
# Add property tags
992
890
for tag in (make_tag(document, name, prop)
993
891
for name, prop
994
in self._get_all_dbus_things("property")
892
in self._get_all_dbus_properties()
995
893
if prop._dbus_interface
996
894
== if_tag.getAttribute("name")):
997
895
if_tag.appendChild(tag)
998
# Add annotation tags
999
for typ in ("method", "signal", "property"):
1000
for tag in if_tag.getElementsByTagName(typ):
1001
annots = dict()
1002
for name, prop in (self.
1003
_get_all_dbus_things(typ)):
1004
if (name == tag.getAttribute("name")
1005
and prop._dbus_interface
1006
== if_tag.getAttribute("name")):
1007
annots.update(getattr
1008
(prop,
1009
"_dbus_annotations",
1010
{}))
1011
for name, value in annots.iteritems():
1012
ann_tag = document.createElement(
1013
"annotation")
1014
ann_tag.setAttribute("name", name)
1015
ann_tag.setAttribute("value", value)
1016
tag.appendChild(ann_tag)
1017
# Add interface annotation tags
1018
for annotation, value in dict(
1019
itertools.chain.from_iterable(
1020
annotations().iteritems()
1021
for name, annotations in
1022
self._get_all_dbus_things("interface")
1023
if name == if_tag.getAttribute("name")
1024
)).iteritems():
1025
ann_tag = document.createElement("annotation")
1026
ann_tag.setAttribute("name", annotation)
1027
ann_tag.setAttribute("value", value)
1028
if_tag.appendChild(ann_tag)
1029
896
# Add the names to the return values for the
1030
897
# "org.freedesktop.DBus.Properties" methods
1031
898
if (if_tag.getAttribute("name")
1046
913
except (AttributeError, xml.dom.DOMException,
1047
914
xml.parsers.expat.ExpatError) as error:
1048
915
logger.error("Failed to override Introspection method",
1049
exc_info=error)
916
error)
1050
917
return xmlstring
1051
918
1052
919
1053
def datetime_to_dbus(dt, variant_level=0):
920
def datetime_to_dbus (dt, variant_level=0):
1054
921
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1055
922
if dt is None:
1056
923
return dbus.String("", variant_level = variant_level)
1058
925
variant_level=variant_level)
1059
926
1060
927
1061
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1062
"""A class decorator; applied to a subclass of
1063
dbus.service.Object, it will add alternate D-Bus attributes with
1064
interface names according to the "alt_interface_names" mapping.
1065
Usage:
1066
1067
@alternate_dbus_interfaces({"org.example.Interface":
1068
"net.example.AlternateInterface"})
1069
class SampleDBusObject(dbus.service.Object):
1070
@dbus.service.method("org.example.Interface")
1071
def SampleDBusMethod():
1072
pass
1073
1074
The above "SampleDBusMethod" on "SampleDBusObject" will be
1075
reachable via two interfaces: "org.example.Interface" and
1076
"net.example.AlternateInterface", the latter of which will have
1077
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1078
"true", unless "deprecate" is passed with a False value.
1079
1080
This works for methods and signals, and also for D-Bus properties
1081
(from DBusObjectWithProperties) and interfaces (from the
1082
dbus_interface_annotations decorator).
928
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
929
.__metaclass__):
930
"""Applied to an empty subclass of a D-Bus object, this metaclass
931
will add additional D-Bus attributes matching a certain pattern.
1083
932
"""
1084
def wrapper(cls):
1085
for orig_interface_name, alt_interface_name in (
1086
alt_interface_names.iteritems()):
1087
attr = {}
1088
interface_names = set()
1089
# Go though all attributes of the class
1090
for attrname, attribute in inspect.getmembers(cls):
933
def __new__(mcs, name, bases, attr):
934
# Go through all the base classes which could have D-Bus
935
# methods, signals, or properties in them
936
for base in (b for b in bases
937
if issubclass(b, dbus.service.Object)):
938
# Go though all attributes of the base class
939
for attrname, attribute in inspect.getmembers(base):
1091
940
# Ignore non-D-Bus attributes, and D-Bus attributes
1092
941
# with the wrong interface name
1093
942
if (not hasattr(attribute, "_dbus_interface")
1094
943
or not attribute._dbus_interface
1095
.startswith(orig_interface_name)):
944
.startswith("se.recompile.Mandos")):
1096
945
continue
1097
946
# Create an alternate D-Bus interface name based on
1098
947
# the current name
1099
948
alt_interface = (attribute._dbus_interface
1100
.replace(orig_interface_name,
1101
alt_interface_name))
1102
interface_names.add(alt_interface)
949
.replace("se.recompile.Mandos",
950
"se.bsnet.fukt.Mandos"))
1103
951
# Is this a D-Bus signal?
1104
952
if getattr(attribute, "_dbus_is_signal", False):
1105
# Extract the original non-method undecorated
1106
# function by black magic
953
# Extract the original non-method function by
954
# black magic
1107
955
nonmethod_func = (dict(
1108
956
zip(attribute.func_code.co_freevars,
1109
957
attribute.__closure__))["func"]
1120
968
nonmethod_func.func_name,
1121
969
nonmethod_func.func_defaults,
1122
970
nonmethod_func.func_closure)))
1123
# Copy annotations, if any
1124
try:
1125
new_function._dbus_annotations = (
1126
dict(attribute._dbus_annotations))
1127
except AttributeError:
1128
pass
1129
971
# Define a creator of a function to call both the
1130
# original and alternate functions, so both the
1131
# original and alternate signals gets sent when
1132
# the function is called
972
# old and new functions, so both the old and new
973
# signals gets sent when the function is called
1133
974
def fixscope(func1, func2):
1134
975
"""This function is a scope container to pass
1135
976
func1 and func2 to the "call_both" function
1142
983
return call_both
1143
984
# Create the "call_both" function and add it to
1144
985
# the class
1145
attr[attrname] = fixscope(attribute, new_function)
986
attr[attrname] = fixscope(attribute,
987
new_function)
1146
988
# Is this a D-Bus method?
1147
989
elif getattr(attribute, "_dbus_is_method", False):
1148
990
# Create a new, but exactly alike, function
1159
1001
attribute.func_name,
1160
1002
attribute.func_defaults,
1161
1003
attribute.func_closure)))
1162
# Copy annotations, if any
1163
try:
1164
attr[attrname]._dbus_annotations = (
1165
dict(attribute._dbus_annotations))
1166
except AttributeError:
1167
pass
1168
1004
# Is this a D-Bus property?
1169
1005
elif getattr(attribute, "_dbus_is_property", False):
1170
1006
# Create a new, but exactly alike, function
1184
1020
attribute.func_name,
1185
1021
attribute.func_defaults,
1186
1022
attribute.func_closure)))
1187
# Copy annotations, if any
1188
try:
1189
attr[attrname]._dbus_annotations = (
1190
dict(attribute._dbus_annotations))
1191
except AttributeError:
1192
pass
1193
# Is this a D-Bus interface?
1194
elif getattr(attribute, "_dbus_is_interface", False):
1195
# Create a new, but exactly alike, function
1196
# object. Decorate it to be a new D-Bus interface
1197
# with the alternate D-Bus interface name. Add it
1198
# to the class.
1199
attr[attrname] = (dbus_interface_annotations
1200
(alt_interface)
1201
(types.FunctionType
1202
(attribute.func_code,
1203
attribute.func_globals,
1204
attribute.func_name,
1205
attribute.func_defaults,
1206
attribute.func_closure)))
1207
if deprecate:
1208
# Deprecate all alternate interfaces
1209
iname="_AlternateDBusNames_interface_annotation{0}"
1210
for interface_name in interface_names:
1211
@dbus_interface_annotations(interface_name)
1212
def func(self):
1213
return { "org.freedesktop.DBus.Deprecated":
1214
"true" }
1215
# Find an unused name
1216
for aname in (iname.format(i)
1217
for i in itertools.count()):
1218
if aname not in attr:
1219
attr[aname] = func
1220
break
1221
if interface_names:
1222
# Replace the class with a new subclass of it with
1223
# methods, signals, etc. as created above.
1224
cls = type(b"{0}Alternate".format(cls.__name__),
1225
(cls,), attr)
1226
return cls
1227
return wrapper
1228
1229
1230
@alternate_dbus_interfaces({"se.recompile.Mandos":
1231
"se.bsnet.fukt.Mandos"})
1023
return type.__new__(mcs, name, bases, attr)
1024
1025
1232
1026
class ClientDBus(Client, DBusObjectWithProperties):
1233
1027
"""A Client class using D-Bus
1234
1028
1245
1039
def __init__(self, bus = None, *args, **kwargs):
1246
1040
self.bus = bus
1247
1041
Client.__init__(self, *args, **kwargs)
1042
self._approvals_pending = 0
1043
1044
self._approvals_pending = 0
1248
1045
# Only now, when this client is initialized, can it show up on
1249
1046
# the D-Bus
1250
1047
client_object_name = unicode(self.name).translate(
1254
1051
("/clients/" + client_object_name))
1255
1052
DBusObjectWithProperties.__init__(self, self.bus,
1256
1053
self.dbus_object_path)
1257
1054
1258
1055
def notifychangeproperty(transform_func,
1259
1056
dbus_name, type_func=lambda x: x,
1260
1057
variant_level=1):
1283
1080
1284
1081
return property(lambda self: getattr(self, attrname), setter)
1285
1082
1083
1286
1084
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1287
1085
approvals_pending = notifychangeproperty(dbus.Boolean,
1288
1086
"ApprovalPending",
1295
1093
checker is not None)
1296
1094
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1297
1095
"LastCheckedOK")
1298
last_checker_status = notifychangeproperty(dbus.Int16,
1299
"LastCheckerStatus")
1300
1096
last_approval_request = notifychangeproperty(
1301
1097
datetime_to_dbus, "LastApprovalRequest")
1302
1098
approved_by_default = notifychangeproperty(dbus.Boolean,
1370
1166
return False
1371
1167
1372
1168
def approve(self, value=True):
1169
self.send_changedstate()
1373
1170
self.approved = value
1374
1171
gobject.timeout_add(timedelta_to_milliseconds
1375
1172
(self.approval_duration),
1376
1173
self._reset_approved)
1377
self.send_changedstate()
1174
1378
1175
1379
1176
## D-Bus methods, signals & properties
1380
1177
_interface = "se.recompile.Mandos.Client"
1381
1178
1382
## Interfaces
1383
1384
@dbus_interface_annotations(_interface)
1385
def _foo(self):
1386
return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
1387
"false"}
1388
1389
1179
## Signals
1390
1180
1391
1181
# CheckerCompleted - signal
1427
1217
"D-Bus signal"
1428
1218
return self.need_approval()
1429
1219
1220
# NeRwequest - signal
1221
@dbus.service.signal(_interface, signature="s")
1222
def NewRequest(self, ip):
1223
"""D-Bus signal
1224
Is sent after a client request a password.
1225
"""
1226
pass
1227
1430
1228
## Methods
1431
1229
1432
1230
# Approve - method
1542
1340
return
1543
1341
return datetime_to_dbus(self.last_checked_ok)
1544
1342
1545
# LastCheckerStatus - property
1546
@dbus_service_property(_interface, signature="n",
1547
access="read")
1548
def LastCheckerStatus_dbus_property(self):
1549
return dbus.Int16(self.last_checker_status)
1550
1551
1343
# Expires - property
1552
1344
@dbus_service_property(_interface, signature="s", access="read")
1553
1345
def Expires_dbus_property(self):
1564
1356
def Timeout_dbus_property(self, value=None):
1565
1357
if value is None: # get
1566
1358
return dbus.UInt64(self.timeout_milliseconds())
1567
old_timeout = self.timeout
1568
1359
self.timeout = datetime.timedelta(0, 0, 0, value)
1569
# Reschedule disabling
1570
if self.enabled:
1571
now = datetime.datetime.utcnow()
1572
self.expires += self.timeout - old_timeout
1573
if self.expires <= now:
1574
# The timeout has passed
1575
self.disable()
1576
else:
1577
if (getattr(self, "disable_initiator_tag", None)
1578
is None):
1579
return
1580
gobject.source_remove(self.disable_initiator_tag)
1581
self.disable_initiator_tag = (
1582
gobject.timeout_add(
1583
timedelta_to_milliseconds(self.expires - now),
1584
self.disable))
1360
if getattr(self, "disable_initiator_tag", None) is None:
1361
return
1362
# Reschedule timeout
1363
gobject.source_remove(self.disable_initiator_tag)
1364
self.disable_initiator_tag = None
1365
self.expires = None
1366
time_to_die = timedelta_to_milliseconds((self
1367
.last_checked_ok
1368
+ self.timeout)
1369
- datetime.datetime
1370
.utcnow())
1371
if time_to_die <= 0:
1372
# The timeout has passed
1373
self.disable()
1374
else:
1375
self.expires = (datetime.datetime.utcnow()
1376
+ datetime.timedelta(milliseconds =
1377
time_to_die))
1378
self.disable_initiator_tag = (gobject.timeout_add
1379
(time_to_die, self.disable))
1585
1380
1586
1381
# ExtendedTimeout - property
1587
1382
@dbus_service_property(_interface, signature="t",
1666
1461
self._pipe.send(('setattr', name, value))
1667
1462
1668
1463
1464
class ClientDBusTransitional(ClientDBus):
1465
__metaclass__ = AlternateDBusNamesMetaclass
1466
1467
1669
1468
class ClientHandler(socketserver.BaseRequestHandler, object):
1670
1469
"""A class to handle client connections.
1671
1470
1707
1506
logger.debug("Protocol version: %r", line)
1708
1507
try:
1709
1508
if int(line.strip().split()[0]) > 1:
1710
raise RuntimeError(line)
1509
raise RuntimeError
1711
1510
except (ValueError, IndexError, RuntimeError) as error:
1712
1511
logger.error("Unknown protocol version: %s", error)
1713
1512
return
1739
1538
except KeyError:
1740
1539
return
1741
1540
1541
if self.server.use_dbus:
1542
# Emit D-Bus signal
1543
client.NewRequest(str(self.client_address))
1544
1742
1545
if client.approval_delay:
1743
1546
delay = client.approval_delay
1744
1547
client.approvals_pending += 1
1775
1578
#wait until timeout or approved
1776
1579
time = datetime.datetime.now()
1777
1580
client.changedstate.acquire()
1778
client.changedstate.wait(
1779
float(timedelta_to_milliseconds(delay)
1780
/ 1000))
1581
(client.changedstate.wait
1582
(float(client.timedelta_to_milliseconds(delay)
1583
/ 1000)))
1781
1584
client.changedstate.release()
1782
1585
time2 = datetime.datetime.now()
1783
1586
if (time2 - time) >= delay:
1799
1602
try:
1800
1603
sent = session.send(client.secret[sent_size:])
1801
1604
except gnutls.errors.GNUTLSError as error:
1802
logger.warning("gnutls send failed",
1803
exc_info=error)
1605
logger.warning("gnutls send failed")
1804
1606
return
1805
1607
logger.debug("Sent: %d, remaining: %d",
1806
1608
sent, len(client.secret)
1809
1611
1810
1612
logger.info("Sending secret to %s", client.name)
1811
1613
# bump the timeout using extended_timeout
1812
client.bump_timeout(client.extended_timeout)
1614
client.checked_ok(client.extended_timeout)
1813
1615
if self.server.use_dbus:
1814
1616
# Emit D-Bus signal
1815
1617
client.GotSecret()
1820
1622
try:
1821
1623
session.bye()
1822
1624
except gnutls.errors.GNUTLSError as error:
1823
logger.warning("GnuTLS bye failed",
1824
exc_info=error)
1625
logger.warning("GnuTLS bye failed")
1825
1626
1826
1627
@staticmethod
1827
1628
def peer_certificate(session):
1899
1700
def process_request(self, request, address):
1900
1701
"""Start a new process to process the request."""
1901
1702
proc = multiprocessing.Process(target = self.sub_process_main,
1902
args = (request, address))
1703
args = (request,
1704
address))
1903
1705
proc.start()
1904
1706
return proc
1905
1707
1920
1722
1921
1723
def add_pipe(self, parent_pipe, proc):
1922
1724
"""Dummy function; override as necessary"""
1923
raise NotImplementedError()
1725
raise NotImplementedError
1924
1726
1925
1727
1926
1728
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1933
1735
use_ipv6: Boolean; to use IPv6 or not
1934
1736
"""
1935
1737
def __init__(self, server_address, RequestHandlerClass,
1936
interface=None, use_ipv6=True, socketfd=None):
1937
"""If socketfd is set, use that file descriptor instead of
1938
creating a new one with socket.socket().
1939
"""
1738
interface=None, use_ipv6=True):
1940
1739
self.interface = interface
1941
1740
if use_ipv6:
1942
1741
self.address_family = socket.AF_INET6
1943
if socketfd is not None:
1944
# Save the file descriptor
1945
self.socketfd = socketfd
1946
# Save the original socket.socket() function
1947
self.socket_socket = socket.socket
1948
# To implement --socket, we monkey patch socket.socket.
1949
#
1950
# (When socketserver.TCPServer is a new-style class, we
1951
# could make self.socket into a property instead of monkey
1952
# patching socket.socket.)
1953
#
1954
# Create a one-time-only replacement for socket.socket()
1955
@functools.wraps(socket.socket)
1956
def socket_wrapper(*args, **kwargs):
1957
# Restore original function so subsequent calls are
1958
# not affected.
1959
socket.socket = self.socket_socket
1960
del self.socket_socket
1961
# This time only, return a new socket object from the
1962
# saved file descriptor.
1963
return socket.fromfd(self.socketfd, *args, **kwargs)
1964
# Replace socket.socket() function with wrapper
1965
socket.socket = socket_wrapper
1966
# The socketserver.TCPServer.__init__ will call
1967
# socket.socket(), which might be our replacement,
1968
# socket_wrapper(), if socketfd was set.
1969
1742
socketserver.TCPServer.__init__(self, server_address,
1970
1743
RequestHandlerClass)
1971
1972
1744
def server_bind(self):
1973
1745
"""This overrides the normal server_bind() function
1974
1746
to bind to an interface if one was specified, and also NOT to
1982
1754
try:
1983
1755
self.socket.setsockopt(socket.SOL_SOCKET,
1984
1756
SO_BINDTODEVICE,
1985
str(self.interface + '\0'))
1757
str(self.interface
1758
+ '\0'))
1986
1759
except socket.error as error:
1987
if error.errno == errno.EPERM:
1988
logger.error("No permission to bind to"
1989
" interface %s", self.interface)
1990
elif error.errno == errno.ENOPROTOOPT:
1760
if error[0] == errno.EPERM:
1761
logger.error("No permission to"
1762
" bind to interface %s",
1763
self.interface)
1764
elif error[0] == errno.ENOPROTOOPT:
1991
1765
logger.error("SO_BINDTODEVICE not available;"
1992
1766
" cannot bind to interface %s",
1993
1767
self.interface)
1994
elif error.errno == errno.ENODEV:
1995
logger.error("Interface %s does not exist,"
1996
" cannot bind", self.interface)
1997
1768
else:
1998
1769
raise
1999
1770
# Only bind(2) the socket if we really need to.
2002
1773
if self.address_family == socket.AF_INET6:
2003
1774
any_address = "::" # in6addr_any
2004
1775
else:
2005
any_address = "0.0.0.0" # INADDR_ANY
1776
any_address = socket.INADDR_ANY
2006
1777
self.server_address = (any_address,
2007
1778
self.server_address[1])
2008
1779
elif not self.server_address[1]:
2029
1800
"""
2030
1801
def __init__(self, server_address, RequestHandlerClass,
2031
1802
interface=None, use_ipv6=True, clients=None,
2032
gnutls_priority=None, use_dbus=True, socketfd=None):
1803
gnutls_priority=None, use_dbus=True):
2033
1804
self.enabled = False
2034
1805
self.clients = clients
2035
1806
if self.clients is None:
2039
1810
IPv6_TCPServer.__init__(self, server_address,
2040
1811
RequestHandlerClass,
2041
1812
interface = interface,
2042
use_ipv6 = use_ipv6,
2043
socketfd = socketfd)
1813
use_ipv6 = use_ipv6)
2044
1814
def server_activate(self):
2045
1815
if self.enabled:
2046
1816
return socketserver.TCPServer.server_activate(self)
2059
1829
2060
1830
def handle_ipc(self, source, condition, parent_pipe=None,
2061
1831
proc = None, client_object=None):
1832
condition_names = {
1833
gobject.IO_IN: "IN", # There is data to read.
1834
gobject.IO_OUT: "OUT", # Data can be written (without
1835
# blocking).
1836
gobject.IO_PRI: "PRI", # There is urgent data to read.
1837
gobject.IO_ERR: "ERR", # Error condition.
1838
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1839
# broken, usually for pipes and
1840
# sockets).
1841
}
1842
conditions_string = ' | '.join(name
1843
for cond, name in
1844
condition_names.iteritems()
1845
if cond & condition)
2062
1846
# error, or the other end of multiprocessing.Pipe has closed
2063
if condition & (gobject.IO_ERR | gobject.IO_HUP):
1847
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
2064
1848
# Wait for other process to exit
2065
1849
proc.join()
2066
1850
return False
2124
1908
return True
2125
1909
2126
1910
2127
def rfc3339_duration_to_delta(duration):
2128
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2129
2130
>>> rfc3339_duration_to_delta("P7D")
2131
datetime.timedelta(7)
2132
>>> rfc3339_duration_to_delta("PT60S")
2133
datetime.timedelta(0, 60)
2134
>>> rfc3339_duration_to_delta("PT60M")
2135
datetime.timedelta(0, 3600)
2136
>>> rfc3339_duration_to_delta("PT24H")
2137
datetime.timedelta(1)
2138
>>> rfc3339_duration_to_delta("P1W")
2139
datetime.timedelta(7)
2140
>>> rfc3339_duration_to_delta("PT5M30S")
2141
datetime.timedelta(0, 330)
2142
>>> rfc3339_duration_to_delta("P1DT3M20S")
2143
datetime.timedelta(1, 200)
2144
"""
2145
2146
# Parsing an RFC 3339 duration with regular expressions is not
2147
# possible - there would have to be multiple places for the same
2148
# values, like seconds. The current code, while more esoteric, is
2149
# cleaner without depending on a parsing library. If Python had a
2150
# built-in library for parsing we would use it, but we'd like to
2151
# avoid excessive use of external libraries.
2152
2153
# New type for defining tokens, syntax, and semantics all-in-one
2154
Token = collections.namedtuple("Token",
2155
("regexp", # To match token; if
2156
# "value" is not None,
2157
# must have a "group"
2158
# containing digits
2159
"value", # datetime.timedelta or
2160
# None
2161
"followers")) # Tokens valid after
2162
# this token
2163
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2164
# the "duration" ABNF definition in RFC 3339, Appendix A.
2165
token_end = Token(re.compile(r"$"), None, frozenset())
2166
token_second = Token(re.compile(r"(\d+)S"),
2167
datetime.timedelta(seconds=1),
2168
frozenset((token_end,)))
2169
token_minute = Token(re.compile(r"(\d+)M"),
2170
datetime.timedelta(minutes=1),
2171
frozenset((token_second, token_end)))
2172
token_hour = Token(re.compile(r"(\d+)H"),
2173
datetime.timedelta(hours=1),
2174
frozenset((token_minute, token_end)))
2175
token_time = Token(re.compile(r"T"),
2176
None,
2177
frozenset((token_hour, token_minute,
2178
token_second)))
2179
token_day = Token(re.compile(r"(\d+)D"),
2180
datetime.timedelta(days=1),
2181
frozenset((token_time, token_end)))
2182
token_month = Token(re.compile(r"(\d+)M"),
2183
datetime.timedelta(weeks=4),
2184
frozenset((token_day, token_end)))
2185
token_year = Token(re.compile(r"(\d+)Y"),
2186
datetime.timedelta(weeks=52),
2187
frozenset((token_month, token_end)))
2188
token_week = Token(re.compile(r"(\d+)W"),
2189
datetime.timedelta(weeks=1),
2190
frozenset((token_end,)))
2191
token_duration = Token(re.compile(r"P"), None,
2192
frozenset((token_year, token_month,
2193
token_day, token_time,
2194
token_week))),
2195
# Define starting values
2196
value = datetime.timedelta() # Value so far
2197
found_token = None
2198
followers = frozenset(token_duration,) # Following valid tokens
2199
s = duration # String left to parse
2200
# Loop until end token is found
2201
while found_token is not token_end:
2202
# Search for any currently valid tokens
2203
for token in followers:
2204
match = token.regexp.match(s)
2205
if match is not None:
2206
# Token found
2207
if token.value is not None:
2208
# Value found, parse digits
2209
factor = int(match.group(1), 10)
2210
# Add to value so far
2211
value += factor * token.value
2212
# Strip token from string
2213
s = token.regexp.sub("", s, 1)
2214
# Go to found token
2215
found_token = token
2216
# Set valid next tokens
2217
followers = found_token.followers
2218
break
2219
else:
2220
# No currently valid tokens were found
2221
raise ValueError("Invalid RFC 3339 duration")
2222
# End token found
2223
return value
2224
2225
2226
1911
def string_to_delta(interval):
2227
1912
"""Parse a string and return a datetime.timedelta
2228
1913
2239
1924
>>> string_to_delta('5m 30s')
2240
1925
datetime.timedelta(0, 330)
2241
1926
"""
2242
2243
try:
2244
return rfc3339_duration_to_delta(interval)
2245
except ValueError:
2246
pass
2247
2248
1927
timevalue = datetime.timedelta(0)
2249
1928
for s in interval.split():
2250
1929
try:
2261
1940
elif suffix == "w":
2262
1941
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2263
1942
else:
2264
raise ValueError("Unknown suffix {0!r}"
2265
.format(suffix))
2266
except IndexError as e:
1943
raise ValueError("Unknown suffix %r" % suffix)
1944
except (ValueError, IndexError) as e:
2267
1945
raise ValueError(*(e.args))
2268
1946
timevalue += delta
2269
1947
return timevalue
2282
1960
sys.exit()
2283
1961
if not noclose:
2284
1962
# Close all standard open file descriptors
2285
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1963
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2286
1964
if not stat.S_ISCHR(os.fstat(null).st_mode):
2287
1965
raise OSError(errno.ENODEV,
2288
"{0} not a character device"
2289
.format(os.devnull))
1966
"%s not a character device"
1967
% os.path.devnull)
2290
1968
os.dup2(null, sys.stdin.fileno())
2291
1969
os.dup2(null, sys.stdout.fileno())
2292
1970
os.dup2(null, sys.stderr.fileno())
2301
1979
2302
1980
parser = argparse.ArgumentParser()
2303
1981
parser.add_argument("-v", "--version", action="version",
2304
version = "%(prog)s {0}".format(version),
1982
version = "%%(prog)s %s" % version,
2305
1983
help="show version number and exit")
2306
1984
parser.add_argument("-i", "--interface", metavar="IF",
2307
1985
help="Bind to interface IF")
2313
1991
help="Run self-test")
2314
1992
parser.add_argument("--debug", action="store_true",
2315
1993
help="Debug mode; run in foreground and log"
2316
" to terminal", default=None)
1994
" to terminal")
2317
1995
parser.add_argument("--debuglevel", metavar="LEVEL",
2318
1996
help="Debug level for stdout output")
2319
1997
parser.add_argument("--priority", help="GnuTLS"
2326
2004
" files")
2327
2005
parser.add_argument("--no-dbus", action="store_false",
2328
2006
dest="use_dbus", help="Do not provide D-Bus"
2329
" system bus interface", default=None)
2007
" system bus interface")
2330
2008
parser.add_argument("--no-ipv6", action="store_false",
2331
dest="use_ipv6", help="Do not use IPv6",
2332
default=None)
2009
dest="use_ipv6", help="Do not use IPv6")
2333
2010
parser.add_argument("--no-restore", action="store_false",
2334
2011
dest="restore", help="Do not restore stored"
2335
" state", default=None)
2336
parser.add_argument("--socket", type=int,
2337
help="Specify a file descriptor to a network"
2338
" socket to use instead of creating one")
2012
" state")
2339
2013
parser.add_argument("--statedir", metavar="DIR",
2340
2014
help="Directory to save/restore state in")
2341
parser.add_argument("--foreground", action="store_true",
2342
help="Run in foreground", default=None)
2343
2015
2344
2016
options = parser.parse_args()
2345
2017
2346
2018
if options.check:
2347
2019
import doctest
2348
fail_count, test_count = doctest.testmod()
2349
sys.exit(os.EX_OK if fail_count == 0 else 1)
2020
doctest.testmod()
2021
sys.exit()
2350
2022
2351
2023
# Default values for config file for server-global settings
2352
2024
server_defaults = { "interface": "",
2354
2026
"port": "",
2355
2027
"debug": "False",
2356
2028
"priority":
2357
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2029
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2358
2030
"servicename": "Mandos",
2359
2031
"use_dbus": "True",
2360
2032
"use_ipv6": "True",
2361
2033
"debuglevel": "",
2362
2034
"restore": "True",
2363
"socket": "",
2364
"statedir": "/var/lib/mandos",
2365
"foreground": "False",
2035
"statedir": "/var/lib/mandos"
2366
2036
}
2367
2037
2368
2038
# Parse config file for server-global settings
2373
2043
# Convert the SafeConfigParser object to a dict
2374
2044
server_settings = server_config.defaults()
2375
2045
# Use the appropriate methods on the non-string config options
2376
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2046
for option in ("debug", "use_dbus", "use_ipv6"):
2377
2047
server_settings[option] = server_config.getboolean("DEFAULT",
2378
2048
option)
2379
2049
if server_settings["port"]:
2380
2050
server_settings["port"] = server_config.getint("DEFAULT",
2381
2051
"port")
2382
if server_settings["socket"]:
2383
server_settings["socket"] = server_config.getint("DEFAULT",
2384
"socket")
2385
# Later, stdin will, and stdout and stderr might, be dup'ed
2386
# over with an opened os.devnull. But we don't want this to
2387
# happen with a supplied network socket.
2388
if 0 <= server_settings["socket"] <= 2:
2389
server_settings["socket"] = os.dup(server_settings
2390
["socket"])
2391
2052
del server_config
2392
2053
2393
2054
# Override the settings from the config file with command line
2395
2056
for option in ("interface", "address", "port", "debug",
2396
2057
"priority", "servicename", "configdir",
2397
2058
"use_dbus", "use_ipv6", "debuglevel", "restore",
2398
"statedir", "socket", "foreground"):
2059
"statedir"):
2399
2060
value = getattr(options, option)
2400
2061
if value is not None:
2401
2062
server_settings[option] = value
2404
2065
for option in server_settings.keys():
2405
2066
if type(server_settings[option]) is str:
2406
2067
server_settings[option] = unicode(server_settings[option])
2407
# Force all boolean options to be boolean
2408
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2409
"foreground"):
2410
server_settings[option] = bool(server_settings[option])
2411
# Debug implies foreground
2412
if server_settings["debug"]:
2413
server_settings["foreground"] = True
2414
2068
# Now we have our good server settings in "server_settings"
2415
2069
2416
2070
##################################################################
2422
2076
use_ipv6 = server_settings["use_ipv6"]
2423
2077
stored_state_path = os.path.join(server_settings["statedir"],
2424
2078
stored_state_file)
2425
foreground = server_settings["foreground"]
2426
2079
2427
2080
if debug:
2428
initlogger(debug, logging.DEBUG)
2081
initlogger(logging.DEBUG)
2429
2082
else:
2430
2083
if not debuglevel:
2431
initlogger(debug)
2084
initlogger()
2432
2085
else:
2433
2086
level = getattr(logging, debuglevel.upper())
2434
initlogger(debug, level)
2087
initlogger(level)
2435
2088
2436
2089
if server_settings["servicename"] != "Mandos":
2437
2090
syslogger.setFormatter(logging.Formatter
2438
('Mandos ({0}) [%(process)d]:'
2439
' %(levelname)s: %(message)s'
2440
.format(server_settings
2441
["servicename"])))
2091
('Mandos (%s) [%%(process)d]:'
2092
' %%(levelname)s: %%(message)s'
2093
% server_settings["servicename"]))
2442
2094
2443
2095
# Parse config file with clients
2444
client_config = configparser.SafeConfigParser(Client
2445
.client_defaults)
2096
client_config = configparser.SafeConfigParser(Client.client_defaults)
2446
2097
client_config.read(os.path.join(server_settings["configdir"],
2447
2098
"clients.conf"))
2448
2099
2457
2108
use_ipv6=use_ipv6,
2458
2109
gnutls_priority=
2459
2110
server_settings["priority"],
2460
use_dbus=use_dbus,
2461
socketfd=(server_settings["socket"]
2462
or None))
2463
if not foreground:
2464
pidfilename = "/run/mandos.pid"
2465
if not os.path.isdir("/run/."):
2466
pidfilename = "/var/run/mandos.pid"
2467
pidfile = None
2111
use_dbus=use_dbus)
2112
if not debug:
2113
pidfilename = "/var/run/mandos.pid"
2468
2114
try:
2469
2115
pidfile = open(pidfilename, "w")
2470
except IOError as e:
2471
logger.error("Could not open file %r", pidfilename,
2472
exc_info=e)
2116
except IOError:
2117
logger.error("Could not open file %r", pidfilename)
2473
2118
2474
for name in ("_mandos", "mandos", "nobody"):
2119
try:
2120
uid = pwd.getpwnam("_mandos").pw_uid
2121
gid = pwd.getpwnam("_mandos").pw_gid
2122
except KeyError:
2475
2123
try:
2476
uid = pwd.getpwnam(name).pw_uid
2477
gid = pwd.getpwnam(name).pw_gid
2478
break
2124
uid = pwd.getpwnam("mandos").pw_uid
2125
gid = pwd.getpwnam("mandos").pw_gid
2479
2126
except KeyError:
2480
continue
2481
else:
2482
uid = 65534
2483
gid = 65534
2127
try:
2128
uid = pwd.getpwnam("nobody").pw_uid
2129
gid = pwd.getpwnam("nobody").pw_gid
2130
except KeyError:
2131
uid = 65534
2132
gid = 65534
2484
2133
try:
2485
2134
os.setgid(gid)
2486
2135
os.setuid(uid)
2487
2136
except OSError as error:
2488
if error.errno != errno.EPERM:
2489
raise
2137
if error[0] != errno.EPERM:
2138
raise error
2490
2139
2491
2140
if debug:
2492
2141
# Enable all possible GnuTLS debugging
2503
2152
.gnutls_global_set_log_function(debug_gnutls))
2504
2153
2505
2154
# Redirect stdin so all checkers get /dev/null
2506
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2155
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2507
2156
os.dup2(null, sys.stdin.fileno())
2508
2157
if null > 2:
2509
2158
os.close(null)
2159
else:
2160
# No console logging
2161
logger.removeHandler(console)
2510
2162
2511
2163
# Need to fork before connecting to D-Bus
2512
if not foreground:
2164
if not debug:
2513
2165
# Close all input and output, do double fork, etc.
2514
2166
daemon()
2515
2167
2516
# multiprocessing will use threads, so before we use gobject we
2517
# need to inform gobject that threads will be used.
2518
gobject.threads_init()
2519
2520
2168
global main_loop
2521
2169
# From the Avahi example code
2522
DBusGMainLoop(set_as_default=True)
2170
DBusGMainLoop(set_as_default=True )
2523
2171
main_loop = gobject.MainLoop()
2524
2172
bus = dbus.SystemBus()
2525
2173
# End of Avahi example code
2531
2179
("se.bsnet.fukt.Mandos", bus,
2532
2180
do_not_queue=True))
2533
2181
except dbus.exceptions.NameExistsException as e:
2534
logger.error("Disabling D-Bus:", exc_info=e)
2182
logger.error(unicode(e) + ", disabling D-Bus")
2535
2183
use_dbus = False
2536
2184
server_settings["use_dbus"] = False
2537
2185
tcp_server.use_dbus = False
2549
2197
2550
2198
client_class = Client
2551
2199
if use_dbus:
2552
client_class = functools.partial(ClientDBus, bus = bus)
2200
client_class = functools.partial(ClientDBusTransitional,
2201
bus = bus)
2553
2202
2554
2203
client_settings = Client.config_parser(client_config)
2555
2204
old_client_settings = {}
2556
2205
clients_data = {}
2557
2206
2558
# This is used to redirect stdout and stderr for checker processes
2559
global wnull
2560
wnull = open(os.devnull, "w") # A writable /dev/null
2561
# Only used if server is running in foreground but not in debug
2562
# mode
2563
if debug or not foreground:
2564
wnull.close()
2565
2566
2207
# Get client data and settings from last running state.
2567
2208
if server_settings["restore"]:
2568
2209
try:
2571
2212
(stored_state))
2572
2213
os.remove(stored_state_path)
2573
2214
except IOError as e:
2574
if e.errno == errno.ENOENT:
2575
logger.warning("Could not load persistent state: {0}"
2576
.format(os.strerror(e.errno)))
2577
else:
2578
logger.critical("Could not load persistent state:",
2579
exc_info=e)
2215
logger.warning("Could not load persistent state: {0}"
2216
.format(e))
2217
if e.errno != errno.ENOENT:
2580
2218
raise
2581
except EOFError as e:
2582
logger.warning("Could not load persistent state: "
2583
"EOFError:", exc_info=e)
2584
2219
2585
2220
with PGPEngine() as pgp:
2586
2221
for client_name, client in clients_data.iteritems():
2587
# Skip removed clients
2588
if client_name not in client_settings:
2589
continue
2590
2591
2222
# Decide which value to use after restoring saved state.
2592
2223
# We have three different values: Old config file,
2593
2224
# new config file, and saved state.
2607
2238
2608
2239
# Clients who has passed its expire date can still be
2609
2240
# enabled if its last checker was successful. Clients
2610
# whose checker succeeded before we stored its state is
2611
# assumed to have successfully run all checkers during
2612
# downtime.
2241
# whose checker failed before we stored its state is
2242
# assumed to have failed all checkers during downtime.
2613
2243
if client["enabled"]:
2614
2244
if datetime.datetime.utcnow() >= client["expires"]:
2615
2245
if not client["last_checked_ok"]:
2616
2246
logger.warning(
2617
2247
"disabling client {0} - Client never "
2618
"performed a successful checker"
2619
.format(client_name))
2248
"performed a successfull checker"
2249
.format(client["name"]))
2620
2250
client["enabled"] = False
2621
2251
elif client["last_checker_status"] != 0:
2622
2252
logger.warning(
2623
2253
"disabling client {0} - Client "
2624
2254
"last checker failed with error code {1}"
2625
.format(client_name,
2255
.format(client["name"],
2626
2256
client["last_checker_status"]))
2627
2257
client["enabled"] = False
2628
2258
else:
2629
2259
client["expires"] = (datetime.datetime
2630
2260
.utcnow()
2631
2261
+ client["timeout"])
2632
logger.debug("Last checker succeeded,"
2633
" keeping {0} enabled"
2634
.format(client_name))
2262
2635
2263
try:
2636
2264
client["secret"] = (
2637
2265
pgp.decrypt(client["encrypted_secret"],
2643
2271
.format(client_name))
2644
2272
client["secret"] = (
2645
2273
client_settings[client_name]["secret"])
2274
2646
2275
2647
2276
# Add/remove clients based on new changes made to config
2648
for client_name in (set(old_client_settings)
2649
- set(client_settings)):
2277
for client_name in set(old_client_settings) - set(client_settings):
2650
2278
del clients_data[client_name]
2651
for client_name in (set(client_settings)
2652
- set(old_client_settings)):
2279
for client_name in set(client_settings) - set(old_client_settings):
2653
2280
clients_data[client_name] = client_settings[client_name]
2654
2655
# Create all client objects
2281
2282
# Create clients all clients
2656
2283
for client_name, client in clients_data.iteritems():
2657
2284
tcp_server.clients[client_name] = client_class(
2658
name = client_name, settings = client,
2659
server_settings = server_settings)
2285
name = client_name, settings = client)
2660
2286
2661
2287
if not tcp_server.clients:
2662
2288
logger.warning("No clients defined")
2663
2664
if not foreground:
2665
if pidfile is not None:
2666
try:
2667
with pidfile:
2668
pid = os.getpid()
2669
pidfile.write(str(pid) + "\n".encode("utf-8"))
2670
except IOError:
2671
logger.error("Could not write to file %r with PID %d",
2672
pidfilename, pid)
2673
del pidfile
2289
2290
if not debug:
2291
try:
2292
with pidfile:
2293
pid = os.getpid()
2294
pidfile.write(str(pid) + "\n".encode("utf-8"))
2295
del pidfile
2296
except IOError:
2297
logger.error("Could not write to file %r with PID %d",
2298
pidfilename, pid)
2299
except NameError:
2300
# "pidfile" was never created
2301
pass
2674
2302
del pidfilename
2303
signal.signal(signal.SIGINT, signal.SIG_IGN)
2675
2304
2676
2305
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2677
2306
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2678
2307
2679
2308
if use_dbus:
2680
@alternate_dbus_interfaces({"se.recompile.Mandos":
2681
"se.bsnet.fukt.Mandos"})
2682
class MandosDBusService(DBusObjectWithProperties):
2309
class MandosDBusService(dbus.service.Object):
2683
2310
"""A D-Bus proxy object"""
2684
2311
def __init__(self):
2685
2312
dbus.service.Object.__init__(self, bus, "/")
2686
2313
_interface = "se.recompile.Mandos"
2687
2314
2688
@dbus_interface_annotations(_interface)
2689
def _foo(self):
2690
return { "org.freedesktop.DBus.Property"
2691
".EmitsChangedSignal":
2692
"false"}
2693
2694
2315
@dbus.service.signal(_interface, signature="o")
2695
2316
def ClientAdded(self, objpath):
2696
2317
"D-Bus signal"
2738
2359
2739
2360
del _interface
2740
2361
2741
mandos_dbus_service = MandosDBusService()
2362
class MandosDBusServiceTransitional(MandosDBusService):
2363
__metaclass__ = AlternateDBusNamesMetaclass
2364
mandos_dbus_service = MandosDBusServiceTransitional()
2742
2365
2743
2366
def cleanup():
2744
2367
"Cleanup function; run on exit"
2745
2368
service.cleanup()
2746
2369
2747
2370
multiprocessing.active_children()
2748
wnull.close()
2749
2371
if not (tcp_server.clients or client_settings):
2750
2372
return
2751
2373
2763
2385
# A list of attributes that can not be pickled
2764
2386
# + secret.
2765
2387
exclude = set(("bus", "changedstate", "secret",
2766
"checker", "server_settings"))
2388
"checker"))
2767
2389
for name, typ in (inspect.getmembers
2768
2390
(dbus.service.Object)):
2769
2391
exclude.add(name)
2778
2400
del client_settings[client.name]["secret"]
2779
2401
2780
2402
try:
2781
with (tempfile.NamedTemporaryFile
2782
(mode='wb', suffix=".pickle", prefix='clients-',
2783
dir=os.path.dirname(stored_state_path),
2784
delete=False)) as stored_state:
2403
with os.fdopen(os.open(stored_state_path,
2404
os.O_CREAT|os.O_WRONLY|os.O_TRUNC,
2405
0600), "wb") as stored_state:
2785
2406
pickle.dump((clients, client_settings), stored_state)
2786
tempname=stored_state.name
2787
os.rename(tempname, stored_state_path)
2788
2407
except (IOError, OSError) as e:
2789
if not debug:
2790
try:
2791
os.remove(tempname)
2792
except NameError:
2793
pass
2794
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2795
logger.warning("Could not save persistent state: {0}"
2796
.format(os.strerror(e.errno)))
2797
else:
2798
logger.warning("Could not save persistent state:",
2799
exc_info=e)
2408
logger.warning("Could not save persistent state: {0}"
2409
.format(e))
2410
if e.errno not in (errno.ENOENT, errno.EACCES):
2800
2411
raise
2801
2412
2802
2413
# Delete all clients, and settings from config
2830
2441
service.port = tcp_server.socket.getsockname()[1]
2831
2442
if use_ipv6:
2832
2443
logger.info("Now listening on address %r, port %d,"
2833
" flowinfo %d, scope_id %d",
2834
*tcp_server.socket.getsockname())
2444
" flowinfo %d, scope_id %d"
2445
% tcp_server.socket.getsockname())
2835
2446
else: # IPv4
2836
logger.info("Now listening on address %r, port %d",
2837
*tcp_server.socket.getsockname())
2447
logger.info("Now listening on address %r, port %d"
2448
% tcp_server.socket.getsockname())
2838
2449
2839
2450
#service.interface = tcp_server.socket.getsockname()[3]
2840
2451
2843
2454
try:
2844
2455
service.activate()
2845
2456
except dbus.exceptions.DBusException as error:
2846
logger.critical("D-Bus Exception", exc_info=error)
2457
logger.critical("DBusException: %s", error)
2847
2458
cleanup()
2848
2459
sys.exit(1)
2849
2460
# End of Avahi example code
2856
2467
logger.debug("Starting main loop")
2857
2468
main_loop.run()
2858
2469
except AvahiError as error:
2859
logger.critical("Avahi Error", exc_info=error)
2470
logger.critical("AvahiError: %s", error)
2860
2471
cleanup()
2861
2472
sys.exit(1)
2862
2473
except KeyboardInterrupt:
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0