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