To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 624
- compare with another revision
- download diff
- download tarball
- view history from revision 624
- Committer: Teddy Hogeborn
- Date: 2013-10-13 15:43:42 UTC
- Revision ID: teddy@recompile.se-20131013154342-2ztabynqog6xuk0t
* initramfs-unpack: Bug fix: Made executable.
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-2012 Teddy Hogeborn
15
# Copyright © 2008-2012 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
from gi.repository import GObject
81
except ImportError:
82
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.0"
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']
194
172
def password_encode(self, password):
195
173
# Passphrase can not be empty and can not contain newlines or
196
174
# NUL bytes. So we prefix it and hex encode it.
197
encoded = b"mandos" + binascii.hexlify(password)
198
if len(encoded) > 2048:
199
# GnuPG can't handle long passwords, so encode differently
200
encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
201
.replace(b"\n", b"\\n")
202
.replace(b"\0", b"\\x00"))
203
return encoded
175
return b"mandos" + binascii.hexlify(password)
204
176
205
177
def encrypt(self, data, password):
206
178
passphrase = self.password_encode(password)
207
with tempfile.NamedTemporaryFile(
208
dir=self.tempdir) as passfile:
179
with tempfile.NamedTemporaryFile(dir=self.tempdir
180
) as passfile:
209
181
passfile.write(passphrase)
210
182
passfile.flush()
211
proc = subprocess.Popen([self.gpg, '--symmetric',
183
proc = subprocess.Popen(['gpg', '--symmetric',
212
184
'--passphrase-file',
213
185
passfile.name]
214
186
+ self.gnupgargs,
222
194
223
195
def decrypt(self, data, password):
224
196
passphrase = self.password_encode(password)
225
with tempfile.NamedTemporaryFile(
226
dir = self.tempdir) as passfile:
197
with tempfile.NamedTemporaryFile(dir = self.tempdir
198
) as passfile:
227
199
passfile.write(passphrase)
228
200
passfile.flush()
229
proc = subprocess.Popen([self.gpg, '--decrypt',
201
proc = subprocess.Popen(['gpg', '--decrypt',
230
202
'--passphrase-file',
231
203
passfile.name]
232
204
+ self.gnupgargs,
233
205
stdin = subprocess.PIPE,
234
206
stdout = subprocess.PIPE,
235
207
stderr = subprocess.PIPE)
236
decrypted_plaintext, err = proc.communicate(input = data)
208
decrypted_plaintext, err = proc.communicate(input
209
= data)
237
210
if proc.returncode != 0:
238
211
raise PGPError(err)
239
212
return decrypted_plaintext
242
215
class AvahiError(Exception):
243
216
def __init__(self, value, *args, **kwargs):
244
217
self.value = value
245
return super(AvahiError, self).__init__(value, *args,
246
**kwargs)
247
218
super(AvahiError, self).__init__(value, *args, **kwargs)
219
def __unicode__(self):
220
return unicode(repr(self.value))
248
221
249
222
class AvahiServiceError(AvahiError):
250
223
pass
251
224
252
253
225
class AvahiGroupError(AvahiError):
254
226
pass
255
227
275
247
bus: dbus.SystemBus()
276
248
"""
277
249
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):
250
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
251
servicetype = None, port = None, TXT = None,
252
domain = "", host = "", max_renames = 32768,
253
protocol = avahi.PROTO_UNSPEC, bus = None):
289
254
self.interface = interface
290
255
self.name = name
291
256
self.type = servicetype
301
266
self.bus = bus
302
267
self.entry_group_state_changed_match = None
303
268
304
def rename(self, remove=True):
269
def rename(self):
305
270
"""Derived from the Avahi example code"""
306
271
if self.rename_count >= self.max_renames:
307
272
logger.critical("No suitable Zeroconf service name found"
308
273
" after %i retries, exiting.",
309
274
self.rename_count)
310
275
raise AvahiServiceError("Too many renames")
311
self.name = str(
312
self.server.GetAlternativeServiceName(self.name))
313
self.rename_count += 1
276
self.name = unicode(self.server
277
.GetAlternativeServiceName(self.name))
314
278
logger.info("Changing Zeroconf service name to %r ...",
315
279
self.name)
316
if remove:
317
self.remove()
280
self.remove()
318
281
try:
319
282
self.add()
320
283
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)
284
logger.critical("D-Bus Exception", exc_info=error)
285
self.cleanup()
286
os._exit(1)
287
self.rename_count += 1
329
288
330
289
def remove(self):
331
290
"""Derived from the Avahi example code"""
369
328
self.rename()
370
329
elif state == avahi.ENTRY_GROUP_FAILURE:
371
330
logger.critical("Avahi: Error in group state changed %s",
372
str(error))
373
raise AvahiGroupError("State changed: {!s}".format(error))
331
unicode(error))
332
raise AvahiGroupError("State changed: {0!s}"
333
.format(error))
374
334
375
335
def cleanup(self):
376
336
"""Derived from the Avahi example code"""
386
346
def server_state_changed(self, state, error=None):
387
347
"""Derived from the Avahi example code"""
388
348
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
}
349
bad_states = { avahi.SERVER_INVALID:
350
"Zeroconf server invalid",
351
avahi.SERVER_REGISTERING: None,
352
avahi.SERVER_COLLISION:
353
"Zeroconf server name collision",
354
avahi.SERVER_FAILURE:
355
"Zeroconf server failure" }
395
356
if state in bad_states:
396
357
if bad_states[state] is not None:
397
358
if error is None:
400
361
logger.error(bad_states[state] + ": %r", error)
401
362
self.cleanup()
402
363
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)
364
self.add()
415
365
else:
416
366
if error is None:
417
367
logger.debug("Unknown state: %r", state)
427
377
follow_name_owner_changes=True),
428
378
avahi.DBUS_INTERFACE_SERVER)
429
379
self.server.connect_to_signal("StateChanged",
430
self.server_state_changed)
380
self.server_state_changed)
431
381
self.server_state_changed(self.server.GetState())
432
382
433
383
434
384
class AvahiServiceToSyslog(AvahiService):
435
def rename(self, *args, **kwargs):
385
def rename(self):
436
386
"""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)))
387
ret = AvahiService.rename(self)
388
syslogger.setFormatter(logging.Formatter
389
('Mandos ({0}) [%(process)d]:'
390
' %(levelname)s: %(message)s'
391
.format(self.name)))
441
392
return ret
442
393
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()
394
395
def timedelta_to_milliseconds(td):
396
"Convert a datetime.timedelta() to milliseconds"
397
return ((td.days * 24 * 60 * 60 * 1000)
398
+ (td.seconds * 1000)
399
+ (td.microseconds // 1000))
400
707
401
708
402
class Client(object):
709
403
"""A representation of a client host served by this server.
715
409
checker: subprocess.Popen(); a running checker process used
716
410
to see if the client lives.
717
411
'None' if no process is running.
718
checker_callback_tag: a GObject event source tag, or None
412
checker_callback_tag: a gobject event source tag, or None
719
413
checker_command: string; External command which is run to check
720
414
if client lives. %() expansions are done at
721
415
runtime with vars(self) as dict, so that for
722
416
instance %(name)s can be used in the command.
723
checker_initiator_tag: a GObject event source tag, or None
417
checker_initiator_tag: a gobject event source tag, or None
724
418
created: datetime.datetime(); (UTC) object creation
725
419
client_structure: Object describing what attributes a client has
726
420
and is used for storing the client at exit
727
421
current_checker_command: string; current running checker_command
728
disable_initiator_tag: a GObject event source tag, or None
422
disable_initiator_tag: a gobject event source tag, or None
729
423
enabled: bool()
730
424
fingerprint: string (40 or 32 hexadecimal digits); used to
731
425
uniquely identify the client
736
430
last_checker_status: integer between 0 and 255 reflecting exit
737
431
status of last checker. -1 reflects crashed
738
432
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
433
last_enabled: datetime.datetime(); (UTC) or None
742
434
name: string; from the config file, used in log messages and
743
435
D-Bus identifiers
756
448
"fingerprint", "host", "interval",
757
449
"last_approval_request", "last_checked_ok",
758
450
"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
}
451
client_defaults = { "timeout": "PT5M",
452
"extended_timeout": "PT15M",
453
"interval": "PT2M",
454
"checker": "fping -q -- %%(host)s",
455
"host": "",
456
"approval_delay": "PT0S",
457
"approval_duration": "PT1S",
458
"approved_by_default": "True",
459
"enabled": "True",
460
}
461
462
def timeout_milliseconds(self):
463
"Return the 'timeout' attribute in milliseconds"
464
return timedelta_to_milliseconds(self.timeout)
465
466
def extended_timeout_milliseconds(self):
467
"Return the 'extended_timeout' attribute in milliseconds"
468
return timedelta_to_milliseconds(self.extended_timeout)
469
470
def interval_milliseconds(self):
471
"Return the 'interval' attribute in milliseconds"
472
return timedelta_to_milliseconds(self.interval)
473
474
def approval_delay_milliseconds(self):
475
return timedelta_to_milliseconds(self.approval_delay)
770
476
771
477
@staticmethod
772
478
def config_parser(config):
788
494
client["enabled"] = config.getboolean(client_name,
789
495
"enabled")
790
496
791
# Uppercase and remove spaces from fingerprint for later
792
# comparison purposes with return value from the
793
# fingerprint() function
794
497
client["fingerprint"] = (section["fingerprint"].upper()
795
498
.replace(" ", ""))
796
499
if "secret" in section:
801
504
"rb") as secfile:
802
505
client["secret"] = secfile.read()
803
506
else:
804
raise TypeError("No secret or secfile for section {}"
507
raise TypeError("No secret or secfile for section {0}"
805
508
.format(section))
806
509
client["timeout"] = string_to_delta(section["timeout"])
807
510
client["extended_timeout"] = string_to_delta(
824
527
server_settings = {}
825
528
self.server_settings = server_settings
826
529
# adding all client settings
827
for setting, value in settings.items():
530
for setting, value in settings.iteritems():
828
531
setattr(self, setting, value)
829
532
830
533
if self.enabled:
838
541
self.expires = None
839
542
840
543
logger.debug("Creating client %r", self.name)
544
# Uppercase and remove spaces from fingerprint for later
545
# comparison purposes with return value from the fingerprint()
546
# function
841
547
logger.debug(" Fingerprint: %s", self.fingerprint)
842
548
self.created = settings.get("created",
843
549
datetime.datetime.utcnow())
850
556
self.current_checker_command = None
851
557
self.approved = None
852
558
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()
559
self.changedstate = (multiprocessing_manager
560
.Condition(multiprocessing_manager
561
.Lock()))
562
self.client_structure = [attr for attr in
563
self.__dict__.iterkeys()
857
564
if not attr.startswith("_")]
858
565
self.client_structure.append("client_structure")
859
566
860
for name, t in inspect.getmembers(
861
type(self), lambda obj: isinstance(obj, property)):
567
for name, t in inspect.getmembers(type(self),
568
lambda obj:
569
isinstance(obj,
570
property)):
862
571
if not name.startswith("_"):
863
572
self.client_structure.append(name)
864
573
885
594
if not quiet:
886
595
logger.info("Disabling client %s", self.name)
887
596
if getattr(self, "disable_initiator_tag", None) is not None:
888
GObject.source_remove(self.disable_initiator_tag)
597
gobject.source_remove(self.disable_initiator_tag)
889
598
self.disable_initiator_tag = None
890
599
self.expires = None
891
600
if getattr(self, "checker_initiator_tag", None) is not None:
892
GObject.source_remove(self.checker_initiator_tag)
601
gobject.source_remove(self.checker_initiator_tag)
893
602
self.checker_initiator_tag = None
894
603
self.stop_checker()
895
604
self.enabled = False
896
605
if not quiet:
897
606
self.send_changedstate()
898
# Do not run this again if called by a GObject.timeout_add
607
# Do not run this again if called by a gobject.timeout_add
899
608
return False
900
609
901
610
def __del__(self):
905
614
# Schedule a new checker to be started an 'interval' from now,
906
615
# and every interval from then on.
907
616
if self.checker_initiator_tag is not None:
908
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)
617
gobject.source_remove(self.checker_initiator_tag)
618
self.checker_initiator_tag = (gobject.timeout_add
619
(self.interval_milliseconds(),
620
self.start_checker))
912
621
# Schedule a disable() when 'timeout' has passed
913
622
if self.disable_initiator_tag is not None:
914
GObject.source_remove(self.disable_initiator_tag)
915
self.disable_initiator_tag = GObject.timeout_add(
916
int(self.timeout.total_seconds() * 1000), self.disable)
623
gobject.source_remove(self.disable_initiator_tag)
624
self.disable_initiator_tag = (gobject.timeout_add
625
(self.timeout_milliseconds(),
626
self.disable))
917
627
# Also start a new checker *right now*.
918
628
self.start_checker()
919
629
920
def checker_callback(self, source, condition, connection,
921
command):
630
def checker_callback(self, pid, condition, command):
922
631
"""The checker has completed, so take appropriate actions."""
923
632
self.checker_callback_tag = None
924
633
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
634
if os.WIFEXITED(condition):
635
self.last_checker_status = os.WEXITSTATUS(condition)
932
636
if self.last_checker_status == 0:
933
637
logger.info("Checker for %(name)s succeeded",
934
638
vars(self))
935
639
self.checked_ok()
936
640
else:
937
logger.info("Checker for %(name)s failed", vars(self))
641
logger.info("Checker for %(name)s failed",
642
vars(self))
938
643
else:
939
644
self.last_checker_status = -1
940
self.last_checker_signal = -returncode
941
645
logger.warning("Checker for %(name)s crashed?",
942
646
vars(self))
943
return False
944
647
945
648
def checked_ok(self):
946
649
"""Assert that the client has been seen, alive and well."""
947
650
self.last_checked_ok = datetime.datetime.utcnow()
948
651
self.last_checker_status = 0
949
self.last_checker_signal = None
950
652
self.bump_timeout()
951
653
952
654
def bump_timeout(self, timeout=None):
954
656
if timeout is None:
955
657
timeout = self.timeout
956
658
if self.disable_initiator_tag is not None:
957
GObject.source_remove(self.disable_initiator_tag)
659
gobject.source_remove(self.disable_initiator_tag)
958
660
self.disable_initiator_tag = None
959
661
if getattr(self, "enabled", False):
960
self.disable_initiator_tag = GObject.timeout_add(
961
int(timeout.total_seconds() * 1000), self.disable)
662
self.disable_initiator_tag = (gobject.timeout_add
663
(timedelta_to_milliseconds
664
(timeout), self.disable))
962
665
self.expires = datetime.datetime.utcnow() + timeout
963
666
964
667
def need_approval(self):
978
681
# than 'timeout' for the client to be disabled, which is as it
979
682
# should be.
980
683
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
684
# If a checker exists, make sure it is not a zombie
685
try:
686
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
687
except (AttributeError, OSError) as error:
688
if (isinstance(error, OSError)
689
and error.errno != errno.ECHILD):
690
raise error
691
else:
692
if pid:
693
logger.warning("Checker was a zombie")
694
gobject.source_remove(self.checker_callback_tag)
695
self.checker_callback(pid, status,
696
self.current_checker_command)
985
697
# Start a new checker if needed
986
698
if self.checker is None:
987
699
# Escape attributes for the shell
988
escaped_attrs = {
989
attr: re.escape(str(getattr(self, attr)))
990
for attr in self.runtime_expansions }
700
escaped_attrs = dict(
701
(attr, re.escape(unicode(getattr(self, attr))))
702
for attr in
703
self.runtime_expansions)
991
704
try:
992
705
command = self.checker_command % escaped_attrs
993
706
except TypeError as error:
994
707
logger.error('Could not format string "%s"',
995
self.checker_command,
708
self.checker_command, exc_info=error)
709
return True # Try again later
710
self.current_checker_command = command
711
try:
712
logger.info("Starting checker %r for %s",
713
command, self.name)
714
# We don't need to redirect stdout and stderr, since
715
# in normal mode, that is already done by daemon(),
716
# and in debug mode we don't want to. (Stdin is
717
# always replaced by /dev/null.)
718
# The exception is when not debugging but nevertheless
719
# running in the foreground; use the previously
720
# created wnull.
721
popen_args = {}
722
if (not self.server_settings["debug"]
723
and self.server_settings["foreground"]):
724
popen_args.update({"stdout": wnull,
725
"stderr": wnull })
726
self.checker = subprocess.Popen(command,
727
close_fds=True,
728
shell=True, cwd="/",
729
**popen_args)
730
except OSError as error:
731
logger.error("Failed to start subprocess",
996
732
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)
1024
# Re-run this periodically if run by GObject.timeout_add
733
return True
734
self.checker_callback_tag = (gobject.child_watch_add
735
(self.checker.pid,
736
self.checker_callback,
737
data=command))
738
# The checker may have completed before the gobject
739
# watch was added. Check for this.
740
try:
741
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
742
except OSError as error:
743
if error.errno == errno.ECHILD:
744
# This should never happen
745
logger.error("Child process vanished",
746
exc_info=error)
747
return True
748
raise
749
if pid:
750
gobject.source_remove(self.checker_callback_tag)
751
self.checker_callback(pid, status, command)
752
# Re-run this periodically if run by gobject.timeout_add
1025
753
return True
1026
754
1027
755
def stop_checker(self):
1028
756
"""Force the checker process, if any, to stop."""
1029
757
if self.checker_callback_tag:
1030
GObject.source_remove(self.checker_callback_tag)
758
gobject.source_remove(self.checker_callback_tag)
1031
759
self.checker_callback_tag = None
1032
760
if getattr(self, "checker", None) is None:
1033
761
return
1034
762
logger.debug("Stopping checker for %(name)s", vars(self))
1035
self.checker.terminate()
763
try:
764
self.checker.terminate()
765
#time.sleep(0.5)
766
#if self.checker.poll() is None:
767
# self.checker.kill()
768
except OSError as error:
769
if error.errno != errno.ESRCH: # No such process
770
raise
1036
771
self.checker = None
1037
772
1038
773
1039
def dbus_service_property(dbus_interface,
1040
signature="v",
1041
access="readwrite",
1042
byte_arrays=False):
774
def dbus_service_property(dbus_interface, signature="v",
775
access="readwrite", byte_arrays=False):
1043
776
"""Decorators for marking methods of a DBusObjectWithProperties to
1044
777
become properties on the D-Bus.
1045
778
1054
787
# "Set" method, so we fail early here:
1055
788
if byte_arrays and signature != "ay":
1056
789
raise ValueError("Byte arrays not supported for non-'ay'"
1057
" signature {!r}".format(signature))
1058
790
" signature {0!r}".format(signature))
1059
791
def decorator(func):
1060
792
func._dbus_is_property = True
1061
793
func._dbus_interface = dbus_interface
1066
798
func._dbus_name = func._dbus_name[:-14]
1067
799
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
1068
800
return func
1069
1070
801
return decorator
1071
802
1072
803
1081
812
"org.freedesktop.DBus.Property.EmitsChangedSignal":
1082
813
"false"}
1083
814
"""
1084
1085
815
def decorator(func):
1086
816
func._dbus_is_interface = True
1087
817
func._dbus_interface = dbus_interface
1088
818
func._dbus_name = dbus_interface
1089
819
return func
1090
1091
820
return decorator
1092
821
1093
822
1095
824
"""Decorator to annotate D-Bus methods, signals or properties
1096
825
Usage:
1097
826
1098
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
1099
"org.freedesktop.DBus.Property."
1100
"EmitsChangedSignal": "false"})
1101
827
@dbus_service_property("org.example.Interface", signature="b",
1102
828
access="r")
829
@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
830
"org.freedesktop.DBus.Property."
831
"EmitsChangedSignal": "false"})
1103
832
def Property_dbus_property(self):
1104
833
return dbus.Boolean(False)
1105
1106
See also the DBusObjectWithAnnotations class.
1107
834
"""
1108
1109
835
def decorator(func):
1110
836
func._dbus_annotations = annotations
1111
837
return func
1112
1113
838
return decorator
1114
839
1115
840
1116
841
class DBusPropertyException(dbus.exceptions.DBusException):
1117
842
"""A base class for D-Bus property-related exceptions
1118
843
"""
1119
pass
844
def __unicode__(self):
845
return unicode(str(self))
1120
846
1121
847
1122
848
class DBusPropertyAccessException(DBusPropertyException):
1131
857
pass
1132
858
1133
859
1134
class DBusObjectWithAnnotations(dbus.service.Object):
1135
"""A D-Bus object with annotations.
860
class DBusObjectWithProperties(dbus.service.Object):
861
"""A D-Bus object with properties.
1136
862
1137
Classes inheriting from this can use the dbus_annotations
1138
decorator to add annotations to methods or signals.
863
Classes inheriting from this can use the dbus_service_property
864
decorator to expose methods as D-Bus properties. It exposes the
865
standard Get(), Set(), and GetAll() methods on the D-Bus.
1139
866
"""
1140
867
1141
868
@staticmethod
1145
872
If called like _is_dbus_thing("method") it returns a function
1146
873
suitable for use as predicate to inspect.getmembers().
1147
874
"""
1148
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
875
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
1149
876
False)
1150
877
1151
878
def _get_all_dbus_things(self, thing):
1152
879
"""Returns a generator of (name, attribute) pairs
1153
880
"""
1154
return ((getattr(athing.__get__(self), "_dbus_name", name),
881
return ((getattr(athing.__get__(self), "_dbus_name",
882
name),
1155
883
athing.__get__(self))
1156
884
for cls in self.__class__.__mro__
1157
885
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
"""
886
inspect.getmembers(cls,
887
self._is_dbus_thing(thing)))
1230
888
1231
889
def _get_dbus_property(self, interface_name, property_name):
1232
890
"""Returns a bound method if one exists which is a D-Bus
1233
891
property with the specified name and interface.
1234
892
"""
1235
for cls in self.__class__.__mro__:
1236
for name, value in inspect.getmembers(
1237
cls, self._is_dbus_thing("property")):
893
for cls in self.__class__.__mro__:
894
for name, value in (inspect.getmembers
895
(cls,
896
self._is_dbus_thing("property"))):
1238
897
if (value._dbus_name == property_name
1239
898
and value._dbus_interface == interface_name):
1240
899
return value.__get__(self)
1241
900
1242
901
# 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",
902
raise DBusPropertyNotFound(self.dbus_object_path + ":"
903
+ interface_name + "."
904
+ property_name)
905
906
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
1257
907
out_signature="v")
1258
908
def Get(self, interface_name, property_name):
1259
909
"""Standard D-Bus property Get() method, see D-Bus standard.
1277
927
# The byte_arrays option is not supported yet on
1278
928
# signatures other than "ay".
1279
929
if prop._dbus_signature != "ay":
1280
raise ValueError("Byte arrays not supported for non-"
1281
"'ay' signature {!r}"
1282
.format(prop._dbus_signature))
930
raise ValueError
1283
931
value = dbus.ByteArray(b''.join(chr(byte)
1284
932
for byte in value))
1285
933
prop(value)
1286
934
1287
@dbus.service.method(dbus.PROPERTIES_IFACE,
1288
in_signature="s",
935
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
1289
936
out_signature="a{sv}")
1290
937
def GetAll(self, interface_name):
1291
938
"""Standard D-Bus property GetAll() method, see D-Bus
1306
953
if not hasattr(value, "variant_level"):
1307
954
properties[name] = value
1308
955
continue
1309
properties[name] = type(value)(
1310
value, variant_level = value.variant_level + 1)
956
properties[name] = type(value)(value, variant_level=
957
value.variant_level+1)
1311
958
return dbus.Dictionary(properties, signature="sv")
1312
959
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
960
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1322
961
out_signature="s",
1323
962
path_keyword='object_path',
1327
966
1328
967
Inserts property tags and interface annotation tags.
1329
968
"""
1330
xmlstring = DBusObjectWithAnnotations.Introspect(self,
1331
object_path,
1332
connection)
969
xmlstring = dbus.service.Object.Introspect(self, object_path,
970
connection)
1333
971
try:
1334
972
document = xml.dom.minidom.parseString(xmlstring)
1335
1336
973
def make_tag(document, name, prop):
1337
974
e = document.createElement("property")
1338
975
e.setAttribute("name", name)
1339
976
e.setAttribute("type", prop._dbus_signature)
1340
977
e.setAttribute("access", prop._dbus_access)
1341
978
return e
1342
1343
979
for if_tag in document.getElementsByTagName("interface"):
1344
980
# Add property tags
1345
981
for tag in (make_tag(document, name, prop)
1348
984
if prop._dbus_interface
1349
985
== if_tag.getAttribute("name")):
1350
986
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)
987
# Add annotation tags
988
for typ in ("method", "signal", "property"):
989
for tag in if_tag.getElementsByTagName(typ):
990
annots = dict()
991
for name, prop in (self.
992
_get_all_dbus_things(typ)):
993
if (name == tag.getAttribute("name")
994
and prop._dbus_interface
995
== if_tag.getAttribute("name")):
996
annots.update(getattr
997
(prop,
998
"_dbus_annotations",
999
{}))
1000
for name, value in annots.iteritems():
1001
ann_tag = document.createElement(
1002
"annotation")
1003
ann_tag.setAttribute("name", name)
1004
ann_tag.setAttribute("value", value)
1005
tag.appendChild(ann_tag)
1006
# Add interface annotation tags
1007
for annotation, value in dict(
1008
itertools.chain.from_iterable(
1009
annotations().iteritems()
1010
for name, annotations in
1011
self._get_all_dbus_things("interface")
1012
if name == if_tag.getAttribute("name")
1013
)).iteritems():
1014
ann_tag = document.createElement("annotation")
1015
ann_tag.setAttribute("name", annotation)
1016
ann_tag.setAttribute("value", value)
1017
if_tag.appendChild(ann_tag)
1367
1018
# Add the names to the return values for the
1368
1019
# "org.freedesktop.DBus.Properties" methods
1369
1020
if (if_tag.getAttribute("name")
1387
1038
exc_info=error)
1388
1039
return xmlstring
1389
1040
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
1041
1459
1042
def datetime_to_dbus(dt, variant_level=0):
1460
1043
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1461
1044
if dt is None:
1462
1045
return dbus.String("", variant_level = variant_level)
1463
return dbus.String(dt.isoformat(), variant_level=variant_level)
1046
return dbus.String(dt.isoformat(),
1047
variant_level=variant_level)
1464
1048
1465
1049
1466
1050
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1486
1070
(from DBusObjectWithProperties) and interfaces (from the
1487
1071
dbus_interface_annotations decorator).
1488
1072
"""
1489
1490
1073
def wrapper(cls):
1491
1074
for orig_interface_name, alt_interface_name in (
1492
alt_interface_names.items()):
1075
alt_interface_names.iteritems()):
1493
1076
attr = {}
1494
1077
interface_names = set()
1495
1078
# Go though all attributes of the class
1497
1080
# Ignore non-D-Bus attributes, and D-Bus attributes
1498
1081
# with the wrong interface name
1499
1082
if (not hasattr(attribute, "_dbus_interface")
1500
or not attribute._dbus_interface.startswith(
1501
orig_interface_name)):
1083
or not attribute._dbus_interface
1084
.startswith(orig_interface_name)):
1502
1085
continue
1503
1086
# Create an alternate D-Bus interface name based on
1504
1087
# the current name
1505
alt_interface = attribute._dbus_interface.replace(
1506
orig_interface_name, alt_interface_name)
1088
alt_interface = (attribute._dbus_interface
1089
.replace(orig_interface_name,
1090
alt_interface_name))
1507
1091
interface_names.add(alt_interface)
1508
1092
# Is this a D-Bus signal?
1509
1093
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(
1094
# Extract the original non-method undecorated
1095
# function by black magic
1096
nonmethod_func = (dict(
1514
1097
zip(attribute.func_code.co_freevars,
1515
attribute.__closure__))
1516
["func"].cell_contents)
1517
else:
1518
nonmethod_func = attribute
1098
attribute.__closure__))["func"]
1099
.cell_contents)
1519
1100
# Create a new, but exactly alike, function
1520
1101
# object, and decorate it to be a new D-Bus signal
1521
1102
# 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))
1103
new_function = (dbus.service.signal
1104
(alt_interface,
1105
attribute._dbus_signature)
1106
(types.FunctionType(
1107
nonmethod_func.func_code,
1108
nonmethod_func.func_globals,
1109
nonmethod_func.func_name,
1110
nonmethod_func.func_defaults,
1111
nonmethod_func.func_closure)))
1539
1112
# Copy annotations, if any
1540
1113
try:
1541
new_function._dbus_annotations = dict(
1542
attribute._dbus_annotations)
1114
new_function._dbus_annotations = (
1115
dict(attribute._dbus_annotations))
1543
1116
except AttributeError:
1544
1117
pass
1545
1118
# Define a creator of a function to call both the
1550
1123
"""This function is a scope container to pass
1551
1124
func1 and func2 to the "call_both" function
1552
1125
outside of its arguments"""
1553
1554
@functools.wraps(func2)
1555
1126
def call_both(*args, **kwargs):
1556
1127
"""This function will emit two D-Bus
1557
1128
signals by calling func1 and func2"""
1558
1129
func1(*args, **kwargs)
1559
1130
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
1131
return call_both
1566
1132
# Create the "call_both" function and add it to
1567
1133
# the class
1572
1138
# object. Decorate it to be a new D-Bus method
1573
1139
# with the alternate D-Bus interface name. Add it
1574
1140
# 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)))
1141
attr[attrname] = (dbus.service.method
1142
(alt_interface,
1143
attribute._dbus_in_signature,
1144
attribute._dbus_out_signature)
1145
(types.FunctionType
1146
(attribute.func_code,
1147
attribute.func_globals,
1148
attribute.func_name,
1149
attribute.func_defaults,
1150
attribute.func_closure)))
1585
1151
# Copy annotations, if any
1586
1152
try:
1587
attr[attrname]._dbus_annotations = dict(
1588
attribute._dbus_annotations)
1153
attr[attrname]._dbus_annotations = (
1154
dict(attribute._dbus_annotations))
1589
1155
except AttributeError:
1590
1156
pass
1591
1157
# Is this a D-Bus property?
1594
1160
# object, and decorate it to be a new D-Bus
1595
1161
# property with the alternate D-Bus interface
1596
1162
# 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)))
1163
attr[attrname] = (dbus_service_property
1164
(alt_interface,
1165
attribute._dbus_signature,
1166
attribute._dbus_access,
1167
attribute
1168
._dbus_get_args_options
1169
["byte_arrays"])
1170
(types.FunctionType
1171
(attribute.func_code,
1172
attribute.func_globals,
1173
attribute.func_name,
1174
attribute.func_defaults,
1175
attribute.func_closure)))
1608
1176
# Copy annotations, if any
1609
1177
try:
1610
attr[attrname]._dbus_annotations = dict(
1611
attribute._dbus_annotations)
1178
attr[attrname]._dbus_annotations = (
1179
dict(attribute._dbus_annotations))
1612
1180
except AttributeError:
1613
1181
pass
1614
1182
# Is this a D-Bus interface?
1617
1185
# object. Decorate it to be a new D-Bus interface
1618
1186
# with the alternate D-Bus interface name. Add it
1619
1187
# 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)))
1188
attr[attrname] = (dbus_interface_annotations
1189
(alt_interface)
1190
(types.FunctionType
1191
(attribute.func_code,
1192
attribute.func_globals,
1193
attribute.func_name,
1194
attribute.func_defaults,
1195
attribute.func_closure)))
1627
1196
if deprecate:
1628
1197
# Deprecate all alternate interfaces
1629
iname="_AlternateDBusNames_interface_annotation{}"
1198
iname="_AlternateDBusNames_interface_annotation{0}"
1630
1199
for interface_name in interface_names:
1631
1632
1200
@dbus_interface_annotations(interface_name)
1633
1201
def func(self):
1634
1202
return { "org.freedesktop.DBus.Deprecated":
1635
"true" }
1203
"true" }
1636
1204
# Find an unused name
1637
1205
for aname in (iname.format(i)
1638
1206
for i in itertools.count()):
1642
1210
if interface_names:
1643
1211
# Replace the class with a new subclass of it with
1644
1212
# methods, signals, etc. as created above.
1645
cls = type(b"{}Alternate".format(cls.__name__),
1646
(cls, ), attr)
1213
cls = type(b"{0}Alternate".format(cls.__name__),
1214
(cls,), attr)
1647
1215
return cls
1648
1649
1216
return wrapper
1650
1217
1651
1218
1652
1219
@alternate_dbus_interfaces({"se.recompile.Mandos":
1653
"se.bsnet.fukt.Mandos"})
1220
"se.bsnet.fukt.Mandos"})
1654
1221
class ClientDBus(Client, DBusObjectWithProperties):
1655
1222
"""A Client class using D-Bus
1656
1223
1660
1227
"""
1661
1228
1662
1229
runtime_expansions = (Client.runtime_expansions
1663
+ ("dbus_object_path", ))
1664
1665
_interface = "se.recompile.Mandos.Client"
1230
+ ("dbus_object_path",))
1666
1231
1667
1232
# dbus.service.Object doesn't use super(), so we can't either.
1668
1233
1671
1236
Client.__init__(self, *args, **kwargs)
1672
1237
# Only now, when this client is initialized, can it show up on
1673
1238
# the D-Bus
1674
client_object_name = str(self.name).translate(
1239
client_object_name = unicode(self.name).translate(
1675
1240
{ord("."): ord("_"),
1676
1241
ord("-"): ord("_")})
1677
self.dbus_object_path = dbus.ObjectPath(
1678
"/clients/" + client_object_name)
1242
self.dbus_object_path = (dbus.ObjectPath
1243
("/clients/" + client_object_name))
1679
1244
DBusObjectWithProperties.__init__(self, self.bus,
1680
1245
self.dbus_object_path)
1681
1246
1682
def notifychangeproperty(transform_func, dbus_name,
1683
type_func=lambda x: x,
1684
variant_level=1,
1685
invalidate_only=False,
1686
_interface=_interface):
1247
def notifychangeproperty(transform_func,
1248
dbus_name, type_func=lambda x: x,
1249
variant_level=1):
1687
1250
""" Modify a variable so that it's a property which announces
1688
1251
its changes to DBus.
1689
1252
1694
1257
to the D-Bus. Default: no transform
1695
1258
variant_level: D-Bus variant level. Default: 1
1696
1259
"""
1697
attrname = "_{}".format(dbus_name)
1698
1260
attrname = "_{0}".format(dbus_name)
1699
1261
def setter(self, value):
1700
1262
if hasattr(self, "dbus_object_path"):
1701
1263
if (not hasattr(self, attrname) or
1702
1264
type_func(getattr(self, attrname, None))
1703
1265
!= 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())
1266
dbus_value = transform_func(type_func(value),
1267
variant_level
1268
=variant_level)
1269
self.PropertyChanged(dbus.String(dbus_name),
1270
dbus_value)
1719
1271
setattr(self, attrname, value)
1720
1272
1721
1273
return property(lambda self: getattr(self, attrname), setter)
1727
1279
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1728
1280
last_enabled = notifychangeproperty(datetime_to_dbus,
1729
1281
"LastEnabled")
1730
checker = notifychangeproperty(
1731
dbus.Boolean, "CheckerRunning",
1732
type_func = lambda checker: checker is not None)
1282
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
1283
type_func = lambda checker:
1284
checker is not None)
1733
1285
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1734
1286
"LastCheckedOK")
1735
1287
last_checker_status = notifychangeproperty(dbus.Int16,
1738
1290
datetime_to_dbus, "LastApprovalRequest")
1739
1291
approved_by_default = notifychangeproperty(dbus.Boolean,
1740
1292
"ApprovedByDefault")
1741
approval_delay = notifychangeproperty(
1742
dbus.UInt64, "ApprovalDelay",
1743
type_func = lambda td: td.total_seconds() * 1000)
1293
approval_delay = notifychangeproperty(dbus.UInt64,
1294
"ApprovalDelay",
1295
type_func =
1296
timedelta_to_milliseconds)
1744
1297
approval_duration = notifychangeproperty(
1745
1298
dbus.UInt64, "ApprovalDuration",
1746
type_func = lambda td: td.total_seconds() * 1000)
1299
type_func = timedelta_to_milliseconds)
1747
1300
host = notifychangeproperty(dbus.String, "Host")
1748
timeout = notifychangeproperty(
1749
dbus.UInt64, "Timeout",
1750
type_func = lambda td: td.total_seconds() * 1000)
1301
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1302
type_func =
1303
timedelta_to_milliseconds)
1751
1304
extended_timeout = notifychangeproperty(
1752
1305
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)
1306
type_func = timedelta_to_milliseconds)
1307
interval = notifychangeproperty(dbus.UInt64,
1308
"Interval",
1309
type_func =
1310
timedelta_to_milliseconds)
1757
1311
checker_command = notifychangeproperty(dbus.String, "Checker")
1758
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1759
invalidate_only=True)
1760
1312
1761
1313
del notifychangeproperty
1762
1314
1769
1321
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1770
1322
Client.__del__(self, *args, **kwargs)
1771
1323
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:
1324
def checker_callback(self, pid, condition, command,
1325
*args, **kwargs):
1326
self.checker_callback_tag = None
1327
self.checker = None
1328
if os.WIFEXITED(condition):
1329
exitstatus = os.WEXITSTATUS(condition)
1779
1330
# Emit D-Bus signal
1780
1331
self.CheckerCompleted(dbus.Int16(exitstatus),
1781
# This is specific to GNU libC
1782
dbus.Int64(exitstatus << 8),
1332
dbus.Int64(condition),
1783
1333
dbus.String(command))
1784
1334
else:
1785
1335
# Emit D-Bus signal
1786
1336
self.CheckerCompleted(dbus.Int16(-1),
1787
dbus.Int64(
1788
# This is specific to GNU libC
1789
(exitstatus << 8)
1790
| self.last_checker_signal),
1337
dbus.Int64(condition),
1791
1338
dbus.String(command))
1792
return ret
1339
1340
return Client.checker_callback(self, pid, condition, command,
1341
*args, **kwargs)
1793
1342
1794
1343
def start_checker(self, *args, **kwargs):
1795
old_checker_pid = getattr(self.checker, "pid", None)
1344
old_checker = self.checker
1345
if self.checker is not None:
1346
old_checker_pid = self.checker.pid
1347
else:
1348
old_checker_pid = None
1796
1349
r = Client.start_checker(self, *args, **kwargs)
1797
1350
# Only if new checker process was started
1798
1351
if (self.checker is not None
1807
1360
1808
1361
def approve(self, value=True):
1809
1362
self.approved = value
1810
GObject.timeout_add(int(self.approval_duration.total_seconds()
1811
* 1000), self._reset_approved)
1363
gobject.timeout_add(timedelta_to_milliseconds
1364
(self.approval_duration),
1365
self._reset_approved)
1812
1366
self.send_changedstate()
1813
1367
1814
1368
## D-Bus methods, signals & properties
1369
_interface = "se.recompile.Mandos.Client"
1815
1370
1816
1371
## Interfaces
1817
1372
1373
@dbus_interface_annotations(_interface)
1374
def _foo(self):
1375
return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
1376
"false"}
1377
1818
1378
## Signals
1819
1379
1820
1380
# CheckerCompleted - signal
1830
1390
pass
1831
1391
1832
1392
# PropertyChanged - signal
1833
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1834
1393
@dbus.service.signal(_interface, signature="sv")
1835
1394
def PropertyChanged(self, property, value):
1836
1395
"D-Bus signal"
1870
1429
self.checked_ok()
1871
1430
1872
1431
# Enable - method
1873
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1874
1432
@dbus.service.method(_interface)
1875
1433
def Enable(self):
1876
1434
"D-Bus method"
1877
1435
self.enable()
1878
1436
1879
1437
# StartChecker - method
1880
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1881
1438
@dbus.service.method(_interface)
1882
1439
def StartChecker(self):
1883
1440
"D-Bus method"
1884
1441
self.start_checker()
1885
1442
1886
1443
# Disable - method
1887
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1888
1444
@dbus.service.method(_interface)
1889
1445
def Disable(self):
1890
1446
"D-Bus method"
1891
1447
self.disable()
1892
1448
1893
1449
# StopChecker - method
1894
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1895
1450
@dbus.service.method(_interface)
1896
1451
def StopChecker(self):
1897
1452
self.stop_checker()
1904
1459
return dbus.Boolean(bool(self.approvals_pending))
1905
1460
1906
1461
# ApprovedByDefault - property
1907
@dbus_service_property(_interface,
1908
signature="b",
1462
@dbus_service_property(_interface, signature="b",
1909
1463
access="readwrite")
1910
1464
def ApprovedByDefault_dbus_property(self, value=None):
1911
1465
if value is None: # get
1913
1467
self.approved_by_default = bool(value)
1914
1468
1915
1469
# ApprovalDelay - property
1916
@dbus_service_property(_interface,
1917
signature="t",
1470
@dbus_service_property(_interface, signature="t",
1918
1471
access="readwrite")
1919
1472
def ApprovalDelay_dbus_property(self, value=None):
1920
1473
if value is None: # get
1921
return dbus.UInt64(self.approval_delay.total_seconds()
1922
* 1000)
1474
return dbus.UInt64(self.approval_delay_milliseconds())
1923
1475
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1924
1476
1925
1477
# ApprovalDuration - property
1926
@dbus_service_property(_interface,
1927
signature="t",
1478
@dbus_service_property(_interface, signature="t",
1928
1479
access="readwrite")
1929
1480
def ApprovalDuration_dbus_property(self, value=None):
1930
1481
if value is None: # get
1931
return dbus.UInt64(self.approval_duration.total_seconds()
1932
* 1000)
1482
return dbus.UInt64(timedelta_to_milliseconds(
1483
self.approval_duration))
1933
1484
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1934
1485
1935
1486
# Name - property
1936
@dbus_annotations(
1937
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1938
1487
@dbus_service_property(_interface, signature="s", access="read")
1939
1488
def Name_dbus_property(self):
1940
1489
return dbus.String(self.name)
1941
1490
1942
1491
# Fingerprint - property
1943
@dbus_annotations(
1944
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1945
1492
@dbus_service_property(_interface, signature="s", access="read")
1946
1493
def Fingerprint_dbus_property(self):
1947
1494
return dbus.String(self.fingerprint)
1948
1495
1949
1496
# Host - property
1950
@dbus_service_property(_interface,
1951
signature="s",
1497
@dbus_service_property(_interface, signature="s",
1952
1498
access="readwrite")
1953
1499
def Host_dbus_property(self, value=None):
1954
1500
if value is None: # get
1955
1501
return dbus.String(self.host)
1956
self.host = str(value)
1502
self.host = unicode(value)
1957
1503
1958
1504
# Created - property
1959
@dbus_annotations(
1960
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1961
1505
@dbus_service_property(_interface, signature="s", access="read")
1962
1506
def Created_dbus_property(self):
1963
1507
return datetime_to_dbus(self.created)
1968
1512
return datetime_to_dbus(self.last_enabled)
1969
1513
1970
1514
# Enabled - property
1971
@dbus_service_property(_interface,
1972
signature="b",
1515
@dbus_service_property(_interface, signature="b",
1973
1516
access="readwrite")
1974
1517
def Enabled_dbus_property(self, value=None):
1975
1518
if value is None: # get
1980
1523
self.disable()
1981
1524
1982
1525
# LastCheckedOK - property
1983
@dbus_service_property(_interface,
1984
signature="s",
1526
@dbus_service_property(_interface, signature="s",
1985
1527
access="readwrite")
1986
1528
def LastCheckedOK_dbus_property(self, value=None):
1987
1529
if value is not None:
1990
1532
return datetime_to_dbus(self.last_checked_ok)
1991
1533
1992
1534
# LastCheckerStatus - property
1993
@dbus_service_property(_interface, signature="n", access="read")
1535
@dbus_service_property(_interface, signature="n",
1536
access="read")
1994
1537
def LastCheckerStatus_dbus_property(self):
1995
1538
return dbus.Int16(self.last_checker_status)
1996
1539
2005
1548
return datetime_to_dbus(self.last_approval_request)
2006
1549
2007
1550
# Timeout - property
2008
@dbus_service_property(_interface,
2009
signature="t",
1551
@dbus_service_property(_interface, signature="t",
2010
1552
access="readwrite")
2011
1553
def Timeout_dbus_property(self, value=None):
2012
1554
if value is None: # get
2013
return dbus.UInt64(self.timeout.total_seconds() * 1000)
1555
return dbus.UInt64(self.timeout_milliseconds())
2014
1556
old_timeout = self.timeout
2015
1557
self.timeout = datetime.timedelta(0, 0, 0, value)
2016
1558
# Reschedule disabling
2024
1566
if (getattr(self, "disable_initiator_tag", None)
2025
1567
is None):
2026
1568
return
2027
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)
1569
gobject.source_remove(self.disable_initiator_tag)
1570
self.disable_initiator_tag = (
1571
gobject.timeout_add(
1572
timedelta_to_milliseconds(self.expires - now),
1573
self.disable))
2031
1574
2032
1575
# ExtendedTimeout - property
2033
@dbus_service_property(_interface,
2034
signature="t",
1576
@dbus_service_property(_interface, signature="t",
2035
1577
access="readwrite")
2036
1578
def ExtendedTimeout_dbus_property(self, value=None):
2037
1579
if value is None: # get
2038
return dbus.UInt64(self.extended_timeout.total_seconds()
2039
* 1000)
1580
return dbus.UInt64(self.extended_timeout_milliseconds())
2040
1581
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
2041
1582
2042
1583
# Interval - property
2043
@dbus_service_property(_interface,
2044
signature="t",
1584
@dbus_service_property(_interface, signature="t",
2045
1585
access="readwrite")
2046
1586
def Interval_dbus_property(self, value=None):
2047
1587
if value is None: # get
2048
return dbus.UInt64(self.interval.total_seconds() * 1000)
1588
return dbus.UInt64(self.interval_milliseconds())
2049
1589
self.interval = datetime.timedelta(0, 0, 0, value)
2050
1590
if getattr(self, "checker_initiator_tag", None) is None:
2051
1591
return
2052
1592
if self.enabled:
2053
1593
# Reschedule checker run
2054
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
1594
gobject.source_remove(self.checker_initiator_tag)
1595
self.checker_initiator_tag = (gobject.timeout_add
1596
(value, self.start_checker))
1597
self.start_checker() # Start one now, too
2058
1598
2059
1599
# Checker - property
2060
@dbus_service_property(_interface,
2061
signature="s",
1600
@dbus_service_property(_interface, signature="s",
2062
1601
access="readwrite")
2063
1602
def Checker_dbus_property(self, value=None):
2064
1603
if value is None: # get
2065
1604
return dbus.String(self.checker_command)
2066
self.checker_command = str(value)
1605
self.checker_command = unicode(value)
2067
1606
2068
1607
# CheckerRunning - property
2069
@dbus_service_property(_interface,
2070
signature="b",
1608
@dbus_service_property(_interface, signature="b",
2071
1609
access="readwrite")
2072
1610
def CheckerRunning_dbus_property(self, value=None):
2073
1611
if value is None: # get
2078
1616
self.stop_checker()
2079
1617
2080
1618
# ObjectPath - property
2081
@dbus_annotations(
2082
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",
2083
"org.freedesktop.DBus.Deprecated": "true"})
2084
1619
@dbus_service_property(_interface, signature="o", access="read")
2085
1620
def ObjectPath_dbus_property(self):
2086
1621
return self.dbus_object_path # is already a dbus.ObjectPath
2087
1622
2088
1623
# 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)
1624
@dbus_service_property(_interface, signature="ay",
1625
access="write", byte_arrays=True)
2096
1626
def Secret_dbus_property(self, value):
2097
self.secret = bytes(value)
1627
self.secret = str(value)
2098
1628
2099
1629
del _interface
2100
1630
2104
1634
self._pipe = child_pipe
2105
1635
self._pipe.send(('init', fpr, address))
2106
1636
if not self._pipe.recv():
2107
raise KeyError(fpr)
1637
raise KeyError()
2108
1638
2109
1639
def __getattribute__(self, name):
2110
1640
if name == '_pipe':
2114
1644
if data[0] == 'data':
2115
1645
return data[1]
2116
1646
if data[0] == 'function':
2117
2118
1647
def func(*args, **kwargs):
2119
1648
self._pipe.send(('funcall', name, args, kwargs))
2120
1649
return self._pipe.recv()[1]
2121
2122
1650
return func
2123
1651
2124
1652
def __setattr__(self, name, value):
2136
1664
def handle(self):
2137
1665
with contextlib.closing(self.server.child_pipe) as child_pipe:
2138
1666
logger.info("TCP connection from: %s",
2139
str(self.client_address))
1667
unicode(self.client_address))
2140
1668
logger.debug("Pipe FD: %d",
2141
1669
self.server.child_pipe.fileno())
2142
1670
2143
session = gnutls.ClientSession(self.request)
1671
session = (gnutls.connection
1672
.ClientSession(self.request,
1673
gnutls.connection
1674
.X509Credentials()))
1675
1676
# Note: gnutls.connection.X509Credentials is really a
1677
# generic GnuTLS certificate credentials object so long as
1678
# no X.509 keys are added to it. Therefore, we can use it
1679
# here despite using OpenPGP certificates.
2144
1680
2145
1681
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
2146
1682
# "+AES-256-CBC", "+SHA1",
2150
1686
priority = self.server.gnutls_priority
2151
1687
if priority is None:
2152
1688
priority = "NORMAL"
2153
gnutls.priority_set_direct(session._c_object, priority,
2154
None)
1689
(gnutls.library.functions
1690
.gnutls_priority_set_direct(session._c_object,
1691
priority, None))
2155
1692
2156
1693
# Start communication using the Mandos protocol
2157
1694
# Get protocol number
2159
1696
logger.debug("Protocol version: %r", line)
2160
1697
try:
2161
1698
if int(line.strip().split()[0]) > 1:
2162
raise RuntimeError(line)
1699
raise RuntimeError
2163
1700
except (ValueError, IndexError, RuntimeError) as error:
2164
1701
logger.error("Unknown protocol version: %s", error)
2165
1702
return
2167
1704
# Start GnuTLS connection
2168
1705
try:
2169
1706
session.handshake()
2170
except gnutls.Error as error:
1707
except gnutls.errors.GNUTLSError as error:
2171
1708
logger.warning("Handshake failed: %s", error)
2172
1709
# Do not run session.bye() here: the session is not
2173
1710
# established. Just abandon the request.
2177
1714
approval_required = False
2178
1715
try:
2179
1716
try:
2180
fpr = self.fingerprint(
2181
self.peer_certificate(session))
2182
except (TypeError, gnutls.Error) as error:
1717
fpr = self.fingerprint(self.peer_certificate
1718
(session))
1719
except (TypeError,
1720
gnutls.errors.GNUTLSError) as error:
2183
1721
logger.warning("Bad certificate: %s", error)
2184
1722
return
2185
1723
logger.debug("Fingerprint: %s", fpr)
2198
1736
while True:
2199
1737
if not client.enabled:
2200
1738
logger.info("Client %s is disabled",
2201
client.name)
1739
client.name)
2202
1740
if self.server.use_dbus:
2203
1741
# Emit D-Bus signal
2204
1742
client.Rejected("Disabled")
2213
1751
if self.server.use_dbus:
2214
1752
# Emit D-Bus signal
2215
1753
client.NeedApproval(
2216
client.approval_delay.total_seconds()
2217
* 1000, client.approved_by_default)
1754
client.approval_delay_milliseconds(),
1755
client.approved_by_default)
2218
1756
else:
2219
1757
logger.warning("Client %s was not approved",
2220
1758
client.name)
2226
1764
#wait until timeout or approved
2227
1765
time = datetime.datetime.now()
2228
1766
client.changedstate.acquire()
2229
client.changedstate.wait(delay.total_seconds())
1767
client.changedstate.wait(
1768
float(timedelta_to_milliseconds(delay)
1769
/ 1000))
2230
1770
client.changedstate.release()
2231
1771
time2 = datetime.datetime.now()
2232
1772
if (time2 - time) >= delay:
2243
1783
else:
2244
1784
delay -= time2 - time
2245
1785
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
1786
sent_size = 0
1787
while sent_size < len(client.secret):
1788
try:
1789
sent = session.send(client.secret[sent_size:])
1790
except gnutls.errors.GNUTLSError as error:
1791
logger.warning("gnutls send failed",
1792
exc_info=error)
1793
return
1794
logger.debug("Sent: %d, remaining: %d",
1795
sent, len(client.secret)
1796
- (sent_size + sent))
1797
sent_size += sent
2252
1798
2253
1799
logger.info("Sending secret to %s", client.name)
2254
1800
# bump the timeout using extended_timeout
2262
1808
client.approvals_pending -= 1
2263
1809
try:
2264
1810
session.bye()
2265
except gnutls.Error as error:
1811
except gnutls.errors.GNUTLSError as error:
2266
1812
logger.warning("GnuTLS bye failed",
2267
1813
exc_info=error)
2268
1814
2270
1816
def peer_certificate(session):
2271
1817
"Return the peer's OpenPGP certificate as a bytestring"
2272
1818
# 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""
1819
if (gnutls.library.functions
1820
.gnutls_certificate_type_get(session._c_object)
1821
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1822
# ...do the normal thing
1823
return session.peer_certificate
2277
1824
list_size = ctypes.c_uint(1)
2278
cert_list = (gnutls.certificate_get_peers
1825
cert_list = (gnutls.library.functions
1826
.gnutls_certificate_get_peers
2279
1827
(session._c_object, ctypes.byref(list_size)))
2280
1828
if not bool(cert_list) and list_size.value != 0:
2281
raise gnutls.Error("error getting peer certificate")
1829
raise gnutls.errors.GNUTLSError("error getting peer"
1830
" certificate")
2282
1831
if list_size.value == 0:
2283
1832
return None
2284
1833
cert = cert_list[0]
2288
1837
def fingerprint(openpgp):
2289
1838
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
2290
1839
# 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)))
1840
datum = (gnutls.library.types
1841
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1842
ctypes.POINTER
1843
(ctypes.c_ubyte)),
1844
ctypes.c_uint(len(openpgp))))
2295
1845
# New empty GnuTLS certificate
2296
crt = gnutls.openpgp_crt_t()
2297
gnutls.openpgp_crt_init(ctypes.byref(crt))
1846
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1847
(gnutls.library.functions
1848
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
2298
1849
# Import the OpenPGP public key into the certificate
2299
gnutls.openpgp_crt_import(crt, ctypes.byref(datum),
2300
gnutls.OPENPGP_FMT_RAW)
1850
(gnutls.library.functions
1851
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1852
gnutls.library.constants
1853
.GNUTLS_OPENPGP_FMT_RAW))
2301
1854
# Verify the self signature in the key
2302
1855
crtverify = ctypes.c_uint()
2303
gnutls.openpgp_crt_verify_self(crt, 0,
2304
ctypes.byref(crtverify))
1856
(gnutls.library.functions
1857
.gnutls_openpgp_crt_verify_self(crt, 0,
1858
ctypes.byref(crtverify)))
2305
1859
if crtverify.value != 0:
2306
gnutls.openpgp_crt_deinit(crt)
2307
raise gnutls.CertificateSecurityError("Verify failed")
1860
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1861
raise (gnutls.errors.CertificateSecurityError
1862
("Verify failed"))
2308
1863
# New buffer for the fingerprint
2309
1864
buf = ctypes.create_string_buffer(20)
2310
1865
buf_len = ctypes.c_size_t()
2311
1866
# Get the fingerprint from the certificate into the buffer
2312
gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
2313
ctypes.byref(buf_len))
1867
(gnutls.library.functions
1868
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1869
ctypes.byref(buf_len)))
2314
1870
# Deinit the certificate
2315
gnutls.openpgp_crt_deinit(crt)
1871
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
2316
1872
# Convert the buffer to a Python bytestring
2317
1873
fpr = ctypes.string_at(buf, buf_len.value)
2318
1874
# Convert the bytestring to hexadecimal notation
2322
1878
2323
1879
class MultiprocessingMixIn(object):
2324
1880
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
2325
2326
1881
def sub_process_main(self, request, address):
2327
1882
try:
2328
1883
self.finish_request(request, address)
2340
1895
2341
1896
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
2342
1897
""" adds a pipe to the MixIn """
2343
2344
1898
def process_request(self, request, client_address):
2345
1899
"""Overrides and wraps the original process_request().
2346
1900
2355
1909
2356
1910
def add_pipe(self, parent_pipe, proc):
2357
1911
"""Dummy function; override as necessary"""
2358
raise NotImplementedError()
1912
raise NotImplementedError
2359
1913
2360
1914
2361
1915
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2367
1921
interface: None or a network interface name (string)
2368
1922
use_ipv6: Boolean; to use IPv6 or not
2369
1923
"""
2370
2371
1924
def __init__(self, server_address, RequestHandlerClass,
2372
interface=None,
2373
use_ipv6=True,
2374
socketfd=None):
1925
interface=None, use_ipv6=True, socketfd=None):
2375
1926
"""If socketfd is set, use that file descriptor instead of
2376
1927
creating a new one with socket.socket().
2377
1928
"""
2418
1969
self.interface)
2419
1970
else:
2420
1971
try:
2421
self.socket.setsockopt(
2422
socket.SOL_SOCKET, SO_BINDTODEVICE,
2423
(self.interface + "\0").encode("utf-8"))
1972
self.socket.setsockopt(socket.SOL_SOCKET,
1973
SO_BINDTODEVICE,
1974
str(self.interface + '\0'))
2424
1975
except socket.error as error:
2425
1976
if error.errno == errno.EPERM:
2426
1977
logger.error("No permission to bind to"
2444
1995
self.server_address = (any_address,
2445
1996
self.server_address[1])
2446
1997
elif not self.server_address[1]:
2447
self.server_address = (self.server_address[0], 0)
1998
self.server_address = (self.server_address[0],
1999
0)
2448
2000
# if self.interface:
2449
2001
# self.server_address = (self.server_address[0],
2450
2002
# 0, # port
2462
2014
gnutls_priority GnuTLS priority string
2463
2015
use_dbus: Boolean; to emit D-Bus signals or not
2464
2016
2465
Assumes a GObject.MainLoop event loop.
2017
Assumes a gobject.MainLoop event loop.
2466
2018
"""
2467
2468
2019
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):
2020
interface=None, use_ipv6=True, clients=None,
2021
gnutls_priority=None, use_dbus=True, socketfd=None):
2475
2022
self.enabled = False
2476
2023
self.clients = clients
2477
2024
if self.clients is None:
2483
2030
interface = interface,
2484
2031
use_ipv6 = use_ipv6,
2485
2032
socketfd = socketfd)
2486
2487
2033
def server_activate(self):
2488
2034
if self.enabled:
2489
2035
return socketserver.TCPServer.server_activate(self)
2493
2039
2494
2040
def add_pipe(self, parent_pipe, proc):
2495
2041
# 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))
2042
gobject.io_add_watch(parent_pipe.fileno(),
2043
gobject.IO_IN | gobject.IO_HUP,
2044
functools.partial(self.handle_ipc,
2045
parent_pipe =
2046
parent_pipe,
2047
proc = proc))
2502
2048
2503
def handle_ipc(self, source, condition,
2504
parent_pipe=None,
2505
proc = None,
2506
client_object=None):
2049
def handle_ipc(self, source, condition, parent_pipe=None,
2050
proc = None, client_object=None):
2507
2051
# error, or the other end of multiprocessing.Pipe has closed
2508
if condition & (GObject.IO_ERR | GObject.IO_HUP):
2052
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2509
2053
# Wait for other process to exit
2510
2054
proc.join()
2511
2055
return False
2532
2076
parent_pipe.send(False)
2533
2077
return False
2534
2078
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))
2079
gobject.io_add_watch(parent_pipe.fileno(),
2080
gobject.IO_IN | gobject.IO_HUP,
2081
functools.partial(self.handle_ipc,
2082
parent_pipe =
2083
parent_pipe,
2084
proc = proc,
2085
client_object =
2086
client))
2542
2087
parent_pipe.send(True)
2543
2088
# remove the old hook in favor of the new above hook on
2544
2089
# same fileno
2550
2095
2551
2096
parent_pipe.send(('data', getattr(client_object,
2552
2097
funcname)(*args,
2553
**kwargs)))
2098
**kwargs)))
2554
2099
2555
2100
if command == 'getattr':
2556
2101
attrname = request[1]
2557
if isinstance(client_object.__getattribute__(attrname),
2558
collections.Callable):
2559
parent_pipe.send(('function', ))
2102
if callable(client_object.__getattribute__(attrname)):
2103
parent_pipe.send(('function',))
2560
2104
else:
2561
parent_pipe.send((
2562
'data', client_object.__getattribute__(attrname)))
2105
parent_pipe.send(('data', client_object
2106
.__getattribute__(attrname)))
2563
2107
2564
2108
if command == 'setattr':
2565
2109
attrname = request[1]
2596
2140
# avoid excessive use of external libraries.
2597
2141
2598
2142
# 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
2143
Token = collections.namedtuple("Token",
2144
("regexp", # To match token; if
2145
# "value" is not None,
2146
# must have a "group"
2147
# containing digits
2148
"value", # datetime.timedelta or
2149
# None
2150
"followers")) # Tokens valid after
2151
# this token
2604
2152
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2605
2153
# the "duration" ABNF definition in RFC 3339, Appendix A.
2606
2154
token_end = Token(re.compile(r"$"), None, frozenset())
2607
2155
token_second = Token(re.compile(r"(\d+)S"),
2608
2156
datetime.timedelta(seconds=1),
2609
frozenset((token_end, )))
2157
frozenset((token_end,)))
2610
2158
token_minute = Token(re.compile(r"(\d+)M"),
2611
2159
datetime.timedelta(minutes=1),
2612
2160
frozenset((token_second, token_end)))
2628
2176
frozenset((token_month, token_end)))
2629
2177
token_week = Token(re.compile(r"(\d+)W"),
2630
2178
datetime.timedelta(weeks=1),
2631
frozenset((token_end, )))
2179
frozenset((token_end,)))
2632
2180
token_duration = Token(re.compile(r"P"), None,
2633
2181
frozenset((token_year, token_month,
2634
2182
token_day, token_time,
2635
token_week)))
2183
token_week))),
2636
2184
# Define starting values
2637
2185
value = datetime.timedelta() # Value so far
2638
2186
found_token = None
2639
followers = frozenset((token_duration, )) # Following valid tokens
2187
followers = frozenset(token_duration,) # Following valid tokens
2640
2188
s = duration # String left to parse
2641
2189
# Loop until end token is found
2642
2190
while found_token is not token_end:
2659
2207
break
2660
2208
else:
2661
2209
# No currently valid tokens were found
2662
raise ValueError("Invalid RFC 3339 duration: {!r}"
2663
.format(duration))
2210
raise ValueError("Invalid RFC 3339 duration")
2664
2211
# End token found
2665
2212
return value
2666
2213
2690
2237
timevalue = datetime.timedelta(0)
2691
2238
for s in interval.split():
2692
2239
try:
2693
suffix = s[-1]
2240
suffix = unicode(s[-1])
2694
2241
value = int(s[:-1])
2695
2242
if suffix == "d":
2696
2243
delta = datetime.timedelta(value)
2703
2250
elif suffix == "w":
2704
2251
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2705
2252
else:
2706
raise ValueError("Unknown suffix {!r}".format(suffix))
2707
except IndexError as e:
2253
raise ValueError("Unknown suffix {0!r}"
2254
.format(suffix))
2255
except (ValueError, IndexError) as e:
2708
2256
raise ValueError(*(e.args))
2709
2257
timevalue += delta
2710
2258
return timevalue
2726
2274
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2727
2275
if not stat.S_ISCHR(os.fstat(null).st_mode):
2728
2276
raise OSError(errno.ENODEV,
2729
"{} not a character device"
2277
"{0} not a character device"
2730
2278
.format(os.devnull))
2731
2279
os.dup2(null, sys.stdin.fileno())
2732
2280
os.dup2(null, sys.stdout.fileno())
2742
2290
2743
2291
parser = argparse.ArgumentParser()
2744
2292
parser.add_argument("-v", "--version", action="version",
2745
version = "%(prog)s {}".format(version),
2293
version = "%(prog)s {0}".format(version),
2746
2294
help="show version number and exit")
2747
2295
parser.add_argument("-i", "--interface", metavar="IF",
2748
2296
help="Bind to interface IF")
2781
2329
help="Directory to save/restore state in")
2782
2330
parser.add_argument("--foreground", action="store_true",
2783
2331
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
2332
2788
2333
options = parser.parse_args()
2789
2334
2790
2335
if options.check:
2791
2336
import doctest
2792
fail_count, test_count = doctest.testmod()
2793
sys.exit(os.EX_OK if fail_count == 0 else 1)
2337
doctest.testmod()
2338
sys.exit()
2794
2339
2795
2340
# Default values for config file for server-global settings
2796
2341
server_defaults = { "interface": "",
2798
2343
"port": "",
2799
2344
"debug": "False",
2800
2345
"priority":
2801
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2802
":+SIGN-DSA-SHA256",
2346
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224",
2803
2347
"servicename": "Mandos",
2804
2348
"use_dbus": "True",
2805
2349
"use_ipv6": "True",
2808
2352
"socket": "",
2809
2353
"statedir": "/var/lib/mandos",
2810
2354
"foreground": "False",
2811
"zeroconf": "True",
2812
}
2355
}
2813
2356
2814
2357
# Parse config file for server-global settings
2815
2358
server_config = configparser.SafeConfigParser(server_defaults)
2816
2359
del server_defaults
2817
server_config.read(os.path.join(options.configdir, "mandos.conf"))
2360
server_config.read(os.path.join(options.configdir,
2361
"mandos.conf"))
2818
2362
# Convert the SafeConfigParser object to a dict
2819
2363
server_settings = server_config.defaults()
2820
2364
# Use the appropriate methods on the non-string config options
2838
2382
# Override the settings from the config file with command line
2839
2383
# options, if set.
2840
2384
for option in ("interface", "address", "port", "debug",
2841
"priority", "servicename", "configdir", "use_dbus",
2842
"use_ipv6", "debuglevel", "restore", "statedir",
2843
"socket", "foreground", "zeroconf"):
2385
"priority", "servicename", "configdir",
2386
"use_dbus", "use_ipv6", "debuglevel", "restore",
2387
"statedir", "socket", "foreground"):
2844
2388
value = getattr(options, option)
2845
2389
if value is not None:
2846
2390
server_settings[option] = value
2847
2391
del options
2848
2392
# Force all strings to be unicode
2849
2393
for option in server_settings.keys():
2850
if isinstance(server_settings[option], bytes):
2851
server_settings[option] = (server_settings[option]
2852
.decode("utf-8"))
2394
if type(server_settings[option]) is str:
2395
server_settings[option] = unicode(server_settings[option])
2853
2396
# Force all boolean options to be boolean
2854
2397
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2855
"foreground", "zeroconf"):
2398
"foreground"):
2856
2399
server_settings[option] = bool(server_settings[option])
2857
2400
# Debug implies foreground
2858
2401
if server_settings["debug"]:
2861
2404
2862
2405
##################################################################
2863
2406
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
2407
# For convenience
2870
2408
debug = server_settings["debug"]
2871
2409
debuglevel = server_settings["debuglevel"]
2874
2412
stored_state_path = os.path.join(server_settings["statedir"],
2875
2413
stored_state_file)
2876
2414
foreground = server_settings["foreground"]
2877
zeroconf = server_settings["zeroconf"]
2878
2415
2879
2416
if debug:
2880
2417
initlogger(debug, logging.DEBUG)
2886
2423
initlogger(debug, level)
2887
2424
2888
2425
if server_settings["servicename"] != "Mandos":
2889
syslogger.setFormatter(
2890
logging.Formatter('Mandos ({}) [%(process)d]:'
2891
' %(levelname)s: %(message)s'.format(
2892
server_settings["servicename"])))
2426
syslogger.setFormatter(logging.Formatter
2427
('Mandos ({0}) [%(process)d]:'
2428
' %(levelname)s: %(message)s'
2429
.format(server_settings
2430
["servicename"])))
2893
2431
2894
2432
# Parse config file with clients
2895
2433
client_config = configparser.SafeConfigParser(Client
2900
2438
global mandos_dbus_service
2901
2439
mandos_dbus_service = None
2902
2440
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)
2441
tcp_server = MandosServer((server_settings["address"],
2442
server_settings["port"]),
2443
ClientHandler,
2444
interface=(server_settings["interface"]
2445
or None),
2446
use_ipv6=use_ipv6,
2447
gnutls_priority=
2448
server_settings["priority"],
2449
use_dbus=use_dbus,
2450
socketfd=(server_settings["socket"]
2451
or None))
2914
2452
if not foreground:
2915
pidfilename = "/run/mandos.pid"
2916
if not os.path.isdir("/run/."):
2917
pidfilename = "/var/run/mandos.pid"
2453
pidfilename = "/var/run/mandos.pid"
2918
2454
pidfile = None
2919
2455
try:
2920
pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
2456
pidfile = open(pidfilename, "w")
2921
2457
except IOError as e:
2922
2458
logger.error("Could not open file %r", pidfilename,
2923
2459
exc_info=e)
2924
2460
2925
for name, group in (("_mandos", "_mandos"),
2926
("mandos", "mandos"),
2927
("nobody", "nogroup")):
2461
for name in ("_mandos", "mandos", "nobody"):
2928
2462
try:
2929
2463
uid = pwd.getpwnam(name).pw_uid
2930
gid = pwd.getpwnam(group).pw_gid
2464
gid = pwd.getpwnam(name).pw_gid
2931
2465
break
2932
2466
except KeyError:
2933
2467
continue
2939
2473
os.setuid(uid)
2940
2474
except OSError as error:
2941
2475
if error.errno != errno.EPERM:
2942
raise
2476
raise error
2943
2477
2944
2478
if debug:
2945
2479
# Enable all possible GnuTLS debugging
2946
2480
2947
2481
# "Use a log level over 10 to enable all debugging options."
2948
2482
# - GnuTLS manual
2949
gnutls.global_set_log_level(11)
2483
gnutls.library.functions.gnutls_global_set_log_level(11)
2950
2484
2951
@gnutls.log_func
2485
@gnutls.library.types.gnutls_log_func
2952
2486
def debug_gnutls(level, string):
2953
2487
logger.debug("GnuTLS: %s", string[:-1])
2954
2488
2955
gnutls.global_set_log_function(debug_gnutls)
2489
(gnutls.library.functions
2490
.gnutls_global_set_log_function(debug_gnutls))
2956
2491
2957
2492
# Redirect stdin so all checkers get /dev/null
2958
2493
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2965
2500
# Close all input and output, do double fork, etc.
2966
2501
daemon()
2967
2502
2968
# multiprocessing will use threads, so before we use GObject we
2969
# need to inform GObject that threads will be used.
2970
GObject.threads_init()
2503
# multiprocessing will use threads, so before we use gobject we
2504
# need to inform gobject that threads will be used.
2505
gobject.threads_init()
2971
2506
2972
2507
global main_loop
2973
2508
# From the Avahi example code
2974
2509
DBusGMainLoop(set_as_default=True)
2975
main_loop = GObject.MainLoop()
2510
main_loop = gobject.MainLoop()
2976
2511
bus = dbus.SystemBus()
2977
2512
# End of Avahi example code
2978
2513
if use_dbus:
2979
2514
try:
2980
2515
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:
2516
bus, do_not_queue=True)
2517
old_bus_name = (dbus.service.BusName
2518
("se.bsnet.fukt.Mandos", bus,
2519
do_not_queue=True))
2520
except dbus.exceptions.NameExistsException as e:
2987
2521
logger.error("Disabling D-Bus:", exc_info=e)
2988
2522
use_dbus = False
2989
2523
server_settings["use_dbus"] = False
2990
2524
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"))
2525
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2526
service = AvahiServiceToSyslog(name =
2527
server_settings["servicename"],
2528
servicetype = "_mandos._tcp",
2529
protocol = protocol, bus = bus)
2530
if server_settings["interface"]:
2531
service.interface = (if_nametoindex
2532
(str(server_settings["interface"])))
3001
2533
3002
2534
global multiprocessing_manager
3003
2535
multiprocessing_manager = multiprocessing.Manager()
3022
2554
if server_settings["restore"]:
3023
2555
try:
3024
2556
with open(stored_state_path, "rb") as stored_state:
3025
clients_data, old_client_settings = pickle.load(
3026
stored_state)
2557
clients_data, old_client_settings = (pickle.load
2558
(stored_state))
3027
2559
os.remove(stored_state_path)
3028
2560
except IOError as e:
3029
2561
if e.errno == errno.ENOENT:
3030
logger.warning("Could not load persistent state:"
3031
" {}".format(os.strerror(e.errno)))
2562
logger.warning("Could not load persistent state: {0}"
2563
.format(os.strerror(e.errno)))
3032
2564
else:
3033
2565
logger.critical("Could not load persistent state:",
3034
2566
exc_info=e)
3035
2567
raise
3036
2568
except EOFError as e:
3037
2569
logger.warning("Could not load persistent state: "
3038
"EOFError:",
3039
exc_info=e)
2570
"EOFError:", exc_info=e)
3040
2571
3041
2572
with PGPEngine() as pgp:
3042
for client_name, client in clients_data.items():
2573
for client_name, client in clients_data.iteritems():
3043
2574
# Skip removed clients
3044
2575
if client_name not in client_settings:
3045
2576
continue
3054
2585
# For each value in new config, check if it
3055
2586
# differs from the old config value (Except for
3056
2587
# the "secret" attribute)
3057
if (name != "secret"
3058
and (value !=
3059
old_client_settings[client_name][name])):
2588
if (name != "secret" and
2589
value != old_client_settings[client_name]
2590
[name]):
3060
2591
client[name] = value
3061
2592
except KeyError:
3062
2593
pass
3063
2594
3064
2595
# Clients who has passed its expire date can still be
3065
# enabled if its last checker was successful. A Client
2596
# enabled if its last checker was successful. Clients
3066
2597
# whose checker succeeded before we stored its state is
3067
2598
# assumed to have successfully run all checkers during
3068
2599
# downtime.
3070
2601
if datetime.datetime.utcnow() >= client["expires"]:
3071
2602
if not client["last_checked_ok"]:
3072
2603
logger.warning(
3073
"disabling client {} - Client never "
3074
"performed a successful checker".format(
3075
client_name))
2604
"disabling client {0} - Client never "
2605
"performed a successful checker"
2606
.format(client_name))
3076
2607
client["enabled"] = False
3077
2608
elif client["last_checker_status"] != 0:
3078
2609
logger.warning(
3079
"disabling client {} - Client last"
3080
" checker failed with error code"
3081
" {}".format(
3082
client_name,
3083
client["last_checker_status"]))
2610
"disabling client {0} - Client "
2611
"last checker failed with error code {1}"
2612
.format(client_name,
2613
client["last_checker_status"]))
3084
2614
client["enabled"] = False
3085
2615
else:
3086
client["expires"] = (
3087
datetime.datetime.utcnow()
3088
+ client["timeout"])
2616
client["expires"] = (datetime.datetime
2617
.utcnow()
2618
+ client["timeout"])
3089
2619
logger.debug("Last checker succeeded,"
3090
" keeping {} enabled".format(
3091
client_name))
2620
" keeping {0} enabled"
2621
.format(client_name))
3092
2622
try:
3093
client["secret"] = pgp.decrypt(
3094
client["encrypted_secret"],
3095
client_settings[client_name]["secret"])
2623
client["secret"] = (
2624
pgp.decrypt(client["encrypted_secret"],
2625
client_settings[client_name]
2626
["secret"]))
3096
2627
except PGPError:
3097
2628
# 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"])
2629
logger.debug("Failed to decrypt {0} old secret"
2630
.format(client_name))
2631
client["secret"] = (
2632
client_settings[client_name]["secret"])
3102
2633
3103
2634
# Add/remove clients based on new changes made to config
3104
2635
for client_name in (set(old_client_settings)
3109
2640
clients_data[client_name] = client_settings[client_name]
3110
2641
3111
2642
# Create all client objects
3112
for client_name, client in clients_data.items():
2643
for client_name, client in clients_data.iteritems():
3113
2644
tcp_server.clients[client_name] = client_class(
3114
name = client_name,
3115
settings = client,
2645
name = client_name, settings = client,
3116
2646
server_settings = server_settings)
3117
2647
3118
2648
if not tcp_server.clients:
3120
2650
3121
2651
if not foreground:
3122
2652
if pidfile is not None:
3123
pid = os.getpid()
3124
2653
try:
3125
2654
with pidfile:
3126
print(pid, file=pidfile)
2655
pid = os.getpid()
2656
pidfile.write(str(pid) + "\n".encode("utf-8"))
3127
2657
except IOError:
3128
2658
logger.error("Could not write to file %r with PID %d",
3129
2659
pidfilename, pid)
3134
2664
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
3135
2665
3136
2666
if use_dbus:
3137
3138
@alternate_dbus_interfaces(
3139
{ "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })
3140
class MandosDBusService(DBusObjectWithObjectManager):
2667
@alternate_dbus_interfaces({"se.recompile.Mandos":
2668
"se.bsnet.fukt.Mandos"})
2669
class MandosDBusService(DBusObjectWithProperties):
3141
2670
"""A D-Bus proxy object"""
3142
3143
2671
def __init__(self):
3144
2672
dbus.service.Object.__init__(self, bus, "/")
3145
3146
2673
_interface = "se.recompile.Mandos"
3147
2674
2675
@dbus_interface_annotations(_interface)
2676
def _foo(self):
2677
return { "org.freedesktop.DBus.Property"
2678
".EmitsChangedSignal":
2679
"false"}
2680
3148
2681
@dbus.service.signal(_interface, signature="o")
3149
2682
def ClientAdded(self, objpath):
3150
2683
"D-Bus signal"
3155
2688
"D-Bus signal"
3156
2689
pass
3157
2690
3158
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3159
"true"})
3160
2691
@dbus.service.signal(_interface, signature="os")
3161
2692
def ClientRemoved(self, objpath, name):
3162
2693
"D-Bus signal"
3163
2694
pass
3164
2695
3165
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3166
"true"})
3167
2696
@dbus.service.method(_interface, out_signature="ao")
3168
2697
def GetAllClients(self):
3169
2698
"D-Bus method"
3170
return dbus.Array(c.dbus_object_path for c in
2699
return dbus.Array(c.dbus_object_path
2700
for c in
3171
2701
tcp_server.clients.itervalues())
3172
2702
3173
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3174
"true"})
3175
2703
@dbus.service.method(_interface,
3176
2704
out_signature="a{oa{sv}}")
3177
2705
def GetAllClientsWithProperties(self):
3178
2706
"D-Bus method"
3179
2707
return dbus.Dictionary(
3180
{ c.dbus_object_path: c.GetAll(
3181
"se.recompile.Mandos.Client")
3182
for c in tcp_server.clients.itervalues() },
2708
((c.dbus_object_path, c.GetAll(""))
2709
for c in tcp_server.clients.itervalues()),
3183
2710
signature="oa{sv}")
3184
2711
3185
2712
@dbus.service.method(_interface, in_signature="o")
3189
2716
if c.dbus_object_path == object_path:
3190
2717
del tcp_server.clients[c.name]
3191
2718
c.remove_from_connection()
3192
# Don't signal the disabling
2719
# Don't signal anything except ClientRemoved
3193
2720
c.disable(quiet=True)
3194
# Emit D-Bus signal for removal
3195
self.client_removed_signal(c)
2721
# Emit D-Bus signal
2722
self.ClientRemoved(object_path, c.name)
3196
2723
return
3197
2724
raise KeyError(object_path)
3198
2725
3199
2726
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
2727
3237
2728
mandos_dbus_service = MandosDBusService()
3238
2729
3239
2730
def cleanup():
3240
2731
"Cleanup function; run on exit"
3241
if zeroconf:
3242
service.cleanup()
2732
service.cleanup()
3243
2733
3244
2734
multiprocessing.active_children()
3245
2735
wnull.close()
3259
2749
3260
2750
# A list of attributes that can not be pickled
3261
2751
# + secret.
3262
exclude = { "bus", "changedstate", "secret",
3263
"checker", "server_settings" }
3264
for name, typ in inspect.getmembers(dbus.service
3265
.Object):
2752
exclude = set(("bus", "changedstate", "secret",
2753
"checker", "server_settings"))
2754
for name, typ in (inspect.getmembers
2755
(dbus.service.Object)):
3266
2756
exclude.add(name)
3267
2757
3268
2758
client_dict["encrypted_secret"] = (client
3275
2765
del client_settings[client.name]["secret"]
3276
2766
3277
2767
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:
2768
with (tempfile.NamedTemporaryFile
2769
(mode='wb', suffix=".pickle", prefix='clients-',
2770
dir=os.path.dirname(stored_state_path),
2771
delete=False)) as stored_state:
3284
2772
pickle.dump((clients, client_settings), stored_state)
3285
tempname = stored_state.name
2773
tempname=stored_state.name
3286
2774
os.rename(tempname, stored_state_path)
3287
2775
except (IOError, OSError) as e:
3288
2776
if not debug:
3291
2779
except NameError:
3292
2780
pass
3293
2781
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
3294
logger.warning("Could not save persistent state: {}"
2782
logger.warning("Could not save persistent state: {0}"
3295
2783
.format(os.strerror(e.errno)))
3296
2784
else:
3297
2785
logger.warning("Could not save persistent state:",
3298
2786
exc_info=e)
3299
raise
2787
raise e
3300
2788
3301
2789
# Delete all clients, and settings from config
3302
2790
while tcp_server.clients:
3303
2791
name, client = tcp_server.clients.popitem()
3304
2792
if use_dbus:
3305
2793
client.remove_from_connection()
3306
# Don't signal the disabling
2794
# Don't signal anything except ClientRemoved
3307
2795
client.disable(quiet=True)
3308
# Emit D-Bus signal for removal
3309
2796
if use_dbus:
3310
mandos_dbus_service.client_removed_signal(client)
2797
# Emit D-Bus signal
2798
mandos_dbus_service.ClientRemoved(client
2799
.dbus_object_path,
2800
client.name)
3311
2801
client_settings.clear()
3312
2802
3313
2803
atexit.register(cleanup)
3314
2804
3315
2805
for client in tcp_server.clients.itervalues():
3316
2806
if use_dbus:
3317
# Emit D-Bus signal for adding
3318
mandos_dbus_service.client_added_signal(client)
2807
# Emit D-Bus signal
2808
mandos_dbus_service.ClientAdded(client.dbus_object_path)
3319
2809
# Need to initiate checking of clients
3320
2810
if client.enabled:
3321
2811
client.init_checker()
3324
2814
tcp_server.server_activate()
3325
2815
3326
2816
# Find out what port we got
3327
if zeroconf:
3328
service.port = tcp_server.socket.getsockname()[1]
2817
service.port = tcp_server.socket.getsockname()[1]
3329
2818
if use_ipv6:
3330
2819
logger.info("Now listening on address %r, port %d,"
3331
2820
" flowinfo %d, scope_id %d",
3337
2826
#service.interface = tcp_server.socket.getsockname()[3]
3338
2827
3339
2828
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
2829
# From the Avahi example code
2830
try:
2831
service.activate()
2832
except dbus.exceptions.DBusException as error:
2833
logger.critical("D-Bus Exception", exc_info=error)
2834
cleanup()
2835
sys.exit(1)
2836
# End of Avahi example code
3349
2837
3350
GObject.io_add_watch(tcp_server.fileno(), GObject.IO_IN,
2838
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
3351
2839
lambda *args, **kwargs:
3352
2840
(tcp_server.handle_request
3353
2841
(*args[2:], **kwargs) or True))
3366
2854
# Must run before the D-Bus bus name gets deregistered
3367
2855
cleanup()
3368
2856
3369
3370
2857
if __name__ == '__main__':
3371
2858
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0