To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 237.7.709
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.709
- Committer: Teddy Hogeborn
- Date: 2019-08-18 04:14:31 UTC
- mto: This revision was merged to the branch mainline in revision 390.
- Revision ID: teddy@recompile.se-20190818041431-jgt8pizlzjvxalj0
Debian package: Client: Install the systemd sysusers.d file
* debian/mandos-client.dirs (usr/lib/sysusers.d): New.
* debian/mandos-client.dirs (usr/lib/sysusers.d): New.
- files added:
- bugs.xml
- debian/tests
- dracut-module
- files removed:
- initramfs-tools-hook-conf
- files modified:
- .bzrignore
added
removed
mandos
1
1
#!/usr/bin/python
2
2
# -*- mode: python; coding: utf-8 -*-
3
#
3
#
4
4
# Mandos server - give out binary blobs to connecting clients.
5
#
5
#
6
6
# This program is partly derived from an example program for an Avahi
7
7
# service publisher, downloaded from
8
8
# <http://avahi.org/wiki/PythonPublishExample>. This includes the
9
9
# methods "add", "remove", "server_state_changed",
10
10
# "entry_group_state_changed", "cleanup", and "activate" in the
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
16
#
17
# This program is free software: you can redistribute it and/or modify
18
# it under the terms of the GNU General Public License as published by
14
# Copyright © 2008-2019 Teddy Hogeborn
15
# Copyright © 2008-2019 Björn Påhlsson
16
#
17
# This file is part of Mandos.
18
#
19
# Mandos is free software: you can redistribute it and/or modify it
20
# under the terms of the GNU General Public License as published by
19
21
# the Free Software Foundation, either version 3 of the License, or
20
22
# (at your option) any later version.
21
23
#
22
# This program is distributed in the hope that it will be useful,
23
# but WITHOUT ANY WARRANTY; without even the implied warranty of
24
# Mandos is distributed in the hope that it will be useful, but
25
# WITHOUT ANY WARRANTY; without even the implied warranty of
24
26
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25
27
# GNU General Public License for more details.
26
#
28
#
27
29
# You should have received a copy of the GNU General Public License
28
# along with this program. If not, see
29
# <http://www.gnu.org/licenses/>.
30
#
30
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
31
#
31
32
# Contact the authors at <mandos@recompile.se>.
32
#
33
#
33
34
34
35
from __future__ import (division, absolute_import, print_function,
35
36
unicode_literals)
36
37
37
from future_builtins import *
38
try:
39
from future_builtins import *
40
except ImportError:
41
pass
38
42
39
43
try:
40
44
import SocketServer as socketserver
76
80
77
81
import dbus
78
82
import dbus.service
79
try:
80
import gobject
81
except ImportError:
82
from gi.repository import GObject as gobject
83
import avahi
83
import gi
84
from gi.repository import GLib
84
85
from dbus.mainloop.glib import DBusGMainLoop
85
86
import ctypes
86
87
import ctypes.util
87
88
import xml.dom.minidom
88
89
import inspect
89
90
91
if sys.version_info.major == 2:
92
__metaclass__ = type
93
94
# Try to find the value of SO_BINDTODEVICE:
90
95
try:
96
# This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
97
# newer, and it is also the most natural place for it:
91
98
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
92
99
except AttributeError:
93
100
try:
101
# This is where SO_BINDTODEVICE was up to and including Python
102
# 2.6, and also 3.2:
94
103
from IN import SO_BINDTODEVICE
95
104
except ImportError:
96
SO_BINDTODEVICE = None
105
# In Python 2.7 it seems to have been removed entirely.
106
# Try running the C preprocessor:
107
try:
108
cc = subprocess.Popen(["cc", "--language=c", "-E",
109
"/dev/stdin"],
110
stdin=subprocess.PIPE,
111
stdout=subprocess.PIPE)
112
stdout = cc.communicate(
113
"#include <sys/socket.h>\nSO_BINDTODEVICE\n")[0]
114
SO_BINDTODEVICE = int(stdout.splitlines()[-1])
115
except (OSError, ValueError, IndexError):
116
# No value found
117
SO_BINDTODEVICE = None
97
118
98
119
if sys.version_info.major == 2:
99
120
str = unicode
100
121
101
version = "1.7.1"
122
if sys.version_info < (3, 2):
123
configparser.Configparser = configparser.SafeConfigParser
124
125
version = "1.8.7"
102
126
stored_state_file = "clients.pickle"
103
127
104
128
logger = logging.getLogger()
108
132
if_nametoindex = ctypes.cdll.LoadLibrary(
109
133
ctypes.util.find_library("c")).if_nametoindex
110
134
except (OSError, AttributeError):
111
135
112
136
def if_nametoindex(interface):
113
137
"Get an interface index the hard way, i.e. using fcntl()"
114
138
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
119
143
return interface_index
120
144
121
145
146
def copy_function(func):
147
"""Make a copy of a function"""
148
if sys.version_info.major == 2:
149
return types.FunctionType(func.func_code,
150
func.func_globals,
151
func.func_name,
152
func.func_defaults,
153
func.func_closure)
154
else:
155
return types.FunctionType(func.__code__,
156
func.__globals__,
157
func.__name__,
158
func.__defaults__,
159
func.__closure__)
160
161
122
162
def initlogger(debug, level=logging.WARNING):
123
163
"""init logger and add loglevel"""
124
164
125
165
global syslogger
126
166
syslogger = (logging.handlers.SysLogHandler(
127
facility = logging.handlers.SysLogHandler.LOG_DAEMON,
128
address = "/dev/log"))
167
facility=logging.handlers.SysLogHandler.LOG_DAEMON,
168
address="/dev/log"))
129
169
syslogger.setFormatter(logging.Formatter
130
170
('Mandos [%(process)d]: %(levelname)s:'
131
171
' %(message)s'))
132
172
logger.addHandler(syslogger)
133
173
134
174
if debug:
135
175
console = logging.StreamHandler()
136
176
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
146
186
pass
147
187
148
188
149
class PGPEngine(object):
189
class PGPEngine:
150
190
"""A simple class for OpenPGP symmetric encryption & decryption"""
151
191
152
192
def __init__(self):
153
193
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
154
194
self.gpg = "gpg"
155
195
try:
156
196
output = subprocess.check_output(["gpgconf"])
157
197
for line in output.splitlines():
158
name, text, path = line.split(":")
198
name, text, path = line.split(b":")
159
199
if name == "gpg":
160
200
self.gpg = path
161
201
break
165
205
self.gnupgargs = ['--batch',
166
206
'--homedir', self.tempdir,
167
207
'--force-mdc',
168
'--quiet',
169
'--no-use-agent']
170
208
'--quiet']
209
# Only GPG version 1 has the --no-use-agent option.
210
if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
211
self.gnupgargs.append("--no-use-agent")
212
171
213
def __enter__(self):
172
214
return self
173
215
174
216
def __exit__(self, exc_type, exc_value, traceback):
175
217
self._cleanup()
176
218
return False
177
219
178
220
def __del__(self):
179
221
self._cleanup()
180
222
181
223
def _cleanup(self):
182
224
if self.tempdir is not None:
183
225
# Delete contents of tempdir
184
226
for root, dirs, files in os.walk(self.tempdir,
185
topdown = False):
227
topdown=False):
186
228
for filename in files:
187
229
os.remove(os.path.join(root, filename))
188
230
for dirname in dirs:
190
232
# Remove tempdir
191
233
os.rmdir(self.tempdir)
192
234
self.tempdir = None
193
235
194
236
def password_encode(self, password):
195
237
# Passphrase can not be empty and can not contain newlines or
196
238
# NUL bytes. So we prefix it and hex encode it.
201
243
.replace(b"\n", b"\\n")
202
244
.replace(b"\0", b"\\x00"))
203
245
return encoded
204
246
205
247
def encrypt(self, data, password):
206
248
passphrase = self.password_encode(password)
207
249
with tempfile.NamedTemporaryFile(
212
254
'--passphrase-file',
213
255
passfile.name]
214
256
+ self.gnupgargs,
215
stdin = subprocess.PIPE,
216
stdout = subprocess.PIPE,
217
stderr = subprocess.PIPE)
218
ciphertext, err = proc.communicate(input = data)
257
stdin=subprocess.PIPE,
258
stdout=subprocess.PIPE,
259
stderr=subprocess.PIPE)
260
ciphertext, err = proc.communicate(input=data)
219
261
if proc.returncode != 0:
220
262
raise PGPError(err)
221
263
return ciphertext
222
264
223
265
def decrypt(self, data, password):
224
266
passphrase = self.password_encode(password)
225
267
with tempfile.NamedTemporaryFile(
226
dir = self.tempdir) as passfile:
268
dir=self.tempdir) as passfile:
227
269
passfile.write(passphrase)
228
270
passfile.flush()
229
271
proc = subprocess.Popen([self.gpg, '--decrypt',
230
272
'--passphrase-file',
231
273
passfile.name]
232
274
+ self.gnupgargs,
233
stdin = subprocess.PIPE,
234
stdout = subprocess.PIPE,
235
stderr = subprocess.PIPE)
236
decrypted_plaintext, err = proc.communicate(input = data)
275
stdin=subprocess.PIPE,
276
stdout=subprocess.PIPE,
277
stderr=subprocess.PIPE)
278
decrypted_plaintext, err = proc.communicate(input=data)
237
279
if proc.returncode != 0:
238
280
raise PGPError(err)
239
281
return decrypted_plaintext
240
282
241
283
284
# Pretend that we have an Avahi module
285
class avahi:
286
"""This isn't so much a class as it is a module-like namespace."""
287
IF_UNSPEC = -1 # avahi-common/address.h
288
PROTO_UNSPEC = -1 # avahi-common/address.h
289
PROTO_INET = 0 # avahi-common/address.h
290
PROTO_INET6 = 1 # avahi-common/address.h
291
DBUS_NAME = "org.freedesktop.Avahi"
292
DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"
293
DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
294
DBUS_PATH_SERVER = "/"
295
296
@staticmethod
297
def string_array_to_txt_array(t):
298
return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
299
for s in t), signature="ay")
300
ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h
301
ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h
302
ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h
303
SERVER_INVALID = 0 # avahi-common/defs.h
304
SERVER_REGISTERING = 1 # avahi-common/defs.h
305
SERVER_RUNNING = 2 # avahi-common/defs.h
306
SERVER_COLLISION = 3 # avahi-common/defs.h
307
SERVER_FAILURE = 4 # avahi-common/defs.h
308
309
242
310
class AvahiError(Exception):
243
311
def __init__(self, value, *args, **kwargs):
244
312
self.value = value
254
322
pass
255
323
256
324
257
class AvahiService(object):
325
class AvahiService:
258
326
"""An Avahi (Zeroconf) service.
259
327
260
328
Attributes:
261
329
interface: integer; avahi.IF_UNSPEC or an interface index.
262
330
Used to optionally bind to the specified interface.
274
342
server: D-Bus Server
275
343
bus: dbus.SystemBus()
276
344
"""
277
345
278
346
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):
347
interface=avahi.IF_UNSPEC,
348
name=None,
349
servicetype=None,
350
port=None,
351
TXT=None,
352
domain="",
353
host="",
354
max_renames=32768,
355
protocol=avahi.PROTO_UNSPEC,
356
bus=None):
289
357
self.interface = interface
290
358
self.name = name
291
359
self.type = servicetype
300
368
self.server = None
301
369
self.bus = bus
302
370
self.entry_group_state_changed_match = None
303
371
304
372
def rename(self, remove=True):
305
373
"""Derived from the Avahi example code"""
306
374
if self.rename_count >= self.max_renames:
326
394
logger.critical("D-Bus Exception", exc_info=error)
327
395
self.cleanup()
328
396
os._exit(1)
329
397
330
398
def remove(self):
331
399
"""Derived from the Avahi example code"""
332
400
if self.entry_group_state_changed_match is not None:
334
402
self.entry_group_state_changed_match = None
335
403
if self.group is not None:
336
404
self.group.Reset()
337
405
338
406
def add(self):
339
407
"""Derived from the Avahi example code"""
340
408
self.remove()
357
425
dbus.UInt16(self.port),
358
426
avahi.string_array_to_txt_array(self.TXT))
359
427
self.group.Commit()
360
428
361
429
def entry_group_state_changed(self, state, error):
362
430
"""Derived from the Avahi example code"""
363
431
logger.debug("Avahi entry group state change: %i", state)
364
432
365
433
if state == avahi.ENTRY_GROUP_ESTABLISHED:
366
434
logger.debug("Zeroconf service established.")
367
435
elif state == avahi.ENTRY_GROUP_COLLISION:
371
439
logger.critical("Avahi: Error in group state changed %s",
372
440
str(error))
373
441
raise AvahiGroupError("State changed: {!s}".format(error))
374
442
375
443
def cleanup(self):
376
444
"""Derived from the Avahi example code"""
377
445
if self.group is not None:
382
450
pass
383
451
self.group = None
384
452
self.remove()
385
453
386
454
def server_state_changed(self, state, error=None):
387
455
"""Derived from the Avahi example code"""
388
456
logger.debug("Avahi server state change: %i", state)
417
485
logger.debug("Unknown state: %r", state)
418
486
else:
419
487
logger.debug("Unknown state: %r: %r", state, error)
420
488
421
489
def activate(self):
422
490
"""Derived from the Avahi example code"""
423
491
if self.server is None:
434
502
class AvahiServiceToSyslog(AvahiService):
435
503
def rename(self, *args, **kwargs):
436
504
"""Add the new name to the syslog messages"""
437
ret = AvahiService.rename(self, *args, **kwargs)
505
ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)
438
506
syslogger.setFormatter(logging.Formatter(
439
507
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
440
508
.format(self.name)))
441
509
return ret
442
510
511
443
512
# 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
513
class gnutls:
514
"""This isn't so much a class as it is a module-like namespace."""
515
516
library = ctypes.util.find_library("gnutls")
517
if library is None:
518
library = ctypes.util.find_library("gnutls-deb0")
519
_library = ctypes.cdll.LoadLibrary(library)
520
del library
521
459
522
# Unless otherwise indicated, the constants and types below are
460
523
# all from the gnutls/gnutls.h C header file.
461
524
462
525
# Constants
463
526
E_SUCCESS = 0
464
527
E_INTERRUPTED = -52
465
528
E_AGAIN = -28
466
529
CRT_OPENPGP = 2
530
CRT_RAWPK = 3
467
531
CLIENT = 2
468
532
SHUT_RDWR = 0
469
533
CRD_CERTIFICATE = 1
470
534
E_NO_CERTIFICATE_FOUND = -49
535
X509_FMT_DER = 0
536
NO_TICKETS = 1<<10
537
ENABLE_RAWPK = 1<<18
538
CTYPE_PEERS = 3
539
KEYID_USE_SHA256 = 1 # gnutls/x509.h
471
540
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
472
541
473
542
# Types
474
543
class session_int(ctypes.Structure):
475
544
_fields_ = []
476
545
session_t = ctypes.POINTER(session_int)
546
477
547
class certificate_credentials_st(ctypes.Structure):
478
548
_fields_ = []
479
549
certificate_credentials_t = ctypes.POINTER(
480
550
certificate_credentials_st)
481
551
certificate_type_t = ctypes.c_int
552
482
553
class datum_t(ctypes.Structure):
483
554
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
484
555
('size', ctypes.c_uint)]
556
485
557
class openpgp_crt_int(ctypes.Structure):
486
558
_fields_ = []
487
559
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
488
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
560
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
489
561
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
490
credentials_type_t = ctypes.c_int #
562
credentials_type_t = ctypes.c_int
491
563
transport_ptr_t = ctypes.c_void_p
492
564
close_request_t = ctypes.c_int
493
565
494
566
# Exceptions
495
567
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=()):
568
def __init__(self, message=None, code=None, args=()):
501
569
# Default usage is by a message string, but if a return
502
570
# code is passed, convert it to a string with
503
571
# gnutls.strerror()
504
572
self.code = code
505
573
if message is None and code is not None:
506
message = GnuTLS.strerror(code)
507
return super(GnuTLS.Error, self).__init__(
574
message = gnutls.strerror(code)
575
return super(gnutls.Error, self).__init__(
508
576
message, *args)
509
577
510
578
class CertificateSecurityError(Error):
511
579
pass
512
580
513
581
# Classes
514
class Credentials(object):
582
class Credentials:
515
583
def __init__(self):
516
584
self._c_object = gnutls.certificate_credentials_t()
517
585
gnutls.certificate_allocate_credentials(
518
586
ctypes.byref(self._c_object))
519
587
self.type = gnutls.CRD_CERTIFICATE
520
588
521
589
def __del__(self):
522
590
gnutls.certificate_free_credentials(self._c_object)
523
524
class ClientSession(object):
525
def __init__(self, socket, credentials = None):
591
592
class ClientSession:
593
def __init__(self, socket, credentials=None):
526
594
self._c_object = gnutls.session_t()
527
gnutls.init(ctypes.byref(self._c_object), gnutls.CLIENT)
595
gnutls_flags = gnutls.CLIENT
596
if gnutls.check_version(b"3.5.6"):
597
gnutls_flags |= gnutls.NO_TICKETS
598
if gnutls.has_rawpk:
599
gnutls_flags |= gnutls.ENABLE_RAWPK
600
gnutls.init(ctypes.byref(self._c_object), gnutls_flags)
601
del gnutls_flags
528
602
gnutls.set_default_priority(self._c_object)
529
603
gnutls.transport_set_ptr(self._c_object, socket.fileno())
530
604
gnutls.handshake_set_private_extensions(self._c_object,
536
610
ctypes.cast(credentials._c_object,
537
611
ctypes.c_void_p))
538
612
self.credentials = credentials
539
613
540
614
def __del__(self):
541
615
gnutls.deinit(self._c_object)
542
616
543
617
def handshake(self):
544
618
return gnutls.handshake(self._c_object)
545
619
546
620
def send(self, data):
547
621
data = bytes(data)
548
622
data_len = len(data)
550
624
data_len -= gnutls.record_send(self._c_object,
551
625
data[-data_len:],
552
626
data_len)
553
627
554
628
def bye(self):
555
629
return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
556
630
557
631
# Error handling functions
558
632
def _error_code(result):
559
633
"""A function to raise exceptions on errors, suitable
561
635
if result >= 0:
562
636
return result
563
637
if result == gnutls.E_NO_CERTIFICATE_FOUND:
564
raise gnutls.CertificateSecurityError(code = result)
565
raise gnutls.Error(code = result)
566
638
raise gnutls.CertificateSecurityError(code=result)
639
raise gnutls.Error(code=result)
640
567
641
def _retry_on_error(result, func, arguments):
568
642
"""A function to retry on some errors, suitable
569
643
for the 'errcheck' attribute on ctypes functions"""
572
646
return _error_code(result)
573
647
result = func(*arguments)
574
648
return result
575
649
576
650
# Unless otherwise indicated, the function declarations below are
577
651
# all from the gnutls/gnutls.h C header file.
578
652
579
653
# Functions
580
654
priority_set_direct = _library.gnutls_priority_set_direct
581
655
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
582
656
ctypes.POINTER(ctypes.c_char_p)]
583
657
priority_set_direct.restype = _error_code
584
658
585
659
init = _library.gnutls_init
586
660
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
587
661
init.restype = _error_code
588
662
589
663
set_default_priority = _library.gnutls_set_default_priority
590
664
set_default_priority.argtypes = [session_t]
591
665
set_default_priority.restype = _error_code
592
666
593
667
record_send = _library.gnutls_record_send
594
668
record_send.argtypes = [session_t, ctypes.c_void_p,
595
669
ctypes.c_size_t]
596
670
record_send.restype = ctypes.c_ssize_t
597
671
record_send.errcheck = _retry_on_error
598
672
599
673
certificate_allocate_credentials = (
600
674
_library.gnutls_certificate_allocate_credentials)
601
675
certificate_allocate_credentials.argtypes = [
602
676
ctypes.POINTER(certificate_credentials_t)]
603
677
certificate_allocate_credentials.restype = _error_code
604
678
605
679
certificate_free_credentials = (
606
680
_library.gnutls_certificate_free_credentials)
607
certificate_free_credentials.argtypes = [certificate_credentials_t]
681
certificate_free_credentials.argtypes = [
682
certificate_credentials_t]
608
683
certificate_free_credentials.restype = None
609
684
610
685
handshake_set_private_extensions = (
611
686
_library.gnutls_handshake_set_private_extensions)
612
687
handshake_set_private_extensions.argtypes = [session_t,
613
688
ctypes.c_int]
614
689
handshake_set_private_extensions.restype = None
615
690
616
691
credentials_set = _library.gnutls_credentials_set
617
692
credentials_set.argtypes = [session_t, credentials_type_t,
618
693
ctypes.c_void_p]
619
694
credentials_set.restype = _error_code
620
695
621
696
strerror = _library.gnutls_strerror
622
697
strerror.argtypes = [ctypes.c_int]
623
698
strerror.restype = ctypes.c_char_p
624
699
625
700
certificate_type_get = _library.gnutls_certificate_type_get
626
701
certificate_type_get.argtypes = [session_t]
627
702
certificate_type_get.restype = _error_code
628
703
629
704
certificate_get_peers = _library.gnutls_certificate_get_peers
630
705
certificate_get_peers.argtypes = [session_t,
631
706
ctypes.POINTER(ctypes.c_uint)]
632
707
certificate_get_peers.restype = ctypes.POINTER(datum_t)
633
708
634
709
global_set_log_level = _library.gnutls_global_set_log_level
635
710
global_set_log_level.argtypes = [ctypes.c_int]
636
711
global_set_log_level.restype = None
637
712
638
713
global_set_log_function = _library.gnutls_global_set_log_function
639
714
global_set_log_function.argtypes = [log_func]
640
715
global_set_log_function.restype = None
641
716
642
717
deinit = _library.gnutls_deinit
643
718
deinit.argtypes = [session_t]
644
719
deinit.restype = None
645
720
646
721
handshake = _library.gnutls_handshake
647
722
handshake.argtypes = [session_t]
648
723
handshake.restype = _error_code
649
724
handshake.errcheck = _retry_on_error
650
725
651
726
transport_set_ptr = _library.gnutls_transport_set_ptr
652
727
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
653
728
transport_set_ptr.restype = None
654
729
655
730
bye = _library.gnutls_bye
656
731
bye.argtypes = [session_t, close_request_t]
657
732
bye.restype = _error_code
658
733
bye.errcheck = _retry_on_error
659
734
660
735
check_version = _library.gnutls_check_version
661
736
check_version.argtypes = [ctypes.c_char_p]
662
737
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
738
739
_need_version = b"3.3.0"
740
if check_version(_need_version) is None:
741
raise self.Error("Needs GnuTLS {} or later"
742
.format(_need_version))
743
744
_tls_rawpk_version = b"3.6.6"
745
has_rawpk = bool(check_version(_tls_rawpk_version))
746
747
if has_rawpk:
748
# Types
749
class pubkey_st(ctypes.Structure):
750
_fields = []
751
pubkey_t = ctypes.POINTER(pubkey_st)
752
753
x509_crt_fmt_t = ctypes.c_int
754
755
# All the function declarations below are from gnutls/abstract.h
756
pubkey_init = _library.gnutls_pubkey_init
757
pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
758
pubkey_init.restype = _error_code
759
760
pubkey_import = _library.gnutls_pubkey_import
761
pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),
762
x509_crt_fmt_t]
763
pubkey_import.restype = _error_code
764
765
pubkey_get_key_id = _library.gnutls_pubkey_get_key_id
766
pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,
767
ctypes.POINTER(ctypes.c_ubyte),
768
ctypes.POINTER(ctypes.c_size_t)]
769
pubkey_get_key_id.restype = _error_code
770
771
pubkey_deinit = _library.gnutls_pubkey_deinit
772
pubkey_deinit.argtypes = [pubkey_t]
773
pubkey_deinit.restype = None
774
else:
775
# All the function declarations below are from gnutls/openpgp.h
776
777
openpgp_crt_init = _library.gnutls_openpgp_crt_init
778
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
779
openpgp_crt_init.restype = _error_code
780
781
openpgp_crt_import = _library.gnutls_openpgp_crt_import
782
openpgp_crt_import.argtypes = [openpgp_crt_t,
783
ctypes.POINTER(datum_t),
784
openpgp_crt_fmt_t]
785
openpgp_crt_import.restype = _error_code
786
787
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
788
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
789
ctypes.POINTER(ctypes.c_uint)]
790
openpgp_crt_verify_self.restype = _error_code
791
792
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
793
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
794
openpgp_crt_deinit.restype = None
795
796
openpgp_crt_get_fingerprint = (
797
_library.gnutls_openpgp_crt_get_fingerprint)
798
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
799
ctypes.c_void_p,
800
ctypes.POINTER(
801
ctypes.c_size_t)]
802
openpgp_crt_get_fingerprint.restype = _error_code
803
804
if check_version(b"3.6.4"):
805
certificate_type_get2 = _library.gnutls_certificate_type_get2
806
certificate_type_get2.argtypes = [session_t, ctypes.c_int]
807
certificate_type_get2.restype = _error_code
808
693
809
# Remove non-public functions
694
810
del _error_code, _retry_on_error
695
# Create the global "gnutls" object, simulating a module
696
gnutls = GnuTLS()
811
697
812
698
813
def call_pipe(connection, # : multiprocessing.Connection
699
814
func, *args, **kwargs):
700
815
"""This function is meant to be called by multiprocessing.Process
701
816
702
817
This function runs func(*args, **kwargs), and writes the resulting
703
818
return value on the provided multiprocessing.Connection.
704
819
"""
705
820
connection.send(func(*args, **kwargs))
706
821
connection.close()
707
822
708
class Client(object):
823
824
class Client:
709
825
"""A representation of a client host served by this server.
710
826
711
827
Attributes:
712
828
approved: bool(); 'None' if not yet approved/disapproved
713
829
approval_delay: datetime.timedelta(); Time to wait for approval
714
830
approval_duration: datetime.timedelta(); Duration of one approval
715
checker: subprocess.Popen(); a running checker process used
716
to see if the client lives.
717
'None' if no process is running.
718
checker_callback_tag: a gobject event source tag, or None
831
checker: multiprocessing.Process(); a running checker process used
832
to see if the client lives. 'None' if no process is
833
running.
834
checker_callback_tag: a GLib event source tag, or None
719
835
checker_command: string; External command which is run to check
720
836
if client lives. %() expansions are done at
721
837
runtime with vars(self) as dict, so that for
722
838
instance %(name)s can be used in the command.
723
checker_initiator_tag: a gobject event source tag, or None
839
checker_initiator_tag: a GLib event source tag, or None
724
840
created: datetime.datetime(); (UTC) object creation
725
841
client_structure: Object describing what attributes a client has
726
842
and is used for storing the client at exit
727
843
current_checker_command: string; current running checker_command
728
disable_initiator_tag: a gobject event source tag, or None
844
disable_initiator_tag: a GLib event source tag, or None
729
845
enabled: bool()
730
846
fingerprint: string (40 or 32 hexadecimal digits); used to
731
uniquely identify the client
847
uniquely identify an OpenPGP client
848
key_id: string (64 hexadecimal digits); used to uniquely identify
849
a client using raw public keys
732
850
host: string; available for use by the checker command
733
851
interval: datetime.timedelta(); How often to start a new checker
734
852
last_approval_request: datetime.datetime(); (UTC) or None
750
868
disabled, or None
751
869
server_settings: The server_settings dict from main()
752
870
"""
753
871
754
872
runtime_expansions = ("approval_delay", "approval_duration",
755
"created", "enabled", "expires",
873
"created", "enabled", "expires", "key_id",
756
874
"fingerprint", "host", "interval",
757
875
"last_approval_request", "last_checked_ok",
758
876
"last_enabled", "name", "timeout")
767
885
"approved_by_default": "True",
768
886
"enabled": "True",
769
887
}
770
888
771
889
@staticmethod
772
890
def config_parser(config):
773
891
"""Construct a new dict of client settings of this form:
780
898
for client_name in config.sections():
781
899
section = dict(config.items(client_name))
782
900
client = settings[client_name] = {}
783
901
784
902
client["host"] = section["host"]
785
903
# Reformat values from string types to Python types
786
904
client["approved_by_default"] = config.getboolean(
787
905
client_name, "approved_by_default")
788
906
client["enabled"] = config.getboolean(client_name,
789
907
"enabled")
790
791
# Uppercase and remove spaces from fingerprint for later
792
# comparison purposes with return value from the
793
# fingerprint() function
908
909
# Uppercase and remove spaces from key_id and fingerprint
910
# for later comparison purposes with return value from the
911
# key_id() and fingerprint() functions
912
client["key_id"] = (section.get("key_id", "").upper()
913
.replace(" ", ""))
794
914
client["fingerprint"] = (section["fingerprint"].upper()
795
915
.replace(" ", ""))
796
916
if "secret" in section:
797
client["secret"] = section["secret"].decode("base64")
917
client["secret"] = codecs.decode(section["secret"]
918
.encode("utf-8"),
919
"base64")
798
920
elif "secfile" in section:
799
921
with open(os.path.expanduser(os.path.expandvars
800
922
(section["secfile"])),
815
937
client["last_approval_request"] = None
816
938
client["last_checked_ok"] = None
817
939
client["last_checker_status"] = -2
818
940
819
941
return settings
820
821
def __init__(self, settings, name = None, server_settings=None):
942
943
def __init__(self, settings, name=None, server_settings=None):
822
944
self.name = name
823
945
if server_settings is None:
824
946
server_settings = {}
826
948
# adding all client settings
827
949
for setting, value in settings.items():
828
950
setattr(self, setting, value)
829
951
830
952
if self.enabled:
831
953
if not hasattr(self, "last_enabled"):
832
954
self.last_enabled = datetime.datetime.utcnow()
836
958
else:
837
959
self.last_enabled = None
838
960
self.expires = None
839
961
840
962
logger.debug("Creating client %r", self.name)
963
logger.debug(" Key ID: %s", self.key_id)
841
964
logger.debug(" Fingerprint: %s", self.fingerprint)
842
965
self.created = settings.get("created",
843
966
datetime.datetime.utcnow())
844
967
845
968
# attributes specific for this server instance
846
969
self.checker = None
847
970
self.checker_initiator_tag = None
853
976
self.changedstate = multiprocessing_manager.Condition(
854
977
multiprocessing_manager.Lock())
855
978
self.client_structure = [attr
856
for attr in self.__dict__.iterkeys()
979
for attr in self.__dict__.keys()
857
980
if not attr.startswith("_")]
858
981
self.client_structure.append("client_structure")
859
982
860
983
for name, t in inspect.getmembers(
861
984
type(self), lambda obj: isinstance(obj, property)):
862
985
if not name.startswith("_"):
863
986
self.client_structure.append(name)
864
987
865
988
# Send notice to process children that client state has changed
866
989
def send_changedstate(self):
867
990
with self.changedstate:
868
991
self.changedstate.notify_all()
869
992
870
993
def enable(self):
871
994
"""Start this client's checker and timeout hooks"""
872
995
if getattr(self, "enabled", False):
877
1000
self.last_enabled = datetime.datetime.utcnow()
878
1001
self.init_checker()
879
1002
self.send_changedstate()
880
1003
881
1004
def disable(self, quiet=True):
882
1005
"""Disable this client."""
883
1006
if not getattr(self, "enabled", False):
885
1008
if not quiet:
886
1009
logger.info("Disabling client %s", self.name)
887
1010
if getattr(self, "disable_initiator_tag", None) is not None:
888
gobject.source_remove(self.disable_initiator_tag)
1011
GLib.source_remove(self.disable_initiator_tag)
889
1012
self.disable_initiator_tag = None
890
1013
self.expires = None
891
1014
if getattr(self, "checker_initiator_tag", None) is not None:
892
gobject.source_remove(self.checker_initiator_tag)
1015
GLib.source_remove(self.checker_initiator_tag)
893
1016
self.checker_initiator_tag = None
894
1017
self.stop_checker()
895
1018
self.enabled = False
896
1019
if not quiet:
897
1020
self.send_changedstate()
898
# Do not run this again if called by a gobject.timeout_add
1021
# Do not run this again if called by a GLib.timeout_add
899
1022
return False
900
1023
901
1024
def __del__(self):
902
1025
self.disable()
903
1026
904
1027
def init_checker(self):
905
1028
# Schedule a new checker to be started an 'interval' from now,
906
1029
# and every interval from then on.
907
1030
if self.checker_initiator_tag is not None:
908
gobject.source_remove(self.checker_initiator_tag)
909
self.checker_initiator_tag = gobject.timeout_add(
1031
GLib.source_remove(self.checker_initiator_tag)
1032
self.checker_initiator_tag = GLib.timeout_add(
910
1033
int(self.interval.total_seconds() * 1000),
911
1034
self.start_checker)
912
1035
# Schedule a disable() when 'timeout' has passed
913
1036
if self.disable_initiator_tag is not None:
914
gobject.source_remove(self.disable_initiator_tag)
915
self.disable_initiator_tag = gobject.timeout_add(
1037
GLib.source_remove(self.disable_initiator_tag)
1038
self.disable_initiator_tag = GLib.timeout_add(
916
1039
int(self.timeout.total_seconds() * 1000), self.disable)
917
1040
# Also start a new checker *right now*.
918
1041
self.start_checker()
919
1042
920
1043
def checker_callback(self, source, condition, connection,
921
1044
command):
922
1045
"""The checker has completed, so take appropriate actions."""
923
self.checker_callback_tag = None
924
self.checker = None
925
1046
# Read return code from connection (see call_pipe)
926
1047
returncode = connection.recv()
927
1048
connection.close()
928
1049
self.checker.join()
1050
self.checker_callback_tag = None
1051
self.checker = None
1052
929
1053
if returncode >= 0:
930
1054
self.last_checker_status = returncode
931
1055
self.last_checker_signal = None
941
1065
logger.warning("Checker for %(name)s crashed?",
942
1066
vars(self))
943
1067
return False
944
1068
945
1069
def checked_ok(self):
946
1070
"""Assert that the client has been seen, alive and well."""
947
1071
self.last_checked_ok = datetime.datetime.utcnow()
948
1072
self.last_checker_status = 0
949
1073
self.last_checker_signal = None
950
1074
self.bump_timeout()
951
1075
952
1076
def bump_timeout(self, timeout=None):
953
1077
"""Bump up the timeout for this client."""
954
1078
if timeout is None:
955
1079
timeout = self.timeout
956
1080
if self.disable_initiator_tag is not None:
957
gobject.source_remove(self.disable_initiator_tag)
1081
GLib.source_remove(self.disable_initiator_tag)
958
1082
self.disable_initiator_tag = None
959
1083
if getattr(self, "enabled", False):
960
self.disable_initiator_tag = gobject.timeout_add(
1084
self.disable_initiator_tag = GLib.timeout_add(
961
1085
int(timeout.total_seconds() * 1000), self.disable)
962
1086
self.expires = datetime.datetime.utcnow() + timeout
963
1087
964
1088
def need_approval(self):
965
1089
self.last_approval_request = datetime.datetime.utcnow()
966
1090
967
1091
def start_checker(self):
968
1092
"""Start a new checker subprocess if one is not running.
969
1093
970
1094
If a checker already exists, leave it running and do
971
1095
nothing."""
972
1096
# The reason for not killing a running checker is that if we
977
1101
# checkers alone, the checker would have to take more time
978
1102
# than 'timeout' for the client to be disabled, which is as it
979
1103
# should be.
980
1104
981
1105
if self.checker is not None and not self.checker.is_alive():
982
1106
logger.warning("Checker was not alive; joining")
983
1107
self.checker.join()
987
1111
# Escape attributes for the shell
988
1112
escaped_attrs = {
989
1113
attr: re.escape(str(getattr(self, attr)))
990
for attr in self.runtime_expansions }
1114
for attr in self.runtime_expansions}
991
1115
try:
992
1116
command = self.checker_command % escaped_attrs
993
1117
except TypeError as error:
1005
1129
# The exception is when not debugging but nevertheless
1006
1130
# running in the foreground; use the previously
1007
1131
# created wnull.
1008
popen_args = { "close_fds": True,
1009
"shell": True,
1010
"cwd": "/" }
1132
popen_args = {"close_fds": True,
1133
"shell": True,
1134
"cwd": "/"}
1011
1135
if (not self.server_settings["debug"]
1012
1136
and self.server_settings["foreground"]):
1013
1137
popen_args.update({"stdout": wnull,
1014
"stderr": wnull })
1015
pipe = multiprocessing.Pipe(duplex = False)
1138
"stderr": wnull})
1139
pipe = multiprocessing.Pipe(duplex=False)
1016
1140
self.checker = multiprocessing.Process(
1017
target = call_pipe,
1018
args = (pipe[1], subprocess.call, command),
1019
kwargs = popen_args)
1141
target=call_pipe,
1142
args=(pipe[1], subprocess.call, command),
1143
kwargs=popen_args)
1020
1144
self.checker.start()
1021
self.checker_callback_tag = gobject.io_add_watch(
1022
pipe[0].fileno(), gobject.IO_IN,
1145
self.checker_callback_tag = GLib.io_add_watch(
1146
pipe[0].fileno(), GLib.IO_IN,
1023
1147
self.checker_callback, pipe[0], command)
1024
# Re-run this periodically if run by gobject.timeout_add
1148
# Re-run this periodically if run by GLib.timeout_add
1025
1149
return True
1026
1150
1027
1151
def stop_checker(self):
1028
1152
"""Force the checker process, if any, to stop."""
1029
1153
if self.checker_callback_tag:
1030
gobject.source_remove(self.checker_callback_tag)
1154
GLib.source_remove(self.checker_callback_tag)
1031
1155
self.checker_callback_tag = None
1032
1156
if getattr(self, "checker", None) is None:
1033
1157
return
1042
1166
byte_arrays=False):
1043
1167
"""Decorators for marking methods of a DBusObjectWithProperties to
1044
1168
become properties on the D-Bus.
1045
1169
1046
1170
The decorated method will be called with no arguments by "Get"
1047
1171
and with one argument by "Set".
1048
1172
1049
1173
The parameters, where they are supported, are the same as
1050
1174
dbus.service.method, except there is only "signature", since the
1051
1175
type from Get() and the type sent to Set() is the same.
1055
1179
if byte_arrays and signature != "ay":
1056
1180
raise ValueError("Byte arrays not supported for non-'ay'"
1057
1181
" signature {!r}".format(signature))
1058
1182
1059
1183
def decorator(func):
1060
1184
func._dbus_is_property = True
1061
1185
func._dbus_interface = dbus_interface
1064
1188
func._dbus_name = func.__name__
1065
1189
if func._dbus_name.endswith("_dbus_property"):
1066
1190
func._dbus_name = func._dbus_name[:-14]
1067
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
1191
func._dbus_get_args_options = {'byte_arrays': byte_arrays}
1068
1192
return func
1069
1193
1070
1194
return decorator
1071
1195
1072
1196
1073
1197
def dbus_interface_annotations(dbus_interface):
1074
1198
"""Decorator for marking functions returning interface annotations
1075
1199
1076
1200
Usage:
1077
1201
1078
1202
@dbus_interface_annotations("org.example.Interface")
1079
1203
def _foo(self): # Function name does not matter
1080
1204
return {"org.freedesktop.DBus.Deprecated": "true",
1081
1205
"org.freedesktop.DBus.Property.EmitsChangedSignal":
1082
1206
"false"}
1083
1207
"""
1084
1208
1085
1209
def decorator(func):
1086
1210
func._dbus_is_interface = True
1087
1211
func._dbus_interface = dbus_interface
1088
1212
func._dbus_name = dbus_interface
1089
1213
return func
1090
1214
1091
1215
return decorator
1092
1216
1093
1217
1094
1218
def dbus_annotations(annotations):
1095
1219
"""Decorator to annotate D-Bus methods, signals or properties
1096
1220
Usage:
1097
1221
1098
1222
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
1099
1223
"org.freedesktop.DBus.Property."
1100
1224
"EmitsChangedSignal": "false"})
1102
1226
access="r")
1103
1227
def Property_dbus_property(self):
1104
1228
return dbus.Boolean(False)
1105
1229
1106
1230
See also the DBusObjectWithAnnotations class.
1107
1231
"""
1108
1232
1109
1233
def decorator(func):
1110
1234
func._dbus_annotations = annotations
1111
1235
return func
1112
1236
1113
1237
return decorator
1114
1238
1115
1239
1133
1257
1134
1258
class DBusObjectWithAnnotations(dbus.service.Object):
1135
1259
"""A D-Bus object with annotations.
1136
1260
1137
1261
Classes inheriting from this can use the dbus_annotations
1138
1262
decorator to add annotations to methods or signals.
1139
1263
"""
1140
1264
1141
1265
@staticmethod
1142
1266
def _is_dbus_thing(thing):
1143
1267
"""Returns a function testing if an attribute is a D-Bus thing
1144
1268
1145
1269
If called like _is_dbus_thing("method") it returns a function
1146
1270
suitable for use as predicate to inspect.getmembers().
1147
1271
"""
1148
1272
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
1149
1273
False)
1150
1274
1151
1275
def _get_all_dbus_things(self, thing):
1152
1276
"""Returns a generator of (name, attribute) pairs
1153
1277
"""
1156
1280
for cls in self.__class__.__mro__
1157
1281
for name, athing in
1158
1282
inspect.getmembers(cls, self._is_dbus_thing(thing)))
1159
1283
1160
1284
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1161
out_signature = "s",
1162
path_keyword = 'object_path',
1163
connection_keyword = 'connection')
1285
out_signature="s",
1286
path_keyword='object_path',
1287
connection_keyword='connection')
1164
1288
def Introspect(self, object_path, connection):
1165
1289
"""Overloading of standard D-Bus method.
1166
1290
1167
1291
Inserts annotation tags on methods and signals.
1168
1292
"""
1169
1293
xmlstring = dbus.service.Object.Introspect(self, object_path,
1170
1294
connection)
1171
1295
try:
1172
1296
document = xml.dom.minidom.parseString(xmlstring)
1173
1297
1174
1298
for if_tag in document.getElementsByTagName("interface"):
1175
1299
# Add annotation tags
1176
1300
for typ in ("method", "signal"):
1203
1327
if_tag.appendChild(ann_tag)
1204
1328
# Fix argument name for the Introspect method itself
1205
1329
if (if_tag.getAttribute("name")
1206
== dbus.INTROSPECTABLE_IFACE):
1330
== dbus.INTROSPECTABLE_IFACE):
1207
1331
for cn in if_tag.getElementsByTagName("method"):
1208
1332
if cn.getAttribute("name") == "Introspect":
1209
1333
for arg in cn.getElementsByTagName("arg"):
1222
1346
1223
1347
class DBusObjectWithProperties(DBusObjectWithAnnotations):
1224
1348
"""A D-Bus object with properties.
1225
1349
1226
1350
Classes inheriting from this can use the dbus_service_property
1227
1351
decorator to expose methods as D-Bus properties. It exposes the
1228
1352
standard Get(), Set(), and GetAll() methods on the D-Bus.
1229
1353
"""
1230
1354
1231
1355
def _get_dbus_property(self, interface_name, property_name):
1232
1356
"""Returns a bound method if one exists which is a D-Bus
1233
1357
property with the specified name and interface.
1238
1362
if (value._dbus_name == property_name
1239
1363
and value._dbus_interface == interface_name):
1240
1364
return value.__get__(self)
1241
1365
1242
1366
# No such property
1243
1367
raise DBusPropertyNotFound("{}:{}.{}".format(
1244
1368
self.dbus_object_path, interface_name, property_name))
1245
1369
1246
1370
@classmethod
1247
1371
def _get_all_interface_names(cls):
1248
1372
"""Get a sequence of all interfaces supported by an object"""
1251
1375
for x in (inspect.getmro(cls))
1252
1376
for attr in dir(x))
1253
1377
if name is not None)
1254
1378
1255
1379
@dbus.service.method(dbus.PROPERTIES_IFACE,
1256
1380
in_signature="ss",
1257
1381
out_signature="v")
1265
1389
if not hasattr(value, "variant_level"):
1266
1390
return value
1267
1391
return type(value)(value, variant_level=value.variant_level+1)
1268
1392
1269
1393
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
1270
1394
def Set(self, interface_name, property_name, value):
1271
1395
"""Standard D-Bus property Set() method, see D-Bus standard.
1283
1407
value = dbus.ByteArray(b''.join(chr(byte)
1284
1408
for byte in value))
1285
1409
prop(value)
1286
1410
1287
1411
@dbus.service.method(dbus.PROPERTIES_IFACE,
1288
1412
in_signature="s",
1289
1413
out_signature="a{sv}")
1290
1414
def GetAll(self, interface_name):
1291
1415
"""Standard D-Bus property GetAll() method, see D-Bus
1292
1416
standard.
1293
1417
1294
1418
Note: Will not include properties with access="write".
1295
1419
"""
1296
1420
properties = {}
1307
1431
properties[name] = value
1308
1432
continue
1309
1433
properties[name] = type(value)(
1310
value, variant_level = value.variant_level + 1)
1434
value, variant_level=value.variant_level + 1)
1311
1435
return dbus.Dictionary(properties, signature="sv")
1312
1436
1313
1437
@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
1314
1438
def PropertiesChanged(self, interface_name, changed_properties,
1315
1439
invalidated_properties):
1317
1441
standard.
1318
1442
"""
1319
1443
pass
1320
1444
1321
1445
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1322
1446
out_signature="s",
1323
1447
path_keyword='object_path',
1324
1448
connection_keyword='connection')
1325
1449
def Introspect(self, object_path, connection):
1326
1450
"""Overloading of standard D-Bus method.
1327
1451
1328
1452
Inserts property tags and interface annotation tags.
1329
1453
"""
1330
1454
xmlstring = DBusObjectWithAnnotations.Introspect(self,
1332
1456
connection)
1333
1457
try:
1334
1458
document = xml.dom.minidom.parseString(xmlstring)
1335
1459
1336
1460
def make_tag(document, name, prop):
1337
1461
e = document.createElement("property")
1338
1462
e.setAttribute("name", name)
1339
1463
e.setAttribute("type", prop._dbus_signature)
1340
1464
e.setAttribute("access", prop._dbus_access)
1341
1465
return e
1342
1466
1343
1467
for if_tag in document.getElementsByTagName("interface"):
1344
1468
# Add property tags
1345
1469
for tag in (make_tag(document, name, prop)
1387
1511
exc_info=error)
1388
1512
return xmlstring
1389
1513
1514
1390
1515
try:
1391
1516
dbus.OBJECT_MANAGER_IFACE
1392
1517
except AttributeError:
1393
1518
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
1394
1519
1520
1395
1521
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
1396
1522
"""A D-Bus object with an ObjectManager.
1397
1523
1398
1524
Classes inheriting from this exposes the standard
1399
1525
GetManagedObjects call and the InterfacesAdded and
1400
1526
InterfacesRemoved signals on the standard
1401
1527
"org.freedesktop.DBus.ObjectManager" interface.
1402
1528
1403
1529
Note: No signals are sent automatically; they must be sent
1404
1530
manually.
1405
1531
"""
1406
1532
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
1407
out_signature = "a{oa{sa{sv}}}")
1533
out_signature="a{oa{sa{sv}}}")
1408
1534
def GetManagedObjects(self):
1409
1535
"""This function must be overridden"""
1410
1536
raise NotImplementedError()
1411
1537
1412
1538
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
1413
signature = "oa{sa{sv}}")
1539
signature="oa{sa{sv}}")
1414
1540
def InterfacesAdded(self, object_path, interfaces_and_properties):
1415
1541
pass
1416
1417
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature = "oas")
1542
1543
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")
1418
1544
def InterfacesRemoved(self, object_path, interfaces):
1419
1545
pass
1420
1546
1421
1547
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1422
out_signature = "s",
1423
path_keyword = 'object_path',
1424
connection_keyword = 'connection')
1548
out_signature="s",
1549
path_keyword='object_path',
1550
connection_keyword='connection')
1425
1551
def Introspect(self, object_path, connection):
1426
1552
"""Overloading of standard D-Bus method.
1427
1553
1428
1554
Override return argument name of GetManagedObjects to be
1429
1555
"objpath_interfaces_and_properties"
1430
1556
"""
1433
1559
connection)
1434
1560
try:
1435
1561
document = xml.dom.minidom.parseString(xmlstring)
1436
1562
1437
1563
for if_tag in document.getElementsByTagName("interface"):
1438
1564
# Fix argument name for the GetManagedObjects method
1439
1565
if (if_tag.getAttribute("name")
1440
== dbus.OBJECT_MANAGER_IFACE):
1566
== dbus.OBJECT_MANAGER_IFACE):
1441
1567
for cn in if_tag.getElementsByTagName("method"):
1442
1568
if (cn.getAttribute("name")
1443
1569
== "GetManagedObjects"):
1453
1579
except (AttributeError, xml.dom.DOMException,
1454
1580
xml.parsers.expat.ExpatError) as error:
1455
1581
logger.error("Failed to override Introspection method",
1456
exc_info = error)
1582
exc_info=error)
1457
1583
return xmlstring
1458
1584
1585
1459
1586
def datetime_to_dbus(dt, variant_level=0):
1460
1587
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1461
1588
if dt is None:
1462
return dbus.String("", variant_level = variant_level)
1589
return dbus.String("", variant_level=variant_level)
1463
1590
return dbus.String(dt.isoformat(), variant_level=variant_level)
1464
1591
1465
1592
1468
1595
dbus.service.Object, it will add alternate D-Bus attributes with
1469
1596
interface names according to the "alt_interface_names" mapping.
1470
1597
Usage:
1471
1598
1472
1599
@alternate_dbus_interfaces({"org.example.Interface":
1473
1600
"net.example.AlternateInterface"})
1474
1601
class SampleDBusObject(dbus.service.Object):
1475
1602
@dbus.service.method("org.example.Interface")
1476
1603
def SampleDBusMethod():
1477
1604
pass
1478
1605
1479
1606
The above "SampleDBusMethod" on "SampleDBusObject" will be
1480
1607
reachable via two interfaces: "org.example.Interface" and
1481
1608
"net.example.AlternateInterface", the latter of which will have
1482
1609
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1483
1610
"true", unless "deprecate" is passed with a False value.
1484
1611
1485
1612
This works for methods and signals, and also for D-Bus properties
1486
1613
(from DBusObjectWithProperties) and interfaces (from the
1487
1614
dbus_interface_annotations decorator).
1488
1615
"""
1489
1616
1490
1617
def wrapper(cls):
1491
1618
for orig_interface_name, alt_interface_name in (
1492
1619
alt_interface_names.items()):
1507
1634
interface_names.add(alt_interface)
1508
1635
# Is this a D-Bus signal?
1509
1636
if getattr(attribute, "_dbus_is_signal", False):
1637
# Extract the original non-method undecorated
1638
# function by black magic
1510
1639
if sys.version_info.major == 2:
1511
# Extract the original non-method undecorated
1512
# function by black magic
1513
1640
nonmethod_func = (dict(
1514
1641
zip(attribute.func_code.co_freevars,
1515
1642
attribute.__closure__))
1516
1643
["func"].cell_contents)
1517
1644
else:
1518
nonmethod_func = attribute
1645
nonmethod_func = (dict(
1646
zip(attribute.__code__.co_freevars,
1647
attribute.__closure__))
1648
["func"].cell_contents)
1519
1649
# Create a new, but exactly alike, function
1520
1650
# object, and decorate it to be a new D-Bus signal
1521
1651
# 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__)
1652
new_function = copy_function(nonmethod_func)
1536
1653
new_function = (dbus.service.signal(
1537
1654
alt_interface,
1538
1655
attribute._dbus_signature)(new_function))
1542
1659
attribute._dbus_annotations)
1543
1660
except AttributeError:
1544
1661
pass
1662
1545
1663
# Define a creator of a function to call both the
1546
1664
# original and alternate functions, so both the
1547
1665
# original and alternate signals gets sent when
1550
1668
"""This function is a scope container to pass
1551
1669
func1 and func2 to the "call_both" function
1552
1670
outside of its arguments"""
1553
1671
1554
1672
@functools.wraps(func2)
1555
1673
def call_both(*args, **kwargs):
1556
1674
"""This function will emit two D-Bus
1557
1675
signals by calling func1 and func2"""
1558
1676
func1(*args, **kwargs)
1559
1677
func2(*args, **kwargs)
1560
# Make wrapper function look like a D-Bus signal
1678
# Make wrapper function look like a D-Bus
1679
# signal
1561
1680
for name, attr in inspect.getmembers(func2):
1562
1681
if name.startswith("_dbus_"):
1563
1682
setattr(call_both, name, attr)
1564
1683
1565
1684
return call_both
1566
1685
# Create the "call_both" function and add it to
1567
1686
# the class
1577
1696
alt_interface,
1578
1697
attribute._dbus_in_signature,
1579
1698
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)))
1699
(copy_function(attribute)))
1585
1700
# Copy annotations, if any
1586
1701
try:
1587
1702
attr[attrname]._dbus_annotations = dict(
1599
1714
attribute._dbus_access,
1600
1715
attribute._dbus_get_args_options
1601
1716
["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)))
1717
(copy_function(attribute)))
1608
1718
# Copy annotations, if any
1609
1719
try:
1610
1720
attr[attrname]._dbus_annotations = dict(
1619
1729
# to the class.
1620
1730
attr[attrname] = (
1621
1731
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)))
1732
(copy_function(attribute)))
1627
1733
if deprecate:
1628
1734
# Deprecate all alternate interfaces
1629
iname="_AlternateDBusNames_interface_annotation{}"
1735
iname = "_AlternateDBusNames_interface_annotation{}"
1630
1736
for interface_name in interface_names:
1631
1737
1632
1738
@dbus_interface_annotations(interface_name)
1633
1739
def func(self):
1634
return { "org.freedesktop.DBus.Deprecated":
1635
"true" }
1740
return {"org.freedesktop.DBus.Deprecated":
1741
"true"}
1636
1742
# Find an unused name
1637
1743
for aname in (iname.format(i)
1638
1744
for i in itertools.count()):
1642
1748
if interface_names:
1643
1749
# Replace the class with a new subclass of it with
1644
1750
# methods, signals, etc. as created above.
1645
cls = type(b"{}Alternate".format(cls.__name__),
1646
(cls, ), attr)
1751
if sys.version_info.major == 2:
1752
cls = type(b"{}Alternate".format(cls.__name__),
1753
(cls, ), attr)
1754
else:
1755
cls = type("{}Alternate".format(cls.__name__),
1756
(cls, ), attr)
1647
1757
return cls
1648
1758
1649
1759
return wrapper
1650
1760
1651
1761
1653
1763
"se.bsnet.fukt.Mandos"})
1654
1764
class ClientDBus(Client, DBusObjectWithProperties):
1655
1765
"""A Client class using D-Bus
1656
1766
1657
1767
Attributes:
1658
1768
dbus_object_path: dbus.ObjectPath
1659
1769
bus: dbus.SystemBus()
1660
1770
"""
1661
1771
1662
1772
runtime_expansions = (Client.runtime_expansions
1663
1773
+ ("dbus_object_path", ))
1664
1774
1665
1775
_interface = "se.recompile.Mandos.Client"
1666
1776
1667
1777
# dbus.service.Object doesn't use super(), so we can't either.
1668
1669
def __init__(self, bus = None, *args, **kwargs):
1778
1779
def __init__(self, bus=None, *args, **kwargs):
1670
1780
self.bus = bus
1671
1781
Client.__init__(self, *args, **kwargs)
1672
1782
# Only now, when this client is initialized, can it show up on
1678
1788
"/clients/" + client_object_name)
1679
1789
DBusObjectWithProperties.__init__(self, self.bus,
1680
1790
self.dbus_object_path)
1681
1791
1682
1792
def notifychangeproperty(transform_func, dbus_name,
1683
1793
type_func=lambda x: x,
1684
1794
variant_level=1,
1686
1796
_interface=_interface):
1687
1797
""" Modify a variable so that it's a property which announces
1688
1798
its changes to DBus.
1689
1799
1690
1800
transform_fun: Function that takes a value and a variant_level
1691
1801
and transforms it to a D-Bus type.
1692
1802
dbus_name: D-Bus name of the variable
1695
1805
variant_level: D-Bus variant level. Default: 1
1696
1806
"""
1697
1807
attrname = "_{}".format(dbus_name)
1698
1808
1699
1809
def setter(self, value):
1700
1810
if hasattr(self, "dbus_object_path"):
1701
1811
if (not hasattr(self, attrname) or
1708
1818
else:
1709
1819
dbus_value = transform_func(
1710
1820
type_func(value),
1711
variant_level = variant_level)
1821
variant_level=variant_level)
1712
1822
self.PropertyChanged(dbus.String(dbus_name),
1713
1823
dbus_value)
1714
1824
self.PropertiesChanged(
1715
1825
_interface,
1716
dbus.Dictionary({ dbus.String(dbus_name):
1717
dbus_value }),
1826
dbus.Dictionary({dbus.String(dbus_name):
1827
dbus_value}),
1718
1828
dbus.Array())
1719
1829
setattr(self, attrname, value)
1720
1830
1721
1831
return property(lambda self: getattr(self, attrname), setter)
1722
1832
1723
1833
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1724
1834
approvals_pending = notifychangeproperty(dbus.Boolean,
1725
1835
"ApprovalPending",
1726
type_func = bool)
1836
type_func=bool)
1727
1837
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1728
1838
last_enabled = notifychangeproperty(datetime_to_dbus,
1729
1839
"LastEnabled")
1730
1840
checker = notifychangeproperty(
1731
1841
dbus.Boolean, "CheckerRunning",
1732
type_func = lambda checker: checker is not None)
1842
type_func=lambda checker: checker is not None)
1733
1843
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1734
1844
"LastCheckedOK")
1735
1845
last_checker_status = notifychangeproperty(dbus.Int16,
1740
1850
"ApprovedByDefault")
1741
1851
approval_delay = notifychangeproperty(
1742
1852
dbus.UInt64, "ApprovalDelay",
1743
type_func = lambda td: td.total_seconds() * 1000)
1853
type_func=lambda td: td.total_seconds() * 1000)
1744
1854
approval_duration = notifychangeproperty(
1745
1855
dbus.UInt64, "ApprovalDuration",
1746
type_func = lambda td: td.total_seconds() * 1000)
1856
type_func=lambda td: td.total_seconds() * 1000)
1747
1857
host = notifychangeproperty(dbus.String, "Host")
1748
1858
timeout = notifychangeproperty(
1749
1859
dbus.UInt64, "Timeout",
1750
type_func = lambda td: td.total_seconds() * 1000)
1860
type_func=lambda td: td.total_seconds() * 1000)
1751
1861
extended_timeout = notifychangeproperty(
1752
1862
dbus.UInt64, "ExtendedTimeout",
1753
type_func = lambda td: td.total_seconds() * 1000)
1863
type_func=lambda td: td.total_seconds() * 1000)
1754
1864
interval = notifychangeproperty(
1755
1865
dbus.UInt64, "Interval",
1756
type_func = lambda td: td.total_seconds() * 1000)
1866
type_func=lambda td: td.total_seconds() * 1000)
1757
1867
checker_command = notifychangeproperty(dbus.String, "Checker")
1758
1868
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1759
1869
invalidate_only=True)
1760
1870
1761
1871
del notifychangeproperty
1762
1872
1763
1873
def __del__(self, *args, **kwargs):
1764
1874
try:
1765
1875
self.remove_from_connection()
1768
1878
if hasattr(DBusObjectWithProperties, "__del__"):
1769
1879
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1770
1880
Client.__del__(self, *args, **kwargs)
1771
1881
1772
1882
def checker_callback(self, source, condition,
1773
1883
connection, command, *args, **kwargs):
1774
1884
ret = Client.checker_callback(self, source, condition,
1790
1900
| self.last_checker_signal),
1791
1901
dbus.String(command))
1792
1902
return ret
1793
1903
1794
1904
def start_checker(self, *args, **kwargs):
1795
1905
old_checker_pid = getattr(self.checker, "pid", None)
1796
1906
r = Client.start_checker(self, *args, **kwargs)
1800
1910
# Emit D-Bus signal
1801
1911
self.CheckerStarted(self.current_checker_command)
1802
1912
return r
1803
1913
1804
1914
def _reset_approved(self):
1805
1915
self.approved = None
1806
1916
return False
1807
1917
1808
1918
def approve(self, value=True):
1809
1919
self.approved = value
1810
gobject.timeout_add(int(self.approval_duration.total_seconds()
1811
* 1000), self._reset_approved)
1920
GLib.timeout_add(int(self.approval_duration.total_seconds()
1921
* 1000), self._reset_approved)
1812
1922
self.send_changedstate()
1813
1814
## D-Bus methods, signals & properties
1815
1816
## Interfaces
1817
1818
## Signals
1819
1923
1924
# D-Bus methods, signals & properties
1925
1926
# Interfaces
1927
1928
# Signals
1929
1820
1930
# CheckerCompleted - signal
1821
1931
@dbus.service.signal(_interface, signature="nxs")
1822
1932
def CheckerCompleted(self, exitcode, waitstatus, command):
1823
1933
"D-Bus signal"
1824
1934
pass
1825
1935
1826
1936
# CheckerStarted - signal
1827
1937
@dbus.service.signal(_interface, signature="s")
1828
1938
def CheckerStarted(self, command):
1829
1939
"D-Bus signal"
1830
1940
pass
1831
1941
1832
1942
# PropertyChanged - signal
1833
1943
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1834
1944
@dbus.service.signal(_interface, signature="sv")
1835
1945
def PropertyChanged(self, property, value):
1836
1946
"D-Bus signal"
1837
1947
pass
1838
1948
1839
1949
# GotSecret - signal
1840
1950
@dbus.service.signal(_interface)
1841
1951
def GotSecret(self):
1844
1954
server to mandos-client
1845
1955
"""
1846
1956
pass
1847
1957
1848
1958
# Rejected - signal
1849
1959
@dbus.service.signal(_interface, signature="s")
1850
1960
def Rejected(self, reason):
1851
1961
"D-Bus signal"
1852
1962
pass
1853
1963
1854
1964
# NeedApproval - signal
1855
1965
@dbus.service.signal(_interface, signature="tb")
1856
1966
def NeedApproval(self, timeout, default):
1857
1967
"D-Bus signal"
1858
1968
return self.need_approval()
1859
1860
## Methods
1861
1969
1970
# Methods
1971
1862
1972
# Approve - method
1863
1973
@dbus.service.method(_interface, in_signature="b")
1864
1974
def Approve(self, value):
1865
1975
self.approve(value)
1866
1976
1867
1977
# CheckedOK - method
1868
1978
@dbus.service.method(_interface)
1869
1979
def CheckedOK(self):
1870
1980
self.checked_ok()
1871
1981
1872
1982
# Enable - method
1873
1983
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1874
1984
@dbus.service.method(_interface)
1875
1985
def Enable(self):
1876
1986
"D-Bus method"
1877
1987
self.enable()
1878
1988
1879
1989
# StartChecker - method
1880
1990
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1881
1991
@dbus.service.method(_interface)
1882
1992
def StartChecker(self):
1883
1993
"D-Bus method"
1884
1994
self.start_checker()
1885
1995
1886
1996
# Disable - method
1887
1997
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1888
1998
@dbus.service.method(_interface)
1889
1999
def Disable(self):
1890
2000
"D-Bus method"
1891
2001
self.disable()
1892
2002
1893
2003
# StopChecker - method
1894
2004
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1895
2005
@dbus.service.method(_interface)
1896
2006
def StopChecker(self):
1897
2007
self.stop_checker()
1898
1899
## Properties
1900
2008
2009
# Properties
2010
1901
2011
# ApprovalPending - property
1902
2012
@dbus_service_property(_interface, signature="b", access="read")
1903
2013
def ApprovalPending_dbus_property(self):
1904
2014
return dbus.Boolean(bool(self.approvals_pending))
1905
2015
1906
2016
# ApprovedByDefault - property
1907
2017
@dbus_service_property(_interface,
1908
2018
signature="b",
1911
2021
if value is None: # get
1912
2022
return dbus.Boolean(self.approved_by_default)
1913
2023
self.approved_by_default = bool(value)
1914
2024
1915
2025
# ApprovalDelay - property
1916
2026
@dbus_service_property(_interface,
1917
2027
signature="t",
1921
2031
return dbus.UInt64(self.approval_delay.total_seconds()
1922
2032
* 1000)
1923
2033
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1924
2034
1925
2035
# ApprovalDuration - property
1926
2036
@dbus_service_property(_interface,
1927
2037
signature="t",
1931
2041
return dbus.UInt64(self.approval_duration.total_seconds()
1932
2042
* 1000)
1933
2043
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1934
2044
1935
2045
# Name - property
1936
2046
@dbus_annotations(
1937
2047
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1938
2048
@dbus_service_property(_interface, signature="s", access="read")
1939
2049
def Name_dbus_property(self):
1940
2050
return dbus.String(self.name)
1941
2051
2052
# KeyID - property
2053
@dbus_annotations(
2054
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2055
@dbus_service_property(_interface, signature="s", access="read")
2056
def KeyID_dbus_property(self):
2057
return dbus.String(self.key_id)
2058
1942
2059
# Fingerprint - property
1943
2060
@dbus_annotations(
1944
2061
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1945
2062
@dbus_service_property(_interface, signature="s", access="read")
1946
2063
def Fingerprint_dbus_property(self):
1947
2064
return dbus.String(self.fingerprint)
1948
2065
1949
2066
# Host - property
1950
2067
@dbus_service_property(_interface,
1951
2068
signature="s",
1954
2071
if value is None: # get
1955
2072
return dbus.String(self.host)
1956
2073
self.host = str(value)
1957
2074
1958
2075
# Created - property
1959
2076
@dbus_annotations(
1960
2077
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1961
2078
@dbus_service_property(_interface, signature="s", access="read")
1962
2079
def Created_dbus_property(self):
1963
2080
return datetime_to_dbus(self.created)
1964
2081
1965
2082
# LastEnabled - property
1966
2083
@dbus_service_property(_interface, signature="s", access="read")
1967
2084
def LastEnabled_dbus_property(self):
1968
2085
return datetime_to_dbus(self.last_enabled)
1969
2086
1970
2087
# Enabled - property
1971
2088
@dbus_service_property(_interface,
1972
2089
signature="b",
1978
2095
self.enable()
1979
2096
else:
1980
2097
self.disable()
1981
2098
1982
2099
# LastCheckedOK - property
1983
2100
@dbus_service_property(_interface,
1984
2101
signature="s",
1988
2105
self.checked_ok()
1989
2106
return
1990
2107
return datetime_to_dbus(self.last_checked_ok)
1991
2108
1992
2109
# LastCheckerStatus - property
1993
2110
@dbus_service_property(_interface, signature="n", access="read")
1994
2111
def LastCheckerStatus_dbus_property(self):
1995
2112
return dbus.Int16(self.last_checker_status)
1996
2113
1997
2114
# Expires - property
1998
2115
@dbus_service_property(_interface, signature="s", access="read")
1999
2116
def Expires_dbus_property(self):
2000
2117
return datetime_to_dbus(self.expires)
2001
2118
2002
2119
# LastApprovalRequest - property
2003
2120
@dbus_service_property(_interface, signature="s", access="read")
2004
2121
def LastApprovalRequest_dbus_property(self):
2005
2122
return datetime_to_dbus(self.last_approval_request)
2006
2123
2007
2124
# Timeout - property
2008
2125
@dbus_service_property(_interface,
2009
2126
signature="t",
2024
2141
if (getattr(self, "disable_initiator_tag", None)
2025
2142
is None):
2026
2143
return
2027
gobject.source_remove(self.disable_initiator_tag)
2028
self.disable_initiator_tag = gobject.timeout_add(
2144
GLib.source_remove(self.disable_initiator_tag)
2145
self.disable_initiator_tag = GLib.timeout_add(
2029
2146
int((self.expires - now).total_seconds() * 1000),
2030
2147
self.disable)
2031
2148
2032
2149
# ExtendedTimeout - property
2033
2150
@dbus_service_property(_interface,
2034
2151
signature="t",
2038
2155
return dbus.UInt64(self.extended_timeout.total_seconds()
2039
2156
* 1000)
2040
2157
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
2041
2158
2042
2159
# Interval - property
2043
2160
@dbus_service_property(_interface,
2044
2161
signature="t",
2051
2168
return
2052
2169
if self.enabled:
2053
2170
# Reschedule checker run
2054
gobject.source_remove(self.checker_initiator_tag)
2055
self.checker_initiator_tag = gobject.timeout_add(
2171
GLib.source_remove(self.checker_initiator_tag)
2172
self.checker_initiator_tag = GLib.timeout_add(
2056
2173
value, self.start_checker)
2057
self.start_checker() # Start one now, too
2058
2174
self.start_checker() # Start one now, too
2175
2059
2176
# Checker - property
2060
2177
@dbus_service_property(_interface,
2061
2178
signature="s",
2064
2181
if value is None: # get
2065
2182
return dbus.String(self.checker_command)
2066
2183
self.checker_command = str(value)
2067
2184
2068
2185
# CheckerRunning - property
2069
2186
@dbus_service_property(_interface,
2070
2187
signature="b",
2076
2193
self.start_checker()
2077
2194
else:
2078
2195
self.stop_checker()
2079
2196
2080
2197
# ObjectPath - property
2081
2198
@dbus_annotations(
2082
2199
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",
2083
2200
"org.freedesktop.DBus.Deprecated": "true"})
2084
2201
@dbus_service_property(_interface, signature="o", access="read")
2085
2202
def ObjectPath_dbus_property(self):
2086
return self.dbus_object_path # is already a dbus.ObjectPath
2087
2203
return self.dbus_object_path # is already a dbus.ObjectPath
2204
2088
2205
# Secret = property
2089
2206
@dbus_annotations(
2090
2207
{"org.freedesktop.DBus.Property.EmitsChangedSignal":
2095
2212
byte_arrays=True)
2096
2213
def Secret_dbus_property(self, value):
2097
2214
self.secret = bytes(value)
2098
2215
2099
2216
del _interface
2100
2217
2101
2218
2102
class ProxyClient(object):
2103
def __init__(self, child_pipe, fpr, address):
2219
class ProxyClient:
2220
def __init__(self, child_pipe, key_id, fpr, address):
2104
2221
self._pipe = child_pipe
2105
self._pipe.send(('init', fpr, address))
2222
self._pipe.send(('init', key_id, fpr, address))
2106
2223
if not self._pipe.recv():
2107
raise KeyError(fpr)
2108
2224
raise KeyError(key_id or fpr)
2225
2109
2226
def __getattribute__(self, name):
2110
2227
if name == '_pipe':
2111
2228
return super(ProxyClient, self).__getattribute__(name)
2114
2231
if data[0] == 'data':
2115
2232
return data[1]
2116
2233
if data[0] == 'function':
2117
2234
2118
2235
def func(*args, **kwargs):
2119
2236
self._pipe.send(('funcall', name, args, kwargs))
2120
2237
return self._pipe.recv()[1]
2121
2238
2122
2239
return func
2123
2240
2124
2241
def __setattr__(self, name, value):
2125
2242
if name == '_pipe':
2126
2243
return super(ProxyClient, self).__setattr__(name, value)
2129
2246
2130
2247
class ClientHandler(socketserver.BaseRequestHandler, object):
2131
2248
"""A class to handle client connections.
2132
2249
2133
2250
Instantiated once for each connection to handle it.
2134
2251
Note: This will run in its own forked process."""
2135
2252
2136
2253
def handle(self):
2137
2254
with contextlib.closing(self.server.child_pipe) as child_pipe:
2138
2255
logger.info("TCP connection from: %s",
2139
2256
str(self.client_address))
2140
2257
logger.debug("Pipe FD: %d",
2141
2258
self.server.child_pipe.fileno())
2142
2259
2143
2260
session = gnutls.ClientSession(self.request)
2144
2145
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
2146
# "+AES-256-CBC", "+SHA1",
2147
# "+COMP-NULL", "+CTYPE-OPENPGP",
2148
# "+DHE-DSS"))
2261
2262
# priority = ':'.join(("NONE", "+VERS-TLS1.1",
2263
# "+AES-256-CBC", "+SHA1",
2264
# "+COMP-NULL", "+CTYPE-OPENPGP",
2265
# "+DHE-DSS"))
2149
2266
# Use a fallback default, since this MUST be set.
2150
2267
priority = self.server.gnutls_priority
2151
2268
if priority is None:
2152
2269
priority = "NORMAL"
2153
gnutls.priority_set_direct(session._c_object, priority,
2270
gnutls.priority_set_direct(session._c_object,
2271
priority.encode("utf-8"),
2154
2272
None)
2155
2273
2156
2274
# Start communication using the Mandos protocol
2157
2275
# Get protocol number
2158
2276
line = self.request.makefile().readline()
2163
2281
except (ValueError, IndexError, RuntimeError) as error:
2164
2282
logger.error("Unknown protocol version: %s", error)
2165
2283
return
2166
2284
2167
2285
# Start GnuTLS connection
2168
2286
try:
2169
2287
session.handshake()
2173
2291
# established. Just abandon the request.
2174
2292
return
2175
2293
logger.debug("Handshake succeeded")
2176
2294
2177
2295
approval_required = False
2178
2296
try:
2179
try:
2180
fpr = self.fingerprint(
2181
self.peer_certificate(session))
2182
except (TypeError, gnutls.Error) as error:
2183
logger.warning("Bad certificate: %s", error)
2184
return
2185
logger.debug("Fingerprint: %s", fpr)
2186
2187
try:
2188
client = ProxyClient(child_pipe, fpr,
2297
if gnutls.has_rawpk:
2298
fpr = b""
2299
try:
2300
key_id = self.key_id(
2301
self.peer_certificate(session))
2302
except (TypeError, gnutls.Error) as error:
2303
logger.warning("Bad certificate: %s", error)
2304
return
2305
logger.debug("Key ID: %s", key_id)
2306
2307
else:
2308
key_id = b""
2309
try:
2310
fpr = self.fingerprint(
2311
self.peer_certificate(session))
2312
except (TypeError, gnutls.Error) as error:
2313
logger.warning("Bad certificate: %s", error)
2314
return
2315
logger.debug("Fingerprint: %s", fpr)
2316
2317
try:
2318
client = ProxyClient(child_pipe, key_id, fpr,
2189
2319
self.client_address)
2190
2320
except KeyError:
2191
2321
return
2192
2322
2193
2323
if client.approval_delay:
2194
2324
delay = client.approval_delay
2195
2325
client.approvals_pending += 1
2196
2326
approval_required = True
2197
2327
2198
2328
while True:
2199
2329
if not client.enabled:
2200
2330
logger.info("Client %s is disabled",
2203
2333
# Emit D-Bus signal
2204
2334
client.Rejected("Disabled")
2205
2335
return
2206
2336
2207
2337
if client.approved or not client.approval_delay:
2208
#We are approved or approval is disabled
2338
# We are approved or approval is disabled
2209
2339
break
2210
2340
elif client.approved is None:
2211
2341
logger.info("Client %s needs approval",
2222
2352
# Emit D-Bus signal
2223
2353
client.Rejected("Denied")
2224
2354
return
2225
2226
#wait until timeout or approved
2355
2356
# wait until timeout or approved
2227
2357
time = datetime.datetime.now()
2228
2358
client.changedstate.acquire()
2229
2359
client.changedstate.wait(delay.total_seconds())
2242
2372
break
2243
2373
else:
2244
2374
delay -= time2 - time
2245
2375
2246
2376
try:
2247
2377
session.send(client.secret)
2248
2378
except gnutls.Error as error:
2249
2379
logger.warning("gnutls send failed",
2250
exc_info = error)
2380
exc_info=error)
2251
2381
return
2252
2382
2253
2383
logger.info("Sending secret to %s", client.name)
2254
2384
# bump the timeout using extended_timeout
2255
2385
client.bump_timeout(client.extended_timeout)
2256
2386
if self.server.use_dbus:
2257
2387
# Emit D-Bus signal
2258
2388
client.GotSecret()
2259
2389
2260
2390
finally:
2261
2391
if approval_required:
2262
2392
client.approvals_pending -= 1
2265
2395
except gnutls.Error as error:
2266
2396
logger.warning("GnuTLS bye failed",
2267
2397
exc_info=error)
2268
2398
2269
2399
@staticmethod
2270
2400
def peer_certificate(session):
2271
"Return the peer's OpenPGP certificate as a bytestring"
2272
# If not an OpenPGP certificate...
2273
if (gnutls.certificate_type_get(session._c_object)
2274
!= gnutls.CRT_OPENPGP):
2401
"Return the peer's certificate as a bytestring"
2402
try:
2403
cert_type = gnutls.certificate_type_get2(session._c_object,
2404
gnutls.CTYPE_PEERS)
2405
except AttributeError:
2406
cert_type = gnutls.certificate_type_get(session._c_object)
2407
if gnutls.has_rawpk:
2408
valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2409
else:
2410
valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2411
# If not a valid certificate type...
2412
if cert_type not in valid_cert_types:
2413
logger.info("Cert type %r not in %r", cert_type,
2414
valid_cert_types)
2275
2415
# ...return invalid data
2276
2416
return b""
2277
2417
list_size = ctypes.c_uint(1)
2283
2423
return None
2284
2424
cert = cert_list[0]
2285
2425
return ctypes.string_at(cert.data, cert.size)
2286
2426
2427
@staticmethod
2428
def key_id(certificate):
2429
"Convert a certificate bytestring to a hexdigit key ID"
2430
# New GnuTLS "datum" with the public key
2431
datum = gnutls.datum_t(
2432
ctypes.cast(ctypes.c_char_p(certificate),
2433
ctypes.POINTER(ctypes.c_ubyte)),
2434
ctypes.c_uint(len(certificate)))
2435
# XXX all these need to be created in the gnutls "module"
2436
# New empty GnuTLS certificate
2437
pubkey = gnutls.pubkey_t()
2438
gnutls.pubkey_init(ctypes.byref(pubkey))
2439
# Import the raw public key into the certificate
2440
gnutls.pubkey_import(pubkey,
2441
ctypes.byref(datum),
2442
gnutls.X509_FMT_DER)
2443
# New buffer for the key ID
2444
buf = ctypes.create_string_buffer(32)
2445
buf_len = ctypes.c_size_t(len(buf))
2446
# Get the key ID from the raw public key into the buffer
2447
gnutls.pubkey_get_key_id(pubkey,
2448
gnutls.KEYID_USE_SHA256,
2449
ctypes.cast(ctypes.byref(buf),
2450
ctypes.POINTER(ctypes.c_ubyte)),
2451
ctypes.byref(buf_len))
2452
# Deinit the certificate
2453
gnutls.pubkey_deinit(pubkey)
2454
2455
# Convert the buffer to a Python bytestring
2456
key_id = ctypes.string_at(buf, buf_len.value)
2457
# Convert the bytestring to hexadecimal notation
2458
hex_key_id = binascii.hexlify(key_id).upper()
2459
return hex_key_id
2460
2287
2461
@staticmethod
2288
2462
def fingerprint(openpgp):
2289
2463
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
2304
2478
ctypes.byref(crtverify))
2305
2479
if crtverify.value != 0:
2306
2480
gnutls.openpgp_crt_deinit(crt)
2307
raise gnutls.CertificateSecurityError("Verify failed")
2481
raise gnutls.CertificateSecurityError(code
2482
=crtverify.value)
2308
2483
# New buffer for the fingerprint
2309
2484
buf = ctypes.create_string_buffer(20)
2310
2485
buf_len = ctypes.c_size_t()
2320
2495
return hex_fpr
2321
2496
2322
2497
2323
class MultiprocessingMixIn(object):
2498
class MultiprocessingMixIn:
2324
2499
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
2325
2500
2326
2501
def sub_process_main(self, request, address):
2327
2502
try:
2328
2503
self.finish_request(request, address)
2329
2504
except Exception:
2330
2505
self.handle_error(request, address)
2331
2506
self.close_request(request)
2332
2507
2333
2508
def process_request(self, request, address):
2334
2509
"""Start a new process to process the request."""
2335
proc = multiprocessing.Process(target = self.sub_process_main,
2336
args = (request, address))
2510
proc = multiprocessing.Process(target=self.sub_process_main,
2511
args=(request, address))
2337
2512
proc.start()
2338
2513
return proc
2339
2514
2340
2515
2341
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
2516
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2342
2517
""" adds a pipe to the MixIn """
2343
2518
2344
2519
def process_request(self, request, client_address):
2345
2520
"""Overrides and wraps the original process_request().
2346
2521
2347
2522
This function creates a new pipe in self.pipe
2348
2523
"""
2349
2524
parent_pipe, self.child_pipe = multiprocessing.Pipe()
2350
2525
2351
2526
proc = MultiprocessingMixIn.process_request(self, request,
2352
2527
client_address)
2353
2528
self.child_pipe.close()
2354
2529
self.add_pipe(parent_pipe, proc)
2355
2530
2356
2531
def add_pipe(self, parent_pipe, proc):
2357
2532
"""Dummy function; override as necessary"""
2358
2533
raise NotImplementedError()
2359
2534
2360
2535
2361
2536
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2362
socketserver.TCPServer, object):
2537
socketserver.TCPServer):
2363
2538
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
2364
2539
2365
2540
Attributes:
2366
2541
enabled: Boolean; whether this server is activated yet
2367
2542
interface: None or a network interface name (string)
2368
2543
use_ipv6: Boolean; to use IPv6 or not
2369
2544
"""
2370
2545
2371
2546
def __init__(self, server_address, RequestHandlerClass,
2372
2547
interface=None,
2373
2548
use_ipv6=True,
2383
2558
self.socketfd = socketfd
2384
2559
# Save the original socket.socket() function
2385
2560
self.socket_socket = socket.socket
2561
2386
2562
# To implement --socket, we monkey patch socket.socket.
2387
#
2563
#
2388
2564
# (When socketserver.TCPServer is a new-style class, we
2389
2565
# could make self.socket into a property instead of monkey
2390
2566
# patching socket.socket.)
2391
#
2567
#
2392
2568
# Create a one-time-only replacement for socket.socket()
2393
2569
@functools.wraps(socket.socket)
2394
2570
def socket_wrapper(*args, **kwargs):
2406
2582
# socket_wrapper(), if socketfd was set.
2407
2583
socketserver.TCPServer.__init__(self, server_address,
2408
2584
RequestHandlerClass)
2409
2585
2410
2586
def server_bind(self):
2411
2587
"""This overrides the normal server_bind() function
2412
2588
to bind to an interface if one was specified, and also NOT to
2413
2589
bind to an address or port if they were not specified."""
2590
global SO_BINDTODEVICE
2414
2591
if self.interface is not None:
2415
2592
if SO_BINDTODEVICE is None:
2416
logger.error("SO_BINDTODEVICE does not exist;"
2417
" cannot bind to interface %s",
2418
self.interface)
2419
else:
2420
try:
2421
self.socket.setsockopt(
2422
socket.SOL_SOCKET, SO_BINDTODEVICE,
2423
(self.interface + "\0").encode("utf-8"))
2424
except socket.error as error:
2425
if error.errno == errno.EPERM:
2426
logger.error("No permission to bind to"
2427
" interface %s", self.interface)
2428
elif error.errno == errno.ENOPROTOOPT:
2429
logger.error("SO_BINDTODEVICE not available;"
2430
" cannot bind to interface %s",
2431
self.interface)
2432
elif error.errno == errno.ENODEV:
2433
logger.error("Interface %s does not exist,"
2434
" cannot bind", self.interface)
2435
else:
2436
raise
2593
# Fall back to a hard-coded value which seems to be
2594
# common enough.
2595
logger.warning("SO_BINDTODEVICE not found, trying 25")
2596
SO_BINDTODEVICE = 25
2597
try:
2598
self.socket.setsockopt(
2599
socket.SOL_SOCKET, SO_BINDTODEVICE,
2600
(self.interface + "\0").encode("utf-8"))
2601
except socket.error as error:
2602
if error.errno == errno.EPERM:
2603
logger.error("No permission to bind to"
2604
" interface %s", self.interface)
2605
elif error.errno == errno.ENOPROTOOPT:
2606
logger.error("SO_BINDTODEVICE not available;"
2607
" cannot bind to interface %s",
2608
self.interface)
2609
elif error.errno == errno.ENODEV:
2610
logger.error("Interface %s does not exist,"
2611
" cannot bind", self.interface)
2612
else:
2613
raise
2437
2614
# Only bind(2) the socket if we really need to.
2438
2615
if self.server_address[0] or self.server_address[1]:
2616
if self.server_address[1]:
2617
self.allow_reuse_address = True
2439
2618
if not self.server_address[0]:
2440
2619
if self.address_family == socket.AF_INET6:
2441
any_address = "::" # in6addr_any
2620
any_address = "::" # in6addr_any
2442
2621
else:
2443
any_address = "0.0.0.0" # INADDR_ANY
2622
any_address = "0.0.0.0" # INADDR_ANY
2444
2623
self.server_address = (any_address,
2445
2624
self.server_address[1])
2446
2625
elif not self.server_address[1]:
2456
2635
2457
2636
class MandosServer(IPv6_TCPServer):
2458
2637
"""Mandos server.
2459
2638
2460
2639
Attributes:
2461
2640
clients: set of Client objects
2462
2641
gnutls_priority GnuTLS priority string
2463
2642
use_dbus: Boolean; to emit D-Bus signals or not
2464
2465
Assumes a gobject.MainLoop event loop.
2643
2644
Assumes a GLib.MainLoop event loop.
2466
2645
"""
2467
2646
2468
2647
def __init__(self, server_address, RequestHandlerClass,
2469
2648
interface=None,
2470
2649
use_ipv6=True,
2480
2659
self.gnutls_priority = gnutls_priority
2481
2660
IPv6_TCPServer.__init__(self, server_address,
2482
2661
RequestHandlerClass,
2483
interface = interface,
2484
use_ipv6 = use_ipv6,
2485
socketfd = socketfd)
2486
2662
interface=interface,
2663
use_ipv6=use_ipv6,
2664
socketfd=socketfd)
2665
2487
2666
def server_activate(self):
2488
2667
if self.enabled:
2489
2668
return socketserver.TCPServer.server_activate(self)
2490
2669
2491
2670
def enable(self):
2492
2671
self.enabled = True
2493
2672
2494
2673
def add_pipe(self, parent_pipe, proc):
2495
2674
# Call "handle_ipc" for both data and EOF events
2496
gobject.io_add_watch(
2675
GLib.io_add_watch(
2497
2676
parent_pipe.fileno(),
2498
gobject.IO_IN | gobject.IO_HUP,
2677
GLib.IO_IN | GLib.IO_HUP,
2499
2678
functools.partial(self.handle_ipc,
2500
parent_pipe = parent_pipe,
2501
proc = proc))
2502
2679
parent_pipe=parent_pipe,
2680
proc=proc))
2681
2503
2682
def handle_ipc(self, source, condition,
2504
2683
parent_pipe=None,
2505
proc = None,
2684
proc=None,
2506
2685
client_object=None):
2507
2686
# error, or the other end of multiprocessing.Pipe has closed
2508
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2687
if condition & (GLib.IO_ERR | GLib.IO_HUP):
2509
2688
# Wait for other process to exit
2510
2689
proc.join()
2511
2690
return False
2512
2691
2513
2692
# Read a request from the child
2514
2693
request = parent_pipe.recv()
2515
2694
command = request[0]
2516
2695
2517
2696
if command == 'init':
2518
fpr = request[1]
2519
address = request[2]
2520
2521
for c in self.clients.itervalues():
2522
if c.fingerprint == fpr:
2697
key_id = request[1].decode("ascii")
2698
fpr = request[2].decode("ascii")
2699
address = request[3]
2700
2701
for c in self.clients.values():
2702
if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":
2703
continue
2704
if key_id and c.key_id == key_id:
2705
client = c
2706
break
2707
if fpr and c.fingerprint == fpr:
2523
2708
client = c
2524
2709
break
2525
2710
else:
2526
logger.info("Client not found for fingerprint: %s, ad"
2527
"dress: %s", fpr, address)
2711
logger.info("Client not found for key ID: %s, address"
2712
": %s", key_id or fpr, address)
2528
2713
if self.use_dbus:
2529
2714
# Emit D-Bus signal
2530
mandos_dbus_service.ClientNotFound(fpr,
2715
mandos_dbus_service.ClientNotFound(key_id or fpr,
2531
2716
address[0])
2532
2717
parent_pipe.send(False)
2533
2718
return False
2534
2535
gobject.io_add_watch(
2719
2720
GLib.io_add_watch(
2536
2721
parent_pipe.fileno(),
2537
gobject.IO_IN | gobject.IO_HUP,
2722
GLib.IO_IN | GLib.IO_HUP,
2538
2723
functools.partial(self.handle_ipc,
2539
parent_pipe = parent_pipe,
2540
proc = proc,
2541
client_object = client))
2724
parent_pipe=parent_pipe,
2725
proc=proc,
2726
client_object=client))
2542
2727
parent_pipe.send(True)
2543
2728
# remove the old hook in favor of the new above hook on
2544
2729
# same fileno
2547
2732
funcname = request[1]
2548
2733
args = request[2]
2549
2734
kwargs = request[3]
2550
2735
2551
2736
parent_pipe.send(('data', getattr(client_object,
2552
2737
funcname)(*args,
2553
2738
**kwargs)))
2554
2739
2555
2740
if command == 'getattr':
2556
2741
attrname = request[1]
2557
2742
if isinstance(client_object.__getattribute__(attrname),
2560
2745
else:
2561
2746
parent_pipe.send((
2562
2747
'data', client_object.__getattribute__(attrname)))
2563
2748
2564
2749
if command == 'setattr':
2565
2750
attrname = request[1]
2566
2751
value = request[2]
2567
2752
setattr(client_object, attrname, value)
2568
2753
2569
2754
return True
2570
2755
2571
2756
2572
2757
def rfc3339_duration_to_delta(duration):
2573
2758
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2574
2759
2575
2760
>>> rfc3339_duration_to_delta("P7D")
2576
2761
datetime.timedelta(7)
2577
2762
>>> rfc3339_duration_to_delta("PT60S")
2587
2772
>>> rfc3339_duration_to_delta("P1DT3M20S")
2588
2773
datetime.timedelta(1, 200)
2589
2774
"""
2590
2775
2591
2776
# Parsing an RFC 3339 duration with regular expressions is not
2592
2777
# possible - there would have to be multiple places for the same
2593
2778
# values, like seconds. The current code, while more esoteric, is
2594
2779
# cleaner without depending on a parsing library. If Python had a
2595
2780
# built-in library for parsing we would use it, but we'd like to
2596
2781
# avoid excessive use of external libraries.
2597
2782
2598
2783
# New type for defining tokens, syntax, and semantics all-in-one
2599
2784
Token = collections.namedtuple("Token", (
2600
2785
"regexp", # To match token; if "value" is not None, must have
2633
2818
frozenset((token_year, token_month,
2634
2819
token_day, token_time,
2635
2820
token_week)))
2636
# Define starting values
2637
value = datetime.timedelta() # Value so far
2821
# Define starting values:
2822
# Value so far
2823
value = datetime.timedelta()
2638
2824
found_token = None
2639
followers = frozenset((token_duration, )) # Following valid tokens
2640
s = duration # String left to parse
2825
# Following valid tokens
2826
followers = frozenset((token_duration, ))
2827
# String left to parse
2828
s = duration
2641
2829
# Loop until end token is found
2642
2830
while found_token is not token_end:
2643
2831
# Search for any currently valid tokens
2667
2855
2668
2856
def string_to_delta(interval):
2669
2857
"""Parse a string and return a datetime.timedelta
2670
2858
2671
2859
>>> string_to_delta('7d')
2672
2860
datetime.timedelta(7)
2673
2861
>>> string_to_delta('60s')
2681
2869
>>> string_to_delta('5m 30s')
2682
2870
datetime.timedelta(0, 330)
2683
2871
"""
2684
2872
2685
2873
try:
2686
2874
return rfc3339_duration_to_delta(interval)
2687
2875
except ValueError:
2688
2876
pass
2689
2877
2690
2878
timevalue = datetime.timedelta(0)
2691
2879
for s in interval.split():
2692
2880
try:
2710
2898
return timevalue
2711
2899
2712
2900
2713
def daemon(nochdir = False, noclose = False):
2901
def daemon(nochdir=False, noclose=False):
2714
2902
"""See daemon(3). Standard BSD Unix function.
2715
2903
2716
2904
This should really exist as os.daemon, but it doesn't (yet)."""
2717
2905
if os.fork():
2718
2906
sys.exit()
2736
2924
2737
2925
2738
2926
def main():
2739
2927
2740
2928
##################################################################
2741
2929
# Parsing of options, both command line and config file
2742
2930
2743
2931
parser = argparse.ArgumentParser()
2744
2932
parser.add_argument("-v", "--version", action="version",
2745
version = "%(prog)s {}".format(version),
2933
version="%(prog)s {}".format(version),
2746
2934
help="show version number and exit")
2747
2935
parser.add_argument("-i", "--interface", metavar="IF",
2748
2936
help="Bind to interface IF")
2784
2972
parser.add_argument("--no-zeroconf", action="store_false",
2785
2973
dest="zeroconf", help="Do not use Zeroconf",
2786
2974
default=None)
2787
2975
2788
2976
options = parser.parse_args()
2789
2977
2790
2978
if options.check:
2791
2979
import doctest
2792
2980
fail_count, test_count = doctest.testmod()
2793
2981
sys.exit(os.EX_OK if fail_count == 0 else 1)
2794
2982
2795
2983
# Default values for config file for server-global settings
2796
server_defaults = { "interface": "",
2797
"address": "",
2798
"port": "",
2799
"debug": "False",
2800
"priority":
2801
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2802
":+SIGN-DSA-SHA256",
2803
"servicename": "Mandos",
2804
"use_dbus": "True",
2805
"use_ipv6": "True",
2806
"debuglevel": "",
2807
"restore": "True",
2808
"socket": "",
2809
"statedir": "/var/lib/mandos",
2810
"foreground": "False",
2811
"zeroconf": "True",
2812
}
2813
2984
if gnutls.has_rawpk:
2985
priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
2986
":!VERS-ALL:+VERS-TLS1.3:%PROFILE_ULTRA")
2987
else:
2988
priority = ("SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2989
":+SIGN-DSA-SHA256")
2990
server_defaults = {"interface": "",
2991
"address": "",
2992
"port": "",
2993
"debug": "False",
2994
"priority": priority,
2995
"servicename": "Mandos",
2996
"use_dbus": "True",
2997
"use_ipv6": "True",
2998
"debuglevel": "",
2999
"restore": "True",
3000
"socket": "",
3001
"statedir": "/var/lib/mandos",
3002
"foreground": "False",
3003
"zeroconf": "True",
3004
}
3005
del priority
3006
2814
3007
# Parse config file for server-global settings
2815
server_config = configparser.SafeConfigParser(server_defaults)
3008
server_config = configparser.ConfigParser(server_defaults)
2816
3009
del server_defaults
2817
3010
server_config.read(os.path.join(options.configdir, "mandos.conf"))
2818
# Convert the SafeConfigParser object to a dict
3011
# Convert the ConfigParser object to a dict
2819
3012
server_settings = server_config.defaults()
2820
3013
# Use the appropriate methods on the non-string config options
2821
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
3014
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3015
"foreground", "zeroconf"):
2822
3016
server_settings[option] = server_config.getboolean("DEFAULT",
2823
3017
option)
2824
3018
if server_settings["port"]:
2834
3028
server_settings["socket"] = os.dup(server_settings
2835
3029
["socket"])
2836
3030
del server_config
2837
3031
2838
3032
# Override the settings from the config file with command line
2839
3033
# options, if set.
2840
3034
for option in ("interface", "address", "port", "debug",
2858
3052
if server_settings["debug"]:
2859
3053
server_settings["foreground"] = True
2860
3054
# Now we have our good server settings in "server_settings"
2861
3055
2862
3056
##################################################################
2863
3057
2864
3058
if (not server_settings["zeroconf"]
2865
3059
and not (server_settings["port"]
2866
3060
or server_settings["socket"] != "")):
2867
3061
parser.error("Needs port or socket to work without Zeroconf")
2868
3062
2869
3063
# For convenience
2870
3064
debug = server_settings["debug"]
2871
3065
debuglevel = server_settings["debuglevel"]
2875
3069
stored_state_file)
2876
3070
foreground = server_settings["foreground"]
2877
3071
zeroconf = server_settings["zeroconf"]
2878
3072
2879
3073
if debug:
2880
3074
initlogger(debug, logging.DEBUG)
2881
3075
else:
2884
3078
else:
2885
3079
level = getattr(logging, debuglevel.upper())
2886
3080
initlogger(debug, level)
2887
3081
2888
3082
if server_settings["servicename"] != "Mandos":
2889
3083
syslogger.setFormatter(
2890
3084
logging.Formatter('Mandos ({}) [%(process)d]:'
2891
3085
' %(levelname)s: %(message)s'.format(
2892
3086
server_settings["servicename"])))
2893
3087
2894
3088
# Parse config file with clients
2895
client_config = configparser.SafeConfigParser(Client
2896
.client_defaults)
3089
client_config = configparser.ConfigParser(Client.client_defaults)
2897
3090
client_config.read(os.path.join(server_settings["configdir"],
2898
3091
"clients.conf"))
2899
3092
2900
3093
global mandos_dbus_service
2901
3094
mandos_dbus_service = None
2902
3095
2903
3096
socketfd = None
2904
3097
if server_settings["socket"] != "":
2905
3098
socketfd = server_settings["socket"]
2921
3114
except IOError as e:
2922
3115
logger.error("Could not open file %r", pidfilename,
2923
3116
exc_info=e)
2924
2925
for name in ("_mandos", "mandos", "nobody"):
3117
3118
for name, group in (("_mandos", "_mandos"),
3119
("mandos", "mandos"),
3120
("nobody", "nogroup")):
2926
3121
try:
2927
3122
uid = pwd.getpwnam(name).pw_uid
2928
gid = pwd.getpwnam(name).pw_gid
3123
gid = pwd.getpwnam(group).pw_gid
2929
3124
break
2930
3125
except KeyError:
2931
3126
continue
2935
3130
try:
2936
3131
os.setgid(gid)
2937
3132
os.setuid(uid)
3133
if debug:
3134
logger.debug("Did setuid/setgid to {}:{}".format(uid,
3135
gid))
2938
3136
except OSError as error:
3137
logger.warning("Failed to setuid/setgid to {}:{}: {}"
3138
.format(uid, gid, os.strerror(error.errno)))
2939
3139
if error.errno != errno.EPERM:
2940
3140
raise
2941
3141
2942
3142
if debug:
2943
3143
# Enable all possible GnuTLS debugging
2944
3144
2945
3145
# "Use a log level over 10 to enable all debugging options."
2946
3146
# - GnuTLS manual
2947
3147
gnutls.global_set_log_level(11)
2948
3148
2949
3149
@gnutls.log_func
2950
3150
def debug_gnutls(level, string):
2951
3151
logger.debug("GnuTLS: %s", string[:-1])
2952
3152
2953
3153
gnutls.global_set_log_function(debug_gnutls)
2954
3154
2955
3155
# Redirect stdin so all checkers get /dev/null
2956
3156
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2957
3157
os.dup2(null, sys.stdin.fileno())
2958
3158
if null > 2:
2959
3159
os.close(null)
2960
3160
2961
3161
# Need to fork before connecting to D-Bus
2962
3162
if not foreground:
2963
3163
# Close all input and output, do double fork, etc.
2964
3164
daemon()
2965
2966
# multiprocessing will use threads, so before we use gobject we
2967
# need to inform gobject that threads will be used.
2968
gobject.threads_init()
2969
3165
3166
if gi.version_info < (3, 10, 2):
3167
# multiprocessing will use threads, so before we use GLib we
3168
# need to inform GLib that threads will be used.
3169
GLib.threads_init()
3170
2970
3171
global main_loop
2971
3172
# From the Avahi example code
2972
3173
DBusGMainLoop(set_as_default=True)
2973
main_loop = gobject.MainLoop()
3174
main_loop = GLib.MainLoop()
2974
3175
bus = dbus.SystemBus()
2975
3176
# End of Avahi example code
2976
3177
if use_dbus:
2989
3190
if zeroconf:
2990
3191
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2991
3192
service = AvahiServiceToSyslog(
2992
name = server_settings["servicename"],
2993
servicetype = "_mandos._tcp",
2994
protocol = protocol,
2995
bus = bus)
3193
name=server_settings["servicename"],
3194
servicetype="_mandos._tcp",
3195
protocol=protocol,
3196
bus=bus)
2996
3197
if server_settings["interface"]:
2997
3198
service.interface = if_nametoindex(
2998
3199
server_settings["interface"].encode("utf-8"))
2999
3200
3000
3201
global multiprocessing_manager
3001
3202
multiprocessing_manager = multiprocessing.Manager()
3002
3203
3003
3204
client_class = Client
3004
3205
if use_dbus:
3005
client_class = functools.partial(ClientDBus, bus = bus)
3006
3206
client_class = functools.partial(ClientDBus, bus=bus)
3207
3007
3208
client_settings = Client.config_parser(client_config)
3008
3209
old_client_settings = {}
3009
3210
clients_data = {}
3010
3211
3011
3212
# This is used to redirect stdout and stderr for checker processes
3012
3213
global wnull
3013
wnull = open(os.devnull, "w") # A writable /dev/null
3214
wnull = open(os.devnull, "w") # A writable /dev/null
3014
3215
# Only used if server is running in foreground but not in debug
3015
3216
# mode
3016
3217
if debug or not foreground:
3017
3218
wnull.close()
3018
3219
3019
3220
# Get client data and settings from last running state.
3020
3221
if server_settings["restore"]:
3021
3222
try:
3022
3223
with open(stored_state_path, "rb") as stored_state:
3023
clients_data, old_client_settings = pickle.load(
3024
stored_state)
3224
if sys.version_info.major == 2:
3225
clients_data, old_client_settings = pickle.load(
3226
stored_state)
3227
else:
3228
bytes_clients_data, bytes_old_client_settings = (
3229
pickle.load(stored_state, encoding="bytes"))
3230
# Fix bytes to strings
3231
# clients_data
3232
# .keys()
3233
clients_data = {(key.decode("utf-8")
3234
if isinstance(key, bytes)
3235
else key): value
3236
for key, value in
3237
bytes_clients_data.items()}
3238
del bytes_clients_data
3239
for key in clients_data:
3240
value = {(k.decode("utf-8")
3241
if isinstance(k, bytes) else k): v
3242
for k, v in
3243
clients_data[key].items()}
3244
clients_data[key] = value
3245
# .client_structure
3246
value["client_structure"] = [
3247
(s.decode("utf-8")
3248
if isinstance(s, bytes)
3249
else s) for s in
3250
value["client_structure"]]
3251
# .name & .host
3252
for k in ("name", "host"):
3253
if isinstance(value[k], bytes):
3254
value[k] = value[k].decode("utf-8")
3255
if "key_id" not in value:
3256
value["key_id"] = ""
3257
elif "fingerprint" not in value:
3258
value["fingerprint"] = ""
3259
# old_client_settings
3260
# .keys()
3261
old_client_settings = {
3262
(key.decode("utf-8")
3263
if isinstance(key, bytes)
3264
else key): value
3265
for key, value in
3266
bytes_old_client_settings.items()}
3267
del bytes_old_client_settings
3268
# .host
3269
for value in old_client_settings.values():
3270
if isinstance(value["host"], bytes):
3271
value["host"] = (value["host"]
3272
.decode("utf-8"))
3025
3273
os.remove(stored_state_path)
3026
3274
except IOError as e:
3027
3275
if e.errno == errno.ENOENT:
3035
3283
logger.warning("Could not load persistent state: "
3036
3284
"EOFError:",
3037
3285
exc_info=e)
3038
3286
3039
3287
with PGPEngine() as pgp:
3040
3288
for client_name, client in clients_data.items():
3041
3289
# Skip removed clients
3042
3290
if client_name not in client_settings:
3043
3291
continue
3044
3292
3045
3293
# Decide which value to use after restoring saved state.
3046
3294
# We have three different values: Old config file,
3047
3295
# new config file, and saved state.
3058
3306
client[name] = value
3059
3307
except KeyError:
3060
3308
pass
3061
3309
3062
3310
# Clients who has passed its expire date can still be
3063
3311
# enabled if its last checker was successful. A Client
3064
3312
# whose checker succeeded before we stored its state is
3097
3345
client_name))
3098
3346
client["secret"] = (client_settings[client_name]
3099
3347
["secret"])
3100
3348
3101
3349
# Add/remove clients based on new changes made to config
3102
3350
for client_name in (set(old_client_settings)
3103
3351
- set(client_settings)):
3105
3353
for client_name in (set(client_settings)
3106
3354
- set(old_client_settings)):
3107
3355
clients_data[client_name] = client_settings[client_name]
3108
3356
3109
3357
# Create all client objects
3110
3358
for client_name, client in clients_data.items():
3111
3359
tcp_server.clients[client_name] = client_class(
3112
name = client_name,
3113
settings = client,
3114
server_settings = server_settings)
3115
3360
name=client_name,
3361
settings=client,
3362
server_settings=server_settings)
3363
3116
3364
if not tcp_server.clients:
3117
3365
logger.warning("No clients defined")
3118
3366
3119
3367
if not foreground:
3120
3368
if pidfile is not None:
3121
3369
pid = os.getpid()
3127
3375
pidfilename, pid)
3128
3376
del pidfile
3129
3377
del pidfilename
3130
3131
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
3132
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
3133
3378
3379
for termsig in (signal.SIGHUP, signal.SIGTERM):
3380
GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
3381
lambda: main_loop.quit() and False)
3382
3134
3383
if use_dbus:
3135
3384
3136
3385
@alternate_dbus_interfaces(
3137
{ "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })
3386
{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
3138
3387
class MandosDBusService(DBusObjectWithObjectManager):
3139
3388
"""A D-Bus proxy object"""
3140
3389
3141
3390
def __init__(self):
3142
3391
dbus.service.Object.__init__(self, bus, "/")
3143
3392
3144
3393
_interface = "se.recompile.Mandos"
3145
3394
3146
3395
@dbus.service.signal(_interface, signature="o")
3147
3396
def ClientAdded(self, objpath):
3148
3397
"D-Bus signal"
3149
3398
pass
3150
3399
3151
3400
@dbus.service.signal(_interface, signature="ss")
3152
def ClientNotFound(self, fingerprint, address):
3401
def ClientNotFound(self, key_id, address):
3153
3402
"D-Bus signal"
3154
3403
pass
3155
3404
3156
3405
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3157
3406
"true"})
3158
3407
@dbus.service.signal(_interface, signature="os")
3159
3408
def ClientRemoved(self, objpath, name):
3160
3409
"D-Bus signal"
3161
3410
pass
3162
3411
3163
3412
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3164
3413
"true"})
3165
3414
@dbus.service.method(_interface, out_signature="ao")
3166
3415
def GetAllClients(self):
3167
3416
"D-Bus method"
3168
3417
return dbus.Array(c.dbus_object_path for c in
3169
tcp_server.clients.itervalues())
3170
3418
tcp_server.clients.values())
3419
3171
3420
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3172
3421
"true"})
3173
3422
@dbus.service.method(_interface,
3175
3424
def GetAllClientsWithProperties(self):
3176
3425
"D-Bus method"
3177
3426
return dbus.Dictionary(
3178
{ c.dbus_object_path: c.GetAll(
3427
{c.dbus_object_path: c.GetAll(
3179
3428
"se.recompile.Mandos.Client")
3180
for c in tcp_server.clients.itervalues() },
3429
for c in tcp_server.clients.values()},
3181
3430
signature="oa{sv}")
3182
3431
3183
3432
@dbus.service.method(_interface, in_signature="o")
3184
3433
def RemoveClient(self, object_path):
3185
3434
"D-Bus method"
3186
for c in tcp_server.clients.itervalues():
3435
for c in tcp_server.clients.values():
3187
3436
if c.dbus_object_path == object_path:
3188
3437
del tcp_server.clients[c.name]
3189
3438
c.remove_from_connection()
3193
3442
self.client_removed_signal(c)
3194
3443
return
3195
3444
raise KeyError(object_path)
3196
3445
3197
3446
del _interface
3198
3447
3199
3448
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
3200
out_signature = "a{oa{sa{sv}}}")
3449
out_signature="a{oa{sa{sv}}}")
3201
3450
def GetManagedObjects(self):
3202
3451
"""D-Bus method"""
3203
3452
return dbus.Dictionary(
3204
{ client.dbus_object_path:
3205
dbus.Dictionary(
3206
{ interface: client.GetAll(interface)
3207
for interface in
3208
client._get_all_interface_names()})
3209
for client in tcp_server.clients.values()})
3210
3453
{client.dbus_object_path:
3454
dbus.Dictionary(
3455
{interface: client.GetAll(interface)
3456
for interface in
3457
client._get_all_interface_names()})
3458
for client in tcp_server.clients.values()})
3459
3211
3460
def client_added_signal(self, client):
3212
3461
"""Send the new standard signal and the old signal"""
3213
3462
if use_dbus:
3215
3464
self.InterfacesAdded(
3216
3465
client.dbus_object_path,
3217
3466
dbus.Dictionary(
3218
{ interface: client.GetAll(interface)
3219
for interface in
3220
client._get_all_interface_names()}))
3467
{interface: client.GetAll(interface)
3468
for interface in
3469
client._get_all_interface_names()}))
3221
3470
# Old signal
3222
3471
self.ClientAdded(client.dbus_object_path)
3223
3472
3224
3473
def client_removed_signal(self, client):
3225
3474
"""Send the new standard signal and the old signal"""
3226
3475
if use_dbus:
3231
3480
# Old signal
3232
3481
self.ClientRemoved(client.dbus_object_path,
3233
3482
client.name)
3234
3483
3235
3484
mandos_dbus_service = MandosDBusService()
3236
3485
3486
# Save modules to variables to exempt the modules from being
3487
# unloaded before the function registered with atexit() is run.
3488
mp = multiprocessing
3489
wn = wnull
3490
3237
3491
def cleanup():
3238
3492
"Cleanup function; run on exit"
3239
3493
if zeroconf:
3240
3494
service.cleanup()
3241
3242
multiprocessing.active_children()
3243
wnull.close()
3495
3496
mp.active_children()
3497
wn.close()
3244
3498
if not (tcp_server.clients or client_settings):
3245
3499
return
3246
3500
3247
3501
# Store client before exiting. Secrets are encrypted with key
3248
3502
# based on what config file has. If config file is
3249
3503
# removed/edited, old secret will thus be unrecovable.
3250
3504
clients = {}
3251
3505
with PGPEngine() as pgp:
3252
for client in tcp_server.clients.itervalues():
3506
for client in tcp_server.clients.values():
3253
3507
key = client_settings[client.name]["secret"]
3254
3508
client.encrypted_secret = pgp.encrypt(client.secret,
3255
3509
key)
3256
3510
client_dict = {}
3257
3511
3258
3512
# A list of attributes that can not be pickled
3259
3513
# + secret.
3260
exclude = { "bus", "changedstate", "secret",
3261
"checker", "server_settings" }
3514
exclude = {"bus", "changedstate", "secret",
3515
"checker", "server_settings"}
3262
3516
for name, typ in inspect.getmembers(dbus.service
3263
3517
.Object):
3264
3518
exclude.add(name)
3265
3519
3266
3520
client_dict["encrypted_secret"] = (client
3267
3521
.encrypted_secret)
3268
3522
for attr in client.client_structure:
3269
3523
if attr not in exclude:
3270
3524
client_dict[attr] = getattr(client, attr)
3271
3525
3272
3526
clients[client.name] = client_dict
3273
3527
del client_settings[client.name]["secret"]
3274
3528
3275
3529
try:
3276
3530
with tempfile.NamedTemporaryFile(
3277
3531
mode='wb',
3279
3533
prefix='clients-',
3280
3534
dir=os.path.dirname(stored_state_path),
3281
3535
delete=False) as stored_state:
3282
pickle.dump((clients, client_settings), stored_state)
3536
pickle.dump((clients, client_settings), stored_state,
3537
protocol=2)
3283
3538
tempname = stored_state.name
3284
3539
os.rename(tempname, stored_state_path)
3285
3540
except (IOError, OSError) as e:
3295
3550
logger.warning("Could not save persistent state:",
3296
3551
exc_info=e)
3297
3552
raise
3298
3553
3299
3554
# Delete all clients, and settings from config
3300
3555
while tcp_server.clients:
3301
3556
name, client = tcp_server.clients.popitem()
3307
3562
if use_dbus:
3308
3563
mandos_dbus_service.client_removed_signal(client)
3309
3564
client_settings.clear()
3310
3565
3311
3566
atexit.register(cleanup)
3312
3313
for client in tcp_server.clients.itervalues():
3567
3568
for client in tcp_server.clients.values():
3314
3569
if use_dbus:
3315
3570
# Emit D-Bus signal for adding
3316
3571
mandos_dbus_service.client_added_signal(client)
3317
3572
# Need to initiate checking of clients
3318
3573
if client.enabled:
3319
3574
client.init_checker()
3320
3575
3321
3576
tcp_server.enable()
3322
3577
tcp_server.server_activate()
3323
3578
3324
3579
# Find out what port we got
3325
3580
if zeroconf:
3326
3581
service.port = tcp_server.socket.getsockname()[1]
3331
3586
else: # IPv4
3332
3587
logger.info("Now listening on address %r, port %d",
3333
3588
*tcp_server.socket.getsockname())
3334
3335
#service.interface = tcp_server.socket.getsockname()[3]
3336
3589
3590
# service.interface = tcp_server.socket.getsockname()[3]
3591
3337
3592
try:
3338
3593
if zeroconf:
3339
3594
# From the Avahi example code
3344
3599
cleanup()
3345
3600
sys.exit(1)
3346
3601
# End of Avahi example code
3347
3348
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
3349
lambda *args, **kwargs:
3350
(tcp_server.handle_request
3351
(*args[2:], **kwargs) or True))
3352
3602
3603
GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3604
lambda *args, **kwargs:
3605
(tcp_server.handle_request
3606
(*args[2:], **kwargs) or True))
3607
3353
3608
logger.debug("Starting main loop")
3354
3609
main_loop.run()
3355
3610
except AvahiError as error:
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0