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 749.1.2
- compare with another revision
- download diff
- download tarball
- view history from revision 749.1.2
- Committer: Teddy Hogeborn
- Date: 2015-05-25 07:54:07 UTC
- mto: This revision was merged to the branch mainline in revision 756.
- Revision ID: teddy@recompile.se-20150525075407-x7u0z4f1zej6bm87
mandos (subprocess_call_pipe): Rename to "call_pipe" and take "func".
Generalize "subprocess_call_pipe" to "call_pipe" which takes an
additional "func" argument which is the function to be run.
Generalize "subprocess_call_pipe" to "call_pipe" which takes an
additional "func" argument which is the function to be run.
- files added:
- debian/mandos-client.examples
- debian/upstream
- files modified:
- DBUS-API
added
removed
mandos
1
#!/usr/bin/python
1
#!/usr/bin/python2.7
2
2
# -*- mode: python; coding: utf-8 -*-
3
3
#
4
4
# Mandos server - give out binary blobs to connecting clients.
11
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2008-2012 Teddy Hogeborn
15
# Copyright © 2008-2012 Björn Påhlsson
14
# Copyright © 2008-2015 Teddy Hogeborn
15
# Copyright © 2008-2015 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
36
36
37
37
from future_builtins import *
38
38
39
import SocketServer as socketserver
39
try:
40
import SocketServer as socketserver
41
except ImportError:
42
import socketserver
40
43
import socket
41
44
import argparse
42
45
import datetime
47
50
import gnutls.library.functions
48
51
import gnutls.library.constants
49
52
import gnutls.library.types
50
import ConfigParser as configparser
53
try:
54
import ConfigParser as configparser
55
except ImportError:
56
import configparser
51
57
import sys
52
58
import re
53
59
import os
62
68
import struct
63
69
import fcntl
64
70
import functools
65
import cPickle as pickle
71
try:
72
import cPickle as pickle
73
except ImportError:
74
import pickle
66
75
import multiprocessing
67
76
import types
68
77
import binascii
69
78
import tempfile
70
79
import itertools
80
import collections
71
81
72
82
import dbus
73
83
import dbus.service
74
import gobject
84
try:
85
import gobject
86
except ImportError:
87
from gi.repository import GObject as gobject
75
88
import avahi
76
89
from dbus.mainloop.glib import DBusGMainLoop
77
90
import ctypes
78
91
import ctypes.util
79
92
import xml.dom.minidom
80
93
import inspect
81
import GnuPGInterface
82
94
83
95
try:
84
96
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
88
100
except ImportError:
89
101
SO_BINDTODEVICE = None
90
102
91
version = "1.5.4"
103
if sys.version_info.major == 2:
104
str = unicode
105
106
version = "1.6.9"
92
107
stored_state_file = "clients.pickle"
93
108
94
109
logger = logging.getLogger()
95
syslogger = (logging.handlers.SysLogHandler
96
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
97
address = str("/dev/log")))
110
syslogger = None
98
111
99
112
try:
100
if_nametoindex = (ctypes.cdll.LoadLibrary
101
(ctypes.util.find_library("c"))
102
.if_nametoindex)
113
if_nametoindex = ctypes.cdll.LoadLibrary(
114
ctypes.util.find_library("c")).if_nametoindex
103
115
except (OSError, AttributeError):
116
104
117
def if_nametoindex(interface):
105
118
"Get an interface index the hard way, i.e. using fcntl()"
106
119
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
107
120
with contextlib.closing(socket.socket()) as s:
108
121
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
109
struct.pack(str("16s16x"),
110
interface))
111
interface_index = struct.unpack(str("I"),
112
ifreq[16:20])[0]
122
struct.pack(b"16s16x", interface))
123
interface_index = struct.unpack("I", ifreq[16:20])[0]
113
124
return interface_index
114
125
115
126
116
127
def initlogger(debug, level=logging.WARNING):
117
128
"""init logger and add loglevel"""
118
129
130
global syslogger
131
syslogger = (logging.handlers.SysLogHandler(
132
facility = logging.handlers.SysLogHandler.LOG_DAEMON,
133
address = "/dev/log"))
119
134
syslogger.setFormatter(logging.Formatter
120
135
('Mandos [%(process)d]: %(levelname)s:'
121
136
' %(message)s'))
138
153
139
154
class PGPEngine(object):
140
155
"""A simple class for OpenPGP symmetric encryption & decryption"""
156
141
157
def __init__(self):
142
self.gnupg = GnuPGInterface.GnuPG()
143
158
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
144
self.gnupg = GnuPGInterface.GnuPG()
145
self.gnupg.options.meta_interactive = False
146
self.gnupg.options.homedir = self.tempdir
147
self.gnupg.options.extra_args.extend(['--force-mdc',
148
'--quiet',
149
'--no-use-agent'])
159
self.gnupgargs = ['--batch',
160
'--home', self.tempdir,
161
'--force-mdc',
162
'--quiet',
163
'--no-use-agent']
150
164
151
165
def __enter__(self):
152
166
return self
174
188
def password_encode(self, password):
175
189
# Passphrase can not be empty and can not contain newlines or
176
190
# NUL bytes. So we prefix it and hex encode it.
177
return b"mandos" + binascii.hexlify(password)
191
encoded = b"mandos" + binascii.hexlify(password)
192
if len(encoded) > 2048:
193
# GnuPG can't handle long passwords, so encode differently
194
encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
195
.replace(b"\n", b"\\n")
196
.replace(b"\0", b"\\x00"))
197
return encoded
178
198
179
199
def encrypt(self, data, password):
180
self.gnupg.passphrase = self.password_encode(password)
181
with open(os.devnull, "w") as devnull:
182
try:
183
proc = self.gnupg.run(['--symmetric'],
184
create_fhs=['stdin', 'stdout'],
185
attach_fhs={'stderr': devnull})
186
with contextlib.closing(proc.handles['stdin']) as f:
187
f.write(data)
188
with contextlib.closing(proc.handles['stdout']) as f:
189
ciphertext = f.read()
190
proc.wait()
191
except IOError as e:
192
raise PGPError(e)
193
self.gnupg.passphrase = None
200
passphrase = self.password_encode(password)
201
with tempfile.NamedTemporaryFile(
202
dir=self.tempdir) as passfile:
203
passfile.write(passphrase)
204
passfile.flush()
205
proc = subprocess.Popen(['gpg', '--symmetric',
206
'--passphrase-file',
207
passfile.name]
208
+ self.gnupgargs,
209
stdin = subprocess.PIPE,
210
stdout = subprocess.PIPE,
211
stderr = subprocess.PIPE)
212
ciphertext, err = proc.communicate(input = data)
213
if proc.returncode != 0:
214
raise PGPError(err)
194
215
return ciphertext
195
216
196
217
def decrypt(self, data, password):
197
self.gnupg.passphrase = self.password_encode(password)
198
with open(os.devnull, "w") as devnull:
199
try:
200
proc = self.gnupg.run(['--decrypt'],
201
create_fhs=['stdin', 'stdout'],
202
attach_fhs={'stderr': devnull})
203
with contextlib.closing(proc.handles['stdin']) as f:
204
f.write(data)
205
with contextlib.closing(proc.handles['stdout']) as f:
206
decrypted_plaintext = f.read()
207
proc.wait()
208
except IOError as e:
209
raise PGPError(e)
210
self.gnupg.passphrase = None
218
passphrase = self.password_encode(password)
219
with tempfile.NamedTemporaryFile(
220
dir = self.tempdir) as passfile:
221
passfile.write(passphrase)
222
passfile.flush()
223
proc = subprocess.Popen(['gpg', '--decrypt',
224
'--passphrase-file',
225
passfile.name]
226
+ self.gnupgargs,
227
stdin = subprocess.PIPE,
228
stdout = subprocess.PIPE,
229
stderr = subprocess.PIPE)
230
decrypted_plaintext, err = proc.communicate(input = data)
231
if proc.returncode != 0:
232
raise PGPError(err)
211
233
return decrypted_plaintext
212
234
213
235
214
236
class AvahiError(Exception):
215
237
def __init__(self, value, *args, **kwargs):
216
238
self.value = value
217
super(AvahiError, self).__init__(value, *args, **kwargs)
218
def __unicode__(self):
219
return unicode(repr(self.value))
239
return super(AvahiError, self).__init__(value, *args,
240
**kwargs)
241
220
242
221
243
class AvahiServiceError(AvahiError):
222
244
pass
223
245
246
224
247
class AvahiGroupError(AvahiError):
225
248
pass
226
249
233
256
Used to optionally bind to the specified interface.
234
257
name: string; Example: 'Mandos'
235
258
type: string; Example: '_mandos._tcp'.
236
See <http://www.dns-sd.org/ServiceTypes.html>
259
See <https://www.iana.org/assignments/service-names-port-numbers>
237
260
port: integer; what port to announce
238
261
TXT: list of strings; TXT record for the service
239
262
domain: string; Domain to publish on, default to .local if empty.
246
269
bus: dbus.SystemBus()
247
270
"""
248
271
249
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
250
servicetype = None, port = None, TXT = None,
251
domain = "", host = "", max_renames = 32768,
252
protocol = avahi.PROTO_UNSPEC, bus = None):
272
def __init__(self,
273
interface = avahi.IF_UNSPEC,
274
name = None,
275
servicetype = None,
276
port = None,
277
TXT = None,
278
domain = "",
279
host = "",
280
max_renames = 32768,
281
protocol = avahi.PROTO_UNSPEC,
282
bus = None):
253
283
self.interface = interface
254
284
self.name = name
255
285
self.type = servicetype
265
295
self.bus = bus
266
296
self.entry_group_state_changed_match = None
267
297
268
def rename(self):
298
def rename(self, remove=True):
269
299
"""Derived from the Avahi example code"""
270
300
if self.rename_count >= self.max_renames:
271
301
logger.critical("No suitable Zeroconf service name found"
272
302
" after %i retries, exiting.",
273
303
self.rename_count)
274
304
raise AvahiServiceError("Too many renames")
275
self.name = unicode(self.server
276
.GetAlternativeServiceName(self.name))
305
self.name = str(
306
self.server.GetAlternativeServiceName(self.name))
307
self.rename_count += 1
277
308
logger.info("Changing Zeroconf service name to %r ...",
278
309
self.name)
279
self.remove()
310
if remove:
311
self.remove()
280
312
try:
281
313
self.add()
282
314
except dbus.exceptions.DBusException as error:
283
logger.critical("D-Bus Exception", exc_info=error)
284
self.cleanup()
285
os._exit(1)
286
self.rename_count += 1
315
if (error.get_dbus_name()
316
== "org.freedesktop.Avahi.CollisionError"):
317
logger.info("Local Zeroconf service name collision.")
318
return self.rename(remove=False)
319
else:
320
logger.critical("D-Bus Exception", exc_info=error)
321
self.cleanup()
322
os._exit(1)
287
323
288
324
def remove(self):
289
325
"""Derived from the Avahi example code"""
327
363
self.rename()
328
364
elif state == avahi.ENTRY_GROUP_FAILURE:
329
365
logger.critical("Avahi: Error in group state changed %s",
330
unicode(error))
331
raise AvahiGroupError("State changed: {0!s}"
332
.format(error))
366
str(error))
367
raise AvahiGroupError("State changed: {!s}".format(error))
333
368
334
369
def cleanup(self):
335
370
"""Derived from the Avahi example code"""
345
380
def server_state_changed(self, state, error=None):
346
381
"""Derived from the Avahi example code"""
347
382
logger.debug("Avahi server state change: %i", state)
348
bad_states = { avahi.SERVER_INVALID:
349
"Zeroconf server invalid",
350
avahi.SERVER_REGISTERING: None,
351
avahi.SERVER_COLLISION:
352
"Zeroconf server name collision",
353
avahi.SERVER_FAILURE:
354
"Zeroconf server failure" }
383
bad_states = {
384
avahi.SERVER_INVALID: "Zeroconf server invalid",
385
avahi.SERVER_REGISTERING: None,
386
avahi.SERVER_COLLISION: "Zeroconf server name collision",
387
avahi.SERVER_FAILURE: "Zeroconf server failure",
388
}
355
389
if state in bad_states:
356
390
if bad_states[state] is not None:
357
391
if error is None:
376
410
follow_name_owner_changes=True),
377
411
avahi.DBUS_INTERFACE_SERVER)
378
412
self.server.connect_to_signal("StateChanged",
379
self.server_state_changed)
413
self.server_state_changed)
380
414
self.server_state_changed(self.server.GetState())
381
415
382
416
383
417
class AvahiServiceToSyslog(AvahiService):
384
def rename(self):
418
def rename(self, *args, **kwargs):
385
419
"""Add the new name to the syslog messages"""
386
ret = AvahiService.rename(self)
387
syslogger.setFormatter(logging.Formatter
388
('Mandos ({0}) [%(process)d]:'
389
' %(levelname)s: %(message)s'
390
.format(self.name)))
420
ret = AvahiService.rename(self, *args, **kwargs)
421
syslogger.setFormatter(logging.Formatter(
422
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
423
.format(self.name)))
391
424
return ret
392
425
393
394
def timedelta_to_milliseconds(td):
395
"Convert a datetime.timedelta() to milliseconds"
396
return ((td.days * 24 * 60 * 60 * 1000)
397
+ (td.seconds * 1000)
398
+ (td.microseconds // 1000))
399
426
def call_pipe(connection, # : multiprocessing.Connection
427
func, *args, **kwargs):
428
"""This function is meant to be called by multiprocessing.Process
429
430
This function runs func(*args, **kwargs), and writes the resulting
431
return value on the provided multiprocessing.Connection.
432
"""
433
connection.send(func(*args, **kwargs))
434
connection.close()
400
435
401
436
class Client(object):
402
437
"""A representation of a client host served by this server.
429
464
last_checker_status: integer between 0 and 255 reflecting exit
430
465
status of last checker. -1 reflects crashed
431
466
checker, -2 means no checker completed yet.
467
last_checker_signal: The signal which killed the last checker, if
468
last_checker_status is -1
432
469
last_enabled: datetime.datetime(); (UTC) or None
433
470
name: string; from the config file, used in log messages and
434
471
D-Bus identifiers
439
476
runtime_expansions: Allowed attributes for runtime expansion.
440
477
expires: datetime.datetime(); time (UTC) when a client will be
441
478
disabled, or None
479
server_settings: The server_settings dict from main()
442
480
"""
443
481
444
482
runtime_expansions = ("approval_delay", "approval_duration",
446
484
"fingerprint", "host", "interval",
447
485
"last_approval_request", "last_checked_ok",
448
486
"last_enabled", "name", "timeout")
449
client_defaults = { "timeout": "5m",
450
"extended_timeout": "15m",
451
"interval": "2m",
452
"checker": "fping -q -- %%(host)s",
453
"host": "",
454
"approval_delay": "0s",
455
"approval_duration": "1s",
456
"approved_by_default": "True",
457
"enabled": "True",
458
}
459
460
def timeout_milliseconds(self):
461
"Return the 'timeout' attribute in milliseconds"
462
return timedelta_to_milliseconds(self.timeout)
463
464
def extended_timeout_milliseconds(self):
465
"Return the 'extended_timeout' attribute in milliseconds"
466
return timedelta_to_milliseconds(self.extended_timeout)
467
468
def interval_milliseconds(self):
469
"Return the 'interval' attribute in milliseconds"
470
return timedelta_to_milliseconds(self.interval)
471
472
def approval_delay_milliseconds(self):
473
return timedelta_to_milliseconds(self.approval_delay)
487
client_defaults = {
488
"timeout": "PT5M",
489
"extended_timeout": "PT15M",
490
"interval": "PT2M",
491
"checker": "fping -q -- %%(host)s",
492
"host": "",
493
"approval_delay": "PT0S",
494
"approval_duration": "PT1S",
495
"approved_by_default": "True",
496
"enabled": "True",
497
}
474
498
475
499
@staticmethod
476
500
def config_parser(config):
492
516
client["enabled"] = config.getboolean(client_name,
493
517
"enabled")
494
518
519
# Uppercase and remove spaces from fingerprint for later
520
# comparison purposes with return value from the
521
# fingerprint() function
495
522
client["fingerprint"] = (section["fingerprint"].upper()
496
523
.replace(" ", ""))
497
524
if "secret" in section:
502
529
"rb") as secfile:
503
530
client["secret"] = secfile.read()
504
531
else:
505
raise TypeError("No secret or secfile for section {0}"
532
raise TypeError("No secret or secfile for section {}"
506
533
.format(section))
507
534
client["timeout"] = string_to_delta(section["timeout"])
508
535
client["extended_timeout"] = string_to_delta(
519
546
520
547
return settings
521
548
522
def __init__(self, settings, name = None):
549
def __init__(self, settings, name = None, server_settings=None):
523
550
self.name = name
551
if server_settings is None:
552
server_settings = {}
553
self.server_settings = server_settings
524
554
# adding all client settings
525
for setting, value in settings.iteritems():
555
for setting, value in settings.items():
526
556
setattr(self, setting, value)
527
557
528
558
if self.enabled:
536
566
self.expires = None
537
567
538
568
logger.debug("Creating client %r", self.name)
539
# Uppercase and remove spaces from fingerprint for later
540
# comparison purposes with return value from the fingerprint()
541
# function
542
569
logger.debug(" Fingerprint: %s", self.fingerprint)
543
570
self.created = settings.get("created",
544
571
datetime.datetime.utcnow())
551
578
self.current_checker_command = None
552
579
self.approved = None
553
580
self.approvals_pending = 0
554
self.changedstate = (multiprocessing_manager
555
.Condition(multiprocessing_manager
556
.Lock()))
557
self.client_structure = [attr for attr in
558
self.__dict__.iterkeys()
581
self.changedstate = multiprocessing_manager.Condition(
582
multiprocessing_manager.Lock())
583
self.client_structure = [attr
584
for attr in self.__dict__.iterkeys()
559
585
if not attr.startswith("_")]
560
586
self.client_structure.append("client_structure")
561
587
562
for name, t in inspect.getmembers(type(self),
563
lambda obj:
564
isinstance(obj,
565
property)):
588
for name, t in inspect.getmembers(
589
type(self), lambda obj: isinstance(obj, property)):
566
590
if not name.startswith("_"):
567
591
self.client_structure.append(name)
568
592
610
634
# and every interval from then on.
611
635
if self.checker_initiator_tag is not None:
612
636
gobject.source_remove(self.checker_initiator_tag)
613
self.checker_initiator_tag = (gobject.timeout_add
614
(self.interval_milliseconds(),
615
self.start_checker))
637
self.checker_initiator_tag = gobject.timeout_add(
638
int(self.interval.total_seconds() * 1000),
639
self.start_checker)
616
640
# Schedule a disable() when 'timeout' has passed
617
641
if self.disable_initiator_tag is not None:
618
642
gobject.source_remove(self.disable_initiator_tag)
619
self.disable_initiator_tag = (gobject.timeout_add
620
(self.timeout_milliseconds(),
621
self.disable))
643
self.disable_initiator_tag = gobject.timeout_add(
644
int(self.timeout.total_seconds() * 1000), self.disable)
622
645
# Also start a new checker *right now*.
623
646
self.start_checker()
624
647
625
def checker_callback(self, pid, condition, command):
648
def checker_callback(self, source, condition,
649
(connection, command)):
626
650
"""The checker has completed, so take appropriate actions."""
627
651
self.checker_callback_tag = None
628
652
self.checker = None
629
if os.WIFEXITED(condition):
630
self.last_checker_status = os.WEXITSTATUS(condition)
653
# Read return code from connection (see call_pipe)
654
returncode = connection.recv()
655
connection.close()
656
657
if returncode >= 0:
658
self.last_checker_status = returncode
659
self.last_checker_signal = None
631
660
if self.last_checker_status == 0:
632
661
logger.info("Checker for %(name)s succeeded",
633
662
vars(self))
634
663
self.checked_ok()
635
664
else:
636
logger.info("Checker for %(name)s failed",
637
vars(self))
665
logger.info("Checker for %(name)s failed", vars(self))
638
666
else:
639
667
self.last_checker_status = -1
668
self.last_checker_signal = -returncode
640
669
logger.warning("Checker for %(name)s crashed?",
641
670
vars(self))
671
return False
642
672
643
673
def checked_ok(self):
644
674
"""Assert that the client has been seen, alive and well."""
645
675
self.last_checked_ok = datetime.datetime.utcnow()
646
676
self.last_checker_status = 0
677
self.last_checker_signal = None
647
678
self.bump_timeout()
648
679
649
680
def bump_timeout(self, timeout=None):
654
685
gobject.source_remove(self.disable_initiator_tag)
655
686
self.disable_initiator_tag = None
656
687
if getattr(self, "enabled", False):
657
self.disable_initiator_tag = (gobject.timeout_add
658
(timedelta_to_milliseconds
659
(timeout), self.disable))
688
self.disable_initiator_tag = gobject.timeout_add(
689
int(timeout.total_seconds() * 1000), self.disable)
660
690
self.expires = datetime.datetime.utcnow() + timeout
661
691
662
692
def need_approval(self):
676
706
# than 'timeout' for the client to be disabled, which is as it
677
707
# should be.
678
708
679
# If a checker exists, make sure it is not a zombie
680
try:
681
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
682
except (AttributeError, OSError) as error:
683
if (isinstance(error, OSError)
684
and error.errno != errno.ECHILD):
685
raise error
686
else:
687
if pid:
688
logger.warning("Checker was a zombie")
689
gobject.source_remove(self.checker_callback_tag)
690
self.checker_callback(pid, status,
691
self.current_checker_command)
709
if self.checker is not None and not self.checker.is_alive():
710
logger.warning("Checker was not alive; joining")
711
self.checker.join()
712
self.checker = None
692
713
# Start a new checker if needed
693
714
if self.checker is None:
694
715
# Escape attributes for the shell
695
escaped_attrs = dict(
696
(attr, re.escape(unicode(getattr(self, attr))))
697
for attr in
698
self.runtime_expansions)
716
escaped_attrs = {
717
attr: re.escape(str(getattr(self, attr)))
718
for attr in self.runtime_expansions }
699
719
try:
700
720
command = self.checker_command % escaped_attrs
701
721
except TypeError as error:
702
722
logger.error('Could not format string "%s"',
703
self.checker_command, exc_info=error)
704
return True # Try again later
723
self.checker_command,
724
exc_info=error)
725
return True # Try again later
705
726
self.current_checker_command = command
706
try:
707
logger.info("Starting checker %r for %s",
708
command, self.name)
709
# We don't need to redirect stdout and stderr, since
710
# in normal mode, that is already done by daemon(),
711
# and in debug mode we don't want to. (Stdin is
712
# always replaced by /dev/null.)
713
self.checker = subprocess.Popen(command,
714
close_fds=True,
715
shell=True, cwd="/")
716
except OSError as error:
717
logger.error("Failed to start subprocess",
718
exc_info=error)
719
self.checker_callback_tag = (gobject.child_watch_add
720
(self.checker.pid,
721
self.checker_callback,
722
data=command))
723
# The checker may have completed before the gobject
724
# watch was added. Check for this.
725
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
726
if pid:
727
gobject.source_remove(self.checker_callback_tag)
728
self.checker_callback(pid, status, command)
727
logger.info("Starting checker %r for %s", command,
728
self.name)
729
# We don't need to redirect stdout and stderr, since
730
# in normal mode, that is already done by daemon(),
731
# and in debug mode we don't want to. (Stdin is
732
# always replaced by /dev/null.)
733
# The exception is when not debugging but nevertheless
734
# running in the foreground; use the previously
735
# created wnull.
736
popen_args = { "close_fds": True,
737
"shell": True,
738
"cwd": "/" }
739
if (not self.server_settings["debug"]
740
and self.server_settings["foreground"]):
741
popen_args.update({"stdout": wnull,
742
"stderr": wnull })
743
pipe = multiprocessing.Pipe(duplex=False)
744
self.checker = multiprocessing.Process(
745
target = call_pipe,
746
args = (subprocess.call, pipe[1], command),
747
kwargs = popen_args)
748
self.checker.start()
749
self.checker_callback_tag = gobject.io_add_watch(
750
pipe[0].fileno(), gobject.IO_IN,
751
self.checker_callback, (pipe[0], command))
729
752
# Re-run this periodically if run by gobject.timeout_add
730
753
return True
731
754
737
760
if getattr(self, "checker", None) is None:
738
761
return
739
762
logger.debug("Stopping checker for %(name)s", vars(self))
740
try:
741
self.checker.terminate()
742
#time.sleep(0.5)
743
#if self.checker.poll() is None:
744
# self.checker.kill()
745
except OSError as error:
746
if error.errno != errno.ESRCH: # No such process
747
raise
763
self.checker.terminate()
748
764
self.checker = None
749
765
750
766
751
def dbus_service_property(dbus_interface, signature="v",
752
access="readwrite", byte_arrays=False):
767
def dbus_service_property(dbus_interface,
768
signature="v",
769
access="readwrite",
770
byte_arrays=False):
753
771
"""Decorators for marking methods of a DBusObjectWithProperties to
754
772
become properties on the D-Bus.
755
773
764
782
# "Set" method, so we fail early here:
765
783
if byte_arrays and signature != "ay":
766
784
raise ValueError("Byte arrays not supported for non-'ay'"
767
" signature {0!r}".format(signature))
785
" signature {!r}".format(signature))
786
768
787
def decorator(func):
769
788
func._dbus_is_property = True
770
789
func._dbus_interface = dbus_interface
775
794
func._dbus_name = func._dbus_name[:-14]
776
795
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
777
796
return func
797
778
798
return decorator
779
799
780
800
789
809
"org.freedesktop.DBus.Property.EmitsChangedSignal":
790
810
"false"}
791
811
"""
812
792
813
def decorator(func):
793
814
func._dbus_is_interface = True
794
815
func._dbus_interface = dbus_interface
795
816
func._dbus_name = dbus_interface
796
817
return func
818
797
819
return decorator
798
820
799
821
801
823
"""Decorator to annotate D-Bus methods, signals or properties
802
824
Usage:
803
825
826
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
827
"org.freedesktop.DBus.Property."
828
"EmitsChangedSignal": "false"})
804
829
@dbus_service_property("org.example.Interface", signature="b",
805
830
access="r")
806
@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
807
"org.freedesktop.DBus.Property."
808
"EmitsChangedSignal": "false"})
809
831
def Property_dbus_property(self):
810
832
return dbus.Boolean(False)
811
833
"""
834
812
835
def decorator(func):
813
836
func._dbus_annotations = annotations
814
837
return func
838
815
839
return decorator
816
840
817
841
818
842
class DBusPropertyException(dbus.exceptions.DBusException):
819
843
"""A base class for D-Bus property-related exceptions
820
844
"""
821
def __unicode__(self):
822
return unicode(str(self))
845
pass
823
846
824
847
825
848
class DBusPropertyAccessException(DBusPropertyException):
849
872
If called like _is_dbus_thing("method") it returns a function
850
873
suitable for use as predicate to inspect.getmembers().
851
874
"""
852
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
875
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
853
876
False)
854
877
855
878
def _get_all_dbus_things(self, thing):
856
879
"""Returns a generator of (name, attribute) pairs
857
880
"""
858
return ((getattr(athing.__get__(self), "_dbus_name",
859
name),
881
return ((getattr(athing.__get__(self), "_dbus_name", name),
860
882
athing.__get__(self))
861
883
for cls in self.__class__.__mro__
862
884
for name, athing in
863
inspect.getmembers(cls,
864
self._is_dbus_thing(thing)))
885
inspect.getmembers(cls, self._is_dbus_thing(thing)))
865
886
866
887
def _get_dbus_property(self, interface_name, property_name):
867
888
"""Returns a bound method if one exists which is a D-Bus
868
889
property with the specified name and interface.
869
890
"""
870
for cls in self.__class__.__mro__:
871
for name, value in (inspect.getmembers
872
(cls,
873
self._is_dbus_thing("property"))):
891
for cls in self.__class__.__mro__:
892
for name, value in inspect.getmembers(
893
cls, self._is_dbus_thing("property")):
874
894
if (value._dbus_name == property_name
875
895
and value._dbus_interface == interface_name):
876
896
return value.__get__(self)
877
897
878
898
# No such property
879
raise DBusPropertyNotFound(self.dbus_object_path + ":"
880
+ interface_name + "."
881
+ property_name)
899
raise DBusPropertyNotFound("{}:{}.{}".format(
900
self.dbus_object_path, interface_name, property_name))
882
901
883
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
902
@dbus.service.method(dbus.PROPERTIES_IFACE,
903
in_signature="ss",
884
904
out_signature="v")
885
905
def Get(self, interface_name, property_name):
886
906
"""Standard D-Bus property Get() method, see D-Bus standard.
904
924
# The byte_arrays option is not supported yet on
905
925
# signatures other than "ay".
906
926
if prop._dbus_signature != "ay":
907
raise ValueError
927
raise ValueError("Byte arrays not supported for non-"
928
"'ay' signature {!r}"
929
.format(prop._dbus_signature))
908
930
value = dbus.ByteArray(b''.join(chr(byte)
909
931
for byte in value))
910
932
prop(value)
911
933
912
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
934
@dbus.service.method(dbus.PROPERTIES_IFACE,
935
in_signature="s",
913
936
out_signature="a{sv}")
914
937
def GetAll(self, interface_name):
915
938
"""Standard D-Bus property GetAll() method, see D-Bus
930
953
if not hasattr(value, "variant_level"):
931
954
properties[name] = value
932
955
continue
933
properties[name] = type(value)(value, variant_level=
934
value.variant_level+1)
956
properties[name] = type(value)(
957
value, variant_level = value.variant_level + 1)
935
958
return dbus.Dictionary(properties, signature="sv")
936
959
960
@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
961
def PropertiesChanged(self, interface_name, changed_properties,
962
invalidated_properties):
963
"""Standard D-Bus PropertiesChanged() signal, see D-Bus
964
standard.
965
"""
966
pass
967
937
968
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
938
969
out_signature="s",
939
970
path_keyword='object_path',
947
978
connection)
948
979
try:
949
980
document = xml.dom.minidom.parseString(xmlstring)
981
950
982
def make_tag(document, name, prop):
951
983
e = document.createElement("property")
952
984
e.setAttribute("name", name)
953
985
e.setAttribute("type", prop._dbus_signature)
954
986
e.setAttribute("access", prop._dbus_access)
955
987
return e
988
956
989
for if_tag in document.getElementsByTagName("interface"):
957
990
# Add property tags
958
991
for tag in (make_tag(document, name, prop)
970
1003
if (name == tag.getAttribute("name")
971
1004
and prop._dbus_interface
972
1005
== if_tag.getAttribute("name")):
973
annots.update(getattr
974
(prop,
975
"_dbus_annotations",
976
{}))
977
for name, value in annots.iteritems():
1006
annots.update(getattr(
1007
prop, "_dbus_annotations", {}))
1008
for name, value in annots.items():
978
1009
ann_tag = document.createElement(
979
1010
"annotation")
980
1011
ann_tag.setAttribute("name", name)
983
1014
# Add interface annotation tags
984
1015
for annotation, value in dict(
985
1016
itertools.chain.from_iterable(
986
annotations().iteritems()
987
for name, annotations in
988
self._get_all_dbus_things("interface")
1017
annotations().items()
1018
for name, annotations
1019
in self._get_all_dbus_things("interface")
989
1020
if name == if_tag.getAttribute("name")
990
)).iteritems():
1021
)).items():
991
1022
ann_tag = document.createElement("annotation")
992
1023
ann_tag.setAttribute("name", annotation)
993
1024
ann_tag.setAttribute("value", value)
1020
1051
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1021
1052
if dt is None:
1022
1053
return dbus.String("", variant_level = variant_level)
1023
return dbus.String(dt.isoformat(),
1024
variant_level=variant_level)
1054
return dbus.String(dt.isoformat(), variant_level=variant_level)
1025
1055
1026
1056
1027
1057
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1047
1077
(from DBusObjectWithProperties) and interfaces (from the
1048
1078
dbus_interface_annotations decorator).
1049
1079
"""
1080
1050
1081
def wrapper(cls):
1051
1082
for orig_interface_name, alt_interface_name in (
1052
alt_interface_names.iteritems()):
1083
alt_interface_names.items()):
1053
1084
attr = {}
1054
1085
interface_names = set()
1055
1086
# Go though all attributes of the class
1057
1088
# Ignore non-D-Bus attributes, and D-Bus attributes
1058
1089
# with the wrong interface name
1059
1090
if (not hasattr(attribute, "_dbus_interface")
1060
or not attribute._dbus_interface
1061
.startswith(orig_interface_name)):
1091
or not attribute._dbus_interface.startswith(
1092
orig_interface_name)):
1062
1093
continue
1063
1094
# Create an alternate D-Bus interface name based on
1064
1095
# the current name
1065
alt_interface = (attribute._dbus_interface
1066
.replace(orig_interface_name,
1067
alt_interface_name))
1096
alt_interface = attribute._dbus_interface.replace(
1097
orig_interface_name, alt_interface_name)
1068
1098
interface_names.add(alt_interface)
1069
1099
# Is this a D-Bus signal?
1070
1100
if getattr(attribute, "_dbus_is_signal", False):
1071
# Extract the original non-method function by
1072
# black magic
1101
# Extract the original non-method undecorated
1102
# function by black magic
1073
1103
nonmethod_func = (dict(
1074
zip(attribute.func_code.co_freevars,
1075
attribute.__closure__))["func"]
1076
.cell_contents)
1104
zip(attribute.func_code.co_freevars,
1105
attribute.__closure__))
1106
["func"].cell_contents)
1077
1107
# Create a new, but exactly alike, function
1078
1108
# object, and decorate it to be a new D-Bus signal
1079
1109
# with the alternate D-Bus interface name
1080
new_function = (dbus.service.signal
1081
(alt_interface,
1082
attribute._dbus_signature)
1110
new_function = (dbus.service.signal(
1111
alt_interface, attribute._dbus_signature)
1083
1112
(types.FunctionType(
1084
nonmethod_func.func_code,
1085
nonmethod_func.func_globals,
1086
nonmethod_func.func_name,
1087
nonmethod_func.func_defaults,
1088
nonmethod_func.func_closure)))
1113
nonmethod_func.func_code,
1114
nonmethod_func.func_globals,
1115
nonmethod_func.func_name,
1116
nonmethod_func.func_defaults,
1117
nonmethod_func.func_closure)))
1089
1118
# Copy annotations, if any
1090
1119
try:
1091
new_function._dbus_annotations = (
1092
dict(attribute._dbus_annotations))
1120
new_function._dbus_annotations = dict(
1121
attribute._dbus_annotations)
1093
1122
except AttributeError:
1094
1123
pass
1095
1124
# Define a creator of a function to call both the
1100
1129
"""This function is a scope container to pass
1101
1130
func1 and func2 to the "call_both" function
1102
1131
outside of its arguments"""
1132
1103
1133
def call_both(*args, **kwargs):
1104
1134
"""This function will emit two D-Bus
1105
1135
signals by calling func1 and func2"""
1106
1136
func1(*args, **kwargs)
1107
1137
func2(*args, **kwargs)
1138
1108
1139
return call_both
1109
1140
# Create the "call_both" function and add it to
1110
1141
# the class
1115
1146
# object. Decorate it to be a new D-Bus method
1116
1147
# with the alternate D-Bus interface name. Add it
1117
1148
# to the class.
1118
attr[attrname] = (dbus.service.method
1119
(alt_interface,
1120
attribute._dbus_in_signature,
1121
attribute._dbus_out_signature)
1122
(types.FunctionType
1123
(attribute.func_code,
1124
attribute.func_globals,
1125
attribute.func_name,
1126
attribute.func_defaults,
1127
attribute.func_closure)))
1149
attr[attrname] = (
1150
dbus.service.method(
1151
alt_interface,
1152
attribute._dbus_in_signature,
1153
attribute._dbus_out_signature)
1154
(types.FunctionType(attribute.func_code,
1155
attribute.func_globals,
1156
attribute.func_name,
1157
attribute.func_defaults,
1158
attribute.func_closure)))
1128
1159
# Copy annotations, if any
1129
1160
try:
1130
attr[attrname]._dbus_annotations = (
1131
dict(attribute._dbus_annotations))
1161
attr[attrname]._dbus_annotations = dict(
1162
attribute._dbus_annotations)
1132
1163
except AttributeError:
1133
1164
pass
1134
1165
# Is this a D-Bus property?
1137
1168
# object, and decorate it to be a new D-Bus
1138
1169
# property with the alternate D-Bus interface
1139
1170
# name. Add it to the class.
1140
attr[attrname] = (dbus_service_property
1141
(alt_interface,
1142
attribute._dbus_signature,
1143
attribute._dbus_access,
1144
attribute
1145
._dbus_get_args_options
1146
["byte_arrays"])
1147
(types.FunctionType
1148
(attribute.func_code,
1149
attribute.func_globals,
1150
attribute.func_name,
1151
attribute.func_defaults,
1152
attribute.func_closure)))
1171
attr[attrname] = (dbus_service_property(
1172
alt_interface, attribute._dbus_signature,
1173
attribute._dbus_access,
1174
attribute._dbus_get_args_options
1175
["byte_arrays"])
1176
(types.FunctionType(
1177
attribute.func_code,
1178
attribute.func_globals,
1179
attribute.func_name,
1180
attribute.func_defaults,
1181
attribute.func_closure)))
1153
1182
# Copy annotations, if any
1154
1183
try:
1155
attr[attrname]._dbus_annotations = (
1156
dict(attribute._dbus_annotations))
1184
attr[attrname]._dbus_annotations = dict(
1185
attribute._dbus_annotations)
1157
1186
except AttributeError:
1158
1187
pass
1159
1188
# Is this a D-Bus interface?
1162
1191
# object. Decorate it to be a new D-Bus interface
1163
1192
# with the alternate D-Bus interface name. Add it
1164
1193
# to the class.
1165
attr[attrname] = (dbus_interface_annotations
1166
(alt_interface)
1167
(types.FunctionType
1168
(attribute.func_code,
1169
attribute.func_globals,
1170
attribute.func_name,
1171
attribute.func_defaults,
1172
attribute.func_closure)))
1194
attr[attrname] = (
1195
dbus_interface_annotations(alt_interface)
1196
(types.FunctionType(attribute.func_code,
1197
attribute.func_globals,
1198
attribute.func_name,
1199
attribute.func_defaults,
1200
attribute.func_closure)))
1173
1201
if deprecate:
1174
1202
# Deprecate all alternate interfaces
1175
iname="_AlternateDBusNames_interface_annotation{0}"
1203
iname="_AlternateDBusNames_interface_annotation{}"
1176
1204
for interface_name in interface_names:
1205
1177
1206
@dbus_interface_annotations(interface_name)
1178
1207
def func(self):
1179
1208
return { "org.freedesktop.DBus.Deprecated":
1180
"true" }
1209
"true" }
1181
1210
# Find an unused name
1182
1211
for aname in (iname.format(i)
1183
1212
for i in itertools.count()):
1187
1216
if interface_names:
1188
1217
# Replace the class with a new subclass of it with
1189
1218
# methods, signals, etc. as created above.
1190
cls = type(b"{0}Alternate".format(cls.__name__),
1191
(cls,), attr)
1219
cls = type(b"{}Alternate".format(cls.__name__),
1220
(cls, ), attr)
1192
1221
return cls
1222
1193
1223
return wrapper
1194
1224
1195
1225
1196
1226
@alternate_dbus_interfaces({"se.recompile.Mandos":
1197
"se.bsnet.fukt.Mandos"})
1227
"se.bsnet.fukt.Mandos"})
1198
1228
class ClientDBus(Client, DBusObjectWithProperties):
1199
1229
"""A Client class using D-Bus
1200
1230
1204
1234
"""
1205
1235
1206
1236
runtime_expansions = (Client.runtime_expansions
1207
+ ("dbus_object_path",))
1237
+ ("dbus_object_path", ))
1238
1239
_interface = "se.recompile.Mandos.Client"
1208
1240
1209
1241
# dbus.service.Object doesn't use super(), so we can't either.
1210
1242
1213
1245
Client.__init__(self, *args, **kwargs)
1214
1246
# Only now, when this client is initialized, can it show up on
1215
1247
# the D-Bus
1216
client_object_name = unicode(self.name).translate(
1248
client_object_name = str(self.name).translate(
1217
1249
{ord("."): ord("_"),
1218
1250
ord("-"): ord("_")})
1219
self.dbus_object_path = (dbus.ObjectPath
1220
("/clients/" + client_object_name))
1251
self.dbus_object_path = dbus.ObjectPath(
1252
"/clients/" + client_object_name)
1221
1253
DBusObjectWithProperties.__init__(self, self.bus,
1222
1254
self.dbus_object_path)
1223
1255
1224
def notifychangeproperty(transform_func,
1225
dbus_name, type_func=lambda x: x,
1226
variant_level=1):
1256
def notifychangeproperty(transform_func, dbus_name,
1257
type_func=lambda x: x,
1258
variant_level=1,
1259
invalidate_only=False,
1260
_interface=_interface):
1227
1261
""" Modify a variable so that it's a property which announces
1228
1262
its changes to DBus.
1229
1263
1234
1268
to the D-Bus. Default: no transform
1235
1269
variant_level: D-Bus variant level. Default: 1
1236
1270
"""
1237
attrname = "_{0}".format(dbus_name)
1271
attrname = "_{}".format(dbus_name)
1272
1238
1273
def setter(self, value):
1239
1274
if hasattr(self, "dbus_object_path"):
1240
1275
if (not hasattr(self, attrname) or
1241
1276
type_func(getattr(self, attrname, None))
1242
1277
!= type_func(value)):
1243
dbus_value = transform_func(type_func(value),
1244
variant_level
1245
=variant_level)
1246
self.PropertyChanged(dbus.String(dbus_name),
1247
dbus_value)
1278
if invalidate_only:
1279
self.PropertiesChanged(
1280
_interface, dbus.Dictionary(),
1281
dbus.Array((dbus_name, )))
1282
else:
1283
dbus_value = transform_func(
1284
type_func(value),
1285
variant_level = variant_level)
1286
self.PropertyChanged(dbus.String(dbus_name),
1287
dbus_value)
1288
self.PropertiesChanged(
1289
_interface,
1290
dbus.Dictionary({ dbus.String(dbus_name):
1291
dbus_value }),
1292
dbus.Array())
1248
1293
setattr(self, attrname, value)
1249
1294
1250
1295
return property(lambda self: getattr(self, attrname), setter)
1256
1301
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1257
1302
last_enabled = notifychangeproperty(datetime_to_dbus,
1258
1303
"LastEnabled")
1259
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
1260
type_func = lambda checker:
1261
checker is not None)
1304
checker = notifychangeproperty(
1305
dbus.Boolean, "CheckerRunning",
1306
type_func = lambda checker: checker is not None)
1262
1307
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1263
1308
"LastCheckedOK")
1264
1309
last_checker_status = notifychangeproperty(dbus.Int16,
1267
1312
datetime_to_dbus, "LastApprovalRequest")
1268
1313
approved_by_default = notifychangeproperty(dbus.Boolean,
1269
1314
"ApprovedByDefault")
1270
approval_delay = notifychangeproperty(dbus.UInt64,
1271
"ApprovalDelay",
1272
type_func =
1273
timedelta_to_milliseconds)
1315
approval_delay = notifychangeproperty(
1316
dbus.UInt64, "ApprovalDelay",
1317
type_func = lambda td: td.total_seconds() * 1000)
1274
1318
approval_duration = notifychangeproperty(
1275
1319
dbus.UInt64, "ApprovalDuration",
1276
type_func = timedelta_to_milliseconds)
1320
type_func = lambda td: td.total_seconds() * 1000)
1277
1321
host = notifychangeproperty(dbus.String, "Host")
1278
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1279
type_func =
1280
timedelta_to_milliseconds)
1322
timeout = notifychangeproperty(
1323
dbus.UInt64, "Timeout",
1324
type_func = lambda td: td.total_seconds() * 1000)
1281
1325
extended_timeout = notifychangeproperty(
1282
1326
dbus.UInt64, "ExtendedTimeout",
1283
type_func = timedelta_to_milliseconds)
1284
interval = notifychangeproperty(dbus.UInt64,
1285
"Interval",
1286
type_func =
1287
timedelta_to_milliseconds)
1327
type_func = lambda td: td.total_seconds() * 1000)
1328
interval = notifychangeproperty(
1329
dbus.UInt64, "Interval",
1330
type_func = lambda td: td.total_seconds() * 1000)
1288
1331
checker_command = notifychangeproperty(dbus.String, "Checker")
1332
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1333
invalidate_only=True)
1289
1334
1290
1335
del notifychangeproperty
1291
1336
1298
1343
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1299
1344
Client.__del__(self, *args, **kwargs)
1300
1345
1301
def checker_callback(self, pid, condition, command,
1302
*args, **kwargs):
1303
self.checker_callback_tag = None
1304
self.checker = None
1305
if os.WIFEXITED(condition):
1306
exitstatus = os.WEXITSTATUS(condition)
1346
def checker_callback(self, source, condition,
1347
(connection, command), *args, **kwargs):
1348
ret = Client.checker_callback(self, source, condition,
1349
(connection, command), *args,
1350
**kwargs)
1351
exitstatus = self.last_checker_status
1352
if exitstatus >= 0:
1307
1353
# Emit D-Bus signal
1308
1354
self.CheckerCompleted(dbus.Int16(exitstatus),
1309
dbus.Int64(condition),
1355
dbus.Int64(0),
1310
1356
dbus.String(command))
1311
1357
else:
1312
1358
# Emit D-Bus signal
1313
1359
self.CheckerCompleted(dbus.Int16(-1),
1314
dbus.Int64(condition),
1360
dbus.Int64(
1361
self.last_checker_signal),
1315
1362
dbus.String(command))
1316
1317
return Client.checker_callback(self, pid, condition, command,
1318
*args, **kwargs)
1363
return ret
1319
1364
1320
1365
def start_checker(self, *args, **kwargs):
1321
old_checker = self.checker
1322
if self.checker is not None:
1323
old_checker_pid = self.checker.pid
1324
else:
1325
old_checker_pid = None
1366
old_checker_pid = getattr(self.checker, "pid", None)
1326
1367
r = Client.start_checker(self, *args, **kwargs)
1327
1368
# Only if new checker process was started
1328
1369
if (self.checker is not None
1337
1378
1338
1379
def approve(self, value=True):
1339
1380
self.approved = value
1340
gobject.timeout_add(timedelta_to_milliseconds
1341
(self.approval_duration),
1342
self._reset_approved)
1381
gobject.timeout_add(int(self.approval_duration.total_seconds()
1382
* 1000), self._reset_approved)
1343
1383
self.send_changedstate()
1344
1384
1345
1385
## D-Bus methods, signals & properties
1346
_interface = "se.recompile.Mandos.Client"
1347
1386
1348
1387
## Interfaces
1349
1388
1350
@dbus_interface_annotations(_interface)
1351
def _foo(self):
1352
return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
1353
"false"}
1354
1355
1389
## Signals
1356
1390
1357
1391
# CheckerCompleted - signal
1367
1401
pass
1368
1402
1369
1403
# PropertyChanged - signal
1404
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1370
1405
@dbus.service.signal(_interface, signature="sv")
1371
1406
def PropertyChanged(self, property, value):
1372
1407
"D-Bus signal"
1436
1471
return dbus.Boolean(bool(self.approvals_pending))
1437
1472
1438
1473
# ApprovedByDefault - property
1439
@dbus_service_property(_interface, signature="b",
1474
@dbus_service_property(_interface,
1475
signature="b",
1440
1476
access="readwrite")
1441
1477
def ApprovedByDefault_dbus_property(self, value=None):
1442
1478
if value is None: # get
1444
1480
self.approved_by_default = bool(value)
1445
1481
1446
1482
# ApprovalDelay - property
1447
@dbus_service_property(_interface, signature="t",
1483
@dbus_service_property(_interface,
1484
signature="t",
1448
1485
access="readwrite")
1449
1486
def ApprovalDelay_dbus_property(self, value=None):
1450
1487
if value is None: # get
1451
return dbus.UInt64(self.approval_delay_milliseconds())
1488
return dbus.UInt64(self.approval_delay.total_seconds()
1489
* 1000)
1452
1490
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1453
1491
1454
1492
# ApprovalDuration - property
1455
@dbus_service_property(_interface, signature="t",
1493
@dbus_service_property(_interface,
1494
signature="t",
1456
1495
access="readwrite")
1457
1496
def ApprovalDuration_dbus_property(self, value=None):
1458
1497
if value is None: # get
1459
return dbus.UInt64(timedelta_to_milliseconds(
1460
self.approval_duration))
1498
return dbus.UInt64(self.approval_duration.total_seconds()
1499
* 1000)
1461
1500
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1462
1501
1463
1502
# Name - property
1471
1510
return dbus.String(self.fingerprint)
1472
1511
1473
1512
# Host - property
1474
@dbus_service_property(_interface, signature="s",
1513
@dbus_service_property(_interface,
1514
signature="s",
1475
1515
access="readwrite")
1476
1516
def Host_dbus_property(self, value=None):
1477
1517
if value is None: # get
1478
1518
return dbus.String(self.host)
1479
self.host = unicode(value)
1519
self.host = str(value)
1480
1520
1481
1521
# Created - property
1482
1522
@dbus_service_property(_interface, signature="s", access="read")
1489
1529
return datetime_to_dbus(self.last_enabled)
1490
1530
1491
1531
# Enabled - property
1492
@dbus_service_property(_interface, signature="b",
1532
@dbus_service_property(_interface,
1533
signature="b",
1493
1534
access="readwrite")
1494
1535
def Enabled_dbus_property(self, value=None):
1495
1536
if value is None: # get
1500
1541
self.disable()
1501
1542
1502
1543
# LastCheckedOK - property
1503
@dbus_service_property(_interface, signature="s",
1544
@dbus_service_property(_interface,
1545
signature="s",
1504
1546
access="readwrite")
1505
1547
def LastCheckedOK_dbus_property(self, value=None):
1506
1548
if value is not None:
1509
1551
return datetime_to_dbus(self.last_checked_ok)
1510
1552
1511
1553
# LastCheckerStatus - property
1512
@dbus_service_property(_interface, signature="n",
1513
access="read")
1554
@dbus_service_property(_interface, signature="n", access="read")
1514
1555
def LastCheckerStatus_dbus_property(self):
1515
1556
return dbus.Int16(self.last_checker_status)
1516
1557
1525
1566
return datetime_to_dbus(self.last_approval_request)
1526
1567
1527
1568
# Timeout - property
1528
@dbus_service_property(_interface, signature="t",
1569
@dbus_service_property(_interface,
1570
signature="t",
1529
1571
access="readwrite")
1530
1572
def Timeout_dbus_property(self, value=None):
1531
1573
if value is None: # get
1532
return dbus.UInt64(self.timeout_milliseconds())
1574
return dbus.UInt64(self.timeout.total_seconds() * 1000)
1533
1575
old_timeout = self.timeout
1534
1576
self.timeout = datetime.timedelta(0, 0, 0, value)
1535
1577
# Reschedule disabling
1544
1586
is None):
1545
1587
return
1546
1588
gobject.source_remove(self.disable_initiator_tag)
1547
self.disable_initiator_tag = (
1548
gobject.timeout_add(
1549
timedelta_to_milliseconds(self.expires - now),
1550
self.disable))
1589
self.disable_initiator_tag = gobject.timeout_add(
1590
int((self.expires - now).total_seconds() * 1000),
1591
self.disable)
1551
1592
1552
1593
# ExtendedTimeout - property
1553
@dbus_service_property(_interface, signature="t",
1594
@dbus_service_property(_interface,
1595
signature="t",
1554
1596
access="readwrite")
1555
1597
def ExtendedTimeout_dbus_property(self, value=None):
1556
1598
if value is None: # get
1557
return dbus.UInt64(self.extended_timeout_milliseconds())
1599
return dbus.UInt64(self.extended_timeout.total_seconds()
1600
* 1000)
1558
1601
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1559
1602
1560
1603
# Interval - property
1561
@dbus_service_property(_interface, signature="t",
1604
@dbus_service_property(_interface,
1605
signature="t",
1562
1606
access="readwrite")
1563
1607
def Interval_dbus_property(self, value=None):
1564
1608
if value is None: # get
1565
return dbus.UInt64(self.interval_milliseconds())
1609
return dbus.UInt64(self.interval.total_seconds() * 1000)
1566
1610
self.interval = datetime.timedelta(0, 0, 0, value)
1567
1611
if getattr(self, "checker_initiator_tag", None) is None:
1568
1612
return
1569
1613
if self.enabled:
1570
1614
# Reschedule checker run
1571
1615
gobject.source_remove(self.checker_initiator_tag)
1572
self.checker_initiator_tag = (gobject.timeout_add
1573
(value, self.start_checker))
1574
self.start_checker() # Start one now, too
1616
self.checker_initiator_tag = gobject.timeout_add(
1617
value, self.start_checker)
1618
self.start_checker() # Start one now, too
1575
1619
1576
1620
# Checker - property
1577
@dbus_service_property(_interface, signature="s",
1621
@dbus_service_property(_interface,
1622
signature="s",
1578
1623
access="readwrite")
1579
1624
def Checker_dbus_property(self, value=None):
1580
1625
if value is None: # get
1581
1626
return dbus.String(self.checker_command)
1582
self.checker_command = unicode(value)
1627
self.checker_command = str(value)
1583
1628
1584
1629
# CheckerRunning - property
1585
@dbus_service_property(_interface, signature="b",
1630
@dbus_service_property(_interface,
1631
signature="b",
1586
1632
access="readwrite")
1587
1633
def CheckerRunning_dbus_property(self, value=None):
1588
1634
if value is None: # get
1598
1644
return self.dbus_object_path # is already a dbus.ObjectPath
1599
1645
1600
1646
# Secret = property
1601
@dbus_service_property(_interface, signature="ay",
1602
access="write", byte_arrays=True)
1647
@dbus_service_property(_interface,
1648
signature="ay",
1649
access="write",
1650
byte_arrays=True)
1603
1651
def Secret_dbus_property(self, value):
1604
self.secret = str(value)
1652
self.secret = bytes(value)
1605
1653
1606
1654
del _interface
1607
1655
1621
1669
if data[0] == 'data':
1622
1670
return data[1]
1623
1671
if data[0] == 'function':
1672
1624
1673
def func(*args, **kwargs):
1625
1674
self._pipe.send(('funcall', name, args, kwargs))
1626
1675
return self._pipe.recv()[1]
1676
1627
1677
return func
1628
1678
1629
1679
def __setattr__(self, name, value):
1641
1691
def handle(self):
1642
1692
with contextlib.closing(self.server.child_pipe) as child_pipe:
1643
1693
logger.info("TCP connection from: %s",
1644
unicode(self.client_address))
1694
str(self.client_address))
1645
1695
logger.debug("Pipe FD: %d",
1646
1696
self.server.child_pipe.fileno())
1647
1697
1648
session = (gnutls.connection
1649
.ClientSession(self.request,
1650
gnutls.connection
1651
.X509Credentials()))
1698
session = gnutls.connection.ClientSession(
1699
self.request, gnutls.connection .X509Credentials())
1652
1700
1653
1701
# Note: gnutls.connection.X509Credentials is really a
1654
1702
# generic GnuTLS certificate credentials object so long as
1663
1711
priority = self.server.gnutls_priority
1664
1712
if priority is None:
1665
1713
priority = "NORMAL"
1666
(gnutls.library.functions
1667
.gnutls_priority_set_direct(session._c_object,
1668
priority, None))
1714
gnutls.library.functions.gnutls_priority_set_direct(
1715
session._c_object, priority, None)
1669
1716
1670
1717
# Start communication using the Mandos protocol
1671
1718
# Get protocol number
1673
1720
logger.debug("Protocol version: %r", line)
1674
1721
try:
1675
1722
if int(line.strip().split()[0]) > 1:
1676
raise RuntimeError
1723
raise RuntimeError(line)
1677
1724
except (ValueError, IndexError, RuntimeError) as error:
1678
1725
logger.error("Unknown protocol version: %s", error)
1679
1726
return
1691
1738
approval_required = False
1692
1739
try:
1693
1740
try:
1694
fpr = self.fingerprint(self.peer_certificate
1695
(session))
1741
fpr = self.fingerprint(
1742
self.peer_certificate(session))
1696
1743
except (TypeError,
1697
1744
gnutls.errors.GNUTLSError) as error:
1698
1745
logger.warning("Bad certificate: %s", error)
1713
1760
while True:
1714
1761
if not client.enabled:
1715
1762
logger.info("Client %s is disabled",
1716
client.name)
1763
client.name)
1717
1764
if self.server.use_dbus:
1718
1765
# Emit D-Bus signal
1719
1766
client.Rejected("Disabled")
1728
1775
if self.server.use_dbus:
1729
1776
# Emit D-Bus signal
1730
1777
client.NeedApproval(
1731
client.approval_delay_milliseconds(),
1732
client.approved_by_default)
1778
client.approval_delay.total_seconds()
1779
* 1000, client.approved_by_default)
1733
1780
else:
1734
1781
logger.warning("Client %s was not approved",
1735
1782
client.name)
1741
1788
#wait until timeout or approved
1742
1789
time = datetime.datetime.now()
1743
1790
client.changedstate.acquire()
1744
client.changedstate.wait(
1745
float(timedelta_to_milliseconds(delay)
1746
/ 1000))
1791
client.changedstate.wait(delay.total_seconds())
1747
1792
client.changedstate.release()
1748
1793
time2 = datetime.datetime.now()
1749
1794
if (time2 - time) >= delay:
1768
1813
logger.warning("gnutls send failed",
1769
1814
exc_info=error)
1770
1815
return
1771
logger.debug("Sent: %d, remaining: %d",
1772
sent, len(client.secret)
1773
- (sent_size + sent))
1816
logger.debug("Sent: %d, remaining: %d", sent,
1817
len(client.secret) - (sent_size
1818
+ sent))
1774
1819
sent_size += sent
1775
1820
1776
1821
logger.info("Sending secret to %s", client.name)
1793
1838
def peer_certificate(session):
1794
1839
"Return the peer's OpenPGP certificate as a bytestring"
1795
1840
# If not an OpenPGP certificate...
1796
if (gnutls.library.functions
1797
.gnutls_certificate_type_get(session._c_object)
1841
if (gnutls.library.functions.gnutls_certificate_type_get(
1842
session._c_object)
1798
1843
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1799
1844
# ...do the normal thing
1800
1845
return session.peer_certificate
1814
1859
def fingerprint(openpgp):
1815
1860
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1816
1861
# New GnuTLS "datum" with the OpenPGP public key
1817
datum = (gnutls.library.types
1818
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1819
ctypes.POINTER
1820
(ctypes.c_ubyte)),
1821
ctypes.c_uint(len(openpgp))))
1862
datum = gnutls.library.types.gnutls_datum_t(
1863
ctypes.cast(ctypes.c_char_p(openpgp),
1864
ctypes.POINTER(ctypes.c_ubyte)),
1865
ctypes.c_uint(len(openpgp)))
1822
1866
# New empty GnuTLS certificate
1823
1867
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1824
(gnutls.library.functions
1825
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1868
gnutls.library.functions.gnutls_openpgp_crt_init(
1869
ctypes.byref(crt))
1826
1870
# Import the OpenPGP public key into the certificate
1827
(gnutls.library.functions
1828
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1829
gnutls.library.constants
1830
.GNUTLS_OPENPGP_FMT_RAW))
1871
gnutls.library.functions.gnutls_openpgp_crt_import(
1872
crt, ctypes.byref(datum),
1873
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
1831
1874
# Verify the self signature in the key
1832
1875
crtverify = ctypes.c_uint()
1833
(gnutls.library.functions
1834
.gnutls_openpgp_crt_verify_self(crt, 0,
1835
ctypes.byref(crtverify)))
1876
gnutls.library.functions.gnutls_openpgp_crt_verify_self(
1877
crt, 0, ctypes.byref(crtverify))
1836
1878
if crtverify.value != 0:
1837
1879
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1838
raise (gnutls.errors.CertificateSecurityError
1839
("Verify failed"))
1880
raise gnutls.errors.CertificateSecurityError(
1881
"Verify failed")
1840
1882
# New buffer for the fingerprint
1841
1883
buf = ctypes.create_string_buffer(20)
1842
1884
buf_len = ctypes.c_size_t()
1843
1885
# Get the fingerprint from the certificate into the buffer
1844
(gnutls.library.functions
1845
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1846
ctypes.byref(buf_len)))
1886
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint(
1887
crt, ctypes.byref(buf), ctypes.byref(buf_len))
1847
1888
# Deinit the certificate
1848
1889
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1849
1890
# Convert the buffer to a Python bytestring
1855
1896
1856
1897
class MultiprocessingMixIn(object):
1857
1898
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1899
1858
1900
def sub_process_main(self, request, address):
1859
1901
try:
1860
1902
self.finish_request(request, address)
1872
1914
1873
1915
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1874
1916
""" adds a pipe to the MixIn """
1917
1875
1918
def process_request(self, request, client_address):
1876
1919
"""Overrides and wraps the original process_request().
1877
1920
1886
1929
1887
1930
def add_pipe(self, parent_pipe, proc):
1888
1931
"""Dummy function; override as necessary"""
1889
raise NotImplementedError
1932
raise NotImplementedError()
1890
1933
1891
1934
1892
1935
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1898
1941
interface: None or a network interface name (string)
1899
1942
use_ipv6: Boolean; to use IPv6 or not
1900
1943
"""
1944
1901
1945
def __init__(self, server_address, RequestHandlerClass,
1902
interface=None, use_ipv6=True, socketfd=None):
1946
interface=None,
1947
use_ipv6=True,
1948
socketfd=None):
1903
1949
"""If socketfd is set, use that file descriptor instead of
1904
1950
creating a new one with socket.socket().
1905
1951
"""
1946
1992
self.interface)
1947
1993
else:
1948
1994
try:
1949
self.socket.setsockopt(socket.SOL_SOCKET,
1950
SO_BINDTODEVICE,
1951
str(self.interface
1952
+ '\0'))
1995
self.socket.setsockopt(
1996
socket.SOL_SOCKET, SO_BINDTODEVICE,
1997
(self.interface + "\0").encode("utf-8"))
1953
1998
except socket.error as error:
1954
1999
if error.errno == errno.EPERM:
1955
logger.error("No permission to"
1956
" bind to interface %s",
1957
self.interface)
2000
logger.error("No permission to bind to"
2001
" interface %s", self.interface)
1958
2002
elif error.errno == errno.ENOPROTOOPT:
1959
2003
logger.error("SO_BINDTODEVICE not available;"
1960
2004
" cannot bind to interface %s",
1961
2005
self.interface)
1962
2006
elif error.errno == errno.ENODEV:
1963
logger.error("Interface %s does not"
1964
" exist, cannot bind",
1965
self.interface)
2007
logger.error("Interface %s does not exist,"
2008
" cannot bind", self.interface)
1966
2009
else:
1967
2010
raise
1968
2011
# Only bind(2) the socket if we really need to.
1971
2014
if self.address_family == socket.AF_INET6:
1972
2015
any_address = "::" # in6addr_any
1973
2016
else:
1974
any_address = socket.INADDR_ANY
2017
any_address = "0.0.0.0" # INADDR_ANY
1975
2018
self.server_address = (any_address,
1976
2019
self.server_address[1])
1977
2020
elif not self.server_address[1]:
1978
self.server_address = (self.server_address[0],
1979
0)
2021
self.server_address = (self.server_address[0], 0)
1980
2022
# if self.interface:
1981
2023
# self.server_address = (self.server_address[0],
1982
2024
# 0, # port
1996
2038
1997
2039
Assumes a gobject.MainLoop event loop.
1998
2040
"""
2041
1999
2042
def __init__(self, server_address, RequestHandlerClass,
2000
interface=None, use_ipv6=True, clients=None,
2001
gnutls_priority=None, use_dbus=True, socketfd=None):
2043
interface=None,
2044
use_ipv6=True,
2045
clients=None,
2046
gnutls_priority=None,
2047
use_dbus=True,
2048
socketfd=None):
2002
2049
self.enabled = False
2003
2050
self.clients = clients
2004
2051
if self.clients is None:
2010
2057
interface = interface,
2011
2058
use_ipv6 = use_ipv6,
2012
2059
socketfd = socketfd)
2060
2013
2061
def server_activate(self):
2014
2062
if self.enabled:
2015
2063
return socketserver.TCPServer.server_activate(self)
2019
2067
2020
2068
def add_pipe(self, parent_pipe, proc):
2021
2069
# Call "handle_ipc" for both data and EOF events
2022
gobject.io_add_watch(parent_pipe.fileno(),
2023
gobject.IO_IN | gobject.IO_HUP,
2024
functools.partial(self.handle_ipc,
2025
parent_pipe =
2026
parent_pipe,
2027
proc = proc))
2070
gobject.io_add_watch(
2071
parent_pipe.fileno(),
2072
gobject.IO_IN | gobject.IO_HUP,
2073
functools.partial(self.handle_ipc,
2074
parent_pipe = parent_pipe,
2075
proc = proc))
2028
2076
2029
def handle_ipc(self, source, condition, parent_pipe=None,
2030
proc = None, client_object=None):
2077
def handle_ipc(self, source, condition,
2078
parent_pipe=None,
2079
proc = None,
2080
client_object=None):
2031
2081
# error, or the other end of multiprocessing.Pipe has closed
2032
2082
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2033
2083
# Wait for other process to exit
2056
2106
parent_pipe.send(False)
2057
2107
return False
2058
2108
2059
gobject.io_add_watch(parent_pipe.fileno(),
2060
gobject.IO_IN | gobject.IO_HUP,
2061
functools.partial(self.handle_ipc,
2062
parent_pipe =
2063
parent_pipe,
2064
proc = proc,
2065
client_object =
2066
client))
2109
gobject.io_add_watch(
2110
parent_pipe.fileno(),
2111
gobject.IO_IN | gobject.IO_HUP,
2112
functools.partial(self.handle_ipc,
2113
parent_pipe = parent_pipe,
2114
proc = proc,
2115
client_object = client))
2067
2116
parent_pipe.send(True)
2068
2117
# remove the old hook in favor of the new above hook on
2069
2118
# same fileno
2075
2124
2076
2125
parent_pipe.send(('data', getattr(client_object,
2077
2126
funcname)(*args,
2078
**kwargs)))
2127
**kwargs)))
2079
2128
2080
2129
if command == 'getattr':
2081
2130
attrname = request[1]
2082
2131
if callable(client_object.__getattribute__(attrname)):
2083
parent_pipe.send(('function',))
2132
parent_pipe.send(('function', ))
2084
2133
else:
2085
parent_pipe.send(('data', client_object
2086
.__getattribute__(attrname)))
2134
parent_pipe.send((
2135
'data', client_object.__getattribute__(attrname)))
2087
2136
2088
2137
if command == 'setattr':
2089
2138
attrname = request[1]
2093
2142
return True
2094
2143
2095
2144
2145
def rfc3339_duration_to_delta(duration):
2146
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2147
2148
>>> rfc3339_duration_to_delta("P7D")
2149
datetime.timedelta(7)
2150
>>> rfc3339_duration_to_delta("PT60S")
2151
datetime.timedelta(0, 60)
2152
>>> rfc3339_duration_to_delta("PT60M")
2153
datetime.timedelta(0, 3600)
2154
>>> rfc3339_duration_to_delta("PT24H")
2155
datetime.timedelta(1)
2156
>>> rfc3339_duration_to_delta("P1W")
2157
datetime.timedelta(7)
2158
>>> rfc3339_duration_to_delta("PT5M30S")
2159
datetime.timedelta(0, 330)
2160
>>> rfc3339_duration_to_delta("P1DT3M20S")
2161
datetime.timedelta(1, 200)
2162
"""
2163
2164
# Parsing an RFC 3339 duration with regular expressions is not
2165
# possible - there would have to be multiple places for the same
2166
# values, like seconds. The current code, while more esoteric, is
2167
# cleaner without depending on a parsing library. If Python had a
2168
# built-in library for parsing we would use it, but we'd like to
2169
# avoid excessive use of external libraries.
2170
2171
# New type for defining tokens, syntax, and semantics all-in-one
2172
Token = collections.namedtuple("Token",
2173
("regexp", # To match token; if
2174
# "value" is not None,
2175
# must have a "group"
2176
# containing digits
2177
"value", # datetime.timedelta or
2178
# None
2179
"followers")) # Tokens valid after
2180
# this token
2181
Token = collections.namedtuple("Token", (
2182
"regexp", # To match token; if "value" is not None, must have
2183
# a "group" containing digits
2184
"value", # datetime.timedelta or None
2185
"followers")) # Tokens valid after this token
2186
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2187
# the "duration" ABNF definition in RFC 3339, Appendix A.
2188
token_end = Token(re.compile(r"$"), None, frozenset())
2189
token_second = Token(re.compile(r"(\d+)S"),
2190
datetime.timedelta(seconds=1),
2191
frozenset((token_end, )))
2192
token_minute = Token(re.compile(r"(\d+)M"),
2193
datetime.timedelta(minutes=1),
2194
frozenset((token_second, token_end)))
2195
token_hour = Token(re.compile(r"(\d+)H"),
2196
datetime.timedelta(hours=1),
2197
frozenset((token_minute, token_end)))
2198
token_time = Token(re.compile(r"T"),
2199
None,
2200
frozenset((token_hour, token_minute,
2201
token_second)))
2202
token_day = Token(re.compile(r"(\d+)D"),
2203
datetime.timedelta(days=1),
2204
frozenset((token_time, token_end)))
2205
token_month = Token(re.compile(r"(\d+)M"),
2206
datetime.timedelta(weeks=4),
2207
frozenset((token_day, token_end)))
2208
token_year = Token(re.compile(r"(\d+)Y"),
2209
datetime.timedelta(weeks=52),
2210
frozenset((token_month, token_end)))
2211
token_week = Token(re.compile(r"(\d+)W"),
2212
datetime.timedelta(weeks=1),
2213
frozenset((token_end, )))
2214
token_duration = Token(re.compile(r"P"), None,
2215
frozenset((token_year, token_month,
2216
token_day, token_time,
2217
token_week)))
2218
# Define starting values
2219
value = datetime.timedelta() # Value so far
2220
found_token = None
2221
followers = frozenset((token_duration,)) # Following valid tokens
2222
s = duration # String left to parse
2223
# Loop until end token is found
2224
while found_token is not token_end:
2225
# Search for any currently valid tokens
2226
for token in followers:
2227
match = token.regexp.match(s)
2228
if match is not None:
2229
# Token found
2230
if token.value is not None:
2231
# Value found, parse digits
2232
factor = int(match.group(1), 10)
2233
# Add to value so far
2234
value += factor * token.value
2235
# Strip token from string
2236
s = token.regexp.sub("", s, 1)
2237
# Go to found token
2238
found_token = token
2239
# Set valid next tokens
2240
followers = found_token.followers
2241
break
2242
else:
2243
# No currently valid tokens were found
2244
raise ValueError("Invalid RFC 3339 duration")
2245
# End token found
2246
return value
2247
2248
2096
2249
def string_to_delta(interval):
2097
2250
"""Parse a string and return a datetime.timedelta
2098
2251
2109
2262
>>> string_to_delta('5m 30s')
2110
2263
datetime.timedelta(0, 330)
2111
2264
"""
2265
2266
try:
2267
return rfc3339_duration_to_delta(interval)
2268
except ValueError:
2269
pass
2270
2112
2271
timevalue = datetime.timedelta(0)
2113
2272
for s in interval.split():
2114
2273
try:
2115
suffix = unicode(s[-1])
2274
suffix = s[-1]
2116
2275
value = int(s[:-1])
2117
2276
if suffix == "d":
2118
2277
delta = datetime.timedelta(value)
2125
2284
elif suffix == "w":
2126
2285
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2127
2286
else:
2128
raise ValueError("Unknown suffix {0!r}"
2129
.format(suffix))
2130
except (ValueError, IndexError) as e:
2287
raise ValueError("Unknown suffix {!r}".format(suffix))
2288
except IndexError as e:
2131
2289
raise ValueError(*(e.args))
2132
2290
timevalue += delta
2133
2291
return timevalue
2149
2307
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2150
2308
if not stat.S_ISCHR(os.fstat(null).st_mode):
2151
2309
raise OSError(errno.ENODEV,
2152
"{0} not a character device"
2310
"{} not a character device"
2153
2311
.format(os.devnull))
2154
2312
os.dup2(null, sys.stdin.fileno())
2155
2313
os.dup2(null, sys.stdout.fileno())
2165
2323
2166
2324
parser = argparse.ArgumentParser()
2167
2325
parser.add_argument("-v", "--version", action="version",
2168
version = "%(prog)s {0}".format(version),
2326
version = "%(prog)s {}".format(version),
2169
2327
help="show version number and exit")
2170
2328
parser.add_argument("-i", "--interface", metavar="IF",
2171
2329
help="Bind to interface IF")
2177
2335
help="Run self-test")
2178
2336
parser.add_argument("--debug", action="store_true",
2179
2337
help="Debug mode; run in foreground and log"
2180
" to terminal")
2338
" to terminal", default=None)
2181
2339
parser.add_argument("--debuglevel", metavar="LEVEL",
2182
2340
help="Debug level for stdout output")
2183
2341
parser.add_argument("--priority", help="GnuTLS"
2190
2348
" files")
2191
2349
parser.add_argument("--no-dbus", action="store_false",
2192
2350
dest="use_dbus", help="Do not provide D-Bus"
2193
" system bus interface")
2351
" system bus interface", default=None)
2194
2352
parser.add_argument("--no-ipv6", action="store_false",
2195
dest="use_ipv6", help="Do not use IPv6")
2353
dest="use_ipv6", help="Do not use IPv6",
2354
default=None)
2196
2355
parser.add_argument("--no-restore", action="store_false",
2197
2356
dest="restore", help="Do not restore stored"
2198
" state")
2357
" state", default=None)
2199
2358
parser.add_argument("--socket", type=int,
2200
2359
help="Specify a file descriptor to a network"
2201
2360
" socket to use instead of creating one")
2202
2361
parser.add_argument("--statedir", metavar="DIR",
2203
2362
help="Directory to save/restore state in")
2363
parser.add_argument("--foreground", action="store_true",
2364
help="Run in foreground", default=None)
2365
parser.add_argument("--no-zeroconf", action="store_false",
2366
dest="zeroconf", help="Do not use Zeroconf",
2367
default=None)
2204
2368
2205
2369
options = parser.parse_args()
2206
2370
2207
2371
if options.check:
2208
2372
import doctest
2209
doctest.testmod()
2210
sys.exit()
2373
fail_count, test_count = doctest.testmod()
2374
sys.exit(os.EX_OK if fail_count == 0 else 1)
2211
2375
2212
2376
# Default values for config file for server-global settings
2213
2377
server_defaults = { "interface": "",
2215
2379
"port": "",
2216
2380
"debug": "False",
2217
2381
"priority":
2218
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2382
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2383
":+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2219
2384
"servicename": "Mandos",
2220
2385
"use_dbus": "True",
2221
2386
"use_ipv6": "True",
2222
2387
"debuglevel": "",
2223
2388
"restore": "True",
2224
2389
"socket": "",
2225
"statedir": "/var/lib/mandos"
2226
}
2390
"statedir": "/var/lib/mandos",
2391
"foreground": "False",
2392
"zeroconf": "True",
2393
}
2227
2394
2228
2395
# Parse config file for server-global settings
2229
2396
server_config = configparser.SafeConfigParser(server_defaults)
2230
2397
del server_defaults
2231
server_config.read(os.path.join(options.configdir,
2232
"mandos.conf"))
2398
server_config.read(os.path.join(options.configdir, "mandos.conf"))
2233
2399
# Convert the SafeConfigParser object to a dict
2234
2400
server_settings = server_config.defaults()
2235
2401
# Use the appropriate methods on the non-string config options
2236
for option in ("debug", "use_dbus", "use_ipv6"):
2402
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2237
2403
server_settings[option] = server_config.getboolean("DEFAULT",
2238
2404
option)
2239
2405
if server_settings["port"]:
2242
2408
if server_settings["socket"]:
2243
2409
server_settings["socket"] = server_config.getint("DEFAULT",
2244
2410
"socket")
2245
# Later, stdin will, and stdout, and stderr might, be dup'ed
2411
# Later, stdin will, and stdout and stderr might, be dup'ed
2246
2412
# over with an opened os.devnull. But we don't want this to
2247
2413
# happen with a supplied network socket.
2248
2414
if 0 <= server_settings["socket"] <= 2:
2253
2419
# Override the settings from the config file with command line
2254
2420
# options, if set.
2255
2421
for option in ("interface", "address", "port", "debug",
2256
"priority", "servicename", "configdir",
2257
"use_dbus", "use_ipv6", "debuglevel", "restore",
2258
"statedir", "socket"):
2422
"priority", "servicename", "configdir", "use_dbus",
2423
"use_ipv6", "debuglevel", "restore", "statedir",
2424
"socket", "foreground", "zeroconf"):
2259
2425
value = getattr(options, option)
2260
2426
if value is not None:
2261
2427
server_settings[option] = value
2262
2428
del options
2263
2429
# Force all strings to be unicode
2264
2430
for option in server_settings.keys():
2265
if type(server_settings[option]) is str:
2266
server_settings[option] = unicode(server_settings[option])
2431
if isinstance(server_settings[option], bytes):
2432
server_settings[option] = (server_settings[option]
2433
.decode("utf-8"))
2434
# Force all boolean options to be boolean
2435
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2436
"foreground", "zeroconf"):
2437
server_settings[option] = bool(server_settings[option])
2438
# Debug implies foreground
2439
if server_settings["debug"]:
2440
server_settings["foreground"] = True
2267
2441
# Now we have our good server settings in "server_settings"
2268
2442
2269
2443
##################################################################
2270
2444
2445
if (not server_settings["zeroconf"]
2446
and not (server_settings["port"]
2447
or server_settings["socket"] != "")):
2448
parser.error("Needs port or socket to work without Zeroconf")
2449
2271
2450
# For convenience
2272
2451
debug = server_settings["debug"]
2273
2452
debuglevel = server_settings["debuglevel"]
2275
2454
use_ipv6 = server_settings["use_ipv6"]
2276
2455
stored_state_path = os.path.join(server_settings["statedir"],
2277
2456
stored_state_file)
2457
foreground = server_settings["foreground"]
2458
zeroconf = server_settings["zeroconf"]
2278
2459
2279
2460
if debug:
2280
2461
initlogger(debug, logging.DEBUG)
2286
2467
initlogger(debug, level)
2287
2468
2288
2469
if server_settings["servicename"] != "Mandos":
2289
syslogger.setFormatter(logging.Formatter
2290
('Mandos ({0}) [%(process)d]:'
2291
' %(levelname)s: %(message)s'
2292
.format(server_settings
2293
["servicename"])))
2470
syslogger.setFormatter(
2471
logging.Formatter('Mandos ({}) [%(process)d]:'
2472
' %(levelname)s: %(message)s'.format(
2473
server_settings["servicename"])))
2294
2474
2295
2475
# Parse config file with clients
2296
2476
client_config = configparser.SafeConfigParser(Client
2301
2481
global mandos_dbus_service
2302
2482
mandos_dbus_service = None
2303
2483
2304
tcp_server = MandosServer((server_settings["address"],
2305
server_settings["port"]),
2306
ClientHandler,
2307
interface=(server_settings["interface"]
2308
or None),
2309
use_ipv6=use_ipv6,
2310
gnutls_priority=
2311
server_settings["priority"],
2312
use_dbus=use_dbus,
2313
socketfd=(server_settings["socket"]
2314
or None))
2315
if not debug:
2316
pidfilename = "/var/run/mandos.pid"
2484
socketfd = None
2485
if server_settings["socket"] != "":
2486
socketfd = server_settings["socket"]
2487
tcp_server = MandosServer(
2488
(server_settings["address"], server_settings["port"]),
2489
ClientHandler,
2490
interface=(server_settings["interface"] or None),
2491
use_ipv6=use_ipv6,
2492
gnutls_priority=server_settings["priority"],
2493
use_dbus=use_dbus,
2494
socketfd=socketfd)
2495
if not foreground:
2496
pidfilename = "/run/mandos.pid"
2497
if not os.path.isdir("/run/."):
2498
pidfilename = "/var/run/mandos.pid"
2499
pidfile = None
2317
2500
try:
2318
2501
pidfile = open(pidfilename, "w")
2319
2502
except IOError as e:
2335
2518
os.setuid(uid)
2336
2519
except OSError as error:
2337
2520
if error.errno != errno.EPERM:
2338
raise error
2521
raise
2339
2522
2340
2523
if debug:
2341
2524
# Enable all possible GnuTLS debugging
2348
2531
def debug_gnutls(level, string):
2349
2532
logger.debug("GnuTLS: %s", string[:-1])
2350
2533
2351
(gnutls.library.functions
2352
.gnutls_global_set_log_function(debug_gnutls))
2534
gnutls.library.functions.gnutls_global_set_log_function(
2535
debug_gnutls)
2353
2536
2354
2537
# Redirect stdin so all checkers get /dev/null
2355
2538
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2358
2541
os.close(null)
2359
2542
2360
2543
# Need to fork before connecting to D-Bus
2361
if not debug:
2544
if not foreground:
2362
2545
# Close all input and output, do double fork, etc.
2363
2546
daemon()
2364
2547
2548
# multiprocessing will use threads, so before we use gobject we
2549
# need to inform gobject that threads will be used.
2365
2550
gobject.threads_init()
2366
2551
2367
2552
global main_loop
2373
2558
if use_dbus:
2374
2559
try:
2375
2560
bus_name = dbus.service.BusName("se.recompile.Mandos",
2376
bus, do_not_queue=True)
2377
old_bus_name = (dbus.service.BusName
2378
("se.bsnet.fukt.Mandos", bus,
2379
do_not_queue=True))
2561
bus,
2562
do_not_queue=True)
2563
old_bus_name = dbus.service.BusName(
2564
"se.bsnet.fukt.Mandos", bus,
2565
do_not_queue=True)
2380
2566
except dbus.exceptions.NameExistsException as e:
2381
2567
logger.error("Disabling D-Bus:", exc_info=e)
2382
2568
use_dbus = False
2383
2569
server_settings["use_dbus"] = False
2384
2570
tcp_server.use_dbus = False
2385
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2386
service = AvahiServiceToSyslog(name =
2387
server_settings["servicename"],
2388
servicetype = "_mandos._tcp",
2389
protocol = protocol, bus = bus)
2390
if server_settings["interface"]:
2391
service.interface = (if_nametoindex
2392
(str(server_settings["interface"])))
2571
if zeroconf:
2572
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2573
service = AvahiServiceToSyslog(
2574
name = server_settings["servicename"],
2575
servicetype = "_mandos._tcp",
2576
protocol = protocol,
2577
bus = bus)
2578
if server_settings["interface"]:
2579
service.interface = if_nametoindex(
2580
server_settings["interface"].encode("utf-8"))
2393
2581
2394
2582
global multiprocessing_manager
2395
2583
multiprocessing_manager = multiprocessing.Manager()
2402
2590
old_client_settings = {}
2403
2591
clients_data = {}
2404
2592
2593
# This is used to redirect stdout and stderr for checker processes
2594
global wnull
2595
wnull = open(os.devnull, "w") # A writable /dev/null
2596
# Only used if server is running in foreground but not in debug
2597
# mode
2598
if debug or not foreground:
2599
wnull.close()
2600
2405
2601
# Get client data and settings from last running state.
2406
2602
if server_settings["restore"]:
2407
2603
try:
2408
2604
with open(stored_state_path, "rb") as stored_state:
2409
clients_data, old_client_settings = (pickle.load
2410
(stored_state))
2605
clients_data, old_client_settings = pickle.load(
2606
stored_state)
2411
2607
os.remove(stored_state_path)
2412
2608
except IOError as e:
2413
2609
if e.errno == errno.ENOENT:
2414
logger.warning("Could not load persistent state: {0}"
2415
.format(os.strerror(e.errno)))
2610
logger.warning("Could not load persistent state:"
2611
" {}".format(os.strerror(e.errno)))
2416
2612
else:
2417
2613
logger.critical("Could not load persistent state:",
2418
2614
exc_info=e)
2419
2615
raise
2420
2616
except EOFError as e:
2421
2617
logger.warning("Could not load persistent state: "
2422
"EOFError:", exc_info=e)
2618
"EOFError:",
2619
exc_info=e)
2423
2620
2424
2621
with PGPEngine() as pgp:
2425
for client_name, client in clients_data.iteritems():
2622
for client_name, client in clients_data.items():
2623
# Skip removed clients
2624
if client_name not in client_settings:
2625
continue
2626
2426
2627
# Decide which value to use after restoring saved state.
2427
2628
# We have three different values: Old config file,
2428
2629
# new config file, and saved state.
2433
2634
# For each value in new config, check if it
2434
2635
# differs from the old config value (Except for
2435
2636
# the "secret" attribute)
2436
if (name != "secret" and
2437
value != old_client_settings[client_name]
2438
[name]):
2637
if (name != "secret"
2638
and (value !=
2639
old_client_settings[client_name][name])):
2439
2640
client[name] = value
2440
2641
except KeyError:
2441
2642
pass
2442
2643
2443
2644
# Clients who has passed its expire date can still be
2444
# enabled if its last checker was successful. Clients
2645
# enabled if its last checker was successful. A Client
2445
2646
# whose checker succeeded before we stored its state is
2446
2647
# assumed to have successfully run all checkers during
2447
2648
# downtime.
2449
2650
if datetime.datetime.utcnow() >= client["expires"]:
2450
2651
if not client["last_checked_ok"]:
2451
2652
logger.warning(
2452
"disabling client {0} - Client never "
2453
"performed a successful checker"
2454
.format(client_name))
2653
"disabling client {} - Client never "
2654
"performed a successful checker".format(
2655
client_name))
2455
2656
client["enabled"] = False
2456
2657
elif client["last_checker_status"] != 0:
2457
2658
logger.warning(
2458
"disabling client {0} - Client "
2459
"last checker failed with error code {1}"
2460
.format(client_name,
2461
client["last_checker_status"]))
2659
"disabling client {} - Client last"
2660
" checker failed with error code"
2661
" {}".format(
2662
client_name,
2663
client["last_checker_status"]))
2462
2664
client["enabled"] = False
2463
2665
else:
2464
client["expires"] = (datetime.datetime
2465
.utcnow()
2466
+ client["timeout"])
2666
client["expires"] = (
2667
datetime.datetime.utcnow()
2668
+ client["timeout"])
2467
2669
logger.debug("Last checker succeeded,"
2468
" keeping {0} enabled"
2469
.format(client_name))
2670
" keeping {} enabled".format(
2671
client_name))
2470
2672
try:
2471
client["secret"] = (
2472
pgp.decrypt(client["encrypted_secret"],
2473
client_settings[client_name]
2474
["secret"]))
2673
client["secret"] = pgp.decrypt(
2674
client["encrypted_secret"],
2675
client_settings[client_name]["secret"])
2475
2676
except PGPError:
2476
2677
# If decryption fails, we use secret from new settings
2477
logger.debug("Failed to decrypt {0} old secret"
2478
.format(client_name))
2479
client["secret"] = (
2480
client_settings[client_name]["secret"])
2678
logger.debug("Failed to decrypt {} old secret".format(
2679
client_name))
2680
client["secret"] = (client_settings[client_name]
2681
["secret"])
2481
2682
2482
2683
# Add/remove clients based on new changes made to config
2483
2684
for client_name in (set(old_client_settings)
2488
2689
clients_data[client_name] = client_settings[client_name]
2489
2690
2490
2691
# Create all client objects
2491
for client_name, client in clients_data.iteritems():
2692
for client_name, client in clients_data.items():
2492
2693
tcp_server.clients[client_name] = client_class(
2493
name = client_name, settings = client)
2694
name = client_name,
2695
settings = client,
2696
server_settings = server_settings)
2494
2697
2495
2698
if not tcp_server.clients:
2496
2699
logger.warning("No clients defined")
2497
2700
2498
if not debug:
2499
try:
2500
with pidfile:
2501
pid = os.getpid()
2502
pidfile.write(str(pid) + "\n".encode("utf-8"))
2503
del pidfile
2504
except IOError:
2505
logger.error("Could not write to file %r with PID %d",
2506
pidfilename, pid)
2507
except NameError:
2508
# "pidfile" was never created
2509
pass
2701
if not foreground:
2702
if pidfile is not None:
2703
try:
2704
with pidfile:
2705
pid = os.getpid()
2706
pidfile.write("{}\n".format(pid).encode("utf-8"))
2707
except IOError:
2708
logger.error("Could not write to file %r with PID %d",
2709
pidfilename, pid)
2710
del pidfile
2510
2711
del pidfilename
2511
2712
2512
2713
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2513
2714
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2514
2715
2515
2716
if use_dbus:
2516
@alternate_dbus_interfaces({"se.recompile.Mandos":
2517
"se.bsnet.fukt.Mandos"})
2717
2718
@alternate_dbus_interfaces(
2719
{ "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })
2518
2720
class MandosDBusService(DBusObjectWithProperties):
2519
2721
"""A D-Bus proxy object"""
2722
2520
2723
def __init__(self):
2521
2724
dbus.service.Object.__init__(self, bus, "/")
2725
2522
2726
_interface = "se.recompile.Mandos"
2523
2727
2524
2728
@dbus_interface_annotations(_interface)
2525
2729
def _foo(self):
2526
return { "org.freedesktop.DBus.Property"
2527
".EmitsChangedSignal":
2528
"false"}
2730
return {
2731
"org.freedesktop.DBus.Property.EmitsChangedSignal":
2732
"false" }
2529
2733
2530
2734
@dbus.service.signal(_interface, signature="o")
2531
2735
def ClientAdded(self, objpath):
2545
2749
@dbus.service.method(_interface, out_signature="ao")
2546
2750
def GetAllClients(self):
2547
2751
"D-Bus method"
2548
return dbus.Array(c.dbus_object_path
2549
for c in
2752
return dbus.Array(c.dbus_object_path for c in
2550
2753
tcp_server.clients.itervalues())
2551
2754
2552
2755
@dbus.service.method(_interface,
2554
2757
def GetAllClientsWithProperties(self):
2555
2758
"D-Bus method"
2556
2759
return dbus.Dictionary(
2557
((c.dbus_object_path, c.GetAll(""))
2558
for c in tcp_server.clients.itervalues()),
2760
{ c.dbus_object_path: c.GetAll("")
2761
for c in tcp_server.clients.itervalues() },
2559
2762
signature="oa{sv}")
2560
2763
2561
2764
@dbus.service.method(_interface, in_signature="o")
2578
2781
2579
2782
def cleanup():
2580
2783
"Cleanup function; run on exit"
2581
service.cleanup()
2784
if zeroconf:
2785
service.cleanup()
2582
2786
2583
2787
multiprocessing.active_children()
2788
wnull.close()
2584
2789
if not (tcp_server.clients or client_settings):
2585
2790
return
2586
2791
2597
2802
2598
2803
# A list of attributes that can not be pickled
2599
2804
# + secret.
2600
exclude = set(("bus", "changedstate", "secret",
2601
"checker"))
2602
for name, typ in (inspect.getmembers
2603
(dbus.service.Object)):
2805
exclude = { "bus", "changedstate", "secret",
2806
"checker", "server_settings" }
2807
for name, typ in inspect.getmembers(dbus.service
2808
.Object):
2604
2809
exclude.add(name)
2605
2810
2606
2811
client_dict["encrypted_secret"] = (client
2613
2818
del client_settings[client.name]["secret"]
2614
2819
2615
2820
try:
2616
with (tempfile.NamedTemporaryFile
2617
(mode='wb', suffix=".pickle", prefix='clients-',
2618
dir=os.path.dirname(stored_state_path),
2619
delete=False)) as stored_state:
2821
with tempfile.NamedTemporaryFile(
2822
mode='wb',
2823
suffix=".pickle",
2824
prefix='clients-',
2825
dir=os.path.dirname(stored_state_path),
2826
delete=False) as stored_state:
2620
2827
pickle.dump((clients, client_settings), stored_state)
2621
tempname=stored_state.name
2828
tempname = stored_state.name
2622
2829
os.rename(tempname, stored_state_path)
2623
2830
except (IOError, OSError) as e:
2624
2831
if not debug:
2627
2834
except NameError:
2628
2835
pass
2629
2836
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2630
logger.warning("Could not save persistent state: {0}"
2837
logger.warning("Could not save persistent state: {}"
2631
2838
.format(os.strerror(e.errno)))
2632
2839
else:
2633
2840
logger.warning("Could not save persistent state:",
2634
2841
exc_info=e)
2635
raise e
2842
raise
2636
2843
2637
2844
# Delete all clients, and settings from config
2638
2845
while tcp_server.clients:
2643
2850
client.disable(quiet=True)
2644
2851
if use_dbus:
2645
2852
# Emit D-Bus signal
2646
mandos_dbus_service.ClientRemoved(client
2647
.dbus_object_path,
2648
client.name)
2853
mandos_dbus_service.ClientRemoved(
2854
client.dbus_object_path, client.name)
2649
2855
client_settings.clear()
2650
2856
2651
2857
atexit.register(cleanup)
2662
2868
tcp_server.server_activate()
2663
2869
2664
2870
# Find out what port we got
2665
service.port = tcp_server.socket.getsockname()[1]
2871
if zeroconf:
2872
service.port = tcp_server.socket.getsockname()[1]
2666
2873
if use_ipv6:
2667
2874
logger.info("Now listening on address %r, port %d,"
2668
2875
" flowinfo %d, scope_id %d",
2674
2881
#service.interface = tcp_server.socket.getsockname()[3]
2675
2882
2676
2883
try:
2677
# From the Avahi example code
2678
try:
2679
service.activate()
2680
except dbus.exceptions.DBusException as error:
2681
logger.critical("D-Bus Exception", exc_info=error)
2682
cleanup()
2683
sys.exit(1)
2684
# End of Avahi example code
2884
if zeroconf:
2885
# From the Avahi example code
2886
try:
2887
service.activate()
2888
except dbus.exceptions.DBusException as error:
2889
logger.critical("D-Bus Exception", exc_info=error)
2890
cleanup()
2891
sys.exit(1)
2892
# End of Avahi example code
2685
2893
2686
2894
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2687
2895
lambda *args, **kwargs:
2702
2910
# Must run before the D-Bus bus name gets deregistered
2703
2911
cleanup()
2704
2912
2913
2705
2914
if __name__ == '__main__':
2706
2915
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0