To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 237.7.179
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.179
- Committer: Teddy Hogeborn
- Date: 2013-10-22 19:24:01 UTC
- mto: (237.7.272 trunk)
- mto: This revision was merged to the branch mainline in revision 305.
- Revision ID: teddy@recompile.se-20131022192401-op6mwsb7f7gygjyh
* mandos (priority): Bug fix: Add even more magic to make the old
DSA/ELG 2048-bit keys work with GnuTLS.
* mandos-keygen (KEYCOMMENT): Changed default to "".
* mandos-keygen (OPTIONS): Document new default value of "--comment".
* mandos-options.xml (priority): Document new default value.
* mandos.conf (priority): - '' -
DSA/ELG 2048-bit keys work with GnuTLS.
* mandos-keygen (KEYCOMMENT): Changed default to "".
* mandos-keygen (OPTIONS): Document new default value of "--comment".
* mandos-options.xml (priority): Document new default value.
* mandos.conf (priority): - '' -
- files added:
- mandos-change-keytype
- files removed:
- debian/upstream
- plugin-helpers
- files modified:
- DBUS-API
added
removed
mandos
11
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2008-2016 Teddy Hogeborn
15
# Copyright © 2008-2016 Björn Påhlsson
14
# Copyright © 2008-2013 Teddy Hogeborn
15
# Copyright © 2008-2013 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
try:
40
import SocketServer as socketserver
41
except ImportError:
42
import socketserver
39
import SocketServer as socketserver
43
40
import socket
44
41
import argparse
45
42
import datetime
46
43
import errno
47
try:
48
import ConfigParser as configparser
49
except ImportError:
50
import configparser
44
import gnutls.crypto
45
import gnutls.connection
46
import gnutls.errors
47
import gnutls.library.functions
48
import gnutls.library.constants
49
import gnutls.library.types
50
import ConfigParser as configparser
51
51
import sys
52
52
import re
53
53
import os
62
62
import struct
63
63
import fcntl
64
64
import functools
65
try:
66
import cPickle as pickle
67
except ImportError:
68
import pickle
65
import cPickle as pickle
69
66
import multiprocessing
70
67
import types
71
68
import binascii
72
69
import tempfile
73
70
import itertools
74
71
import collections
75
import codecs
76
72
77
73
import dbus
78
74
import dbus.service
79
try:
80
import gobject
81
except ImportError:
82
from gi.repository import GObject as gobject
75
import gobject
83
76
import avahi
84
77
from dbus.mainloop.glib import DBusGMainLoop
85
78
import ctypes
95
88
except ImportError:
96
89
SO_BINDTODEVICE = None
97
90
98
if sys.version_info.major == 2:
99
str = unicode
100
101
version = "1.7.3"
91
version = "1.6.1"
102
92
stored_state_file = "clients.pickle"
103
93
104
94
logger = logging.getLogger()
105
syslogger = None
95
syslogger = (logging.handlers.SysLogHandler
96
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
97
address = str("/dev/log")))
106
98
107
99
try:
108
if_nametoindex = ctypes.cdll.LoadLibrary(
109
ctypes.util.find_library("c")).if_nametoindex
100
if_nametoindex = (ctypes.cdll.LoadLibrary
101
(ctypes.util.find_library("c"))
102
.if_nametoindex)
110
103
except (OSError, AttributeError):
111
112
104
def if_nametoindex(interface):
113
105
"Get an interface index the hard way, i.e. using fcntl()"
114
106
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
115
107
with contextlib.closing(socket.socket()) as s:
116
108
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
117
struct.pack(b"16s16x", interface))
118
interface_index = struct.unpack("I", ifreq[16:20])[0]
109
struct.pack(str("16s16x"),
110
interface))
111
interface_index = struct.unpack(str("I"),
112
ifreq[16:20])[0]
119
113
return interface_index
120
114
121
115
122
116
def initlogger(debug, level=logging.WARNING):
123
117
"""init logger and add loglevel"""
124
118
125
global syslogger
126
syslogger = (logging.handlers.SysLogHandler(
127
facility = logging.handlers.SysLogHandler.LOG_DAEMON,
128
address = "/dev/log"))
129
119
syslogger.setFormatter(logging.Formatter
130
120
('Mandos [%(process)d]: %(levelname)s:'
131
121
' %(message)s'))
148
138
149
139
class PGPEngine(object):
150
140
"""A simple class for OpenPGP symmetric encryption & decryption"""
151
152
141
def __init__(self):
153
142
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
154
self.gpg = "gpg"
155
try:
156
output = subprocess.check_output(["gpgconf"])
157
for line in output.splitlines():
158
name, text, path = line.split(":")
159
if name == "gpg":
160
self.gpg = path
161
break
162
except OSError as e:
163
if e.errno != errno.ENOENT:
164
raise
165
143
self.gnupgargs = ['--batch',
166
'--homedir', self.tempdir,
144
'--home', self.tempdir,
167
145
'--force-mdc',
168
146
'--quiet',
169
147
'--no-use-agent']
204
182
205
183
def encrypt(self, data, password):
206
184
passphrase = self.password_encode(password)
207
with tempfile.NamedTemporaryFile(
208
dir=self.tempdir) as passfile:
185
with tempfile.NamedTemporaryFile(dir=self.tempdir
186
) as passfile:
209
187
passfile.write(passphrase)
210
188
passfile.flush()
211
proc = subprocess.Popen([self.gpg, '--symmetric',
189
proc = subprocess.Popen(['gpg', '--symmetric',
212
190
'--passphrase-file',
213
191
passfile.name]
214
192
+ self.gnupgargs,
222
200
223
201
def decrypt(self, data, password):
224
202
passphrase = self.password_encode(password)
225
with tempfile.NamedTemporaryFile(
226
dir = self.tempdir) as passfile:
203
with tempfile.NamedTemporaryFile(dir = self.tempdir
204
) as passfile:
227
205
passfile.write(passphrase)
228
206
passfile.flush()
229
proc = subprocess.Popen([self.gpg, '--decrypt',
207
proc = subprocess.Popen(['gpg', '--decrypt',
230
208
'--passphrase-file',
231
209
passfile.name]
232
210
+ self.gnupgargs,
233
211
stdin = subprocess.PIPE,
234
212
stdout = subprocess.PIPE,
235
213
stderr = subprocess.PIPE)
236
decrypted_plaintext, err = proc.communicate(input = data)
214
decrypted_plaintext, err = proc.communicate(input
215
= data)
237
216
if proc.returncode != 0:
238
217
raise PGPError(err)
239
218
return decrypted_plaintext
242
221
class AvahiError(Exception):
243
222
def __init__(self, value, *args, **kwargs):
244
223
self.value = value
245
return super(AvahiError, self).__init__(value, *args,
246
**kwargs)
247
224
super(AvahiError, self).__init__(value, *args, **kwargs)
225
def __unicode__(self):
226
return unicode(repr(self.value))
248
227
249
228
class AvahiServiceError(AvahiError):
250
229
pass
251
230
252
253
231
class AvahiGroupError(AvahiError):
254
232
pass
255
233
275
253
bus: dbus.SystemBus()
276
254
"""
277
255
278
def __init__(self,
279
interface = avahi.IF_UNSPEC,
280
name = None,
281
servicetype = None,
282
port = None,
283
TXT = None,
284
domain = "",
285
host = "",
286
max_renames = 32768,
287
protocol = avahi.PROTO_UNSPEC,
288
bus = None):
256
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
257
servicetype = None, port = None, TXT = None,
258
domain = "", host = "", max_renames = 32768,
259
protocol = avahi.PROTO_UNSPEC, bus = None):
289
260
self.interface = interface
290
261
self.name = name
291
262
self.type = servicetype
301
272
self.bus = bus
302
273
self.entry_group_state_changed_match = None
303
274
304
def rename(self, remove=True):
275
def rename(self):
305
276
"""Derived from the Avahi example code"""
306
277
if self.rename_count >= self.max_renames:
307
278
logger.critical("No suitable Zeroconf service name found"
308
279
" after %i retries, exiting.",
309
280
self.rename_count)
310
281
raise AvahiServiceError("Too many renames")
311
self.name = str(
312
self.server.GetAlternativeServiceName(self.name))
313
self.rename_count += 1
282
self.name = unicode(self.server
283
.GetAlternativeServiceName(self.name))
314
284
logger.info("Changing Zeroconf service name to %r ...",
315
285
self.name)
316
if remove:
317
self.remove()
286
self.remove()
318
287
try:
319
288
self.add()
320
289
except dbus.exceptions.DBusException as error:
321
if (error.get_dbus_name()
322
== "org.freedesktop.Avahi.CollisionError"):
323
logger.info("Local Zeroconf service name collision.")
324
return self.rename(remove=False)
325
else:
326
logger.critical("D-Bus Exception", exc_info=error)
327
self.cleanup()
328
os._exit(1)
290
logger.critical("D-Bus Exception", exc_info=error)
291
self.cleanup()
292
os._exit(1)
293
self.rename_count += 1
329
294
330
295
def remove(self):
331
296
"""Derived from the Avahi example code"""
369
334
self.rename()
370
335
elif state == avahi.ENTRY_GROUP_FAILURE:
371
336
logger.critical("Avahi: Error in group state changed %s",
372
str(error))
373
raise AvahiGroupError("State changed: {!s}".format(error))
337
unicode(error))
338
raise AvahiGroupError("State changed: {0!s}"
339
.format(error))
374
340
375
341
def cleanup(self):
376
342
"""Derived from the Avahi example code"""
386
352
def server_state_changed(self, state, error=None):
387
353
"""Derived from the Avahi example code"""
388
354
logger.debug("Avahi server state change: %i", state)
389
bad_states = {
390
avahi.SERVER_INVALID: "Zeroconf server invalid",
391
avahi.SERVER_REGISTERING: None,
392
avahi.SERVER_COLLISION: "Zeroconf server name collision",
393
avahi.SERVER_FAILURE: "Zeroconf server failure",
394
}
355
bad_states = { avahi.SERVER_INVALID:
356
"Zeroconf server invalid",
357
avahi.SERVER_REGISTERING: None,
358
avahi.SERVER_COLLISION:
359
"Zeroconf server name collision",
360
avahi.SERVER_FAILURE:
361
"Zeroconf server failure" }
395
362
if state in bad_states:
396
363
if bad_states[state] is not None:
397
364
if error is None:
400
367
logger.error(bad_states[state] + ": %r", error)
401
368
self.cleanup()
402
369
elif state == avahi.SERVER_RUNNING:
403
try:
404
self.add()
405
except dbus.exceptions.DBusException as error:
406
if (error.get_dbus_name()
407
== "org.freedesktop.Avahi.CollisionError"):
408
logger.info("Local Zeroconf service name"
409
" collision.")
410
return self.rename(remove=False)
411
else:
412
logger.critical("D-Bus Exception", exc_info=error)
413
self.cleanup()
414
os._exit(1)
370
self.add()
415
371
else:
416
372
if error is None:
417
373
logger.debug("Unknown state: %r", state)
427
383
follow_name_owner_changes=True),
428
384
avahi.DBUS_INTERFACE_SERVER)
429
385
self.server.connect_to_signal("StateChanged",
430
self.server_state_changed)
386
self.server_state_changed)
431
387
self.server_state_changed(self.server.GetState())
432
388
433
389
434
390
class AvahiServiceToSyslog(AvahiService):
435
def rename(self, *args, **kwargs):
391
def rename(self):
436
392
"""Add the new name to the syslog messages"""
437
ret = AvahiService.rename(self, *args, **kwargs)
438
syslogger.setFormatter(logging.Formatter(
439
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
440
.format(self.name)))
393
ret = AvahiService.rename(self)
394
syslogger.setFormatter(logging.Formatter
395
('Mandos ({0}) [%(process)d]:'
396
' %(levelname)s: %(message)s'
397
.format(self.name)))
441
398
return ret
442
399
443
# Pretend that we have a GnuTLS module
444
class GnuTLS(object):
445
"""This isn't so much a class as it is a module-like namespace.
446
It is instantiated once, and simulates having a GnuTLS module."""
447
448
_library = ctypes.cdll.LoadLibrary(
449
ctypes.util.find_library("gnutls"))
450
_need_version = "3.3.0"
451
def __init__(self):
452
# Need to use class name "GnuTLS" here, since this method is
453
# called before the assignment to the "gnutls" global variable
454
# happens.
455
if GnuTLS.check_version(self._need_version) is None:
456
raise GnuTLS.Error("Needs GnuTLS {} or later"
457
.format(self._need_version))
458
459
# Unless otherwise indicated, the constants and types below are
460
# all from the gnutls/gnutls.h C header file.
461
462
# Constants
463
E_SUCCESS = 0
464
E_INTERRUPTED = -52
465
E_AGAIN = -28
466
CRT_OPENPGP = 2
467
CLIENT = 2
468
SHUT_RDWR = 0
469
CRD_CERTIFICATE = 1
470
E_NO_CERTIFICATE_FOUND = -49
471
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
472
473
# Types
474
class session_int(ctypes.Structure):
475
_fields_ = []
476
session_t = ctypes.POINTER(session_int)
477
class certificate_credentials_st(ctypes.Structure):
478
_fields_ = []
479
certificate_credentials_t = ctypes.POINTER(
480
certificate_credentials_st)
481
certificate_type_t = ctypes.c_int
482
class datum_t(ctypes.Structure):
483
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
484
('size', ctypes.c_uint)]
485
class openpgp_crt_int(ctypes.Structure):
486
_fields_ = []
487
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
488
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
489
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
490
credentials_type_t = ctypes.c_int #
491
transport_ptr_t = ctypes.c_void_p
492
close_request_t = ctypes.c_int
493
494
# Exceptions
495
class Error(Exception):
496
# We need to use the class name "GnuTLS" here, since this
497
# exception might be raised from within GnuTLS.__init__,
498
# which is called before the assignment to the "gnutls"
499
# global variable has happened.
500
def __init__(self, message = None, code = None, args=()):
501
# Default usage is by a message string, but if a return
502
# code is passed, convert it to a string with
503
# gnutls.strerror()
504
self.code = code
505
if message is None and code is not None:
506
message = GnuTLS.strerror(code)
507
return super(GnuTLS.Error, self).__init__(
508
message, *args)
509
510
class CertificateSecurityError(Error):
511
pass
512
513
# Classes
514
class Credentials(object):
515
def __init__(self):
516
self._c_object = gnutls.certificate_credentials_t()
517
gnutls.certificate_allocate_credentials(
518
ctypes.byref(self._c_object))
519
self.type = gnutls.CRD_CERTIFICATE
520
521
def __del__(self):
522
gnutls.certificate_free_credentials(self._c_object)
523
524
class ClientSession(object):
525
def __init__(self, socket, credentials = None):
526
self._c_object = gnutls.session_t()
527
gnutls.init(ctypes.byref(self._c_object), gnutls.CLIENT)
528
gnutls.set_default_priority(self._c_object)
529
gnutls.transport_set_ptr(self._c_object, socket.fileno())
530
gnutls.handshake_set_private_extensions(self._c_object,
531
True)
532
self.socket = socket
533
if credentials is None:
534
credentials = gnutls.Credentials()
535
gnutls.credentials_set(self._c_object, credentials.type,
536
ctypes.cast(credentials._c_object,
537
ctypes.c_void_p))
538
self.credentials = credentials
539
540
def __del__(self):
541
gnutls.deinit(self._c_object)
542
543
def handshake(self):
544
return gnutls.handshake(self._c_object)
545
546
def send(self, data):
547
data = bytes(data)
548
data_len = len(data)
549
while data_len > 0:
550
data_len -= gnutls.record_send(self._c_object,
551
data[-data_len:],
552
data_len)
553
554
def bye(self):
555
return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
556
557
# Error handling functions
558
def _error_code(result):
559
"""A function to raise exceptions on errors, suitable
560
for the 'restype' attribute on ctypes functions"""
561
if result >= 0:
562
return result
563
if result == gnutls.E_NO_CERTIFICATE_FOUND:
564
raise gnutls.CertificateSecurityError(code = result)
565
raise gnutls.Error(code = result)
566
567
def _retry_on_error(result, func, arguments):
568
"""A function to retry on some errors, suitable
569
for the 'errcheck' attribute on ctypes functions"""
570
while result < 0:
571
if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
572
return _error_code(result)
573
result = func(*arguments)
574
return result
575
576
# Unless otherwise indicated, the function declarations below are
577
# all from the gnutls/gnutls.h C header file.
578
579
# Functions
580
priority_set_direct = _library.gnutls_priority_set_direct
581
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
582
ctypes.POINTER(ctypes.c_char_p)]
583
priority_set_direct.restype = _error_code
584
585
init = _library.gnutls_init
586
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
587
init.restype = _error_code
588
589
set_default_priority = _library.gnutls_set_default_priority
590
set_default_priority.argtypes = [session_t]
591
set_default_priority.restype = _error_code
592
593
record_send = _library.gnutls_record_send
594
record_send.argtypes = [session_t, ctypes.c_void_p,
595
ctypes.c_size_t]
596
record_send.restype = ctypes.c_ssize_t
597
record_send.errcheck = _retry_on_error
598
599
certificate_allocate_credentials = (
600
_library.gnutls_certificate_allocate_credentials)
601
certificate_allocate_credentials.argtypes = [
602
ctypes.POINTER(certificate_credentials_t)]
603
certificate_allocate_credentials.restype = _error_code
604
605
certificate_free_credentials = (
606
_library.gnutls_certificate_free_credentials)
607
certificate_free_credentials.argtypes = [certificate_credentials_t]
608
certificate_free_credentials.restype = None
609
610
handshake_set_private_extensions = (
611
_library.gnutls_handshake_set_private_extensions)
612
handshake_set_private_extensions.argtypes = [session_t,
613
ctypes.c_int]
614
handshake_set_private_extensions.restype = None
615
616
credentials_set = _library.gnutls_credentials_set
617
credentials_set.argtypes = [session_t, credentials_type_t,
618
ctypes.c_void_p]
619
credentials_set.restype = _error_code
620
621
strerror = _library.gnutls_strerror
622
strerror.argtypes = [ctypes.c_int]
623
strerror.restype = ctypes.c_char_p
624
625
certificate_type_get = _library.gnutls_certificate_type_get
626
certificate_type_get.argtypes = [session_t]
627
certificate_type_get.restype = _error_code
628
629
certificate_get_peers = _library.gnutls_certificate_get_peers
630
certificate_get_peers.argtypes = [session_t,
631
ctypes.POINTER(ctypes.c_uint)]
632
certificate_get_peers.restype = ctypes.POINTER(datum_t)
633
634
global_set_log_level = _library.gnutls_global_set_log_level
635
global_set_log_level.argtypes = [ctypes.c_int]
636
global_set_log_level.restype = None
637
638
global_set_log_function = _library.gnutls_global_set_log_function
639
global_set_log_function.argtypes = [log_func]
640
global_set_log_function.restype = None
641
642
deinit = _library.gnutls_deinit
643
deinit.argtypes = [session_t]
644
deinit.restype = None
645
646
handshake = _library.gnutls_handshake
647
handshake.argtypes = [session_t]
648
handshake.restype = _error_code
649
handshake.errcheck = _retry_on_error
650
651
transport_set_ptr = _library.gnutls_transport_set_ptr
652
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
653
transport_set_ptr.restype = None
654
655
bye = _library.gnutls_bye
656
bye.argtypes = [session_t, close_request_t]
657
bye.restype = _error_code
658
bye.errcheck = _retry_on_error
659
660
check_version = _library.gnutls_check_version
661
check_version.argtypes = [ctypes.c_char_p]
662
check_version.restype = ctypes.c_char_p
663
664
# All the function declarations below are from gnutls/openpgp.h
665
666
openpgp_crt_init = _library.gnutls_openpgp_crt_init
667
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
668
openpgp_crt_init.restype = _error_code
669
670
openpgp_crt_import = _library.gnutls_openpgp_crt_import
671
openpgp_crt_import.argtypes = [openpgp_crt_t,
672
ctypes.POINTER(datum_t),
673
openpgp_crt_fmt_t]
674
openpgp_crt_import.restype = _error_code
675
676
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
677
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
678
ctypes.POINTER(ctypes.c_uint)]
679
openpgp_crt_verify_self.restype = _error_code
680
681
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
682
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
683
openpgp_crt_deinit.restype = None
684
685
openpgp_crt_get_fingerprint = (
686
_library.gnutls_openpgp_crt_get_fingerprint)
687
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
688
ctypes.c_void_p,
689
ctypes.POINTER(
690
ctypes.c_size_t)]
691
openpgp_crt_get_fingerprint.restype = _error_code
692
693
# Remove non-public functions
694
del _error_code, _retry_on_error
695
# Create the global "gnutls" object, simulating a module
696
gnutls = GnuTLS()
697
698
def call_pipe(connection, # : multiprocessing.Connection
699
func, *args, **kwargs):
700
"""This function is meant to be called by multiprocessing.Process
701
702
This function runs func(*args, **kwargs), and writes the resulting
703
return value on the provided multiprocessing.Connection.
704
"""
705
connection.send(func(*args, **kwargs))
706
connection.close()
400
401
def timedelta_to_milliseconds(td):
402
"Convert a datetime.timedelta() to milliseconds"
403
return ((td.days * 24 * 60 * 60 * 1000)
404
+ (td.seconds * 1000)
405
+ (td.microseconds // 1000))
406
707
407
708
408
class Client(object):
709
409
"""A representation of a client host served by this server.
736
436
last_checker_status: integer between 0 and 255 reflecting exit
737
437
status of last checker. -1 reflects crashed
738
438
checker, -2 means no checker completed yet.
739
last_checker_signal: The signal which killed the last checker, if
740
last_checker_status is -1
741
439
last_enabled: datetime.datetime(); (UTC) or None
742
440
name: string; from the config file, used in log messages and
743
441
D-Bus identifiers
756
454
"fingerprint", "host", "interval",
757
455
"last_approval_request", "last_checked_ok",
758
456
"last_enabled", "name", "timeout")
759
client_defaults = {
760
"timeout": "PT5M",
761
"extended_timeout": "PT15M",
762
"interval": "PT2M",
763
"checker": "fping -q -- %%(host)s",
764
"host": "",
765
"approval_delay": "PT0S",
766
"approval_duration": "PT1S",
767
"approved_by_default": "True",
768
"enabled": "True",
769
}
457
client_defaults = { "timeout": "PT5M",
458
"extended_timeout": "PT15M",
459
"interval": "PT2M",
460
"checker": "fping -q -- %%(host)s",
461
"host": "",
462
"approval_delay": "PT0S",
463
"approval_duration": "PT1S",
464
"approved_by_default": "True",
465
"enabled": "True",
466
}
467
468
def timeout_milliseconds(self):
469
"Return the 'timeout' attribute in milliseconds"
470
return timedelta_to_milliseconds(self.timeout)
471
472
def extended_timeout_milliseconds(self):
473
"Return the 'extended_timeout' attribute in milliseconds"
474
return timedelta_to_milliseconds(self.extended_timeout)
475
476
def interval_milliseconds(self):
477
"Return the 'interval' attribute in milliseconds"
478
return timedelta_to_milliseconds(self.interval)
479
480
def approval_delay_milliseconds(self):
481
return timedelta_to_milliseconds(self.approval_delay)
770
482
771
483
@staticmethod
772
484
def config_parser(config):
788
500
client["enabled"] = config.getboolean(client_name,
789
501
"enabled")
790
502
791
# Uppercase and remove spaces from fingerprint for later
792
# comparison purposes with return value from the
793
# fingerprint() function
794
503
client["fingerprint"] = (section["fingerprint"].upper()
795
504
.replace(" ", ""))
796
505
if "secret" in section:
801
510
"rb") as secfile:
802
511
client["secret"] = secfile.read()
803
512
else:
804
raise TypeError("No secret or secfile for section {}"
513
raise TypeError("No secret or secfile for section {0}"
805
514
.format(section))
806
515
client["timeout"] = string_to_delta(section["timeout"])
807
516
client["extended_timeout"] = string_to_delta(
824
533
server_settings = {}
825
534
self.server_settings = server_settings
826
535
# adding all client settings
827
for setting, value in settings.items():
536
for setting, value in settings.iteritems():
828
537
setattr(self, setting, value)
829
538
830
539
if self.enabled:
838
547
self.expires = None
839
548
840
549
logger.debug("Creating client %r", self.name)
550
# Uppercase and remove spaces from fingerprint for later
551
# comparison purposes with return value from the fingerprint()
552
# function
841
553
logger.debug(" Fingerprint: %s", self.fingerprint)
842
554
self.created = settings.get("created",
843
555
datetime.datetime.utcnow())
850
562
self.current_checker_command = None
851
563
self.approved = None
852
564
self.approvals_pending = 0
853
self.changedstate = multiprocessing_manager.Condition(
854
multiprocessing_manager.Lock())
855
self.client_structure = [attr
856
for attr in self.__dict__.iterkeys()
565
self.changedstate = (multiprocessing_manager
566
.Condition(multiprocessing_manager
567
.Lock()))
568
self.client_structure = [attr for attr in
569
self.__dict__.iterkeys()
857
570
if not attr.startswith("_")]
858
571
self.client_structure.append("client_structure")
859
572
860
for name, t in inspect.getmembers(
861
type(self), lambda obj: isinstance(obj, property)):
573
for name, t in inspect.getmembers(type(self),
574
lambda obj:
575
isinstance(obj,
576
property)):
862
577
if not name.startswith("_"):
863
578
self.client_structure.append(name)
864
579
906
621
# and every interval from then on.
907
622
if self.checker_initiator_tag is not None:
908
623
gobject.source_remove(self.checker_initiator_tag)
909
self.checker_initiator_tag = gobject.timeout_add(
910
int(self.interval.total_seconds() * 1000),
911
self.start_checker)
624
self.checker_initiator_tag = (gobject.timeout_add
625
(self.interval_milliseconds(),
626
self.start_checker))
912
627
# Schedule a disable() when 'timeout' has passed
913
628
if self.disable_initiator_tag is not None:
914
629
gobject.source_remove(self.disable_initiator_tag)
915
self.disable_initiator_tag = gobject.timeout_add(
916
int(self.timeout.total_seconds() * 1000), self.disable)
630
self.disable_initiator_tag = (gobject.timeout_add
631
(self.timeout_milliseconds(),
632
self.disable))
917
633
# Also start a new checker *right now*.
918
634
self.start_checker()
919
635
920
def checker_callback(self, source, condition, connection,
921
command):
636
def checker_callback(self, pid, condition, command):
922
637
"""The checker has completed, so take appropriate actions."""
923
638
self.checker_callback_tag = None
924
639
self.checker = None
925
# Read return code from connection (see call_pipe)
926
returncode = connection.recv()
927
connection.close()
928
929
if returncode >= 0:
930
self.last_checker_status = returncode
931
self.last_checker_signal = None
640
if os.WIFEXITED(condition):
641
self.last_checker_status = os.WEXITSTATUS(condition)
932
642
if self.last_checker_status == 0:
933
643
logger.info("Checker for %(name)s succeeded",
934
644
vars(self))
935
645
self.checked_ok()
936
646
else:
937
logger.info("Checker for %(name)s failed", vars(self))
647
logger.info("Checker for %(name)s failed",
648
vars(self))
938
649
else:
939
650
self.last_checker_status = -1
940
self.last_checker_signal = -returncode
941
651
logger.warning("Checker for %(name)s crashed?",
942
652
vars(self))
943
return False
944
653
945
654
def checked_ok(self):
946
655
"""Assert that the client has been seen, alive and well."""
947
656
self.last_checked_ok = datetime.datetime.utcnow()
948
657
self.last_checker_status = 0
949
self.last_checker_signal = None
950
658
self.bump_timeout()
951
659
952
660
def bump_timeout(self, timeout=None):
957
665
gobject.source_remove(self.disable_initiator_tag)
958
666
self.disable_initiator_tag = None
959
667
if getattr(self, "enabled", False):
960
self.disable_initiator_tag = gobject.timeout_add(
961
int(timeout.total_seconds() * 1000), self.disable)
668
self.disable_initiator_tag = (gobject.timeout_add
669
(timedelta_to_milliseconds
670
(timeout), self.disable))
962
671
self.expires = datetime.datetime.utcnow() + timeout
963
672
964
673
def need_approval(self):
978
687
# than 'timeout' for the client to be disabled, which is as it
979
688
# should be.
980
689
981
if self.checker is not None and not self.checker.is_alive():
982
logger.warning("Checker was not alive; joining")
983
self.checker.join()
984
self.checker = None
690
# If a checker exists, make sure it is not a zombie
691
try:
692
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
693
except (AttributeError, OSError) as error:
694
if (isinstance(error, OSError)
695
and error.errno != errno.ECHILD):
696
raise error
697
else:
698
if pid:
699
logger.warning("Checker was a zombie")
700
gobject.source_remove(self.checker_callback_tag)
701
self.checker_callback(pid, status,
702
self.current_checker_command)
985
703
# Start a new checker if needed
986
704
if self.checker is None:
987
705
# Escape attributes for the shell
988
escaped_attrs = {
989
attr: re.escape(str(getattr(self, attr)))
990
for attr in self.runtime_expansions }
706
escaped_attrs = dict(
707
(attr, re.escape(unicode(getattr(self, attr))))
708
for attr in
709
self.runtime_expansions)
991
710
try:
992
711
command = self.checker_command % escaped_attrs
993
712
except TypeError as error:
994
713
logger.error('Could not format string "%s"',
995
self.checker_command,
714
self.checker_command, exc_info=error)
715
return True # Try again later
716
self.current_checker_command = command
717
try:
718
logger.info("Starting checker %r for %s",
719
command, self.name)
720
# We don't need to redirect stdout and stderr, since
721
# in normal mode, that is already done by daemon(),
722
# and in debug mode we don't want to. (Stdin is
723
# always replaced by /dev/null.)
724
# The exception is when not debugging but nevertheless
725
# running in the foreground; use the previously
726
# created wnull.
727
popen_args = {}
728
if (not self.server_settings["debug"]
729
and self.server_settings["foreground"]):
730
popen_args.update({"stdout": wnull,
731
"stderr": wnull })
732
self.checker = subprocess.Popen(command,
733
close_fds=True,
734
shell=True, cwd="/",
735
**popen_args)
736
except OSError as error:
737
logger.error("Failed to start subprocess",
996
738
exc_info=error)
997
return True # Try again later
998
self.current_checker_command = command
999
logger.info("Starting checker %r for %s", command,
1000
self.name)
1001
# We don't need to redirect stdout and stderr, since
1002
# in normal mode, that is already done by daemon(),
1003
# and in debug mode we don't want to. (Stdin is
1004
# always replaced by /dev/null.)
1005
# The exception is when not debugging but nevertheless
1006
# running in the foreground; use the previously
1007
# created wnull.
1008
popen_args = { "close_fds": True,
1009
"shell": True,
1010
"cwd": "/" }
1011
if (not self.server_settings["debug"]
1012
and self.server_settings["foreground"]):
1013
popen_args.update({"stdout": wnull,
1014
"stderr": wnull })
1015
pipe = multiprocessing.Pipe(duplex = False)
1016
self.checker = multiprocessing.Process(
1017
target = call_pipe,
1018
args = (pipe[1], subprocess.call, command),
1019
kwargs = popen_args)
1020
self.checker.start()
1021
self.checker_callback_tag = gobject.io_add_watch(
1022
pipe[0].fileno(), gobject.IO_IN,
1023
self.checker_callback, pipe[0], command)
739
return True
740
self.checker_callback_tag = (gobject.child_watch_add
741
(self.checker.pid,
742
self.checker_callback,
743
data=command))
744
# The checker may have completed before the gobject
745
# watch was added. Check for this.
746
try:
747
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
748
except OSError as error:
749
if error.errno == errno.ECHILD:
750
# This should never happen
751
logger.error("Child process vanished",
752
exc_info=error)
753
return True
754
raise
755
if pid:
756
gobject.source_remove(self.checker_callback_tag)
757
self.checker_callback(pid, status, command)
1024
758
# Re-run this periodically if run by gobject.timeout_add
1025
759
return True
1026
760
1032
766
if getattr(self, "checker", None) is None:
1033
767
return
1034
768
logger.debug("Stopping checker for %(name)s", vars(self))
1035
self.checker.terminate()
769
try:
770
self.checker.terminate()
771
#time.sleep(0.5)
772
#if self.checker.poll() is None:
773
# self.checker.kill()
774
except OSError as error:
775
if error.errno != errno.ESRCH: # No such process
776
raise
1036
777
self.checker = None
1037
778
1038
779
1039
def dbus_service_property(dbus_interface,
1040
signature="v",
1041
access="readwrite",
1042
byte_arrays=False):
780
def dbus_service_property(dbus_interface, signature="v",
781
access="readwrite", byte_arrays=False):
1043
782
"""Decorators for marking methods of a DBusObjectWithProperties to
1044
783
become properties on the D-Bus.
1045
784
1054
793
# "Set" method, so we fail early here:
1055
794
if byte_arrays and signature != "ay":
1056
795
raise ValueError("Byte arrays not supported for non-'ay'"
1057
" signature {!r}".format(signature))
1058
796
" signature {0!r}".format(signature))
1059
797
def decorator(func):
1060
798
func._dbus_is_property = True
1061
799
func._dbus_interface = dbus_interface
1066
804
func._dbus_name = func._dbus_name[:-14]
1067
805
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
1068
806
return func
1069
1070
807
return decorator
1071
808
1072
809
1081
818
"org.freedesktop.DBus.Property.EmitsChangedSignal":
1082
819
"false"}
1083
820
"""
1084
1085
821
def decorator(func):
1086
822
func._dbus_is_interface = True
1087
823
func._dbus_interface = dbus_interface
1088
824
func._dbus_name = dbus_interface
1089
825
return func
1090
1091
826
return decorator
1092
827
1093
828
1095
830
"""Decorator to annotate D-Bus methods, signals or properties
1096
831
Usage:
1097
832
1098
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
1099
"org.freedesktop.DBus.Property."
1100
"EmitsChangedSignal": "false"})
1101
833
@dbus_service_property("org.example.Interface", signature="b",
1102
834
access="r")
835
@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
836
"org.freedesktop.DBus.Property."
837
"EmitsChangedSignal": "false"})
1103
838
def Property_dbus_property(self):
1104
839
return dbus.Boolean(False)
1105
1106
See also the DBusObjectWithAnnotations class.
1107
840
"""
1108
1109
841
def decorator(func):
1110
842
func._dbus_annotations = annotations
1111
843
return func
1112
1113
844
return decorator
1114
845
1115
846
1116
847
class DBusPropertyException(dbus.exceptions.DBusException):
1117
848
"""A base class for D-Bus property-related exceptions
1118
849
"""
1119
pass
850
def __unicode__(self):
851
return unicode(str(self))
1120
852
1121
853
1122
854
class DBusPropertyAccessException(DBusPropertyException):
1131
863
pass
1132
864
1133
865
1134
class DBusObjectWithAnnotations(dbus.service.Object):
1135
"""A D-Bus object with annotations.
866
class DBusObjectWithProperties(dbus.service.Object):
867
"""A D-Bus object with properties.
1136
868
1137
Classes inheriting from this can use the dbus_annotations
1138
decorator to add annotations to methods or signals.
869
Classes inheriting from this can use the dbus_service_property
870
decorator to expose methods as D-Bus properties. It exposes the
871
standard Get(), Set(), and GetAll() methods on the D-Bus.
1139
872
"""
1140
873
1141
874
@staticmethod
1145
878
If called like _is_dbus_thing("method") it returns a function
1146
879
suitable for use as predicate to inspect.getmembers().
1147
880
"""
1148
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
881
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
1149
882
False)
1150
883
1151
884
def _get_all_dbus_things(self, thing):
1152
885
"""Returns a generator of (name, attribute) pairs
1153
886
"""
1154
return ((getattr(athing.__get__(self), "_dbus_name", name),
887
return ((getattr(athing.__get__(self), "_dbus_name",
888
name),
1155
889
athing.__get__(self))
1156
890
for cls in self.__class__.__mro__
1157
891
for name, athing in
1158
inspect.getmembers(cls, self._is_dbus_thing(thing)))
1159
1160
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1161
out_signature = "s",
1162
path_keyword = 'object_path',
1163
connection_keyword = 'connection')
1164
def Introspect(self, object_path, connection):
1165
"""Overloading of standard D-Bus method.
1166
1167
Inserts annotation tags on methods and signals.
1168
"""
1169
xmlstring = dbus.service.Object.Introspect(self, object_path,
1170
connection)
1171
try:
1172
document = xml.dom.minidom.parseString(xmlstring)
1173
1174
for if_tag in document.getElementsByTagName("interface"):
1175
# Add annotation tags
1176
for typ in ("method", "signal"):
1177
for tag in if_tag.getElementsByTagName(typ):
1178
annots = dict()
1179
for name, prop in (self.
1180
_get_all_dbus_things(typ)):
1181
if (name == tag.getAttribute("name")
1182
and prop._dbus_interface
1183
== if_tag.getAttribute("name")):
1184
annots.update(getattr(
1185
prop, "_dbus_annotations", {}))
1186
for name, value in annots.items():
1187
ann_tag = document.createElement(
1188
"annotation")
1189
ann_tag.setAttribute("name", name)
1190
ann_tag.setAttribute("value", value)
1191
tag.appendChild(ann_tag)
1192
# Add interface annotation tags
1193
for annotation, value in dict(
1194
itertools.chain.from_iterable(
1195
annotations().items()
1196
for name, annotations
1197
in self._get_all_dbus_things("interface")
1198
if name == if_tag.getAttribute("name")
1199
)).items():
1200
ann_tag = document.createElement("annotation")
1201
ann_tag.setAttribute("name", annotation)
1202
ann_tag.setAttribute("value", value)
1203
if_tag.appendChild(ann_tag)
1204
# Fix argument name for the Introspect method itself
1205
if (if_tag.getAttribute("name")
1206
== dbus.INTROSPECTABLE_IFACE):
1207
for cn in if_tag.getElementsByTagName("method"):
1208
if cn.getAttribute("name") == "Introspect":
1209
for arg in cn.getElementsByTagName("arg"):
1210
if (arg.getAttribute("direction")
1211
== "out"):
1212
arg.setAttribute("name",
1213
"xml_data")
1214
xmlstring = document.toxml("utf-8")
1215
document.unlink()
1216
except (AttributeError, xml.dom.DOMException,
1217
xml.parsers.expat.ExpatError) as error:
1218
logger.error("Failed to override Introspection method",
1219
exc_info=error)
1220
return xmlstring
1221
1222
1223
class DBusObjectWithProperties(DBusObjectWithAnnotations):
1224
"""A D-Bus object with properties.
1225
1226
Classes inheriting from this can use the dbus_service_property
1227
decorator to expose methods as D-Bus properties. It exposes the
1228
standard Get(), Set(), and GetAll() methods on the D-Bus.
1229
"""
892
inspect.getmembers(cls,
893
self._is_dbus_thing(thing)))
1230
894
1231
895
def _get_dbus_property(self, interface_name, property_name):
1232
896
"""Returns a bound method if one exists which is a D-Bus
1233
897
property with the specified name and interface.
1234
898
"""
1235
for cls in self.__class__.__mro__:
1236
for name, value in inspect.getmembers(
1237
cls, self._is_dbus_thing("property")):
899
for cls in self.__class__.__mro__:
900
for name, value in (inspect.getmembers
901
(cls,
902
self._is_dbus_thing("property"))):
1238
903
if (value._dbus_name == property_name
1239
904
and value._dbus_interface == interface_name):
1240
905
return value.__get__(self)
1241
906
1242
907
# No such property
1243
raise DBusPropertyNotFound("{}:{}.{}".format(
1244
self.dbus_object_path, interface_name, property_name))
1245
1246
@classmethod
1247
def _get_all_interface_names(cls):
1248
"""Get a sequence of all interfaces supported by an object"""
1249
return (name for name in set(getattr(getattr(x, attr),
1250
"_dbus_interface", None)
1251
for x in (inspect.getmro(cls))
1252
for attr in dir(x))
1253
if name is not None)
1254
1255
@dbus.service.method(dbus.PROPERTIES_IFACE,
1256
in_signature="ss",
908
raise DBusPropertyNotFound(self.dbus_object_path + ":"
909
+ interface_name + "."
910
+ property_name)
911
912
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
1257
913
out_signature="v")
1258
914
def Get(self, interface_name, property_name):
1259
915
"""Standard D-Bus property Get() method, see D-Bus standard.
1277
933
# The byte_arrays option is not supported yet on
1278
934
# signatures other than "ay".
1279
935
if prop._dbus_signature != "ay":
1280
raise ValueError("Byte arrays not supported for non-"
1281
"'ay' signature {!r}"
1282
.format(prop._dbus_signature))
936
raise ValueError
1283
937
value = dbus.ByteArray(b''.join(chr(byte)
1284
938
for byte in value))
1285
939
prop(value)
1286
940
1287
@dbus.service.method(dbus.PROPERTIES_IFACE,
1288
in_signature="s",
941
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
1289
942
out_signature="a{sv}")
1290
943
def GetAll(self, interface_name):
1291
944
"""Standard D-Bus property GetAll() method, see D-Bus
1306
959
if not hasattr(value, "variant_level"):
1307
960
properties[name] = value
1308
961
continue
1309
properties[name] = type(value)(
1310
value, variant_level = value.variant_level + 1)
962
properties[name] = type(value)(value, variant_level=
963
value.variant_level+1)
1311
964
return dbus.Dictionary(properties, signature="sv")
1312
965
1313
@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
1314
def PropertiesChanged(self, interface_name, changed_properties,
1315
invalidated_properties):
1316
"""Standard D-Bus PropertiesChanged() signal, see D-Bus
1317
standard.
1318
"""
1319
pass
1320
1321
966
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1322
967
out_signature="s",
1323
968
path_keyword='object_path',
1327
972
1328
973
Inserts property tags and interface annotation tags.
1329
974
"""
1330
xmlstring = DBusObjectWithAnnotations.Introspect(self,
1331
object_path,
1332
connection)
975
xmlstring = dbus.service.Object.Introspect(self, object_path,
976
connection)
1333
977
try:
1334
978
document = xml.dom.minidom.parseString(xmlstring)
1335
1336
979
def make_tag(document, name, prop):
1337
980
e = document.createElement("property")
1338
981
e.setAttribute("name", name)
1339
982
e.setAttribute("type", prop._dbus_signature)
1340
983
e.setAttribute("access", prop._dbus_access)
1341
984
return e
1342
1343
985
for if_tag in document.getElementsByTagName("interface"):
1344
986
# Add property tags
1345
987
for tag in (make_tag(document, name, prop)
1348
990
if prop._dbus_interface
1349
991
== if_tag.getAttribute("name")):
1350
992
if_tag.appendChild(tag)
1351
# Add annotation tags for properties
1352
for tag in if_tag.getElementsByTagName("property"):
1353
annots = dict()
1354
for name, prop in self._get_all_dbus_things(
1355
"property"):
1356
if (name == tag.getAttribute("name")
1357
and prop._dbus_interface
1358
== if_tag.getAttribute("name")):
1359
annots.update(getattr(
1360
prop, "_dbus_annotations", {}))
1361
for name, value in annots.items():
1362
ann_tag = document.createElement(
1363
"annotation")
1364
ann_tag.setAttribute("name", name)
1365
ann_tag.setAttribute("value", value)
1366
tag.appendChild(ann_tag)
993
# Add annotation tags
994
for typ in ("method", "signal", "property"):
995
for tag in if_tag.getElementsByTagName(typ):
996
annots = dict()
997
for name, prop in (self.
998
_get_all_dbus_things(typ)):
999
if (name == tag.getAttribute("name")
1000
and prop._dbus_interface
1001
== if_tag.getAttribute("name")):
1002
annots.update(getattr
1003
(prop,
1004
"_dbus_annotations",
1005
{}))
1006
for name, value in annots.iteritems():
1007
ann_tag = document.createElement(
1008
"annotation")
1009
ann_tag.setAttribute("name", name)
1010
ann_tag.setAttribute("value", value)
1011
tag.appendChild(ann_tag)
1012
# Add interface annotation tags
1013
for annotation, value in dict(
1014
itertools.chain.from_iterable(
1015
annotations().iteritems()
1016
for name, annotations in
1017
self._get_all_dbus_things("interface")
1018
if name == if_tag.getAttribute("name")
1019
)).iteritems():
1020
ann_tag = document.createElement("annotation")
1021
ann_tag.setAttribute("name", annotation)
1022
ann_tag.setAttribute("value", value)
1023
if_tag.appendChild(ann_tag)
1367
1024
# Add the names to the return values for the
1368
1025
# "org.freedesktop.DBus.Properties" methods
1369
1026
if (if_tag.getAttribute("name")
1387
1044
exc_info=error)
1388
1045
return xmlstring
1389
1046
1390
try:
1391
dbus.OBJECT_MANAGER_IFACE
1392
except AttributeError:
1393
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
1394
1395
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
1396
"""A D-Bus object with an ObjectManager.
1397
1398
Classes inheriting from this exposes the standard
1399
GetManagedObjects call and the InterfacesAdded and
1400
InterfacesRemoved signals on the standard
1401
"org.freedesktop.DBus.ObjectManager" interface.
1402
1403
Note: No signals are sent automatically; they must be sent
1404
manually.
1405
"""
1406
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
1407
out_signature = "a{oa{sa{sv}}}")
1408
def GetManagedObjects(self):
1409
"""This function must be overridden"""
1410
raise NotImplementedError()
1411
1412
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
1413
signature = "oa{sa{sv}}")
1414
def InterfacesAdded(self, object_path, interfaces_and_properties):
1415
pass
1416
1417
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature = "oas")
1418
def InterfacesRemoved(self, object_path, interfaces):
1419
pass
1420
1421
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1422
out_signature = "s",
1423
path_keyword = 'object_path',
1424
connection_keyword = 'connection')
1425
def Introspect(self, object_path, connection):
1426
"""Overloading of standard D-Bus method.
1427
1428
Override return argument name of GetManagedObjects to be
1429
"objpath_interfaces_and_properties"
1430
"""
1431
xmlstring = DBusObjectWithAnnotations.Introspect(self,
1432
object_path,
1433
connection)
1434
try:
1435
document = xml.dom.minidom.parseString(xmlstring)
1436
1437
for if_tag in document.getElementsByTagName("interface"):
1438
# Fix argument name for the GetManagedObjects method
1439
if (if_tag.getAttribute("name")
1440
== dbus.OBJECT_MANAGER_IFACE):
1441
for cn in if_tag.getElementsByTagName("method"):
1442
if (cn.getAttribute("name")
1443
== "GetManagedObjects"):
1444
for arg in cn.getElementsByTagName("arg"):
1445
if (arg.getAttribute("direction")
1446
== "out"):
1447
arg.setAttribute(
1448
"name",
1449
"objpath_interfaces"
1450
"_and_properties")
1451
xmlstring = document.toxml("utf-8")
1452
document.unlink()
1453
except (AttributeError, xml.dom.DOMException,
1454
xml.parsers.expat.ExpatError) as error:
1455
logger.error("Failed to override Introspection method",
1456
exc_info = error)
1457
return xmlstring
1458
1047
1459
1048
def datetime_to_dbus(dt, variant_level=0):
1460
1049
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1461
1050
if dt is None:
1462
1051
return dbus.String("", variant_level = variant_level)
1463
return dbus.String(dt.isoformat(), variant_level=variant_level)
1052
return dbus.String(dt.isoformat(),
1053
variant_level=variant_level)
1464
1054
1465
1055
1466
1056
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1486
1076
(from DBusObjectWithProperties) and interfaces (from the
1487
1077
dbus_interface_annotations decorator).
1488
1078
"""
1489
1490
1079
def wrapper(cls):
1491
1080
for orig_interface_name, alt_interface_name in (
1492
alt_interface_names.items()):
1081
alt_interface_names.iteritems()):
1493
1082
attr = {}
1494
1083
interface_names = set()
1495
1084
# Go though all attributes of the class
1497
1086
# Ignore non-D-Bus attributes, and D-Bus attributes
1498
1087
# with the wrong interface name
1499
1088
if (not hasattr(attribute, "_dbus_interface")
1500
or not attribute._dbus_interface.startswith(
1501
orig_interface_name)):
1089
or not attribute._dbus_interface
1090
.startswith(orig_interface_name)):
1502
1091
continue
1503
1092
# Create an alternate D-Bus interface name based on
1504
1093
# the current name
1505
alt_interface = attribute._dbus_interface.replace(
1506
orig_interface_name, alt_interface_name)
1094
alt_interface = (attribute._dbus_interface
1095
.replace(orig_interface_name,
1096
alt_interface_name))
1507
1097
interface_names.add(alt_interface)
1508
1098
# Is this a D-Bus signal?
1509
1099
if getattr(attribute, "_dbus_is_signal", False):
1510
if sys.version_info.major == 2:
1511
# Extract the original non-method undecorated
1512
# function by black magic
1513
nonmethod_func = (dict(
1100
# Extract the original non-method undecorated
1101
# function by black magic
1102
nonmethod_func = (dict(
1514
1103
zip(attribute.func_code.co_freevars,
1515
attribute.__closure__))
1516
["func"].cell_contents)
1517
else:
1518
nonmethod_func = attribute
1104
attribute.__closure__))["func"]
1105
.cell_contents)
1519
1106
# Create a new, but exactly alike, function
1520
1107
# object, and decorate it to be a new D-Bus signal
1521
1108
# with the alternate D-Bus interface name
1522
if sys.version_info.major == 2:
1523
new_function = types.FunctionType(
1524
nonmethod_func.func_code,
1525
nonmethod_func.func_globals,
1526
nonmethod_func.func_name,
1527
nonmethod_func.func_defaults,
1528
nonmethod_func.func_closure)
1529
else:
1530
new_function = types.FunctionType(
1531
nonmethod_func.__code__,
1532
nonmethod_func.__globals__,
1533
nonmethod_func.__name__,
1534
nonmethod_func.__defaults__,
1535
nonmethod_func.__closure__)
1536
new_function = (dbus.service.signal(
1537
alt_interface,
1538
attribute._dbus_signature)(new_function))
1109
new_function = (dbus.service.signal
1110
(alt_interface,
1111
attribute._dbus_signature)
1112
(types.FunctionType(
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)))
1539
1118
# Copy annotations, if any
1540
1119
try:
1541
new_function._dbus_annotations = dict(
1542
attribute._dbus_annotations)
1120
new_function._dbus_annotations = (
1121
dict(attribute._dbus_annotations))
1543
1122
except AttributeError:
1544
1123
pass
1545
1124
# Define a creator of a function to call both the
1550
1129
"""This function is a scope container to pass
1551
1130
func1 and func2 to the "call_both" function
1552
1131
outside of its arguments"""
1553
1554
@functools.wraps(func2)
1555
1132
def call_both(*args, **kwargs):
1556
1133
"""This function will emit two D-Bus
1557
1134
signals by calling func1 and func2"""
1558
1135
func1(*args, **kwargs)
1559
1136
func2(*args, **kwargs)
1560
# Make wrapper function look like a D-Bus signal
1561
for name, attr in inspect.getmembers(func2):
1562
if name.startswith("_dbus_"):
1563
setattr(call_both, name, attr)
1564
1565
1137
return call_both
1566
1138
# Create the "call_both" function and add it to
1567
1139
# the class
1572
1144
# object. Decorate it to be a new D-Bus method
1573
1145
# with the alternate D-Bus interface name. Add it
1574
1146
# to the class.
1575
attr[attrname] = (
1576
dbus.service.method(
1577
alt_interface,
1578
attribute._dbus_in_signature,
1579
attribute._dbus_out_signature)
1580
(types.FunctionType(attribute.func_code,
1581
attribute.func_globals,
1582
attribute.func_name,
1583
attribute.func_defaults,
1584
attribute.func_closure)))
1147
attr[attrname] = (dbus.service.method
1148
(alt_interface,
1149
attribute._dbus_in_signature,
1150
attribute._dbus_out_signature)
1151
(types.FunctionType
1152
(attribute.func_code,
1153
attribute.func_globals,
1154
attribute.func_name,
1155
attribute.func_defaults,
1156
attribute.func_closure)))
1585
1157
# Copy annotations, if any
1586
1158
try:
1587
attr[attrname]._dbus_annotations = dict(
1588
attribute._dbus_annotations)
1159
attr[attrname]._dbus_annotations = (
1160
dict(attribute._dbus_annotations))
1589
1161
except AttributeError:
1590
1162
pass
1591
1163
# Is this a D-Bus property?
1594
1166
# object, and decorate it to be a new D-Bus
1595
1167
# property with the alternate D-Bus interface
1596
1168
# name. Add it to the class.
1597
attr[attrname] = (dbus_service_property(
1598
alt_interface, attribute._dbus_signature,
1599
attribute._dbus_access,
1600
attribute._dbus_get_args_options
1601
["byte_arrays"])
1602
(types.FunctionType(
1603
attribute.func_code,
1604
attribute.func_globals,
1605
attribute.func_name,
1606
attribute.func_defaults,
1607
attribute.func_closure)))
1169
attr[attrname] = (dbus_service_property
1170
(alt_interface,
1171
attribute._dbus_signature,
1172
attribute._dbus_access,
1173
attribute
1174
._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)))
1608
1182
# Copy annotations, if any
1609
1183
try:
1610
attr[attrname]._dbus_annotations = dict(
1611
attribute._dbus_annotations)
1184
attr[attrname]._dbus_annotations = (
1185
dict(attribute._dbus_annotations))
1612
1186
except AttributeError:
1613
1187
pass
1614
1188
# Is this a D-Bus interface?
1617
1191
# object. Decorate it to be a new D-Bus interface
1618
1192
# with the alternate D-Bus interface name. Add it
1619
1193
# to the class.
1620
attr[attrname] = (
1621
dbus_interface_annotations(alt_interface)
1622
(types.FunctionType(attribute.func_code,
1623
attribute.func_globals,
1624
attribute.func_name,
1625
attribute.func_defaults,
1626
attribute.func_closure)))
1194
attr[attrname] = (dbus_interface_annotations
1195
(alt_interface)
1196
(types.FunctionType
1197
(attribute.func_code,
1198
attribute.func_globals,
1199
attribute.func_name,
1200
attribute.func_defaults,
1201
attribute.func_closure)))
1627
1202
if deprecate:
1628
1203
# Deprecate all alternate interfaces
1629
iname="_AlternateDBusNames_interface_annotation{}"
1204
iname="_AlternateDBusNames_interface_annotation{0}"
1630
1205
for interface_name in interface_names:
1631
1632
1206
@dbus_interface_annotations(interface_name)
1633
1207
def func(self):
1634
1208
return { "org.freedesktop.DBus.Deprecated":
1635
"true" }
1209
"true" }
1636
1210
# Find an unused name
1637
1211
for aname in (iname.format(i)
1638
1212
for i in itertools.count()):
1642
1216
if interface_names:
1643
1217
# Replace the class with a new subclass of it with
1644
1218
# methods, signals, etc. as created above.
1645
cls = type(b"{}Alternate".format(cls.__name__),
1646
(cls, ), attr)
1219
cls = type(b"{0}Alternate".format(cls.__name__),
1220
(cls,), attr)
1647
1221
return cls
1648
1649
1222
return wrapper
1650
1223
1651
1224
1652
1225
@alternate_dbus_interfaces({"se.recompile.Mandos":
1653
"se.bsnet.fukt.Mandos"})
1226
"se.bsnet.fukt.Mandos"})
1654
1227
class ClientDBus(Client, DBusObjectWithProperties):
1655
1228
"""A Client class using D-Bus
1656
1229
1660
1233
"""
1661
1234
1662
1235
runtime_expansions = (Client.runtime_expansions
1663
+ ("dbus_object_path", ))
1664
1665
_interface = "se.recompile.Mandos.Client"
1236
+ ("dbus_object_path",))
1666
1237
1667
1238
# dbus.service.Object doesn't use super(), so we can't either.
1668
1239
1671
1242
Client.__init__(self, *args, **kwargs)
1672
1243
# Only now, when this client is initialized, can it show up on
1673
1244
# the D-Bus
1674
client_object_name = str(self.name).translate(
1245
client_object_name = unicode(self.name).translate(
1675
1246
{ord("."): ord("_"),
1676
1247
ord("-"): ord("_")})
1677
self.dbus_object_path = dbus.ObjectPath(
1678
"/clients/" + client_object_name)
1248
self.dbus_object_path = (dbus.ObjectPath
1249
("/clients/" + client_object_name))
1679
1250
DBusObjectWithProperties.__init__(self, self.bus,
1680
1251
self.dbus_object_path)
1681
1252
1682
def notifychangeproperty(transform_func, dbus_name,
1683
type_func=lambda x: x,
1684
variant_level=1,
1685
invalidate_only=False,
1686
_interface=_interface):
1253
def notifychangeproperty(transform_func,
1254
dbus_name, type_func=lambda x: x,
1255
variant_level=1):
1687
1256
""" Modify a variable so that it's a property which announces
1688
1257
its changes to DBus.
1689
1258
1694
1263
to the D-Bus. Default: no transform
1695
1264
variant_level: D-Bus variant level. Default: 1
1696
1265
"""
1697
attrname = "_{}".format(dbus_name)
1698
1266
attrname = "_{0}".format(dbus_name)
1699
1267
def setter(self, value):
1700
1268
if hasattr(self, "dbus_object_path"):
1701
1269
if (not hasattr(self, attrname) or
1702
1270
type_func(getattr(self, attrname, None))
1703
1271
!= type_func(value)):
1704
if invalidate_only:
1705
self.PropertiesChanged(
1706
_interface, dbus.Dictionary(),
1707
dbus.Array((dbus_name, )))
1708
else:
1709
dbus_value = transform_func(
1710
type_func(value),
1711
variant_level = variant_level)
1712
self.PropertyChanged(dbus.String(dbus_name),
1713
dbus_value)
1714
self.PropertiesChanged(
1715
_interface,
1716
dbus.Dictionary({ dbus.String(dbus_name):
1717
dbus_value }),
1718
dbus.Array())
1272
dbus_value = transform_func(type_func(value),
1273
variant_level
1274
=variant_level)
1275
self.PropertyChanged(dbus.String(dbus_name),
1276
dbus_value)
1719
1277
setattr(self, attrname, value)
1720
1278
1721
1279
return property(lambda self: getattr(self, attrname), setter)
1727
1285
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1728
1286
last_enabled = notifychangeproperty(datetime_to_dbus,
1729
1287
"LastEnabled")
1730
checker = notifychangeproperty(
1731
dbus.Boolean, "CheckerRunning",
1732
type_func = lambda checker: checker is not None)
1288
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
1289
type_func = lambda checker:
1290
checker is not None)
1733
1291
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1734
1292
"LastCheckedOK")
1735
1293
last_checker_status = notifychangeproperty(dbus.Int16,
1738
1296
datetime_to_dbus, "LastApprovalRequest")
1739
1297
approved_by_default = notifychangeproperty(dbus.Boolean,
1740
1298
"ApprovedByDefault")
1741
approval_delay = notifychangeproperty(
1742
dbus.UInt64, "ApprovalDelay",
1743
type_func = lambda td: td.total_seconds() * 1000)
1299
approval_delay = notifychangeproperty(dbus.UInt64,
1300
"ApprovalDelay",
1301
type_func =
1302
timedelta_to_milliseconds)
1744
1303
approval_duration = notifychangeproperty(
1745
1304
dbus.UInt64, "ApprovalDuration",
1746
type_func = lambda td: td.total_seconds() * 1000)
1305
type_func = timedelta_to_milliseconds)
1747
1306
host = notifychangeproperty(dbus.String, "Host")
1748
timeout = notifychangeproperty(
1749
dbus.UInt64, "Timeout",
1750
type_func = lambda td: td.total_seconds() * 1000)
1307
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1308
type_func =
1309
timedelta_to_milliseconds)
1751
1310
extended_timeout = notifychangeproperty(
1752
1311
dbus.UInt64, "ExtendedTimeout",
1753
type_func = lambda td: td.total_seconds() * 1000)
1754
interval = notifychangeproperty(
1755
dbus.UInt64, "Interval",
1756
type_func = lambda td: td.total_seconds() * 1000)
1312
type_func = timedelta_to_milliseconds)
1313
interval = notifychangeproperty(dbus.UInt64,
1314
"Interval",
1315
type_func =
1316
timedelta_to_milliseconds)
1757
1317
checker_command = notifychangeproperty(dbus.String, "Checker")
1758
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1759
invalidate_only=True)
1760
1318
1761
1319
del notifychangeproperty
1762
1320
1769
1327
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1770
1328
Client.__del__(self, *args, **kwargs)
1771
1329
1772
def checker_callback(self, source, condition,
1773
connection, command, *args, **kwargs):
1774
ret = Client.checker_callback(self, source, condition,
1775
connection, command, *args,
1776
**kwargs)
1777
exitstatus = self.last_checker_status
1778
if exitstatus >= 0:
1330
def checker_callback(self, pid, condition, command,
1331
*args, **kwargs):
1332
self.checker_callback_tag = None
1333
self.checker = None
1334
if os.WIFEXITED(condition):
1335
exitstatus = os.WEXITSTATUS(condition)
1779
1336
# Emit D-Bus signal
1780
1337
self.CheckerCompleted(dbus.Int16(exitstatus),
1781
# This is specific to GNU libC
1782
dbus.Int64(exitstatus << 8),
1338
dbus.Int64(condition),
1783
1339
dbus.String(command))
1784
1340
else:
1785
1341
# Emit D-Bus signal
1786
1342
self.CheckerCompleted(dbus.Int16(-1),
1787
dbus.Int64(
1788
# This is specific to GNU libC
1789
(exitstatus << 8)
1790
| self.last_checker_signal),
1343
dbus.Int64(condition),
1791
1344
dbus.String(command))
1792
return ret
1345
1346
return Client.checker_callback(self, pid, condition, command,
1347
*args, **kwargs)
1793
1348
1794
1349
def start_checker(self, *args, **kwargs):
1795
old_checker_pid = getattr(self.checker, "pid", None)
1350
old_checker = self.checker
1351
if self.checker is not None:
1352
old_checker_pid = self.checker.pid
1353
else:
1354
old_checker_pid = None
1796
1355
r = Client.start_checker(self, *args, **kwargs)
1797
1356
# Only if new checker process was started
1798
1357
if (self.checker is not None
1807
1366
1808
1367
def approve(self, value=True):
1809
1368
self.approved = value
1810
gobject.timeout_add(int(self.approval_duration.total_seconds()
1811
* 1000), self._reset_approved)
1369
gobject.timeout_add(timedelta_to_milliseconds
1370
(self.approval_duration),
1371
self._reset_approved)
1812
1372
self.send_changedstate()
1813
1373
1814
1374
## D-Bus methods, signals & properties
1375
_interface = "se.recompile.Mandos.Client"
1815
1376
1816
1377
## Interfaces
1817
1378
1379
@dbus_interface_annotations(_interface)
1380
def _foo(self):
1381
return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
1382
"false"}
1383
1818
1384
## Signals
1819
1385
1820
1386
# CheckerCompleted - signal
1830
1396
pass
1831
1397
1832
1398
# PropertyChanged - signal
1833
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1834
1399
@dbus.service.signal(_interface, signature="sv")
1835
1400
def PropertyChanged(self, property, value):
1836
1401
"D-Bus signal"
1870
1435
self.checked_ok()
1871
1436
1872
1437
# Enable - method
1873
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1874
1438
@dbus.service.method(_interface)
1875
1439
def Enable(self):
1876
1440
"D-Bus method"
1877
1441
self.enable()
1878
1442
1879
1443
# StartChecker - method
1880
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1881
1444
@dbus.service.method(_interface)
1882
1445
def StartChecker(self):
1883
1446
"D-Bus method"
1884
1447
self.start_checker()
1885
1448
1886
1449
# Disable - method
1887
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1888
1450
@dbus.service.method(_interface)
1889
1451
def Disable(self):
1890
1452
"D-Bus method"
1891
1453
self.disable()
1892
1454
1893
1455
# StopChecker - method
1894
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1895
1456
@dbus.service.method(_interface)
1896
1457
def StopChecker(self):
1897
1458
self.stop_checker()
1904
1465
return dbus.Boolean(bool(self.approvals_pending))
1905
1466
1906
1467
# ApprovedByDefault - property
1907
@dbus_service_property(_interface,
1908
signature="b",
1468
@dbus_service_property(_interface, signature="b",
1909
1469
access="readwrite")
1910
1470
def ApprovedByDefault_dbus_property(self, value=None):
1911
1471
if value is None: # get
1913
1473
self.approved_by_default = bool(value)
1914
1474
1915
1475
# ApprovalDelay - property
1916
@dbus_service_property(_interface,
1917
signature="t",
1476
@dbus_service_property(_interface, signature="t",
1918
1477
access="readwrite")
1919
1478
def ApprovalDelay_dbus_property(self, value=None):
1920
1479
if value is None: # get
1921
return dbus.UInt64(self.approval_delay.total_seconds()
1922
* 1000)
1480
return dbus.UInt64(self.approval_delay_milliseconds())
1923
1481
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1924
1482
1925
1483
# ApprovalDuration - property
1926
@dbus_service_property(_interface,
1927
signature="t",
1484
@dbus_service_property(_interface, signature="t",
1928
1485
access="readwrite")
1929
1486
def ApprovalDuration_dbus_property(self, value=None):
1930
1487
if value is None: # get
1931
return dbus.UInt64(self.approval_duration.total_seconds()
1932
* 1000)
1488
return dbus.UInt64(timedelta_to_milliseconds(
1489
self.approval_duration))
1933
1490
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1934
1491
1935
1492
# Name - property
1936
@dbus_annotations(
1937
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1938
1493
@dbus_service_property(_interface, signature="s", access="read")
1939
1494
def Name_dbus_property(self):
1940
1495
return dbus.String(self.name)
1941
1496
1942
1497
# Fingerprint - property
1943
@dbus_annotations(
1944
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1945
1498
@dbus_service_property(_interface, signature="s", access="read")
1946
1499
def Fingerprint_dbus_property(self):
1947
1500
return dbus.String(self.fingerprint)
1948
1501
1949
1502
# Host - property
1950
@dbus_service_property(_interface,
1951
signature="s",
1503
@dbus_service_property(_interface, signature="s",
1952
1504
access="readwrite")
1953
1505
def Host_dbus_property(self, value=None):
1954
1506
if value is None: # get
1955
1507
return dbus.String(self.host)
1956
self.host = str(value)
1508
self.host = unicode(value)
1957
1509
1958
1510
# Created - property
1959
@dbus_annotations(
1960
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1961
1511
@dbus_service_property(_interface, signature="s", access="read")
1962
1512
def Created_dbus_property(self):
1963
1513
return datetime_to_dbus(self.created)
1968
1518
return datetime_to_dbus(self.last_enabled)
1969
1519
1970
1520
# Enabled - property
1971
@dbus_service_property(_interface,
1972
signature="b",
1521
@dbus_service_property(_interface, signature="b",
1973
1522
access="readwrite")
1974
1523
def Enabled_dbus_property(self, value=None):
1975
1524
if value is None: # get
1980
1529
self.disable()
1981
1530
1982
1531
# LastCheckedOK - property
1983
@dbus_service_property(_interface,
1984
signature="s",
1532
@dbus_service_property(_interface, signature="s",
1985
1533
access="readwrite")
1986
1534
def LastCheckedOK_dbus_property(self, value=None):
1987
1535
if value is not None:
1990
1538
return datetime_to_dbus(self.last_checked_ok)
1991
1539
1992
1540
# LastCheckerStatus - property
1993
@dbus_service_property(_interface, signature="n", access="read")
1541
@dbus_service_property(_interface, signature="n",
1542
access="read")
1994
1543
def LastCheckerStatus_dbus_property(self):
1995
1544
return dbus.Int16(self.last_checker_status)
1996
1545
2005
1554
return datetime_to_dbus(self.last_approval_request)
2006
1555
2007
1556
# Timeout - property
2008
@dbus_service_property(_interface,
2009
signature="t",
1557
@dbus_service_property(_interface, signature="t",
2010
1558
access="readwrite")
2011
1559
def Timeout_dbus_property(self, value=None):
2012
1560
if value is None: # get
2013
return dbus.UInt64(self.timeout.total_seconds() * 1000)
1561
return dbus.UInt64(self.timeout_milliseconds())
2014
1562
old_timeout = self.timeout
2015
1563
self.timeout = datetime.timedelta(0, 0, 0, value)
2016
1564
# Reschedule disabling
2025
1573
is None):
2026
1574
return
2027
1575
gobject.source_remove(self.disable_initiator_tag)
2028
self.disable_initiator_tag = gobject.timeout_add(
2029
int((self.expires - now).total_seconds() * 1000),
2030
self.disable)
1576
self.disable_initiator_tag = (
1577
gobject.timeout_add(
1578
timedelta_to_milliseconds(self.expires - now),
1579
self.disable))
2031
1580
2032
1581
# ExtendedTimeout - property
2033
@dbus_service_property(_interface,
2034
signature="t",
1582
@dbus_service_property(_interface, signature="t",
2035
1583
access="readwrite")
2036
1584
def ExtendedTimeout_dbus_property(self, value=None):
2037
1585
if value is None: # get
2038
return dbus.UInt64(self.extended_timeout.total_seconds()
2039
* 1000)
1586
return dbus.UInt64(self.extended_timeout_milliseconds())
2040
1587
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
2041
1588
2042
1589
# Interval - property
2043
@dbus_service_property(_interface,
2044
signature="t",
1590
@dbus_service_property(_interface, signature="t",
2045
1591
access="readwrite")
2046
1592
def Interval_dbus_property(self, value=None):
2047
1593
if value is None: # get
2048
return dbus.UInt64(self.interval.total_seconds() * 1000)
1594
return dbus.UInt64(self.interval_milliseconds())
2049
1595
self.interval = datetime.timedelta(0, 0, 0, value)
2050
1596
if getattr(self, "checker_initiator_tag", None) is None:
2051
1597
return
2052
1598
if self.enabled:
2053
1599
# Reschedule checker run
2054
1600
gobject.source_remove(self.checker_initiator_tag)
2055
self.checker_initiator_tag = gobject.timeout_add(
2056
value, self.start_checker)
2057
self.start_checker() # Start one now, too
1601
self.checker_initiator_tag = (gobject.timeout_add
1602
(value, self.start_checker))
1603
self.start_checker() # Start one now, too
2058
1604
2059
1605
# Checker - property
2060
@dbus_service_property(_interface,
2061
signature="s",
1606
@dbus_service_property(_interface, signature="s",
2062
1607
access="readwrite")
2063
1608
def Checker_dbus_property(self, value=None):
2064
1609
if value is None: # get
2065
1610
return dbus.String(self.checker_command)
2066
self.checker_command = str(value)
1611
self.checker_command = unicode(value)
2067
1612
2068
1613
# CheckerRunning - property
2069
@dbus_service_property(_interface,
2070
signature="b",
1614
@dbus_service_property(_interface, signature="b",
2071
1615
access="readwrite")
2072
1616
def CheckerRunning_dbus_property(self, value=None):
2073
1617
if value is None: # get
2078
1622
self.stop_checker()
2079
1623
2080
1624
# ObjectPath - property
2081
@dbus_annotations(
2082
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",
2083
"org.freedesktop.DBus.Deprecated": "true"})
2084
1625
@dbus_service_property(_interface, signature="o", access="read")
2085
1626
def ObjectPath_dbus_property(self):
2086
1627
return self.dbus_object_path # is already a dbus.ObjectPath
2087
1628
2088
1629
# Secret = property
2089
@dbus_annotations(
2090
{"org.freedesktop.DBus.Property.EmitsChangedSignal":
2091
"invalidates"})
2092
@dbus_service_property(_interface,
2093
signature="ay",
2094
access="write",
2095
byte_arrays=True)
1630
@dbus_service_property(_interface, signature="ay",
1631
access="write", byte_arrays=True)
2096
1632
def Secret_dbus_property(self, value):
2097
self.secret = bytes(value)
1633
self.secret = str(value)
2098
1634
2099
1635
del _interface
2100
1636
2104
1640
self._pipe = child_pipe
2105
1641
self._pipe.send(('init', fpr, address))
2106
1642
if not self._pipe.recv():
2107
raise KeyError(fpr)
1643
raise KeyError()
2108
1644
2109
1645
def __getattribute__(self, name):
2110
1646
if name == '_pipe':
2114
1650
if data[0] == 'data':
2115
1651
return data[1]
2116
1652
if data[0] == 'function':
2117
2118
1653
def func(*args, **kwargs):
2119
1654
self._pipe.send(('funcall', name, args, kwargs))
2120
1655
return self._pipe.recv()[1]
2121
2122
1656
return func
2123
1657
2124
1658
def __setattr__(self, name, value):
2136
1670
def handle(self):
2137
1671
with contextlib.closing(self.server.child_pipe) as child_pipe:
2138
1672
logger.info("TCP connection from: %s",
2139
str(self.client_address))
1673
unicode(self.client_address))
2140
1674
logger.debug("Pipe FD: %d",
2141
1675
self.server.child_pipe.fileno())
2142
1676
2143
session = gnutls.ClientSession(self.request)
1677
session = (gnutls.connection
1678
.ClientSession(self.request,
1679
gnutls.connection
1680
.X509Credentials()))
1681
1682
# Note: gnutls.connection.X509Credentials is really a
1683
# generic GnuTLS certificate credentials object so long as
1684
# no X.509 keys are added to it. Therefore, we can use it
1685
# here despite using OpenPGP certificates.
2144
1686
2145
1687
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
2146
1688
# "+AES-256-CBC", "+SHA1",
2150
1692
priority = self.server.gnutls_priority
2151
1693
if priority is None:
2152
1694
priority = "NORMAL"
2153
gnutls.priority_set_direct(session._c_object, priority,
2154
None)
1695
(gnutls.library.functions
1696
.gnutls_priority_set_direct(session._c_object,
1697
priority, None))
2155
1698
2156
1699
# Start communication using the Mandos protocol
2157
1700
# Get protocol number
2159
1702
logger.debug("Protocol version: %r", line)
2160
1703
try:
2161
1704
if int(line.strip().split()[0]) > 1:
2162
raise RuntimeError(line)
1705
raise RuntimeError
2163
1706
except (ValueError, IndexError, RuntimeError) as error:
2164
1707
logger.error("Unknown protocol version: %s", error)
2165
1708
return
2167
1710
# Start GnuTLS connection
2168
1711
try:
2169
1712
session.handshake()
2170
except gnutls.Error as error:
1713
except gnutls.errors.GNUTLSError as error:
2171
1714
logger.warning("Handshake failed: %s", error)
2172
1715
# Do not run session.bye() here: the session is not
2173
1716
# established. Just abandon the request.
2177
1720
approval_required = False
2178
1721
try:
2179
1722
try:
2180
fpr = self.fingerprint(
2181
self.peer_certificate(session))
2182
except (TypeError, gnutls.Error) as error:
1723
fpr = self.fingerprint(self.peer_certificate
1724
(session))
1725
except (TypeError,
1726
gnutls.errors.GNUTLSError) as error:
2183
1727
logger.warning("Bad certificate: %s", error)
2184
1728
return
2185
1729
logger.debug("Fingerprint: %s", fpr)
2198
1742
while True:
2199
1743
if not client.enabled:
2200
1744
logger.info("Client %s is disabled",
2201
client.name)
1745
client.name)
2202
1746
if self.server.use_dbus:
2203
1747
# Emit D-Bus signal
2204
1748
client.Rejected("Disabled")
2213
1757
if self.server.use_dbus:
2214
1758
# Emit D-Bus signal
2215
1759
client.NeedApproval(
2216
client.approval_delay.total_seconds()
2217
* 1000, client.approved_by_default)
1760
client.approval_delay_milliseconds(),
1761
client.approved_by_default)
2218
1762
else:
2219
1763
logger.warning("Client %s was not approved",
2220
1764
client.name)
2226
1770
#wait until timeout or approved
2227
1771
time = datetime.datetime.now()
2228
1772
client.changedstate.acquire()
2229
client.changedstate.wait(delay.total_seconds())
1773
client.changedstate.wait(
1774
float(timedelta_to_milliseconds(delay)
1775
/ 1000))
2230
1776
client.changedstate.release()
2231
1777
time2 = datetime.datetime.now()
2232
1778
if (time2 - time) >= delay:
2243
1789
else:
2244
1790
delay -= time2 - time
2245
1791
2246
try:
2247
session.send(client.secret)
2248
except gnutls.Error as error:
2249
logger.warning("gnutls send failed",
2250
exc_info = error)
2251
return
1792
sent_size = 0
1793
while sent_size < len(client.secret):
1794
try:
1795
sent = session.send(client.secret[sent_size:])
1796
except gnutls.errors.GNUTLSError as error:
1797
logger.warning("gnutls send failed",
1798
exc_info=error)
1799
return
1800
logger.debug("Sent: %d, remaining: %d",
1801
sent, len(client.secret)
1802
- (sent_size + sent))
1803
sent_size += sent
2252
1804
2253
1805
logger.info("Sending secret to %s", client.name)
2254
1806
# bump the timeout using extended_timeout
2262
1814
client.approvals_pending -= 1
2263
1815
try:
2264
1816
session.bye()
2265
except gnutls.Error as error:
1817
except gnutls.errors.GNUTLSError as error:
2266
1818
logger.warning("GnuTLS bye failed",
2267
1819
exc_info=error)
2268
1820
2270
1822
def peer_certificate(session):
2271
1823
"Return the peer's OpenPGP certificate as a bytestring"
2272
1824
# If not an OpenPGP certificate...
2273
if (gnutls.certificate_type_get(session._c_object)
2274
!= gnutls.CRT_OPENPGP):
2275
# ...return invalid data
2276
return b""
1825
if (gnutls.library.functions
1826
.gnutls_certificate_type_get(session._c_object)
1827
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1828
# ...do the normal thing
1829
return session.peer_certificate
2277
1830
list_size = ctypes.c_uint(1)
2278
cert_list = (gnutls.certificate_get_peers
1831
cert_list = (gnutls.library.functions
1832
.gnutls_certificate_get_peers
2279
1833
(session._c_object, ctypes.byref(list_size)))
2280
1834
if not bool(cert_list) and list_size.value != 0:
2281
raise gnutls.Error("error getting peer certificate")
1835
raise gnutls.errors.GNUTLSError("error getting peer"
1836
" certificate")
2282
1837
if list_size.value == 0:
2283
1838
return None
2284
1839
cert = cert_list[0]
2288
1843
def fingerprint(openpgp):
2289
1844
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
2290
1845
# New GnuTLS "datum" with the OpenPGP public key
2291
datum = gnutls.datum_t(
2292
ctypes.cast(ctypes.c_char_p(openpgp),
2293
ctypes.POINTER(ctypes.c_ubyte)),
2294
ctypes.c_uint(len(openpgp)))
1846
datum = (gnutls.library.types
1847
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1848
ctypes.POINTER
1849
(ctypes.c_ubyte)),
1850
ctypes.c_uint(len(openpgp))))
2295
1851
# New empty GnuTLS certificate
2296
crt = gnutls.openpgp_crt_t()
2297
gnutls.openpgp_crt_init(ctypes.byref(crt))
1852
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1853
(gnutls.library.functions
1854
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
2298
1855
# Import the OpenPGP public key into the certificate
2299
gnutls.openpgp_crt_import(crt, ctypes.byref(datum),
2300
gnutls.OPENPGP_FMT_RAW)
1856
(gnutls.library.functions
1857
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1858
gnutls.library.constants
1859
.GNUTLS_OPENPGP_FMT_RAW))
2301
1860
# Verify the self signature in the key
2302
1861
crtverify = ctypes.c_uint()
2303
gnutls.openpgp_crt_verify_self(crt, 0,
2304
ctypes.byref(crtverify))
1862
(gnutls.library.functions
1863
.gnutls_openpgp_crt_verify_self(crt, 0,
1864
ctypes.byref(crtverify)))
2305
1865
if crtverify.value != 0:
2306
gnutls.openpgp_crt_deinit(crt)
2307
raise gnutls.CertificateSecurityError("Verify failed")
1866
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1867
raise (gnutls.errors.CertificateSecurityError
1868
("Verify failed"))
2308
1869
# New buffer for the fingerprint
2309
1870
buf = ctypes.create_string_buffer(20)
2310
1871
buf_len = ctypes.c_size_t()
2311
1872
# Get the fingerprint from the certificate into the buffer
2312
gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
2313
ctypes.byref(buf_len))
1873
(gnutls.library.functions
1874
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1875
ctypes.byref(buf_len)))
2314
1876
# Deinit the certificate
2315
gnutls.openpgp_crt_deinit(crt)
1877
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
2316
1878
# Convert the buffer to a Python bytestring
2317
1879
fpr = ctypes.string_at(buf, buf_len.value)
2318
1880
# Convert the bytestring to hexadecimal notation
2322
1884
2323
1885
class MultiprocessingMixIn(object):
2324
1886
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
2325
2326
1887
def sub_process_main(self, request, address):
2327
1888
try:
2328
1889
self.finish_request(request, address)
2340
1901
2341
1902
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
2342
1903
""" adds a pipe to the MixIn """
2343
2344
1904
def process_request(self, request, client_address):
2345
1905
"""Overrides and wraps the original process_request().
2346
1906
2355
1915
2356
1916
def add_pipe(self, parent_pipe, proc):
2357
1917
"""Dummy function; override as necessary"""
2358
raise NotImplementedError()
1918
raise NotImplementedError
2359
1919
2360
1920
2361
1921
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2367
1927
interface: None or a network interface name (string)
2368
1928
use_ipv6: Boolean; to use IPv6 or not
2369
1929
"""
2370
2371
1930
def __init__(self, server_address, RequestHandlerClass,
2372
interface=None,
2373
use_ipv6=True,
2374
socketfd=None):
1931
interface=None, use_ipv6=True, socketfd=None):
2375
1932
"""If socketfd is set, use that file descriptor instead of
2376
1933
creating a new one with socket.socket().
2377
1934
"""
2418
1975
self.interface)
2419
1976
else:
2420
1977
try:
2421
self.socket.setsockopt(
2422
socket.SOL_SOCKET, SO_BINDTODEVICE,
2423
(self.interface + "\0").encode("utf-8"))
1978
self.socket.setsockopt(socket.SOL_SOCKET,
1979
SO_BINDTODEVICE,
1980
str(self.interface + '\0'))
2424
1981
except socket.error as error:
2425
1982
if error.errno == errno.EPERM:
2426
1983
logger.error("No permission to bind to"
2444
2001
self.server_address = (any_address,
2445
2002
self.server_address[1])
2446
2003
elif not self.server_address[1]:
2447
self.server_address = (self.server_address[0], 0)
2004
self.server_address = (self.server_address[0],
2005
0)
2448
2006
# if self.interface:
2449
2007
# self.server_address = (self.server_address[0],
2450
2008
# 0, # port
2464
2022
2465
2023
Assumes a gobject.MainLoop event loop.
2466
2024
"""
2467
2468
2025
def __init__(self, server_address, RequestHandlerClass,
2469
interface=None,
2470
use_ipv6=True,
2471
clients=None,
2472
gnutls_priority=None,
2473
use_dbus=True,
2474
socketfd=None):
2026
interface=None, use_ipv6=True, clients=None,
2027
gnutls_priority=None, use_dbus=True, socketfd=None):
2475
2028
self.enabled = False
2476
2029
self.clients = clients
2477
2030
if self.clients is None:
2483
2036
interface = interface,
2484
2037
use_ipv6 = use_ipv6,
2485
2038
socketfd = socketfd)
2486
2487
2039
def server_activate(self):
2488
2040
if self.enabled:
2489
2041
return socketserver.TCPServer.server_activate(self)
2493
2045
2494
2046
def add_pipe(self, parent_pipe, proc):
2495
2047
# Call "handle_ipc" for both data and EOF events
2496
gobject.io_add_watch(
2497
parent_pipe.fileno(),
2498
gobject.IO_IN | gobject.IO_HUP,
2499
functools.partial(self.handle_ipc,
2500
parent_pipe = parent_pipe,
2501
proc = proc))
2048
gobject.io_add_watch(parent_pipe.fileno(),
2049
gobject.IO_IN | gobject.IO_HUP,
2050
functools.partial(self.handle_ipc,
2051
parent_pipe =
2052
parent_pipe,
2053
proc = proc))
2502
2054
2503
def handle_ipc(self, source, condition,
2504
parent_pipe=None,
2505
proc = None,
2506
client_object=None):
2055
def handle_ipc(self, source, condition, parent_pipe=None,
2056
proc = None, client_object=None):
2507
2057
# error, or the other end of multiprocessing.Pipe has closed
2508
2058
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2509
2059
# Wait for other process to exit
2532
2082
parent_pipe.send(False)
2533
2083
return False
2534
2084
2535
gobject.io_add_watch(
2536
parent_pipe.fileno(),
2537
gobject.IO_IN | gobject.IO_HUP,
2538
functools.partial(self.handle_ipc,
2539
parent_pipe = parent_pipe,
2540
proc = proc,
2541
client_object = client))
2085
gobject.io_add_watch(parent_pipe.fileno(),
2086
gobject.IO_IN | gobject.IO_HUP,
2087
functools.partial(self.handle_ipc,
2088
parent_pipe =
2089
parent_pipe,
2090
proc = proc,
2091
client_object =
2092
client))
2542
2093
parent_pipe.send(True)
2543
2094
# remove the old hook in favor of the new above hook on
2544
2095
# same fileno
2550
2101
2551
2102
parent_pipe.send(('data', getattr(client_object,
2552
2103
funcname)(*args,
2553
**kwargs)))
2104
**kwargs)))
2554
2105
2555
2106
if command == 'getattr':
2556
2107
attrname = request[1]
2557
if isinstance(client_object.__getattribute__(attrname),
2558
collections.Callable):
2559
parent_pipe.send(('function', ))
2108
if callable(client_object.__getattribute__(attrname)):
2109
parent_pipe.send(('function',))
2560
2110
else:
2561
parent_pipe.send((
2562
'data', client_object.__getattribute__(attrname)))
2111
parent_pipe.send(('data', client_object
2112
.__getattribute__(attrname)))
2563
2113
2564
2114
if command == 'setattr':
2565
2115
attrname = request[1]
2596
2146
# avoid excessive use of external libraries.
2597
2147
2598
2148
# New type for defining tokens, syntax, and semantics all-in-one
2599
Token = collections.namedtuple("Token", (
2600
"regexp", # To match token; if "value" is not None, must have
2601
# a "group" containing digits
2602
"value", # datetime.timedelta or None
2603
"followers")) # Tokens valid after this token
2149
Token = collections.namedtuple("Token",
2150
("regexp", # To match token; if
2151
# "value" is not None,
2152
# must have a "group"
2153
# containing digits
2154
"value", # datetime.timedelta or
2155
# None
2156
"followers")) # Tokens valid after
2157
# this token
2604
2158
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2605
2159
# the "duration" ABNF definition in RFC 3339, Appendix A.
2606
2160
token_end = Token(re.compile(r"$"), None, frozenset())
2607
2161
token_second = Token(re.compile(r"(\d+)S"),
2608
2162
datetime.timedelta(seconds=1),
2609
frozenset((token_end, )))
2163
frozenset((token_end,)))
2610
2164
token_minute = Token(re.compile(r"(\d+)M"),
2611
2165
datetime.timedelta(minutes=1),
2612
2166
frozenset((token_second, token_end)))
2628
2182
frozenset((token_month, token_end)))
2629
2183
token_week = Token(re.compile(r"(\d+)W"),
2630
2184
datetime.timedelta(weeks=1),
2631
frozenset((token_end, )))
2185
frozenset((token_end,)))
2632
2186
token_duration = Token(re.compile(r"P"), None,
2633
2187
frozenset((token_year, token_month,
2634
2188
token_day, token_time,
2635
token_week)))
2189
token_week))),
2636
2190
# Define starting values
2637
2191
value = datetime.timedelta() # Value so far
2638
2192
found_token = None
2639
followers = frozenset((token_duration, )) # Following valid tokens
2193
followers = frozenset(token_duration,) # Following valid tokens
2640
2194
s = duration # String left to parse
2641
2195
# Loop until end token is found
2642
2196
while found_token is not token_end:
2659
2213
break
2660
2214
else:
2661
2215
# No currently valid tokens were found
2662
raise ValueError("Invalid RFC 3339 duration: {!r}"
2663
.format(duration))
2216
raise ValueError("Invalid RFC 3339 duration")
2664
2217
# End token found
2665
2218
return value
2666
2219
2690
2243
timevalue = datetime.timedelta(0)
2691
2244
for s in interval.split():
2692
2245
try:
2693
suffix = s[-1]
2246
suffix = unicode(s[-1])
2694
2247
value = int(s[:-1])
2695
2248
if suffix == "d":
2696
2249
delta = datetime.timedelta(value)
2703
2256
elif suffix == "w":
2704
2257
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2705
2258
else:
2706
raise ValueError("Unknown suffix {!r}".format(suffix))
2707
except IndexError as e:
2259
raise ValueError("Unknown suffix {0!r}"
2260
.format(suffix))
2261
except (ValueError, IndexError) as e:
2708
2262
raise ValueError(*(e.args))
2709
2263
timevalue += delta
2710
2264
return timevalue
2726
2280
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2727
2281
if not stat.S_ISCHR(os.fstat(null).st_mode):
2728
2282
raise OSError(errno.ENODEV,
2729
"{} not a character device"
2283
"{0} not a character device"
2730
2284
.format(os.devnull))
2731
2285
os.dup2(null, sys.stdin.fileno())
2732
2286
os.dup2(null, sys.stdout.fileno())
2742
2296
2743
2297
parser = argparse.ArgumentParser()
2744
2298
parser.add_argument("-v", "--version", action="version",
2745
version = "%(prog)s {}".format(version),
2299
version = "%(prog)s {0}".format(version),
2746
2300
help="show version number and exit")
2747
2301
parser.add_argument("-i", "--interface", metavar="IF",
2748
2302
help="Bind to interface IF")
2781
2335
help="Directory to save/restore state in")
2782
2336
parser.add_argument("--foreground", action="store_true",
2783
2337
help="Run in foreground", default=None)
2784
parser.add_argument("--no-zeroconf", action="store_false",
2785
dest="zeroconf", help="Do not use Zeroconf",
2786
default=None)
2787
2338
2788
2339
options = parser.parse_args()
2789
2340
2790
2341
if options.check:
2791
2342
import doctest
2792
fail_count, test_count = doctest.testmod()
2793
sys.exit(os.EX_OK if fail_count == 0 else 1)
2343
doctest.testmod()
2344
sys.exit()
2794
2345
2795
2346
# Default values for config file for server-global settings
2796
2347
server_defaults = { "interface": "",
2798
2349
"port": "",
2799
2350
"debug": "False",
2800
2351
"priority":
2801
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2802
":+SIGN-DSA-SHA256",
2352
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2803
2353
"servicename": "Mandos",
2804
2354
"use_dbus": "True",
2805
2355
"use_ipv6": "True",
2808
2358
"socket": "",
2809
2359
"statedir": "/var/lib/mandos",
2810
2360
"foreground": "False",
2811
"zeroconf": "True",
2812
}
2361
}
2813
2362
2814
2363
# Parse config file for server-global settings
2815
2364
server_config = configparser.SafeConfigParser(server_defaults)
2816
2365
del server_defaults
2817
server_config.read(os.path.join(options.configdir, "mandos.conf"))
2366
server_config.read(os.path.join(options.configdir,
2367
"mandos.conf"))
2818
2368
# Convert the SafeConfigParser object to a dict
2819
2369
server_settings = server_config.defaults()
2820
2370
# Use the appropriate methods on the non-string config options
2838
2388
# Override the settings from the config file with command line
2839
2389
# options, if set.
2840
2390
for option in ("interface", "address", "port", "debug",
2841
"priority", "servicename", "configdir", "use_dbus",
2842
"use_ipv6", "debuglevel", "restore", "statedir",
2843
"socket", "foreground", "zeroconf"):
2391
"priority", "servicename", "configdir",
2392
"use_dbus", "use_ipv6", "debuglevel", "restore",
2393
"statedir", "socket", "foreground"):
2844
2394
value = getattr(options, option)
2845
2395
if value is not None:
2846
2396
server_settings[option] = value
2847
2397
del options
2848
2398
# Force all strings to be unicode
2849
2399
for option in server_settings.keys():
2850
if isinstance(server_settings[option], bytes):
2851
server_settings[option] = (server_settings[option]
2852
.decode("utf-8"))
2400
if type(server_settings[option]) is str:
2401
server_settings[option] = unicode(server_settings[option])
2853
2402
# Force all boolean options to be boolean
2854
2403
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2855
"foreground", "zeroconf"):
2404
"foreground"):
2856
2405
server_settings[option] = bool(server_settings[option])
2857
2406
# Debug implies foreground
2858
2407
if server_settings["debug"]:
2861
2410
2862
2411
##################################################################
2863
2412
2864
if (not server_settings["zeroconf"]
2865
and not (server_settings["port"]
2866
or server_settings["socket"] != "")):
2867
parser.error("Needs port or socket to work without Zeroconf")
2868
2869
2413
# For convenience
2870
2414
debug = server_settings["debug"]
2871
2415
debuglevel = server_settings["debuglevel"]
2874
2418
stored_state_path = os.path.join(server_settings["statedir"],
2875
2419
stored_state_file)
2876
2420
foreground = server_settings["foreground"]
2877
zeroconf = server_settings["zeroconf"]
2878
2421
2879
2422
if debug:
2880
2423
initlogger(debug, logging.DEBUG)
2886
2429
initlogger(debug, level)
2887
2430
2888
2431
if server_settings["servicename"] != "Mandos":
2889
syslogger.setFormatter(
2890
logging.Formatter('Mandos ({}) [%(process)d]:'
2891
' %(levelname)s: %(message)s'.format(
2892
server_settings["servicename"])))
2432
syslogger.setFormatter(logging.Formatter
2433
('Mandos ({0}) [%(process)d]:'
2434
' %(levelname)s: %(message)s'
2435
.format(server_settings
2436
["servicename"])))
2893
2437
2894
2438
# Parse config file with clients
2895
2439
client_config = configparser.SafeConfigParser(Client
2900
2444
global mandos_dbus_service
2901
2445
mandos_dbus_service = None
2902
2446
2903
socketfd = None
2904
if server_settings["socket"] != "":
2905
socketfd = server_settings["socket"]
2906
tcp_server = MandosServer(
2907
(server_settings["address"], server_settings["port"]),
2908
ClientHandler,
2909
interface=(server_settings["interface"] or None),
2910
use_ipv6=use_ipv6,
2911
gnutls_priority=server_settings["priority"],
2912
use_dbus=use_dbus,
2913
socketfd=socketfd)
2447
tcp_server = MandosServer((server_settings["address"],
2448
server_settings["port"]),
2449
ClientHandler,
2450
interface=(server_settings["interface"]
2451
or None),
2452
use_ipv6=use_ipv6,
2453
gnutls_priority=
2454
server_settings["priority"],
2455
use_dbus=use_dbus,
2456
socketfd=(server_settings["socket"]
2457
or None))
2914
2458
if not foreground:
2915
2459
pidfilename = "/run/mandos.pid"
2916
if not os.path.isdir("/run/."):
2917
pidfilename = "/var/run/mandos.pid"
2918
2460
pidfile = None
2919
2461
try:
2920
pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
2462
pidfile = open(pidfilename, "w")
2921
2463
except IOError as e:
2922
2464
logger.error("Could not open file %r", pidfilename,
2923
2465
exc_info=e)
2924
2466
2925
for name, group in (("_mandos", "_mandos"),
2926
("mandos", "mandos"),
2927
("nobody", "nogroup")):
2467
for name in ("_mandos", "mandos", "nobody"):
2928
2468
try:
2929
2469
uid = pwd.getpwnam(name).pw_uid
2930
gid = pwd.getpwnam(group).pw_gid
2470
gid = pwd.getpwnam(name).pw_gid
2931
2471
break
2932
2472
except KeyError:
2933
2473
continue
2939
2479
os.setuid(uid)
2940
2480
except OSError as error:
2941
2481
if error.errno != errno.EPERM:
2942
raise
2482
raise error
2943
2483
2944
2484
if debug:
2945
2485
# Enable all possible GnuTLS debugging
2946
2486
2947
2487
# "Use a log level over 10 to enable all debugging options."
2948
2488
# - GnuTLS manual
2949
gnutls.global_set_log_level(11)
2489
gnutls.library.functions.gnutls_global_set_log_level(11)
2950
2490
2951
@gnutls.log_func
2491
@gnutls.library.types.gnutls_log_func
2952
2492
def debug_gnutls(level, string):
2953
2493
logger.debug("GnuTLS: %s", string[:-1])
2954
2494
2955
gnutls.global_set_log_function(debug_gnutls)
2495
(gnutls.library.functions
2496
.gnutls_global_set_log_function(debug_gnutls))
2956
2497
2957
2498
# Redirect stdin so all checkers get /dev/null
2958
2499
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2978
2519
if use_dbus:
2979
2520
try:
2980
2521
bus_name = dbus.service.BusName("se.recompile.Mandos",
2981
bus,
2982
do_not_queue=True)
2983
old_bus_name = dbus.service.BusName(
2984
"se.bsnet.fukt.Mandos", bus,
2985
do_not_queue=True)
2986
except dbus.exceptions.DBusException as e:
2522
bus, do_not_queue=True)
2523
old_bus_name = (dbus.service.BusName
2524
("se.bsnet.fukt.Mandos", bus,
2525
do_not_queue=True))
2526
except dbus.exceptions.NameExistsException as e:
2987
2527
logger.error("Disabling D-Bus:", exc_info=e)
2988
2528
use_dbus = False
2989
2529
server_settings["use_dbus"] = False
2990
2530
tcp_server.use_dbus = False
2991
if zeroconf:
2992
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2993
service = AvahiServiceToSyslog(
2994
name = server_settings["servicename"],
2995
servicetype = "_mandos._tcp",
2996
protocol = protocol,
2997
bus = bus)
2998
if server_settings["interface"]:
2999
service.interface = if_nametoindex(
3000
server_settings["interface"].encode("utf-8"))
2531
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2532
service = AvahiServiceToSyslog(name =
2533
server_settings["servicename"],
2534
servicetype = "_mandos._tcp",
2535
protocol = protocol, bus = bus)
2536
if server_settings["interface"]:
2537
service.interface = (if_nametoindex
2538
(str(server_settings["interface"])))
3001
2539
3002
2540
global multiprocessing_manager
3003
2541
multiprocessing_manager = multiprocessing.Manager()
3022
2560
if server_settings["restore"]:
3023
2561
try:
3024
2562
with open(stored_state_path, "rb") as stored_state:
3025
clients_data, old_client_settings = pickle.load(
3026
stored_state)
2563
clients_data, old_client_settings = (pickle.load
2564
(stored_state))
3027
2565
os.remove(stored_state_path)
3028
2566
except IOError as e:
3029
2567
if e.errno == errno.ENOENT:
3030
logger.warning("Could not load persistent state:"
3031
" {}".format(os.strerror(e.errno)))
2568
logger.warning("Could not load persistent state: {0}"
2569
.format(os.strerror(e.errno)))
3032
2570
else:
3033
2571
logger.critical("Could not load persistent state:",
3034
2572
exc_info=e)
3035
2573
raise
3036
2574
except EOFError as e:
3037
2575
logger.warning("Could not load persistent state: "
3038
"EOFError:",
3039
exc_info=e)
2576
"EOFError:", exc_info=e)
3040
2577
3041
2578
with PGPEngine() as pgp:
3042
for client_name, client in clients_data.items():
2579
for client_name, client in clients_data.iteritems():
3043
2580
# Skip removed clients
3044
2581
if client_name not in client_settings:
3045
2582
continue
3054
2591
# For each value in new config, check if it
3055
2592
# differs from the old config value (Except for
3056
2593
# the "secret" attribute)
3057
if (name != "secret"
3058
and (value !=
3059
old_client_settings[client_name][name])):
2594
if (name != "secret" and
2595
value != old_client_settings[client_name]
2596
[name]):
3060
2597
client[name] = value
3061
2598
except KeyError:
3062
2599
pass
3063
2600
3064
2601
# Clients who has passed its expire date can still be
3065
# enabled if its last checker was successful. A Client
2602
# enabled if its last checker was successful. Clients
3066
2603
# whose checker succeeded before we stored its state is
3067
2604
# assumed to have successfully run all checkers during
3068
2605
# downtime.
3070
2607
if datetime.datetime.utcnow() >= client["expires"]:
3071
2608
if not client["last_checked_ok"]:
3072
2609
logger.warning(
3073
"disabling client {} - Client never "
3074
"performed a successful checker".format(
3075
client_name))
2610
"disabling client {0} - Client never "
2611
"performed a successful checker"
2612
.format(client_name))
3076
2613
client["enabled"] = False
3077
2614
elif client["last_checker_status"] != 0:
3078
2615
logger.warning(
3079
"disabling client {} - Client last"
3080
" checker failed with error code"
3081
" {}".format(
3082
client_name,
3083
client["last_checker_status"]))
2616
"disabling client {0} - Client "
2617
"last checker failed with error code {1}"
2618
.format(client_name,
2619
client["last_checker_status"]))
3084
2620
client["enabled"] = False
3085
2621
else:
3086
client["expires"] = (
3087
datetime.datetime.utcnow()
3088
+ client["timeout"])
2622
client["expires"] = (datetime.datetime
2623
.utcnow()
2624
+ client["timeout"])
3089
2625
logger.debug("Last checker succeeded,"
3090
" keeping {} enabled".format(
3091
client_name))
2626
" keeping {0} enabled"
2627
.format(client_name))
3092
2628
try:
3093
client["secret"] = pgp.decrypt(
3094
client["encrypted_secret"],
3095
client_settings[client_name]["secret"])
2629
client["secret"] = (
2630
pgp.decrypt(client["encrypted_secret"],
2631
client_settings[client_name]
2632
["secret"]))
3096
2633
except PGPError:
3097
2634
# If decryption fails, we use secret from new settings
3098
logger.debug("Failed to decrypt {} old secret".format(
3099
client_name))
3100
client["secret"] = (client_settings[client_name]
3101
["secret"])
2635
logger.debug("Failed to decrypt {0} old secret"
2636
.format(client_name))
2637
client["secret"] = (
2638
client_settings[client_name]["secret"])
3102
2639
3103
2640
# Add/remove clients based on new changes made to config
3104
2641
for client_name in (set(old_client_settings)
3109
2646
clients_data[client_name] = client_settings[client_name]
3110
2647
3111
2648
# Create all client objects
3112
for client_name, client in clients_data.items():
2649
for client_name, client in clients_data.iteritems():
3113
2650
tcp_server.clients[client_name] = client_class(
3114
name = client_name,
3115
settings = client,
2651
name = client_name, settings = client,
3116
2652
server_settings = server_settings)
3117
2653
3118
2654
if not tcp_server.clients:
3120
2656
3121
2657
if not foreground:
3122
2658
if pidfile is not None:
3123
pid = os.getpid()
3124
2659
try:
3125
2660
with pidfile:
3126
print(pid, file=pidfile)
2661
pid = os.getpid()
2662
pidfile.write(str(pid) + "\n".encode("utf-8"))
3127
2663
except IOError:
3128
2664
logger.error("Could not write to file %r with PID %d",
3129
2665
pidfilename, pid)
3134
2670
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
3135
2671
3136
2672
if use_dbus:
3137
3138
@alternate_dbus_interfaces(
3139
{ "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })
3140
class MandosDBusService(DBusObjectWithObjectManager):
2673
@alternate_dbus_interfaces({"se.recompile.Mandos":
2674
"se.bsnet.fukt.Mandos"})
2675
class MandosDBusService(DBusObjectWithProperties):
3141
2676
"""A D-Bus proxy object"""
3142
3143
2677
def __init__(self):
3144
2678
dbus.service.Object.__init__(self, bus, "/")
3145
3146
2679
_interface = "se.recompile.Mandos"
3147
2680
2681
@dbus_interface_annotations(_interface)
2682
def _foo(self):
2683
return { "org.freedesktop.DBus.Property"
2684
".EmitsChangedSignal":
2685
"false"}
2686
3148
2687
@dbus.service.signal(_interface, signature="o")
3149
2688
def ClientAdded(self, objpath):
3150
2689
"D-Bus signal"
3155
2694
"D-Bus signal"
3156
2695
pass
3157
2696
3158
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3159
"true"})
3160
2697
@dbus.service.signal(_interface, signature="os")
3161
2698
def ClientRemoved(self, objpath, name):
3162
2699
"D-Bus signal"
3163
2700
pass
3164
2701
3165
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3166
"true"})
3167
2702
@dbus.service.method(_interface, out_signature="ao")
3168
2703
def GetAllClients(self):
3169
2704
"D-Bus method"
3170
return dbus.Array(c.dbus_object_path for c in
2705
return dbus.Array(c.dbus_object_path
2706
for c in
3171
2707
tcp_server.clients.itervalues())
3172
2708
3173
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3174
"true"})
3175
2709
@dbus.service.method(_interface,
3176
2710
out_signature="a{oa{sv}}")
3177
2711
def GetAllClientsWithProperties(self):
3178
2712
"D-Bus method"
3179
2713
return dbus.Dictionary(
3180
{ c.dbus_object_path: c.GetAll(
3181
"se.recompile.Mandos.Client")
3182
for c in tcp_server.clients.itervalues() },
2714
((c.dbus_object_path, c.GetAll(""))
2715
for c in tcp_server.clients.itervalues()),
3183
2716
signature="oa{sv}")
3184
2717
3185
2718
@dbus.service.method(_interface, in_signature="o")
3189
2722
if c.dbus_object_path == object_path:
3190
2723
del tcp_server.clients[c.name]
3191
2724
c.remove_from_connection()
3192
# Don't signal the disabling
2725
# Don't signal anything except ClientRemoved
3193
2726
c.disable(quiet=True)
3194
# Emit D-Bus signal for removal
3195
self.client_removed_signal(c)
2727
# Emit D-Bus signal
2728
self.ClientRemoved(object_path, c.name)
3196
2729
return
3197
2730
raise KeyError(object_path)
3198
2731
3199
2732
del _interface
3200
3201
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
3202
out_signature = "a{oa{sa{sv}}}")
3203
def GetManagedObjects(self):
3204
"""D-Bus method"""
3205
return dbus.Dictionary(
3206
{ client.dbus_object_path:
3207
dbus.Dictionary(
3208
{ interface: client.GetAll(interface)
3209
for interface in
3210
client._get_all_interface_names()})
3211
for client in tcp_server.clients.values()})
3212
3213
def client_added_signal(self, client):
3214
"""Send the new standard signal and the old signal"""
3215
if use_dbus:
3216
# New standard signal
3217
self.InterfacesAdded(
3218
client.dbus_object_path,
3219
dbus.Dictionary(
3220
{ interface: client.GetAll(interface)
3221
for interface in
3222
client._get_all_interface_names()}))
3223
# Old signal
3224
self.ClientAdded(client.dbus_object_path)
3225
3226
def client_removed_signal(self, client):
3227
"""Send the new standard signal and the old signal"""
3228
if use_dbus:
3229
# New standard signal
3230
self.InterfacesRemoved(
3231
client.dbus_object_path,
3232
client._get_all_interface_names())
3233
# Old signal
3234
self.ClientRemoved(client.dbus_object_path,
3235
client.name)
3236
2733
3237
2734
mandos_dbus_service = MandosDBusService()
3238
2735
3239
2736
def cleanup():
3240
2737
"Cleanup function; run on exit"
3241
if zeroconf:
3242
service.cleanup()
2738
service.cleanup()
3243
2739
3244
2740
multiprocessing.active_children()
3245
2741
wnull.close()
3259
2755
3260
2756
# A list of attributes that can not be pickled
3261
2757
# + secret.
3262
exclude = { "bus", "changedstate", "secret",
3263
"checker", "server_settings" }
3264
for name, typ in inspect.getmembers(dbus.service
3265
.Object):
2758
exclude = set(("bus", "changedstate", "secret",
2759
"checker", "server_settings"))
2760
for name, typ in (inspect.getmembers
2761
(dbus.service.Object)):
3266
2762
exclude.add(name)
3267
2763
3268
2764
client_dict["encrypted_secret"] = (client
3275
2771
del client_settings[client.name]["secret"]
3276
2772
3277
2773
try:
3278
with tempfile.NamedTemporaryFile(
3279
mode='wb',
3280
suffix=".pickle",
3281
prefix='clients-',
3282
dir=os.path.dirname(stored_state_path),
3283
delete=False) as stored_state:
2774
with (tempfile.NamedTemporaryFile
2775
(mode='wb', suffix=".pickle", prefix='clients-',
2776
dir=os.path.dirname(stored_state_path),
2777
delete=False)) as stored_state:
3284
2778
pickle.dump((clients, client_settings), stored_state)
3285
tempname = stored_state.name
2779
tempname=stored_state.name
3286
2780
os.rename(tempname, stored_state_path)
3287
2781
except (IOError, OSError) as e:
3288
2782
if not debug:
3291
2785
except NameError:
3292
2786
pass
3293
2787
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
3294
logger.warning("Could not save persistent state: {}"
2788
logger.warning("Could not save persistent state: {0}"
3295
2789
.format(os.strerror(e.errno)))
3296
2790
else:
3297
2791
logger.warning("Could not save persistent state:",
3298
2792
exc_info=e)
3299
raise
2793
raise e
3300
2794
3301
2795
# Delete all clients, and settings from config
3302
2796
while tcp_server.clients:
3303
2797
name, client = tcp_server.clients.popitem()
3304
2798
if use_dbus:
3305
2799
client.remove_from_connection()
3306
# Don't signal the disabling
2800
# Don't signal anything except ClientRemoved
3307
2801
client.disable(quiet=True)
3308
# Emit D-Bus signal for removal
3309
2802
if use_dbus:
3310
mandos_dbus_service.client_removed_signal(client)
2803
# Emit D-Bus signal
2804
mandos_dbus_service.ClientRemoved(client
2805
.dbus_object_path,
2806
client.name)
3311
2807
client_settings.clear()
3312
2808
3313
2809
atexit.register(cleanup)
3314
2810
3315
2811
for client in tcp_server.clients.itervalues():
3316
2812
if use_dbus:
3317
# Emit D-Bus signal for adding
3318
mandos_dbus_service.client_added_signal(client)
2813
# Emit D-Bus signal
2814
mandos_dbus_service.ClientAdded(client.dbus_object_path)
3319
2815
# Need to initiate checking of clients
3320
2816
if client.enabled:
3321
2817
client.init_checker()
3324
2820
tcp_server.server_activate()
3325
2821
3326
2822
# Find out what port we got
3327
if zeroconf:
3328
service.port = tcp_server.socket.getsockname()[1]
2823
service.port = tcp_server.socket.getsockname()[1]
3329
2824
if use_ipv6:
3330
2825
logger.info("Now listening on address %r, port %d,"
3331
2826
" flowinfo %d, scope_id %d",
3337
2832
#service.interface = tcp_server.socket.getsockname()[3]
3338
2833
3339
2834
try:
3340
if zeroconf:
3341
# From the Avahi example code
3342
try:
3343
service.activate()
3344
except dbus.exceptions.DBusException as error:
3345
logger.critical("D-Bus Exception", exc_info=error)
3346
cleanup()
3347
sys.exit(1)
3348
# End of Avahi example code
2835
# From the Avahi example code
2836
try:
2837
service.activate()
2838
except dbus.exceptions.DBusException as error:
2839
logger.critical("D-Bus Exception", exc_info=error)
2840
cleanup()
2841
sys.exit(1)
2842
# End of Avahi example code
3349
2843
3350
2844
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
3351
2845
lambda *args, **kwargs:
3366
2860
# Must run before the D-Bus bus name gets deregistered
3367
2861
cleanup()
3368
2862
3369
3370
2863
if __name__ == '__main__':
3371
2864
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0