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:
- DBUS-API
- debian/source
- debian/upstream
- network-hooks.d
- files removed:
- plugins.d/plymouth
- 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
self.add()
290
try:
291
self.add()
292
except dbus.exceptions.DBusException as error:
293
logger.critical("D-Bus Exception", exc_info=error)
294
self.cleanup()
295
os._exit(1)
169
296
self.rename_count += 1
297
170
298
def remove(self):
171
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
172
303
if self.group is not None:
173
304
self.group.Reset()
305
174
306
def add(self):
175
307
"""Derived from the Avahi example code"""
308
self.remove()
176
309
if self.group is None:
177
310
self.group = dbus.Interface(
178
311
self.bus.get_object(avahi.DBUS_NAME,
179
312
self.server.EntryGroupNew()),
180
313
avahi.DBUS_INTERFACE_ENTRY_GROUP)
181
self.group.connect_to_signal('StateChanged',
182
self
183
.entry_group_state_changed)
184
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' ...",
185
318
self.name, self.type)
186
319
self.group.AddService(
187
320
self.interface,
192
325
dbus.UInt16(self.port),
193
326
avahi.string_array_to_txt_array(self.TXT))
194
327
self.group.Commit()
328
195
329
def entry_group_state_changed(self, state, error):
196
330
"""Derived from the Avahi example code"""
197
logger.debug(u"Avahi state change: %i", state)
331
logger.debug("Avahi entry group state change: %i", state)
198
332
199
333
if state == avahi.ENTRY_GROUP_ESTABLISHED:
200
logger.debug(u"Zeroconf service established.")
334
logger.debug("Zeroconf service established.")
201
335
elif state == avahi.ENTRY_GROUP_COLLISION:
202
logger.warning(u"Zeroconf service name collision.")
336
logger.info("Zeroconf service name collision.")
203
337
self.rename()
204
338
elif state == avahi.ENTRY_GROUP_FAILURE:
205
logger.critical(u"Avahi: Error in group state changed %s",
206
unicode(error))
207
raise AvahiGroupError(u"State changed: %s"
208
% 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
209
344
def cleanup(self):
210
345
"""Derived from the Avahi example code"""
211
346
if self.group is not None:
212
self.group.Free()
347
try:
348
self.group.Free()
349
except (dbus.exceptions.UnknownMethodException,
350
dbus.exceptions.DBusException):
351
pass
213
352
self.group = None
214
def server_state_changed(self, state):
353
self.remove()
354
355
def server_state_changed(self, state, error=None):
215
356
"""Derived from the Avahi example code"""
216
if state == avahi.SERVER_COLLISION:
217
logger.error(u"Zeroconf server name collision")
218
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()
219
372
elif state == avahi.SERVER_RUNNING:
220
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
221
380
def activate(self):
222
381
"""Derived from the Avahi example code"""
223
382
if self.server is None:
224
383
self.server = dbus.Interface(
225
384
self.bus.get_object(avahi.DBUS_NAME,
226
avahi.DBUS_PATH_SERVER),
385
avahi.DBUS_PATH_SERVER,
386
follow_name_owner_changes=True),
227
387
avahi.DBUS_INTERFACE_SERVER)
228
self.server.connect_to_signal(u"StateChanged",
388
self.server.connect_to_signal("StateChanged",
229
389
self.server_state_changed)
230
390
self.server_state_changed(self.server.GetState())
231
391
232
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
233
404
class Client(object):
234
405
"""A representation of a client host served by this server.
235
406
236
407
Attributes:
237
name: string; from the config file, used in log messages and
238
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()
239
426
fingerprint: string (40 or 32 hexadecimal digits); used to
240
427
uniquely identify the client
241
secret: bytestring; sent verbatim (over TLS) to client
242
428
host: string; available for use by the checker command
243
created: datetime.datetime(); (UTC) object creation
244
last_enabled: datetime.datetime(); (UTC)
245
enabled: bool()
429
interval: datetime.timedelta(); How often to start a new checker
430
last_approval_request: datetime.datetime(); (UTC) or None
246
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
247
439
timeout: datetime.timedelta(); How long from last_checked_ok
248
440
until this client is disabled
249
interval: datetime.timedelta(); How often to start a new checker
250
disable_hook: If set, called by disable() as disable_hook(self)
251
checker: subprocess.Popen(); a running checker process used
252
to see if the client lives.
253
'None' if no process is running.
254
checker_initiator_tag: a gobject event source tag, or None
255
disable_initiator_tag: - '' -
256
checker_callback_tag: - '' -
257
checker_command: string; External command which is run to check if
258
client lives. %() expansions are done at
259
runtime with vars(self) as dict, so that for
260
instance %(name)s can be used in the command.
261
current_checker_command: string; current running checker_command
262
approved_delay: datetime.timedelta(); Time to wait for approval
263
_approved: bool(); 'None' if not yet approved/disapproved
264
approved_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()
265
446
"""
266
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
267
464
@staticmethod
268
def _timedelta_to_milliseconds(td):
269
"Convert a datetime.timedelta() to milliseconds"
270
return ((td.days * 24 * 60 * 60 * 1000)
271
+ (td.seconds * 1000)
272
+ (td.microseconds // 1000))
273
274
def timeout_milliseconds(self):
275
"Return the 'timeout' attribute in milliseconds"
276
return self._timedelta_to_milliseconds(self.timeout)
277
278
def interval_milliseconds(self):
279
"Return the 'interval' attribute in milliseconds"
280
return self._timedelta_to_milliseconds(self.interval)
281
282
def approved_delay_milliseconds(self):
283
return self._timedelta_to_milliseconds(self.approved_delay)
284
285
def __init__(self, name = None, disable_hook=None, config=None):
286
"""Note: the 'checker' key in 'config' sets the
287
'checker_command' attribute and *not* the 'checker'
288
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):
289
512
self.name = name
290
if config is None:
291
config = {}
292
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)
293
531
# Uppercase and remove spaces from fingerprint for later
294
532
# comparison purposes with return value from the fingerprint()
295
533
# function
296
self.fingerprint = (config[u"fingerprint"].upper()
297
.replace(u" ", u""))
298
logger.debug(u" Fingerprint: %s", self.fingerprint)
299
if u"secret" in config:
300
self.secret = config[u"secret"].decode(u"base64")
301
elif u"secfile" in config:
302
with open(os.path.expanduser(os.path.expandvars
303
(config[u"secfile"])),
304
"rb") as secfile:
305
self.secret = secfile.read()
306
else:
307
raise TypeError(u"No secret or secfile for client %s"
308
% self.name)
309
self.host = config.get(u"host", u"")
310
self.created = datetime.datetime.utcnow()
311
self.enabled = False
312
self.last_enabled = None
313
self.last_checked_ok = None
314
self.timeout = string_to_delta(config[u"timeout"])
315
self.interval = string_to_delta(config[u"interval"])
316
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
317
539
self.checker = None
318
540
self.checker_initiator_tag = None
319
541
self.disable_initiator_tag = None
320
542
self.checker_callback_tag = None
321
self.checker_command = config[u"checker"]
322
543
self.current_checker_command = None
323
self.last_connect = None
324
self._approved = None
325
self.approved_by_default = config.get(u"approved_by_default",
326
True)
544
self.approved = None
327
545
self.approvals_pending = 0
328
self.approved_delay = string_to_delta(
329
config[u"approved_delay"])
330
self.approved_duration = string_to_delta(
331
config[u"approved_duration"])
332
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)
333
560
561
# Send notice to process children that client state has changed
334
562
def send_changedstate(self):
335
self.changedstate.acquire()
336
self.changedstate.notify_all()
337
self.changedstate.release()
338
563
with self.changedstate:
564
self.changedstate.notify_all()
565
339
566
def enable(self):
340
567
"""Start this client's checker and timeout hooks"""
341
if getattr(self, u"enabled", False):
568
if getattr(self, "enabled", False):
342
569
# Already enabled
343
570
return
344
self.send_changedstate()
571
self.expires = datetime.datetime.utcnow() + self.timeout
572
self.enabled = True
345
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):
346
601
# Schedule a new checker to be started an 'interval' from now,
347
602
# and every interval from then on.
603
if self.checker_initiator_tag is not None:
604
gobject.source_remove(self.checker_initiator_tag)
348
605
self.checker_initiator_tag = (gobject.timeout_add
349
(self.interval_milliseconds(),
606
(int(self.interval
607
.total_seconds() * 1000),
350
608
self.start_checker))
351
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)
352
612
self.disable_initiator_tag = (gobject.timeout_add
353
(self.timeout_milliseconds(),
354
self.disable))
355
self.enabled = True
613
(int(self.timeout
614
.total_seconds() * 1000),
615
self.disable))
356
616
# Also start a new checker *right now*.
357
617
self.start_checker()
358
618
359
def disable(self, quiet=True):
360
"""Disable this client."""
361
if not getattr(self, "enabled", False):
362
return False
363
if not quiet:
364
self.send_changedstate()
365
if not quiet:
366
logger.info(u"Disabling client %s", self.name)
367
if getattr(self, u"disable_initiator_tag", False):
368
gobject.source_remove(self.disable_initiator_tag)
369
self.disable_initiator_tag = None
370
if getattr(self, u"checker_initiator_tag", False):
371
gobject.source_remove(self.checker_initiator_tag)
372
self.checker_initiator_tag = None
373
self.stop_checker()
374
if self.disable_hook:
375
self.disable_hook(self)
376
self.enabled = False
377
# Do not run this again if called by a gobject.timeout_add
378
return False
379
380
def __del__(self):
381
self.disable_hook = None
382
self.disable()
383
384
619
def checker_callback(self, pid, condition, command):
385
620
"""The checker has completed, so take appropriate actions."""
386
621
self.checker_callback_tag = None
387
622
self.checker = None
388
623
if os.WIFEXITED(condition):
389
exitstatus = os.WEXITSTATUS(condition)
390
if exitstatus == 0:
391
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",
392
627
vars(self))
393
628
self.checked_ok()
394
629
else:
395
logger.info(u"Checker for %(name)s failed",
630
logger.info("Checker for %(name)s failed",
396
631
vars(self))
397
632
else:
398
logger.warning(u"Checker for %(name)s crashed?",
633
self.last_checker_status = -1
634
logger.warning("Checker for %(name)s crashed?",
399
635
vars(self))
400
636
401
637
def checked_ok(self):
402
"""Bump up the timeout for this client.
403
404
This should only be called when the client has been seen,
405
alive and well.
406
"""
638
"""Assert that the client has been seen, alive and well."""
407
639
self.last_checked_ok = datetime.datetime.utcnow()
408
gobject.source_remove(self.disable_initiator_tag)
409
self.disable_initiator_tag = (gobject.timeout_add
410
(self.timeout_milliseconds(),
411
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()
412
658
413
659
def start_checker(self):
414
660
"""Start a new checker subprocess if one is not running.
416
662
If a checker already exists, leave it running and do
417
663
nothing."""
418
664
# The reason for not killing a running checker is that if we
419
# did that, then if a checker (for some reason) started
420
# running slowly and taking more than 'interval' time, the
421
# client would inevitably timeout, since no checker would get
422
# 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
423
669
# checkers alone, the checker would have to take more time
424
670
# than 'timeout' for the client to be disabled, which is as it
425
671
# should be.
427
673
# If a checker exists, make sure it is not a zombie
428
674
try:
429
675
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
430
except (AttributeError, OSError), error:
431
if (isinstance(error, OSError)
432
and error.errno != errno.ECHILD):
433
raise error
676
except AttributeError:
677
pass
678
except OSError as error:
679
if error.errno != errno.ECHILD:
680
raise
434
681
else:
435
682
if pid:
436
logger.warning(u"Checker was a zombie")
683
logger.warning("Checker was a zombie")
437
684
gobject.source_remove(self.checker_callback_tag)
438
685
self.checker_callback(pid, status,
439
686
self.current_checker_command)
440
687
# Start a new checker if needed
441
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 }
442
693
try:
443
# In case checker_command has exactly one % operator
444
command = self.checker_command % self.host
445
except TypeError:
446
# Escape attributes for the shell
447
escaped_attrs = dict((key,
448
re.escape(unicode(str(val),
449
errors=
450
u'replace')))
451
for key, val in
452
vars(self).iteritems())
453
try:
454
command = self.checker_command % escaped_attrs
455
except TypeError, error:
456
logger.error(u'Could not format string "%s":'
457
u' %s', self.checker_command, error)
458
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
459
699
self.current_checker_command = command
460
700
try:
461
logger.info(u"Starting checker %r for %s",
701
logger.info("Starting checker %r for %s",
462
702
command, self.name)
463
703
# We don't need to redirect stdout and stderr, since
464
704
# in normal mode, that is already done by daemon(),
465
705
# and in debug mode we don't want to. (Stdin is
466
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 })
467
715
self.checker = subprocess.Popen(command,
468
716
close_fds=True,
469
shell=True, cwd=u"/")
470
self.checker_callback_tag = (gobject.child_watch_add
471
(self.checker.pid,
472
self.checker_callback,
473
data=command))
474
# The checker may have completed before the gobject
475
# 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:
476
730
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
477
if pid:
478
gobject.source_remove(self.checker_callback_tag)
479
self.checker_callback(pid, status, command)
480
except OSError, error:
481
logger.error(u"Failed to start subprocess: %s",
482
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)
483
741
# Re-run this periodically if run by gobject.timeout_add
484
742
return True
485
743
488
746
if self.checker_callback_tag:
489
747
gobject.source_remove(self.checker_callback_tag)
490
748
self.checker_callback_tag = None
491
if getattr(self, u"checker", None) is None:
749
if getattr(self, "checker", None) is None:
492
750
return
493
logger.debug(u"Stopping checker for %(name)s", vars(self))
751
logger.debug("Stopping checker for %(name)s", vars(self))
494
752
try:
495
os.kill(self.checker.pid, signal.SIGTERM)
753
self.checker.terminate()
496
754
#time.sleep(0.5)
497
755
#if self.checker.poll() is None:
498
# os.kill(self.checker.pid, signal.SIGKILL)
499
except OSError, error:
756
# self.checker.kill()
757
except OSError as error:
500
758
if error.errno != errno.ESRCH: # No such process
501
759
raise
502
760
self.checker = None
503
761
504
def dbus_service_property(dbus_interface, signature=u"v",
505
access=u"readwrite", byte_arrays=False):
762
763
def dbus_service_property(dbus_interface, signature="v",
764
access="readwrite", byte_arrays=False):
506
765
"""Decorators for marking methods of a DBusObjectWithProperties to
507
766
become properties on the D-Bus.
508
767
515
774
"""
516
775
# Encoding deeply encoded byte arrays is not supported yet by the
517
776
# "Set" method, so we fail early here:
518
if byte_arrays and signature != u"ay":
519
raise ValueError(u"Byte arrays not supported for non-'ay'"
520
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))
521
780
def decorator(func):
522
781
func._dbus_is_property = True
523
782
func._dbus_interface = dbus_interface
524
783
func._dbus_signature = signature
525
784
func._dbus_access = access
526
785
func._dbus_name = func.__name__
527
if func._dbus_name.endswith(u"_dbus_property"):
786
if func._dbus_name.endswith("_dbus_property"):
528
787
func._dbus_name = func._dbus_name[:-14]
529
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
530
826
return func
531
827
return decorator
532
828
534
830
class DBusPropertyException(dbus.exceptions.DBusException):
535
831
"""A base class for D-Bus property-related exceptions
536
832
"""
537
def __unicode__(self):
538
return unicode(str(self))
539
833
pass
540
834
541
835
class DBusPropertyAccessException(DBusPropertyException):
542
836
"""A property's access permissions disallows an operation.
552
846
553
847
class DBusObjectWithProperties(dbus.service.Object):
554
848
"""A D-Bus object with properties.
555
849
556
850
Classes inheriting from this can use the dbus_service_property
557
851
decorator to expose methods as D-Bus properties. It exposes the
558
852
standard Get(), Set(), and GetAll() methods on the D-Bus.
559
853
"""
560
854
561
855
@staticmethod
562
def _is_dbus_property(obj):
563
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)
564
864
565
def _get_all_dbus_properties(self):
865
def _get_all_dbus_things(self, thing):
566
866
"""Returns a generator of (name, attribute) pairs
567
867
"""
568
return ((prop._dbus_name, prop)
569
for name, prop in
570
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)))
571
875
572
876
def _get_dbus_property(self, interface_name, property_name):
573
877
"""Returns a bound method if one exists which is a D-Bus
574
878
property with the specified name and interface.
575
879
"""
576
for name in (property_name,
577
property_name + u"_dbus_property"):
578
prop = getattr(self, name, None)
579
if (prop is None
580
or not self._is_dbus_property(prop)
581
or prop._dbus_name != property_name
582
or (interface_name and prop._dbus_interface
583
and interface_name != prop._dbus_interface)):
584
continue
585
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
586
888
# No such property
587
raise DBusPropertyNotFound(self.dbus_object_path + u":"
588
+ interface_name + u"."
889
raise DBusPropertyNotFound(self.dbus_object_path + ":"
890
+ interface_name + "."
589
891
+ property_name)
590
892
591
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
592
out_signature=u"v")
893
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
894
out_signature="v")
593
895
def Get(self, interface_name, property_name):
594
896
"""Standard D-Bus property Get() method, see D-Bus standard.
595
897
"""
596
898
prop = self._get_dbus_property(interface_name, property_name)
597
if prop._dbus_access == u"write":
899
if prop._dbus_access == "write":
598
900
raise DBusPropertyAccessException(property_name)
599
901
value = prop()
600
if not hasattr(value, u"variant_level"):
902
if not hasattr(value, "variant_level"):
601
903
return value
602
904
return type(value)(value, variant_level=value.variant_level+1)
603
905
604
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
906
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
605
907
def Set(self, interface_name, property_name, value):
606
908
"""Standard D-Bus property Set() method, see D-Bus standard.
607
909
"""
608
910
prop = self._get_dbus_property(interface_name, property_name)
609
if prop._dbus_access == u"read":
911
if prop._dbus_access == "read":
610
912
raise DBusPropertyAccessException(property_name)
611
if prop._dbus_get_args_options[u"byte_arrays"]:
913
if prop._dbus_get_args_options["byte_arrays"]:
612
914
# The byte_arrays option is not supported yet on
613
915
# signatures other than "ay".
614
if prop._dbus_signature != u"ay":
615
raise ValueError
616
value = dbus.ByteArray(''.join(unichr(byte)
617
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))
618
922
prop(value)
619
923
620
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
621
out_signature=u"a{sv}")
924
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
925
out_signature="a{sv}")
622
926
def GetAll(self, interface_name):
623
927
"""Standard D-Bus property GetAll() method, see D-Bus
624
928
standard.
625
929
626
930
Note: Will not include properties with access="write".
627
931
"""
628
all = {}
629
for name, prop in self._get_all_dbus_properties():
932
properties = {}
933
for name, prop in self._get_all_dbus_things("property"):
630
934
if (interface_name
631
935
and interface_name != prop._dbus_interface):
632
936
# Interface non-empty but did not match
633
937
continue
634
938
# Ignore write-only properties
635
if prop._dbus_access == u"write":
939
if prop._dbus_access == "write":
636
940
continue
637
941
value = prop()
638
if not hasattr(value, u"variant_level"):
639
all[name] = value
942
if not hasattr(value, "variant_level"):
943
properties[name] = value
640
944
continue
641
all[name] = type(value)(value, variant_level=
642
value.variant_level+1)
643
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
644
956
645
957
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
646
out_signature=u"s",
958
out_signature="s",
647
959
path_keyword='object_path',
648
960
connection_keyword='connection')
649
961
def Introspect(self, object_path, connection):
650
"""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.
651
965
"""
652
966
xmlstring = dbus.service.Object.Introspect(self, object_path,
653
967
connection)
654
968
try:
655
969
document = xml.dom.minidom.parseString(xmlstring)
656
970
def make_tag(document, name, prop):
657
e = document.createElement(u"property")
658
e.setAttribute(u"name", name)
659
e.setAttribute(u"type", prop._dbus_signature)
660
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)
661
975
return e
662
for if_tag in document.getElementsByTagName(u"interface"):
976
for if_tag in document.getElementsByTagName("interface"):
977
# Add property tags
663
978
for tag in (make_tag(document, name, prop)
664
979
for name, prop
665
in self._get_all_dbus_properties()
980
in self._get_all_dbus_things("property")
666
981
if prop._dbus_interface
667
== if_tag.getAttribute(u"name")):
982
== if_tag.getAttribute("name")):
668
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)
669
1015
# Add the names to the return values for the
670
1016
# "org.freedesktop.DBus.Properties" methods
671
if (if_tag.getAttribute(u"name")
672
== u"org.freedesktop.DBus.Properties"):
673
for cn in if_tag.getElementsByTagName(u"method"):
674
if cn.getAttribute(u"name") == u"Get":
675
for arg in cn.getElementsByTagName(u"arg"):
676
if (arg.getAttribute(u"direction")
677
== u"out"):
678
arg.setAttribute(u"name", u"value")
679
elif cn.getAttribute(u"name") == u"GetAll":
680
for arg in cn.getElementsByTagName(u"arg"):
681
if (arg.getAttribute(u"direction")
682
== u"out"):
683
arg.setAttribute(u"name", u"props")
684
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")
685
1031
document.unlink()
686
1032
except (AttributeError, xml.dom.DOMException,
687
xml.parsers.expat.ExpatError), error:
688
logger.error(u"Failed to override Introspection method",
689
error)
1033
xml.parsers.expat.ExpatError) as error:
1034
logger.error("Failed to override Introspection method",
1035
exc_info=error)
690
1036
return xmlstring
691
1037
692
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"})
693
1218
class ClientDBus(Client, DBusObjectWithProperties):
694
1219
"""A Client class using D-Bus
695
1220
697
1222
dbus_object_path: dbus.ObjectPath
698
1223
bus: dbus.SystemBus()
699
1224
"""
1225
1226
runtime_expansions = (Client.runtime_expansions
1227
+ ("dbus_object_path",))
1228
1229
_interface = "se.recompile.Mandos.Client"
1230
700
1231
# dbus.service.Object doesn't use super(), so we can't either.
701
1232
702
1233
def __init__(self, bus = None, *args, **kwargs):
703
self._approvals_pending = 0
704
1234
self.bus = bus
705
1235
Client.__init__(self, *args, **kwargs)
706
1236
# Only now, when this client is initialized, can it show up on
707
1237
# the D-Bus
1238
client_object_name = str(self.name).translate(
1239
{ord("."): ord("_"),
1240
ord("-"): ord("_")})
708
1241
self.dbus_object_path = (dbus.ObjectPath
709
(u"/clients/"
710
+ self.name.replace(u".", u"_")))
1242
("/clients/" + client_object_name))
711
1243
DBusObjectWithProperties.__init__(self, self.bus,
712
1244
self.dbus_object_path)
713
714
def _get_approvals_pending(self):
715
return self._approvals_pending
716
def _set_approvals_pending(self, value):
717
old_value = self._approvals_pending
718
self._approvals_pending = value
719
bval = bool(value)
720
if (hasattr(self, "dbus_object_path")
721
and bval is not bool(old_value)):
722
dbus_bool = dbus.Boolean(bval, variant_level=1)
723
self.PropertyChanged(dbus.String(u"approved_pending"),
724
dbus_bool)
725
726
approvals_pending = property(_get_approvals_pending,
727
_set_approvals_pending)
728
del _get_approvals_pending, _set_approvals_pending
729
730
@staticmethod
731
def _datetime_to_dbus(dt, variant_level=0):
732
"""Convert a UTC datetime.datetime() to a D-Bus type."""
733
return dbus.String(dt.isoformat(),
734
variant_level=variant_level)
735
736
def enable(self):
737
oldstate = getattr(self, u"enabled", False)
738
r = Client.enable(self)
739
if oldstate != self.enabled:
740
# Emit D-Bus signals
741
self.PropertyChanged(dbus.String(u"enabled"),
742
dbus.Boolean(True, variant_level=1))
743
self.PropertyChanged(
744
dbus.String(u"last_enabled"),
745
self._datetime_to_dbus(self.last_enabled,
746
variant_level=1))
747
return r
748
749
def disable(self, quiet = False):
750
oldstate = getattr(self, u"enabled", False)
751
r = Client.disable(self, quiet=quiet)
752
if not quiet and oldstate != self.enabled:
753
# Emit D-Bus signal
754
self.PropertyChanged(dbus.String(u"enabled"),
755
dbus.Boolean(False, variant_level=1))
756
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
757
1328
758
1329
def __del__(self, *args, **kwargs):
759
1330
try:
760
1331
self.remove_from_connection()
761
1332
except LookupError:
762
1333
pass
763
if hasattr(DBusObjectWithProperties, u"__del__"):
1334
if hasattr(DBusObjectWithProperties, "__del__"):
764
1335
DBusObjectWithProperties.__del__(self, *args, **kwargs)
765
1336
Client.__del__(self, *args, **kwargs)
766
1337
768
1339
*args, **kwargs):
769
1340
self.checker_callback_tag = None
770
1341
self.checker = None
771
# Emit D-Bus signal
772
self.PropertyChanged(dbus.String(u"checker_running"),
773
dbus.Boolean(False, variant_level=1))
774
1342
if os.WIFEXITED(condition):
775
1343
exitstatus = os.WEXITSTATUS(condition)
776
1344
# Emit D-Bus signal
786
1354
return Client.checker_callback(self, pid, condition, command,
787
1355
*args, **kwargs)
788
1356
789
def checked_ok(self, *args, **kwargs):
790
r = Client.checked_ok(self, *args, **kwargs)
791
# Emit D-Bus signal
792
self.PropertyChanged(
793
dbus.String(u"last_checked_ok"),
794
(self._datetime_to_dbus(self.last_checked_ok,
795
variant_level=1)))
796
return r
797
798
1357
def start_checker(self, *args, **kwargs):
799
old_checker = self.checker
800
if self.checker is not None:
801
old_checker_pid = self.checker.pid
802
else:
803
old_checker_pid = None
1358
old_checker_pid = getattr(self.checker, "pid", None)
804
1359
r = Client.start_checker(self, *args, **kwargs)
805
1360
# Only if new checker process was started
806
1361
if (self.checker is not None
807
1362
and old_checker_pid != self.checker.pid):
808
1363
# Emit D-Bus signal
809
1364
self.CheckerStarted(self.current_checker_command)
810
self.PropertyChanged(
811
dbus.String(u"checker_running"),
812
dbus.Boolean(True, variant_level=1))
813
1365
return r
814
1366
815
def stop_checker(self, *args, **kwargs):
816
old_checker = getattr(self, u"checker", None)
817
r = Client.stop_checker(self, *args, **kwargs)
818
if (old_checker is not None
819
and getattr(self, u"checker", None) is None):
820
self.PropertyChanged(dbus.String(u"checker_running"),
821
dbus.Boolean(False, variant_level=1))
822
return r
823
824
1367
def _reset_approved(self):
825
self._approved = None
1368
self.approved = None
826
1369
return False
827
1370
828
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)
829
1375
self.send_changedstate()
830
self._approved = value
831
gobject.timeout_add(self._timedelta_to_milliseconds(self.approved_duration),
832
self._reset_approved)
833
834
1376
835
1377
## D-Bus methods, signals & properties
836
_interface = u"se.bsnet.fukt.Mandos.Client"
1378
1379
## Interfaces
837
1380
838
1381
## Signals
839
1382
840
1383
# CheckerCompleted - signal
841
@dbus.service.signal(_interface, signature=u"nxs")
1384
@dbus.service.signal(_interface, signature="nxs")
842
1385
def CheckerCompleted(self, exitcode, waitstatus, command):
843
1386
"D-Bus signal"
844
1387
pass
845
1388
846
1389
# CheckerStarted - signal
847
@dbus.service.signal(_interface, signature=u"s")
1390
@dbus.service.signal(_interface, signature="s")
848
1391
def CheckerStarted(self, command):
849
1392
"D-Bus signal"
850
1393
pass
851
1394
852
1395
# PropertyChanged - signal
853
@dbus.service.signal(_interface, signature=u"sv")
1396
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1397
@dbus.service.signal(_interface, signature="sv")
854
1398
def PropertyChanged(self, property, value):
855
1399
"D-Bus signal"
856
1400
pass
865
1409
pass
866
1410
867
1411
# Rejected - signal
868
@dbus.service.signal(_interface, signature=u"s")
1412
@dbus.service.signal(_interface, signature="s")
869
1413
def Rejected(self, reason):
870
1414
"D-Bus signal"
871
1415
pass
872
1416
873
1417
# NeedApproval - signal
874
@dbus.service.signal(_interface, signature=u"db")
1418
@dbus.service.signal(_interface, signature="tb")
875
1419
def NeedApproval(self, timeout, default):
876
1420
"D-Bus signal"
877
pass
1421
return self.need_approval()
878
1422
879
1423
## Methods
880
1424
881
1425
# Approve - method
882
@dbus.service.method(_interface, in_signature=u"b")
1426
@dbus.service.method(_interface, in_signature="b")
883
1427
def Approve(self, value):
884
1428
self.approve(value)
885
1429
886
1430
# CheckedOK - method
887
1431
@dbus.service.method(_interface)
888
1432
def CheckedOK(self):
889
return self.checked_ok()
1433
self.checked_ok()
890
1434
891
1435
# Enable - method
892
1436
@dbus.service.method(_interface)
913
1457
914
1458
## Properties
915
1459
916
# approved_pending - property
917
@dbus_service_property(_interface, signature=u"b", access=u"read")
918
def approved_pending_dbus_property(self):
1460
# ApprovalPending - property
1461
@dbus_service_property(_interface, signature="b", access="read")
1462
def ApprovalPending_dbus_property(self):
919
1463
return dbus.Boolean(bool(self.approvals_pending))
920
1464
921
# approved_by_default - property
922
@dbus_service_property(_interface, signature=u"b",
923
access=u"readwrite")
924
def approved_by_default_dbus_property(self):
925
return dbus.Boolean(self.approved_by_default)
926
927
# approved_delay - property
928
@dbus_service_property(_interface, signature=u"t",
929
access=u"readwrite")
930
def approved_delay_dbus_property(self):
931
return dbus.UInt64(self.approved_delay_milliseconds())
932
933
# approved_duration - property
934
@dbus_service_property(_interface, signature=u"t",
935
access=u"readwrite")
936
def approved_duration_dbus_property(self):
937
return dbus.UInt64(self._timedelta_to_milliseconds(
938
self.approved_duration))
939
940
# name - property
941
@dbus_service_property(_interface, signature=u"s", access=u"read")
942
def name_dbus_property(self):
1465
# ApprovedByDefault - property
1466
@dbus_service_property(_interface, signature="b",
1467
access="readwrite")
1468
def ApprovedByDefault_dbus_property(self, value=None):
1469
if value is None: # get
1470
return dbus.Boolean(self.approved_by_default)
1471
self.approved_by_default = bool(value)
1472
1473
# ApprovalDelay - property
1474
@dbus_service_property(_interface, signature="t",
1475
access="readwrite")
1476
def ApprovalDelay_dbus_property(self, value=None):
1477
if value is None: # get
1478
return dbus.UInt64(self.approval_delay.total_seconds()
1479
* 1000)
1480
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1481
1482
# ApprovalDuration - property
1483
@dbus_service_property(_interface, signature="t",
1484
access="readwrite")
1485
def ApprovalDuration_dbus_property(self, value=None):
1486
if value is None: # get
1487
return dbus.UInt64(self.approval_duration.total_seconds()
1488
* 1000)
1489
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1490
1491
# Name - property
1492
@dbus_service_property(_interface, signature="s", access="read")
1493
def Name_dbus_property(self):
943
1494
return dbus.String(self.name)
944
1495
945
# fingerprint - property
946
@dbus_service_property(_interface, signature=u"s", access=u"read")
947
def fingerprint_dbus_property(self):
1496
# Fingerprint - property
1497
@dbus_service_property(_interface, signature="s", access="read")
1498
def Fingerprint_dbus_property(self):
948
1499
return dbus.String(self.fingerprint)
949
1500
950
# host - property
951
@dbus_service_property(_interface, signature=u"s",
952
access=u"readwrite")
953
def host_dbus_property(self, value=None):
1501
# Host - property
1502
@dbus_service_property(_interface, signature="s",
1503
access="readwrite")
1504
def Host_dbus_property(self, value=None):
954
1505
if value is None: # get
955
1506
return dbus.String(self.host)
956
self.host = value
957
# Emit D-Bus signal
958
self.PropertyChanged(dbus.String(u"host"),
959
dbus.String(value, variant_level=1))
960
961
# created - property
962
@dbus_service_property(_interface, signature=u"s", access=u"read")
963
def created_dbus_property(self):
964
return dbus.String(self._datetime_to_dbus(self.created))
965
966
# last_enabled - property
967
@dbus_service_property(_interface, signature=u"s", access=u"read")
968
def last_enabled_dbus_property(self):
969
if self.last_enabled is None:
970
return dbus.String(u"")
971
return dbus.String(self._datetime_to_dbus(self.last_enabled))
972
973
# enabled - property
974
@dbus_service_property(_interface, signature=u"b",
975
access=u"readwrite")
976
def enabled_dbus_property(self, value=None):
1507
self.host = str(value)
1508
1509
# Created - property
1510
@dbus_service_property(_interface, signature="s", access="read")
1511
def Created_dbus_property(self):
1512
return datetime_to_dbus(self.created)
1513
1514
# LastEnabled - property
1515
@dbus_service_property(_interface, signature="s", access="read")
1516
def LastEnabled_dbus_property(self):
1517
return datetime_to_dbus(self.last_enabled)
1518
1519
# Enabled - property
1520
@dbus_service_property(_interface, signature="b",
1521
access="readwrite")
1522
def Enabled_dbus_property(self, value=None):
977
1523
if value is None: # get
978
1524
return dbus.Boolean(self.enabled)
979
1525
if value:
981
1527
else:
982
1528
self.disable()
983
1529
984
# last_checked_ok - property
985
@dbus_service_property(_interface, signature=u"s",
986
access=u"readwrite")
987
def last_checked_ok_dbus_property(self, value=None):
1530
# LastCheckedOK - property
1531
@dbus_service_property(_interface, signature="s",
1532
access="readwrite")
1533
def LastCheckedOK_dbus_property(self, value=None):
988
1534
if value is not None:
989
1535
self.checked_ok()
990
1536
return
991
if self.last_checked_ok is None:
992
return dbus.String(u"")
993
return dbus.String(self._datetime_to_dbus(self
994
.last_checked_ok))
995
996
# timeout - property
997
@dbus_service_property(_interface, signature=u"t",
998
access=u"readwrite")
999
def timeout_dbus_property(self, value=None):
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)
1554
1555
# Timeout - property
1556
@dbus_service_property(_interface, signature="t",
1557
access="readwrite")
1558
def Timeout_dbus_property(self, value=None):
1000
1559
if value is None: # get
1001
return dbus.UInt64(self.timeout_milliseconds())
1560
return dbus.UInt64(self.timeout.total_seconds() * 1000)
1561
old_timeout = self.timeout
1002
1562
self.timeout = datetime.timedelta(0, 0, 0, value)
1003
# Emit D-Bus signal
1004
self.PropertyChanged(dbus.String(u"timeout"),
1005
dbus.UInt64(value, variant_level=1))
1006
if getattr(self, u"disable_initiator_tag", None) is None:
1007
return
1008
# Reschedule timeout
1009
gobject.source_remove(self.disable_initiator_tag)
1010
self.disable_initiator_tag = None
1011
time_to_die = (self.
1012
_timedelta_to_milliseconds((self
1013
.last_checked_ok
1014
+ self.timeout)
1015
- datetime.datetime
1016
.utcnow()))
1017
if time_to_die <= 0:
1018
# The timeout has passed
1019
self.disable()
1020
else:
1021
self.disable_initiator_tag = (gobject.timeout_add
1022
(time_to_die, self.disable))
1023
1024
# interval - property
1025
@dbus_service_property(_interface, signature=u"t",
1026
access=u"readwrite")
1027
def interval_dbus_property(self, value=None):
1028
if value is None: # get
1029
return dbus.UInt64(self.interval_milliseconds())
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)
1588
1589
# Interval - property
1590
@dbus_service_property(_interface, signature="t",
1591
access="readwrite")
1592
def Interval_dbus_property(self, value=None):
1593
if value is None: # get
1594
return dbus.UInt64(self.interval.total_seconds() * 1000)
1030
1595
self.interval = datetime.timedelta(0, 0, 0, value)
1031
# Emit D-Bus signal
1032
self.PropertyChanged(dbus.String(u"interval"),
1033
dbus.UInt64(value, variant_level=1))
1034
if getattr(self, u"checker_initiator_tag", None) is None:
1596
if getattr(self, "checker_initiator_tag", None) is None:
1035
1597
return
1036
# Reschedule checker run
1037
gobject.source_remove(self.checker_initiator_tag)
1038
self.checker_initiator_tag = (gobject.timeout_add
1039
(value, self.start_checker))
1040
self.start_checker() # Start one now, too
1041
1042
# checker - property
1043
@dbus_service_property(_interface, signature=u"s",
1044
access=u"readwrite")
1045
def checker_dbus_property(self, value=None):
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
1605
# Checker - property
1606
@dbus_service_property(_interface, signature="s",
1607
access="readwrite")
1608
def Checker_dbus_property(self, value=None):
1046
1609
if value is None: # get
1047
1610
return dbus.String(self.checker_command)
1048
self.checker_command = value
1049
# Emit D-Bus signal
1050
self.PropertyChanged(dbus.String(u"checker"),
1051
dbus.String(self.checker_command,
1052
variant_level=1))
1611
self.checker_command = str(value)
1053
1612
1054
# checker_running - property
1055
@dbus_service_property(_interface, signature=u"b",
1056
access=u"readwrite")
1057
def checker_running_dbus_property(self, value=None):
1613
# CheckerRunning - property
1614
@dbus_service_property(_interface, signature="b",
1615
access="readwrite")
1616
def CheckerRunning_dbus_property(self, value=None):
1058
1617
if value is None: # get
1059
1618
return dbus.Boolean(self.checker is not None)
1060
1619
if value:
1062
1621
else:
1063
1622
self.stop_checker()
1064
1623
1065
# object_path - property
1066
@dbus_service_property(_interface, signature=u"o", access=u"read")
1067
def object_path_dbus_property(self):
1624
# ObjectPath - property
1625
@dbus_service_property(_interface, signature="o", access="read")
1626
def ObjectPath_dbus_property(self):
1068
1627
return self.dbus_object_path # is already a dbus.ObjectPath
1069
1628
1070
# secret = property
1071
@dbus_service_property(_interface, signature=u"ay",
1072
access=u"write", byte_arrays=True)
1073
def secret_dbus_property(self, value):
1074
self.secret = str(value)
1629
# Secret = property
1630
@dbus_service_property(_interface, signature="ay",
1631
access="write", byte_arrays=True)
1632
def Secret_dbus_property(self, value):
1633
self.secret = bytes(value)
1075
1634
1076
1635
del _interface
1077
1636
1082
1641
self._pipe.send(('init', fpr, address))
1083
1642
if not self._pipe.recv():
1084
1643
raise KeyError()
1085
1644
1086
1645
def __getattribute__(self, name):
1087
if(name == '_pipe'):
1646
if name == '_pipe':
1088
1647
return super(ProxyClient, self).__getattribute__(name)
1089
1648
self._pipe.send(('getattr', name))
1090
1649
data = self._pipe.recv()
1095
1654
self._pipe.send(('funcall', name, args, kwargs))
1096
1655
return self._pipe.recv()[1]
1097
1656
return func
1098
1657
1099
1658
def __setattr__(self, name, value):
1100
if(name == '_pipe'):
1659
if name == '_pipe':
1101
1660
return super(ProxyClient, self).__setattr__(name, value)
1102
1661
self._pipe.send(('setattr', name, value))
1103
1662
1110
1669
1111
1670
def handle(self):
1112
1671
with contextlib.closing(self.server.child_pipe) as child_pipe:
1113
logger.info(u"TCP connection from: %s",
1114
unicode(self.client_address))
1115
logger.debug(u"Pipe FD: %d",
1672
logger.info("TCP connection from: %s",
1673
str(self.client_address))
1674
logger.debug("Pipe FD: %d",
1116
1675
self.server.child_pipe.fileno())
1117
1676
1118
1677
session = (gnutls.connection
1119
1678
.ClientSession(self.request,
1120
1679
gnutls.connection
1121
1680
.X509Credentials()))
1122
1681
1123
1682
# Note: gnutls.connection.X509Credentials is really a
1124
1683
# generic GnuTLS certificate credentials object so long as
1125
1684
# no X.509 keys are added to it. Therefore, we can use it
1126
1685
# here despite using OpenPGP certificates.
1127
1128
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
1129
# u"+AES-256-CBC", u"+SHA1",
1130
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
1131
# u"+DHE-DSS"))
1686
1687
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1688
# "+AES-256-CBC", "+SHA1",
1689
# "+COMP-NULL", "+CTYPE-OPENPGP",
1690
# "+DHE-DSS"))
1132
1691
# Use a fallback default, since this MUST be set.
1133
1692
priority = self.server.gnutls_priority
1134
1693
if priority is None:
1135
priority = u"NORMAL"
1694
priority = "NORMAL"
1136
1695
(gnutls.library.functions
1137
1696
.gnutls_priority_set_direct(session._c_object,
1138
1697
priority, None))
1139
1698
1140
1699
# Start communication using the Mandos protocol
1141
1700
# Get protocol number
1142
1701
line = self.request.makefile().readline()
1143
logger.debug(u"Protocol version: %r", line)
1702
logger.debug("Protocol version: %r", line)
1144
1703
try:
1145
1704
if int(line.strip().split()[0]) > 1:
1146
raise RuntimeError
1147
except (ValueError, IndexError, RuntimeError), error:
1148
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)
1149
1708
return
1150
1709
1151
1710
# Start GnuTLS connection
1152
1711
try:
1153
1712
session.handshake()
1154
except gnutls.errors.GNUTLSError, error:
1155
logger.warning(u"Handshake failed: %s", error)
1713
except gnutls.errors.GNUTLSError as error:
1714
logger.warning("Handshake failed: %s", error)
1156
1715
# Do not run session.bye() here: the session is not
1157
1716
# established. Just abandon the request.
1158
1717
return
1159
logger.debug(u"Handshake succeeded")
1160
1718
logger.debug("Handshake succeeded")
1719
1161
1720
approval_required = False
1162
1721
try:
1163
1722
try:
1164
1723
fpr = self.fingerprint(self.peer_certificate
1165
1724
(session))
1166
except (TypeError, gnutls.errors.GNUTLSError), error:
1167
logger.warning(u"Bad certificate: %s", error)
1725
except (TypeError,
1726
gnutls.errors.GNUTLSError) as error:
1727
logger.warning("Bad certificate: %s", error)
1168
1728
return
1169
logger.debug(u"Fingerprint: %s", fpr)
1170
1729
logger.debug("Fingerprint: %s", fpr)
1730
1171
1731
try:
1172
1732
client = ProxyClient(child_pipe, fpr,
1173
1733
self.client_address)
1174
1734
except KeyError:
1175
1735
return
1176
1736
1177
if client.approved_delay:
1178
delay = client.approved_delay
1737
if client.approval_delay:
1738
delay = client.approval_delay
1179
1739
client.approvals_pending += 1
1180
1740
approval_required = True
1181
1741
1182
1742
while True:
1183
1743
if not client.enabled:
1184
logger.warning(u"Client %s is disabled",
1744
logger.info("Client %s is disabled",
1185
1745
client.name)
1186
1746
if self.server.use_dbus:
1187
1747
# Emit D-Bus signal
1188
client.Rejected("Disabled")
1748
client.Rejected("Disabled")
1189
1749
return
1190
1750
1191
if client._approved or not client.approved_delay:
1751
if client.approved or not client.approval_delay:
1192
1752
#We are approved or approval is disabled
1193
1753
break
1194
elif client._approved is None:
1195
logger.info(u"Client %s need approval",
1754
elif client.approved is None:
1755
logger.info("Client %s needs approval",
1196
1756
client.name)
1197
1757
if self.server.use_dbus:
1198
1758
# Emit D-Bus signal
1199
1759
client.NeedApproval(
1200
client.approved_delay_milliseconds(),
1201
client.approved_by_default)
1760
client.approval_delay.total_seconds()
1761
* 1000, client.approved_by_default)
1202
1762
else:
1203
logger.warning(u"Client %s was not approved",
1763
logger.warning("Client %s was not approved",
1204
1764
client.name)
1205
1765
if self.server.use_dbus:
1206
1766
# Emit D-Bus signal
1207
client.Rejected("Disapproved")
1767
client.Rejected("Denied")
1208
1768
return
1209
1769
1210
1770
#wait until timeout or approved
1211
#x = float(client._timedelta_to_milliseconds(delay))
1212
1771
time = datetime.datetime.now()
1213
1772
client.changedstate.acquire()
1214
client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))
1773
client.changedstate.wait(delay.total_seconds())
1215
1774
client.changedstate.release()
1216
1775
time2 = datetime.datetime.now()
1217
1776
if (time2 - time) >= delay:
1221
1780
client.name)
1222
1781
if self.server.use_dbus:
1223
1782
# Emit D-Bus signal
1224
client.Rejected("Time out")
1783
client.Rejected("Approval timed out")
1225
1784
return
1226
1785
else:
1227
1786
break
1232
1791
while sent_size < len(client.secret):
1233
1792
try:
1234
1793
sent = session.send(client.secret[sent_size:])
1235
except (gnutls.errors.GNUTLSError), error:
1236
logger.warning("gnutls send failed")
1794
except gnutls.errors.GNUTLSError as error:
1795
logger.warning("gnutls send failed",
1796
exc_info=error)
1237
1797
return
1238
logger.debug(u"Sent: %d, remaining: %d",
1798
logger.debug("Sent: %d, remaining: %d",
1239
1799
sent, len(client.secret)
1240
1800
- (sent_size + sent))
1241
1801
sent_size += sent
1242
1243
logger.info(u"Sending secret to %s", client.name)
1244
# bump the timeout as if seen
1245
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)
1246
1806
if self.server.use_dbus:
1247
1807
# Emit D-Bus signal
1248
1808
client.GotSecret()
1252
1812
client.approvals_pending -= 1
1253
1813
try:
1254
1814
session.bye()
1255
except (gnutls.errors.GNUTLSError), error:
1256
logger.warning("gnutls bye failed")
1815
except gnutls.errors.GNUTLSError as error:
1816
logger.warning("GnuTLS bye failed",
1817
exc_info=error)
1257
1818
1258
1819
@staticmethod
1259
1820
def peer_certificate(session):
1269
1830
.gnutls_certificate_get_peers
1270
1831
(session._c_object, ctypes.byref(list_size)))
1271
1832
if not bool(cert_list) and list_size.value != 0:
1272
raise gnutls.errors.GNUTLSError(u"error getting peer"
1273
u" certificate")
1833
raise gnutls.errors.GNUTLSError("error getting peer"
1834
" certificate")
1274
1835
if list_size.value == 0:
1275
1836
return None
1276
1837
cert = cert_list[0]
1302
1863
if crtverify.value != 0:
1303
1864
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1304
1865
raise (gnutls.errors.CertificateSecurityError
1305
(u"Verify failed"))
1866
("Verify failed"))
1306
1867
# New buffer for the fingerprint
1307
1868
buf = ctypes.create_string_buffer(20)
1308
1869
buf_len = ctypes.c_size_t()
1315
1876
# Convert the buffer to a Python bytestring
1316
1877
fpr = ctypes.string_at(buf, buf_len.value)
1317
1878
# Convert the bytestring to hexadecimal notation
1318
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
1879
hex_fpr = binascii.hexlify(fpr).upper()
1319
1880
return hex_fpr
1320
1881
1321
1882
1324
1885
def sub_process_main(self, request, address):
1325
1886
try:
1326
1887
self.finish_request(request, address)
1327
except:
1888
except Exception:
1328
1889
self.handle_error(request, address)
1329
1890
self.close_request(request)
1330
1891
1331
1892
def process_request(self, request, address):
1332
1893
"""Start a new process to process the request."""
1333
multiprocessing.Process(target = self.sub_process_main,
1334
args = (request, address)).start()
1894
proc = multiprocessing.Process(target = self.sub_process_main,
1895
args = (request, address))
1896
proc.start()
1897
return proc
1898
1335
1899
1336
1900
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1337
1901
""" adds a pipe to the MixIn """
1341
1905
This function creates a new pipe in self.pipe
1342
1906
"""
1343
1907
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1344
1345
super(MultiprocessingMixInWithPipe,
1346
self).process_request(request, client_address)
1908
1909
proc = MultiprocessingMixIn.process_request(self, request,
1910
client_address)
1347
1911
self.child_pipe.close()
1348
self.add_pipe(parent_pipe)
1349
1350
def add_pipe(self, parent_pipe):
1912
self.add_pipe(parent_pipe, proc)
1913
1914
def add_pipe(self, parent_pipe, proc):
1351
1915
"""Dummy function; override as necessary"""
1352
pass
1916
raise NotImplementedError()
1917
1353
1918
1354
1919
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1355
1920
socketserver.TCPServer, object):
1361
1926
use_ipv6: Boolean; to use IPv6 or not
1362
1927
"""
1363
1928
def __init__(self, server_address, RequestHandlerClass,
1364
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
"""
1365
1933
self.interface = interface
1366
1934
if use_ipv6:
1367
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.
1368
1962
socketserver.TCPServer.__init__(self, server_address,
1369
1963
RequestHandlerClass)
1964
1370
1965
def server_bind(self):
1371
1966
"""This overrides the normal server_bind() function
1372
1967
to bind to an interface if one was specified, and also NOT to
1373
1968
bind to an address or port if they were not specified."""
1374
1969
if self.interface is not None:
1375
1970
if SO_BINDTODEVICE is None:
1376
logger.error(u"SO_BINDTODEVICE does not exist;"
1377
u" cannot bind to interface %s",
1971
logger.error("SO_BINDTODEVICE does not exist;"
1972
" cannot bind to interface %s",
1378
1973
self.interface)
1379
1974
else:
1380
1975
try:
1381
1976
self.socket.setsockopt(socket.SOL_SOCKET,
1382
1977
SO_BINDTODEVICE,
1383
str(self.interface
1384
+ u'\0'))
1385
except socket.error, error:
1386
if error[0] == errno.EPERM:
1387
logger.error(u"No permission to"
1388
u" bind to interface %s",
1389
self.interface)
1390
elif error[0] == errno.ENOPROTOOPT:
1391
logger.error(u"SO_BINDTODEVICE not available;"
1392
u" cannot bind to interface %s",
1393
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)
1394
1991
else:
1395
1992
raise
1396
1993
# Only bind(2) the socket if we really need to.
1397
1994
if self.server_address[0] or self.server_address[1]:
1398
1995
if not self.server_address[0]:
1399
1996
if self.address_family == socket.AF_INET6:
1400
any_address = u"::" # in6addr_any
1997
any_address = "::" # in6addr_any
1401
1998
else:
1402
any_address = socket.INADDR_ANY
1999
any_address = "0.0.0.0" # INADDR_ANY
1403
2000
self.server_address = (any_address,
1404
2001
self.server_address[1])
1405
2002
elif not self.server_address[1]:
1426
2023
"""
1427
2024
def __init__(self, server_address, RequestHandlerClass,
1428
2025
interface=None, use_ipv6=True, clients=None,
1429
gnutls_priority=None, use_dbus=True):
2026
gnutls_priority=None, use_dbus=True, socketfd=None):
1430
2027
self.enabled = False
1431
2028
self.clients = clients
1432
2029
if self.clients is None:
1433
self.clients = set()
2030
self.clients = {}
1434
2031
self.use_dbus = use_dbus
1435
2032
self.gnutls_priority = gnutls_priority
1436
2033
IPv6_TCPServer.__init__(self, server_address,
1437
2034
RequestHandlerClass,
1438
2035
interface = interface,
1439
use_ipv6 = use_ipv6)
2036
use_ipv6 = use_ipv6,
2037
socketfd = socketfd)
1440
2038
def server_activate(self):
1441
2039
if self.enabled:
1442
2040
return socketserver.TCPServer.server_activate(self)
2041
1443
2042
def enable(self):
1444
2043
self.enabled = True
1445
def add_pipe(self, parent_pipe):
2044
2045
def add_pipe(self, parent_pipe, proc):
1446
2046
# Call "handle_ipc" for both data and EOF events
1447
2047
gobject.io_add_watch(parent_pipe.fileno(),
1448
2048
gobject.IO_IN | gobject.IO_HUP,
1449
2049
functools.partial(self.handle_ipc,
1450
parent_pipe = parent_pipe))
1451
2050
parent_pipe =
2051
parent_pipe,
2052
proc = proc))
2053
1452
2054
def handle_ipc(self, source, condition, parent_pipe=None,
1453
client_object=None):
1454
condition_names = {
1455
gobject.IO_IN: u"IN", # There is data to read.
1456
gobject.IO_OUT: u"OUT", # Data can be written (without
1457
# blocking).
1458
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1459
gobject.IO_ERR: u"ERR", # Error condition.
1460
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1461
# broken, usually for pipes and
1462
# sockets).
1463
}
1464
conditions_string = ' | '.join(name
1465
for cond, name in
1466
condition_names.iteritems()
1467
if cond & condition)
1468
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1469
conditions_string)
1470
1471
# error or the other end of multiprocessing.Pipe has closed
1472
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()
1473
2060
return False
1474
2061
1475
2062
# Read a request from the child
1476
2063
request = parent_pipe.recv()
1477
logger.debug(u"IPC request: %s", repr(request))
1478
2064
command = request[0]
1479
2065
1480
2066
if command == 'init':
1481
2067
fpr = request[1]
1482
2068
address = request[2]
1483
2069
1484
for c in self.clients:
2070
for c in self.clients.itervalues():
1485
2071
if c.fingerprint == fpr:
1486
2072
client = c
1487
2073
break
1488
2074
else:
1489
logger.warning(u"Client not found for fingerprint: %s, ad"
1490
u"dress: %s", fpr, address)
2075
logger.info("Client not found for fingerprint: %s, ad"
2076
"dress: %s", fpr, address)
1491
2077
if self.use_dbus:
1492
2078
# Emit D-Bus signal
1493
mandos_dbus_service.ClientNotFound(fpr, address)
2079
mandos_dbus_service.ClientNotFound(fpr,
2080
address[0])
1494
2081
parent_pipe.send(False)
1495
2082
return False
1496
2083
1497
2084
gobject.io_add_watch(parent_pipe.fileno(),
1498
2085
gobject.IO_IN | gobject.IO_HUP,
1499
2086
functools.partial(self.handle_ipc,
1500
parent_pipe = parent_pipe,
1501
client_object = client))
2087
parent_pipe =
2088
parent_pipe,
2089
proc = proc,
2090
client_object =
2091
client))
1502
2092
parent_pipe.send(True)
1503
# 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
1504
2095
return False
1505
2096
if command == 'funcall':
1506
2097
funcname = request[1]
1507
2098
args = request[2]
1508
2099
kwargs = request[3]
1509
2100
1510
parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))
1511
2101
parent_pipe.send(('data', getattr(client_object,
2102
funcname)(*args,
2103
**kwargs)))
2104
1512
2105
if command == 'getattr':
1513
2106
attrname = request[1]
1514
2107
if callable(client_object.__getattribute__(attrname)):
1515
2108
parent_pipe.send(('function',))
1516
2109
else:
1517
parent_pipe.send(('data', client_object.__getattribute__(attrname)))
2110
parent_pipe.send(('data', client_object
2111
.__getattribute__(attrname)))
1518
2112
1519
2113
if command == 'setattr':
1520
2114
attrname = request[1]
1521
2115
value = request[2]
1522
2116
setattr(client_object, attrname, value)
1523
2117
1524
2118
return True
1525
2119
1526
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
1527
2220
def string_to_delta(interval):
1528
2221
"""Parse a string and return a datetime.timedelta
1529
2222
1530
>>> string_to_delta(u'7d')
2223
>>> string_to_delta('7d')
1531
2224
datetime.timedelta(7)
1532
>>> string_to_delta(u'60s')
2225
>>> string_to_delta('60s')
1533
2226
datetime.timedelta(0, 60)
1534
>>> string_to_delta(u'60m')
2227
>>> string_to_delta('60m')
1535
2228
datetime.timedelta(0, 3600)
1536
>>> string_to_delta(u'24h')
2229
>>> string_to_delta('24h')
1537
2230
datetime.timedelta(1)
1538
>>> string_to_delta(u'1w')
2231
>>> string_to_delta('1w')
1539
2232
datetime.timedelta(7)
1540
>>> string_to_delta(u'5m 30s')
2233
>>> string_to_delta('5m 30s')
1541
2234
datetime.timedelta(0, 330)
1542
2235
"""
2236
2237
try:
2238
return rfc3339_duration_to_delta(interval)
2239
except ValueError:
2240
pass
2241
1543
2242
timevalue = datetime.timedelta(0)
1544
2243
for s in interval.split():
1545
2244
try:
1546
suffix = unicode(s[-1])
2245
suffix = s[-1]
1547
2246
value = int(s[:-1])
1548
if suffix == u"d":
2247
if suffix == "d":
1549
2248
delta = datetime.timedelta(value)
1550
elif suffix == u"s":
2249
elif suffix == "s":
1551
2250
delta = datetime.timedelta(0, value)
1552
elif suffix == u"m":
2251
elif suffix == "m":
1553
2252
delta = datetime.timedelta(0, 0, 0, 0, value)
1554
elif suffix == u"h":
2253
elif suffix == "h":
1555
2254
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1556
elif suffix == u"w":
2255
elif suffix == "w":
1557
2256
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1558
2257
else:
1559
raise ValueError(u"Unknown suffix %r" % suffix)
1560
except (ValueError, IndexError), e:
1561
raise ValueError(e.message)
2258
raise ValueError("Unknown suffix {!r}"
2259
.format(suffix))
2260
except IndexError as e:
2261
raise ValueError(*(e.args))
1562
2262
timevalue += delta
1563
2263
return timevalue
1564
2264
1565
2265
1566
def if_nametoindex(interface):
1567
"""Call the C function if_nametoindex(), or equivalent
1568
1569
Note: This function cannot accept a unicode string."""
1570
global if_nametoindex
1571
try:
1572
if_nametoindex = (ctypes.cdll.LoadLibrary
1573
(ctypes.util.find_library(u"c"))
1574
.if_nametoindex)
1575
except (OSError, AttributeError):
1576
logger.warning(u"Doing if_nametoindex the hard way")
1577
def if_nametoindex(interface):
1578
"Get an interface index the hard way, i.e. using fcntl()"
1579
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1580
with contextlib.closing(socket.socket()) as s:
1581
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1582
struct.pack(str(u"16s16x"),
1583
interface))
1584
interface_index = struct.unpack(str(u"I"),
1585
ifreq[16:20])[0]
1586
return interface_index
1587
return if_nametoindex(interface)
1588
1589
1590
2266
def daemon(nochdir = False, noclose = False):
1591
2267
"""See daemon(3). Standard BSD Unix function.
1592
2268
1595
2271
sys.exit()
1596
2272
os.setsid()
1597
2273
if not nochdir:
1598
os.chdir(u"/")
2274
os.chdir("/")
1599
2275
if os.fork():
1600
2276
sys.exit()
1601
2277
if not noclose:
1602
2278
# Close all standard open file descriptors
1603
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2279
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1604
2280
if not stat.S_ISCHR(os.fstat(null).st_mode):
1605
raise OSError(errno.ENODEV,
1606
u"%s not a character device"
1607
% os.path.devnull)
2281
raise OSError(errno.ENODEV, "{} not a character device"
2282
.format(os.devnull))
1608
2283
os.dup2(null, sys.stdin.fileno())
1609
2284
os.dup2(null, sys.stdout.fileno())
1610
2285
os.dup2(null, sys.stderr.fileno())
1617
2292
##################################################################
1618
2293
# Parsing of options, both command line and config file
1619
2294
1620
parser = optparse.OptionParser(version = "%%prog %s" % version)
1621
parser.add_option("-i", u"--interface", type=u"string",
1622
metavar="IF", help=u"Bind to interface IF")
1623
parser.add_option("-a", u"--address", type=u"string",
1624
help=u"Address to listen for requests on")
1625
parser.add_option("-p", u"--port", type=u"int",
1626
help=u"Port number to receive requests on")
1627
parser.add_option("--check", action=u"store_true",
1628
help=u"Run self-test")
1629
parser.add_option("--debug", action=u"store_true",
1630
help=u"Debug mode; run in foreground and log to"
1631
u" terminal")
1632
parser.add_option("--debuglevel", type=u"string", metavar="Level",
1633
help=u"Debug level for stdout output")
1634
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1635
u" priority string (see GnuTLS documentation)")
1636
parser.add_option("--servicename", type=u"string",
1637
metavar=u"NAME", help=u"Zeroconf service name")
1638
parser.add_option("--configdir", type=u"string",
1639
default=u"/etc/mandos", metavar=u"DIR",
1640
help=u"Directory to search for configuration"
1641
u" files")
1642
parser.add_option("--no-dbus", action=u"store_false",
1643
dest=u"use_dbus", help=u"Do not provide D-Bus"
1644
u" system bus interface")
1645
parser.add_option("--no-ipv6", action=u"store_false",
1646
dest=u"use_ipv6", help=u"Do not use IPv6")
1647
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()
1648
2341
1649
2342
if options.check:
1650
2343
import doctest
1651
doctest.testmod()
1652
sys.exit()
2344
fail_count, test_count = doctest.testmod()
2345
sys.exit(os.EX_OK if fail_count == 0 else 1)
1653
2346
1654
2347
# Default values for config file for server-global settings
1655
server_defaults = { u"interface": u"",
1656
u"address": u"",
1657
u"port": u"",
1658
u"debug": u"False",
1659
u"priority":
1660
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1661
u"servicename": u"Mandos",
1662
u"use_dbus": u"True",
1663
u"use_ipv6": u"True",
1664
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",
1665
2363
}
1666
2364
1667
2365
# Parse config file for server-global settings
1668
2366
server_config = configparser.SafeConfigParser(server_defaults)
1669
2367
del server_defaults
1670
2368
server_config.read(os.path.join(options.configdir,
1671
u"mandos.conf"))
2369
"mandos.conf"))
1672
2370
# Convert the SafeConfigParser object to a dict
1673
2371
server_settings = server_config.defaults()
1674
2372
# Use the appropriate methods on the non-string config options
1675
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1676
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",
1677
2375
option)
1678
2376
if server_settings["port"]:
1679
server_settings["port"] = server_config.getint(u"DEFAULT",
1680
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"])
1681
2388
del server_config
1682
2389
1683
2390
# Override the settings from the config file with command line
1684
2391
# options, if set.
1685
for option in (u"interface", u"address", u"port", u"debug",
1686
u"priority", u"servicename", u"configdir",
1687
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"):
1688
2396
value = getattr(options, option)
1689
2397
if value is not None:
1690
2398
server_settings[option] = value
1691
2399
del options
1692
2400
# Force all strings to be unicode
1693
2401
for option in server_settings.keys():
1694
if type(server_settings[option]) is str:
1695
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
1696
2412
# Now we have our good server settings in "server_settings"
1697
2413
1698
2414
##################################################################
1699
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
1700
2422
# For convenience
1701
debug = server_settings[u"debug"]
1702
debuglevel = server_settings[u"debuglevel"]
1703
use_dbus = server_settings[u"use_dbus"]
1704
use_ipv6 = server_settings[u"use_ipv6"]
1705
1706
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":
1707
2442
syslogger.setFormatter(logging.Formatter
1708
(u'Mandos (%s) [%%(process)d]:'
1709
u' %%(levelname)s: %%(message)s'
1710
% server_settings[u"servicename"]))
2443
('Mandos ({}) [%(process)d]:'
2444
' %(levelname)s: %(message)s'
2445
.format(server_settings
2446
["servicename"])))
1711
2447
1712
2448
# Parse config file with clients
1713
client_defaults = { u"timeout": u"1h",
1714
u"interval": u"5m",
1715
u"checker": u"fping -q -- %%(host)s",
1716
u"host": u"",
1717
u"approved_delay": u"0s",
1718
u"approved_duration": u"1s",
1719
}
1720
client_config = configparser.SafeConfigParser(client_defaults)
1721
client_config.read(os.path.join(server_settings[u"configdir"],
1722
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"))
1723
2453
1724
2454
global mandos_dbus_service
1725
2455
mandos_dbus_service = None
1726
2456
1727
tcp_server = MandosServer((server_settings[u"address"],
1728
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"]),
1729
2462
ClientHandler,
1730
interface=server_settings[u"interface"],
2463
interface=(server_settings["interface"]
2464
or None),
1731
2465
use_ipv6=use_ipv6,
1732
2466
gnutls_priority=
1733
server_settings[u"priority"],
1734
use_dbus=use_dbus)
1735
pidfilename = u"/var/run/mandos.pid"
1736
try:
1737
pidfile = open(pidfilename, u"w")
1738
except IOError:
1739
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)
1740
2480
1741
try:
1742
uid = pwd.getpwnam(u"_mandos").pw_uid
1743
gid = pwd.getpwnam(u"_mandos").pw_gid
1744
except KeyError:
2481
for name in ("_mandos", "mandos", "nobody"):
1745
2482
try:
1746
uid = pwd.getpwnam(u"mandos").pw_uid
1747
gid = pwd.getpwnam(u"mandos").pw_gid
2483
uid = pwd.getpwnam(name).pw_uid
2484
gid = pwd.getpwnam(name).pw_gid
2485
break
1748
2486
except KeyError:
1749
try:
1750
uid = pwd.getpwnam(u"nobody").pw_uid
1751
gid = pwd.getpwnam(u"nobody").pw_gid
1752
except KeyError:
1753
uid = 65534
1754
gid = 65534
2487
continue
2488
else:
2489
uid = 65534
2490
gid = 65534
1755
2491
try:
1756
2492
os.setgid(gid)
1757
2493
os.setuid(uid)
1758
except OSError, error:
1759
if error[0] != errno.EPERM:
1760
raise error
2494
except OSError as error:
2495
if error.errno != errno.EPERM:
2496
raise
1761
2497
1762
# Enable all possible GnuTLS debugging
1763
1764
1765
if not debug and not debuglevel:
1766
syslogger.setLevel(logging.WARNING)
1767
console.setLevel(logging.WARNING)
1768
if debuglevel:
1769
level = getattr(logging, debuglevel.upper())
1770
syslogger.setLevel(level)
1771
console.setLevel(level)
1772
1773
2498
if debug:
2499
# Enable all possible GnuTLS debugging
2500
1774
2501
# "Use a log level over 10 to enable all debugging options."
1775
2502
# - GnuTLS manual
1776
2503
gnutls.library.functions.gnutls_global_set_log_level(11)
1777
2504
1778
2505
@gnutls.library.types.gnutls_log_func
1779
2506
def debug_gnutls(level, string):
1780
logger.debug(u"GnuTLS: %s", string[:-1])
2507
logger.debug("GnuTLS: %s", string[:-1])
1781
2508
1782
2509
(gnutls.library.functions
1783
2510
.gnutls_global_set_log_function(debug_gnutls))
1784
2511
1785
2512
# Redirect stdin so all checkers get /dev/null
1786
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2513
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1787
2514
os.dup2(null, sys.stdin.fileno())
1788
2515
if null > 2:
1789
2516
os.close(null)
1790
else:
1791
# No console logging
1792
logger.removeHandler(console)
1793
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()
1794
2526
1795
2527
global main_loop
1796
2528
# From the Avahi example code
1797
DBusGMainLoop(set_as_default=True )
2529
DBusGMainLoop(set_as_default=True)
1798
2530
main_loop = gobject.MainLoop()
1799
2531
bus = dbus.SystemBus()
1800
2532
# End of Avahi example code
1801
2533
if use_dbus:
1802
2534
try:
1803
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
2535
bus_name = dbus.service.BusName("se.recompile.Mandos",
1804
2536
bus, do_not_queue=True)
1805
except dbus.exceptions.NameExistsException, e:
1806
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)
1807
2542
use_dbus = False
1808
server_settings[u"use_dbus"] = False
2543
server_settings["use_dbus"] = False
1809
2544
tcp_server.use_dbus = False
1810
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1811
service = AvahiService(name = server_settings[u"servicename"],
1812
servicetype = u"_mandos._tcp",
1813
protocol = protocol, bus = bus)
1814
if server_settings["interface"]:
1815
service.interface = (if_nametoindex
1816
(str(server_settings[u"interface"])))
1817
1818
if not debug:
1819
# Close all input and output, do double fork, etc.
1820
daemon()
1821
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
1822
2556
global multiprocessing_manager
1823
2557
multiprocessing_manager = multiprocessing.Manager()
1824
2558
1825
2559
client_class = Client
1826
2560
if use_dbus:
1827
2561
client_class = functools.partial(ClientDBus, bus = bus)
1828
def client_config_items(config, section):
1829
special_settings = {
1830
"approved_by_default":
1831
lambda: config.getboolean(section,
1832
"approved_by_default"),
1833
}
1834
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))
1835
2644
try:
1836
yield (name, special_settings[name]())
1837
except KeyError:
1838
yield (name, value)
1839
1840
tcp_server.clients.update(set(
1841
client_class(name = section,
1842
config= dict(client_config_items(
1843
client_config, section)))
1844
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
1845
2670
if not tcp_server.clients:
1846
logger.warning(u"No clients defined")
1847
1848
try:
1849
with pidfile:
1850
pid = os.getpid()
1851
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)
1852
2682
del pidfile
1853
except IOError:
1854
logger.error(u"Could not write to file %r with PID %d",
1855
pidfilename, pid)
1856
except NameError:
1857
# "pidfile" was never created
1858
pass
1859
del pidfilename
2683
del pidfilename
1860
2684
1861
if not debug:
1862
signal.signal(signal.SIGINT, signal.SIG_IGN)
1863
2685
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1864
2686
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1865
2687
1866
2688
if use_dbus:
1867
class MandosDBusService(dbus.service.Object):
2689
@alternate_dbus_interfaces({"se.recompile.Mandos":
2690
"se.bsnet.fukt.Mandos"})
2691
class MandosDBusService(DBusObjectWithProperties):
1868
2692
"""A D-Bus proxy object"""
1869
2693
def __init__(self):
1870
dbus.service.Object.__init__(self, bus, u"/")
1871
_interface = u"se.bsnet.fukt.Mandos"
1872
1873
@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")
1874
2704
def ClientAdded(self, objpath):
1875
2705
"D-Bus signal"
1876
2706
pass
1877
2707
1878
@dbus.service.signal(_interface, signature=u"ss")
2708
@dbus.service.signal(_interface, signature="ss")
1879
2709
def ClientNotFound(self, fingerprint, address):
1880
2710
"D-Bus signal"
1881
2711
pass
1882
2712
1883
@dbus.service.signal(_interface, signature=u"os")
2713
@dbus.service.signal(_interface, signature="os")
1884
2714
def ClientRemoved(self, objpath, name):
1885
2715
"D-Bus signal"
1886
2716
pass
1887
2717
1888
@dbus.service.method(_interface, out_signature=u"ao")
2718
@dbus.service.method(_interface, out_signature="ao")
1889
2719
def GetAllClients(self):
1890
2720
"D-Bus method"
1891
2721
return dbus.Array(c.dbus_object_path
1892
for c in tcp_server.clients)
2722
for c in
2723
tcp_server.clients.itervalues())
1893
2724
1894
2725
@dbus.service.method(_interface,
1895
out_signature=u"a{oa{sv}}")
2726
out_signature="a{oa{sv}}")
1896
2727
def GetAllClientsWithProperties(self):
1897
2728
"D-Bus method"
1898
2729
return dbus.Dictionary(
1899
((c.dbus_object_path, c.GetAll(u""))
1900
for c in tcp_server.clients),
1901
signature=u"oa{sv}")
2730
{ c.dbus_object_path: c.GetAll("")
2731
for c in tcp_server.clients.itervalues() },
2732
signature="oa{sv}")
1902
2733
1903
@dbus.service.method(_interface, in_signature=u"o")
2734
@dbus.service.method(_interface, in_signature="o")
1904
2735
def RemoveClient(self, object_path):
1905
2736
"D-Bus method"
1906
for c in tcp_server.clients:
2737
for c in tcp_server.clients.itervalues():
1907
2738
if c.dbus_object_path == object_path:
1908
tcp_server.clients.remove(c)
2739
del tcp_server.clients[c.name]
1909
2740
c.remove_from_connection()
1910
2741
# Don't signal anything except ClientRemoved
1911
2742
c.disable(quiet=True)
1920
2751
1921
2752
def cleanup():
1922
2753
"Cleanup function; run on exit"
1923
service.cleanup()
1924
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
1925
2813
while tcp_server.clients:
1926
client = tcp_server.clients.pop()
2814
name, client = tcp_server.clients.popitem()
1927
2815
if use_dbus:
1928
2816
client.remove_from_connection()
1929
client.disable_hook = None
1930
2817
# Don't signal anything except ClientRemoved
1931
2818
client.disable(quiet=True)
1932
2819
if use_dbus:
1933
2820
# Emit D-Bus signal
1934
mandos_dbus_service.ClientRemoved(client.dbus_object_path,
2821
mandos_dbus_service.ClientRemoved(client
2822
.dbus_object_path,
1935
2823
client.name)
2824
client_settings.clear()
1936
2825
1937
2826
atexit.register(cleanup)
1938
2827
1939
for client in tcp_server.clients:
2828
for client in tcp_server.clients.itervalues():
1940
2829
if use_dbus:
1941
2830
# Emit D-Bus signal
1942
2831
mandos_dbus_service.ClientAdded(client.dbus_object_path)
1943
client.enable()
2832
# Need to initiate checking of clients
2833
if client.enabled:
2834
client.init_checker()
1944
2835
1945
2836
tcp_server.enable()
1946
2837
tcp_server.server_activate()
1947
2838
1948
2839
# Find out what port we got
1949
service.port = tcp_server.socket.getsockname()[1]
2840
if zeroconf:
2841
service.port = tcp_server.socket.getsockname()[1]
1950
2842
if use_ipv6:
1951
logger.info(u"Now listening on address %r, port %d,"
1952
" flowinfo %d, scope_id %d"
1953
% 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())
1954
2846
else: # IPv4
1955
logger.info(u"Now listening on address %r, port %d"
1956
% tcp_server.socket.getsockname())
2847
logger.info("Now listening on address %r, port %d",
2848
*tcp_server.socket.getsockname())
1957
2849
1958
2850
#service.interface = tcp_server.socket.getsockname()[3]
1959
2851
1960
2852
try:
1961
# From the Avahi example code
1962
try:
1963
service.activate()
1964
except dbus.exceptions.DBusException, error:
1965
logger.critical(u"DBusException: %s", error)
1966
cleanup()
1967
sys.exit(1)
1968
# 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
1969
2862
1970
2863
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1971
2864
lambda *args, **kwargs:
1972
2865
(tcp_server.handle_request
1973
2866
(*args[2:], **kwargs) or True))
1974
2867
1975
logger.debug(u"Starting main loop")
2868
logger.debug("Starting main loop")
1976
2869
main_loop.run()
1977
except AvahiError, error:
1978
logger.critical(u"AvahiError: %s", error)
2870
except AvahiError as error:
2871
logger.critical("Avahi Error", exc_info=error)
1979
2872
cleanup()
1980
2873
sys.exit(1)
1981
2874
except KeyboardInterrupt:
1982
2875
if debug:
1983
print >> sys.stderr
1984
logger.debug(u"Server received KeyboardInterrupt")
1985
logger.debug(u"Server exiting")
2876
print("", file=sys.stderr)
2877
logger.debug("Server received KeyboardInterrupt")
2878
logger.debug("Server exiting")
1986
2879
# Must run before the D-Bus bus name gets deregistered
1987
2880
cleanup()
1988
2881
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0