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