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.281
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.281
- Committer: Teddy Hogeborn
- Date: 2014-08-20 21:46:38 UTC
- mto: (237.7.304 trunk)
- mto: This revision was merged to the branch mainline in revision 323.
- Revision ID: teddy@recompile.se-20140820214638-k4naueej6hffdgfg
mandos-client: Bug fix: Check fork() return value.
When executing network hook scripts, check fork() return value.
* plugins.d/mandos-client.c (run_network_hooks): Bug fix: check if
fork() returns -1.
When executing network hook scripts, check fork() return value.
* plugins.d/mandos-client.c (run_network_hooks): Bug fix: check if
fork() returns -1.
- files added:
- debian/mandos-client.examples
- debian/source
- debian/upstream
- network-hooks.d
- files modified:
- .bzrignore
added
removed
mandos
1
#!/usr/bin/python
1
#!/usr/bin/python2.7
2
2
# -*- mode: python; coding: utf-8 -*-
3
3
#
4
4
# Mandos server - give out binary blobs to connecting clients.
11
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2008,2009 Teddy Hogeborn
15
# Copyright © 2008,2009 Björn Påhlsson
14
# Copyright © 2008-2014 Teddy Hogeborn
15
# Copyright © 2008-2014 Björn Påhlsson
16
16
#
17
17
# This program is free software: you can redistribute it and/or modify
18
18
# it under the terms of the GNU General Public License as published by
28
28
# along with this program. If not, see
29
29
# <http://www.gnu.org/licenses/>.
30
30
#
31
# Contact the authors at <mandos@fukt.bsnet.se>.
31
# Contact the authors at <mandos@recompile.se>.
32
32
#
33
33
34
from __future__ import division, with_statement, absolute_import
34
from __future__ import (division, absolute_import, print_function,
35
unicode_literals)
36
37
from future_builtins import *
35
38
36
39
import SocketServer as socketserver
37
40
import socket
38
import optparse
41
import argparse
39
42
import datetime
40
43
import errno
41
44
import gnutls.crypto
61
64
import functools
62
65
import cPickle as pickle
63
66
import multiprocessing
67
import types
68
import binascii
69
import tempfile
70
import itertools
71
import collections
64
72
65
73
import dbus
66
74
import dbus.service
80
88
except ImportError:
81
89
SO_BINDTODEVICE = None
82
90
83
84
version = "1.0.14"
85
86
#logger = logging.getLogger(u'mandos')
87
logger = logging.Logger(u'mandos')
88
syslogger = (logging.handlers.SysLogHandler
89
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
90
address = "/dev/log"))
91
syslogger.setFormatter(logging.Formatter
92
(u'Mandos [%(process)d]: %(levelname)s:'
93
u' %(message)s'))
94
logger.addHandler(syslogger)
95
96
console = logging.StreamHandler()
97
console.setFormatter(logging.Formatter(u'%(name)s [%(process)d]:'
98
u' %(levelname)s:'
99
u' %(message)s'))
100
logger.addHandler(console)
91
if sys.version_info.major == 2:
92
str = unicode
93
94
version = "1.6.8"
95
stored_state_file = "clients.pickle"
96
97
logger = logging.getLogger()
98
syslogger = None
99
100
try:
101
if_nametoindex = (ctypes.cdll.LoadLibrary
102
(ctypes.util.find_library("c"))
103
.if_nametoindex)
104
except (OSError, AttributeError):
105
def if_nametoindex(interface):
106
"Get an interface index the hard way, i.e. using fcntl()"
107
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
108
with contextlib.closing(socket.socket()) as s:
109
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
110
struct.pack(b"16s16x", interface))
111
interface_index = struct.unpack("I", ifreq[16:20])[0]
112
return interface_index
113
114
115
def initlogger(debug, level=logging.WARNING):
116
"""init logger and add loglevel"""
117
118
global syslogger
119
syslogger = (logging.handlers.SysLogHandler
120
(facility =
121
logging.handlers.SysLogHandler.LOG_DAEMON,
122
address = "/dev/log"))
123
syslogger.setFormatter(logging.Formatter
124
('Mandos [%(process)d]: %(levelname)s:'
125
' %(message)s'))
126
logger.addHandler(syslogger)
127
128
if debug:
129
console = logging.StreamHandler()
130
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
131
' [%(process)d]:'
132
' %(levelname)s:'
133
' %(message)s'))
134
logger.addHandler(console)
135
logger.setLevel(level)
136
137
138
class PGPError(Exception):
139
"""Exception if encryption/decryption fails"""
140
pass
141
142
143
class PGPEngine(object):
144
"""A simple class for OpenPGP symmetric encryption & decryption"""
145
def __init__(self):
146
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
147
self.gnupgargs = ['--batch',
148
'--home', self.tempdir,
149
'--force-mdc',
150
'--quiet',
151
'--no-use-agent']
152
153
def __enter__(self):
154
return self
155
156
def __exit__(self, exc_type, exc_value, traceback):
157
self._cleanup()
158
return False
159
160
def __del__(self):
161
self._cleanup()
162
163
def _cleanup(self):
164
if self.tempdir is not None:
165
# Delete contents of tempdir
166
for root, dirs, files in os.walk(self.tempdir,
167
topdown = False):
168
for filename in files:
169
os.remove(os.path.join(root, filename))
170
for dirname in dirs:
171
os.rmdir(os.path.join(root, dirname))
172
# Remove tempdir
173
os.rmdir(self.tempdir)
174
self.tempdir = None
175
176
def password_encode(self, password):
177
# Passphrase can not be empty and can not contain newlines or
178
# NUL bytes. So we prefix it and hex encode it.
179
encoded = b"mandos" + binascii.hexlify(password)
180
if len(encoded) > 2048:
181
# GnuPG can't handle long passwords, so encode differently
182
encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
183
.replace(b"\n", b"\\n")
184
.replace(b"\0", b"\\x00"))
185
return encoded
186
187
def encrypt(self, data, password):
188
passphrase = self.password_encode(password)
189
with tempfile.NamedTemporaryFile(dir=self.tempdir
190
) as passfile:
191
passfile.write(passphrase)
192
passfile.flush()
193
proc = subprocess.Popen(['gpg', '--symmetric',
194
'--passphrase-file',
195
passfile.name]
196
+ self.gnupgargs,
197
stdin = subprocess.PIPE,
198
stdout = subprocess.PIPE,
199
stderr = subprocess.PIPE)
200
ciphertext, err = proc.communicate(input = data)
201
if proc.returncode != 0:
202
raise PGPError(err)
203
return ciphertext
204
205
def decrypt(self, data, password):
206
passphrase = self.password_encode(password)
207
with tempfile.NamedTemporaryFile(dir = self.tempdir
208
) as passfile:
209
passfile.write(passphrase)
210
passfile.flush()
211
proc = subprocess.Popen(['gpg', '--decrypt',
212
'--passphrase-file',
213
passfile.name]
214
+ self.gnupgargs,
215
stdin = subprocess.PIPE,
216
stdout = subprocess.PIPE,
217
stderr = subprocess.PIPE)
218
decrypted_plaintext, err = proc.communicate(input
219
= data)
220
if proc.returncode != 0:
221
raise PGPError(err)
222
return decrypted_plaintext
223
101
224
102
225
class AvahiError(Exception):
103
226
def __init__(self, value, *args, **kwargs):
104
227
self.value = value
105
super(AvahiError, self).__init__(value, *args, **kwargs)
106
def __unicode__(self):
107
return unicode(repr(self.value))
228
return super(AvahiError, self).__init__(value, *args,
229
**kwargs)
108
230
109
231
class AvahiServiceError(AvahiError):
110
232
pass
119
241
Attributes:
120
242
interface: integer; avahi.IF_UNSPEC or an interface index.
121
243
Used to optionally bind to the specified interface.
122
name: string; Example: u'Mandos'
123
type: string; Example: u'_mandos._tcp'.
124
See <http://www.dns-sd.org/ServiceTypes.html>
244
name: string; Example: 'Mandos'
245
type: string; Example: '_mandos._tcp'.
246
See <https://www.iana.org/assignments/service-names-port-numbers>
125
247
port: integer; what port to announce
126
248
TXT: list of strings; TXT record for the service
127
249
domain: string; Domain to publish on, default to .local if empty.
133
255
server: D-Bus Server
134
256
bus: dbus.SystemBus()
135
257
"""
258
136
259
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
137
260
servicetype = None, port = None, TXT = None,
138
domain = u"", host = u"", max_renames = 32768,
261
domain = "", host = "", max_renames = 32768,
139
262
protocol = avahi.PROTO_UNSPEC, bus = None):
140
263
self.interface = interface
141
264
self.name = name
150
273
self.group = None # our entry group
151
274
self.server = None
152
275
self.bus = bus
276
self.entry_group_state_changed_match = None
277
153
278
def rename(self):
154
279
"""Derived from the Avahi example code"""
155
280
if self.rename_count >= self.max_renames:
156
logger.critical(u"No suitable Zeroconf service name found"
157
u" after %i retries, exiting.",
281
logger.critical("No suitable Zeroconf service name found"
282
" after %i retries, exiting.",
158
283
self.rename_count)
159
raise AvahiServiceError(u"Too many renames")
160
self.name = unicode(self.server.GetAlternativeServiceName(self.name))
161
logger.info(u"Changing Zeroconf service name to %r ...",
284
raise AvahiServiceError("Too many renames")
285
self.name = str(self.server
286
.GetAlternativeServiceName(self.name))
287
logger.info("Changing Zeroconf service name to %r ...",
162
288
self.name)
163
syslogger.setFormatter(logging.Formatter
164
(u'Mandos (%s) [%%(process)d]:'
165
u' %%(levelname)s: %%(message)s'
166
% self.name))
167
289
self.remove()
168
290
try:
169
291
self.add()
170
except dbus.exceptions.DBusException, error:
171
logger.critical(u"DBusException: %s", error)
292
except dbus.exceptions.DBusException as error:
293
logger.critical("D-Bus Exception", exc_info=error)
172
294
self.cleanup()
173
295
os._exit(1)
174
296
self.rename_count += 1
297
175
298
def remove(self):
176
299
"""Derived from the Avahi example code"""
300
if self.entry_group_state_changed_match is not None:
301
self.entry_group_state_changed_match.remove()
302
self.entry_group_state_changed_match = None
177
303
if self.group is not None:
178
304
self.group.Reset()
305
179
306
def add(self):
180
307
"""Derived from the Avahi example code"""
308
self.remove()
181
309
if self.group is None:
182
310
self.group = dbus.Interface(
183
311
self.bus.get_object(avahi.DBUS_NAME,
184
312
self.server.EntryGroupNew()),
185
313
avahi.DBUS_INTERFACE_ENTRY_GROUP)
186
self.group.connect_to_signal('StateChanged',
187
self
188
.entry_group_state_changed)
189
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
314
self.entry_group_state_changed_match = (
315
self.group.connect_to_signal(
316
'StateChanged', self.entry_group_state_changed))
317
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
190
318
self.name, self.type)
191
319
self.group.AddService(
192
320
self.interface,
197
325
dbus.UInt16(self.port),
198
326
avahi.string_array_to_txt_array(self.TXT))
199
327
self.group.Commit()
328
200
329
def entry_group_state_changed(self, state, error):
201
330
"""Derived from the Avahi example code"""
202
logger.debug(u"Avahi entry group state change: %i", state)
331
logger.debug("Avahi entry group state change: %i", state)
203
332
204
333
if state == avahi.ENTRY_GROUP_ESTABLISHED:
205
logger.debug(u"Zeroconf service established.")
334
logger.debug("Zeroconf service established.")
206
335
elif state == avahi.ENTRY_GROUP_COLLISION:
207
logger.warning(u"Zeroconf service name collision.")
336
logger.info("Zeroconf service name collision.")
208
337
self.rename()
209
338
elif state == avahi.ENTRY_GROUP_FAILURE:
210
logger.critical(u"Avahi: Error in group state changed %s",
211
unicode(error))
212
raise AvahiGroupError(u"State changed: %s"
213
% unicode(error))
339
logger.critical("Avahi: Error in group state changed %s",
340
str(error))
341
raise AvahiGroupError("State changed: {!s}"
342
.format(error))
343
214
344
def cleanup(self):
215
345
"""Derived from the Avahi example code"""
216
346
if self.group is not None:
217
self.group.Free()
347
try:
348
self.group.Free()
349
except (dbus.exceptions.UnknownMethodException,
350
dbus.exceptions.DBusException):
351
pass
218
352
self.group = None
219
def server_state_changed(self, state):
353
self.remove()
354
355
def server_state_changed(self, state, error=None):
220
356
"""Derived from the Avahi example code"""
221
logger.debug(u"Avahi server state change: %i", state)
222
if state == avahi.SERVER_COLLISION:
223
logger.error(u"Zeroconf server name collision")
224
self.remove()
357
logger.debug("Avahi server state change: %i", state)
358
bad_states = { avahi.SERVER_INVALID:
359
"Zeroconf server invalid",
360
avahi.SERVER_REGISTERING: None,
361
avahi.SERVER_COLLISION:
362
"Zeroconf server name collision",
363
avahi.SERVER_FAILURE:
364
"Zeroconf server failure" }
365
if state in bad_states:
366
if bad_states[state] is not None:
367
if error is None:
368
logger.error(bad_states[state])
369
else:
370
logger.error(bad_states[state] + ": %r", error)
371
self.cleanup()
225
372
elif state == avahi.SERVER_RUNNING:
226
373
self.add()
374
else:
375
if error is None:
376
logger.debug("Unknown state: %r", state)
377
else:
378
logger.debug("Unknown state: %r: %r", state, error)
379
227
380
def activate(self):
228
381
"""Derived from the Avahi example code"""
229
382
if self.server is None:
230
383
self.server = dbus.Interface(
231
384
self.bus.get_object(avahi.DBUS_NAME,
232
avahi.DBUS_PATH_SERVER),
385
avahi.DBUS_PATH_SERVER,
386
follow_name_owner_changes=True),
233
387
avahi.DBUS_INTERFACE_SERVER)
234
self.server.connect_to_signal(u"StateChanged",
388
self.server.connect_to_signal("StateChanged",
235
389
self.server_state_changed)
236
390
self.server_state_changed(self.server.GetState())
237
391
238
392
393
class AvahiServiceToSyslog(AvahiService):
394
def rename(self):
395
"""Add the new name to the syslog messages"""
396
ret = AvahiService.rename(self)
397
syslogger.setFormatter(logging.Formatter
398
('Mandos ({}) [%(process)d]:'
399
' %(levelname)s: %(message)s'
400
.format(self.name)))
401
return ret
402
403
239
404
class Client(object):
240
405
"""A representation of a client host served by this server.
241
406
242
407
Attributes:
243
name: string; from the config file, used in log messages and
244
D-Bus identifiers
408
approved: bool(); 'None' if not yet approved/disapproved
409
approval_delay: datetime.timedelta(); Time to wait for approval
410
approval_duration: datetime.timedelta(); Duration of one approval
411
checker: subprocess.Popen(); a running checker process used
412
to see if the client lives.
413
'None' if no process is running.
414
checker_callback_tag: a gobject event source tag, or None
415
checker_command: string; External command which is run to check
416
if client lives. %() expansions are done at
417
runtime with vars(self) as dict, so that for
418
instance %(name)s can be used in the command.
419
checker_initiator_tag: a gobject event source tag, or None
420
created: datetime.datetime(); (UTC) object creation
421
client_structure: Object describing what attributes a client has
422
and is used for storing the client at exit
423
current_checker_command: string; current running checker_command
424
disable_initiator_tag: a gobject event source tag, or None
425
enabled: bool()
245
426
fingerprint: string (40 or 32 hexadecimal digits); used to
246
427
uniquely identify the client
247
secret: bytestring; sent verbatim (over TLS) to client
248
428
host: string; available for use by the checker command
249
created: datetime.datetime(); (UTC) object creation
250
last_enabled: datetime.datetime(); (UTC)
251
enabled: bool()
429
interval: datetime.timedelta(); How often to start a new checker
430
last_approval_request: datetime.datetime(); (UTC) or None
252
431
last_checked_ok: datetime.datetime(); (UTC) or None
432
last_checker_status: integer between 0 and 255 reflecting exit
433
status of last checker. -1 reflects crashed
434
checker, -2 means no checker completed yet.
435
last_enabled: datetime.datetime(); (UTC) or None
436
name: string; from the config file, used in log messages and
437
D-Bus identifiers
438
secret: bytestring; sent verbatim (over TLS) to client
253
439
timeout: datetime.timedelta(); How long from last_checked_ok
254
440
until this client is disabled
255
interval: datetime.timedelta(); How often to start a new checker
256
disable_hook: If set, called by disable() as disable_hook(self)
257
checker: subprocess.Popen(); a running checker process used
258
to see if the client lives.
259
'None' if no process is running.
260
checker_initiator_tag: a gobject event source tag, or None
261
disable_initiator_tag: - '' -
262
checker_callback_tag: - '' -
263
checker_command: string; External command which is run to check if
264
client lives. %() expansions are done at
265
runtime with vars(self) as dict, so that for
266
instance %(name)s can be used in the command.
267
current_checker_command: string; current running checker_command
268
approval_delay: datetime.timedelta(); Time to wait for approval
269
_approved: bool(); 'None' if not yet approved/disapproved
270
approval_duration: datetime.timedelta(); Duration of one approval
441
extended_timeout: extra long timeout when secret has been sent
442
runtime_expansions: Allowed attributes for runtime expansion.
443
expires: datetime.datetime(); time (UTC) when a client will be
444
disabled, or None
445
server_settings: The server_settings dict from main()
271
446
"""
272
447
448
runtime_expansions = ("approval_delay", "approval_duration",
449
"created", "enabled", "expires",
450
"fingerprint", "host", "interval",
451
"last_approval_request", "last_checked_ok",
452
"last_enabled", "name", "timeout")
453
client_defaults = { "timeout": "PT5M",
454
"extended_timeout": "PT15M",
455
"interval": "PT2M",
456
"checker": "fping -q -- %%(host)s",
457
"host": "",
458
"approval_delay": "PT0S",
459
"approval_duration": "PT1S",
460
"approved_by_default": "True",
461
"enabled": "True",
462
}
463
273
464
@staticmethod
274
def _timedelta_to_milliseconds(td):
275
"Convert a datetime.timedelta() to milliseconds"
276
return ((td.days * 24 * 60 * 60 * 1000)
277
+ (td.seconds * 1000)
278
+ (td.microseconds // 1000))
279
280
def timeout_milliseconds(self):
281
"Return the 'timeout' attribute in milliseconds"
282
return self._timedelta_to_milliseconds(self.timeout)
283
284
def interval_milliseconds(self):
285
"Return the 'interval' attribute in milliseconds"
286
return self._timedelta_to_milliseconds(self.interval)
287
288
def approval_delay_milliseconds(self):
289
return self._timedelta_to_milliseconds(self.approval_delay)
290
291
def __init__(self, name = None, disable_hook=None, config=None):
292
"""Note: the 'checker' key in 'config' sets the
293
'checker_command' attribute and *not* the 'checker'
294
attribute."""
465
def config_parser(config):
466
"""Construct a new dict of client settings of this form:
467
{ client_name: {setting_name: value, ...}, ...}
468
with exceptions for any special settings as defined above.
469
NOTE: Must be a pure function. Must return the same result
470
value given the same arguments.
471
"""
472
settings = {}
473
for client_name in config.sections():
474
section = dict(config.items(client_name))
475
client = settings[client_name] = {}
476
477
client["host"] = section["host"]
478
# Reformat values from string types to Python types
479
client["approved_by_default"] = config.getboolean(
480
client_name, "approved_by_default")
481
client["enabled"] = config.getboolean(client_name,
482
"enabled")
483
484
client["fingerprint"] = (section["fingerprint"].upper()
485
.replace(" ", ""))
486
if "secret" in section:
487
client["secret"] = section["secret"].decode("base64")
488
elif "secfile" in section:
489
with open(os.path.expanduser(os.path.expandvars
490
(section["secfile"])),
491
"rb") as secfile:
492
client["secret"] = secfile.read()
493
else:
494
raise TypeError("No secret or secfile for section {}"
495
.format(section))
496
client["timeout"] = string_to_delta(section["timeout"])
497
client["extended_timeout"] = string_to_delta(
498
section["extended_timeout"])
499
client["interval"] = string_to_delta(section["interval"])
500
client["approval_delay"] = string_to_delta(
501
section["approval_delay"])
502
client["approval_duration"] = string_to_delta(
503
section["approval_duration"])
504
client["checker_command"] = section["checker"]
505
client["last_approval_request"] = None
506
client["last_checked_ok"] = None
507
client["last_checker_status"] = -2
508
509
return settings
510
511
def __init__(self, settings, name = None, server_settings=None):
295
512
self.name = name
296
if config is None:
297
config = {}
298
logger.debug(u"Creating client %r", self.name)
513
if server_settings is None:
514
server_settings = {}
515
self.server_settings = server_settings
516
# adding all client settings
517
for setting, value in settings.items():
518
setattr(self, setting, value)
519
520
if self.enabled:
521
if not hasattr(self, "last_enabled"):
522
self.last_enabled = datetime.datetime.utcnow()
523
if not hasattr(self, "expires"):
524
self.expires = (datetime.datetime.utcnow()
525
+ self.timeout)
526
else:
527
self.last_enabled = None
528
self.expires = None
529
530
logger.debug("Creating client %r", self.name)
299
531
# Uppercase and remove spaces from fingerprint for later
300
532
# comparison purposes with return value from the fingerprint()
301
533
# function
302
self.fingerprint = (config[u"fingerprint"].upper()
303
.replace(u" ", u""))
304
logger.debug(u" Fingerprint: %s", self.fingerprint)
305
if u"secret" in config:
306
self.secret = config[u"secret"].decode(u"base64")
307
elif u"secfile" in config:
308
with open(os.path.expanduser(os.path.expandvars
309
(config[u"secfile"])),
310
"rb") as secfile:
311
self.secret = secfile.read()
312
else:
313
raise TypeError(u"No secret or secfile for client %s"
314
% self.name)
315
self.host = config.get(u"host", u"")
316
self.created = datetime.datetime.utcnow()
317
self.enabled = False
318
self.last_enabled = None
319
self.last_checked_ok = None
320
self.timeout = string_to_delta(config[u"timeout"])
321
self.interval = string_to_delta(config[u"interval"])
322
self.disable_hook = disable_hook
534
logger.debug(" Fingerprint: %s", self.fingerprint)
535
self.created = settings.get("created",
536
datetime.datetime.utcnow())
537
538
# attributes specific for this server instance
323
539
self.checker = None
324
540
self.checker_initiator_tag = None
325
541
self.disable_initiator_tag = None
326
542
self.checker_callback_tag = None
327
self.checker_command = config[u"checker"]
328
543
self.current_checker_command = None
329
self.last_connect = None
330
self._approved = None
331
self.approved_by_default = config.get(u"approved_by_default",
332
True)
544
self.approved = None
333
545
self.approvals_pending = 0
334
self.approval_delay = string_to_delta(
335
config[u"approval_delay"])
336
self.approval_duration = string_to_delta(
337
config[u"approval_duration"])
338
self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
546
self.changedstate = (multiprocessing_manager
547
.Condition(multiprocessing_manager
548
.Lock()))
549
self.client_structure = [attr for attr in
550
self.__dict__.iterkeys()
551
if not attr.startswith("_")]
552
self.client_structure.append("client_structure")
553
554
for name, t in inspect.getmembers(type(self),
555
lambda obj:
556
isinstance(obj,
557
property)):
558
if not name.startswith("_"):
559
self.client_structure.append(name)
339
560
561
# Send notice to process children that client state has changed
340
562
def send_changedstate(self):
341
self.changedstate.acquire()
342
self.changedstate.notify_all()
343
self.changedstate.release()
344
563
with self.changedstate:
564
self.changedstate.notify_all()
565
345
566
def enable(self):
346
567
"""Start this client's checker and timeout hooks"""
347
if getattr(self, u"enabled", False):
568
if getattr(self, "enabled", False):
348
569
# Already enabled
349
570
return
350
self.send_changedstate()
571
self.expires = datetime.datetime.utcnow() + self.timeout
572
self.enabled = True
351
573
self.last_enabled = datetime.datetime.utcnow()
574
self.init_checker()
575
self.send_changedstate()
576
577
def disable(self, quiet=True):
578
"""Disable this client."""
579
if not getattr(self, "enabled", False):
580
return False
581
if not quiet:
582
logger.info("Disabling client %s", self.name)
583
if getattr(self, "disable_initiator_tag", None) is not None:
584
gobject.source_remove(self.disable_initiator_tag)
585
self.disable_initiator_tag = None
586
self.expires = None
587
if getattr(self, "checker_initiator_tag", None) is not None:
588
gobject.source_remove(self.checker_initiator_tag)
589
self.checker_initiator_tag = None
590
self.stop_checker()
591
self.enabled = False
592
if not quiet:
593
self.send_changedstate()
594
# Do not run this again if called by a gobject.timeout_add
595
return False
596
597
def __del__(self):
598
self.disable()
599
600
def init_checker(self):
352
601
# Schedule a new checker to be started an 'interval' from now,
353
602
# and every interval from then on.
603
if self.checker_initiator_tag is not None:
604
gobject.source_remove(self.checker_initiator_tag)
354
605
self.checker_initiator_tag = (gobject.timeout_add
355
(self.interval_milliseconds(),
606
(int(self.interval
607
.total_seconds() * 1000),
356
608
self.start_checker))
357
609
# Schedule a disable() when 'timeout' has passed
610
if self.disable_initiator_tag is not None:
611
gobject.source_remove(self.disable_initiator_tag)
358
612
self.disable_initiator_tag = (gobject.timeout_add
359
(self.timeout_milliseconds(),
360
self.disable))
361
self.enabled = True
613
(int(self.timeout
614
.total_seconds() * 1000),
615
self.disable))
362
616
# Also start a new checker *right now*.
363
617
self.start_checker()
364
618
365
def disable(self, quiet=True):
366
"""Disable this client."""
367
if not getattr(self, "enabled", False):
368
return False
369
if not quiet:
370
self.send_changedstate()
371
if not quiet:
372
logger.info(u"Disabling client %s", self.name)
373
if getattr(self, u"disable_initiator_tag", False):
374
gobject.source_remove(self.disable_initiator_tag)
375
self.disable_initiator_tag = None
376
if getattr(self, u"checker_initiator_tag", False):
377
gobject.source_remove(self.checker_initiator_tag)
378
self.checker_initiator_tag = None
379
self.stop_checker()
380
if self.disable_hook:
381
self.disable_hook(self)
382
self.enabled = False
383
# Do not run this again if called by a gobject.timeout_add
384
return False
385
386
def __del__(self):
387
self.disable_hook = None
388
self.disable()
389
390
619
def checker_callback(self, pid, condition, command):
391
620
"""The checker has completed, so take appropriate actions."""
392
621
self.checker_callback_tag = None
393
622
self.checker = None
394
623
if os.WIFEXITED(condition):
395
exitstatus = os.WEXITSTATUS(condition)
396
if exitstatus == 0:
397
logger.info(u"Checker for %(name)s succeeded",
624
self.last_checker_status = os.WEXITSTATUS(condition)
625
if self.last_checker_status == 0:
626
logger.info("Checker for %(name)s succeeded",
398
627
vars(self))
399
628
self.checked_ok()
400
629
else:
401
logger.info(u"Checker for %(name)s failed",
630
logger.info("Checker for %(name)s failed",
402
631
vars(self))
403
632
else:
404
logger.warning(u"Checker for %(name)s crashed?",
633
self.last_checker_status = -1
634
logger.warning("Checker for %(name)s crashed?",
405
635
vars(self))
406
636
407
637
def checked_ok(self):
408
"""Bump up the timeout for this client.
409
410
This should only be called when the client has been seen,
411
alive and well.
412
"""
638
"""Assert that the client has been seen, alive and well."""
413
639
self.last_checked_ok = datetime.datetime.utcnow()
414
gobject.source_remove(self.disable_initiator_tag)
415
self.disable_initiator_tag = (gobject.timeout_add
416
(self.timeout_milliseconds(),
417
self.disable))
640
self.last_checker_status = 0
641
self.bump_timeout()
642
643
def bump_timeout(self, timeout=None):
644
"""Bump up the timeout for this client."""
645
if timeout is None:
646
timeout = self.timeout
647
if self.disable_initiator_tag is not None:
648
gobject.source_remove(self.disable_initiator_tag)
649
self.disable_initiator_tag = None
650
if getattr(self, "enabled", False):
651
self.disable_initiator_tag = (gobject.timeout_add
652
(int(timeout.total_seconds()
653
* 1000), self.disable))
654
self.expires = datetime.datetime.utcnow() + timeout
655
656
def need_approval(self):
657
self.last_approval_request = datetime.datetime.utcnow()
418
658
419
659
def start_checker(self):
420
660
"""Start a new checker subprocess if one is not running.
422
662
If a checker already exists, leave it running and do
423
663
nothing."""
424
664
# The reason for not killing a running checker is that if we
425
# did that, then if a checker (for some reason) started
426
# running slowly and taking more than 'interval' time, the
427
# client would inevitably timeout, since no checker would get
428
# a chance to run to completion. If we instead leave running
665
# did that, and if a checker (for some reason) started running
666
# slowly and taking more than 'interval' time, then the client
667
# would inevitably timeout, since no checker would get a
668
# chance to run to completion. If we instead leave running
429
669
# checkers alone, the checker would have to take more time
430
670
# than 'timeout' for the client to be disabled, which is as it
431
671
# should be.
433
673
# If a checker exists, make sure it is not a zombie
434
674
try:
435
675
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
436
except (AttributeError, OSError), error:
437
if (isinstance(error, OSError)
438
and error.errno != errno.ECHILD):
439
raise error
676
except AttributeError:
677
pass
678
except OSError as error:
679
if error.errno != errno.ECHILD:
680
raise
440
681
else:
441
682
if pid:
442
logger.warning(u"Checker was a zombie")
683
logger.warning("Checker was a zombie")
443
684
gobject.source_remove(self.checker_callback_tag)
444
685
self.checker_callback(pid, status,
445
686
self.current_checker_command)
446
687
# Start a new checker if needed
447
688
if self.checker is None:
689
# Escape attributes for the shell
690
escaped_attrs = { attr:
691
re.escape(str(getattr(self, attr)))
692
for attr in self.runtime_expansions }
448
693
try:
449
# In case checker_command has exactly one % operator
450
command = self.checker_command % self.host
451
except TypeError:
452
# Escape attributes for the shell
453
escaped_attrs = dict((key,
454
re.escape(unicode(str(val),
455
errors=
456
u'replace')))
457
for key, val in
458
vars(self).iteritems())
459
try:
460
command = self.checker_command % escaped_attrs
461
except TypeError, error:
462
logger.error(u'Could not format string "%s":'
463
u' %s', self.checker_command, error)
464
return True # Try again later
694
command = self.checker_command % escaped_attrs
695
except TypeError as error:
696
logger.error('Could not format string "%s"',
697
self.checker_command, exc_info=error)
698
return True # Try again later
465
699
self.current_checker_command = command
466
700
try:
467
logger.info(u"Starting checker %r for %s",
701
logger.info("Starting checker %r for %s",
468
702
command, self.name)
469
703
# We don't need to redirect stdout and stderr, since
470
704
# in normal mode, that is already done by daemon(),
471
705
# and in debug mode we don't want to. (Stdin is
472
706
# always replaced by /dev/null.)
707
# The exception is when not debugging but nevertheless
708
# running in the foreground; use the previously
709
# created wnull.
710
popen_args = {}
711
if (not self.server_settings["debug"]
712
and self.server_settings["foreground"]):
713
popen_args.update({"stdout": wnull,
714
"stderr": wnull })
473
715
self.checker = subprocess.Popen(command,
474
716
close_fds=True,
475
shell=True, cwd=u"/")
476
self.checker_callback_tag = (gobject.child_watch_add
477
(self.checker.pid,
478
self.checker_callback,
479
data=command))
480
# The checker may have completed before the gobject
481
# watch was added. Check for this.
717
shell=True, cwd="/",
718
**popen_args)
719
except OSError as error:
720
logger.error("Failed to start subprocess",
721
exc_info=error)
722
return True
723
self.checker_callback_tag = (gobject.child_watch_add
724
(self.checker.pid,
725
self.checker_callback,
726
data=command))
727
# The checker may have completed before the gobject
728
# watch was added. Check for this.
729
try:
482
730
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
483
if pid:
484
gobject.source_remove(self.checker_callback_tag)
485
self.checker_callback(pid, status, command)
486
except OSError, error:
487
logger.error(u"Failed to start subprocess: %s",
488
error)
731
except OSError as error:
732
if error.errno == errno.ECHILD:
733
# This should never happen
734
logger.error("Child process vanished",
735
exc_info=error)
736
return True
737
raise
738
if pid:
739
gobject.source_remove(self.checker_callback_tag)
740
self.checker_callback(pid, status, command)
489
741
# Re-run this periodically if run by gobject.timeout_add
490
742
return True
491
743
494
746
if self.checker_callback_tag:
495
747
gobject.source_remove(self.checker_callback_tag)
496
748
self.checker_callback_tag = None
497
if getattr(self, u"checker", None) is None:
749
if getattr(self, "checker", None) is None:
498
750
return
499
logger.debug(u"Stopping checker for %(name)s", vars(self))
751
logger.debug("Stopping checker for %(name)s", vars(self))
500
752
try:
501
os.kill(self.checker.pid, signal.SIGTERM)
753
self.checker.terminate()
502
754
#time.sleep(0.5)
503
755
#if self.checker.poll() is None:
504
# os.kill(self.checker.pid, signal.SIGKILL)
505
except OSError, error:
756
# self.checker.kill()
757
except OSError as error:
506
758
if error.errno != errno.ESRCH: # No such process
507
759
raise
508
760
self.checker = None
509
761
510
def dbus_service_property(dbus_interface, signature=u"v",
511
access=u"readwrite", byte_arrays=False):
762
763
def dbus_service_property(dbus_interface, signature="v",
764
access="readwrite", byte_arrays=False):
512
765
"""Decorators for marking methods of a DBusObjectWithProperties to
513
766
become properties on the D-Bus.
514
767
521
774
"""
522
775
# Encoding deeply encoded byte arrays is not supported yet by the
523
776
# "Set" method, so we fail early here:
524
if byte_arrays and signature != u"ay":
525
raise ValueError(u"Byte arrays not supported for non-'ay'"
526
u" signature %r" % signature)
777
if byte_arrays and signature != "ay":
778
raise ValueError("Byte arrays not supported for non-'ay'"
779
" signature {!r}".format(signature))
527
780
def decorator(func):
528
781
func._dbus_is_property = True
529
782
func._dbus_interface = dbus_interface
530
783
func._dbus_signature = signature
531
784
func._dbus_access = access
532
785
func._dbus_name = func.__name__
533
if func._dbus_name.endswith(u"_dbus_property"):
786
if func._dbus_name.endswith("_dbus_property"):
534
787
func._dbus_name = func._dbus_name[:-14]
535
func._dbus_get_args_options = {u'byte_arrays': byte_arrays }
788
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
789
return func
790
return decorator
791
792
793
def dbus_interface_annotations(dbus_interface):
794
"""Decorator for marking functions returning interface annotations
795
796
Usage:
797
798
@dbus_interface_annotations("org.example.Interface")
799
def _foo(self): # Function name does not matter
800
return {"org.freedesktop.DBus.Deprecated": "true",
801
"org.freedesktop.DBus.Property.EmitsChangedSignal":
802
"false"}
803
"""
804
def decorator(func):
805
func._dbus_is_interface = True
806
func._dbus_interface = dbus_interface
807
func._dbus_name = dbus_interface
808
return func
809
return decorator
810
811
812
def dbus_annotations(annotations):
813
"""Decorator to annotate D-Bus methods, signals or properties
814
Usage:
815
816
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
817
"org.freedesktop.DBus.Property."
818
"EmitsChangedSignal": "false"})
819
@dbus_service_property("org.example.Interface", signature="b",
820
access="r")
821
def Property_dbus_property(self):
822
return dbus.Boolean(False)
823
"""
824
def decorator(func):
825
func._dbus_annotations = annotations
536
826
return func
537
827
return decorator
538
828
540
830
class DBusPropertyException(dbus.exceptions.DBusException):
541
831
"""A base class for D-Bus property-related exceptions
542
832
"""
543
def __unicode__(self):
544
return unicode(str(self))
545
833
pass
546
834
547
835
class DBusPropertyAccessException(DBusPropertyException):
548
836
"""A property's access permissions disallows an operation.
558
846
559
847
class DBusObjectWithProperties(dbus.service.Object):
560
848
"""A D-Bus object with properties.
561
849
562
850
Classes inheriting from this can use the dbus_service_property
563
851
decorator to expose methods as D-Bus properties. It exposes the
564
852
standard Get(), Set(), and GetAll() methods on the D-Bus.
565
853
"""
566
854
567
855
@staticmethod
568
def _is_dbus_property(obj):
569
return getattr(obj, u"_dbus_is_property", False)
856
def _is_dbus_thing(thing):
857
"""Returns a function testing if an attribute is a D-Bus thing
858
859
If called like _is_dbus_thing("method") it returns a function
860
suitable for use as predicate to inspect.getmembers().
861
"""
862
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
863
False)
570
864
571
def _get_all_dbus_properties(self):
865
def _get_all_dbus_things(self, thing):
572
866
"""Returns a generator of (name, attribute) pairs
573
867
"""
574
return ((prop._dbus_name, prop)
575
for name, prop in
576
inspect.getmembers(self, self._is_dbus_property))
868
return ((getattr(athing.__get__(self), "_dbus_name",
869
name),
870
athing.__get__(self))
871
for cls in self.__class__.__mro__
872
for name, athing in
873
inspect.getmembers(cls,
874
self._is_dbus_thing(thing)))
577
875
578
876
def _get_dbus_property(self, interface_name, property_name):
579
877
"""Returns a bound method if one exists which is a D-Bus
580
878
property with the specified name and interface.
581
879
"""
582
for name in (property_name,
583
property_name + u"_dbus_property"):
584
prop = getattr(self, name, None)
585
if (prop is None
586
or not self._is_dbus_property(prop)
587
or prop._dbus_name != property_name
588
or (interface_name and prop._dbus_interface
589
and interface_name != prop._dbus_interface)):
590
continue
591
return prop
880
for cls in self.__class__.__mro__:
881
for name, value in (inspect.getmembers
882
(cls,
883
self._is_dbus_thing("property"))):
884
if (value._dbus_name == property_name
885
and value._dbus_interface == interface_name):
886
return value.__get__(self)
887
592
888
# No such property
593
raise DBusPropertyNotFound(self.dbus_object_path + u":"
594
+ interface_name + u"."
889
raise DBusPropertyNotFound(self.dbus_object_path + ":"
890
+ interface_name + "."
595
891
+ property_name)
596
892
597
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
598
out_signature=u"v")
893
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
894
out_signature="v")
599
895
def Get(self, interface_name, property_name):
600
896
"""Standard D-Bus property Get() method, see D-Bus standard.
601
897
"""
602
898
prop = self._get_dbus_property(interface_name, property_name)
603
if prop._dbus_access == u"write":
899
if prop._dbus_access == "write":
604
900
raise DBusPropertyAccessException(property_name)
605
901
value = prop()
606
if not hasattr(value, u"variant_level"):
902
if not hasattr(value, "variant_level"):
607
903
return value
608
904
return type(value)(value, variant_level=value.variant_level+1)
609
905
610
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
906
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
611
907
def Set(self, interface_name, property_name, value):
612
908
"""Standard D-Bus property Set() method, see D-Bus standard.
613
909
"""
614
910
prop = self._get_dbus_property(interface_name, property_name)
615
if prop._dbus_access == u"read":
911
if prop._dbus_access == "read":
616
912
raise DBusPropertyAccessException(property_name)
617
if prop._dbus_get_args_options[u"byte_arrays"]:
913
if prop._dbus_get_args_options["byte_arrays"]:
618
914
# The byte_arrays option is not supported yet on
619
915
# signatures other than "ay".
620
if prop._dbus_signature != u"ay":
621
raise ValueError
622
value = dbus.ByteArray(''.join(unichr(byte)
623
for byte in value))
916
if prop._dbus_signature != "ay":
917
raise ValueError("Byte arrays not supported for non-"
918
"'ay' signature {!r}"
919
.format(prop._dbus_signature))
920
value = dbus.ByteArray(b''.join(chr(byte)
921
for byte in value))
624
922
prop(value)
625
923
626
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
627
out_signature=u"a{sv}")
924
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
925
out_signature="a{sv}")
628
926
def GetAll(self, interface_name):
629
927
"""Standard D-Bus property GetAll() method, see D-Bus
630
928
standard.
631
929
632
930
Note: Will not include properties with access="write".
633
931
"""
634
all = {}
635
for name, prop in self._get_all_dbus_properties():
932
properties = {}
933
for name, prop in self._get_all_dbus_things("property"):
636
934
if (interface_name
637
935
and interface_name != prop._dbus_interface):
638
936
# Interface non-empty but did not match
639
937
continue
640
938
# Ignore write-only properties
641
if prop._dbus_access == u"write":
939
if prop._dbus_access == "write":
642
940
continue
643
941
value = prop()
644
if not hasattr(value, u"variant_level"):
645
all[name] = value
942
if not hasattr(value, "variant_level"):
943
properties[name] = value
646
944
continue
647
all[name] = type(value)(value, variant_level=
648
value.variant_level+1)
649
return dbus.Dictionary(all, signature=u"sv")
945
properties[name] = type(value)(value, variant_level=
946
value.variant_level+1)
947
return dbus.Dictionary(properties, signature="sv")
948
949
@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
950
def PropertiesChanged(self, interface_name, changed_properties,
951
invalidated_properties):
952
"""Standard D-Bus PropertiesChanged() signal, see D-Bus
953
standard.
954
"""
955
pass
650
956
651
957
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
652
out_signature=u"s",
958
out_signature="s",
653
959
path_keyword='object_path',
654
960
connection_keyword='connection')
655
961
def Introspect(self, object_path, connection):
656
"""Standard D-Bus method, overloaded to insert property tags.
962
"""Overloading of standard D-Bus method.
963
964
Inserts property tags and interface annotation tags.
657
965
"""
658
966
xmlstring = dbus.service.Object.Introspect(self, object_path,
659
967
connection)
660
968
try:
661
969
document = xml.dom.minidom.parseString(xmlstring)
662
970
def make_tag(document, name, prop):
663
e = document.createElement(u"property")
664
e.setAttribute(u"name", name)
665
e.setAttribute(u"type", prop._dbus_signature)
666
e.setAttribute(u"access", prop._dbus_access)
971
e = document.createElement("property")
972
e.setAttribute("name", name)
973
e.setAttribute("type", prop._dbus_signature)
974
e.setAttribute("access", prop._dbus_access)
667
975
return e
668
for if_tag in document.getElementsByTagName(u"interface"):
976
for if_tag in document.getElementsByTagName("interface"):
977
# Add property tags
669
978
for tag in (make_tag(document, name, prop)
670
979
for name, prop
671
in self._get_all_dbus_properties()
980
in self._get_all_dbus_things("property")
672
981
if prop._dbus_interface
673
== if_tag.getAttribute(u"name")):
982
== if_tag.getAttribute("name")):
674
983
if_tag.appendChild(tag)
984
# Add annotation tags
985
for typ in ("method", "signal", "property"):
986
for tag in if_tag.getElementsByTagName(typ):
987
annots = dict()
988
for name, prop in (self.
989
_get_all_dbus_things(typ)):
990
if (name == tag.getAttribute("name")
991
and prop._dbus_interface
992
== if_tag.getAttribute("name")):
993
annots.update(getattr
994
(prop,
995
"_dbus_annotations",
996
{}))
997
for name, value in annots.items():
998
ann_tag = document.createElement(
999
"annotation")
1000
ann_tag.setAttribute("name", name)
1001
ann_tag.setAttribute("value", value)
1002
tag.appendChild(ann_tag)
1003
# Add interface annotation tags
1004
for annotation, value in dict(
1005
itertools.chain.from_iterable(
1006
annotations().items()
1007
for name, annotations in
1008
self._get_all_dbus_things("interface")
1009
if name == if_tag.getAttribute("name")
1010
)).items():
1011
ann_tag = document.createElement("annotation")
1012
ann_tag.setAttribute("name", annotation)
1013
ann_tag.setAttribute("value", value)
1014
if_tag.appendChild(ann_tag)
675
1015
# Add the names to the return values for the
676
1016
# "org.freedesktop.DBus.Properties" methods
677
if (if_tag.getAttribute(u"name")
678
== u"org.freedesktop.DBus.Properties"):
679
for cn in if_tag.getElementsByTagName(u"method"):
680
if cn.getAttribute(u"name") == u"Get":
681
for arg in cn.getElementsByTagName(u"arg"):
682
if (arg.getAttribute(u"direction")
683
== u"out"):
684
arg.setAttribute(u"name", u"value")
685
elif cn.getAttribute(u"name") == u"GetAll":
686
for arg in cn.getElementsByTagName(u"arg"):
687
if (arg.getAttribute(u"direction")
688
== u"out"):
689
arg.setAttribute(u"name", u"props")
690
xmlstring = document.toxml(u"utf-8")
1017
if (if_tag.getAttribute("name")
1018
== "org.freedesktop.DBus.Properties"):
1019
for cn in if_tag.getElementsByTagName("method"):
1020
if cn.getAttribute("name") == "Get":
1021
for arg in cn.getElementsByTagName("arg"):
1022
if (arg.getAttribute("direction")
1023
== "out"):
1024
arg.setAttribute("name", "value")
1025
elif cn.getAttribute("name") == "GetAll":
1026
for arg in cn.getElementsByTagName("arg"):
1027
if (arg.getAttribute("direction")
1028
== "out"):
1029
arg.setAttribute("name", "props")
1030
xmlstring = document.toxml("utf-8")
691
1031
document.unlink()
692
1032
except (AttributeError, xml.dom.DOMException,
693
xml.parsers.expat.ExpatError), error:
694
logger.error(u"Failed to override Introspection method",
695
error)
1033
xml.parsers.expat.ExpatError) as error:
1034
logger.error("Failed to override Introspection method",
1035
exc_info=error)
696
1036
return xmlstring
697
1037
698
1038
1039
def datetime_to_dbus(dt, variant_level=0):
1040
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1041
if dt is None:
1042
return dbus.String("", variant_level = variant_level)
1043
return dbus.String(dt.isoformat(),
1044
variant_level=variant_level)
1045
1046
1047
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1048
"""A class decorator; applied to a subclass of
1049
dbus.service.Object, it will add alternate D-Bus attributes with
1050
interface names according to the "alt_interface_names" mapping.
1051
Usage:
1052
1053
@alternate_dbus_interfaces({"org.example.Interface":
1054
"net.example.AlternateInterface"})
1055
class SampleDBusObject(dbus.service.Object):
1056
@dbus.service.method("org.example.Interface")
1057
def SampleDBusMethod():
1058
pass
1059
1060
The above "SampleDBusMethod" on "SampleDBusObject" will be
1061
reachable via two interfaces: "org.example.Interface" and
1062
"net.example.AlternateInterface", the latter of which will have
1063
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1064
"true", unless "deprecate" is passed with a False value.
1065
1066
This works for methods and signals, and also for D-Bus properties
1067
(from DBusObjectWithProperties) and interfaces (from the
1068
dbus_interface_annotations decorator).
1069
"""
1070
def wrapper(cls):
1071
for orig_interface_name, alt_interface_name in (
1072
alt_interface_names.items()):
1073
attr = {}
1074
interface_names = set()
1075
# Go though all attributes of the class
1076
for attrname, attribute in inspect.getmembers(cls):
1077
# Ignore non-D-Bus attributes, and D-Bus attributes
1078
# with the wrong interface name
1079
if (not hasattr(attribute, "_dbus_interface")
1080
or not attribute._dbus_interface
1081
.startswith(orig_interface_name)):
1082
continue
1083
# Create an alternate D-Bus interface name based on
1084
# the current name
1085
alt_interface = (attribute._dbus_interface
1086
.replace(orig_interface_name,
1087
alt_interface_name))
1088
interface_names.add(alt_interface)
1089
# Is this a D-Bus signal?
1090
if getattr(attribute, "_dbus_is_signal", False):
1091
# Extract the original non-method undecorated
1092
# function by black magic
1093
nonmethod_func = (dict(
1094
zip(attribute.func_code.co_freevars,
1095
attribute.__closure__))["func"]
1096
.cell_contents)
1097
# Create a new, but exactly alike, function
1098
# object, and decorate it to be a new D-Bus signal
1099
# with the alternate D-Bus interface name
1100
new_function = (dbus.service.signal
1101
(alt_interface,
1102
attribute._dbus_signature)
1103
(types.FunctionType(
1104
nonmethod_func.func_code,
1105
nonmethod_func.func_globals,
1106
nonmethod_func.func_name,
1107
nonmethod_func.func_defaults,
1108
nonmethod_func.func_closure)))
1109
# Copy annotations, if any
1110
try:
1111
new_function._dbus_annotations = (
1112
dict(attribute._dbus_annotations))
1113
except AttributeError:
1114
pass
1115
# Define a creator of a function to call both the
1116
# original and alternate functions, so both the
1117
# original and alternate signals gets sent when
1118
# the function is called
1119
def fixscope(func1, func2):
1120
"""This function is a scope container to pass
1121
func1 and func2 to the "call_both" function
1122
outside of its arguments"""
1123
def call_both(*args, **kwargs):
1124
"""This function will emit two D-Bus
1125
signals by calling func1 and func2"""
1126
func1(*args, **kwargs)
1127
func2(*args, **kwargs)
1128
return call_both
1129
# Create the "call_both" function and add it to
1130
# the class
1131
attr[attrname] = fixscope(attribute, new_function)
1132
# Is this a D-Bus method?
1133
elif getattr(attribute, "_dbus_is_method", False):
1134
# Create a new, but exactly alike, function
1135
# object. Decorate it to be a new D-Bus method
1136
# with the alternate D-Bus interface name. Add it
1137
# to the class.
1138
attr[attrname] = (dbus.service.method
1139
(alt_interface,
1140
attribute._dbus_in_signature,
1141
attribute._dbus_out_signature)
1142
(types.FunctionType
1143
(attribute.func_code,
1144
attribute.func_globals,
1145
attribute.func_name,
1146
attribute.func_defaults,
1147
attribute.func_closure)))
1148
# Copy annotations, if any
1149
try:
1150
attr[attrname]._dbus_annotations = (
1151
dict(attribute._dbus_annotations))
1152
except AttributeError:
1153
pass
1154
# Is this a D-Bus property?
1155
elif getattr(attribute, "_dbus_is_property", False):
1156
# Create a new, but exactly alike, function
1157
# object, and decorate it to be a new D-Bus
1158
# property with the alternate D-Bus interface
1159
# name. Add it to the class.
1160
attr[attrname] = (dbus_service_property
1161
(alt_interface,
1162
attribute._dbus_signature,
1163
attribute._dbus_access,
1164
attribute
1165
._dbus_get_args_options
1166
["byte_arrays"])
1167
(types.FunctionType
1168
(attribute.func_code,
1169
attribute.func_globals,
1170
attribute.func_name,
1171
attribute.func_defaults,
1172
attribute.func_closure)))
1173
# Copy annotations, if any
1174
try:
1175
attr[attrname]._dbus_annotations = (
1176
dict(attribute._dbus_annotations))
1177
except AttributeError:
1178
pass
1179
# Is this a D-Bus interface?
1180
elif getattr(attribute, "_dbus_is_interface", False):
1181
# Create a new, but exactly alike, function
1182
# object. Decorate it to be a new D-Bus interface
1183
# with the alternate D-Bus interface name. Add it
1184
# to the class.
1185
attr[attrname] = (dbus_interface_annotations
1186
(alt_interface)
1187
(types.FunctionType
1188
(attribute.func_code,
1189
attribute.func_globals,
1190
attribute.func_name,
1191
attribute.func_defaults,
1192
attribute.func_closure)))
1193
if deprecate:
1194
# Deprecate all alternate interfaces
1195
iname="_AlternateDBusNames_interface_annotation{}"
1196
for interface_name in interface_names:
1197
@dbus_interface_annotations(interface_name)
1198
def func(self):
1199
return { "org.freedesktop.DBus.Deprecated":
1200
"true" }
1201
# Find an unused name
1202
for aname in (iname.format(i)
1203
for i in itertools.count()):
1204
if aname not in attr:
1205
attr[aname] = func
1206
break
1207
if interface_names:
1208
# Replace the class with a new subclass of it with
1209
# methods, signals, etc. as created above.
1210
cls = type(b"{}Alternate".format(cls.__name__),
1211
(cls,), attr)
1212
return cls
1213
return wrapper
1214
1215
1216
@alternate_dbus_interfaces({"se.recompile.Mandos":
1217
"se.bsnet.fukt.Mandos"})
699
1218
class ClientDBus(Client, DBusObjectWithProperties):
700
1219
"""A Client class using D-Bus
701
1220
703
1222
dbus_object_path: dbus.ObjectPath
704
1223
bus: dbus.SystemBus()
705
1224
"""
1225
1226
runtime_expansions = (Client.runtime_expansions
1227
+ ("dbus_object_path",))
1228
1229
_interface = "se.recompile.Mandos.Client"
1230
706
1231
# dbus.service.Object doesn't use super(), so we can't either.
707
1232
708
1233
def __init__(self, bus = None, *args, **kwargs):
709
self._approvals_pending = 0
710
1234
self.bus = bus
711
1235
Client.__init__(self, *args, **kwargs)
712
1236
# Only now, when this client is initialized, can it show up on
713
1237
# the D-Bus
1238
client_object_name = str(self.name).translate(
1239
{ord("."): ord("_"),
1240
ord("-"): ord("_")})
714
1241
self.dbus_object_path = (dbus.ObjectPath
715
(u"/clients/"
716
+ self.name.replace(u".", u"_")))
1242
("/clients/" + client_object_name))
717
1243
DBusObjectWithProperties.__init__(self, self.bus,
718
1244
self.dbus_object_path)
719
720
def _get_approvals_pending(self):
721
return self._approvals_pending
722
def _set_approvals_pending(self, value):
723
old_value = self._approvals_pending
724
self._approvals_pending = value
725
bval = bool(value)
726
if (hasattr(self, "dbus_object_path")
727
and bval is not bool(old_value)):
728
dbus_bool = dbus.Boolean(bval, variant_level=1)
729
self.PropertyChanged(dbus.String(u"ApprovalPending"),
730
dbus_bool)
731
732
approvals_pending = property(_get_approvals_pending,
733
_set_approvals_pending)
734
del _get_approvals_pending, _set_approvals_pending
735
736
@staticmethod
737
def _datetime_to_dbus(dt, variant_level=0):
738
"""Convert a UTC datetime.datetime() to a D-Bus type."""
739
return dbus.String(dt.isoformat(),
740
variant_level=variant_level)
741
742
def enable(self):
743
oldstate = getattr(self, u"enabled", False)
744
r = Client.enable(self)
745
if oldstate != self.enabled:
746
# Emit D-Bus signals
747
self.PropertyChanged(dbus.String(u"Enabled"),
748
dbus.Boolean(True, variant_level=1))
749
self.PropertyChanged(
750
dbus.String(u"LastEnabled"),
751
self._datetime_to_dbus(self.last_enabled,
752
variant_level=1))
753
return r
754
755
def disable(self, quiet = False):
756
oldstate = getattr(self, u"enabled", False)
757
r = Client.disable(self, quiet=quiet)
758
if not quiet and oldstate != self.enabled:
759
# Emit D-Bus signal
760
self.PropertyChanged(dbus.String(u"Enabled"),
761
dbus.Boolean(False, variant_level=1))
762
return r
1245
1246
def notifychangeproperty(transform_func,
1247
dbus_name, type_func=lambda x: x,
1248
variant_level=1, invalidate_only=False,
1249
_interface=_interface):
1250
""" Modify a variable so that it's a property which announces
1251
its changes to DBus.
1252
1253
transform_fun: Function that takes a value and a variant_level
1254
and transforms it to a D-Bus type.
1255
dbus_name: D-Bus name of the variable
1256
type_func: Function that transform the value before sending it
1257
to the D-Bus. Default: no transform
1258
variant_level: D-Bus variant level. Default: 1
1259
"""
1260
attrname = "_{}".format(dbus_name)
1261
def setter(self, value):
1262
if hasattr(self, "dbus_object_path"):
1263
if (not hasattr(self, attrname) or
1264
type_func(getattr(self, attrname, None))
1265
!= type_func(value)):
1266
if invalidate_only:
1267
self.PropertiesChanged(_interface,
1268
dbus.Dictionary(),
1269
dbus.Array
1270
((dbus_name,)))
1271
else:
1272
dbus_value = transform_func(type_func(value),
1273
variant_level
1274
=variant_level)
1275
self.PropertyChanged(dbus.String(dbus_name),
1276
dbus_value)
1277
self.PropertiesChanged(_interface,
1278
dbus.Dictionary({
1279
dbus.String(dbus_name):
1280
dbus_value }), dbus.Array())
1281
setattr(self, attrname, value)
1282
1283
return property(lambda self: getattr(self, attrname), setter)
1284
1285
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1286
approvals_pending = notifychangeproperty(dbus.Boolean,
1287
"ApprovalPending",
1288
type_func = bool)
1289
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1290
last_enabled = notifychangeproperty(datetime_to_dbus,
1291
"LastEnabled")
1292
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
1293
type_func = lambda checker:
1294
checker is not None)
1295
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1296
"LastCheckedOK")
1297
last_checker_status = notifychangeproperty(dbus.Int16,
1298
"LastCheckerStatus")
1299
last_approval_request = notifychangeproperty(
1300
datetime_to_dbus, "LastApprovalRequest")
1301
approved_by_default = notifychangeproperty(dbus.Boolean,
1302
"ApprovedByDefault")
1303
approval_delay = notifychangeproperty(dbus.UInt64,
1304
"ApprovalDelay",
1305
type_func =
1306
lambda td: td.total_seconds()
1307
* 1000)
1308
approval_duration = notifychangeproperty(
1309
dbus.UInt64, "ApprovalDuration",
1310
type_func = lambda td: td.total_seconds() * 1000)
1311
host = notifychangeproperty(dbus.String, "Host")
1312
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1313
type_func = lambda td:
1314
td.total_seconds() * 1000)
1315
extended_timeout = notifychangeproperty(
1316
dbus.UInt64, "ExtendedTimeout",
1317
type_func = lambda td: td.total_seconds() * 1000)
1318
interval = notifychangeproperty(dbus.UInt64,
1319
"Interval",
1320
type_func =
1321
lambda td: td.total_seconds()
1322
* 1000)
1323
checker_command = notifychangeproperty(dbus.String, "Checker")
1324
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1325
invalidate_only=True)
1326
1327
del notifychangeproperty
763
1328
764
1329
def __del__(self, *args, **kwargs):
765
1330
try:
766
1331
self.remove_from_connection()
767
1332
except LookupError:
768
1333
pass
769
if hasattr(DBusObjectWithProperties, u"__del__"):
1334
if hasattr(DBusObjectWithProperties, "__del__"):
770
1335
DBusObjectWithProperties.__del__(self, *args, **kwargs)
771
1336
Client.__del__(self, *args, **kwargs)
772
1337
774
1339
*args, **kwargs):
775
1340
self.checker_callback_tag = None
776
1341
self.checker = None
777
# Emit D-Bus signal
778
self.PropertyChanged(dbus.String(u"CheckerRunning"),
779
dbus.Boolean(False, variant_level=1))
780
1342
if os.WIFEXITED(condition):
781
1343
exitstatus = os.WEXITSTATUS(condition)
782
1344
# Emit D-Bus signal
792
1354
return Client.checker_callback(self, pid, condition, command,
793
1355
*args, **kwargs)
794
1356
795
def checked_ok(self, *args, **kwargs):
796
r = Client.checked_ok(self, *args, **kwargs)
797
# Emit D-Bus signal
798
self.PropertyChanged(
799
dbus.String(u"LastCheckedOK"),
800
(self._datetime_to_dbus(self.last_checked_ok,
801
variant_level=1)))
802
return r
803
804
1357
def start_checker(self, *args, **kwargs):
805
old_checker = self.checker
806
if self.checker is not None:
807
old_checker_pid = self.checker.pid
808
else:
809
old_checker_pid = None
1358
old_checker_pid = getattr(self.checker, "pid", None)
810
1359
r = Client.start_checker(self, *args, **kwargs)
811
1360
# Only if new checker process was started
812
1361
if (self.checker is not None
813
1362
and old_checker_pid != self.checker.pid):
814
1363
# Emit D-Bus signal
815
1364
self.CheckerStarted(self.current_checker_command)
816
self.PropertyChanged(
817
dbus.String(u"CheckerRunning"),
818
dbus.Boolean(True, variant_level=1))
819
1365
return r
820
1366
821
def stop_checker(self, *args, **kwargs):
822
old_checker = getattr(self, u"checker", None)
823
r = Client.stop_checker(self, *args, **kwargs)
824
if (old_checker is not None
825
and getattr(self, u"checker", None) is None):
826
self.PropertyChanged(dbus.String(u"CheckerRunning"),
827
dbus.Boolean(False, variant_level=1))
828
return r
829
830
1367
def _reset_approved(self):
831
self._approved = None
1368
self.approved = None
832
1369
return False
833
1370
834
1371
def approve(self, value=True):
1372
self.approved = value
1373
gobject.timeout_add(int(self.approval_duration.total_seconds()
1374
* 1000), self._reset_approved)
835
1375
self.send_changedstate()
836
self._approved = value
837
gobject.timeout_add(self._timedelta_to_milliseconds
838
(self.approval_duration),
839
self._reset_approved)
840
841
1376
842
1377
## D-Bus methods, signals & properties
843
_interface = u"se.bsnet.fukt.Mandos.Client"
1378
1379
## Interfaces
844
1380
845
1381
## Signals
846
1382
847
1383
# CheckerCompleted - signal
848
@dbus.service.signal(_interface, signature=u"nxs")
1384
@dbus.service.signal(_interface, signature="nxs")
849
1385
def CheckerCompleted(self, exitcode, waitstatus, command):
850
1386
"D-Bus signal"
851
1387
pass
852
1388
853
1389
# CheckerStarted - signal
854
@dbus.service.signal(_interface, signature=u"s")
1390
@dbus.service.signal(_interface, signature="s")
855
1391
def CheckerStarted(self, command):
856
1392
"D-Bus signal"
857
1393
pass
858
1394
859
1395
# PropertyChanged - signal
860
@dbus.service.signal(_interface, signature=u"sv")
1396
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1397
@dbus.service.signal(_interface, signature="sv")
861
1398
def PropertyChanged(self, property, value):
862
1399
"D-Bus signal"
863
1400
pass
872
1409
pass
873
1410
874
1411
# Rejected - signal
875
@dbus.service.signal(_interface, signature=u"s")
1412
@dbus.service.signal(_interface, signature="s")
876
1413
def Rejected(self, reason):
877
1414
"D-Bus signal"
878
1415
pass
879
1416
880
1417
# NeedApproval - signal
881
@dbus.service.signal(_interface, signature=u"tb")
1418
@dbus.service.signal(_interface, signature="tb")
882
1419
def NeedApproval(self, timeout, default):
883
1420
"D-Bus signal"
884
pass
1421
return self.need_approval()
885
1422
886
1423
## Methods
887
1424
888
1425
# Approve - method
889
@dbus.service.method(_interface, in_signature=u"b")
1426
@dbus.service.method(_interface, in_signature="b")
890
1427
def Approve(self, value):
891
1428
self.approve(value)
892
1429
893
1430
# CheckedOK - method
894
1431
@dbus.service.method(_interface)
895
1432
def CheckedOK(self):
896
return self.checked_ok()
1433
self.checked_ok()
897
1434
898
1435
# Enable - method
899
1436
@dbus.service.method(_interface)
921
1458
## Properties
922
1459
923
1460
# ApprovalPending - property
924
@dbus_service_property(_interface, signature=u"b", access=u"read")
1461
@dbus_service_property(_interface, signature="b", access="read")
925
1462
def ApprovalPending_dbus_property(self):
926
1463
return dbus.Boolean(bool(self.approvals_pending))
927
1464
928
1465
# ApprovedByDefault - property
929
@dbus_service_property(_interface, signature=u"b",
930
access=u"readwrite")
1466
@dbus_service_property(_interface, signature="b",
1467
access="readwrite")
931
1468
def ApprovedByDefault_dbus_property(self, value=None):
932
1469
if value is None: # get
933
1470
return dbus.Boolean(self.approved_by_default)
934
1471
self.approved_by_default = bool(value)
935
# Emit D-Bus signal
936
self.PropertyChanged(dbus.String(u"ApprovedByDefault"),
937
dbus.Boolean(value, variant_level=1))
938
1472
939
1473
# ApprovalDelay - property
940
@dbus_service_property(_interface, signature=u"t",
941
access=u"readwrite")
1474
@dbus_service_property(_interface, signature="t",
1475
access="readwrite")
942
1476
def ApprovalDelay_dbus_property(self, value=None):
943
1477
if value is None: # get
944
return dbus.UInt64(self.approval_delay_milliseconds())
1478
return dbus.UInt64(self.approval_delay.total_seconds()
1479
* 1000)
945
1480
self.approval_delay = datetime.timedelta(0, 0, 0, value)
946
# Emit D-Bus signal
947
self.PropertyChanged(dbus.String(u"ApprovalDelay"),
948
dbus.UInt64(value, variant_level=1))
949
1481
950
1482
# ApprovalDuration - property
951
@dbus_service_property(_interface, signature=u"t",
952
access=u"readwrite")
1483
@dbus_service_property(_interface, signature="t",
1484
access="readwrite")
953
1485
def ApprovalDuration_dbus_property(self, value=None):
954
1486
if value is None: # get
955
return dbus.UInt64(self._timedelta_to_milliseconds(
956
self.approval_duration))
1487
return dbus.UInt64(self.approval_duration.total_seconds()
1488
* 1000)
957
1489
self.approval_duration = datetime.timedelta(0, 0, 0, value)
958
# Emit D-Bus signal
959
self.PropertyChanged(dbus.String(u"ApprovalDuration"),
960
dbus.UInt64(value, variant_level=1))
961
1490
962
1491
# Name - property
963
@dbus_service_property(_interface, signature=u"s", access=u"read")
1492
@dbus_service_property(_interface, signature="s", access="read")
964
1493
def Name_dbus_property(self):
965
1494
return dbus.String(self.name)
966
1495
967
1496
# Fingerprint - property
968
@dbus_service_property(_interface, signature=u"s", access=u"read")
1497
@dbus_service_property(_interface, signature="s", access="read")
969
1498
def Fingerprint_dbus_property(self):
970
1499
return dbus.String(self.fingerprint)
971
1500
972
1501
# Host - property
973
@dbus_service_property(_interface, signature=u"s",
974
access=u"readwrite")
1502
@dbus_service_property(_interface, signature="s",
1503
access="readwrite")
975
1504
def Host_dbus_property(self, value=None):
976
1505
if value is None: # get
977
1506
return dbus.String(self.host)
978
self.host = value
979
# Emit D-Bus signal
980
self.PropertyChanged(dbus.String(u"Host"),
981
dbus.String(value, variant_level=1))
1507
self.host = str(value)
982
1508
983
1509
# Created - property
984
@dbus_service_property(_interface, signature=u"s", access=u"read")
1510
@dbus_service_property(_interface, signature="s", access="read")
985
1511
def Created_dbus_property(self):
986
return dbus.String(self._datetime_to_dbus(self.created))
1512
return datetime_to_dbus(self.created)
987
1513
988
1514
# LastEnabled - property
989
@dbus_service_property(_interface, signature=u"s", access=u"read")
1515
@dbus_service_property(_interface, signature="s", access="read")
990
1516
def LastEnabled_dbus_property(self):
991
if self.last_enabled is None:
992
return dbus.String(u"")
993
return dbus.String(self._datetime_to_dbus(self.last_enabled))
1517
return datetime_to_dbus(self.last_enabled)
994
1518
995
1519
# Enabled - property
996
@dbus_service_property(_interface, signature=u"b",
997
access=u"readwrite")
1520
@dbus_service_property(_interface, signature="b",
1521
access="readwrite")
998
1522
def Enabled_dbus_property(self, value=None):
999
1523
if value is None: # get
1000
1524
return dbus.Boolean(self.enabled)
1004
1528
self.disable()
1005
1529
1006
1530
# LastCheckedOK - property
1007
@dbus_service_property(_interface, signature=u"s",
1008
access=u"readwrite")
1531
@dbus_service_property(_interface, signature="s",
1532
access="readwrite")
1009
1533
def LastCheckedOK_dbus_property(self, value=None):
1010
1534
if value is not None:
1011
1535
self.checked_ok()
1012
1536
return
1013
if self.last_checked_ok is None:
1014
return dbus.String(u"")
1015
return dbus.String(self._datetime_to_dbus(self
1016
.last_checked_ok))
1537
return datetime_to_dbus(self.last_checked_ok)
1538
1539
# LastCheckerStatus - property
1540
@dbus_service_property(_interface, signature="n",
1541
access="read")
1542
def LastCheckerStatus_dbus_property(self):
1543
return dbus.Int16(self.last_checker_status)
1544
1545
# Expires - property
1546
@dbus_service_property(_interface, signature="s", access="read")
1547
def Expires_dbus_property(self):
1548
return datetime_to_dbus(self.expires)
1549
1550
# LastApprovalRequest - property
1551
@dbus_service_property(_interface, signature="s", access="read")
1552
def LastApprovalRequest_dbus_property(self):
1553
return datetime_to_dbus(self.last_approval_request)
1017
1554
1018
1555
# Timeout - property
1019
@dbus_service_property(_interface, signature=u"t",
1020
access=u"readwrite")
1556
@dbus_service_property(_interface, signature="t",
1557
access="readwrite")
1021
1558
def Timeout_dbus_property(self, value=None):
1022
1559
if value is None: # get
1023
return dbus.UInt64(self.timeout_milliseconds())
1560
return dbus.UInt64(self.timeout.total_seconds() * 1000)
1561
old_timeout = self.timeout
1024
1562
self.timeout = datetime.timedelta(0, 0, 0, value)
1025
# Emit D-Bus signal
1026
self.PropertyChanged(dbus.String(u"Timeout"),
1027
dbus.UInt64(value, variant_level=1))
1028
if getattr(self, u"disable_initiator_tag", None) is None:
1029
return
1030
# Reschedule timeout
1031
gobject.source_remove(self.disable_initiator_tag)
1032
self.disable_initiator_tag = None
1033
time_to_die = (self.
1034
_timedelta_to_milliseconds((self
1035
.last_checked_ok
1036
+ self.timeout)
1037
- datetime.datetime
1038
.utcnow()))
1039
if time_to_die <= 0:
1040
# The timeout has passed
1041
self.disable()
1042
else:
1043
self.disable_initiator_tag = (gobject.timeout_add
1044
(time_to_die, self.disable))
1563
# Reschedule disabling
1564
if self.enabled:
1565
now = datetime.datetime.utcnow()
1566
self.expires += self.timeout - old_timeout
1567
if self.expires <= now:
1568
# The timeout has passed
1569
self.disable()
1570
else:
1571
if (getattr(self, "disable_initiator_tag", None)
1572
is None):
1573
return
1574
gobject.source_remove(self.disable_initiator_tag)
1575
self.disable_initiator_tag = (
1576
gobject.timeout_add(
1577
int((self.expires - now).total_seconds()
1578
* 1000), self.disable))
1579
1580
# ExtendedTimeout - property
1581
@dbus_service_property(_interface, signature="t",
1582
access="readwrite")
1583
def ExtendedTimeout_dbus_property(self, value=None):
1584
if value is None: # get
1585
return dbus.UInt64(self.extended_timeout.total_seconds()
1586
* 1000)
1587
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1045
1588
1046
1589
# Interval - property
1047
@dbus_service_property(_interface, signature=u"t",
1048
access=u"readwrite")
1590
@dbus_service_property(_interface, signature="t",
1591
access="readwrite")
1049
1592
def Interval_dbus_property(self, value=None):
1050
1593
if value is None: # get
1051
return dbus.UInt64(self.interval_milliseconds())
1594
return dbus.UInt64(self.interval.total_seconds() * 1000)
1052
1595
self.interval = datetime.timedelta(0, 0, 0, value)
1053
# Emit D-Bus signal
1054
self.PropertyChanged(dbus.String(u"Interval"),
1055
dbus.UInt64(value, variant_level=1))
1056
if getattr(self, u"checker_initiator_tag", None) is None:
1596
if getattr(self, "checker_initiator_tag", None) is None:
1057
1597
return
1058
# Reschedule checker run
1059
gobject.source_remove(self.checker_initiator_tag)
1060
self.checker_initiator_tag = (gobject.timeout_add
1061
(value, self.start_checker))
1062
self.start_checker() # Start one now, too
1063
1598
if self.enabled:
1599
# Reschedule checker run
1600
gobject.source_remove(self.checker_initiator_tag)
1601
self.checker_initiator_tag = (gobject.timeout_add
1602
(value, self.start_checker))
1603
self.start_checker() # Start one now, too
1604
1064
1605
# Checker - property
1065
@dbus_service_property(_interface, signature=u"s",
1066
access=u"readwrite")
1606
@dbus_service_property(_interface, signature="s",
1607
access="readwrite")
1067
1608
def Checker_dbus_property(self, value=None):
1068
1609
if value is None: # get
1069
1610
return dbus.String(self.checker_command)
1070
self.checker_command = value
1071
# Emit D-Bus signal
1072
self.PropertyChanged(dbus.String(u"Checker"),
1073
dbus.String(self.checker_command,
1074
variant_level=1))
1611
self.checker_command = str(value)
1075
1612
1076
1613
# CheckerRunning - property
1077
@dbus_service_property(_interface, signature=u"b",
1078
access=u"readwrite")
1614
@dbus_service_property(_interface, signature="b",
1615
access="readwrite")
1079
1616
def CheckerRunning_dbus_property(self, value=None):
1080
1617
if value is None: # get
1081
1618
return dbus.Boolean(self.checker is not None)
1085
1622
self.stop_checker()
1086
1623
1087
1624
# ObjectPath - property
1088
@dbus_service_property(_interface, signature=u"o", access=u"read")
1625
@dbus_service_property(_interface, signature="o", access="read")
1089
1626
def ObjectPath_dbus_property(self):
1090
1627
return self.dbus_object_path # is already a dbus.ObjectPath
1091
1628
1092
1629
# Secret = property
1093
@dbus_service_property(_interface, signature=u"ay",
1094
access=u"write", byte_arrays=True)
1630
@dbus_service_property(_interface, signature="ay",
1631
access="write", byte_arrays=True)
1095
1632
def Secret_dbus_property(self, value):
1096
self.secret = str(value)
1633
self.secret = bytes(value)
1097
1634
1098
1635
del _interface
1099
1636
1104
1641
self._pipe.send(('init', fpr, address))
1105
1642
if not self._pipe.recv():
1106
1643
raise KeyError()
1107
1644
1108
1645
def __getattribute__(self, name):
1109
if(name == '_pipe'):
1646
if name == '_pipe':
1110
1647
return super(ProxyClient, self).__getattribute__(name)
1111
1648
self._pipe.send(('getattr', name))
1112
1649
data = self._pipe.recv()
1117
1654
self._pipe.send(('funcall', name, args, kwargs))
1118
1655
return self._pipe.recv()[1]
1119
1656
return func
1120
1657
1121
1658
def __setattr__(self, name, value):
1122
if(name == '_pipe'):
1659
if name == '_pipe':
1123
1660
return super(ProxyClient, self).__setattr__(name, value)
1124
1661
self._pipe.send(('setattr', name, value))
1125
1662
1132
1669
1133
1670
def handle(self):
1134
1671
with contextlib.closing(self.server.child_pipe) as child_pipe:
1135
logger.info(u"TCP connection from: %s",
1136
unicode(self.client_address))
1137
logger.debug(u"Pipe FD: %d",
1672
logger.info("TCP connection from: %s",
1673
str(self.client_address))
1674
logger.debug("Pipe FD: %d",
1138
1675
self.server.child_pipe.fileno())
1139
1676
1140
1677
session = (gnutls.connection
1141
1678
.ClientSession(self.request,
1142
1679
gnutls.connection
1143
1680
.X509Credentials()))
1144
1681
1145
1682
# Note: gnutls.connection.X509Credentials is really a
1146
1683
# generic GnuTLS certificate credentials object so long as
1147
1684
# no X.509 keys are added to it. Therefore, we can use it
1148
1685
# here despite using OpenPGP certificates.
1149
1150
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
1151
# u"+AES-256-CBC", u"+SHA1",
1152
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
1153
# u"+DHE-DSS"))
1686
1687
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1688
# "+AES-256-CBC", "+SHA1",
1689
# "+COMP-NULL", "+CTYPE-OPENPGP",
1690
# "+DHE-DSS"))
1154
1691
# Use a fallback default, since this MUST be set.
1155
1692
priority = self.server.gnutls_priority
1156
1693
if priority is None:
1157
priority = u"NORMAL"
1694
priority = "NORMAL"
1158
1695
(gnutls.library.functions
1159
1696
.gnutls_priority_set_direct(session._c_object,
1160
1697
priority, None))
1161
1698
1162
1699
# Start communication using the Mandos protocol
1163
1700
# Get protocol number
1164
1701
line = self.request.makefile().readline()
1165
logger.debug(u"Protocol version: %r", line)
1702
logger.debug("Protocol version: %r", line)
1166
1703
try:
1167
1704
if int(line.strip().split()[0]) > 1:
1168
raise RuntimeError
1169
except (ValueError, IndexError, RuntimeError), error:
1170
logger.error(u"Unknown protocol version: %s", error)
1705
raise RuntimeError(line)
1706
except (ValueError, IndexError, RuntimeError) as error:
1707
logger.error("Unknown protocol version: %s", error)
1171
1708
return
1172
1709
1173
1710
# Start GnuTLS connection
1174
1711
try:
1175
1712
session.handshake()
1176
except gnutls.errors.GNUTLSError, error:
1177
logger.warning(u"Handshake failed: %s", error)
1713
except gnutls.errors.GNUTLSError as error:
1714
logger.warning("Handshake failed: %s", error)
1178
1715
# Do not run session.bye() here: the session is not
1179
1716
# established. Just abandon the request.
1180
1717
return
1181
logger.debug(u"Handshake succeeded")
1182
1718
logger.debug("Handshake succeeded")
1719
1183
1720
approval_required = False
1184
1721
try:
1185
1722
try:
1186
1723
fpr = self.fingerprint(self.peer_certificate
1187
1724
(session))
1188
except (TypeError, gnutls.errors.GNUTLSError), error:
1189
logger.warning(u"Bad certificate: %s", error)
1725
except (TypeError,
1726
gnutls.errors.GNUTLSError) as error:
1727
logger.warning("Bad certificate: %s", error)
1190
1728
return
1191
logger.debug(u"Fingerprint: %s", fpr)
1192
1729
logger.debug("Fingerprint: %s", fpr)
1730
1193
1731
try:
1194
1732
client = ProxyClient(child_pipe, fpr,
1195
1733
self.client_address)
1203
1741
1204
1742
while True:
1205
1743
if not client.enabled:
1206
logger.warning(u"Client %s is disabled",
1744
logger.info("Client %s is disabled",
1207
1745
client.name)
1208
1746
if self.server.use_dbus:
1209
1747
# Emit D-Bus signal
1210
client.Rejected("Disabled")
1748
client.Rejected("Disabled")
1211
1749
return
1212
1750
1213
if client._approved or not client.approval_delay:
1751
if client.approved or not client.approval_delay:
1214
1752
#We are approved or approval is disabled
1215
1753
break
1216
elif client._approved is None:
1217
logger.info(u"Client %s needs approval",
1754
elif client.approved is None:
1755
logger.info("Client %s needs approval",
1218
1756
client.name)
1219
1757
if self.server.use_dbus:
1220
1758
# Emit D-Bus signal
1221
1759
client.NeedApproval(
1222
client.approval_delay_milliseconds(),
1223
client.approved_by_default)
1760
client.approval_delay.total_seconds()
1761
* 1000, client.approved_by_default)
1224
1762
else:
1225
logger.warning(u"Client %s was not approved",
1763
logger.warning("Client %s was not approved",
1226
1764
client.name)
1227
1765
if self.server.use_dbus:
1228
1766
# Emit D-Bus signal
1230
1768
return
1231
1769
1232
1770
#wait until timeout or approved
1233
#x = float(client._timedelta_to_milliseconds(delay))
1234
1771
time = datetime.datetime.now()
1235
1772
client.changedstate.acquire()
1236
client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))
1773
client.changedstate.wait(delay.total_seconds())
1237
1774
client.changedstate.release()
1238
1775
time2 = datetime.datetime.now()
1239
1776
if (time2 - time) >= delay:
1254
1791
while sent_size < len(client.secret):
1255
1792
try:
1256
1793
sent = session.send(client.secret[sent_size:])
1257
except (gnutls.errors.GNUTLSError), error:
1258
logger.warning("gnutls send failed")
1794
except gnutls.errors.GNUTLSError as error:
1795
logger.warning("gnutls send failed",
1796
exc_info=error)
1259
1797
return
1260
logger.debug(u"Sent: %d, remaining: %d",
1798
logger.debug("Sent: %d, remaining: %d",
1261
1799
sent, len(client.secret)
1262
1800
- (sent_size + sent))
1263
1801
sent_size += sent
1264
1265
logger.info(u"Sending secret to %s", client.name)
1266
# bump the timeout as if seen
1267
client.checked_ok()
1802
1803
logger.info("Sending secret to %s", client.name)
1804
# bump the timeout using extended_timeout
1805
client.bump_timeout(client.extended_timeout)
1268
1806
if self.server.use_dbus:
1269
1807
# Emit D-Bus signal
1270
1808
client.GotSecret()
1274
1812
client.approvals_pending -= 1
1275
1813
try:
1276
1814
session.bye()
1277
except (gnutls.errors.GNUTLSError), error:
1278
logger.warning("GnuTLS bye failed")
1815
except gnutls.errors.GNUTLSError as error:
1816
logger.warning("GnuTLS bye failed",
1817
exc_info=error)
1279
1818
1280
1819
@staticmethod
1281
1820
def peer_certificate(session):
1291
1830
.gnutls_certificate_get_peers
1292
1831
(session._c_object, ctypes.byref(list_size)))
1293
1832
if not bool(cert_list) and list_size.value != 0:
1294
raise gnutls.errors.GNUTLSError(u"error getting peer"
1295
u" certificate")
1833
raise gnutls.errors.GNUTLSError("error getting peer"
1834
" certificate")
1296
1835
if list_size.value == 0:
1297
1836
return None
1298
1837
cert = cert_list[0]
1324
1863
if crtverify.value != 0:
1325
1864
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1326
1865
raise (gnutls.errors.CertificateSecurityError
1327
(u"Verify failed"))
1866
("Verify failed"))
1328
1867
# New buffer for the fingerprint
1329
1868
buf = ctypes.create_string_buffer(20)
1330
1869
buf_len = ctypes.c_size_t()
1337
1876
# Convert the buffer to a Python bytestring
1338
1877
fpr = ctypes.string_at(buf, buf_len.value)
1339
1878
# Convert the bytestring to hexadecimal notation
1340
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
1879
hex_fpr = binascii.hexlify(fpr).upper()
1341
1880
return hex_fpr
1342
1881
1343
1882
1346
1885
def sub_process_main(self, request, address):
1347
1886
try:
1348
1887
self.finish_request(request, address)
1349
except:
1888
except Exception:
1350
1889
self.handle_error(request, address)
1351
1890
self.close_request(request)
1352
1891
1353
1892
def process_request(self, request, address):
1354
1893
"""Start a new process to process the request."""
1355
multiprocessing.Process(target = self.sub_process_main,
1356
args = (request, address)).start()
1894
proc = multiprocessing.Process(target = self.sub_process_main,
1895
args = (request, address))
1896
proc.start()
1897
return proc
1898
1357
1899
1358
1900
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1359
1901
""" adds a pipe to the MixIn """
1363
1905
This function creates a new pipe in self.pipe
1364
1906
"""
1365
1907
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1366
1367
super(MultiprocessingMixInWithPipe,
1368
self).process_request(request, client_address)
1908
1909
proc = MultiprocessingMixIn.process_request(self, request,
1910
client_address)
1369
1911
self.child_pipe.close()
1370
self.add_pipe(parent_pipe)
1371
1372
def add_pipe(self, parent_pipe):
1912
self.add_pipe(parent_pipe, proc)
1913
1914
def add_pipe(self, parent_pipe, proc):
1373
1915
"""Dummy function; override as necessary"""
1374
pass
1916
raise NotImplementedError()
1917
1375
1918
1376
1919
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1377
1920
socketserver.TCPServer, object):
1383
1926
use_ipv6: Boolean; to use IPv6 or not
1384
1927
"""
1385
1928
def __init__(self, server_address, RequestHandlerClass,
1386
interface=None, use_ipv6=True):
1929
interface=None, use_ipv6=True, socketfd=None):
1930
"""If socketfd is set, use that file descriptor instead of
1931
creating a new one with socket.socket().
1932
"""
1387
1933
self.interface = interface
1388
1934
if use_ipv6:
1389
1935
self.address_family = socket.AF_INET6
1936
if socketfd is not None:
1937
# Save the file descriptor
1938
self.socketfd = socketfd
1939
# Save the original socket.socket() function
1940
self.socket_socket = socket.socket
1941
# To implement --socket, we monkey patch socket.socket.
1942
#
1943
# (When socketserver.TCPServer is a new-style class, we
1944
# could make self.socket into a property instead of monkey
1945
# patching socket.socket.)
1946
#
1947
# Create a one-time-only replacement for socket.socket()
1948
@functools.wraps(socket.socket)
1949
def socket_wrapper(*args, **kwargs):
1950
# Restore original function so subsequent calls are
1951
# not affected.
1952
socket.socket = self.socket_socket
1953
del self.socket_socket
1954
# This time only, return a new socket object from the
1955
# saved file descriptor.
1956
return socket.fromfd(self.socketfd, *args, **kwargs)
1957
# Replace socket.socket() function with wrapper
1958
socket.socket = socket_wrapper
1959
# The socketserver.TCPServer.__init__ will call
1960
# socket.socket(), which might be our replacement,
1961
# socket_wrapper(), if socketfd was set.
1390
1962
socketserver.TCPServer.__init__(self, server_address,
1391
1963
RequestHandlerClass)
1964
1392
1965
def server_bind(self):
1393
1966
"""This overrides the normal server_bind() function
1394
1967
to bind to an interface if one was specified, and also NOT to
1395
1968
bind to an address or port if they were not specified."""
1396
1969
if self.interface is not None:
1397
1970
if SO_BINDTODEVICE is None:
1398
logger.error(u"SO_BINDTODEVICE does not exist;"
1399
u" cannot bind to interface %s",
1971
logger.error("SO_BINDTODEVICE does not exist;"
1972
" cannot bind to interface %s",
1400
1973
self.interface)
1401
1974
else:
1402
1975
try:
1403
1976
self.socket.setsockopt(socket.SOL_SOCKET,
1404
1977
SO_BINDTODEVICE,
1405
str(self.interface
1406
+ u'\0'))
1407
except socket.error, error:
1408
if error[0] == errno.EPERM:
1409
logger.error(u"No permission to"
1410
u" bind to interface %s",
1411
self.interface)
1412
elif error[0] == errno.ENOPROTOOPT:
1413
logger.error(u"SO_BINDTODEVICE not available;"
1414
u" cannot bind to interface %s",
1415
self.interface)
1978
(self.interface + "\0")
1979
.encode("utf-8"))
1980
except socket.error as error:
1981
if error.errno == errno.EPERM:
1982
logger.error("No permission to bind to"
1983
" interface %s", self.interface)
1984
elif error.errno == errno.ENOPROTOOPT:
1985
logger.error("SO_BINDTODEVICE not available;"
1986
" cannot bind to interface %s",
1987
self.interface)
1988
elif error.errno == errno.ENODEV:
1989
logger.error("Interface %s does not exist,"
1990
" cannot bind", self.interface)
1416
1991
else:
1417
1992
raise
1418
1993
# Only bind(2) the socket if we really need to.
1419
1994
if self.server_address[0] or self.server_address[1]:
1420
1995
if not self.server_address[0]:
1421
1996
if self.address_family == socket.AF_INET6:
1422
any_address = u"::" # in6addr_any
1997
any_address = "::" # in6addr_any
1423
1998
else:
1424
any_address = socket.INADDR_ANY
1999
any_address = "0.0.0.0" # INADDR_ANY
1425
2000
self.server_address = (any_address,
1426
2001
self.server_address[1])
1427
2002
elif not self.server_address[1]:
1448
2023
"""
1449
2024
def __init__(self, server_address, RequestHandlerClass,
1450
2025
interface=None, use_ipv6=True, clients=None,
1451
gnutls_priority=None, use_dbus=True):
2026
gnutls_priority=None, use_dbus=True, socketfd=None):
1452
2027
self.enabled = False
1453
2028
self.clients = clients
1454
2029
if self.clients is None:
1455
self.clients = set()
2030
self.clients = {}
1456
2031
self.use_dbus = use_dbus
1457
2032
self.gnutls_priority = gnutls_priority
1458
2033
IPv6_TCPServer.__init__(self, server_address,
1459
2034
RequestHandlerClass,
1460
2035
interface = interface,
1461
use_ipv6 = use_ipv6)
2036
use_ipv6 = use_ipv6,
2037
socketfd = socketfd)
1462
2038
def server_activate(self):
1463
2039
if self.enabled:
1464
2040
return socketserver.TCPServer.server_activate(self)
2041
1465
2042
def enable(self):
1466
2043
self.enabled = True
1467
def add_pipe(self, parent_pipe):
2044
2045
def add_pipe(self, parent_pipe, proc):
1468
2046
# Call "handle_ipc" for both data and EOF events
1469
2047
gobject.io_add_watch(parent_pipe.fileno(),
1470
2048
gobject.IO_IN | gobject.IO_HUP,
1471
2049
functools.partial(self.handle_ipc,
1472
parent_pipe = parent_pipe))
1473
2050
parent_pipe =
2051
parent_pipe,
2052
proc = proc))
2053
1474
2054
def handle_ipc(self, source, condition, parent_pipe=None,
1475
client_object=None):
1476
condition_names = {
1477
gobject.IO_IN: u"IN", # There is data to read.
1478
gobject.IO_OUT: u"OUT", # Data can be written (without
1479
# blocking).
1480
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1481
gobject.IO_ERR: u"ERR", # Error condition.
1482
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1483
# broken, usually for pipes and
1484
# sockets).
1485
}
1486
conditions_string = ' | '.join(name
1487
for cond, name in
1488
condition_names.iteritems()
1489
if cond & condition)
1490
# error or the other end of multiprocessing.Pipe has closed
1491
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
2055
proc = None, client_object=None):
2056
# error, or the other end of multiprocessing.Pipe has closed
2057
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2058
# Wait for other process to exit
2059
proc.join()
1492
2060
return False
1493
2061
1494
2062
# Read a request from the child
1499
2067
fpr = request[1]
1500
2068
address = request[2]
1501
2069
1502
for c in self.clients:
2070
for c in self.clients.itervalues():
1503
2071
if c.fingerprint == fpr:
1504
2072
client = c
1505
2073
break
1506
2074
else:
1507
logger.warning(u"Client not found for fingerprint: %s, ad"
1508
u"dress: %s", fpr, address)
2075
logger.info("Client not found for fingerprint: %s, ad"
2076
"dress: %s", fpr, address)
1509
2077
if self.use_dbus:
1510
2078
# Emit D-Bus signal
1511
mandos_dbus_service.ClientNotFound(fpr, address)
2079
mandos_dbus_service.ClientNotFound(fpr,
2080
address[0])
1512
2081
parent_pipe.send(False)
1513
2082
return False
1514
2083
1515
2084
gobject.io_add_watch(parent_pipe.fileno(),
1516
2085
gobject.IO_IN | gobject.IO_HUP,
1517
2086
functools.partial(self.handle_ipc,
1518
parent_pipe = parent_pipe,
1519
client_object = client))
2087
parent_pipe =
2088
parent_pipe,
2089
proc = proc,
2090
client_object =
2091
client))
1520
2092
parent_pipe.send(True)
1521
# remove the old hook in favor of the new above hook on same fileno
2093
# remove the old hook in favor of the new above hook on
2094
# same fileno
1522
2095
return False
1523
2096
if command == 'funcall':
1524
2097
funcname = request[1]
1525
2098
args = request[2]
1526
2099
kwargs = request[3]
1527
2100
1528
parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))
1529
2101
parent_pipe.send(('data', getattr(client_object,
2102
funcname)(*args,
2103
**kwargs)))
2104
1530
2105
if command == 'getattr':
1531
2106
attrname = request[1]
1532
2107
if callable(client_object.__getattribute__(attrname)):
1533
2108
parent_pipe.send(('function',))
1534
2109
else:
1535
parent_pipe.send(('data', client_object.__getattribute__(attrname)))
2110
parent_pipe.send(('data', client_object
2111
.__getattribute__(attrname)))
1536
2112
1537
2113
if command == 'setattr':
1538
2114
attrname = request[1]
1539
2115
value = request[2]
1540
2116
setattr(client_object, attrname, value)
1541
2117
1542
2118
return True
1543
2119
1544
2120
2121
def rfc3339_duration_to_delta(duration):
2122
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2123
2124
>>> rfc3339_duration_to_delta("P7D")
2125
datetime.timedelta(7)
2126
>>> rfc3339_duration_to_delta("PT60S")
2127
datetime.timedelta(0, 60)
2128
>>> rfc3339_duration_to_delta("PT60M")
2129
datetime.timedelta(0, 3600)
2130
>>> rfc3339_duration_to_delta("PT24H")
2131
datetime.timedelta(1)
2132
>>> rfc3339_duration_to_delta("P1W")
2133
datetime.timedelta(7)
2134
>>> rfc3339_duration_to_delta("PT5M30S")
2135
datetime.timedelta(0, 330)
2136
>>> rfc3339_duration_to_delta("P1DT3M20S")
2137
datetime.timedelta(1, 200)
2138
"""
2139
2140
# Parsing an RFC 3339 duration with regular expressions is not
2141
# possible - there would have to be multiple places for the same
2142
# values, like seconds. The current code, while more esoteric, is
2143
# cleaner without depending on a parsing library. If Python had a
2144
# built-in library for parsing we would use it, but we'd like to
2145
# avoid excessive use of external libraries.
2146
2147
# New type for defining tokens, syntax, and semantics all-in-one
2148
Token = collections.namedtuple("Token",
2149
("regexp", # To match token; if
2150
# "value" is not None,
2151
# must have a "group"
2152
# containing digits
2153
"value", # datetime.timedelta or
2154
# None
2155
"followers")) # Tokens valid after
2156
# this token
2157
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2158
# the "duration" ABNF definition in RFC 3339, Appendix A.
2159
token_end = Token(re.compile(r"$"), None, frozenset())
2160
token_second = Token(re.compile(r"(\d+)S"),
2161
datetime.timedelta(seconds=1),
2162
frozenset((token_end,)))
2163
token_minute = Token(re.compile(r"(\d+)M"),
2164
datetime.timedelta(minutes=1),
2165
frozenset((token_second, token_end)))
2166
token_hour = Token(re.compile(r"(\d+)H"),
2167
datetime.timedelta(hours=1),
2168
frozenset((token_minute, token_end)))
2169
token_time = Token(re.compile(r"T"),
2170
None,
2171
frozenset((token_hour, token_minute,
2172
token_second)))
2173
token_day = Token(re.compile(r"(\d+)D"),
2174
datetime.timedelta(days=1),
2175
frozenset((token_time, token_end)))
2176
token_month = Token(re.compile(r"(\d+)M"),
2177
datetime.timedelta(weeks=4),
2178
frozenset((token_day, token_end)))
2179
token_year = Token(re.compile(r"(\d+)Y"),
2180
datetime.timedelta(weeks=52),
2181
frozenset((token_month, token_end)))
2182
token_week = Token(re.compile(r"(\d+)W"),
2183
datetime.timedelta(weeks=1),
2184
frozenset((token_end,)))
2185
token_duration = Token(re.compile(r"P"), None,
2186
frozenset((token_year, token_month,
2187
token_day, token_time,
2188
token_week)))
2189
# Define starting values
2190
value = datetime.timedelta() # Value so far
2191
found_token = None
2192
followers = frozenset((token_duration,)) # Following valid tokens
2193
s = duration # String left to parse
2194
# Loop until end token is found
2195
while found_token is not token_end:
2196
# Search for any currently valid tokens
2197
for token in followers:
2198
match = token.regexp.match(s)
2199
if match is not None:
2200
# Token found
2201
if token.value is not None:
2202
# Value found, parse digits
2203
factor = int(match.group(1), 10)
2204
# Add to value so far
2205
value += factor * token.value
2206
# Strip token from string
2207
s = token.regexp.sub("", s, 1)
2208
# Go to found token
2209
found_token = token
2210
# Set valid next tokens
2211
followers = found_token.followers
2212
break
2213
else:
2214
# No currently valid tokens were found
2215
raise ValueError("Invalid RFC 3339 duration")
2216
# End token found
2217
return value
2218
2219
1545
2220
def string_to_delta(interval):
1546
2221
"""Parse a string and return a datetime.timedelta
1547
2222
1548
>>> string_to_delta(u'7d')
2223
>>> string_to_delta('7d')
1549
2224
datetime.timedelta(7)
1550
>>> string_to_delta(u'60s')
2225
>>> string_to_delta('60s')
1551
2226
datetime.timedelta(0, 60)
1552
>>> string_to_delta(u'60m')
2227
>>> string_to_delta('60m')
1553
2228
datetime.timedelta(0, 3600)
1554
>>> string_to_delta(u'24h')
2229
>>> string_to_delta('24h')
1555
2230
datetime.timedelta(1)
1556
>>> string_to_delta(u'1w')
2231
>>> string_to_delta('1w')
1557
2232
datetime.timedelta(7)
1558
>>> string_to_delta(u'5m 30s')
2233
>>> string_to_delta('5m 30s')
1559
2234
datetime.timedelta(0, 330)
1560
2235
"""
2236
2237
try:
2238
return rfc3339_duration_to_delta(interval)
2239
except ValueError:
2240
pass
2241
1561
2242
timevalue = datetime.timedelta(0)
1562
2243
for s in interval.split():
1563
2244
try:
1564
suffix = unicode(s[-1])
2245
suffix = s[-1]
1565
2246
value = int(s[:-1])
1566
if suffix == u"d":
2247
if suffix == "d":
1567
2248
delta = datetime.timedelta(value)
1568
elif suffix == u"s":
2249
elif suffix == "s":
1569
2250
delta = datetime.timedelta(0, value)
1570
elif suffix == u"m":
2251
elif suffix == "m":
1571
2252
delta = datetime.timedelta(0, 0, 0, 0, value)
1572
elif suffix == u"h":
2253
elif suffix == "h":
1573
2254
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1574
elif suffix == u"w":
2255
elif suffix == "w":
1575
2256
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1576
2257
else:
1577
raise ValueError(u"Unknown suffix %r" % suffix)
1578
except (ValueError, IndexError), e:
1579
raise ValueError(e.message)
2258
raise ValueError("Unknown suffix {!r}"
2259
.format(suffix))
2260
except IndexError as e:
2261
raise ValueError(*(e.args))
1580
2262
timevalue += delta
1581
2263
return timevalue
1582
2264
1583
2265
1584
def if_nametoindex(interface):
1585
"""Call the C function if_nametoindex(), or equivalent
1586
1587
Note: This function cannot accept a unicode string."""
1588
global if_nametoindex
1589
try:
1590
if_nametoindex = (ctypes.cdll.LoadLibrary
1591
(ctypes.util.find_library(u"c"))
1592
.if_nametoindex)
1593
except (OSError, AttributeError):
1594
logger.warning(u"Doing if_nametoindex the hard way")
1595
def if_nametoindex(interface):
1596
"Get an interface index the hard way, i.e. using fcntl()"
1597
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1598
with contextlib.closing(socket.socket()) as s:
1599
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1600
struct.pack(str(u"16s16x"),
1601
interface))
1602
interface_index = struct.unpack(str(u"I"),
1603
ifreq[16:20])[0]
1604
return interface_index
1605
return if_nametoindex(interface)
1606
1607
1608
2266
def daemon(nochdir = False, noclose = False):
1609
2267
"""See daemon(3). Standard BSD Unix function.
1610
2268
1613
2271
sys.exit()
1614
2272
os.setsid()
1615
2273
if not nochdir:
1616
os.chdir(u"/")
2274
os.chdir("/")
1617
2275
if os.fork():
1618
2276
sys.exit()
1619
2277
if not noclose:
1620
2278
# Close all standard open file descriptors
1621
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2279
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1622
2280
if not stat.S_ISCHR(os.fstat(null).st_mode):
1623
raise OSError(errno.ENODEV,
1624
u"%s not a character device"
1625
% os.path.devnull)
2281
raise OSError(errno.ENODEV, "{} not a character device"
2282
.format(os.devnull))
1626
2283
os.dup2(null, sys.stdin.fileno())
1627
2284
os.dup2(null, sys.stdout.fileno())
1628
2285
os.dup2(null, sys.stderr.fileno())
1635
2292
##################################################################
1636
2293
# Parsing of options, both command line and config file
1637
2294
1638
parser = optparse.OptionParser(version = "%%prog %s" % version)
1639
parser.add_option("-i", u"--interface", type=u"string",
1640
metavar="IF", help=u"Bind to interface IF")
1641
parser.add_option("-a", u"--address", type=u"string",
1642
help=u"Address to listen for requests on")
1643
parser.add_option("-p", u"--port", type=u"int",
1644
help=u"Port number to receive requests on")
1645
parser.add_option("--check", action=u"store_true",
1646
help=u"Run self-test")
1647
parser.add_option("--debug", action=u"store_true",
1648
help=u"Debug mode; run in foreground and log to"
1649
u" terminal")
1650
parser.add_option("--debuglevel", type=u"string", metavar="Level",
1651
help=u"Debug level for stdout output")
1652
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1653
u" priority string (see GnuTLS documentation)")
1654
parser.add_option("--servicename", type=u"string",
1655
metavar=u"NAME", help=u"Zeroconf service name")
1656
parser.add_option("--configdir", type=u"string",
1657
default=u"/etc/mandos", metavar=u"DIR",
1658
help=u"Directory to search for configuration"
1659
u" files")
1660
parser.add_option("--no-dbus", action=u"store_false",
1661
dest=u"use_dbus", help=u"Do not provide D-Bus"
1662
u" system bus interface")
1663
parser.add_option("--no-ipv6", action=u"store_false",
1664
dest=u"use_ipv6", help=u"Do not use IPv6")
1665
options = parser.parse_args()[0]
2295
parser = argparse.ArgumentParser()
2296
parser.add_argument("-v", "--version", action="version",
2297
version = "%(prog)s {}".format(version),
2298
help="show version number and exit")
2299
parser.add_argument("-i", "--interface", metavar="IF",
2300
help="Bind to interface IF")
2301
parser.add_argument("-a", "--address",
2302
help="Address to listen for requests on")
2303
parser.add_argument("-p", "--port", type=int,
2304
help="Port number to receive requests on")
2305
parser.add_argument("--check", action="store_true",
2306
help="Run self-test")
2307
parser.add_argument("--debug", action="store_true",
2308
help="Debug mode; run in foreground and log"
2309
" to terminal", default=None)
2310
parser.add_argument("--debuglevel", metavar="LEVEL",
2311
help="Debug level for stdout output")
2312
parser.add_argument("--priority", help="GnuTLS"
2313
" priority string (see GnuTLS documentation)")
2314
parser.add_argument("--servicename",
2315
metavar="NAME", help="Zeroconf service name")
2316
parser.add_argument("--configdir",
2317
default="/etc/mandos", metavar="DIR",
2318
help="Directory to search for configuration"
2319
" files")
2320
parser.add_argument("--no-dbus", action="store_false",
2321
dest="use_dbus", help="Do not provide D-Bus"
2322
" system bus interface", default=None)
2323
parser.add_argument("--no-ipv6", action="store_false",
2324
dest="use_ipv6", help="Do not use IPv6",
2325
default=None)
2326
parser.add_argument("--no-restore", action="store_false",
2327
dest="restore", help="Do not restore stored"
2328
" state", default=None)
2329
parser.add_argument("--socket", type=int,
2330
help="Specify a file descriptor to a network"
2331
" socket to use instead of creating one")
2332
parser.add_argument("--statedir", metavar="DIR",
2333
help="Directory to save/restore state in")
2334
parser.add_argument("--foreground", action="store_true",
2335
help="Run in foreground", default=None)
2336
parser.add_argument("--no-zeroconf", action="store_false",
2337
dest="zeroconf", help="Do not use Zeroconf",
2338
default=None)
2339
2340
options = parser.parse_args()
1666
2341
1667
2342
if options.check:
1668
2343
import doctest
1669
doctest.testmod()
1670
sys.exit()
2344
fail_count, test_count = doctest.testmod()
2345
sys.exit(os.EX_OK if fail_count == 0 else 1)
1671
2346
1672
2347
# Default values for config file for server-global settings
1673
server_defaults = { u"interface": u"",
1674
u"address": u"",
1675
u"port": u"",
1676
u"debug": u"False",
1677
u"priority":
1678
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1679
u"servicename": u"Mandos",
1680
u"use_dbus": u"True",
1681
u"use_ipv6": u"True",
1682
u"debuglevel": u"",
2348
server_defaults = { "interface": "",
2349
"address": "",
2350
"port": "",
2351
"debug": "False",
2352
"priority":
2353
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2354
"servicename": "Mandos",
2355
"use_dbus": "True",
2356
"use_ipv6": "True",
2357
"debuglevel": "",
2358
"restore": "True",
2359
"socket": "",
2360
"statedir": "/var/lib/mandos",
2361
"foreground": "False",
2362
"zeroconf": "True",
1683
2363
}
1684
2364
1685
2365
# Parse config file for server-global settings
1686
2366
server_config = configparser.SafeConfigParser(server_defaults)
1687
2367
del server_defaults
1688
2368
server_config.read(os.path.join(options.configdir,
1689
u"mandos.conf"))
2369
"mandos.conf"))
1690
2370
# Convert the SafeConfigParser object to a dict
1691
2371
server_settings = server_config.defaults()
1692
2372
# Use the appropriate methods on the non-string config options
1693
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1694
server_settings[option] = server_config.getboolean(u"DEFAULT",
2373
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2374
server_settings[option] = server_config.getboolean("DEFAULT",
1695
2375
option)
1696
2376
if server_settings["port"]:
1697
server_settings["port"] = server_config.getint(u"DEFAULT",
1698
u"port")
2377
server_settings["port"] = server_config.getint("DEFAULT",
2378
"port")
2379
if server_settings["socket"]:
2380
server_settings["socket"] = server_config.getint("DEFAULT",
2381
"socket")
2382
# Later, stdin will, and stdout and stderr might, be dup'ed
2383
# over with an opened os.devnull. But we don't want this to
2384
# happen with a supplied network socket.
2385
if 0 <= server_settings["socket"] <= 2:
2386
server_settings["socket"] = os.dup(server_settings
2387
["socket"])
1699
2388
del server_config
1700
2389
1701
2390
# Override the settings from the config file with command line
1702
2391
# options, if set.
1703
for option in (u"interface", u"address", u"port", u"debug",
1704
u"priority", u"servicename", u"configdir",
1705
u"use_dbus", u"use_ipv6", u"debuglevel"):
2392
for option in ("interface", "address", "port", "debug",
2393
"priority", "servicename", "configdir",
2394
"use_dbus", "use_ipv6", "debuglevel", "restore",
2395
"statedir", "socket", "foreground", "zeroconf"):
1706
2396
value = getattr(options, option)
1707
2397
if value is not None:
1708
2398
server_settings[option] = value
1709
2399
del options
1710
2400
# Force all strings to be unicode
1711
2401
for option in server_settings.keys():
1712
if type(server_settings[option]) is str:
1713
server_settings[option] = unicode(server_settings[option])
2402
if isinstance(server_settings[option], bytes):
2403
server_settings[option] = (server_settings[option]
2404
.decode("utf-8"))
2405
# Force all boolean options to be boolean
2406
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2407
"foreground", "zeroconf"):
2408
server_settings[option] = bool(server_settings[option])
2409
# Debug implies foreground
2410
if server_settings["debug"]:
2411
server_settings["foreground"] = True
1714
2412
# Now we have our good server settings in "server_settings"
1715
2413
1716
2414
##################################################################
1717
2415
2416
if (not server_settings["zeroconf"] and
2417
not (server_settings["port"]
2418
or server_settings["socket"] != "")):
2419
parser.error("Needs port or socket to work without"
2420
" Zeroconf")
2421
1718
2422
# For convenience
1719
debug = server_settings[u"debug"]
1720
debuglevel = server_settings[u"debuglevel"]
1721
use_dbus = server_settings[u"use_dbus"]
1722
use_ipv6 = server_settings[u"use_ipv6"]
1723
1724
if server_settings[u"servicename"] != u"Mandos":
2423
debug = server_settings["debug"]
2424
debuglevel = server_settings["debuglevel"]
2425
use_dbus = server_settings["use_dbus"]
2426
use_ipv6 = server_settings["use_ipv6"]
2427
stored_state_path = os.path.join(server_settings["statedir"],
2428
stored_state_file)
2429
foreground = server_settings["foreground"]
2430
zeroconf = server_settings["zeroconf"]
2431
2432
if debug:
2433
initlogger(debug, logging.DEBUG)
2434
else:
2435
if not debuglevel:
2436
initlogger(debug)
2437
else:
2438
level = getattr(logging, debuglevel.upper())
2439
initlogger(debug, level)
2440
2441
if server_settings["servicename"] != "Mandos":
1725
2442
syslogger.setFormatter(logging.Formatter
1726
(u'Mandos (%s) [%%(process)d]:'
1727
u' %%(levelname)s: %%(message)s'
1728
% server_settings[u"servicename"]))
2443
('Mandos ({}) [%(process)d]:'
2444
' %(levelname)s: %(message)s'
2445
.format(server_settings
2446
["servicename"])))
1729
2447
1730
2448
# Parse config file with clients
1731
client_defaults = { u"timeout": u"1h",
1732
u"interval": u"5m",
1733
u"checker": u"fping -q -- %%(host)s",
1734
u"host": u"",
1735
u"approval_delay": u"0s",
1736
u"approval_duration": u"1s",
1737
}
1738
client_config = configparser.SafeConfigParser(client_defaults)
1739
client_config.read(os.path.join(server_settings[u"configdir"],
1740
u"clients.conf"))
2449
client_config = configparser.SafeConfigParser(Client
2450
.client_defaults)
2451
client_config.read(os.path.join(server_settings["configdir"],
2452
"clients.conf"))
1741
2453
1742
2454
global mandos_dbus_service
1743
2455
mandos_dbus_service = None
1744
2456
1745
tcp_server = MandosServer((server_settings[u"address"],
1746
server_settings[u"port"]),
2457
socketfd = None
2458
if server_settings["socket"] != "":
2459
socketfd = server_settings["socket"]
2460
tcp_server = MandosServer((server_settings["address"],
2461
server_settings["port"]),
1747
2462
ClientHandler,
1748
interface=(server_settings[u"interface"]
2463
interface=(server_settings["interface"]
1749
2464
or None),
1750
2465
use_ipv6=use_ipv6,
1751
2466
gnutls_priority=
1752
server_settings[u"priority"],
1753
use_dbus=use_dbus)
1754
pidfilename = u"/var/run/mandos.pid"
1755
try:
1756
pidfile = open(pidfilename, u"w")
1757
except IOError:
1758
logger.error(u"Could not open file %r", pidfilename)
2467
server_settings["priority"],
2468
use_dbus=use_dbus,
2469
socketfd=socketfd)
2470
if not foreground:
2471
pidfilename = "/run/mandos.pid"
2472
if not os.path.isdir("/run/."):
2473
pidfilename = "/var/run/mandos.pid"
2474
pidfile = None
2475
try:
2476
pidfile = open(pidfilename, "w")
2477
except IOError as e:
2478
logger.error("Could not open file %r", pidfilename,
2479
exc_info=e)
1759
2480
1760
try:
1761
uid = pwd.getpwnam(u"_mandos").pw_uid
1762
gid = pwd.getpwnam(u"_mandos").pw_gid
1763
except KeyError:
2481
for name in ("_mandos", "mandos", "nobody"):
1764
2482
try:
1765
uid = pwd.getpwnam(u"mandos").pw_uid
1766
gid = pwd.getpwnam(u"mandos").pw_gid
2483
uid = pwd.getpwnam(name).pw_uid
2484
gid = pwd.getpwnam(name).pw_gid
2485
break
1767
2486
except KeyError:
1768
try:
1769
uid = pwd.getpwnam(u"nobody").pw_uid
1770
gid = pwd.getpwnam(u"nobody").pw_gid
1771
except KeyError:
1772
uid = 65534
1773
gid = 65534
2487
continue
2488
else:
2489
uid = 65534
2490
gid = 65534
1774
2491
try:
1775
2492
os.setgid(gid)
1776
2493
os.setuid(uid)
1777
except OSError, error:
1778
if error[0] != errno.EPERM:
1779
raise error
2494
except OSError as error:
2495
if error.errno != errno.EPERM:
2496
raise
1780
2497
1781
if not debug and not debuglevel:
1782
syslogger.setLevel(logging.WARNING)
1783
console.setLevel(logging.WARNING)
1784
if debuglevel:
1785
level = getattr(logging, debuglevel.upper())
1786
syslogger.setLevel(level)
1787
console.setLevel(level)
1788
1789
2498
if debug:
1790
2499
# Enable all possible GnuTLS debugging
1791
2500
1795
2504
1796
2505
@gnutls.library.types.gnutls_log_func
1797
2506
def debug_gnutls(level, string):
1798
logger.debug(u"GnuTLS: %s", string[:-1])
2507
logger.debug("GnuTLS: %s", string[:-1])
1799
2508
1800
2509
(gnutls.library.functions
1801
2510
.gnutls_global_set_log_function(debug_gnutls))
1802
2511
1803
2512
# Redirect stdin so all checkers get /dev/null
1804
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2513
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1805
2514
os.dup2(null, sys.stdin.fileno())
1806
2515
if null > 2:
1807
2516
os.close(null)
1808
else:
1809
# No console logging
1810
logger.removeHandler(console)
1811
2517
2518
# Need to fork before connecting to D-Bus
2519
if not foreground:
2520
# Close all input and output, do double fork, etc.
2521
daemon()
2522
2523
# multiprocessing will use threads, so before we use gobject we
2524
# need to inform gobject that threads will be used.
2525
gobject.threads_init()
1812
2526
1813
2527
global main_loop
1814
2528
# From the Avahi example code
1815
DBusGMainLoop(set_as_default=True )
2529
DBusGMainLoop(set_as_default=True)
1816
2530
main_loop = gobject.MainLoop()
1817
2531
bus = dbus.SystemBus()
1818
2532
# End of Avahi example code
1819
2533
if use_dbus:
1820
2534
try:
1821
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
2535
bus_name = dbus.service.BusName("se.recompile.Mandos",
1822
2536
bus, do_not_queue=True)
1823
except dbus.exceptions.NameExistsException, e:
1824
logger.error(unicode(e) + u", disabling D-Bus")
2537
old_bus_name = (dbus.service.BusName
2538
("se.bsnet.fukt.Mandos", bus,
2539
do_not_queue=True))
2540
except dbus.exceptions.NameExistsException as e:
2541
logger.error("Disabling D-Bus:", exc_info=e)
1825
2542
use_dbus = False
1826
server_settings[u"use_dbus"] = False
2543
server_settings["use_dbus"] = False
1827
2544
tcp_server.use_dbus = False
1828
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1829
service = AvahiService(name = server_settings[u"servicename"],
1830
servicetype = u"_mandos._tcp",
1831
protocol = protocol, bus = bus)
1832
if server_settings["interface"]:
1833
service.interface = (if_nametoindex
1834
(str(server_settings[u"interface"])))
1835
1836
if not debug:
1837
# Close all input and output, do double fork, etc.
1838
daemon()
1839
2545
if zeroconf:
2546
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2547
service = AvahiServiceToSyslog(name =
2548
server_settings["servicename"],
2549
servicetype = "_mandos._tcp",
2550
protocol = protocol, bus = bus)
2551
if server_settings["interface"]:
2552
service.interface = (if_nametoindex
2553
(server_settings["interface"]
2554
.encode("utf-8")))
2555
1840
2556
global multiprocessing_manager
1841
2557
multiprocessing_manager = multiprocessing.Manager()
1842
2558
1843
2559
client_class = Client
1844
2560
if use_dbus:
1845
2561
client_class = functools.partial(ClientDBus, bus = bus)
1846
def client_config_items(config, section):
1847
special_settings = {
1848
"approved_by_default":
1849
lambda: config.getboolean(section,
1850
"approved_by_default"),
1851
}
1852
for name, value in config.items(section):
2562
2563
client_settings = Client.config_parser(client_config)
2564
old_client_settings = {}
2565
clients_data = {}
2566
2567
# This is used to redirect stdout and stderr for checker processes
2568
global wnull
2569
wnull = open(os.devnull, "w") # A writable /dev/null
2570
# Only used if server is running in foreground but not in debug
2571
# mode
2572
if debug or not foreground:
2573
wnull.close()
2574
2575
# Get client data and settings from last running state.
2576
if server_settings["restore"]:
2577
try:
2578
with open(stored_state_path, "rb") as stored_state:
2579
clients_data, old_client_settings = (pickle.load
2580
(stored_state))
2581
os.remove(stored_state_path)
2582
except IOError as e:
2583
if e.errno == errno.ENOENT:
2584
logger.warning("Could not load persistent state: {}"
2585
.format(os.strerror(e.errno)))
2586
else:
2587
logger.critical("Could not load persistent state:",
2588
exc_info=e)
2589
raise
2590
except EOFError as e:
2591
logger.warning("Could not load persistent state: "
2592
"EOFError:", exc_info=e)
2593
2594
with PGPEngine() as pgp:
2595
for client_name, client in clients_data.items():
2596
# Skip removed clients
2597
if client_name not in client_settings:
2598
continue
2599
2600
# Decide which value to use after restoring saved state.
2601
# We have three different values: Old config file,
2602
# new config file, and saved state.
2603
# New config value takes precedence if it differs from old
2604
# config value, otherwise use saved state.
2605
for name, value in client_settings[client_name].items():
2606
try:
2607
# For each value in new config, check if it
2608
# differs from the old config value (Except for
2609
# the "secret" attribute)
2610
if (name != "secret" and
2611
value != old_client_settings[client_name]
2612
[name]):
2613
client[name] = value
2614
except KeyError:
2615
pass
2616
2617
# Clients who has passed its expire date can still be
2618
# enabled if its last checker was successful. Clients
2619
# whose checker succeeded before we stored its state is
2620
# assumed to have successfully run all checkers during
2621
# downtime.
2622
if client["enabled"]:
2623
if datetime.datetime.utcnow() >= client["expires"]:
2624
if not client["last_checked_ok"]:
2625
logger.warning(
2626
"disabling client {} - Client never "
2627
"performed a successful checker"
2628
.format(client_name))
2629
client["enabled"] = False
2630
elif client["last_checker_status"] != 0:
2631
logger.warning(
2632
"disabling client {} - Client last"
2633
" checker failed with error code {}"
2634
.format(client_name,
2635
client["last_checker_status"]))
2636
client["enabled"] = False
2637
else:
2638
client["expires"] = (datetime.datetime
2639
.utcnow()
2640
+ client["timeout"])
2641
logger.debug("Last checker succeeded,"
2642
" keeping {} enabled"
2643
.format(client_name))
1853
2644
try:
1854
yield (name, special_settings[name]())
1855
except KeyError:
1856
yield (name, value)
1857
1858
tcp_server.clients.update(set(
1859
client_class(name = section,
1860
config= dict(client_config_items(
1861
client_config, section)))
1862
for section in client_config.sections()))
2645
client["secret"] = (
2646
pgp.decrypt(client["encrypted_secret"],
2647
client_settings[client_name]
2648
["secret"]))
2649
except PGPError:
2650
# If decryption fails, we use secret from new settings
2651
logger.debug("Failed to decrypt {} old secret"
2652
.format(client_name))
2653
client["secret"] = (
2654
client_settings[client_name]["secret"])
2655
2656
# Add/remove clients based on new changes made to config
2657
for client_name in (set(old_client_settings)
2658
- set(client_settings)):
2659
del clients_data[client_name]
2660
for client_name in (set(client_settings)
2661
- set(old_client_settings)):
2662
clients_data[client_name] = client_settings[client_name]
2663
2664
# Create all client objects
2665
for client_name, client in clients_data.items():
2666
tcp_server.clients[client_name] = client_class(
2667
name = client_name, settings = client,
2668
server_settings = server_settings)
2669
1863
2670
if not tcp_server.clients:
1864
logger.warning(u"No clients defined")
1865
1866
try:
1867
with pidfile:
1868
pid = os.getpid()
1869
pidfile.write(str(pid) + "\n")
2671
logger.warning("No clients defined")
2672
2673
if not foreground:
2674
if pidfile is not None:
2675
try:
2676
with pidfile:
2677
pid = os.getpid()
2678
pidfile.write("{}\n".format(pid).encode("utf-8"))
2679
except IOError:
2680
logger.error("Could not write to file %r with PID %d",
2681
pidfilename, pid)
1870
2682
del pidfile
1871
except IOError:
1872
logger.error(u"Could not write to file %r with PID %d",
1873
pidfilename, pid)
1874
except NameError:
1875
# "pidfile" was never created
1876
pass
1877
del pidfilename
2683
del pidfilename
1878
2684
1879
if not debug:
1880
signal.signal(signal.SIGINT, signal.SIG_IGN)
1881
2685
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1882
2686
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1883
2687
1884
2688
if use_dbus:
1885
class MandosDBusService(dbus.service.Object):
2689
@alternate_dbus_interfaces({"se.recompile.Mandos":
2690
"se.bsnet.fukt.Mandos"})
2691
class MandosDBusService(DBusObjectWithProperties):
1886
2692
"""A D-Bus proxy object"""
1887
2693
def __init__(self):
1888
dbus.service.Object.__init__(self, bus, u"/")
1889
_interface = u"se.bsnet.fukt.Mandos"
1890
1891
@dbus.service.signal(_interface, signature=u"o")
2694
dbus.service.Object.__init__(self, bus, "/")
2695
_interface = "se.recompile.Mandos"
2696
2697
@dbus_interface_annotations(_interface)
2698
def _foo(self):
2699
return { "org.freedesktop.DBus.Property"
2700
".EmitsChangedSignal":
2701
"false"}
2702
2703
@dbus.service.signal(_interface, signature="o")
1892
2704
def ClientAdded(self, objpath):
1893
2705
"D-Bus signal"
1894
2706
pass
1895
2707
1896
@dbus.service.signal(_interface, signature=u"ss")
2708
@dbus.service.signal(_interface, signature="ss")
1897
2709
def ClientNotFound(self, fingerprint, address):
1898
2710
"D-Bus signal"
1899
2711
pass
1900
2712
1901
@dbus.service.signal(_interface, signature=u"os")
2713
@dbus.service.signal(_interface, signature="os")
1902
2714
def ClientRemoved(self, objpath, name):
1903
2715
"D-Bus signal"
1904
2716
pass
1905
2717
1906
@dbus.service.method(_interface, out_signature=u"ao")
2718
@dbus.service.method(_interface, out_signature="ao")
1907
2719
def GetAllClients(self):
1908
2720
"D-Bus method"
1909
2721
return dbus.Array(c.dbus_object_path
1910
for c in tcp_server.clients)
2722
for c in
2723
tcp_server.clients.itervalues())
1911
2724
1912
2725
@dbus.service.method(_interface,
1913
out_signature=u"a{oa{sv}}")
2726
out_signature="a{oa{sv}}")
1914
2727
def GetAllClientsWithProperties(self):
1915
2728
"D-Bus method"
1916
2729
return dbus.Dictionary(
1917
((c.dbus_object_path, c.GetAll(u""))
1918
for c in tcp_server.clients),
1919
signature=u"oa{sv}")
2730
{ c.dbus_object_path: c.GetAll("")
2731
for c in tcp_server.clients.itervalues() },
2732
signature="oa{sv}")
1920
2733
1921
@dbus.service.method(_interface, in_signature=u"o")
2734
@dbus.service.method(_interface, in_signature="o")
1922
2735
def RemoveClient(self, object_path):
1923
2736
"D-Bus method"
1924
for c in tcp_server.clients:
2737
for c in tcp_server.clients.itervalues():
1925
2738
if c.dbus_object_path == object_path:
1926
tcp_server.clients.remove(c)
2739
del tcp_server.clients[c.name]
1927
2740
c.remove_from_connection()
1928
2741
# Don't signal anything except ClientRemoved
1929
2742
c.disable(quiet=True)
1938
2751
1939
2752
def cleanup():
1940
2753
"Cleanup function; run on exit"
1941
service.cleanup()
1942
2754
if zeroconf:
2755
service.cleanup()
2756
2757
multiprocessing.active_children()
2758
wnull.close()
2759
if not (tcp_server.clients or client_settings):
2760
return
2761
2762
# Store client before exiting. Secrets are encrypted with key
2763
# based on what config file has. If config file is
2764
# removed/edited, old secret will thus be unrecovable.
2765
clients = {}
2766
with PGPEngine() as pgp:
2767
for client in tcp_server.clients.itervalues():
2768
key = client_settings[client.name]["secret"]
2769
client.encrypted_secret = pgp.encrypt(client.secret,
2770
key)
2771
client_dict = {}
2772
2773
# A list of attributes that can not be pickled
2774
# + secret.
2775
exclude = { "bus", "changedstate", "secret",
2776
"checker", "server_settings" }
2777
for name, typ in (inspect.getmembers
2778
(dbus.service.Object)):
2779
exclude.add(name)
2780
2781
client_dict["encrypted_secret"] = (client
2782
.encrypted_secret)
2783
for attr in client.client_structure:
2784
if attr not in exclude:
2785
client_dict[attr] = getattr(client, attr)
2786
2787
clients[client.name] = client_dict
2788
del client_settings[client.name]["secret"]
2789
2790
try:
2791
with (tempfile.NamedTemporaryFile
2792
(mode='wb', suffix=".pickle", prefix='clients-',
2793
dir=os.path.dirname(stored_state_path),
2794
delete=False)) as stored_state:
2795
pickle.dump((clients, client_settings), stored_state)
2796
tempname=stored_state.name
2797
os.rename(tempname, stored_state_path)
2798
except (IOError, OSError) as e:
2799
if not debug:
2800
try:
2801
os.remove(tempname)
2802
except NameError:
2803
pass
2804
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2805
logger.warning("Could not save persistent state: {}"
2806
.format(os.strerror(e.errno)))
2807
else:
2808
logger.warning("Could not save persistent state:",
2809
exc_info=e)
2810
raise
2811
2812
# Delete all clients, and settings from config
1943
2813
while tcp_server.clients:
1944
client = tcp_server.clients.pop()
2814
name, client = tcp_server.clients.popitem()
1945
2815
if use_dbus:
1946
2816
client.remove_from_connection()
1947
client.disable_hook = None
1948
2817
# Don't signal anything except ClientRemoved
1949
2818
client.disable(quiet=True)
1950
2819
if use_dbus:
1951
2820
# Emit D-Bus signal
1952
mandos_dbus_service.ClientRemoved(client.dbus_object_path,
2821
mandos_dbus_service.ClientRemoved(client
2822
.dbus_object_path,
1953
2823
client.name)
2824
client_settings.clear()
1954
2825
1955
2826
atexit.register(cleanup)
1956
2827
1957
for client in tcp_server.clients:
2828
for client in tcp_server.clients.itervalues():
1958
2829
if use_dbus:
1959
2830
# Emit D-Bus signal
1960
2831
mandos_dbus_service.ClientAdded(client.dbus_object_path)
1961
client.enable()
2832
# Need to initiate checking of clients
2833
if client.enabled:
2834
client.init_checker()
1962
2835
1963
2836
tcp_server.enable()
1964
2837
tcp_server.server_activate()
1965
2838
1966
2839
# Find out what port we got
1967
service.port = tcp_server.socket.getsockname()[1]
2840
if zeroconf:
2841
service.port = tcp_server.socket.getsockname()[1]
1968
2842
if use_ipv6:
1969
logger.info(u"Now listening on address %r, port %d,"
1970
" flowinfo %d, scope_id %d"
1971
% tcp_server.socket.getsockname())
2843
logger.info("Now listening on address %r, port %d,"
2844
" flowinfo %d, scope_id %d",
2845
*tcp_server.socket.getsockname())
1972
2846
else: # IPv4
1973
logger.info(u"Now listening on address %r, port %d"
1974
% tcp_server.socket.getsockname())
2847
logger.info("Now listening on address %r, port %d",
2848
*tcp_server.socket.getsockname())
1975
2849
1976
2850
#service.interface = tcp_server.socket.getsockname()[3]
1977
2851
1978
2852
try:
1979
# From the Avahi example code
1980
try:
1981
service.activate()
1982
except dbus.exceptions.DBusException, error:
1983
logger.critical(u"DBusException: %s", error)
1984
cleanup()
1985
sys.exit(1)
1986
# End of Avahi example code
2853
if zeroconf:
2854
# From the Avahi example code
2855
try:
2856
service.activate()
2857
except dbus.exceptions.DBusException as error:
2858
logger.critical("D-Bus Exception", exc_info=error)
2859
cleanup()
2860
sys.exit(1)
2861
# End of Avahi example code
1987
2862
1988
2863
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1989
2864
lambda *args, **kwargs:
1990
2865
(tcp_server.handle_request
1991
2866
(*args[2:], **kwargs) or True))
1992
2867
1993
logger.debug(u"Starting main loop")
2868
logger.debug("Starting main loop")
1994
2869
main_loop.run()
1995
except AvahiError, error:
1996
logger.critical(u"AvahiError: %s", error)
2870
except AvahiError as error:
2871
logger.critical("Avahi Error", exc_info=error)
1997
2872
cleanup()
1998
2873
sys.exit(1)
1999
2874
except KeyboardInterrupt:
2000
2875
if debug:
2001
print >> sys.stderr
2002
logger.debug(u"Server received KeyboardInterrupt")
2003
logger.debug(u"Server exiting")
2876
print("", file=sys.stderr)
2877
logger.debug("Server received KeyboardInterrupt")
2878
logger.debug("Server exiting")
2004
2879
# Must run before the D-Bus bus name gets deregistered
2005
2880
cleanup()
2006
2881
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0