To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 342
- compare with another revision
- download diff
- download tarball
- view history from revision 342
- Committer: Teddy Hogeborn
- Date: 2009-04-17 08:26:17 UTC
- Revision ID: teddy@fukt.bsnet.se-20090417082617-eltetak5lzjyz55o
* initramfs-tools-hook: Bug fix: Add "--userid" and "--groupid" to
start of "plugin-runner.conf" file instead of
appending, to allow any preexisting options to
override.
* plugin-runner.conf: Improved wording.
start of "plugin-runner.conf" file instead of
appending, to allow any preexisting options to
override.
* plugin-runner.conf: Improved wording.
- files removed:
- DBUS-API
- debian/source
- files modified:
- .bzrignore
added
removed
mandos
11
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2008-2011 Teddy Hogeborn
15
# Copyright © 2008-2011 Björn Påhlsson
14
# Copyright © 2008,2009 Teddy Hogeborn
15
# Copyright © 2008,2009 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
31
31
# Contact the authors at <mandos@fukt.bsnet.se>.
32
32
#
33
33
34
from __future__ import (division, absolute_import, print_function,
35
unicode_literals)
34
from __future__ import division, with_statement, absolute_import
36
35
37
36
import SocketServer as socketserver
38
37
import socket
39
import argparse
38
import optparse
40
39
import datetime
41
40
import errno
42
41
import gnutls.crypto
56
55
import logging
57
56
import logging.handlers
58
57
import pwd
59
import contextlib
58
from contextlib import closing
60
59
import struct
61
60
import fcntl
62
61
import functools
63
import cPickle as pickle
64
import multiprocessing
65
62
66
63
import dbus
67
64
import dbus.service
70
67
from dbus.mainloop.glib import DBusGMainLoop
71
68
import ctypes
72
69
import ctypes.util
73
import xml.dom.minidom
74
import inspect
75
70
76
71
try:
77
72
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
82
77
SO_BINDTODEVICE = None
83
78
84
79
85
version = "1.3.1"
80
version = "1.0.8"
86
81
87
#logger = logging.getLogger('mandos')
88
logger = logging.Logger('mandos')
82
logger = logging.Logger(u'mandos')
89
83
syslogger = (logging.handlers.SysLogHandler
90
84
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
91
address = str("/dev/log")))
85
address = "/dev/log"))
92
86
syslogger.setFormatter(logging.Formatter
93
('Mandos [%(process)d]: %(levelname)s:'
94
' %(message)s'))
87
(u'Mandos [%(process)d]: %(levelname)s:'
88
u' %(message)s'))
95
89
logger.addHandler(syslogger)
96
90
97
91
console = logging.StreamHandler()
98
console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'
99
' %(levelname)s:'
100
' %(message)s'))
92
console.setFormatter(logging.Formatter(u'%(name)s [%(process)d]:'
93
u' %(levelname)s:'
94
u' %(message)s'))
101
95
logger.addHandler(console)
102
96
103
97
class AvahiError(Exception):
120
114
Attributes:
121
115
interface: integer; avahi.IF_UNSPEC or an interface index.
122
116
Used to optionally bind to the specified interface.
123
name: string; Example: 'Mandos'
124
type: string; Example: '_mandos._tcp'.
117
name: string; Example: u'Mandos'
118
type: string; Example: u'_mandos._tcp'.
125
119
See <http://www.dns-sd.org/ServiceTypes.html>
126
120
port: integer; what port to announce
127
121
TXT: list of strings; TXT record for the service
136
130
"""
137
131
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
138
132
servicetype = None, port = None, TXT = None,
139
domain = "", host = "", max_renames = 32768,
133
domain = u"", host = u"", max_renames = 32768,
140
134
protocol = avahi.PROTO_UNSPEC, bus = None):
141
135
self.interface = interface
142
136
self.name = name
151
145
self.group = None # our entry group
152
146
self.server = None
153
147
self.bus = bus
154
self.entry_group_state_changed_match = None
155
148
def rename(self):
156
149
"""Derived from the Avahi example code"""
157
150
if self.rename_count >= self.max_renames:
158
logger.critical("No suitable Zeroconf service name found"
159
" after %i retries, exiting.",
151
logger.critical(u"No suitable Zeroconf service name found"
152
u" after %i retries, exiting.",
160
153
self.rename_count)
161
raise AvahiServiceError("Too many renames")
162
self.name = unicode(self.server.GetAlternativeServiceName(self.name))
163
logger.info("Changing Zeroconf service name to %r ...",
164
self.name)
154
raise AvahiServiceError(u"Too many renames")
155
self.name = self.server.GetAlternativeServiceName(self.name)
156
logger.info(u"Changing Zeroconf service name to %r ...",
157
unicode(self.name))
165
158
syslogger.setFormatter(logging.Formatter
166
('Mandos (%s) [%%(process)d]:'
167
' %%(levelname)s: %%(message)s'
159
(u'Mandos (%s) [%%(process)d]:'
160
u' %%(levelname)s: %%(message)s'
168
161
% self.name))
169
162
self.remove()
170
try:
171
self.add()
172
except dbus.exceptions.DBusException as error:
173
logger.critical("DBusException: %s", error)
174
self.cleanup()
175
os._exit(1)
163
self.add()
176
164
self.rename_count += 1
177
165
def remove(self):
178
166
"""Derived from the Avahi example code"""
179
if self.entry_group_state_changed_match is not None:
180
self.entry_group_state_changed_match.remove()
181
self.entry_group_state_changed_match = None
182
167
if self.group is not None:
183
168
self.group.Reset()
184
169
def add(self):
185
170
"""Derived from the Avahi example code"""
186
self.remove()
187
171
if self.group is None:
188
172
self.group = dbus.Interface(
189
173
self.bus.get_object(avahi.DBUS_NAME,
190
174
self.server.EntryGroupNew()),
191
175
avahi.DBUS_INTERFACE_ENTRY_GROUP)
192
self.entry_group_state_changed_match = (
193
self.group.connect_to_signal(
194
'StateChanged', self .entry_group_state_changed))
195
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
176
self.group.connect_to_signal('StateChanged',
177
self.entry_group_state_changed)
178
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
196
179
self.name, self.type)
197
180
self.group.AddService(
198
181
self.interface,
205
188
self.group.Commit()
206
189
def entry_group_state_changed(self, state, error):
207
190
"""Derived from the Avahi example code"""
208
logger.debug("Avahi entry group state change: %i", state)
191
logger.debug(u"Avahi state change: %i", state)
209
192
210
193
if state == avahi.ENTRY_GROUP_ESTABLISHED:
211
logger.debug("Zeroconf service established.")
194
logger.debug(u"Zeroconf service established.")
212
195
elif state == avahi.ENTRY_GROUP_COLLISION:
213
logger.info("Zeroconf service name collision.")
196
logger.warning(u"Zeroconf service name collision.")
214
197
self.rename()
215
198
elif state == avahi.ENTRY_GROUP_FAILURE:
216
logger.critical("Avahi: Error in group state changed %s",
199
logger.critical(u"Avahi: Error in group state changed %s",
217
200
unicode(error))
218
raise AvahiGroupError("State changed: %s"
201
raise AvahiGroupError(u"State changed: %s"
219
202
% unicode(error))
220
203
def cleanup(self):
221
204
"""Derived from the Avahi example code"""
222
205
if self.group is not None:
223
try:
224
self.group.Free()
225
except (dbus.exceptions.UnknownMethodException,
226
dbus.exceptions.DBusException) as e:
227
pass
206
self.group.Free()
228
207
self.group = None
229
self.remove()
230
def server_state_changed(self, state, error=None):
208
def server_state_changed(self, state):
231
209
"""Derived from the Avahi example code"""
232
logger.debug("Avahi server state change: %i", state)
233
bad_states = { avahi.SERVER_INVALID:
234
"Zeroconf server invalid",
235
avahi.SERVER_REGISTERING: None,
236
avahi.SERVER_COLLISION:
237
"Zeroconf server name collision",
238
avahi.SERVER_FAILURE:
239
"Zeroconf server failure" }
240
if state in bad_states:
241
if bad_states[state] is not None:
242
if error is None:
243
logger.error(bad_states[state])
244
else:
245
logger.error(bad_states[state] + ": %r", error)
246
self.cleanup()
210
if state == avahi.SERVER_COLLISION:
211
logger.error(u"Zeroconf server name collision")
212
self.remove()
247
213
elif state == avahi.SERVER_RUNNING:
248
214
self.add()
249
else:
250
if error is None:
251
logger.debug("Unknown state: %r", state)
252
else:
253
logger.debug("Unknown state: %r: %r", state, error)
254
215
def activate(self):
255
216
"""Derived from the Avahi example code"""
256
217
if self.server is None:
257
218
self.server = dbus.Interface(
258
219
self.bus.get_object(avahi.DBUS_NAME,
259
avahi.DBUS_PATH_SERVER,
260
follow_name_owner_changes=True),
220
avahi.DBUS_PATH_SERVER),
261
221
avahi.DBUS_INTERFACE_SERVER)
262
self.server.connect_to_signal("StateChanged",
222
self.server.connect_to_signal(u"StateChanged",
263
223
self.server_state_changed)
264
224
self.server_state_changed(self.server.GetState())
265
225
268
228
"""A representation of a client host served by this server.
269
229
270
230
Attributes:
271
_approved: bool(); 'None' if not yet approved/disapproved
272
approval_delay: datetime.timedelta(); Time to wait for approval
273
approval_duration: datetime.timedelta(); Duration of one approval
231
name: string; from the config file, used in log messages and
232
D-Bus identifiers
233
fingerprint: string (40 or 32 hexadecimal digits); used to
234
uniquely identify the client
235
secret: bytestring; sent verbatim (over TLS) to client
236
host: string; available for use by the checker command
237
created: datetime.datetime(); (UTC) object creation
238
last_enabled: datetime.datetime(); (UTC)
239
enabled: bool()
240
last_checked_ok: datetime.datetime(); (UTC) or None
241
timeout: datetime.timedelta(); How long from last_checked_ok
242
until this client is invalid
243
interval: datetime.timedelta(); How often to start a new checker
244
disable_hook: If set, called by disable() as disable_hook(self)
274
245
checker: subprocess.Popen(); a running checker process used
275
246
to see if the client lives.
276
247
'None' if no process is running.
277
checker_callback_tag: a gobject event source tag, or None
278
checker_command: string; External command which is run to check
279
if client lives. %() expansions are done at
248
checker_initiator_tag: a gobject event source tag, or None
249
disable_initiator_tag: - '' -
250
checker_callback_tag: - '' -
251
checker_command: string; External command which is run to check if
252
client lives. %() expansions are done at
280
253
runtime with vars(self) as dict, so that for
281
254
instance %(name)s can be used in the command.
282
checker_initiator_tag: a gobject event source tag, or None
283
created: datetime.datetime(); (UTC) object creation
284
255
current_checker_command: string; current running checker_command
285
disable_hook: If set, called by disable() as disable_hook(self)
286
disable_initiator_tag: a gobject event source tag, or None
287
enabled: bool()
288
fingerprint: string (40 or 32 hexadecimal digits); used to
289
uniquely identify the client
290
host: string; available for use by the checker command
291
interval: datetime.timedelta(); How often to start a new checker
292
last_approval_request: datetime.datetime(); (UTC) or None
293
last_checked_ok: datetime.datetime(); (UTC) or None
294
last_enabled: datetime.datetime(); (UTC)
295
name: string; from the config file, used in log messages and
296
D-Bus identifiers
297
secret: bytestring; sent verbatim (over TLS) to client
298
timeout: datetime.timedelta(); How long from last_checked_ok
299
until this client is disabled
300
extended_timeout: extra long timeout when password has been sent
301
runtime_expansions: Allowed attributes for runtime expansion.
302
expires: datetime.datetime(); time (UTC) when a client will be
303
disabled, or None
304
256
"""
305
257
306
runtime_expansions = ("approval_delay", "approval_duration",
307
"created", "enabled", "fingerprint",
308
"host", "interval", "last_checked_ok",
309
"last_enabled", "name", "timeout")
310
311
258
@staticmethod
312
def _timedelta_to_milliseconds(td):
313
"Convert a datetime.timedelta() to milliseconds"
314
return ((td.days * 24 * 60 * 60 * 1000)
315
+ (td.seconds * 1000)
316
+ (td.microseconds // 1000))
259
def _datetime_to_milliseconds(dt):
260
"Convert a datetime.datetime() to milliseconds"
261
return ((dt.days * 24 * 60 * 60 * 1000)
262
+ (dt.seconds * 1000)
263
+ (dt.microseconds // 1000))
317
264
318
265
def timeout_milliseconds(self):
319
266
"Return the 'timeout' attribute in milliseconds"
320
return self._timedelta_to_milliseconds(self.timeout)
321
322
def extended_timeout_milliseconds(self):
323
"Return the 'extended_timeout' attribute in milliseconds"
324
return self._timedelta_to_milliseconds(self.extended_timeout)
267
return self._datetime_to_milliseconds(self.timeout)
325
268
326
269
def interval_milliseconds(self):
327
270
"Return the 'interval' attribute in milliseconds"
328
return self._timedelta_to_milliseconds(self.interval)
329
330
def approval_delay_milliseconds(self):
331
return self._timedelta_to_milliseconds(self.approval_delay)
271
return self._datetime_to_milliseconds(self.interval)
332
272
333
273
def __init__(self, name = None, disable_hook=None, config=None):
334
274
"""Note: the 'checker' key in 'config' sets the
337
277
self.name = name
338
278
if config is None:
339
279
config = {}
340
logger.debug("Creating client %r", self.name)
280
logger.debug(u"Creating client %r", self.name)
341
281
# Uppercase and remove spaces from fingerprint for later
342
282
# comparison purposes with return value from the fingerprint()
343
283
# function
344
self.fingerprint = (config["fingerprint"].upper()
345
.replace(" ", ""))
346
logger.debug(" Fingerprint: %s", self.fingerprint)
347
if "secret" in config:
348
self.secret = config["secret"].decode("base64")
349
elif "secfile" in config:
350
with open(os.path.expanduser(os.path.expandvars
351
(config["secfile"])),
352
"rb") as secfile:
284
self.fingerprint = (config[u"fingerprint"].upper()
285
.replace(u" ", u""))
286
logger.debug(u" Fingerprint: %s", self.fingerprint)
287
if u"secret" in config:
288
self.secret = config[u"secret"].decode(u"base64")
289
elif u"secfile" in config:
290
with closing(open(os.path.expanduser
291
(os.path.expandvars
292
(config[u"secfile"])))) as secfile:
353
293
self.secret = secfile.read()
354
294
else:
355
raise TypeError("No secret or secfile for client %s"
295
raise TypeError(u"No secret or secfile for client %s"
356
296
% self.name)
357
self.host = config.get("host", "")
297
self.host = config.get(u"host", u"")
358
298
self.created = datetime.datetime.utcnow()
359
299
self.enabled = False
360
self.last_approval_request = None
361
300
self.last_enabled = None
362
301
self.last_checked_ok = None
363
self.timeout = string_to_delta(config["timeout"])
364
self.extended_timeout = string_to_delta(config["extended_timeout"])
365
self.interval = string_to_delta(config["interval"])
302
self.timeout = string_to_delta(config[u"timeout"])
303
self.interval = string_to_delta(config[u"interval"])
366
304
self.disable_hook = disable_hook
367
305
self.checker = None
368
306
self.checker_initiator_tag = None
369
307
self.disable_initiator_tag = None
370
self.expires = None
371
308
self.checker_callback_tag = None
372
self.checker_command = config["checker"]
309
self.checker_command = config[u"checker"]
373
310
self.current_checker_command = None
374
311
self.last_connect = None
375
self._approved = None
376
self.approved_by_default = config.get("approved_by_default",
377
True)
378
self.approvals_pending = 0
379
self.approval_delay = string_to_delta(
380
config["approval_delay"])
381
self.approval_duration = string_to_delta(
382
config["approval_duration"])
383
self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
384
312
385
def send_changedstate(self):
386
self.changedstate.acquire()
387
self.changedstate.notify_all()
388
self.changedstate.release()
389
390
313
def enable(self):
391
314
"""Start this client's checker and timeout hooks"""
392
if getattr(self, "enabled", False):
315
if getattr(self, u"enabled", False):
393
316
# Already enabled
394
317
return
395
self.send_changedstate()
396
318
self.last_enabled = datetime.datetime.utcnow()
397
319
# Schedule a new checker to be started an 'interval' from now,
398
320
# and every interval from then on.
399
321
self.checker_initiator_tag = (gobject.timeout_add
400
322
(self.interval_milliseconds(),
401
323
self.start_checker))
324
# Also start a new checker *right now*.
325
self.start_checker()
402
326
# Schedule a disable() when 'timeout' has passed
403
self.expires = datetime.datetime.utcnow() + self.timeout
404
327
self.disable_initiator_tag = (gobject.timeout_add
405
328
(self.timeout_milliseconds(),
406
329
self.disable))
407
330
self.enabled = True
408
# Also start a new checker *right now*.
409
self.start_checker()
410
331
411
def disable(self, quiet=True):
332
def disable(self):
412
333
"""Disable this client."""
413
334
if not getattr(self, "enabled", False):
414
335
return False
415
if not quiet:
416
self.send_changedstate()
417
if not quiet:
418
logger.info("Disabling client %s", self.name)
419
if getattr(self, "disable_initiator_tag", False):
336
logger.info(u"Disabling client %s", self.name)
337
if getattr(self, u"disable_initiator_tag", False):
420
338
gobject.source_remove(self.disable_initiator_tag)
421
339
self.disable_initiator_tag = None
422
self.expires = None
423
if getattr(self, "checker_initiator_tag", False):
340
if getattr(self, u"checker_initiator_tag", False):
424
341
gobject.source_remove(self.checker_initiator_tag)
425
342
self.checker_initiator_tag = None
426
343
self.stop_checker()
441
358
if os.WIFEXITED(condition):
442
359
exitstatus = os.WEXITSTATUS(condition)
443
360
if exitstatus == 0:
444
logger.info("Checker for %(name)s succeeded",
361
logger.info(u"Checker for %(name)s succeeded",
445
362
vars(self))
446
363
self.checked_ok()
447
364
else:
448
logger.info("Checker for %(name)s failed",
365
logger.info(u"Checker for %(name)s failed",
449
366
vars(self))
450
367
else:
451
logger.warning("Checker for %(name)s crashed?",
368
logger.warning(u"Checker for %(name)s crashed?",
452
369
vars(self))
453
370
454
def checked_ok(self, timeout=None):
371
def checked_ok(self):
455
372
"""Bump up the timeout for this client.
456
373
457
374
This should only be called when the client has been seen,
458
375
alive and well.
459
376
"""
460
if timeout is None:
461
timeout = self.timeout
462
377
self.last_checked_ok = datetime.datetime.utcnow()
463
378
gobject.source_remove(self.disable_initiator_tag)
464
self.expires = datetime.datetime.utcnow() + timeout
465
379
self.disable_initiator_tag = (gobject.timeout_add
466
(self._timedelta_to_milliseconds(timeout),
380
(self.timeout_milliseconds(),
467
381
self.disable))
468
382
469
def need_approval(self):
470
self.last_approval_request = datetime.datetime.utcnow()
471
472
383
def start_checker(self):
473
384
"""Start a new checker subprocess if one is not running.
474
385
480
391
# client would inevitably timeout, since no checker would get
481
392
# a chance to run to completion. If we instead leave running
482
393
# checkers alone, the checker would have to take more time
483
# than 'timeout' for the client to be disabled, which is as it
484
# should be.
394
# than 'timeout' for the client to be declared invalid, which
395
# is as it should be.
485
396
486
397
# If a checker exists, make sure it is not a zombie
487
try:
398
if self.checker is not None:
488
399
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
489
except (AttributeError, OSError) as error:
490
if (isinstance(error, OSError)
491
and error.errno != errno.ECHILD):
492
raise error
493
else:
494
400
if pid:
495
logger.warning("Checker was a zombie")
401
logger.warning(u"Checker was a zombie")
496
402
gobject.source_remove(self.checker_callback_tag)
497
403
self.checker_callback(pid, status,
498
404
self.current_checker_command)
503
409
command = self.checker_command % self.host
504
410
except TypeError:
505
411
# Escape attributes for the shell
506
escaped_attrs = dict(
507
(attr,
508
re.escape(unicode(str(getattr(self, attr, "")),
509
errors=
510
'replace')))
511
for attr in
512
self.runtime_expansions)
513
412
escaped_attrs = dict((key,
413
re.escape(unicode(str(val),
414
errors=
415
u'replace')))
416
for key, val in
417
vars(self).iteritems())
514
418
try:
515
419
command = self.checker_command % escaped_attrs
516
except TypeError as error:
517
logger.error('Could not format string "%s":'
518
' %s', self.checker_command, error)
420
except TypeError, error:
421
logger.error(u'Could not format string "%s":'
422
u' %s', self.checker_command, error)
519
423
return True # Try again later
520
424
self.current_checker_command = command
521
425
try:
522
logger.info("Starting checker %r for %s",
426
logger.info(u"Starting checker %r for %s",
523
427
command, self.name)
524
428
# We don't need to redirect stdout and stderr, since
525
429
# in normal mode, that is already done by daemon(),
527
431
# always replaced by /dev/null.)
528
432
self.checker = subprocess.Popen(command,
529
433
close_fds=True,
530
shell=True, cwd="/")
434
shell=True, cwd=u"/")
531
435
self.checker_callback_tag = (gobject.child_watch_add
532
436
(self.checker.pid,
533
437
self.checker_callback,
538
442
if pid:
539
443
gobject.source_remove(self.checker_callback_tag)
540
444
self.checker_callback(pid, status, command)
541
except OSError as error:
542
logger.error("Failed to start subprocess: %s",
445
except OSError, error:
446
logger.error(u"Failed to start subprocess: %s",
543
447
error)
544
448
# Re-run this periodically if run by gobject.timeout_add
545
449
return True
549
453
if self.checker_callback_tag:
550
454
gobject.source_remove(self.checker_callback_tag)
551
455
self.checker_callback_tag = None
552
if getattr(self, "checker", None) is None:
456
if getattr(self, u"checker", None) is None:
553
457
return
554
logger.debug("Stopping checker for %(name)s", vars(self))
458
logger.debug(u"Stopping checker for %(name)s", vars(self))
555
459
try:
556
460
os.kill(self.checker.pid, signal.SIGTERM)
557
#time.sleep(0.5)
461
#os.sleep(0.5)
558
462
#if self.checker.poll() is None:
559
463
# os.kill(self.checker.pid, signal.SIGKILL)
560
except OSError as error:
464
except OSError, error:
561
465
if error.errno != errno.ESRCH: # No such process
562
466
raise
563
467
self.checker = None
564
565
def dbus_service_property(dbus_interface, signature="v",
566
access="readwrite", byte_arrays=False):
567
"""Decorators for marking methods of a DBusObjectWithProperties to
568
become properties on the D-Bus.
569
570
The decorated method will be called with no arguments by "Get"
571
and with one argument by "Set".
572
573
The parameters, where they are supported, are the same as
574
dbus.service.method, except there is only "signature", since the
575
type from Get() and the type sent to Set() is the same.
576
"""
577
# Encoding deeply encoded byte arrays is not supported yet by the
578
# "Set" method, so we fail early here:
579
if byte_arrays and signature != "ay":
580
raise ValueError("Byte arrays not supported for non-'ay'"
581
" signature %r" % signature)
582
def decorator(func):
583
func._dbus_is_property = True
584
func._dbus_interface = dbus_interface
585
func._dbus_signature = signature
586
func._dbus_access = access
587
func._dbus_name = func.__name__
588
if func._dbus_name.endswith("_dbus_property"):
589
func._dbus_name = func._dbus_name[:-14]
590
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
591
return func
592
return decorator
593
594
595
class DBusPropertyException(dbus.exceptions.DBusException):
596
"""A base class for D-Bus property-related exceptions
597
"""
598
def __unicode__(self):
599
return unicode(str(self))
600
601
602
class DBusPropertyAccessException(DBusPropertyException):
603
"""A property's access permissions disallows an operation.
604
"""
605
pass
606
607
608
class DBusPropertyNotFound(DBusPropertyException):
609
"""An attempt was made to access a non-existing property.
610
"""
611
pass
612
613
614
class DBusObjectWithProperties(dbus.service.Object):
615
"""A D-Bus object with properties.
616
617
Classes inheriting from this can use the dbus_service_property
618
decorator to expose methods as D-Bus properties. It exposes the
619
standard Get(), Set(), and GetAll() methods on the D-Bus.
620
"""
621
622
@staticmethod
623
def _is_dbus_property(obj):
624
return getattr(obj, "_dbus_is_property", False)
625
626
def _get_all_dbus_properties(self):
627
"""Returns a generator of (name, attribute) pairs
628
"""
629
return ((prop._dbus_name, prop)
630
for name, prop in
631
inspect.getmembers(self, self._is_dbus_property))
632
633
def _get_dbus_property(self, interface_name, property_name):
634
"""Returns a bound method if one exists which is a D-Bus
635
property with the specified name and interface.
636
"""
637
for name in (property_name,
638
property_name + "_dbus_property"):
639
prop = getattr(self, name, None)
640
if (prop is None
641
or not self._is_dbus_property(prop)
642
or prop._dbus_name != property_name
643
or (interface_name and prop._dbus_interface
644
and interface_name != prop._dbus_interface)):
645
continue
646
return prop
647
# No such property
648
raise DBusPropertyNotFound(self.dbus_object_path + ":"
649
+ interface_name + "."
650
+ property_name)
651
652
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
653
out_signature="v")
654
def Get(self, interface_name, property_name):
655
"""Standard D-Bus property Get() method, see D-Bus standard.
656
"""
657
prop = self._get_dbus_property(interface_name, property_name)
658
if prop._dbus_access == "write":
659
raise DBusPropertyAccessException(property_name)
660
value = prop()
661
if not hasattr(value, "variant_level"):
662
return value
663
return type(value)(value, variant_level=value.variant_level+1)
664
665
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
666
def Set(self, interface_name, property_name, value):
667
"""Standard D-Bus property Set() method, see D-Bus standard.
668
"""
669
prop = self._get_dbus_property(interface_name, property_name)
670
if prop._dbus_access == "read":
671
raise DBusPropertyAccessException(property_name)
672
if prop._dbus_get_args_options["byte_arrays"]:
673
# The byte_arrays option is not supported yet on
674
# signatures other than "ay".
675
if prop._dbus_signature != "ay":
676
raise ValueError
677
value = dbus.ByteArray(''.join(unichr(byte)
678
for byte in value))
679
prop(value)
680
681
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
682
out_signature="a{sv}")
683
def GetAll(self, interface_name):
684
"""Standard D-Bus property GetAll() method, see D-Bus
685
standard.
686
687
Note: Will not include properties with access="write".
688
"""
689
all = {}
690
for name, prop in self._get_all_dbus_properties():
691
if (interface_name
692
and interface_name != prop._dbus_interface):
693
# Interface non-empty but did not match
694
continue
695
# Ignore write-only properties
696
if prop._dbus_access == "write":
697
continue
698
value = prop()
699
if not hasattr(value, "variant_level"):
700
all[name] = value
701
continue
702
all[name] = type(value)(value, variant_level=
703
value.variant_level+1)
704
return dbus.Dictionary(all, signature="sv")
705
706
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
707
out_signature="s",
708
path_keyword='object_path',
709
connection_keyword='connection')
710
def Introspect(self, object_path, connection):
711
"""Standard D-Bus method, overloaded to insert property tags.
712
"""
713
xmlstring = dbus.service.Object.Introspect(self, object_path,
714
connection)
715
try:
716
document = xml.dom.minidom.parseString(xmlstring)
717
def make_tag(document, name, prop):
718
e = document.createElement("property")
719
e.setAttribute("name", name)
720
e.setAttribute("type", prop._dbus_signature)
721
e.setAttribute("access", prop._dbus_access)
722
return e
723
for if_tag in document.getElementsByTagName("interface"):
724
for tag in (make_tag(document, name, prop)
725
for name, prop
726
in self._get_all_dbus_properties()
727
if prop._dbus_interface
728
== if_tag.getAttribute("name")):
729
if_tag.appendChild(tag)
730
# Add the names to the return values for the
731
# "org.freedesktop.DBus.Properties" methods
732
if (if_tag.getAttribute("name")
733
== "org.freedesktop.DBus.Properties"):
734
for cn in if_tag.getElementsByTagName("method"):
735
if cn.getAttribute("name") == "Get":
736
for arg in cn.getElementsByTagName("arg"):
737
if (arg.getAttribute("direction")
738
== "out"):
739
arg.setAttribute("name", "value")
740
elif cn.getAttribute("name") == "GetAll":
741
for arg in cn.getElementsByTagName("arg"):
742
if (arg.getAttribute("direction")
743
== "out"):
744
arg.setAttribute("name", "props")
745
xmlstring = document.toxml("utf-8")
746
document.unlink()
747
except (AttributeError, xml.dom.DOMException,
748
xml.parsers.expat.ExpatError) as error:
749
logger.error("Failed to override Introspection method",
750
error)
751
return xmlstring
752
753
754
class ClientDBus(Client, DBusObjectWithProperties):
468
469
def still_valid(self):
470
"""Has the timeout not yet passed for this client?"""
471
if not getattr(self, u"enabled", False):
472
return False
473
now = datetime.datetime.utcnow()
474
if self.last_checked_ok is None:
475
return now < (self.created + self.timeout)
476
else:
477
return now < (self.last_checked_ok + self.timeout)
478
479
480
class ClientDBus(Client, dbus.service.Object):
755
481
"""A Client class using D-Bus
756
482
757
483
Attributes:
758
484
dbus_object_path: dbus.ObjectPath
759
485
bus: dbus.SystemBus()
760
486
"""
761
762
runtime_expansions = (Client.runtime_expansions
763
+ ("dbus_object_path",))
764
765
487
# dbus.service.Object doesn't use super(), so we can't either.
766
488
767
489
def __init__(self, bus = None, *args, **kwargs):
768
self._approvals_pending = 0
769
490
self.bus = bus
770
491
Client.__init__(self, *args, **kwargs)
771
492
# Only now, when this client is initialized, can it show up on
772
493
# the D-Bus
773
client_object_name = unicode(self.name).translate(
774
{ord("."): ord("_"),
775
ord("-"): ord("_")})
776
494
self.dbus_object_path = (dbus.ObjectPath
777
("/clients/" + client_object_name))
778
DBusObjectWithProperties.__init__(self, self.bus,
779
self.dbus_object_path)
780
def _set_expires(self, value):
781
old_value = getattr(self, "_expires", None)
782
self._expires = value
783
if hasattr(self, "dbus_object_path") and old_value != value:
784
dbus_time = (self._datetime_to_dbus(self._expires,
785
variant_level=1))
786
self.PropertyChanged(dbus.String("Expires"),
787
dbus_time)
788
expires = property(lambda self: self._expires, _set_expires)
789
del _set_expires
790
791
def _get_approvals_pending(self):
792
return self._approvals_pending
793
def _set_approvals_pending(self, value):
794
old_value = self._approvals_pending
795
self._approvals_pending = value
796
bval = bool(value)
797
if (hasattr(self, "dbus_object_path")
798
and bval is not bool(old_value)):
799
dbus_bool = dbus.Boolean(bval, variant_level=1)
800
self.PropertyChanged(dbus.String("ApprovalPending"),
801
dbus_bool)
802
803
approvals_pending = property(_get_approvals_pending,
804
_set_approvals_pending)
805
del _get_approvals_pending, _set_approvals_pending
495
(u"/clients/"
496
+ self.name.replace(u".", u"_")))
497
dbus.service.Object.__init__(self, self.bus,
498
self.dbus_object_path)
806
499
807
500
@staticmethod
808
501
def _datetime_to_dbus(dt, variant_level=0):
809
502
"""Convert a UTC datetime.datetime() to a D-Bus type."""
810
if dt is None:
811
return dbus.String("", variant_level = variant_level)
812
503
return dbus.String(dt.isoformat(),
813
504
variant_level=variant_level)
814
505
815
506
def enable(self):
816
oldstate = getattr(self, "enabled", False)
507
oldstate = getattr(self, u"enabled", False)
817
508
r = Client.enable(self)
818
509
if oldstate != self.enabled:
819
510
# Emit D-Bus signals
820
self.PropertyChanged(dbus.String("Enabled"),
511
self.PropertyChanged(dbus.String(u"enabled"),
821
512
dbus.Boolean(True, variant_level=1))
822
513
self.PropertyChanged(
823
dbus.String("LastEnabled"),
514
dbus.String(u"last_enabled"),
824
515
self._datetime_to_dbus(self.last_enabled,
825
516
variant_level=1))
826
517
return r
827
518
828
def disable(self, quiet = False):
829
oldstate = getattr(self, "enabled", False)
830
r = Client.disable(self, quiet=quiet)
831
if not quiet and oldstate != self.enabled:
519
def disable(self, signal = True):
520
oldstate = getattr(self, u"enabled", False)
521
r = Client.disable(self)
522
if signal and oldstate != self.enabled:
832
523
# Emit D-Bus signal
833
self.PropertyChanged(dbus.String("Enabled"),
524
self.PropertyChanged(dbus.String(u"enabled"),
834
525
dbus.Boolean(False, variant_level=1))
835
526
return r
836
527
839
530
self.remove_from_connection()
840
531
except LookupError:
841
532
pass
842
if hasattr(DBusObjectWithProperties, "__del__"):
843
DBusObjectWithProperties.__del__(self, *args, **kwargs)
533
if hasattr(dbus.service.Object, u"__del__"):
534
dbus.service.Object.__del__(self, *args, **kwargs)
844
535
Client.__del__(self, *args, **kwargs)
845
536
846
537
def checker_callback(self, pid, condition, command,
848
539
self.checker_callback_tag = None
849
540
self.checker = None
850
541
# Emit D-Bus signal
851
self.PropertyChanged(dbus.String("CheckerRunning"),
542
self.PropertyChanged(dbus.String(u"checker_running"),
852
543
dbus.Boolean(False, variant_level=1))
853
544
if os.WIFEXITED(condition):
854
545
exitstatus = os.WEXITSTATUS(condition)
866
557
*args, **kwargs)
867
558
868
559
def checked_ok(self, *args, **kwargs):
869
Client.checked_ok(self, *args, **kwargs)
560
r = Client.checked_ok(self, *args, **kwargs)
870
561
# Emit D-Bus signal
871
562
self.PropertyChanged(
872
dbus.String("LastCheckedOK"),
563
dbus.String(u"last_checked_ok"),
873
564
(self._datetime_to_dbus(self.last_checked_ok,
874
565
variant_level=1)))
875
876
def need_approval(self, *args, **kwargs):
877
r = Client.need_approval(self, *args, **kwargs)
878
# Emit D-Bus signal
879
self.PropertyChanged(
880
dbus.String("LastApprovalRequest"),
881
(self._datetime_to_dbus(self.last_approval_request,
882
variant_level=1)))
883
566
return r
884
567
885
568
def start_checker(self, *args, **kwargs):
895
578
# Emit D-Bus signal
896
579
self.CheckerStarted(self.current_checker_command)
897
580
self.PropertyChanged(
898
dbus.String("CheckerRunning"),
581
dbus.String(u"checker_running"),
899
582
dbus.Boolean(True, variant_level=1))
900
583
return r
901
584
902
585
def stop_checker(self, *args, **kwargs):
903
old_checker = getattr(self, "checker", None)
586
old_checker = getattr(self, u"checker", None)
904
587
r = Client.stop_checker(self, *args, **kwargs)
905
588
if (old_checker is not None
906
and getattr(self, "checker", None) is None):
907
self.PropertyChanged(dbus.String("CheckerRunning"),
589
and getattr(self, u"checker", None) is None):
590
self.PropertyChanged(dbus.String(u"checker_running"),
908
591
dbus.Boolean(False, variant_level=1))
909
592
return r
910
911
def _reset_approved(self):
912
self._approved = None
913
return False
914
915
def approve(self, value=True):
916
self.send_changedstate()
917
self._approved = value
918
gobject.timeout_add(self._timedelta_to_milliseconds
919
(self.approval_duration),
920
self._reset_approved)
921
922
923
## D-Bus methods, signals & properties
924
_interface = "se.bsnet.fukt.Mandos.Client"
925
926
## Signals
593
594
## D-Bus methods & signals
595
_interface = u"se.bsnet.fukt.Mandos.Client"
596
597
# CheckedOK - method
598
@dbus.service.method(_interface)
599
def CheckedOK(self):
600
return self.checked_ok()
927
601
928
602
# CheckerCompleted - signal
929
@dbus.service.signal(_interface, signature="nxs")
603
@dbus.service.signal(_interface, signature=u"nxs")
930
604
def CheckerCompleted(self, exitcode, waitstatus, command):
931
605
"D-Bus signal"
932
606
pass
933
607
934
608
# CheckerStarted - signal
935
@dbus.service.signal(_interface, signature="s")
609
@dbus.service.signal(_interface, signature=u"s")
936
610
def CheckerStarted(self, command):
937
611
"D-Bus signal"
938
612
pass
939
613
614
# GetAllProperties - method
615
@dbus.service.method(_interface, out_signature=u"a{sv}")
616
def GetAllProperties(self):
617
"D-Bus method"
618
return dbus.Dictionary({
619
dbus.String(u"name"):
620
dbus.String(self.name, variant_level=1),
621
dbus.String(u"fingerprint"):
622
dbus.String(self.fingerprint, variant_level=1),
623
dbus.String(u"host"):
624
dbus.String(self.host, variant_level=1),
625
dbus.String(u"created"):
626
self._datetime_to_dbus(self.created,
627
variant_level=1),
628
dbus.String(u"last_enabled"):
629
(self._datetime_to_dbus(self.last_enabled,
630
variant_level=1)
631
if self.last_enabled is not None
632
else dbus.Boolean(False, variant_level=1)),
633
dbus.String(u"enabled"):
634
dbus.Boolean(self.enabled, variant_level=1),
635
dbus.String(u"last_checked_ok"):
636
(self._datetime_to_dbus(self.last_checked_ok,
637
variant_level=1)
638
if self.last_checked_ok is not None
639
else dbus.Boolean (False, variant_level=1)),
640
dbus.String(u"timeout"):
641
dbus.UInt64(self.timeout_milliseconds(),
642
variant_level=1),
643
dbus.String(u"interval"):
644
dbus.UInt64(self.interval_milliseconds(),
645
variant_level=1),
646
dbus.String(u"checker"):
647
dbus.String(self.checker_command,
648
variant_level=1),
649
dbus.String(u"checker_running"):
650
dbus.Boolean(self.checker is not None,
651
variant_level=1),
652
dbus.String(u"object_path"):
653
dbus.ObjectPath(self.dbus_object_path,
654
variant_level=1)
655
}, signature=u"sv")
656
657
# IsStillValid - method
658
@dbus.service.method(_interface, out_signature=u"b")
659
def IsStillValid(self):
660
return self.still_valid()
661
940
662
# PropertyChanged - signal
941
@dbus.service.signal(_interface, signature="sv")
663
@dbus.service.signal(_interface, signature=u"sv")
942
664
def PropertyChanged(self, property, value):
943
665
"D-Bus signal"
944
666
pass
945
667
946
# GotSecret - signal
668
# ReceivedSecret - signal
947
669
@dbus.service.signal(_interface)
948
def GotSecret(self):
949
"""D-Bus signal
950
Is sent after a successful transfer of secret from the Mandos
951
server to mandos-client
952
"""
670
def ReceivedSecret(self):
671
"D-Bus signal"
953
672
pass
954
673
955
674
# Rejected - signal
956
@dbus.service.signal(_interface, signature="s")
957
def Rejected(self, reason):
675
@dbus.service.signal(_interface)
676
def Rejected(self):
958
677
"D-Bus signal"
959
678
pass
960
679
961
# NeedApproval - signal
962
@dbus.service.signal(_interface, signature="tb")
963
def NeedApproval(self, timeout, default):
964
"D-Bus signal"
965
return self.need_approval()
966
967
## Methods
968
969
# Approve - method
970
@dbus.service.method(_interface, in_signature="b")
971
def Approve(self, value):
972
self.approve(value)
973
974
# CheckedOK - method
975
@dbus.service.method(_interface)
976
def CheckedOK(self):
977
self.checked_ok()
680
# SetChecker - method
681
@dbus.service.method(_interface, in_signature=u"s")
682
def SetChecker(self, checker):
683
"D-Bus setter method"
684
self.checker_command = checker
685
# Emit D-Bus signal
686
self.PropertyChanged(dbus.String(u"checker"),
687
dbus.String(self.checker_command,
688
variant_level=1))
689
690
# SetHost - method
691
@dbus.service.method(_interface, in_signature=u"s")
692
def SetHost(self, host):
693
"D-Bus setter method"
694
self.host = host
695
# Emit D-Bus signal
696
self.PropertyChanged(dbus.String(u"host"),
697
dbus.String(self.host, variant_level=1))
698
699
# SetInterval - method
700
@dbus.service.method(_interface, in_signature=u"t")
701
def SetInterval(self, milliseconds):
702
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
703
# Emit D-Bus signal
704
self.PropertyChanged(dbus.String(u"interval"),
705
(dbus.UInt64(self.interval_milliseconds(),
706
variant_level=1)))
707
708
# SetSecret - method
709
@dbus.service.method(_interface, in_signature=u"ay",
710
byte_arrays=True)
711
def SetSecret(self, secret):
712
"D-Bus setter method"
713
self.secret = str(secret)
714
715
# SetTimeout - method
716
@dbus.service.method(_interface, in_signature=u"t")
717
def SetTimeout(self, milliseconds):
718
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
719
# Emit D-Bus signal
720
self.PropertyChanged(dbus.String(u"timeout"),
721
(dbus.UInt64(self.timeout_milliseconds(),
722
variant_level=1)))
978
723
979
724
# Enable - method
980
725
@dbus.service.method(_interface)
999
744
def StopChecker(self):
1000
745
self.stop_checker()
1001
746
1002
## Properties
1003
1004
# ApprovalPending - property
1005
@dbus_service_property(_interface, signature="b", access="read")
1006
def ApprovalPending_dbus_property(self):
1007
return dbus.Boolean(bool(self.approvals_pending))
1008
1009
# ApprovedByDefault - property
1010
@dbus_service_property(_interface, signature="b",
1011
access="readwrite")
1012
def ApprovedByDefault_dbus_property(self, value=None):
1013
if value is None: # get
1014
return dbus.Boolean(self.approved_by_default)
1015
old_value = self.approved_by_default
1016
self.approved_by_default = bool(value)
1017
# Emit D-Bus signal
1018
if old_value != self.approved_by_default:
1019
self.PropertyChanged(dbus.String("ApprovedByDefault"),
1020
dbus.Boolean(value, variant_level=1))
1021
1022
# ApprovalDelay - property
1023
@dbus_service_property(_interface, signature="t",
1024
access="readwrite")
1025
def ApprovalDelay_dbus_property(self, value=None):
1026
if value is None: # get
1027
return dbus.UInt64(self.approval_delay_milliseconds())
1028
old_value = self.approval_delay
1029
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1030
# Emit D-Bus signal
1031
if old_value != self.approval_delay:
1032
self.PropertyChanged(dbus.String("ApprovalDelay"),
1033
dbus.UInt64(value, variant_level=1))
1034
1035
# ApprovalDuration - property
1036
@dbus_service_property(_interface, signature="t",
1037
access="readwrite")
1038
def ApprovalDuration_dbus_property(self, value=None):
1039
if value is None: # get
1040
return dbus.UInt64(self._timedelta_to_milliseconds(
1041
self.approval_duration))
1042
old_value = self.approval_duration
1043
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1044
# Emit D-Bus signal
1045
if old_value != self.approval_duration:
1046
self.PropertyChanged(dbus.String("ApprovalDuration"),
1047
dbus.UInt64(value, variant_level=1))
1048
1049
# Name - property
1050
@dbus_service_property(_interface, signature="s", access="read")
1051
def Name_dbus_property(self):
1052
return dbus.String(self.name)
1053
1054
# Fingerprint - property
1055
@dbus_service_property(_interface, signature="s", access="read")
1056
def Fingerprint_dbus_property(self):
1057
return dbus.String(self.fingerprint)
1058
1059
# Host - property
1060
@dbus_service_property(_interface, signature="s",
1061
access="readwrite")
1062
def Host_dbus_property(self, value=None):
1063
if value is None: # get
1064
return dbus.String(self.host)
1065
old_value = self.host
1066
self.host = value
1067
# Emit D-Bus signal
1068
if old_value != self.host:
1069
self.PropertyChanged(dbus.String("Host"),
1070
dbus.String(value, variant_level=1))
1071
1072
# Created - property
1073
@dbus_service_property(_interface, signature="s", access="read")
1074
def Created_dbus_property(self):
1075
return dbus.String(self._datetime_to_dbus(self.created))
1076
1077
# LastEnabled - property
1078
@dbus_service_property(_interface, signature="s", access="read")
1079
def LastEnabled_dbus_property(self):
1080
return self._datetime_to_dbus(self.last_enabled)
1081
1082
# Enabled - property
1083
@dbus_service_property(_interface, signature="b",
1084
access="readwrite")
1085
def Enabled_dbus_property(self, value=None):
1086
if value is None: # get
1087
return dbus.Boolean(self.enabled)
1088
if value:
1089
self.enable()
1090
else:
1091
self.disable()
1092
1093
# LastCheckedOK - property
1094
@dbus_service_property(_interface, signature="s",
1095
access="readwrite")
1096
def LastCheckedOK_dbus_property(self, value=None):
1097
if value is not None:
1098
self.checked_ok()
1099
return
1100
return self._datetime_to_dbus(self.last_checked_ok)
1101
1102
# Expires - property
1103
@dbus_service_property(_interface, signature="s", access="read")
1104
def Expires_dbus_property(self):
1105
return self._datetime_to_dbus(self.expires)
1106
1107
# LastApprovalRequest - property
1108
@dbus_service_property(_interface, signature="s", access="read")
1109
def LastApprovalRequest_dbus_property(self):
1110
return self._datetime_to_dbus(self.last_approval_request)
1111
1112
# Timeout - property
1113
@dbus_service_property(_interface, signature="t",
1114
access="readwrite")
1115
def Timeout_dbus_property(self, value=None):
1116
if value is None: # get
1117
return dbus.UInt64(self.timeout_milliseconds())
1118
old_value = self.timeout
1119
self.timeout = datetime.timedelta(0, 0, 0, value)
1120
# Emit D-Bus signal
1121
if old_value != self.timeout:
1122
self.PropertyChanged(dbus.String("Timeout"),
1123
dbus.UInt64(value, variant_level=1))
1124
if getattr(self, "disable_initiator_tag", None) is None:
1125
return
1126
# Reschedule timeout
1127
gobject.source_remove(self.disable_initiator_tag)
1128
self.disable_initiator_tag = None
1129
self.expires = None
1130
time_to_die = (self.
1131
_timedelta_to_milliseconds((self
1132
.last_checked_ok
1133
+ self.timeout)
1134
- datetime.datetime
1135
.utcnow()))
1136
if time_to_die <= 0:
1137
# The timeout has passed
1138
self.disable()
1139
else:
1140
self.expires = (datetime.datetime.utcnow()
1141
+ datetime.timedelta(milliseconds = time_to_die))
1142
self.disable_initiator_tag = (gobject.timeout_add
1143
(time_to_die, self.disable))
1144
1145
# ExtendedTimeout - property
1146
@dbus_service_property(_interface, signature="t",
1147
access="readwrite")
1148
def ExtendedTimeout_dbus_property(self, value=None):
1149
if value is None: # get
1150
return dbus.UInt64(self.extended_timeout_milliseconds())
1151
old_value = self.extended_timeout
1152
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1153
# Emit D-Bus signal
1154
if old_value != self.extended_timeout:
1155
self.PropertyChanged(dbus.String("ExtendedTimeout"),
1156
dbus.UInt64(value, variant_level=1))
1157
1158
# Interval - property
1159
@dbus_service_property(_interface, signature="t",
1160
access="readwrite")
1161
def Interval_dbus_property(self, value=None):
1162
if value is None: # get
1163
return dbus.UInt64(self.interval_milliseconds())
1164
old_value = self.interval
1165
self.interval = datetime.timedelta(0, 0, 0, value)
1166
# Emit D-Bus signal
1167
if old_value != self.interval:
1168
self.PropertyChanged(dbus.String("Interval"),
1169
dbus.UInt64(value, variant_level=1))
1170
if getattr(self, "checker_initiator_tag", None) is None:
1171
return
1172
# Reschedule checker run
1173
gobject.source_remove(self.checker_initiator_tag)
1174
self.checker_initiator_tag = (gobject.timeout_add
1175
(value, self.start_checker))
1176
self.start_checker() # Start one now, too
1177
1178
# Checker - property
1179
@dbus_service_property(_interface, signature="s",
1180
access="readwrite")
1181
def Checker_dbus_property(self, value=None):
1182
if value is None: # get
1183
return dbus.String(self.checker_command)
1184
old_value = self.checker_command
1185
self.checker_command = value
1186
# Emit D-Bus signal
1187
if old_value != self.checker_command:
1188
self.PropertyChanged(dbus.String("Checker"),
1189
dbus.String(self.checker_command,
1190
variant_level=1))
1191
1192
# CheckerRunning - property
1193
@dbus_service_property(_interface, signature="b",
1194
access="readwrite")
1195
def CheckerRunning_dbus_property(self, value=None):
1196
if value is None: # get
1197
return dbus.Boolean(self.checker is not None)
1198
if value:
1199
self.start_checker()
1200
else:
1201
self.stop_checker()
1202
1203
# ObjectPath - property
1204
@dbus_service_property(_interface, signature="o", access="read")
1205
def ObjectPath_dbus_property(self):
1206
return self.dbus_object_path # is already a dbus.ObjectPath
1207
1208
# Secret = property
1209
@dbus_service_property(_interface, signature="ay",
1210
access="write", byte_arrays=True)
1211
def Secret_dbus_property(self, value):
1212
self.secret = str(value)
1213
1214
747
del _interface
1215
748
1216
749
1217
class ProxyClient(object):
1218
def __init__(self, child_pipe, fpr, address):
1219
self._pipe = child_pipe
1220
self._pipe.send(('init', fpr, address))
1221
if not self._pipe.recv():
1222
raise KeyError()
1223
1224
def __getattribute__(self, name):
1225
if(name == '_pipe'):
1226
return super(ProxyClient, self).__getattribute__(name)
1227
self._pipe.send(('getattr', name))
1228
data = self._pipe.recv()
1229
if data[0] == 'data':
1230
return data[1]
1231
if data[0] == 'function':
1232
def func(*args, **kwargs):
1233
self._pipe.send(('funcall', name, args, kwargs))
1234
return self._pipe.recv()[1]
1235
return func
1236
1237
def __setattr__(self, name, value):
1238
if(name == '_pipe'):
1239
return super(ProxyClient, self).__setattr__(name, value)
1240
self._pipe.send(('setattr', name, value))
1241
1242
1243
750
class ClientHandler(socketserver.BaseRequestHandler, object):
1244
751
"""A class to handle client connections.
1245
752
1247
754
Note: This will run in its own forked process."""
1248
755
1249
756
def handle(self):
1250
with contextlib.closing(self.server.child_pipe) as child_pipe:
1251
logger.info("TCP connection from: %s",
1252
unicode(self.client_address))
1253
logger.debug("Pipe FD: %d",
1254
self.server.child_pipe.fileno())
1255
757
logger.info(u"TCP connection from: %s",
758
unicode(self.client_address))
759
logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])
760
# Open IPC pipe to parent process
761
with closing(os.fdopen(self.server.pipe[1], u"w", 1)) as ipc:
1256
762
session = (gnutls.connection
1257
763
.ClientSession(self.request,
1258
764
gnutls.connection
1259
765
.X509Credentials()))
1260
766
767
line = self.request.makefile().readline()
768
logger.debug(u"Protocol version: %r", line)
769
try:
770
if int(line.strip().split()[0]) > 1:
771
raise RuntimeError
772
except (ValueError, IndexError, RuntimeError), error:
773
logger.error(u"Unknown protocol version: %s", error)
774
return
775
1261
776
# Note: gnutls.connection.X509Credentials is really a
1262
777
# generic GnuTLS certificate credentials object so long as
1263
778
# no X.509 keys are added to it. Therefore, we can use it
1264
779
# here despite using OpenPGP certificates.
1265
1266
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1267
# "+AES-256-CBC", "+SHA1",
1268
# "+COMP-NULL", "+CTYPE-OPENPGP",
1269
# "+DHE-DSS"))
780
781
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
782
# u"+AES-256-CBC", u"+SHA1",
783
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
784
# u"+DHE-DSS"))
1270
785
# Use a fallback default, since this MUST be set.
1271
786
priority = self.server.gnutls_priority
1272
787
if priority is None:
1273
priority = "NORMAL"
788
priority = u"NORMAL"
1274
789
(gnutls.library.functions
1275
790
.gnutls_priority_set_direct(session._c_object,
1276
791
priority, None))
1277
1278
# Start communication using the Mandos protocol
1279
# Get protocol number
1280
line = self.request.makefile().readline()
1281
logger.debug("Protocol version: %r", line)
1282
try:
1283
if int(line.strip().split()[0]) > 1:
1284
raise RuntimeError
1285
except (ValueError, IndexError, RuntimeError) as error:
1286
logger.error("Unknown protocol version: %s", error)
1287
return
1288
1289
# Start GnuTLS connection
792
1290
793
try:
1291
794
session.handshake()
1292
except gnutls.errors.GNUTLSError as error:
1293
logger.warning("Handshake failed: %s", error)
795
except gnutls.errors.GNUTLSError, error:
796
logger.warning(u"Handshake failed: %s", error)
1294
797
# Do not run session.bye() here: the session is not
1295
798
# established. Just abandon the request.
1296
799
return
1297
logger.debug("Handshake succeeded")
1298
1299
approval_required = False
800
logger.debug(u"Handshake succeeded")
1300
801
try:
1301
try:
1302
fpr = self.fingerprint(self.peer_certificate
1303
(session))
1304
except (TypeError,
1305
gnutls.errors.GNUTLSError) as error:
1306
logger.warning("Bad certificate: %s", error)
1307
return
1308
logger.debug("Fingerprint: %s", fpr)
1309
1310
try:
1311
client = ProxyClient(child_pipe, fpr,
1312
self.client_address)
1313
except KeyError:
1314
return
1315
1316
if client.approval_delay:
1317
delay = client.approval_delay
1318
client.approvals_pending += 1
1319
approval_required = True
1320
1321
while True:
1322
if not client.enabled:
1323
logger.info("Client %s is disabled",
1324
client.name)
1325
if self.server.use_dbus:
1326
# Emit D-Bus signal
1327
client.Rejected("Disabled")
1328
return
1329
1330
if client._approved or not client.approval_delay:
1331
#We are approved or approval is disabled
1332
break
1333
elif client._approved is None:
1334
logger.info("Client %s needs approval",
1335
client.name)
1336
if self.server.use_dbus:
1337
# Emit D-Bus signal
1338
client.NeedApproval(
1339
client.approval_delay_milliseconds(),
1340
client.approved_by_default)
1341
else:
1342
logger.warning("Client %s was not approved",
1343
client.name)
1344
if self.server.use_dbus:
1345
# Emit D-Bus signal
1346
client.Rejected("Denied")
1347
return
1348
1349
#wait until timeout or approved
1350
#x = float(client._timedelta_to_milliseconds(delay))
1351
time = datetime.datetime.now()
1352
client.changedstate.acquire()
1353
client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))
1354
client.changedstate.release()
1355
time2 = datetime.datetime.now()
1356
if (time2 - time) >= delay:
1357
if not client.approved_by_default:
1358
logger.warning("Client %s timed out while"
1359
" waiting for approval",
1360
client.name)
1361
if self.server.use_dbus:
1362
# Emit D-Bus signal
1363
client.Rejected("Approval timed out")
1364
return
1365
else:
1366
break
1367
else:
1368
delay -= time2 - time
1369
1370
sent_size = 0
1371
while sent_size < len(client.secret):
1372
try:
1373
sent = session.send(client.secret[sent_size:])
1374
except gnutls.errors.GNUTLSError as error:
1375
logger.warning("gnutls send failed")
1376
return
1377
logger.debug("Sent: %d, remaining: %d",
1378
sent, len(client.secret)
1379
- (sent_size + sent))
1380
sent_size += sent
1381
1382
logger.info("Sending secret to %s", client.name)
1383
# bump the timeout as if seen
1384
client.checked_ok(client.extended_timeout)
1385
if self.server.use_dbus:
1386
# Emit D-Bus signal
1387
client.GotSecret()
802
fpr = self.fingerprint(self.peer_certificate(session))
803
except (TypeError, gnutls.errors.GNUTLSError), error:
804
logger.warning(u"Bad certificate: %s", error)
805
session.bye()
806
return
807
logger.debug(u"Fingerprint: %s", fpr)
1388
808
1389
finally:
1390
if approval_required:
1391
client.approvals_pending -= 1
1392
try:
1393
session.bye()
1394
except gnutls.errors.GNUTLSError as error:
1395
logger.warning("GnuTLS bye failed")
809
for c in self.server.clients:
810
if c.fingerprint == fpr:
811
client = c
812
break
813
else:
814
ipc.write(u"NOTFOUND %s\n" % fpr)
815
session.bye()
816
return
817
# Have to check if client.still_valid(), since it is
818
# possible that the client timed out while establishing
819
# the GnuTLS session.
820
if not client.still_valid():
821
ipc.write(u"INVALID %s\n" % client.name)
822
session.bye()
823
return
824
ipc.write(u"SENDING %s\n" % client.name)
825
sent_size = 0
826
while sent_size < len(client.secret):
827
sent = session.send(client.secret[sent_size:])
828
logger.debug(u"Sent: %d, remaining: %d",
829
sent, len(client.secret)
830
- (sent_size + sent))
831
sent_size += sent
832
session.bye()
1396
833
1397
834
@staticmethod
1398
835
def peer_certificate(session):
1408
845
.gnutls_certificate_get_peers
1409
846
(session._c_object, ctypes.byref(list_size)))
1410
847
if not bool(cert_list) and list_size.value != 0:
1411
raise gnutls.errors.GNUTLSError("error getting peer"
1412
" certificate")
848
raise gnutls.errors.GNUTLSError(u"error getting peer"
849
u" certificate")
1413
850
if list_size.value == 0:
1414
851
return None
1415
852
cert = cert_list[0]
1441
878
if crtverify.value != 0:
1442
879
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1443
880
raise (gnutls.errors.CertificateSecurityError
1444
("Verify failed"))
881
(u"Verify failed"))
1445
882
# New buffer for the fingerprint
1446
883
buf = ctypes.create_string_buffer(20)
1447
884
buf_len = ctypes.c_size_t()
1454
891
# Convert the buffer to a Python bytestring
1455
892
fpr = ctypes.string_at(buf, buf_len.value)
1456
893
# Convert the bytestring to hexadecimal notation
1457
hex_fpr = ''.join("%02X" % ord(char) for char in fpr)
894
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
1458
895
return hex_fpr
1459
896
1460
897
1461
class MultiprocessingMixIn(object):
1462
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1463
def sub_process_main(self, request, address):
1464
try:
1465
self.finish_request(request, address)
1466
except:
1467
self.handle_error(request, address)
1468
self.close_request(request)
1469
1470
def process_request(self, request, address):
1471
"""Start a new process to process the request."""
1472
multiprocessing.Process(target = self.sub_process_main,
1473
args = (request, address)).start()
1474
1475
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1476
""" adds a pipe to the MixIn """
898
class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):
899
"""Like socketserver.ForkingMixIn, but also pass a pipe."""
1477
900
def process_request(self, request, client_address):
1478
901
"""Overrides and wraps the original process_request().
1479
902
1480
This function creates a new pipe in self.pipe
903
This function creates a new pipe in self.pipe
1481
904
"""
1482
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1483
1484
super(MultiprocessingMixInWithPipe,
905
self.pipe = os.pipe()
906
super(ForkingMixInWithPipe,
1485
907
self).process_request(request, client_address)
1486
self.child_pipe.close()
1487
self.add_pipe(parent_pipe)
1488
1489
def add_pipe(self, parent_pipe):
908
os.close(self.pipe[1]) # close write end
909
self.add_pipe(self.pipe[0])
910
def add_pipe(self, pipe):
1490
911
"""Dummy function; override as necessary"""
1491
raise NotImplementedError
1492
1493
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
912
os.close(pipe)
913
914
915
class IPv6_TCPServer(ForkingMixInWithPipe,
1494
916
socketserver.TCPServer, object):
1495
917
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
1496
918
1512
934
bind to an address or port if they were not specified."""
1513
935
if self.interface is not None:
1514
936
if SO_BINDTODEVICE is None:
1515
logger.error("SO_BINDTODEVICE does not exist;"
1516
" cannot bind to interface %s",
937
logger.error(u"SO_BINDTODEVICE does not exist;"
938
u" cannot bind to interface %s",
1517
939
self.interface)
1518
940
else:
1519
941
try:
1520
942
self.socket.setsockopt(socket.SOL_SOCKET,
1521
943
SO_BINDTODEVICE,
1522
944
str(self.interface
1523
+ '\0'))
1524
except socket.error as error:
945
+ u'\0'))
946
except socket.error, error:
1525
947
if error[0] == errno.EPERM:
1526
logger.error("No permission to"
1527
" bind to interface %s",
948
logger.error(u"No permission to"
949
u" bind to interface %s",
1528
950
self.interface)
1529
951
elif error[0] == errno.ENOPROTOOPT:
1530
logger.error("SO_BINDTODEVICE not available;"
1531
" cannot bind to interface %s",
952
logger.error(u"SO_BINDTODEVICE not available;"
953
u" cannot bind to interface %s",
1532
954
self.interface)
1533
955
else:
1534
956
raise
1536
958
if self.server_address[0] or self.server_address[1]:
1537
959
if not self.server_address[0]:
1538
960
if self.address_family == socket.AF_INET6:
1539
any_address = "::" # in6addr_any
961
any_address = u"::" # in6addr_any
1540
962
else:
1541
963
any_address = socket.INADDR_ANY
1542
964
self.server_address = (any_address,
1560
982
clients: set of Client objects
1561
983
gnutls_priority GnuTLS priority string
1562
984
use_dbus: Boolean; to emit D-Bus signals or not
985
clients: set of Client objects
986
gnutls_priority GnuTLS priority string
987
use_dbus: Boolean; to emit D-Bus signals or not
1563
988
1564
989
Assumes a gobject.MainLoop event loop.
1565
990
"""
1581
1006
return socketserver.TCPServer.server_activate(self)
1582
1007
def enable(self):
1583
1008
self.enabled = True
1584
def add_pipe(self, parent_pipe):
1009
def add_pipe(self, pipe):
1585
1010
# Call "handle_ipc" for both data and EOF events
1586
gobject.io_add_watch(parent_pipe.fileno(),
1587
gobject.IO_IN | gobject.IO_HUP,
1588
functools.partial(self.handle_ipc,
1589
parent_pipe = parent_pipe))
1590
1591
def handle_ipc(self, source, condition, parent_pipe=None,
1592
client_object=None):
1011
gobject.io_add_watch(pipe, gobject.IO_IN | gobject.IO_HUP,
1012
self.handle_ipc)
1013
def handle_ipc(self, source, condition, file_objects={}):
1593
1014
condition_names = {
1594
gobject.IO_IN: "IN", # There is data to read.
1595
gobject.IO_OUT: "OUT", # Data can be written (without
1015
gobject.IO_IN: u"IN", # There is data to read.
1016
gobject.IO_OUT: u"OUT", # Data can be written (without
1596
1017
# blocking).
1597
gobject.IO_PRI: "PRI", # There is urgent data to read.
1598
gobject.IO_ERR: "ERR", # Error condition.
1599
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1018
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1019
gobject.IO_ERR: u"ERR", # Error condition.
1020
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1600
1021
# broken, usually for pipes and
1601
1022
# sockets).
1602
1023
}
1604
1025
for cond, name in
1605
1026
condition_names.iteritems()
1606
1027
if cond & condition)
1607
# error or the other end of multiprocessing.Pipe has closed
1608
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1609
return False
1610
1611
# Read a request from the child
1612
request = parent_pipe.recv()
1613
command = request[0]
1614
1615
if command == 'init':
1616
fpr = request[1]
1617
address = request[2]
1618
1619
for c in self.clients:
1620
if c.fingerprint == fpr:
1621
client = c
1622
break
1623
else:
1624
logger.info("Client not found for fingerprint: %s, ad"
1625
"dress: %s", fpr, address)
1626
if self.use_dbus:
1627
# Emit D-Bus signal
1628
mandos_dbus_service.ClientNotFound(fpr, address[0])
1629
parent_pipe.send(False)
1630
return False
1631
1632
gobject.io_add_watch(parent_pipe.fileno(),
1633
gobject.IO_IN | gobject.IO_HUP,
1634
functools.partial(self.handle_ipc,
1635
parent_pipe = parent_pipe,
1636
client_object = client))
1637
parent_pipe.send(True)
1638
# remove the old hook in favor of the new above hook on same fileno
1639
return False
1640
if command == 'funcall':
1641
funcname = request[1]
1642
args = request[2]
1643
kwargs = request[3]
1644
1645
parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))
1646
1647
if command == 'getattr':
1648
attrname = request[1]
1649
if callable(client_object.__getattribute__(attrname)):
1650
parent_pipe.send(('function',))
1651
else:
1652
parent_pipe.send(('data', client_object.__getattribute__(attrname)))
1653
1654
if command == 'setattr':
1655
attrname = request[1]
1656
value = request[2]
1657
setattr(client_object, attrname, value)
1658
1028
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1029
conditions_string)
1030
1031
# Turn the pipe file descriptor into a Python file object
1032
if source not in file_objects:
1033
file_objects[source] = os.fdopen(source, u"r", 1)
1034
1035
# Read a line from the file object
1036
cmdline = file_objects[source].readline()
1037
if not cmdline: # Empty line means end of file
1038
# close the IPC pipe
1039
file_objects[source].close()
1040
del file_objects[source]
1041
1042
# Stop calling this function
1043
return False
1044
1045
logger.debug(u"IPC command: %r", cmdline)
1046
1047
# Parse and act on command
1048
cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)
1049
1050
if cmd == u"NOTFOUND":
1051
logger.warning(u"Client not found for fingerprint: %s",
1052
args)
1053
if self.use_dbus:
1054
# Emit D-Bus signal
1055
mandos_dbus_service.ClientNotFound(args)
1056
elif cmd == u"INVALID":
1057
for client in self.clients:
1058
if client.name == args:
1059
logger.warning(u"Client %s is invalid", args)
1060
if self.use_dbus:
1061
# Emit D-Bus signal
1062
client.Rejected()
1063
break
1064
else:
1065
logger.error(u"Unknown client %s is invalid", args)
1066
elif cmd == u"SENDING":
1067
for client in self.clients:
1068
if client.name == args:
1069
logger.info(u"Sending secret to %s", client.name)
1070
client.checked_ok()
1071
if self.use_dbus:
1072
# Emit D-Bus signal
1073
client.ReceivedSecret()
1074
break
1075
else:
1076
logger.error(u"Sending secret to unknown client %s",
1077
args)
1078
else:
1079
logger.error(u"Unknown IPC command: %r", cmdline)
1080
1081
# Keep calling this function
1659
1082
return True
1660
1083
1661
1084
1662
1085
def string_to_delta(interval):
1663
1086
"""Parse a string and return a datetime.timedelta
1664
1087
1665
>>> string_to_delta('7d')
1088
>>> string_to_delta(u'7d')
1666
1089
datetime.timedelta(7)
1667
>>> string_to_delta('60s')
1090
>>> string_to_delta(u'60s')
1668
1091
datetime.timedelta(0, 60)
1669
>>> string_to_delta('60m')
1092
>>> string_to_delta(u'60m')
1670
1093
datetime.timedelta(0, 3600)
1671
>>> string_to_delta('24h')
1094
>>> string_to_delta(u'24h')
1672
1095
datetime.timedelta(1)
1673
>>> string_to_delta('1w')
1096
>>> string_to_delta(u'1w')
1674
1097
datetime.timedelta(7)
1675
>>> string_to_delta('5m 30s')
1098
>>> string_to_delta(u'5m 30s')
1676
1099
datetime.timedelta(0, 330)
1677
1100
"""
1678
1101
timevalue = datetime.timedelta(0)
1680
1103
try:
1681
1104
suffix = unicode(s[-1])
1682
1105
value = int(s[:-1])
1683
if suffix == "d":
1106
if suffix == u"d":
1684
1107
delta = datetime.timedelta(value)
1685
elif suffix == "s":
1108
elif suffix == u"s":
1686
1109
delta = datetime.timedelta(0, value)
1687
elif suffix == "m":
1110
elif suffix == u"m":
1688
1111
delta = datetime.timedelta(0, 0, 0, 0, value)
1689
elif suffix == "h":
1112
elif suffix == u"h":
1690
1113
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1691
elif suffix == "w":
1114
elif suffix == u"w":
1692
1115
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1693
1116
else:
1694
raise ValueError("Unknown suffix %r" % suffix)
1695
except (ValueError, IndexError) as e:
1696
raise ValueError(*(e.args))
1117
raise ValueError
1118
except (ValueError, IndexError):
1119
raise ValueError
1697
1120
timevalue += delta
1698
1121
return timevalue
1699
1122
1705
1128
global if_nametoindex
1706
1129
try:
1707
1130
if_nametoindex = (ctypes.cdll.LoadLibrary
1708
(ctypes.util.find_library("c"))
1131
(ctypes.util.find_library(u"c"))
1709
1132
.if_nametoindex)
1710
1133
except (OSError, AttributeError):
1711
logger.warning("Doing if_nametoindex the hard way")
1134
logger.warning(u"Doing if_nametoindex the hard way")
1712
1135
def if_nametoindex(interface):
1713
1136
"Get an interface index the hard way, i.e. using fcntl()"
1714
1137
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1715
with contextlib.closing(socket.socket()) as s:
1138
with closing(socket.socket()) as s:
1716
1139
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1717
struct.pack(str("16s16x"),
1140
struct.pack(str(u"16s16x"),
1718
1141
interface))
1719
interface_index = struct.unpack(str("I"),
1142
interface_index = struct.unpack(str(u"I"),
1720
1143
ifreq[16:20])[0]
1721
1144
return interface_index
1722
1145
return if_nametoindex(interface)
1730
1153
sys.exit()
1731
1154
os.setsid()
1732
1155
if not nochdir:
1733
os.chdir("/")
1156
os.chdir(u"/")
1734
1157
if os.fork():
1735
1158
sys.exit()
1736
1159
if not noclose:
1738
1161
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1739
1162
if not stat.S_ISCHR(os.fstat(null).st_mode):
1740
1163
raise OSError(errno.ENODEV,
1741
"%s not a character device"
1742
% os.path.devnull)
1164
u"/dev/null not a character device")
1743
1165
os.dup2(null, sys.stdin.fileno())
1744
1166
os.dup2(null, sys.stdout.fileno())
1745
1167
os.dup2(null, sys.stderr.fileno())
1749
1171
1750
1172
def main():
1751
1173
1752
##################################################################
1174
######################################################################
1753
1175
# Parsing of options, both command line and config file
1754
1176
1755
parser = argparse.ArgumentParser()
1756
parser.add_argument("-v", "--version", action="version",
1757
version = "%%(prog)s %s" % version,
1758
help="show version number and exit")
1759
parser.add_argument("-i", "--interface", metavar="IF",
1760
help="Bind to interface IF")
1761
parser.add_argument("-a", "--address",
1762
help="Address to listen for requests on")
1763
parser.add_argument("-p", "--port", type=int,
1764
help="Port number to receive requests on")
1765
parser.add_argument("--check", action="store_true",
1766
help="Run self-test")
1767
parser.add_argument("--debug", action="store_true",
1768
help="Debug mode; run in foreground and log"
1769
" to terminal")
1770
parser.add_argument("--debuglevel", metavar="LEVEL",
1771
help="Debug level for stdout output")
1772
parser.add_argument("--priority", help="GnuTLS"
1773
" priority string (see GnuTLS documentation)")
1774
parser.add_argument("--servicename",
1775
metavar="NAME", help="Zeroconf service name")
1776
parser.add_argument("--configdir",
1777
default="/etc/mandos", metavar="DIR",
1778
help="Directory to search for configuration"
1779
" files")
1780
parser.add_argument("--no-dbus", action="store_false",
1781
dest="use_dbus", help="Do not provide D-Bus"
1782
" system bus interface")
1783
parser.add_argument("--no-ipv6", action="store_false",
1784
dest="use_ipv6", help="Do not use IPv6")
1785
options = parser.parse_args()
1177
parser = optparse.OptionParser(version = "%%prog %s" % version)
1178
parser.add_option("-i", u"--interface", type=u"string",
1179
metavar="IF", help=u"Bind to interface IF")
1180
parser.add_option("-a", u"--address", type=u"string",
1181
help=u"Address to listen for requests on")
1182
parser.add_option("-p", u"--port", type=u"int",
1183
help=u"Port number to receive requests on")
1184
parser.add_option("--check", action=u"store_true",
1185
help=u"Run self-test")
1186
parser.add_option("--debug", action=u"store_true",
1187
help=u"Debug mode; run in foreground and log to"
1188
u" terminal")
1189
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1190
u" priority string (see GnuTLS documentation)")
1191
parser.add_option("--servicename", type=u"string",
1192
metavar=u"NAME", help=u"Zeroconf service name")
1193
parser.add_option("--configdir", type=u"string",
1194
default=u"/etc/mandos", metavar=u"DIR",
1195
help=u"Directory to search for configuration"
1196
u" files")
1197
parser.add_option("--no-dbus", action=u"store_false",
1198
dest=u"use_dbus", help=u"Do not provide D-Bus"
1199
u" system bus interface")
1200
parser.add_option("--no-ipv6", action=u"store_false",
1201
dest=u"use_ipv6", help=u"Do not use IPv6")
1202
options = parser.parse_args()[0]
1786
1203
1787
1204
if options.check:
1788
1205
import doctest
1790
1207
sys.exit()
1791
1208
1792
1209
# Default values for config file for server-global settings
1793
server_defaults = { "interface": "",
1794
"address": "",
1795
"port": "",
1796
"debug": "False",
1797
"priority":
1798
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1799
"servicename": "Mandos",
1800
"use_dbus": "True",
1801
"use_ipv6": "True",
1802
"debuglevel": "",
1210
server_defaults = { u"interface": u"",
1211
u"address": u"",
1212
u"port": u"",
1213
u"debug": u"False",
1214
u"priority":
1215
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1216
u"servicename": u"Mandos",
1217
u"use_dbus": u"True",
1218
u"use_ipv6": u"True",
1803
1219
}
1804
1220
1805
1221
# Parse config file for server-global settings
1806
1222
server_config = configparser.SafeConfigParser(server_defaults)
1807
1223
del server_defaults
1808
1224
server_config.read(os.path.join(options.configdir,
1809
"mandos.conf"))
1225
u"mandos.conf"))
1810
1226
# Convert the SafeConfigParser object to a dict
1811
1227
server_settings = server_config.defaults()
1812
1228
# Use the appropriate methods on the non-string config options
1813
for option in ("debug", "use_dbus", "use_ipv6"):
1814
server_settings[option] = server_config.getboolean("DEFAULT",
1229
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1230
server_settings[option] = server_config.getboolean(u"DEFAULT",
1815
1231
option)
1816
1232
if server_settings["port"]:
1817
server_settings["port"] = server_config.getint("DEFAULT",
1818
"port")
1233
server_settings["port"] = server_config.getint(u"DEFAULT",
1234
u"port")
1819
1235
del server_config
1820
1236
1821
1237
# Override the settings from the config file with command line
1822
1238
# options, if set.
1823
for option in ("interface", "address", "port", "debug",
1824
"priority", "servicename", "configdir",
1825
"use_dbus", "use_ipv6", "debuglevel"):
1239
for option in (u"interface", u"address", u"port", u"debug",
1240
u"priority", u"servicename", u"configdir",
1241
u"use_dbus", u"use_ipv6"):
1826
1242
value = getattr(options, option)
1827
1243
if value is not None:
1828
1244
server_settings[option] = value
1836
1252
##################################################################
1837
1253
1838
1254
# For convenience
1839
debug = server_settings["debug"]
1840
debuglevel = server_settings["debuglevel"]
1841
use_dbus = server_settings["use_dbus"]
1842
use_ipv6 = server_settings["use_ipv6"]
1843
1844
if server_settings["servicename"] != "Mandos":
1255
debug = server_settings[u"debug"]
1256
use_dbus = server_settings[u"use_dbus"]
1257
use_ipv6 = server_settings[u"use_ipv6"]
1258
1259
if not debug:
1260
syslogger.setLevel(logging.WARNING)
1261
console.setLevel(logging.WARNING)
1262
1263
if server_settings[u"servicename"] != u"Mandos":
1845
1264
syslogger.setFormatter(logging.Formatter
1846
('Mandos (%s) [%%(process)d]:'
1847
' %%(levelname)s: %%(message)s'
1848
% server_settings["servicename"]))
1265
(u'Mandos (%s) [%%(process)d]:'
1266
u' %%(levelname)s: %%(message)s'
1267
% server_settings[u"servicename"]))
1849
1268
1850
1269
# Parse config file with clients
1851
client_defaults = { "timeout": "5m",
1852
"extended_timeout": "15m",
1853
"interval": "2m",
1854
"checker": "fping -q -- %%(host)s",
1855
"host": "",
1856
"approval_delay": "0s",
1857
"approval_duration": "1s",
1270
client_defaults = { u"timeout": u"1h",
1271
u"interval": u"5m",
1272
u"checker": u"fping -q -- %%(host)s",
1273
u"host": u"",
1858
1274
}
1859
1275
client_config = configparser.SafeConfigParser(client_defaults)
1860
client_config.read(os.path.join(server_settings["configdir"],
1861
"clients.conf"))
1276
client_config.read(os.path.join(server_settings[u"configdir"],
1277
u"clients.conf"))
1862
1278
1863
1279
global mandos_dbus_service
1864
1280
mandos_dbus_service = None
1865
1281
1866
tcp_server = MandosServer((server_settings["address"],
1867
server_settings["port"]),
1282
tcp_server = MandosServer((server_settings[u"address"],
1283
server_settings[u"port"]),
1868
1284
ClientHandler,
1869
interface=(server_settings["interface"]
1870
or None),
1285
interface=server_settings[u"interface"],
1871
1286
use_ipv6=use_ipv6,
1872
1287
gnutls_priority=
1873
server_settings["priority"],
1288
server_settings[u"priority"],
1874
1289
use_dbus=use_dbus)
1875
if not debug:
1876
pidfilename = "/var/run/mandos.pid"
1877
try:
1878
pidfile = open(pidfilename, "w")
1879
except IOError:
1880
logger.error("Could not open file %r", pidfilename)
1290
pidfilename = u"/var/run/mandos.pid"
1291
try:
1292
pidfile = open(pidfilename, u"w")
1293
except IOError:
1294
logger.error(u"Could not open file %r", pidfilename)
1881
1295
1882
1296
try:
1883
uid = pwd.getpwnam("_mandos").pw_uid
1884
gid = pwd.getpwnam("_mandos").pw_gid
1297
uid = pwd.getpwnam(u"_mandos").pw_uid
1298
gid = pwd.getpwnam(u"_mandos").pw_gid
1885
1299
except KeyError:
1886
1300
try:
1887
uid = pwd.getpwnam("mandos").pw_uid
1888
gid = pwd.getpwnam("mandos").pw_gid
1301
uid = pwd.getpwnam(u"mandos").pw_uid
1302
gid = pwd.getpwnam(u"mandos").pw_gid
1889
1303
except KeyError:
1890
1304
try:
1891
uid = pwd.getpwnam("nobody").pw_uid
1892
gid = pwd.getpwnam("nobody").pw_gid
1305
uid = pwd.getpwnam(u"nobody").pw_uid
1306
gid = pwd.getpwnam(u"nobody").pw_gid
1893
1307
except KeyError:
1894
1308
uid = 65534
1895
1309
gid = 65534
1896
1310
try:
1897
1311
os.setgid(gid)
1898
1312
os.setuid(uid)
1899
except OSError as error:
1313
except OSError, error:
1900
1314
if error[0] != errno.EPERM:
1901
1315
raise error
1902
1316
1903
if not debug and not debuglevel:
1904
syslogger.setLevel(logging.WARNING)
1905
console.setLevel(logging.WARNING)
1906
if debuglevel:
1907
level = getattr(logging, debuglevel.upper())
1908
syslogger.setLevel(level)
1909
console.setLevel(level)
1910
1317
# Enable all possible GnuTLS debugging
1911
1318
if debug:
1912
# Enable all possible GnuTLS debugging
1913
1914
1319
# "Use a log level over 10 to enable all debugging options."
1915
1320
# - GnuTLS manual
1916
1321
gnutls.library.functions.gnutls_global_set_log_level(11)
1917
1322
1918
1323
@gnutls.library.types.gnutls_log_func
1919
1324
def debug_gnutls(level, string):
1920
logger.debug("GnuTLS: %s", string[:-1])
1325
logger.debug(u"GnuTLS: %s", string[:-1])
1921
1326
1922
1327
(gnutls.library.functions
1923
1328
.gnutls_global_set_log_function(debug_gnutls))
1924
1925
# Redirect stdin so all checkers get /dev/null
1926
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1927
os.dup2(null, sys.stdin.fileno())
1928
if null > 2:
1929
os.close(null)
1930
else:
1931
# No console logging
1932
logger.removeHandler(console)
1933
1934
# Need to fork before connecting to D-Bus
1935
if not debug:
1936
# Close all input and output, do double fork, etc.
1937
daemon()
1938
1329
1939
1330
global main_loop
1940
1331
# From the Avahi example code
1943
1334
bus = dbus.SystemBus()
1944
1335
# End of Avahi example code
1945
1336
if use_dbus:
1946
try:
1947
bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",
1948
bus, do_not_queue=True)
1949
except dbus.exceptions.NameExistsException as e:
1950
logger.error(unicode(e) + ", disabling D-Bus")
1951
use_dbus = False
1952
server_settings["use_dbus"] = False
1953
tcp_server.use_dbus = False
1337
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
1954
1338
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1955
service = AvahiService(name = server_settings["servicename"],
1956
servicetype = "_mandos._tcp",
1339
service = AvahiService(name = server_settings[u"servicename"],
1340
servicetype = u"_mandos._tcp",
1957
1341
protocol = protocol, bus = bus)
1958
1342
if server_settings["interface"]:
1959
1343
service.interface = (if_nametoindex
1960
(str(server_settings["interface"])))
1961
1962
global multiprocessing_manager
1963
multiprocessing_manager = multiprocessing.Manager()
1344
(str(server_settings[u"interface"])))
1964
1345
1965
1346
client_class = Client
1966
1347
if use_dbus:
1967
1348
client_class = functools.partial(ClientDBus, bus = bus)
1968
def client_config_items(config, section):
1969
special_settings = {
1970
"approved_by_default":
1971
lambda: config.getboolean(section,
1972
"approved_by_default"),
1973
}
1974
for name, value in config.items(section):
1975
try:
1976
yield (name, special_settings[name]())
1977
except KeyError:
1978
yield (name, value)
1979
1980
1349
tcp_server.clients.update(set(
1981
1350
client_class(name = section,
1982
config= dict(client_config_items(
1983
client_config, section)))
1351
config= dict(client_config.items(section)))
1984
1352
for section in client_config.sections()))
1985
1353
if not tcp_server.clients:
1986
logger.warning("No clients defined")
1354
logger.warning(u"No clients defined")
1355
1356
if debug:
1357
# Redirect stdin so all checkers get /dev/null
1358
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1359
os.dup2(null, sys.stdin.fileno())
1360
if null > 2:
1361
os.close(null)
1362
else:
1363
# No console logging
1364
logger.removeHandler(console)
1365
# Close all input and output, do double fork, etc.
1366
daemon()
1367
1368
try:
1369
with closing(pidfile):
1370
pid = os.getpid()
1371
pidfile.write(str(pid) + "\n")
1372
del pidfile
1373
except IOError:
1374
logger.error(u"Could not write to file %r with PID %d",
1375
pidfilename, pid)
1376
except NameError:
1377
# "pidfile" was never created
1378
pass
1379
del pidfilename
1380
1381
def cleanup():
1382
"Cleanup function; run on exit"
1383
service.cleanup()
1987
1384
1385
while tcp_server.clients:
1386
client = tcp_server.clients.pop()
1387
client.disable_hook = None
1388
client.disable()
1389
1390
atexit.register(cleanup)
1391
1988
1392
if not debug:
1989
try:
1990
with pidfile:
1991
pid = os.getpid()
1992
pidfile.write(str(pid) + "\n".encode("utf-8"))
1993
del pidfile
1994
except IOError:
1995
logger.error("Could not write to file %r with PID %d",
1996
pidfilename, pid)
1997
except NameError:
1998
# "pidfile" was never created
1999
pass
2000
del pidfilename
2001
2002
1393
signal.signal(signal.SIGINT, signal.SIG_IGN)
2003
2004
1394
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2005
1395
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2006
1396
2008
1398
class MandosDBusService(dbus.service.Object):
2009
1399
"""A D-Bus proxy object"""
2010
1400
def __init__(self):
2011
dbus.service.Object.__init__(self, bus, "/")
2012
_interface = "se.bsnet.fukt.Mandos"
2013
2014
@dbus.service.signal(_interface, signature="o")
2015
def ClientAdded(self, objpath):
2016
"D-Bus signal"
2017
pass
2018
2019
@dbus.service.signal(_interface, signature="ss")
2020
def ClientNotFound(self, fingerprint, address):
2021
"D-Bus signal"
2022
pass
2023
2024
@dbus.service.signal(_interface, signature="os")
1401
dbus.service.Object.__init__(self, bus, u"/")
1402
_interface = u"se.bsnet.fukt.Mandos"
1403
1404
@dbus.service.signal(_interface, signature=u"oa{sv}")
1405
def ClientAdded(self, objpath, properties):
1406
"D-Bus signal"
1407
pass
1408
1409
@dbus.service.signal(_interface, signature=u"s")
1410
def ClientNotFound(self, fingerprint):
1411
"D-Bus signal"
1412
pass
1413
1414
@dbus.service.signal(_interface, signature=u"os")
2025
1415
def ClientRemoved(self, objpath, name):
2026
1416
"D-Bus signal"
2027
1417
pass
2028
1418
2029
@dbus.service.method(_interface, out_signature="ao")
1419
@dbus.service.method(_interface, out_signature=u"ao")
2030
1420
def GetAllClients(self):
2031
1421
"D-Bus method"
2032
1422
return dbus.Array(c.dbus_object_path
2033
1423
for c in tcp_server.clients)
2034
1424
2035
1425
@dbus.service.method(_interface,
2036
out_signature="a{oa{sv}}")
1426
out_signature=u"a{oa{sv}}")
2037
1427
def GetAllClientsWithProperties(self):
2038
1428
"D-Bus method"
2039
1429
return dbus.Dictionary(
2040
((c.dbus_object_path, c.GetAll(""))
1430
((c.dbus_object_path, c.GetAllProperties())
2041
1431
for c in tcp_server.clients),
2042
signature="oa{sv}")
1432
signature=u"oa{sv}")
2043
1433
2044
@dbus.service.method(_interface, in_signature="o")
1434
@dbus.service.method(_interface, in_signature=u"o")
2045
1435
def RemoveClient(self, object_path):
2046
1436
"D-Bus method"
2047
1437
for c in tcp_server.clients:
2049
1439
tcp_server.clients.remove(c)
2050
1440
c.remove_from_connection()
2051
1441
# Don't signal anything except ClientRemoved
2052
c.disable(quiet=True)
1442
c.disable(signal=False)
2053
1443
# Emit D-Bus signal
2054
1444
self.ClientRemoved(object_path, c.name)
2055
1445
return
2056
raise KeyError(object_path)
1446
raise KeyError
2057
1447
2058
1448
del _interface
2059
1449
2060
1450
mandos_dbus_service = MandosDBusService()
2061
1451
2062
def cleanup():
2063
"Cleanup function; run on exit"
2064
service.cleanup()
2065
2066
while tcp_server.clients:
2067
client = tcp_server.clients.pop()
2068
if use_dbus:
2069
client.remove_from_connection()
2070
client.disable_hook = None
2071
# Don't signal anything except ClientRemoved
2072
client.disable(quiet=True)
2073
if use_dbus:
2074
# Emit D-Bus signal
2075
mandos_dbus_service.ClientRemoved(client.dbus_object_path,
2076
client.name)
2077
2078
atexit.register(cleanup)
2079
2080
1452
for client in tcp_server.clients:
2081
1453
if use_dbus:
2082
1454
# Emit D-Bus signal
2083
mandos_dbus_service.ClientAdded(client.dbus_object_path)
1455
mandos_dbus_service.ClientAdded(client.dbus_object_path,
1456
client.GetAllProperties())
2084
1457
client.enable()
2085
1458
2086
1459
tcp_server.enable()
2089
1462
# Find out what port we got
2090
1463
service.port = tcp_server.socket.getsockname()[1]
2091
1464
if use_ipv6:
2092
logger.info("Now listening on address %r, port %d,"
1465
logger.info(u"Now listening on address %r, port %d,"
2093
1466
" flowinfo %d, scope_id %d"
2094
1467
% tcp_server.socket.getsockname())
2095
1468
else: # IPv4
2096
logger.info("Now listening on address %r, port %d"
1469
logger.info(u"Now listening on address %r, port %d"
2097
1470
% tcp_server.socket.getsockname())
2098
1471
2099
1472
#service.interface = tcp_server.socket.getsockname()[3]
2102
1475
# From the Avahi example code
2103
1476
try:
2104
1477
service.activate()
2105
except dbus.exceptions.DBusException as error:
2106
logger.critical("DBusException: %s", error)
2107
cleanup()
1478
except dbus.exceptions.DBusException, error:
1479
logger.critical(u"DBusException: %s", error)
2108
1480
sys.exit(1)
2109
1481
# End of Avahi example code
2110
1482
2113
1485
(tcp_server.handle_request
2114
1486
(*args[2:], **kwargs) or True))
2115
1487
2116
logger.debug("Starting main loop")
1488
logger.debug(u"Starting main loop")
2117
1489
main_loop.run()
2118
except AvahiError as error:
2119
logger.critical("AvahiError: %s", error)
2120
cleanup()
1490
except AvahiError, error:
1491
logger.critical(u"AvahiError: %s", error)
2121
1492
sys.exit(1)
2122
1493
except KeyboardInterrupt:
2123
1494
if debug:
2124
print("", file=sys.stderr)
2125
logger.debug("Server received KeyboardInterrupt")
2126
logger.debug("Server exiting")
2127
# Must run before the D-Bus bus name gets deregistered
2128
cleanup()
1495
print >> sys.stderr
1496
logger.debug(u"Server received KeyboardInterrupt")
1497
logger.debug(u"Server exiting")
2129
1498
2130
1499
if __name__ == '__main__':
2131
1500
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0