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
- debian/upstream
- network-hooks.d
- files modified:
- .bzrignore
added
removed
mandos
1
#!/usr/bin/python2.7
1
#!/usr/bin/python
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-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
if sys.version_info.major == 2:
92
str = unicode
93
94
version = "1.6.8"
88
version = "1.4.1"
95
89
stored_state_file = "clients.pickle"
96
90
97
91
logger = logging.getLogger()
98
syslogger = None
92
syslogger = (logging.handlers.SysLogHandler
93
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
94
address = str("/dev/log")))
99
95
100
96
try:
101
97
if_nametoindex = (ctypes.cdll.LoadLibrary
107
103
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
108
104
with contextlib.closing(socket.socket()) as s:
109
105
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
110
struct.pack(b"16s16x", interface))
111
interface_index = struct.unpack("I", ifreq[16:20])[0]
106
struct.pack(str("16s16x"),
107
interface))
108
interface_index = struct.unpack(str("I"),
109
ifreq[16:20])[0]
112
110
return interface_index
113
111
114
112
115
def initlogger(debug, level=logging.WARNING):
113
def initlogger(level=logging.WARNING):
116
114
"""init logger and add loglevel"""
117
115
118
global syslogger
119
syslogger = (logging.handlers.SysLogHandler
120
(facility =
121
logging.handlers.SysLogHandler.LOG_DAEMON,
122
address = "/dev/log"))
123
116
syslogger.setFormatter(logging.Formatter
124
117
('Mandos [%(process)d]: %(levelname)s:'
125
118
' %(message)s'))
126
119
logger.addHandler(syslogger)
127
120
128
if debug:
129
console = logging.StreamHandler()
130
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
131
' [%(process)d]:'
132
' %(levelname)s:'
133
' %(message)s'))
134
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)
135
127
logger.setLevel(level)
136
128
137
129
143
135
class PGPEngine(object):
144
136
"""A simple class for OpenPGP symmetric encryption & decryption"""
145
137
def __init__(self):
138
self.gnupg = GnuPGInterface.GnuPG()
146
139
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
147
self.gnupgargs = ['--batch',
148
'--home', self.tempdir,
149
'--force-mdc',
150
'--quiet',
151
'--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'])
152
145
153
146
def __enter__(self):
154
147
return self
155
148
156
def __exit__(self, exc_type, exc_value, traceback):
149
def __exit__ (self, exc_type, exc_value, traceback):
157
150
self._cleanup()
158
151
return False
159
152
176
169
def password_encode(self, password):
177
170
# Passphrase can not be empty and can not contain newlines or
178
171
# NUL bytes. So we prefix it and hex encode it.
179
encoded = b"mandos" + binascii.hexlify(password)
180
if len(encoded) > 2048:
181
# GnuPG can't handle long passwords, so encode differently
182
encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
183
.replace(b"\n", b"\\n")
184
.replace(b"\0", b"\\x00"))
185
return encoded
172
return b"mandos" + binascii.hexlify(password)
186
173
187
174
def encrypt(self, data, password):
188
passphrase = self.password_encode(password)
189
with tempfile.NamedTemporaryFile(dir=self.tempdir
190
) as passfile:
191
passfile.write(passphrase)
192
passfile.flush()
193
proc = subprocess.Popen(['gpg', '--symmetric',
194
'--passphrase-file',
195
passfile.name]
196
+ self.gnupgargs,
197
stdin = subprocess.PIPE,
198
stdout = subprocess.PIPE,
199
stderr = subprocess.PIPE)
200
ciphertext, err = proc.communicate(input = data)
201
if proc.returncode != 0:
202
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
203
189
return ciphertext
204
190
205
191
def decrypt(self, data, password):
206
passphrase = self.password_encode(password)
207
with tempfile.NamedTemporaryFile(dir = self.tempdir
208
) as passfile:
209
passfile.write(passphrase)
210
passfile.flush()
211
proc = subprocess.Popen(['gpg', '--decrypt',
212
'--passphrase-file',
213
passfile.name]
214
+ self.gnupgargs,
215
stdin = subprocess.PIPE,
216
stdout = subprocess.PIPE,
217
stderr = subprocess.PIPE)
218
decrypted_plaintext, err = proc.communicate(input
219
= data)
220
if proc.returncode != 0:
221
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
222
206
return decrypted_plaintext
223
207
224
208
209
225
210
class AvahiError(Exception):
226
211
def __init__(self, value, *args, **kwargs):
227
212
self.value = value
228
return super(AvahiError, self).__init__(value, *args,
229
**kwargs)
213
super(AvahiError, self).__init__(value, *args, **kwargs)
214
def __unicode__(self):
215
return unicode(repr(self.value))
230
216
231
217
class AvahiServiceError(AvahiError):
232
218
pass
243
229
Used to optionally bind to the specified interface.
244
230
name: string; Example: 'Mandos'
245
231
type: string; Example: '_mandos._tcp'.
246
See <https://www.iana.org/assignments/service-names-port-numbers>
232
See <http://www.dns-sd.org/ServiceTypes.html>
247
233
port: integer; what port to announce
248
234
TXT: list of strings; TXT record for the service
249
235
domain: string; Domain to publish on, default to .local if empty.
255
241
server: D-Bus Server
256
242
bus: dbus.SystemBus()
257
243
"""
258
259
244
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
260
245
servicetype = None, port = None, TXT = None,
261
246
domain = "", host = "", max_renames = 32768,
274
259
self.server = None
275
260
self.bus = bus
276
261
self.entry_group_state_changed_match = None
277
278
262
def rename(self):
279
263
"""Derived from the Avahi example code"""
280
264
if self.rename_count >= self.max_renames:
282
266
" after %i retries, exiting.",
283
267
self.rename_count)
284
268
raise AvahiServiceError("Too many renames")
285
self.name = str(self.server
286
.GetAlternativeServiceName(self.name))
269
self.name = unicode(self.server
270
.GetAlternativeServiceName(self.name))
287
271
logger.info("Changing Zeroconf service name to %r ...",
288
272
self.name)
289
273
self.remove()
290
274
try:
291
275
self.add()
292
276
except dbus.exceptions.DBusException as error:
293
logger.critical("D-Bus Exception", exc_info=error)
277
logger.critical("DBusException: %s", error)
294
278
self.cleanup()
295
279
os._exit(1)
296
280
self.rename_count += 1
297
298
281
def remove(self):
299
282
"""Derived from the Avahi example code"""
300
283
if self.entry_group_state_changed_match is not None:
302
285
self.entry_group_state_changed_match = None
303
286
if self.group is not None:
304
287
self.group.Reset()
305
306
288
def add(self):
307
289
"""Derived from the Avahi example code"""
308
290
self.remove()
325
307
dbus.UInt16(self.port),
326
308
avahi.string_array_to_txt_array(self.TXT))
327
309
self.group.Commit()
328
329
310
def entry_group_state_changed(self, state, error):
330
311
"""Derived from the Avahi example code"""
331
312
logger.debug("Avahi entry group state change: %i", state)
337
318
self.rename()
338
319
elif state == avahi.ENTRY_GROUP_FAILURE:
339
320
logger.critical("Avahi: Error in group state changed %s",
340
str(error))
341
raise AvahiGroupError("State changed: {!s}"
342
.format(error))
343
321
unicode(error))
322
raise AvahiGroupError("State changed: %s"
323
% unicode(error))
344
324
def cleanup(self):
345
325
"""Derived from the Avahi example code"""
346
326
if self.group is not None:
351
331
pass
352
332
self.group = None
353
333
self.remove()
354
355
334
def server_state_changed(self, state, error=None):
356
335
"""Derived from the Avahi example code"""
357
336
logger.debug("Avahi server state change: %i", state)
376
355
logger.debug("Unknown state: %r", state)
377
356
else:
378
357
logger.debug("Unknown state: %r: %r", state, error)
379
380
358
def activate(self):
381
359
"""Derived from the Avahi example code"""
382
360
if self.server is None:
389
367
self.server_state_changed)
390
368
self.server_state_changed(self.server.GetState())
391
369
392
393
370
class AvahiServiceToSyslog(AvahiService):
394
371
def rename(self):
395
372
"""Add the new name to the syslog messages"""
396
373
ret = AvahiService.rename(self)
397
374
syslogger.setFormatter(logging.Formatter
398
('Mandos ({}) [%(process)d]:'
399
' %(levelname)s: %(message)s'
400
.format(self.name)))
375
('Mandos (%s) [%%(process)d]:'
376
' %%(levelname)s: %%(message)s'
377
% self.name))
401
378
return ret
402
379
403
380
def timedelta_to_milliseconds(td):
381
"Convert a datetime.timedelta() to milliseconds"
382
return ((td.days * 24 * 60 * 60 * 1000)
383
+ (td.seconds * 1000)
384
+ (td.microseconds // 1000))
385
404
386
class Client(object):
405
387
"""A representation of a client host served by this server.
406
388
431
413
last_checked_ok: datetime.datetime(); (UTC) or None
432
414
last_checker_status: integer between 0 and 255 reflecting exit
433
415
status of last checker. -1 reflects crashed
434
checker, -2 means no checker completed yet.
416
checker, or None.
435
417
last_enabled: datetime.datetime(); (UTC) or None
436
418
name: string; from the config file, used in log messages and
437
419
D-Bus identifiers
438
420
secret: bytestring; sent verbatim (over TLS) to client
439
421
timeout: datetime.timedelta(); How long from last_checked_ok
440
422
until this client is disabled
441
extended_timeout: extra long timeout when secret has been sent
423
extended_timeout: extra long timeout when password has been sent
442
424
runtime_expansions: Allowed attributes for runtime expansion.
443
425
expires: datetime.datetime(); time (UTC) when a client will be
444
426
disabled, or None
445
server_settings: The server_settings dict from main()
446
427
"""
447
428
448
429
runtime_expansions = ("approval_delay", "approval_duration",
449
"created", "enabled", "expires",
450
"fingerprint", "host", "interval",
451
"last_approval_request", "last_checked_ok",
430
"created", "enabled", "fingerprint",
431
"host", "interval", "last_checked_ok",
452
432
"last_enabled", "name", "timeout")
453
client_defaults = { "timeout": "PT5M",
454
"extended_timeout": "PT15M",
455
"interval": "PT2M",
433
client_defaults = { "timeout": "5m",
434
"extended_timeout": "15m",
435
"interval": "2m",
456
436
"checker": "fping -q -- %%(host)s",
457
437
"host": "",
458
"approval_delay": "PT0S",
459
"approval_duration": "PT1S",
438
"approval_delay": "0s",
439
"approval_duration": "1s",
460
440
"approved_by_default": "True",
461
441
"enabled": "True",
462
442
}
463
443
444
def timeout_milliseconds(self):
445
"Return the 'timeout' attribute in milliseconds"
446
return timedelta_to_milliseconds(self.timeout)
447
448
def extended_timeout_milliseconds(self):
449
"Return the 'extended_timeout' attribute in milliseconds"
450
return timedelta_to_milliseconds(self.extended_timeout)
451
452
def interval_milliseconds(self):
453
"Return the 'interval' attribute in milliseconds"
454
return timedelta_to_milliseconds(self.interval)
455
456
def approval_delay_milliseconds(self):
457
return timedelta_to_milliseconds(self.approval_delay)
458
464
459
@staticmethod
465
460
def config_parser(config):
466
"""Construct a new dict of client settings of this form:
461
""" Construct a new dict of client settings of this form:
467
462
{ client_name: {setting_name: value, ...}, ...}
468
with exceptions for any special settings as defined above.
469
NOTE: Must be a pure function. Must return the same result
470
value given the same arguments.
471
"""
463
with exceptions for any special settings as defined above"""
472
464
settings = {}
473
465
for client_name in config.sections():
474
466
section = dict(config.items(client_name))
478
470
# Reformat values from string types to Python types
479
471
client["approved_by_default"] = config.getboolean(
480
472
client_name, "approved_by_default")
481
client["enabled"] = config.getboolean(client_name,
482
"enabled")
473
client["enabled"] = config.getboolean(client_name, "enabled")
483
474
484
475
client["fingerprint"] = (section["fingerprint"].upper()
485
476
.replace(" ", ""))
491
482
"rb") as secfile:
492
483
client["secret"] = secfile.read()
493
484
else:
494
raise TypeError("No secret or secfile for section {}"
495
.format(section))
485
raise TypeError("No secret or secfile for section %s"
486
% section)
496
487
client["timeout"] = string_to_delta(section["timeout"])
497
488
client["extended_timeout"] = string_to_delta(
498
489
section["extended_timeout"])
504
495
client["checker_command"] = section["checker"]
505
496
client["last_approval_request"] = None
506
497
client["last_checked_ok"] = None
507
client["last_checker_status"] = -2
508
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
509
507
return settings
510
511
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."""
512
514
self.name = name
513
if server_settings is None:
514
server_settings = {}
515
self.server_settings = server_settings
516
515
# adding all client settings
517
for setting, value in settings.items():
516
for setting, value in settings.iteritems():
518
517
setattr(self, setting, value)
519
518
520
if self.enabled:
521
if not hasattr(self, "last_enabled"):
522
self.last_enabled = datetime.datetime.utcnow()
523
if not hasattr(self, "expires"):
524
self.expires = (datetime.datetime.utcnow()
525
+ self.timeout)
526
else:
527
self.last_enabled = None
528
self.expires = None
529
530
519
logger.debug("Creating client %r", self.name)
531
520
# Uppercase and remove spaces from fingerprint for later
532
521
# comparison purposes with return value from the fingerprint()
533
522
# function
534
523
logger.debug(" Fingerprint: %s", self.fingerprint)
535
self.created = settings.get("created",
536
datetime.datetime.utcnow())
537
524
self.created = settings.get("created", datetime.datetime.utcnow())
525
538
526
# attributes specific for this server instance
539
527
self.checker = None
540
528
self.checker_initiator_tag = None
568
556
if getattr(self, "enabled", False):
569
557
# Already enabled
570
558
return
559
self.send_changedstate()
571
560
self.expires = datetime.datetime.utcnow() + self.timeout
572
561
self.enabled = True
573
562
self.last_enabled = datetime.datetime.utcnow()
574
563
self.init_checker()
575
self.send_changedstate()
576
564
577
565
def disable(self, quiet=True):
578
566
"""Disable this client."""
579
567
if not getattr(self, "enabled", False):
580
568
return False
581
569
if not quiet:
570
self.send_changedstate()
571
if not quiet:
582
572
logger.info("Disabling client %s", self.name)
583
if getattr(self, "disable_initiator_tag", None) is not None:
573
if getattr(self, "disable_initiator_tag", False):
584
574
gobject.source_remove(self.disable_initiator_tag)
585
575
self.disable_initiator_tag = None
586
576
self.expires = None
587
if getattr(self, "checker_initiator_tag", None) is not None:
577
if getattr(self, "checker_initiator_tag", False):
588
578
gobject.source_remove(self.checker_initiator_tag)
589
579
self.checker_initiator_tag = None
590
580
self.stop_checker()
591
581
self.enabled = False
592
if not quiet:
593
self.send_changedstate()
594
582
# Do not run this again if called by a gobject.timeout_add
595
583
return False
596
584
600
588
def init_checker(self):
601
589
# Schedule a new checker to be started an 'interval' from now,
602
590
# and every interval from then on.
603
if self.checker_initiator_tag is not None:
604
gobject.source_remove(self.checker_initiator_tag)
605
591
self.checker_initiator_tag = (gobject.timeout_add
606
(int(self.interval
607
.total_seconds() * 1000),
592
(self.interval_milliseconds(),
608
593
self.start_checker))
609
594
# Schedule a disable() when 'timeout' has passed
610
if self.disable_initiator_tag is not None:
611
gobject.source_remove(self.disable_initiator_tag)
612
595
self.disable_initiator_tag = (gobject.timeout_add
613
(int(self.timeout
614
.total_seconds() * 1000),
615
self.disable))
596
(self.timeout_milliseconds(),
597
self.disable))
616
598
# Also start a new checker *right now*.
617
599
self.start_checker()
618
600
634
616
logger.warning("Checker for %(name)s crashed?",
635
617
vars(self))
636
618
637
def checked_ok(self):
638
"""Assert that the client has been seen, alive and well."""
639
self.last_checked_ok = datetime.datetime.utcnow()
640
self.last_checker_status = 0
641
self.bump_timeout()
642
643
def bump_timeout(self, timeout=None):
644
"""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
"""
645
625
if timeout is None:
646
626
timeout = self.timeout
627
self.last_checked_ok = datetime.datetime.utcnow()
647
628
if self.disable_initiator_tag is not None:
648
629
gobject.source_remove(self.disable_initiator_tag)
649
self.disable_initiator_tag = None
650
630
if getattr(self, "enabled", False):
651
631
self.disable_initiator_tag = (gobject.timeout_add
652
(int(timeout.total_seconds()
653
* 1000), self.disable))
632
(timedelta_to_milliseconds
633
(timeout), self.disable))
654
634
self.expires = datetime.datetime.utcnow() + timeout
655
635
656
636
def need_approval(self):
662
642
If a checker already exists, leave it running and do
663
643
nothing."""
664
644
# The reason for not killing a running checker is that if we
665
# did that, and if a checker (for some reason) started running
666
# slowly and taking more than 'interval' time, then the client
667
# would inevitably timeout, since no checker would get a
668
# 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
669
649
# checkers alone, the checker would have to take more time
670
650
# than 'timeout' for the client to be disabled, which is as it
671
651
# should be.
673
653
# If a checker exists, make sure it is not a zombie
674
654
try:
675
655
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
676
except AttributeError:
677
pass
678
except OSError as error:
679
if error.errno != errno.ECHILD:
680
raise
656
except (AttributeError, OSError) as error:
657
if (isinstance(error, OSError)
658
and error.errno != errno.ECHILD):
659
raise error
681
660
else:
682
661
if pid:
683
662
logger.warning("Checker was a zombie")
686
665
self.current_checker_command)
687
666
# Start a new checker if needed
688
667
if self.checker is None:
689
# Escape attributes for the shell
690
escaped_attrs = { attr:
691
re.escape(str(getattr(self, attr)))
692
for attr in self.runtime_expansions }
693
668
try:
694
command = self.checker_command % escaped_attrs
695
except TypeError as error:
696
logger.error('Could not format string "%s"',
697
self.checker_command, exc_info=error)
698
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
699
687
self.current_checker_command = command
700
688
try:
701
689
logger.info("Starting checker %r for %s",
704
692
# in normal mode, that is already done by daemon(),
705
693
# and in debug mode we don't want to. (Stdin is
706
694
# always replaced by /dev/null.)
707
# The exception is when not debugging but nevertheless
708
# running in the foreground; use the previously
709
# created wnull.
710
popen_args = {}
711
if (not self.server_settings["debug"]
712
and self.server_settings["foreground"]):
713
popen_args.update({"stdout": wnull,
714
"stderr": wnull })
715
695
self.checker = subprocess.Popen(command,
716
696
close_fds=True,
717
shell=True, cwd="/",
718
**popen_args)
719
except OSError as error:
720
logger.error("Failed to start subprocess",
721
exc_info=error)
722
return True
723
self.checker_callback_tag = (gobject.child_watch_add
724
(self.checker.pid,
725
self.checker_callback,
726
data=command))
727
# The checker may have completed before the gobject
728
# watch was added. Check for this.
729
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.
730
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)
731
708
except OSError as error:
732
if error.errno == errno.ECHILD:
733
# This should never happen
734
logger.error("Child process vanished",
735
exc_info=error)
736
return True
737
raise
738
if pid:
739
gobject.source_remove(self.checker_callback_tag)
740
self.checker_callback(pid, status, command)
709
logger.error("Failed to start subprocess: %s",
710
error)
741
711
# Re-run this periodically if run by gobject.timeout_add
742
712
return True
743
713
750
720
return
751
721
logger.debug("Stopping checker for %(name)s", vars(self))
752
722
try:
753
self.checker.terminate()
723
os.kill(self.checker.pid, signal.SIGTERM)
754
724
#time.sleep(0.5)
755
725
#if self.checker.poll() is None:
756
# self.checker.kill()
726
# os.kill(self.checker.pid, signal.SIGKILL)
757
727
except OSError as error:
758
728
if error.errno != errno.ESRCH: # No such process
759
729
raise
776
746
# "Set" method, so we fail early here:
777
747
if byte_arrays and signature != "ay":
778
748
raise ValueError("Byte arrays not supported for non-'ay'"
779
" signature {!r}".format(signature))
749
" signature %r" % signature)
780
750
def decorator(func):
781
751
func._dbus_is_property = True
782
752
func._dbus_interface = dbus_interface
790
760
return decorator
791
761
792
762
793
def dbus_interface_annotations(dbus_interface):
794
"""Decorator for marking functions returning interface annotations
795
796
Usage:
797
798
@dbus_interface_annotations("org.example.Interface")
799
def _foo(self): # Function name does not matter
800
return {"org.freedesktop.DBus.Deprecated": "true",
801
"org.freedesktop.DBus.Property.EmitsChangedSignal":
802
"false"}
803
"""
804
def decorator(func):
805
func._dbus_is_interface = True
806
func._dbus_interface = dbus_interface
807
func._dbus_name = dbus_interface
808
return func
809
return decorator
810
811
812
def dbus_annotations(annotations):
813
"""Decorator to annotate D-Bus methods, signals or properties
814
Usage:
815
816
@dbus_service_property("org.example.Interface", signature="b",
817
access="r")
818
@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
819
"org.freedesktop.DBus.Property."
820
"EmitsChangedSignal": "false"})
821
def Property_dbus_property(self):
822
return dbus.Boolean(False)
823
"""
824
def decorator(func):
825
func._dbus_annotations = annotations
826
return func
827
return decorator
828
829
830
763
class DBusPropertyException(dbus.exceptions.DBusException):
831
764
"""A base class for D-Bus property-related exceptions
832
765
"""
833
pass
766
def __unicode__(self):
767
return unicode(str(self))
768
834
769
835
770
class DBusPropertyAccessException(DBusPropertyException):
836
771
"""A property's access permissions disallows an operation.
853
788
"""
854
789
855
790
@staticmethod
856
def _is_dbus_thing(thing):
857
"""Returns a function testing if an attribute is a D-Bus thing
858
859
If called like _is_dbus_thing("method") it returns a function
860
suitable for use as predicate to inspect.getmembers().
861
"""
862
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
863
False)
791
def _is_dbus_property(obj):
792
return getattr(obj, "_dbus_is_property", False)
864
793
865
def _get_all_dbus_things(self, thing):
794
def _get_all_dbus_properties(self):
866
795
"""Returns a generator of (name, attribute) pairs
867
796
"""
868
return ((getattr(athing.__get__(self), "_dbus_name",
869
name),
870
athing.__get__(self))
797
return ((prop.__get__(self)._dbus_name, prop.__get__(self))
871
798
for cls in self.__class__.__mro__
872
for name, athing in
873
inspect.getmembers(cls,
874
self._is_dbus_thing(thing)))
799
for name, prop in
800
inspect.getmembers(cls, self._is_dbus_property))
875
801
876
802
def _get_dbus_property(self, interface_name, property_name):
877
803
"""Returns a bound method if one exists which is a D-Bus
879
805
"""
880
806
for cls in self.__class__.__mro__:
881
807
for name, value in (inspect.getmembers
882
(cls,
883
self._is_dbus_thing("property"))):
808
(cls, self._is_dbus_property)):
884
809
if (value._dbus_name == property_name
885
810
and value._dbus_interface == interface_name):
886
811
return value.__get__(self)
914
839
# The byte_arrays option is not supported yet on
915
840
# signatures other than "ay".
916
841
if prop._dbus_signature != "ay":
917
raise ValueError("Byte arrays not supported for non-"
918
"'ay' signature {!r}"
919
.format(prop._dbus_signature))
920
value = dbus.ByteArray(b''.join(chr(byte)
921
for byte in value))
842
raise ValueError
843
value = dbus.ByteArray(''.join(unichr(byte)
844
for byte in value))
922
845
prop(value)
923
846
924
847
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
930
853
Note: Will not include properties with access="write".
931
854
"""
932
855
properties = {}
933
for name, prop in self._get_all_dbus_things("property"):
856
for name, prop in self._get_all_dbus_properties():
934
857
if (interface_name
935
858
and interface_name != prop._dbus_interface):
936
859
# Interface non-empty but did not match
951
874
path_keyword='object_path',
952
875
connection_keyword='connection')
953
876
def Introspect(self, object_path, connection):
954
"""Overloading of standard D-Bus method.
955
956
Inserts property tags and interface annotation tags.
877
"""Standard D-Bus method, overloaded to insert property tags.
957
878
"""
958
879
xmlstring = dbus.service.Object.Introspect(self, object_path,
959
880
connection)
966
887
e.setAttribute("access", prop._dbus_access)
967
888
return e
968
889
for if_tag in document.getElementsByTagName("interface"):
969
# Add property tags
970
890
for tag in (make_tag(document, name, prop)
971
891
for name, prop
972
in self._get_all_dbus_things("property")
892
in self._get_all_dbus_properties()
973
893
if prop._dbus_interface
974
894
== if_tag.getAttribute("name")):
975
895
if_tag.appendChild(tag)
976
# Add annotation tags
977
for typ in ("method", "signal", "property"):
978
for tag in if_tag.getElementsByTagName(typ):
979
annots = dict()
980
for name, prop in (self.
981
_get_all_dbus_things(typ)):
982
if (name == tag.getAttribute("name")
983
and prop._dbus_interface
984
== if_tag.getAttribute("name")):
985
annots.update(getattr
986
(prop,
987
"_dbus_annotations",
988
{}))
989
for name, value in annots.items():
990
ann_tag = document.createElement(
991
"annotation")
992
ann_tag.setAttribute("name", name)
993
ann_tag.setAttribute("value", value)
994
tag.appendChild(ann_tag)
995
# Add interface annotation tags
996
for annotation, value in dict(
997
itertools.chain.from_iterable(
998
annotations().items()
999
for name, annotations in
1000
self._get_all_dbus_things("interface")
1001
if name == if_tag.getAttribute("name")
1002
)).items():
1003
ann_tag = document.createElement("annotation")
1004
ann_tag.setAttribute("name", annotation)
1005
ann_tag.setAttribute("value", value)
1006
if_tag.appendChild(ann_tag)
1007
896
# Add the names to the return values for the
1008
897
# "org.freedesktop.DBus.Properties" methods
1009
898
if (if_tag.getAttribute("name")
1024
913
except (AttributeError, xml.dom.DOMException,
1025
914
xml.parsers.expat.ExpatError) as error:
1026
915
logger.error("Failed to override Introspection method",
1027
exc_info=error)
916
error)
1028
917
return xmlstring
1029
918
1030
919
1031
def datetime_to_dbus(dt, variant_level=0):
920
def datetime_to_dbus (dt, variant_level=0):
1032
921
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1033
922
if dt is None:
1034
923
return dbus.String("", variant_level = variant_level)
1036
925
variant_level=variant_level)
1037
926
1038
927
1039
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1040
"""A class decorator; applied to a subclass of
1041
dbus.service.Object, it will add alternate D-Bus attributes with
1042
interface names according to the "alt_interface_names" mapping.
1043
Usage:
1044
1045
@alternate_dbus_interfaces({"org.example.Interface":
1046
"net.example.AlternateInterface"})
1047
class SampleDBusObject(dbus.service.Object):
1048
@dbus.service.method("org.example.Interface")
1049
def SampleDBusMethod():
1050
pass
1051
1052
The above "SampleDBusMethod" on "SampleDBusObject" will be
1053
reachable via two interfaces: "org.example.Interface" and
1054
"net.example.AlternateInterface", the latter of which will have
1055
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1056
"true", unless "deprecate" is passed with a False value.
1057
1058
This works for methods and signals, and also for D-Bus properties
1059
(from DBusObjectWithProperties) and interfaces (from the
1060
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.
1061
932
"""
1062
def wrapper(cls):
1063
for orig_interface_name, alt_interface_name in (
1064
alt_interface_names.items()):
1065
attr = {}
1066
interface_names = set()
1067
# Go though all attributes of the class
1068
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):
1069
940
# Ignore non-D-Bus attributes, and D-Bus attributes
1070
941
# with the wrong interface name
1071
942
if (not hasattr(attribute, "_dbus_interface")
1072
943
or not attribute._dbus_interface
1073
.startswith(orig_interface_name)):
944
.startswith("se.recompile.Mandos")):
1074
945
continue
1075
946
# Create an alternate D-Bus interface name based on
1076
947
# the current name
1077
948
alt_interface = (attribute._dbus_interface
1078
.replace(orig_interface_name,
1079
alt_interface_name))
1080
interface_names.add(alt_interface)
949
.replace("se.recompile.Mandos",
950
"se.bsnet.fukt.Mandos"))
1081
951
# Is this a D-Bus signal?
1082
952
if getattr(attribute, "_dbus_is_signal", False):
1083
# Extract the original non-method undecorated
1084
# function by black magic
953
# Extract the original non-method function by
954
# black magic
1085
955
nonmethod_func = (dict(
1086
956
zip(attribute.func_code.co_freevars,
1087
957
attribute.__closure__))["func"]
1098
968
nonmethod_func.func_name,
1099
969
nonmethod_func.func_defaults,
1100
970
nonmethod_func.func_closure)))
1101
# Copy annotations, if any
1102
try:
1103
new_function._dbus_annotations = (
1104
dict(attribute._dbus_annotations))
1105
except AttributeError:
1106
pass
1107
971
# Define a creator of a function to call both the
1108
# original and alternate functions, so both the
1109
# original and alternate signals gets sent when
1110
# the function is called
972
# old and new functions, so both the old and new
973
# signals gets sent when the function is called
1111
974
def fixscope(func1, func2):
1112
975
"""This function is a scope container to pass
1113
976
func1 and func2 to the "call_both" function
1120
983
return call_both
1121
984
# Create the "call_both" function and add it to
1122
985
# the class
1123
attr[attrname] = fixscope(attribute, new_function)
986
attr[attrname] = fixscope(attribute,
987
new_function)
1124
988
# Is this a D-Bus method?
1125
989
elif getattr(attribute, "_dbus_is_method", False):
1126
990
# Create a new, but exactly alike, function
1137
1001
attribute.func_name,
1138
1002
attribute.func_defaults,
1139
1003
attribute.func_closure)))
1140
# Copy annotations, if any
1141
try:
1142
attr[attrname]._dbus_annotations = (
1143
dict(attribute._dbus_annotations))
1144
except AttributeError:
1145
pass
1146
1004
# Is this a D-Bus property?
1147
1005
elif getattr(attribute, "_dbus_is_property", False):
1148
1006
# Create a new, but exactly alike, function
1162
1020
attribute.func_name,
1163
1021
attribute.func_defaults,
1164
1022
attribute.func_closure)))
1165
# Copy annotations, if any
1166
try:
1167
attr[attrname]._dbus_annotations = (
1168
dict(attribute._dbus_annotations))
1169
except AttributeError:
1170
pass
1171
# Is this a D-Bus interface?
1172
elif getattr(attribute, "_dbus_is_interface", False):
1173
# Create a new, but exactly alike, function
1174
# object. Decorate it to be a new D-Bus interface
1175
# with the alternate D-Bus interface name. Add it
1176
# to the class.
1177
attr[attrname] = (dbus_interface_annotations
1178
(alt_interface)
1179
(types.FunctionType
1180
(attribute.func_code,
1181
attribute.func_globals,
1182
attribute.func_name,
1183
attribute.func_defaults,
1184
attribute.func_closure)))
1185
if deprecate:
1186
# Deprecate all alternate interfaces
1187
iname="_AlternateDBusNames_interface_annotation{}"
1188
for interface_name in interface_names:
1189
@dbus_interface_annotations(interface_name)
1190
def func(self):
1191
return { "org.freedesktop.DBus.Deprecated":
1192
"true" }
1193
# Find an unused name
1194
for aname in (iname.format(i)
1195
for i in itertools.count()):
1196
if aname not in attr:
1197
attr[aname] = func
1198
break
1199
if interface_names:
1200
# Replace the class with a new subclass of it with
1201
# methods, signals, etc. as created above.
1202
cls = type(b"{}Alternate".format(cls.__name__),
1203
(cls,), attr)
1204
return cls
1205
return wrapper
1206
1207
1208
@alternate_dbus_interfaces({"se.recompile.Mandos":
1209
"se.bsnet.fukt.Mandos"})
1023
return type.__new__(mcs, name, bases, attr)
1024
1025
1210
1026
class ClientDBus(Client, DBusObjectWithProperties):
1211
1027
"""A Client class using D-Bus
1212
1028
1223
1039
def __init__(self, bus = None, *args, **kwargs):
1224
1040
self.bus = bus
1225
1041
Client.__init__(self, *args, **kwargs)
1042
self._approvals_pending = 0
1043
1044
self._approvals_pending = 0
1226
1045
# Only now, when this client is initialized, can it show up on
1227
1046
# the D-Bus
1228
client_object_name = str(self.name).translate(
1047
client_object_name = unicode(self.name).translate(
1229
1048
{ord("."): ord("_"),
1230
1049
ord("-"): ord("_")})
1231
1050
self.dbus_object_path = (dbus.ObjectPath
1232
1051
("/clients/" + client_object_name))
1233
1052
DBusObjectWithProperties.__init__(self, self.bus,
1234
1053
self.dbus_object_path)
1235
1054
1236
1055
def notifychangeproperty(transform_func,
1237
1056
dbus_name, type_func=lambda x: x,
1238
1057
variant_level=1):
1246
1065
to the D-Bus. Default: no transform
1247
1066
variant_level: D-Bus variant level. Default: 1
1248
1067
"""
1249
attrname = "_{}".format(dbus_name)
1068
attrname = "_{0}".format(dbus_name)
1250
1069
def setter(self, value):
1251
1070
if hasattr(self, "dbus_object_path"):
1252
1071
if (not hasattr(self, attrname) or
1261
1080
1262
1081
return property(lambda self: getattr(self, attrname), setter)
1263
1082
1083
1264
1084
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1265
1085
approvals_pending = notifychangeproperty(dbus.Boolean,
1266
1086
"ApprovalPending",
1273
1093
checker is not None)
1274
1094
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1275
1095
"LastCheckedOK")
1276
last_checker_status = notifychangeproperty(dbus.Int16,
1277
"LastCheckerStatus")
1278
1096
last_approval_request = notifychangeproperty(
1279
1097
datetime_to_dbus, "LastApprovalRequest")
1280
1098
approved_by_default = notifychangeproperty(dbus.Boolean,
1282
1100
approval_delay = notifychangeproperty(dbus.UInt64,
1283
1101
"ApprovalDelay",
1284
1102
type_func =
1285
lambda td: td.total_seconds()
1286
* 1000)
1103
timedelta_to_milliseconds)
1287
1104
approval_duration = notifychangeproperty(
1288
1105
dbus.UInt64, "ApprovalDuration",
1289
type_func = lambda td: td.total_seconds() * 1000)
1106
type_func = timedelta_to_milliseconds)
1290
1107
host = notifychangeproperty(dbus.String, "Host")
1291
1108
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1292
type_func = lambda td:
1293
td.total_seconds() * 1000)
1109
type_func =
1110
timedelta_to_milliseconds)
1294
1111
extended_timeout = notifychangeproperty(
1295
1112
dbus.UInt64, "ExtendedTimeout",
1296
type_func = lambda td: td.total_seconds() * 1000)
1113
type_func = timedelta_to_milliseconds)
1297
1114
interval = notifychangeproperty(dbus.UInt64,
1298
1115
"Interval",
1299
1116
type_func =
1300
lambda td: td.total_seconds()
1301
* 1000)
1117
timedelta_to_milliseconds)
1302
1118
checker_command = notifychangeproperty(dbus.String, "Checker")
1303
1119
1304
1120
del notifychangeproperty
1332
1148
*args, **kwargs)
1333
1149
1334
1150
def start_checker(self, *args, **kwargs):
1335
old_checker_pid = getattr(self.checker, "pid", None)
1151
old_checker = self.checker
1152
if self.checker is not None:
1153
old_checker_pid = self.checker.pid
1154
else:
1155
old_checker_pid = None
1336
1156
r = Client.start_checker(self, *args, **kwargs)
1337
1157
# Only if new checker process was started
1338
1158
if (self.checker is not None
1346
1166
return False
1347
1167
1348
1168
def approve(self, value=True):
1169
self.send_changedstate()
1349
1170
self.approved = value
1350
gobject.timeout_add(int(self.approval_duration.total_seconds()
1351
* 1000), self._reset_approved)
1352
self.send_changedstate()
1171
gobject.timeout_add(timedelta_to_milliseconds
1172
(self.approval_duration),
1173
self._reset_approved)
1174
1353
1175
1354
1176
## D-Bus methods, signals & properties
1355
1177
_interface = "se.recompile.Mandos.Client"
1356
1178
1357
## Interfaces
1358
1359
@dbus_interface_annotations(_interface)
1360
def _foo(self):
1361
return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
1362
"false"}
1363
1364
1179
## Signals
1365
1180
1366
1181
# CheckerCompleted - signal
1402
1217
"D-Bus signal"
1403
1218
return self.need_approval()
1404
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
1405
1228
## Methods
1406
1229
1407
1230
# Approve - method
1457
1280
access="readwrite")
1458
1281
def ApprovalDelay_dbus_property(self, value=None):
1459
1282
if value is None: # get
1460
return dbus.UInt64(self.approval_delay.total_seconds()
1461
* 1000)
1283
return dbus.UInt64(self.approval_delay_milliseconds())
1462
1284
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1463
1285
1464
1286
# ApprovalDuration - property
1466
1288
access="readwrite")
1467
1289
def ApprovalDuration_dbus_property(self, value=None):
1468
1290
if value is None: # get
1469
return dbus.UInt64(self.approval_duration.total_seconds()
1470
* 1000)
1291
return dbus.UInt64(timedelta_to_milliseconds(
1292
self.approval_duration))
1471
1293
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1472
1294
1473
1295
# Name - property
1486
1308
def Host_dbus_property(self, value=None):
1487
1309
if value is None: # get
1488
1310
return dbus.String(self.host)
1489
self.host = str(value)
1311
self.host = unicode(value)
1490
1312
1491
1313
# Created - property
1492
1314
@dbus_service_property(_interface, signature="s", access="read")
1518
1340
return
1519
1341
return datetime_to_dbus(self.last_checked_ok)
1520
1342
1521
# LastCheckerStatus - property
1522
@dbus_service_property(_interface, signature="n",
1523
access="read")
1524
def LastCheckerStatus_dbus_property(self):
1525
return dbus.Int16(self.last_checker_status)
1526
1527
1343
# Expires - property
1528
1344
@dbus_service_property(_interface, signature="s", access="read")
1529
1345
def Expires_dbus_property(self):
1539
1355
access="readwrite")
1540
1356
def Timeout_dbus_property(self, value=None):
1541
1357
if value is None: # get
1542
return dbus.UInt64(self.timeout.total_seconds() * 1000)
1543
old_timeout = self.timeout
1358
return dbus.UInt64(self.timeout_milliseconds())
1544
1359
self.timeout = datetime.timedelta(0, 0, 0, value)
1545
# Reschedule disabling
1546
if self.enabled:
1547
now = datetime.datetime.utcnow()
1548
self.expires += self.timeout - old_timeout
1549
if self.expires <= now:
1550
# The timeout has passed
1551
self.disable()
1552
else:
1553
if (getattr(self, "disable_initiator_tag", None)
1554
is None):
1555
return
1556
gobject.source_remove(self.disable_initiator_tag)
1557
self.disable_initiator_tag = (
1558
gobject.timeout_add(
1559
int((self.expires - now).total_seconds()
1560
* 1000), 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))
1561
1380
1562
1381
# ExtendedTimeout - property
1563
1382
@dbus_service_property(_interface, signature="t",
1564
1383
access="readwrite")
1565
1384
def ExtendedTimeout_dbus_property(self, value=None):
1566
1385
if value is None: # get
1567
return dbus.UInt64(self.extended_timeout.total_seconds()
1568
* 1000)
1386
return dbus.UInt64(self.extended_timeout_milliseconds())
1569
1387
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1570
1388
1571
1389
# Interval - property
1573
1391
access="readwrite")
1574
1392
def Interval_dbus_property(self, value=None):
1575
1393
if value is None: # get
1576
return dbus.UInt64(self.interval.total_seconds() * 1000)
1394
return dbus.UInt64(self.interval_milliseconds())
1577
1395
self.interval = datetime.timedelta(0, 0, 0, value)
1578
1396
if getattr(self, "checker_initiator_tag", None) is None:
1579
1397
return
1590
1408
def Checker_dbus_property(self, value=None):
1591
1409
if value is None: # get
1592
1410
return dbus.String(self.checker_command)
1593
self.checker_command = str(value)
1411
self.checker_command = unicode(value)
1594
1412
1595
1413
# CheckerRunning - property
1596
1414
@dbus_service_property(_interface, signature="b",
1612
1430
@dbus_service_property(_interface, signature="ay",
1613
1431
access="write", byte_arrays=True)
1614
1432
def Secret_dbus_property(self, value):
1615
self.secret = bytes(value)
1433
self.secret = str(value)
1616
1434
1617
1435
del _interface
1618
1436
1643
1461
self._pipe.send(('setattr', name, value))
1644
1462
1645
1463
1464
class ClientDBusTransitional(ClientDBus):
1465
__metaclass__ = AlternateDBusNamesMetaclass
1466
1467
1646
1468
class ClientHandler(socketserver.BaseRequestHandler, object):
1647
1469
"""A class to handle client connections.
1648
1470
1652
1474
def handle(self):
1653
1475
with contextlib.closing(self.server.child_pipe) as child_pipe:
1654
1476
logger.info("TCP connection from: %s",
1655
str(self.client_address))
1477
unicode(self.client_address))
1656
1478
logger.debug("Pipe FD: %d",
1657
1479
self.server.child_pipe.fileno())
1658
1480
1684
1506
logger.debug("Protocol version: %r", line)
1685
1507
try:
1686
1508
if int(line.strip().split()[0]) > 1:
1687
raise RuntimeError(line)
1509
raise RuntimeError
1688
1510
except (ValueError, IndexError, RuntimeError) as error:
1689
1511
logger.error("Unknown protocol version: %s", error)
1690
1512
return
1716
1538
except KeyError:
1717
1539
return
1718
1540
1541
if self.server.use_dbus:
1542
# Emit D-Bus signal
1543
client.NewRequest(str(self.client_address))
1544
1719
1545
if client.approval_delay:
1720
1546
delay = client.approval_delay
1721
1547
client.approvals_pending += 1
1739
1565
if self.server.use_dbus:
1740
1566
# Emit D-Bus signal
1741
1567
client.NeedApproval(
1742
client.approval_delay.total_seconds()
1743
* 1000, client.approved_by_default)
1568
client.approval_delay_milliseconds(),
1569
client.approved_by_default)
1744
1570
else:
1745
1571
logger.warning("Client %s was not approved",
1746
1572
client.name)
1752
1578
#wait until timeout or approved
1753
1579
time = datetime.datetime.now()
1754
1580
client.changedstate.acquire()
1755
client.changedstate.wait(delay.total_seconds())
1581
(client.changedstate.wait
1582
(float(client.timedelta_to_milliseconds(delay)
1583
/ 1000)))
1756
1584
client.changedstate.release()
1757
1585
time2 = datetime.datetime.now()
1758
1586
if (time2 - time) >= delay:
1774
1602
try:
1775
1603
sent = session.send(client.secret[sent_size:])
1776
1604
except gnutls.errors.GNUTLSError as error:
1777
logger.warning("gnutls send failed",
1778
exc_info=error)
1605
logger.warning("gnutls send failed")
1779
1606
return
1780
1607
logger.debug("Sent: %d, remaining: %d",
1781
1608
sent, len(client.secret)
1784
1611
1785
1612
logger.info("Sending secret to %s", client.name)
1786
1613
# bump the timeout using extended_timeout
1787
client.bump_timeout(client.extended_timeout)
1614
client.checked_ok(client.extended_timeout)
1788
1615
if self.server.use_dbus:
1789
1616
# Emit D-Bus signal
1790
1617
client.GotSecret()
1795
1622
try:
1796
1623
session.bye()
1797
1624
except gnutls.errors.GNUTLSError as error:
1798
logger.warning("GnuTLS bye failed",
1799
exc_info=error)
1625
logger.warning("GnuTLS bye failed")
1800
1626
1801
1627
@staticmethod
1802
1628
def peer_certificate(session):
1874
1700
def process_request(self, request, address):
1875
1701
"""Start a new process to process the request."""
1876
1702
proc = multiprocessing.Process(target = self.sub_process_main,
1877
args = (request, address))
1703
args = (request,
1704
address))
1878
1705
proc.start()
1879
1706
return proc
1880
1707
1895
1722
1896
1723
def add_pipe(self, parent_pipe, proc):
1897
1724
"""Dummy function; override as necessary"""
1898
raise NotImplementedError()
1725
raise NotImplementedError
1899
1726
1900
1727
1901
1728
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1908
1735
use_ipv6: Boolean; to use IPv6 or not
1909
1736
"""
1910
1737
def __init__(self, server_address, RequestHandlerClass,
1911
interface=None, use_ipv6=True, socketfd=None):
1912
"""If socketfd is set, use that file descriptor instead of
1913
creating a new one with socket.socket().
1914
"""
1738
interface=None, use_ipv6=True):
1915
1739
self.interface = interface
1916
1740
if use_ipv6:
1917
1741
self.address_family = socket.AF_INET6
1918
if socketfd is not None:
1919
# Save the file descriptor
1920
self.socketfd = socketfd
1921
# Save the original socket.socket() function
1922
self.socket_socket = socket.socket
1923
# To implement --socket, we monkey patch socket.socket.
1924
#
1925
# (When socketserver.TCPServer is a new-style class, we
1926
# could make self.socket into a property instead of monkey
1927
# patching socket.socket.)
1928
#
1929
# Create a one-time-only replacement for socket.socket()
1930
@functools.wraps(socket.socket)
1931
def socket_wrapper(*args, **kwargs):
1932
# Restore original function so subsequent calls are
1933
# not affected.
1934
socket.socket = self.socket_socket
1935
del self.socket_socket
1936
# This time only, return a new socket object from the
1937
# saved file descriptor.
1938
return socket.fromfd(self.socketfd, *args, **kwargs)
1939
# Replace socket.socket() function with wrapper
1940
socket.socket = socket_wrapper
1941
# The socketserver.TCPServer.__init__ will call
1942
# socket.socket(), which might be our replacement,
1943
# socket_wrapper(), if socketfd was set.
1944
1742
socketserver.TCPServer.__init__(self, server_address,
1945
1743
RequestHandlerClass)
1946
1947
1744
def server_bind(self):
1948
1745
"""This overrides the normal server_bind() function
1949
1746
to bind to an interface if one was specified, and also NOT to
1957
1754
try:
1958
1755
self.socket.setsockopt(socket.SOL_SOCKET,
1959
1756
SO_BINDTODEVICE,
1960
(self.interface + "\0")
1961
.encode("utf-8"))
1757
str(self.interface
1758
+ '\0'))
1962
1759
except socket.error as error:
1963
if error.errno == errno.EPERM:
1964
logger.error("No permission to bind to"
1965
" interface %s", self.interface)
1966
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:
1967
1765
logger.error("SO_BINDTODEVICE not available;"
1968
1766
" cannot bind to interface %s",
1969
1767
self.interface)
1970
elif error.errno == errno.ENODEV:
1971
logger.error("Interface %s does not exist,"
1972
" cannot bind", self.interface)
1973
1768
else:
1974
1769
raise
1975
1770
# Only bind(2) the socket if we really need to.
1978
1773
if self.address_family == socket.AF_INET6:
1979
1774
any_address = "::" # in6addr_any
1980
1775
else:
1981
any_address = "0.0.0.0" # INADDR_ANY
1776
any_address = socket.INADDR_ANY
1982
1777
self.server_address = (any_address,
1983
1778
self.server_address[1])
1984
1779
elif not self.server_address[1]:
2005
1800
"""
2006
1801
def __init__(self, server_address, RequestHandlerClass,
2007
1802
interface=None, use_ipv6=True, clients=None,
2008
gnutls_priority=None, use_dbus=True, socketfd=None):
1803
gnutls_priority=None, use_dbus=True):
2009
1804
self.enabled = False
2010
1805
self.clients = clients
2011
1806
if self.clients is None:
2015
1810
IPv6_TCPServer.__init__(self, server_address,
2016
1811
RequestHandlerClass,
2017
1812
interface = interface,
2018
use_ipv6 = use_ipv6,
2019
socketfd = socketfd)
1813
use_ipv6 = use_ipv6)
2020
1814
def server_activate(self):
2021
1815
if self.enabled:
2022
1816
return socketserver.TCPServer.server_activate(self)
2035
1829
2036
1830
def handle_ipc(self, source, condition, parent_pipe=None,
2037
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)
2038
1846
# error, or the other end of multiprocessing.Pipe has closed
2039
if condition & (gobject.IO_ERR | gobject.IO_HUP):
1847
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
2040
1848
# Wait for other process to exit
2041
1849
proc.join()
2042
1850
return False
2100
1908
return True
2101
1909
2102
1910
2103
def rfc3339_duration_to_delta(duration):
2104
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2105
2106
>>> rfc3339_duration_to_delta("P7D")
2107
datetime.timedelta(7)
2108
>>> rfc3339_duration_to_delta("PT60S")
2109
datetime.timedelta(0, 60)
2110
>>> rfc3339_duration_to_delta("PT60M")
2111
datetime.timedelta(0, 3600)
2112
>>> rfc3339_duration_to_delta("PT24H")
2113
datetime.timedelta(1)
2114
>>> rfc3339_duration_to_delta("P1W")
2115
datetime.timedelta(7)
2116
>>> rfc3339_duration_to_delta("PT5M30S")
2117
datetime.timedelta(0, 330)
2118
>>> rfc3339_duration_to_delta("P1DT3M20S")
2119
datetime.timedelta(1, 200)
2120
"""
2121
2122
# Parsing an RFC 3339 duration with regular expressions is not
2123
# possible - there would have to be multiple places for the same
2124
# values, like seconds. The current code, while more esoteric, is
2125
# cleaner without depending on a parsing library. If Python had a
2126
# built-in library for parsing we would use it, but we'd like to
2127
# avoid excessive use of external libraries.
2128
2129
# New type for defining tokens, syntax, and semantics all-in-one
2130
Token = collections.namedtuple("Token",
2131
("regexp", # To match token; if
2132
# "value" is not None,
2133
# must have a "group"
2134
# containing digits
2135
"value", # datetime.timedelta or
2136
# None
2137
"followers")) # Tokens valid after
2138
# this token
2139
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2140
# the "duration" ABNF definition in RFC 3339, Appendix A.
2141
token_end = Token(re.compile(r"$"), None, frozenset())
2142
token_second = Token(re.compile(r"(\d+)S"),
2143
datetime.timedelta(seconds=1),
2144
frozenset((token_end,)))
2145
token_minute = Token(re.compile(r"(\d+)M"),
2146
datetime.timedelta(minutes=1),
2147
frozenset((token_second, token_end)))
2148
token_hour = Token(re.compile(r"(\d+)H"),
2149
datetime.timedelta(hours=1),
2150
frozenset((token_minute, token_end)))
2151
token_time = Token(re.compile(r"T"),
2152
None,
2153
frozenset((token_hour, token_minute,
2154
token_second)))
2155
token_day = Token(re.compile(r"(\d+)D"),
2156
datetime.timedelta(days=1),
2157
frozenset((token_time, token_end)))
2158
token_month = Token(re.compile(r"(\d+)M"),
2159
datetime.timedelta(weeks=4),
2160
frozenset((token_day, token_end)))
2161
token_year = Token(re.compile(r"(\d+)Y"),
2162
datetime.timedelta(weeks=52),
2163
frozenset((token_month, token_end)))
2164
token_week = Token(re.compile(r"(\d+)W"),
2165
datetime.timedelta(weeks=1),
2166
frozenset((token_end,)))
2167
token_duration = Token(re.compile(r"P"), None,
2168
frozenset((token_year, token_month,
2169
token_day, token_time,
2170
token_week)))
2171
# Define starting values
2172
value = datetime.timedelta() # Value so far
2173
found_token = None
2174
followers = frozenset((token_duration,)) # Following valid tokens
2175
s = duration # String left to parse
2176
# Loop until end token is found
2177
while found_token is not token_end:
2178
# Search for any currently valid tokens
2179
for token in followers:
2180
match = token.regexp.match(s)
2181
if match is not None:
2182
# Token found
2183
if token.value is not None:
2184
# Value found, parse digits
2185
factor = int(match.group(1), 10)
2186
# Add to value so far
2187
value += factor * token.value
2188
# Strip token from string
2189
s = token.regexp.sub("", s, 1)
2190
# Go to found token
2191
found_token = token
2192
# Set valid next tokens
2193
followers = found_token.followers
2194
break
2195
else:
2196
# No currently valid tokens were found
2197
raise ValueError("Invalid RFC 3339 duration")
2198
# End token found
2199
return value
2200
2201
2202
1911
def string_to_delta(interval):
2203
1912
"""Parse a string and return a datetime.timedelta
2204
1913
2215
1924
>>> string_to_delta('5m 30s')
2216
1925
datetime.timedelta(0, 330)
2217
1926
"""
2218
2219
try:
2220
return rfc3339_duration_to_delta(interval)
2221
except ValueError:
2222
pass
2223
2224
1927
timevalue = datetime.timedelta(0)
2225
1928
for s in interval.split():
2226
1929
try:
2227
suffix = s[-1]
1930
suffix = unicode(s[-1])
2228
1931
value = int(s[:-1])
2229
1932
if suffix == "d":
2230
1933
delta = datetime.timedelta(value)
2237
1940
elif suffix == "w":
2238
1941
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2239
1942
else:
2240
raise ValueError("Unknown suffix {!r}"
2241
.format(suffix))
2242
except IndexError as e:
1943
raise ValueError("Unknown suffix %r" % suffix)
1944
except (ValueError, IndexError) as e:
2243
1945
raise ValueError(*(e.args))
2244
1946
timevalue += delta
2245
1947
return timevalue
2258
1960
sys.exit()
2259
1961
if not noclose:
2260
1962
# Close all standard open file descriptors
2261
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1963
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2262
1964
if not stat.S_ISCHR(os.fstat(null).st_mode):
2263
raise OSError(errno.ENODEV, "{} not a character device"
2264
.format(os.devnull))
1965
raise OSError(errno.ENODEV,
1966
"%s not a character device"
1967
% os.path.devnull)
2265
1968
os.dup2(null, sys.stdin.fileno())
2266
1969
os.dup2(null, sys.stdout.fileno())
2267
1970
os.dup2(null, sys.stderr.fileno())
2276
1979
2277
1980
parser = argparse.ArgumentParser()
2278
1981
parser.add_argument("-v", "--version", action="version",
2279
version = "%(prog)s {}".format(version),
1982
version = "%%(prog)s %s" % version,
2280
1983
help="show version number and exit")
2281
1984
parser.add_argument("-i", "--interface", metavar="IF",
2282
1985
help="Bind to interface IF")
2288
1991
help="Run self-test")
2289
1992
parser.add_argument("--debug", action="store_true",
2290
1993
help="Debug mode; run in foreground and log"
2291
" to terminal", default=None)
1994
" to terminal")
2292
1995
parser.add_argument("--debuglevel", metavar="LEVEL",
2293
1996
help="Debug level for stdout output")
2294
1997
parser.add_argument("--priority", help="GnuTLS"
2301
2004
" files")
2302
2005
parser.add_argument("--no-dbus", action="store_false",
2303
2006
dest="use_dbus", help="Do not provide D-Bus"
2304
" system bus interface", default=None)
2007
" system bus interface")
2305
2008
parser.add_argument("--no-ipv6", action="store_false",
2306
dest="use_ipv6", help="Do not use IPv6",
2307
default=None)
2009
dest="use_ipv6", help="Do not use IPv6")
2308
2010
parser.add_argument("--no-restore", action="store_false",
2309
2011
dest="restore", help="Do not restore stored"
2310
" state", default=None)
2311
parser.add_argument("--socket", type=int,
2312
help="Specify a file descriptor to a network"
2313
" socket to use instead of creating one")
2012
" state")
2314
2013
parser.add_argument("--statedir", metavar="DIR",
2315
2014
help="Directory to save/restore state in")
2316
parser.add_argument("--foreground", action="store_true",
2317
help="Run in foreground", default=None)
2318
parser.add_argument("--no-zeroconf", action="store_false",
2319
dest="zeroconf", help="Do not use Zeroconf",
2320
default=None)
2321
2015
2322
2016
options = parser.parse_args()
2323
2017
2324
2018
if options.check:
2325
2019
import doctest
2326
fail_count, test_count = doctest.testmod()
2327
sys.exit(os.EX_OK if fail_count == 0 else 1)
2020
doctest.testmod()
2021
sys.exit()
2328
2022
2329
2023
# Default values for config file for server-global settings
2330
2024
server_defaults = { "interface": "",
2332
2026
"port": "",
2333
2027
"debug": "False",
2334
2028
"priority":
2335
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2029
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2336
2030
"servicename": "Mandos",
2337
2031
"use_dbus": "True",
2338
2032
"use_ipv6": "True",
2339
2033
"debuglevel": "",
2340
2034
"restore": "True",
2341
"socket": "",
2342
"statedir": "/var/lib/mandos",
2343
"foreground": "False",
2344
"zeroconf": "True",
2035
"statedir": "/var/lib/mandos"
2345
2036
}
2346
2037
2347
2038
# Parse config file for server-global settings
2352
2043
# Convert the SafeConfigParser object to a dict
2353
2044
server_settings = server_config.defaults()
2354
2045
# Use the appropriate methods on the non-string config options
2355
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2046
for option in ("debug", "use_dbus", "use_ipv6"):
2356
2047
server_settings[option] = server_config.getboolean("DEFAULT",
2357
2048
option)
2358
2049
if server_settings["port"]:
2359
2050
server_settings["port"] = server_config.getint("DEFAULT",
2360
2051
"port")
2361
if server_settings["socket"]:
2362
server_settings["socket"] = server_config.getint("DEFAULT",
2363
"socket")
2364
# Later, stdin will, and stdout and stderr might, be dup'ed
2365
# over with an opened os.devnull. But we don't want this to
2366
# happen with a supplied network socket.
2367
if 0 <= server_settings["socket"] <= 2:
2368
server_settings["socket"] = os.dup(server_settings
2369
["socket"])
2370
2052
del server_config
2371
2053
2372
2054
# Override the settings from the config file with command line
2374
2056
for option in ("interface", "address", "port", "debug",
2375
2057
"priority", "servicename", "configdir",
2376
2058
"use_dbus", "use_ipv6", "debuglevel", "restore",
2377
"statedir", "socket", "foreground", "zeroconf"):
2059
"statedir"):
2378
2060
value = getattr(options, option)
2379
2061
if value is not None:
2380
2062
server_settings[option] = value
2381
2063
del options
2382
2064
# Force all strings to be unicode
2383
2065
for option in server_settings.keys():
2384
if isinstance(server_settings[option], bytes):
2385
server_settings[option] = (server_settings[option]
2386
.decode("utf-8"))
2387
# Force all boolean options to be boolean
2388
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2389
"foreground", "zeroconf"):
2390
server_settings[option] = bool(server_settings[option])
2391
# Debug implies foreground
2392
if server_settings["debug"]:
2393
server_settings["foreground"] = True
2066
if type(server_settings[option]) is str:
2067
server_settings[option] = unicode(server_settings[option])
2394
2068
# Now we have our good server settings in "server_settings"
2395
2069
2396
2070
##################################################################
2397
2071
2398
if (not server_settings["zeroconf"] and
2399
not (server_settings["port"]
2400
or server_settings["socket"] != "")):
2401
parser.error("Needs port or socket to work without"
2402
" Zeroconf")
2403
2404
2072
# For convenience
2405
2073
debug = server_settings["debug"]
2406
2074
debuglevel = server_settings["debuglevel"]
2408
2076
use_ipv6 = server_settings["use_ipv6"]
2409
2077
stored_state_path = os.path.join(server_settings["statedir"],
2410
2078
stored_state_file)
2411
foreground = server_settings["foreground"]
2412
zeroconf = server_settings["zeroconf"]
2413
2079
2414
2080
if debug:
2415
initlogger(debug, logging.DEBUG)
2081
initlogger(logging.DEBUG)
2416
2082
else:
2417
2083
if not debuglevel:
2418
initlogger(debug)
2084
initlogger()
2419
2085
else:
2420
2086
level = getattr(logging, debuglevel.upper())
2421
initlogger(debug, level)
2087
initlogger(level)
2422
2088
2423
2089
if server_settings["servicename"] != "Mandos":
2424
2090
syslogger.setFormatter(logging.Formatter
2425
('Mandos ({}) [%(process)d]:'
2426
' %(levelname)s: %(message)s'
2427
.format(server_settings
2428
["servicename"])))
2091
('Mandos (%s) [%%(process)d]:'
2092
' %%(levelname)s: %%(message)s'
2093
% server_settings["servicename"]))
2429
2094
2430
2095
# Parse config file with clients
2431
client_config = configparser.SafeConfigParser(Client
2432
.client_defaults)
2096
client_config = configparser.SafeConfigParser(Client.client_defaults)
2433
2097
client_config.read(os.path.join(server_settings["configdir"],
2434
2098
"clients.conf"))
2435
2099
2436
2100
global mandos_dbus_service
2437
2101
mandos_dbus_service = None
2438
2102
2439
socketfd = None
2440
if server_settings["socket"] != "":
2441
socketfd = server_settings["socket"]
2442
2103
tcp_server = MandosServer((server_settings["address"],
2443
2104
server_settings["port"]),
2444
2105
ClientHandler,
2447
2108
use_ipv6=use_ipv6,
2448
2109
gnutls_priority=
2449
2110
server_settings["priority"],
2450
use_dbus=use_dbus,
2451
socketfd=socketfd)
2452
if not foreground:
2453
pidfilename = "/run/mandos.pid"
2454
if not os.path.isdir("/run/."):
2455
pidfilename = "/var/run/mandos.pid"
2456
pidfile = None
2111
use_dbus=use_dbus)
2112
if not debug:
2113
pidfilename = "/var/run/mandos.pid"
2457
2114
try:
2458
2115
pidfile = open(pidfilename, "w")
2459
except IOError as e:
2460
logger.error("Could not open file %r", pidfilename,
2461
exc_info=e)
2116
except IOError:
2117
logger.error("Could not open file %r", pidfilename)
2462
2118
2463
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:
2464
2123
try:
2465
uid = pwd.getpwnam(name).pw_uid
2466
gid = pwd.getpwnam(name).pw_gid
2467
break
2124
uid = pwd.getpwnam("mandos").pw_uid
2125
gid = pwd.getpwnam("mandos").pw_gid
2468
2126
except KeyError:
2469
continue
2470
else:
2471
uid = 65534
2472
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
2473
2133
try:
2474
2134
os.setgid(gid)
2475
2135
os.setuid(uid)
2476
2136
except OSError as error:
2477
if error.errno != errno.EPERM:
2478
raise
2137
if error[0] != errno.EPERM:
2138
raise error
2479
2139
2480
2140
if debug:
2481
2141
# Enable all possible GnuTLS debugging
2492
2152
.gnutls_global_set_log_function(debug_gnutls))
2493
2153
2494
2154
# Redirect stdin so all checkers get /dev/null
2495
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2155
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2496
2156
os.dup2(null, sys.stdin.fileno())
2497
2157
if null > 2:
2498
2158
os.close(null)
2159
else:
2160
# No console logging
2161
logger.removeHandler(console)
2499
2162
2500
2163
# Need to fork before connecting to D-Bus
2501
if not foreground:
2164
if not debug:
2502
2165
# Close all input and output, do double fork, etc.
2503
2166
daemon()
2504
2167
2505
# multiprocessing will use threads, so before we use gobject we
2506
# need to inform gobject that threads will be used.
2507
gobject.threads_init()
2508
2509
2168
global main_loop
2510
2169
# From the Avahi example code
2511
DBusGMainLoop(set_as_default=True)
2170
DBusGMainLoop(set_as_default=True )
2512
2171
main_loop = gobject.MainLoop()
2513
2172
bus = dbus.SystemBus()
2514
2173
# End of Avahi example code
2520
2179
("se.bsnet.fukt.Mandos", bus,
2521
2180
do_not_queue=True))
2522
2181
except dbus.exceptions.NameExistsException as e:
2523
logger.error("Disabling D-Bus:", exc_info=e)
2182
logger.error(unicode(e) + ", disabling D-Bus")
2524
2183
use_dbus = False
2525
2184
server_settings["use_dbus"] = False
2526
2185
tcp_server.use_dbus = False
2527
if zeroconf:
2528
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2529
service = AvahiServiceToSyslog(name =
2530
server_settings["servicename"],
2531
servicetype = "_mandos._tcp",
2532
protocol = protocol, bus = bus)
2533
if server_settings["interface"]:
2534
service.interface = (if_nametoindex
2535
(server_settings["interface"]
2536
.encode("utf-8")))
2186
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2187
service = AvahiServiceToSyslog(name =
2188
server_settings["servicename"],
2189
servicetype = "_mandos._tcp",
2190
protocol = protocol, bus = bus)
2191
if server_settings["interface"]:
2192
service.interface = (if_nametoindex
2193
(str(server_settings["interface"])))
2537
2194
2538
2195
global multiprocessing_manager
2539
2196
multiprocessing_manager = multiprocessing.Manager()
2540
2197
2541
2198
client_class = Client
2542
2199
if use_dbus:
2543
client_class = functools.partial(ClientDBus, bus = bus)
2200
client_class = functools.partial(ClientDBusTransitional,
2201
bus = bus)
2544
2202
2545
2203
client_settings = Client.config_parser(client_config)
2546
2204
old_client_settings = {}
2547
2205
clients_data = {}
2548
2206
2549
# This is used to redirect stdout and stderr for checker processes
2550
global wnull
2551
wnull = open(os.devnull, "w") # A writable /dev/null
2552
# Only used if server is running in foreground but not in debug
2553
# mode
2554
if debug or not foreground:
2555
wnull.close()
2556
2557
2207
# Get client data and settings from last running state.
2558
2208
if server_settings["restore"]:
2559
2209
try:
2562
2212
(stored_state))
2563
2213
os.remove(stored_state_path)
2564
2214
except IOError as e:
2565
if e.errno == errno.ENOENT:
2566
logger.warning("Could not load persistent state: {}"
2567
.format(os.strerror(e.errno)))
2568
else:
2569
logger.critical("Could not load persistent state:",
2570
exc_info=e)
2215
logger.warning("Could not load persistent state: {0}"
2216
.format(e))
2217
if e.errno != errno.ENOENT:
2571
2218
raise
2572
except EOFError as e:
2573
logger.warning("Could not load persistent state: "
2574
"EOFError:", exc_info=e)
2575
2219
2576
2220
with PGPEngine() as pgp:
2577
for client_name, client in clients_data.items():
2578
# Skip removed clients
2579
if client_name not in client_settings:
2580
continue
2581
2221
for client_name, client in clients_data.iteritems():
2582
2222
# Decide which value to use after restoring saved state.
2583
2223
# We have three different values: Old config file,
2584
2224
# new config file, and saved state.
2598
2238
2599
2239
# Clients who has passed its expire date can still be
2600
2240
# enabled if its last checker was successful. Clients
2601
# whose checker succeeded before we stored its state is
2602
# assumed to have successfully run all checkers during
2603
# downtime.
2241
# whose checker failed before we stored its state is
2242
# assumed to have failed all checkers during downtime.
2604
2243
if client["enabled"]:
2605
2244
if datetime.datetime.utcnow() >= client["expires"]:
2606
2245
if not client["last_checked_ok"]:
2607
2246
logger.warning(
2608
"disabling client {} - Client never "
2609
"performed a successful checker"
2610
.format(client_name))
2247
"disabling client {0} - Client never "
2248
"performed a successfull checker"
2249
.format(client["name"]))
2611
2250
client["enabled"] = False
2612
2251
elif client["last_checker_status"] != 0:
2613
2252
logger.warning(
2614
"disabling client {} - Client last"
2615
" checker failed with error code {}"
2616
.format(client_name,
2253
"disabling client {0} - Client "
2254
"last checker failed with error code {1}"
2255
.format(client["name"],
2617
2256
client["last_checker_status"]))
2618
2257
client["enabled"] = False
2619
2258
else:
2620
2259
client["expires"] = (datetime.datetime
2621
2260
.utcnow()
2622
2261
+ client["timeout"])
2623
logger.debug("Last checker succeeded,"
2624
" keeping {} enabled"
2625
.format(client_name))
2262
2626
2263
try:
2627
2264
client["secret"] = (
2628
2265
pgp.decrypt(client["encrypted_secret"],
2630
2267
["secret"]))
2631
2268
except PGPError:
2632
2269
# If decryption fails, we use secret from new settings
2633
logger.debug("Failed to decrypt {} old secret"
2270
logger.debug("Failed to decrypt {0} old secret"
2634
2271
.format(client_name))
2635
2272
client["secret"] = (
2636
2273
client_settings[client_name]["secret"])
2274
2637
2275
2638
2276
# Add/remove clients based on new changes made to config
2639
for client_name in (set(old_client_settings)
2640
- set(client_settings)):
2277
for client_name in set(old_client_settings) - set(client_settings):
2641
2278
del clients_data[client_name]
2642
for client_name in (set(client_settings)
2643
- set(old_client_settings)):
2279
for client_name in set(client_settings) - set(old_client_settings):
2644
2280
clients_data[client_name] = client_settings[client_name]
2645
2646
# Create all client objects
2647
for client_name, client in clients_data.items():
2281
2282
# Create clients all clients
2283
for client_name, client in clients_data.iteritems():
2648
2284
tcp_server.clients[client_name] = client_class(
2649
name = client_name, settings = client,
2650
server_settings = server_settings)
2285
name = client_name, settings = client)
2651
2286
2652
2287
if not tcp_server.clients:
2653
2288
logger.warning("No clients defined")
2654
2655
if not foreground:
2656
if pidfile is not None:
2657
try:
2658
with pidfile:
2659
pid = os.getpid()
2660
pidfile.write("{}\n".format(pid).encode("utf-8"))
2661
except IOError:
2662
logger.error("Could not write to file %r with PID %d",
2663
pidfilename, pid)
2664
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
2665
2302
del pidfilename
2303
signal.signal(signal.SIGINT, signal.SIG_IGN)
2666
2304
2667
2305
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2668
2306
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2669
2307
2670
2308
if use_dbus:
2671
@alternate_dbus_interfaces({"se.recompile.Mandos":
2672
"se.bsnet.fukt.Mandos"})
2673
class MandosDBusService(DBusObjectWithProperties):
2309
class MandosDBusService(dbus.service.Object):
2674
2310
"""A D-Bus proxy object"""
2675
2311
def __init__(self):
2676
2312
dbus.service.Object.__init__(self, bus, "/")
2677
2313
_interface = "se.recompile.Mandos"
2678
2314
2679
@dbus_interface_annotations(_interface)
2680
def _foo(self):
2681
return { "org.freedesktop.DBus.Property"
2682
".EmitsChangedSignal":
2683
"false"}
2684
2685
2315
@dbus.service.signal(_interface, signature="o")
2686
2316
def ClientAdded(self, objpath):
2687
2317
"D-Bus signal"
2729
2359
2730
2360
del _interface
2731
2361
2732
mandos_dbus_service = MandosDBusService()
2362
class MandosDBusServiceTransitional(MandosDBusService):
2363
__metaclass__ = AlternateDBusNamesMetaclass
2364
mandos_dbus_service = MandosDBusServiceTransitional()
2733
2365
2734
2366
def cleanup():
2735
2367
"Cleanup function; run on exit"
2736
if zeroconf:
2737
service.cleanup()
2368
service.cleanup()
2738
2369
2739
2370
multiprocessing.active_children()
2740
wnull.close()
2741
2371
if not (tcp_server.clients or client_settings):
2742
2372
return
2743
2373
2754
2384
2755
2385
# A list of attributes that can not be pickled
2756
2386
# + secret.
2757
exclude = { "bus", "changedstate", "secret",
2758
"checker", "server_settings" }
2387
exclude = set(("bus", "changedstate", "secret",
2388
"checker"))
2759
2389
for name, typ in (inspect.getmembers
2760
2390
(dbus.service.Object)):
2761
2391
exclude.add(name)
2770
2400
del client_settings[client.name]["secret"]
2771
2401
2772
2402
try:
2773
with (tempfile.NamedTemporaryFile
2774
(mode='wb', suffix=".pickle", prefix='clients-',
2775
dir=os.path.dirname(stored_state_path),
2776
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:
2777
2406
pickle.dump((clients, client_settings), stored_state)
2778
tempname=stored_state.name
2779
os.rename(tempname, stored_state_path)
2780
2407
except (IOError, OSError) as e:
2781
if not debug:
2782
try:
2783
os.remove(tempname)
2784
except NameError:
2785
pass
2786
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2787
logger.warning("Could not save persistent state: {}"
2788
.format(os.strerror(e.errno)))
2789
else:
2790
logger.warning("Could not save persistent state:",
2791
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):
2792
2411
raise
2793
2412
2794
2413
# Delete all clients, and settings from config
2819
2438
tcp_server.server_activate()
2820
2439
2821
2440
# Find out what port we got
2822
if zeroconf:
2823
service.port = tcp_server.socket.getsockname()[1]
2441
service.port = tcp_server.socket.getsockname()[1]
2824
2442
if use_ipv6:
2825
2443
logger.info("Now listening on address %r, port %d,"
2826
" flowinfo %d, scope_id %d",
2827
*tcp_server.socket.getsockname())
2444
" flowinfo %d, scope_id %d"
2445
% tcp_server.socket.getsockname())
2828
2446
else: # IPv4
2829
logger.info("Now listening on address %r, port %d",
2830
*tcp_server.socket.getsockname())
2447
logger.info("Now listening on address %r, port %d"
2448
% tcp_server.socket.getsockname())
2831
2449
2832
2450
#service.interface = tcp_server.socket.getsockname()[3]
2833
2451
2834
2452
try:
2835
if zeroconf:
2836
# From the Avahi example code
2837
try:
2838
service.activate()
2839
except dbus.exceptions.DBusException as error:
2840
logger.critical("D-Bus Exception", exc_info=error)
2841
cleanup()
2842
sys.exit(1)
2843
# End of Avahi example code
2453
# From the Avahi example code
2454
try:
2455
service.activate()
2456
except dbus.exceptions.DBusException as error:
2457
logger.critical("DBusException: %s", error)
2458
cleanup()
2459
sys.exit(1)
2460
# End of Avahi example code
2844
2461
2845
2462
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2846
2463
lambda *args, **kwargs:
2850
2467
logger.debug("Starting main loop")
2851
2468
main_loop.run()
2852
2469
except AvahiError as error:
2853
logger.critical("Avahi Error", exc_info=error)
2470
logger.critical("AvahiError: %s", error)
2854
2471
cleanup()
2855
2472
sys.exit(1)
2856
2473
except KeyboardInterrupt:
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0