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.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 502.1.1
- Committer: Teddy Hogeborn
- Date: 2011-09-26 21:06:14 UTC
- mto: This revision was merged to the branch mainline in revision 503.
- Revision ID: teddy@fukt.bsnet.se-20110926210614-tvxkpb6xfhkq3gc3
* mandos: White space fixes only.
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.2.1"
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))
312
runtime_expansions = ("approval_delay", "approval_duration",
313
"created", "enabled", "fingerprint",
314
"host", "interval", "last_checked_ok",
315
"last_enabled", "name", "timeout")
286
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)
294
327
return _timedelta_to_milliseconds(self.interval)
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
565
def dbus_service_property(dbus_interface, signature="v",
566
access="readwrite", byte_arrays=False):
525
567
"""Decorators for marking methods of a DBusObjectWithProperties to
526
568
become properties on the D-Bus.
527
569
534
576
"""
535
577
# Encoding deeply encoded byte arrays is not supported yet by the
536
578
# "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)
579
if byte_arrays and signature != "ay":
580
raise ValueError("Byte arrays not supported for non-'ay'"
581
" signature %r" % signature)
540
582
def decorator(func):
541
583
func._dbus_is_property = True
542
584
func._dbus_interface = dbus_interface
543
585
func._dbus_signature = signature
544
586
func._dbus_access = access
545
587
func._dbus_name = func.__name__
546
if func._dbus_name.endswith(u"_dbus_property"):
588
if func._dbus_name.endswith("_dbus_property"):
547
589
func._dbus_name = func._dbus_name[:-14]
548
func._dbus_get_args_options = {u'byte_arrays': byte_arrays }
590
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
549
591
return func
550
592
return decorator
551
593
571
613
572
614
class DBusObjectWithProperties(dbus.service.Object):
573
615
"""A D-Bus object with properties.
574
616
575
617
Classes inheriting from this can use the dbus_service_property
576
618
decorator to expose methods as D-Bus properties. It exposes the
577
619
standard Get(), Set(), and GetAll() methods on the D-Bus.
579
621
580
622
@staticmethod
581
623
def _is_dbus_property(obj):
582
return getattr(obj, u"_dbus_is_property", False)
624
return getattr(obj, "_dbus_is_property", False)
583
625
584
626
def _get_all_dbus_properties(self):
585
627
"""Returns a generator of (name, attribute) pairs
593
635
property with the specified name and interface.
594
636
"""
595
637
for name in (property_name,
596
property_name + u"_dbus_property"):
638
property_name + "_dbus_property"):
597
639
prop = getattr(self, name, None)
598
640
if (prop is None
599
641
or not self._is_dbus_property(prop)
603
645
continue
604
646
return prop
605
647
# No such property
606
raise DBusPropertyNotFound(self.dbus_object_path + u":"
607
+ interface_name + u"."
648
raise DBusPropertyNotFound(self.dbus_object_path + ":"
649
+ interface_name + "."
608
650
+ property_name)
609
651
610
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
611
out_signature=u"v")
652
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
653
out_signature="v")
612
654
def Get(self, interface_name, property_name):
613
655
"""Standard D-Bus property Get() method, see D-Bus standard.
614
656
"""
615
657
prop = self._get_dbus_property(interface_name, property_name)
616
if prop._dbus_access == u"write":
658
if prop._dbus_access == "write":
617
659
raise DBusPropertyAccessException(property_name)
618
660
value = prop()
619
if not hasattr(value, u"variant_level"):
661
if not hasattr(value, "variant_level"):
620
662
return value
621
663
return type(value)(value, variant_level=value.variant_level+1)
622
664
623
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
665
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
624
666
def Set(self, interface_name, property_name, value):
625
667
"""Standard D-Bus property Set() method, see D-Bus standard.
626
668
"""
627
669
prop = self._get_dbus_property(interface_name, property_name)
628
if prop._dbus_access == u"read":
670
if prop._dbus_access == "read":
629
671
raise DBusPropertyAccessException(property_name)
630
if prop._dbus_get_args_options[u"byte_arrays"]:
672
if prop._dbus_get_args_options["byte_arrays"]:
631
673
# The byte_arrays option is not supported yet on
632
674
# signatures other than "ay".
633
if prop._dbus_signature != u"ay":
675
if prop._dbus_signature != "ay":
634
676
raise ValueError
635
677
value = dbus.ByteArray(''.join(unichr(byte)
636
678
for byte in value))
637
679
prop(value)
638
680
639
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
640
out_signature=u"a{sv}")
681
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
682
out_signature="a{sv}")
641
683
def GetAll(self, interface_name):
642
684
"""Standard D-Bus property GetAll() method, see D-Bus
643
685
standard.
644
686
645
687
Note: Will not include properties with access="write".
646
688
"""
647
689
all = {}
651
693
# Interface non-empty but did not match
652
694
continue
653
695
# Ignore write-only properties
654
if prop._dbus_access == u"write":
696
if prop._dbus_access == "write":
655
697
continue
656
698
value = prop()
657
if not hasattr(value, u"variant_level"):
699
if not hasattr(value, "variant_level"):
658
700
all[name] = value
659
701
continue
660
702
all[name] = type(value)(value, variant_level=
661
703
value.variant_level+1)
662
return dbus.Dictionary(all, signature=u"sv")
704
return dbus.Dictionary(all, signature="sv")
663
705
664
706
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
665
out_signature=u"s",
707
out_signature="s",
666
708
path_keyword='object_path',
667
709
connection_keyword='connection')
668
710
def Introspect(self, object_path, connection):
673
715
try:
674
716
document = xml.dom.minidom.parseString(xmlstring)
675
717
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)
718
e = document.createElement("property")
719
e.setAttribute("name", name)
720
e.setAttribute("type", prop._dbus_signature)
721
e.setAttribute("access", prop._dbus_access)
680
722
return e
681
for if_tag in document.getElementsByTagName(u"interface"):
723
for if_tag in document.getElementsByTagName("interface"):
682
724
for tag in (make_tag(document, name, prop)
683
725
for name, prop
684
726
in self._get_all_dbus_properties()
685
727
if prop._dbus_interface
686
== if_tag.getAttribute(u"name")):
728
== if_tag.getAttribute("name")):
687
729
if_tag.appendChild(tag)
688
730
# Add the names to the return values for the
689
731
# "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")
732
if (if_tag.getAttribute("name")
733
== "org.freedesktop.DBus.Properties"):
734
for cn in if_tag.getElementsByTagName("method"):
735
if cn.getAttribute("name") == "Get":
736
for arg in cn.getElementsByTagName("arg"):
737
if (arg.getAttribute("direction")
738
== "out"):
739
arg.setAttribute("name", "value")
740
elif cn.getAttribute("name") == "GetAll":
741
for arg in cn.getElementsByTagName("arg"):
742
if (arg.getAttribute("direction")
743
== "out"):
744
arg.setAttribute("name", "props")
745
xmlstring = document.toxml("utf-8")
704
746
document.unlink()
705
747
except (AttributeError, xml.dom.DOMException,
706
xml.parsers.expat.ExpatError), error:
707
logger.error(u"Failed to override Introspection method",
748
xml.parsers.expat.ExpatError) as error:
749
logger.error("Failed to override Introspection method",
708
750
error)
709
751
return xmlstring
710
752
711
753
754
def datetime_to_dbus (dt, variant_level=0):
755
"""Convert a UTC datetime.datetime() to a D-Bus type."""
756
if dt is None:
757
return dbus.String("", variant_level = variant_level)
758
return dbus.String(dt.isoformat(),
759
variant_level=variant_level)
760
761
712
762
class ClientDBus(Client, DBusObjectWithProperties):
713
763
"""A Client class using D-Bus
714
764
718
768
"""
719
769
720
770
runtime_expansions = (Client.runtime_expansions
721
+ (u"dbus_object_path",))
771
+ ("dbus_object_path",))
722
772
723
773
# dbus.service.Object doesn't use super(), so we can't either.
724
774
729
779
# Only now, when this client is initialized, can it show up on
730
780
# the D-Bus
731
781
client_object_name = unicode(self.name).translate(
732
{ord(u"."): ord(u"_"),
733
ord(u"-"): ord(u"_")})
782
{ord("."): ord("_"),
783
ord("-"): ord("_")})
734
784
self.dbus_object_path = (dbus.ObjectPath
735
(u"/clients/" + client_object_name))
785
("/clients/" + client_object_name))
736
786
DBusObjectWithProperties.__init__(self, self.bus,
737
787
self.dbus_object_path)
738
788
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
789
def notifychangeproperty(transform_func,
790
dbus_name, type_func=lambda x: x,
791
variant_level=1):
792
""" Modify a variable so that its a property that announce its
793
changes to DBus.
794
transform_fun: Function that takes a value and transform it to
795
DBus type.
796
dbus_name: DBus name of the variable
797
type_func: Function that transform the value before sending it
798
to DBus
799
variant_level: DBus variant level. default: 1
800
"""
801
real_value = [None,]
802
def setter(self, value):
803
old_value = real_value[0]
804
real_value[0] = value
805
if hasattr(self, "dbus_object_path"):
806
if type_func(old_value) != type_func(real_value[0]):
807
dbus_value = transform_func(type_func(real_value[0]),
808
variant_level)
809
self.PropertyChanged(dbus.String(dbus_name),
810
dbus_value)
811
812
return property(lambda self: real_value[0], setter)
813
814
815
expires = notifychangeproperty(datetime_to_dbus, "Expires")
816
approvals_pending = notifychangeproperty(dbus.Boolean,
817
"ApprovalPending",
818
type_func = bool)
819
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
820
last_enabled = notifychangeproperty(datetime_to_dbus,
821
"LastEnabled")
822
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
823
type_func = lambda checker: checker is not None)
824
last_checked_ok = notifychangeproperty(datetime_to_dbus,
825
"LastCheckedOK")
826
last_approval_request = notifychangeproperty(datetime_to_dbus,
827
"LastApprovalRequest")
828
approved_by_default = notifychangeproperty(dbus.Boolean,
829
"ApprovedByDefault")
830
approval_delay = notifychangeproperty(dbus.UInt16, "ApprovalDelay",
831
type_func = _timedelta_to_milliseconds)
832
approval_duration = notifychangeproperty(dbus.UInt16, "ApprovalDuration",
833
type_func = _timedelta_to_milliseconds)
834
host = notifychangeproperty(dbus.String, "Host")
835
timeout = notifychangeproperty(dbus.UInt16, "Timeout",
836
type_func = _timedelta_to_milliseconds)
837
extended_timeout = notifychangeproperty(dbus.UInt16, "ExtendedTimeout",
838
type_func = _timedelta_to_milliseconds)
839
interval = notifychangeproperty(dbus.UInt16, "Interval",
840
type_func = _timedelta_to_milliseconds)
841
checker_command = notifychangeproperty(dbus.String, "Checker")
842
843
del notifychangeproperty
782
844
783
845
def __del__(self, *args, **kwargs):
784
846
try:
785
847
self.remove_from_connection()
786
848
except LookupError:
787
849
pass
788
if hasattr(DBusObjectWithProperties, u"__del__"):
850
if hasattr(DBusObjectWithProperties, "__del__"):
789
851
DBusObjectWithProperties.__del__(self, *args, **kwargs)
790
852
Client.__del__(self, *args, **kwargs)
791
853
793
855
*args, **kwargs):
794
856
self.checker_callback_tag = None
795
857
self.checker = None
796
# Emit D-Bus signal
797
self.PropertyChanged(dbus.String(u"CheckerRunning"),
798
dbus.Boolean(False, variant_level=1))
799
858
if os.WIFEXITED(condition):
800
859
exitstatus = os.WEXITSTATUS(condition)
801
860
# Emit D-Bus signal
811
870
return Client.checker_callback(self, pid, condition, command,
812
871
*args, **kwargs)
813
872
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
873
def start_checker(self, *args, **kwargs):
833
874
old_checker = self.checker
834
875
if self.checker is not None:
841
882
and old_checker_pid != self.checker.pid):
842
883
# Emit D-Bus signal
843
884
self.CheckerStarted(self.current_checker_command)
844
self.PropertyChanged(
845
dbus.String(u"CheckerRunning"),
846
dbus.Boolean(True, variant_level=1))
847
885
return r
848
886
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
887
def _reset_approved(self):
859
888
self._approved = None
860
889
return False
862
891
def approve(self, value=True):
863
892
self.send_changedstate()
864
893
self._approved = value
865
gobject.timeout_add(self._timedelta_to_milliseconds
894
gobject.timeout_add(_timedelta_to_milliseconds
866
895
(self.approval_duration),
867
896
self._reset_approved)
868
897
869
898
870
899
## D-Bus methods, signals & properties
871
_interface = u"se.bsnet.fukt.Mandos.Client"
900
_interface = "se.bsnet.fukt.Mandos.Client"
872
901
873
902
## Signals
874
903
875
904
# CheckerCompleted - signal
876
@dbus.service.signal(_interface, signature=u"nxs")
905
@dbus.service.signal(_interface, signature="nxs")
877
906
def CheckerCompleted(self, exitcode, waitstatus, command):
878
907
"D-Bus signal"
879
908
pass
880
909
881
910
# CheckerStarted - signal
882
@dbus.service.signal(_interface, signature=u"s")
911
@dbus.service.signal(_interface, signature="s")
883
912
def CheckerStarted(self, command):
884
913
"D-Bus signal"
885
914
pass
886
915
887
916
# PropertyChanged - signal
888
@dbus.service.signal(_interface, signature=u"sv")
917
@dbus.service.signal(_interface, signature="sv")
889
918
def PropertyChanged(self, property, value):
890
919
"D-Bus signal"
891
920
pass
900
929
pass
901
930
902
931
# Rejected - signal
903
@dbus.service.signal(_interface, signature=u"s")
932
@dbus.service.signal(_interface, signature="s")
904
933
def Rejected(self, reason):
905
934
"D-Bus signal"
906
935
pass
907
936
908
937
# NeedApproval - signal
909
@dbus.service.signal(_interface, signature=u"tb")
938
@dbus.service.signal(_interface, signature="tb")
910
939
def NeedApproval(self, timeout, default):
911
940
"D-Bus signal"
912
941
return self.need_approval()
914
943
## Methods
915
944
916
945
# Approve - method
917
@dbus.service.method(_interface, in_signature=u"b")
946
@dbus.service.method(_interface, in_signature="b")
918
947
def Approve(self, value):
919
948
self.approve(value)
920
949
921
950
# CheckedOK - method
922
951
@dbus.service.method(_interface)
923
952
def CheckedOK(self):
924
return self.checked_ok()
953
self.checked_ok()
925
954
926
955
# Enable - method
927
956
@dbus.service.method(_interface)
949
978
## Properties
950
979
951
980
# ApprovalPending - property
952
@dbus_service_property(_interface, signature=u"b", access=u"read")
981
@dbus_service_property(_interface, signature="b", access="read")
953
982
def ApprovalPending_dbus_property(self):
954
983
return dbus.Boolean(bool(self.approvals_pending))
955
984
956
985
# ApprovedByDefault - property
957
@dbus_service_property(_interface, signature=u"b",
958
access=u"readwrite")
986
@dbus_service_property(_interface, signature="b",
987
access="readwrite")
959
988
def ApprovedByDefault_dbus_property(self, value=None):
960
989
if value is None: # get
961
990
return dbus.Boolean(self.approved_by_default)
962
991
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
992
967
993
# ApprovalDelay - property
968
@dbus_service_property(_interface, signature=u"t",
969
access=u"readwrite")
994
@dbus_service_property(_interface, signature="t",
995
access="readwrite")
970
996
def ApprovalDelay_dbus_property(self, value=None):
971
997
if value is None: # get
972
998
return dbus.UInt64(self.approval_delay_milliseconds())
973
999
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
1000
978
1001
# ApprovalDuration - property
979
@dbus_service_property(_interface, signature=u"t",
980
access=u"readwrite")
1002
@dbus_service_property(_interface, signature="t",
1003
access="readwrite")
981
1004
def ApprovalDuration_dbus_property(self, value=None):
982
1005
if value is None: # get
983
return dbus.UInt64(self._timedelta_to_milliseconds(
1006
return dbus.UInt64(_timedelta_to_milliseconds(
984
1007
self.approval_duration))
985
1008
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
1009
990
1010
# Name - property
991
@dbus_service_property(_interface, signature=u"s", access=u"read")
1011
@dbus_service_property(_interface, signature="s", access="read")
992
1012
def Name_dbus_property(self):
993
1013
return dbus.String(self.name)
994
1014
995
1015
# Fingerprint - property
996
@dbus_service_property(_interface, signature=u"s", access=u"read")
1016
@dbus_service_property(_interface, signature="s", access="read")
997
1017
def Fingerprint_dbus_property(self):
998
1018
return dbus.String(self.fingerprint)
999
1019
1000
1020
# Host - property
1001
@dbus_service_property(_interface, signature=u"s",
1002
access=u"readwrite")
1021
@dbus_service_property(_interface, signature="s",
1022
access="readwrite")
1003
1023
def Host_dbus_property(self, value=None):
1004
1024
if value is None: # get
1005
1025
return dbus.String(self.host)
1006
1026
self.host = value
1007
# Emit D-Bus signal
1008
self.PropertyChanged(dbus.String(u"Host"),
1009
dbus.String(value, variant_level=1))
1010
1027
1011
1028
# Created - property
1012
@dbus_service_property(_interface, signature=u"s", access=u"read")
1029
@dbus_service_property(_interface, signature="s", access="read")
1013
1030
def Created_dbus_property(self):
1014
return dbus.String(self._datetime_to_dbus(self.created))
1031
return dbus.String(datetime_to_dbus(self.created))
1015
1032
1016
1033
# LastEnabled - property
1017
@dbus_service_property(_interface, signature=u"s", access=u"read")
1034
@dbus_service_property(_interface, signature="s", access="read")
1018
1035
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))
1036
return datetime_to_dbus(self.last_enabled)
1022
1037
1023
1038
# Enabled - property
1024
@dbus_service_property(_interface, signature=u"b",
1025
access=u"readwrite")
1039
@dbus_service_property(_interface, signature="b",
1040
access="readwrite")
1026
1041
def Enabled_dbus_property(self, value=None):
1027
1042
if value is None: # get
1028
1043
return dbus.Boolean(self.enabled)
1032
1047
self.disable()
1033
1048
1034
1049
# LastCheckedOK - property
1035
@dbus_service_property(_interface, signature=u"s",
1036
access=u"readwrite")
1050
@dbus_service_property(_interface, signature="s",
1051
access="readwrite")
1037
1052
def LastCheckedOK_dbus_property(self, value=None):
1038
1053
if value is not None:
1039
1054
self.checked_ok()
1040
1055
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))
1056
return datetime_to_dbus(self.last_checked_ok)
1057
1058
# Expires - property
1059
@dbus_service_property(_interface, signature="s", access="read")
1060
def Expires_dbus_property(self):
1061
return datetime_to_dbus(self.expires)
1045
1062
1046
1063
# LastApprovalRequest - property
1047
@dbus_service_property(_interface, signature=u"s", access=u"read")
1064
@dbus_service_property(_interface, signature="s", access="read")
1048
1065
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))
1066
return datetime_to_dbus(self.last_approval_request)
1054
1067
1055
1068
# Timeout - property
1056
@dbus_service_property(_interface, signature=u"t",
1057
access=u"readwrite")
1069
@dbus_service_property(_interface, signature="t",
1070
access="readwrite")
1058
1071
def Timeout_dbus_property(self, value=None):
1059
1072
if value is None: # get
1060
1073
return dbus.UInt64(self.timeout_milliseconds())
1061
1074
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:
1075
if getattr(self, "disable_initiator_tag", None) is None:
1066
1076
return
1067
1077
# Reschedule timeout
1068
1078
gobject.source_remove(self.disable_initiator_tag)
1069
1079
self.disable_initiator_tag = None
1080
self.expires = None
1070
1081
time_to_die = (self.
1071
1082
_timedelta_to_milliseconds((self
1072
1083
.last_checked_ok
1077
1088
# The timeout has passed
1078
1089
self.disable()
1079
1090
else:
1091
self.expires = (datetime.datetime.utcnow()
1092
+ datetime.timedelta(milliseconds = time_to_die))
1080
1093
self.disable_initiator_tag = (gobject.timeout_add
1081
1094
(time_to_die, self.disable))
1082
1095
1096
# ExtendedTimeout - property
1097
@dbus_service_property(_interface, signature="t",
1098
access="readwrite")
1099
def ExtendedTimeout_dbus_property(self, value=None):
1100
if value is None: # get
1101
return dbus.UInt64(self.extended_timeout_milliseconds())
1102
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1103
1083
1104
# Interval - property
1084
@dbus_service_property(_interface, signature=u"t",
1085
access=u"readwrite")
1105
@dbus_service_property(_interface, signature="t",
1106
access="readwrite")
1086
1107
def Interval_dbus_property(self, value=None):
1087
1108
if value is None: # get
1088
1109
return dbus.UInt64(self.interval_milliseconds())
1089
1110
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:
1111
if getattr(self, "checker_initiator_tag", None) is None:
1094
1112
return
1095
1113
# Reschedule checker run
1096
1114
gobject.source_remove(self.checker_initiator_tag)
1097
1115
self.checker_initiator_tag = (gobject.timeout_add
1098
1116
(value, self.start_checker))
1099
1117
self.start_checker() # Start one now, too
1100
1118
1101
1119
# Checker - property
1102
@dbus_service_property(_interface, signature=u"s",
1103
access=u"readwrite")
1120
@dbus_service_property(_interface, signature="s",
1121
access="readwrite")
1104
1122
def Checker_dbus_property(self, value=None):
1105
1123
if value is None: # get
1106
1124
return dbus.String(self.checker_command)
1107
1125
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
1126
1113
1127
# CheckerRunning - property
1114
@dbus_service_property(_interface, signature=u"b",
1115
access=u"readwrite")
1128
@dbus_service_property(_interface, signature="b",
1129
access="readwrite")
1116
1130
def CheckerRunning_dbus_property(self, value=None):
1117
1131
if value is None: # get
1118
1132
return dbus.Boolean(self.checker is not None)
1122
1136
self.stop_checker()
1123
1137
1124
1138
# ObjectPath - property
1125
@dbus_service_property(_interface, signature=u"o", access=u"read")
1139
@dbus_service_property(_interface, signature="o", access="read")
1126
1140
def ObjectPath_dbus_property(self):
1127
1141
return self.dbus_object_path # is already a dbus.ObjectPath
1128
1142
1129
1143
# Secret = property
1130
@dbus_service_property(_interface, signature=u"ay",
1131
access=u"write", byte_arrays=True)
1144
@dbus_service_property(_interface, signature="ay",
1145
access="write", byte_arrays=True)
1132
1146
def Secret_dbus_property(self, value):
1133
1147
self.secret = str(value)
1134
1148
1141
1155
self._pipe.send(('init', fpr, address))
1142
1156
if not self._pipe.recv():
1143
1157
raise KeyError()
1144
1158
1145
1159
def __getattribute__(self, name):
1146
1160
if(name == '_pipe'):
1147
1161
return super(ProxyClient, self).__getattribute__(name)
1154
1168
self._pipe.send(('funcall', name, args, kwargs))
1155
1169
return self._pipe.recv()[1]
1156
1170
return func
1157
1171
1158
1172
def __setattr__(self, name, value):
1159
1173
if(name == '_pipe'):
1160
1174
return super(ProxyClient, self).__setattr__(name, value)
1169
1183
1170
1184
def handle(self):
1171
1185
with contextlib.closing(self.server.child_pipe) as child_pipe:
1172
logger.info(u"TCP connection from: %s",
1186
logger.info("TCP connection from: %s",
1173
1187
unicode(self.client_address))
1174
logger.debug(u"Pipe FD: %d",
1188
logger.debug("Pipe FD: %d",
1175
1189
self.server.child_pipe.fileno())
1176
1190
1177
1191
session = (gnutls.connection
1178
1192
.ClientSession(self.request,
1179
1193
gnutls.connection
1180
1194
.X509Credentials()))
1181
1195
1182
1196
# Note: gnutls.connection.X509Credentials is really a
1183
1197
# generic GnuTLS certificate credentials object so long as
1184
1198
# no X.509 keys are added to it. Therefore, we can use it
1185
1199
# 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"))
1200
1201
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1202
# "+AES-256-CBC", "+SHA1",
1203
# "+COMP-NULL", "+CTYPE-OPENPGP",
1204
# "+DHE-DSS"))
1191
1205
# Use a fallback default, since this MUST be set.
1192
1206
priority = self.server.gnutls_priority
1193
1207
if priority is None:
1194
priority = u"NORMAL"
1208
priority = "NORMAL"
1195
1209
(gnutls.library.functions
1196
1210
.gnutls_priority_set_direct(session._c_object,
1197
1211
priority, None))
1198
1212
1199
1213
# Start communication using the Mandos protocol
1200
1214
# Get protocol number
1201
1215
line = self.request.makefile().readline()
1202
logger.debug(u"Protocol version: %r", line)
1216
logger.debug("Protocol version: %r", line)
1203
1217
try:
1204
1218
if int(line.strip().split()[0]) > 1:
1205
1219
raise RuntimeError
1206
except (ValueError, IndexError, RuntimeError), error:
1207
logger.error(u"Unknown protocol version: %s", error)
1220
except (ValueError, IndexError, RuntimeError) as error:
1221
logger.error("Unknown protocol version: %s", error)
1208
1222
return
1209
1223
1210
1224
# Start GnuTLS connection
1211
1225
try:
1212
1226
session.handshake()
1213
except gnutls.errors.GNUTLSError, error:
1214
logger.warning(u"Handshake failed: %s", error)
1227
except gnutls.errors.GNUTLSError as error:
1228
logger.warning("Handshake failed: %s", error)
1215
1229
# Do not run session.bye() here: the session is not
1216
1230
# established. Just abandon the request.
1217
1231
return
1218
logger.debug(u"Handshake succeeded")
1219
1232
logger.debug("Handshake succeeded")
1233
1220
1234
approval_required = False
1221
1235
try:
1222
1236
try:
1223
1237
fpr = self.fingerprint(self.peer_certificate
1224
1238
(session))
1225
except (TypeError, gnutls.errors.GNUTLSError), error:
1226
logger.warning(u"Bad certificate: %s", error)
1239
except (TypeError,
1240
gnutls.errors.GNUTLSError) as error:
1241
logger.warning("Bad certificate: %s", error)
1227
1242
return
1228
logger.debug(u"Fingerprint: %s", fpr)
1229
1243
logger.debug("Fingerprint: %s", fpr)
1244
1230
1245
try:
1231
1246
client = ProxyClient(child_pipe, fpr,
1232
1247
self.client_address)
1240
1255
1241
1256
while True:
1242
1257
if not client.enabled:
1243
logger.warning(u"Client %s is disabled",
1258
logger.info("Client %s is disabled",
1244
1259
client.name)
1245
1260
if self.server.use_dbus:
1246
1261
# Emit D-Bus signal
1251
1266
#We are approved or approval is disabled
1252
1267
break
1253
1268
elif client._approved is None:
1254
logger.info(u"Client %s needs approval",
1269
logger.info("Client %s needs approval",
1255
1270
client.name)
1256
1271
if self.server.use_dbus:
1257
1272
# Emit D-Bus signal
1259
1274
client.approval_delay_milliseconds(),
1260
1275
client.approved_by_default)
1261
1276
else:
1262
logger.warning(u"Client %s was not approved",
1277
logger.warning("Client %s was not approved",
1263
1278
client.name)
1264
1279
if self.server.use_dbus:
1265
1280
# Emit D-Bus signal
1291
1306
while sent_size < len(client.secret):
1292
1307
try:
1293
1308
sent = session.send(client.secret[sent_size:])
1294
except (gnutls.errors.GNUTLSError), error:
1309
except gnutls.errors.GNUTLSError as error:
1295
1310
logger.warning("gnutls send failed")
1296
1311
return
1297
logger.debug(u"Sent: %d, remaining: %d",
1312
logger.debug("Sent: %d, remaining: %d",
1298
1313
sent, len(client.secret)
1299
1314
- (sent_size + sent))
1300
1315
sent_size += sent
1301
1302
logger.info(u"Sending secret to %s", client.name)
1316
1317
logger.info("Sending secret to %s", client.name)
1303
1318
# bump the timeout as if seen
1304
client.checked_ok()
1319
client.checked_ok(client.extended_timeout)
1305
1320
if self.server.use_dbus:
1306
1321
# Emit D-Bus signal
1307
1322
client.GotSecret()
1311
1326
client.approvals_pending -= 1
1312
1327
try:
1313
1328
session.bye()
1314
except (gnutls.errors.GNUTLSError), error:
1329
except gnutls.errors.GNUTLSError as error:
1315
1330
logger.warning("GnuTLS bye failed")
1316
1331
1317
1332
@staticmethod
1328
1343
.gnutls_certificate_get_peers
1329
1344
(session._c_object, ctypes.byref(list_size)))
1330
1345
if not bool(cert_list) and list_size.value != 0:
1331
raise gnutls.errors.GNUTLSError(u"error getting peer"
1332
u" certificate")
1346
raise gnutls.errors.GNUTLSError("error getting peer"
1347
" certificate")
1333
1348
if list_size.value == 0:
1334
1349
return None
1335
1350
cert = cert_list[0]
1361
1376
if crtverify.value != 0:
1362
1377
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1363
1378
raise (gnutls.errors.CertificateSecurityError
1364
(u"Verify failed"))
1379
("Verify failed"))
1365
1380
# New buffer for the fingerprint
1366
1381
buf = ctypes.create_string_buffer(20)
1367
1382
buf_len = ctypes.c_size_t()
1374
1389
# Convert the buffer to a Python bytestring
1375
1390
fpr = ctypes.string_at(buf, buf_len.value)
1376
1391
# Convert the bytestring to hexadecimal notation
1377
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
1392
hex_fpr = ''.join("%02X" % ord(char) for char in fpr)
1378
1393
return hex_fpr
1379
1394
1380
1395
1392
1407
multiprocessing.Process(target = self.sub_process_main,
1393
1408
args = (request, address)).start()
1394
1409
1410
1395
1411
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1396
1412
""" adds a pipe to the MixIn """
1397
1413
def process_request(self, request, client_address):
1400
1416
This function creates a new pipe in self.pipe
1401
1417
"""
1402
1418
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1403
1419
1404
1420
super(MultiprocessingMixInWithPipe,
1405
1421
self).process_request(request, client_address)
1406
1422
self.child_pipe.close()
1407
1423
self.add_pipe(parent_pipe)
1408
1424
1409
1425
def add_pipe(self, parent_pipe):
1410
1426
"""Dummy function; override as necessary"""
1411
pass
1427
raise NotImplementedError
1428
1412
1429
1413
1430
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1414
1431
socketserver.TCPServer, object):
1432
1449
bind to an address or port if they were not specified."""
1433
1450
if self.interface is not None:
1434
1451
if SO_BINDTODEVICE is None:
1435
logger.error(u"SO_BINDTODEVICE does not exist;"
1436
u" cannot bind to interface %s",
1452
logger.error("SO_BINDTODEVICE does not exist;"
1453
" cannot bind to interface %s",
1437
1454
self.interface)
1438
1455
else:
1439
1456
try:
1440
1457
self.socket.setsockopt(socket.SOL_SOCKET,
1441
1458
SO_BINDTODEVICE,
1442
1459
str(self.interface
1443
+ u'\0'))
1444
except socket.error, error:
1460
+ '\0'))
1461
except socket.error as error:
1445
1462
if error[0] == errno.EPERM:
1446
logger.error(u"No permission to"
1447
u" bind to interface %s",
1463
logger.error("No permission to"
1464
" bind to interface %s",
1448
1465
self.interface)
1449
1466
elif error[0] == errno.ENOPROTOOPT:
1450
logger.error(u"SO_BINDTODEVICE not available;"
1451
u" cannot bind to interface %s",
1467
logger.error("SO_BINDTODEVICE not available;"
1468
" cannot bind to interface %s",
1452
1469
self.interface)
1453
1470
else:
1454
1471
raise
1456
1473
if self.server_address[0] or self.server_address[1]:
1457
1474
if not self.server_address[0]:
1458
1475
if self.address_family == socket.AF_INET6:
1459
any_address = u"::" # in6addr_any
1476
any_address = "::" # in6addr_any
1460
1477
else:
1461
1478
any_address = socket.INADDR_ANY
1462
1479
self.server_address = (any_address,
1511
1528
def handle_ipc(self, source, condition, parent_pipe=None,
1512
1529
client_object=None):
1513
1530
condition_names = {
1514
gobject.IO_IN: u"IN", # There is data to read.
1515
gobject.IO_OUT: u"OUT", # Data can be written (without
1531
gobject.IO_IN: "IN", # There is data to read.
1532
gobject.IO_OUT: "OUT", # Data can be written (without
1516
1533
# 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
1534
gobject.IO_PRI: "PRI", # There is urgent data to read.
1535
gobject.IO_ERR: "ERR", # Error condition.
1536
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1520
1537
# broken, usually for pipes and
1521
1538
# sockets).
1522
1539
}
1541
1558
client = c
1542
1559
break
1543
1560
else:
1544
logger.warning(u"Client not found for fingerprint: %s, ad"
1545
u"dress: %s", fpr, address)
1561
logger.info("Client not found for fingerprint: %s, ad"
1562
"dress: %s", fpr, address)
1546
1563
if self.use_dbus:
1547
1564
# Emit D-Bus signal
1548
1565
mandos_dbus_service.ClientNotFound(fpr, address[0])
1563
1580
kwargs = request[3]
1564
1581
1565
1582
parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))
1566
1583
1567
1584
if command == 'getattr':
1568
1585
attrname = request[1]
1569
1586
if callable(client_object.__getattribute__(attrname)):
1575
1592
attrname = request[1]
1576
1593
value = request[2]
1577
1594
setattr(client_object, attrname, value)
1578
1595
1579
1596
return True
1580
1597
1581
1598
1582
1599
def string_to_delta(interval):
1583
1600
"""Parse a string and return a datetime.timedelta
1584
1601
1585
>>> string_to_delta(u'7d')
1602
>>> string_to_delta('7d')
1586
1603
datetime.timedelta(7)
1587
>>> string_to_delta(u'60s')
1604
>>> string_to_delta('60s')
1588
1605
datetime.timedelta(0, 60)
1589
>>> string_to_delta(u'60m')
1606
>>> string_to_delta('60m')
1590
1607
datetime.timedelta(0, 3600)
1591
>>> string_to_delta(u'24h')
1608
>>> string_to_delta('24h')
1592
1609
datetime.timedelta(1)
1593
>>> string_to_delta(u'1w')
1610
>>> string_to_delta('1w')
1594
1611
datetime.timedelta(7)
1595
>>> string_to_delta(u'5m 30s')
1612
>>> string_to_delta('5m 30s')
1596
1613
datetime.timedelta(0, 330)
1597
1614
"""
1598
1615
timevalue = datetime.timedelta(0)
1600
1617
try:
1601
1618
suffix = unicode(s[-1])
1602
1619
value = int(s[:-1])
1603
if suffix == u"d":
1620
if suffix == "d":
1604
1621
delta = datetime.timedelta(value)
1605
elif suffix == u"s":
1622
elif suffix == "s":
1606
1623
delta = datetime.timedelta(0, value)
1607
elif suffix == u"m":
1624
elif suffix == "m":
1608
1625
delta = datetime.timedelta(0, 0, 0, 0, value)
1609
elif suffix == u"h":
1626
elif suffix == "h":
1610
1627
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1611
elif suffix == u"w":
1628
elif suffix == "w":
1612
1629
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1613
1630
else:
1614
raise ValueError(u"Unknown suffix %r" % suffix)
1615
except (ValueError, IndexError), e:
1616
raise ValueError(e.message)
1631
raise ValueError("Unknown suffix %r" % suffix)
1632
except (ValueError, IndexError) as e:
1633
raise ValueError(*(e.args))
1617
1634
timevalue += delta
1618
1635
return timevalue
1619
1636
1625
1642
global if_nametoindex
1626
1643
try:
1627
1644
if_nametoindex = (ctypes.cdll.LoadLibrary
1628
(ctypes.util.find_library(u"c"))
1645
(ctypes.util.find_library("c"))
1629
1646
.if_nametoindex)
1630
1647
except (OSError, AttributeError):
1631
logger.warning(u"Doing if_nametoindex the hard way")
1648
logger.warning("Doing if_nametoindex the hard way")
1632
1649
def if_nametoindex(interface):
1633
1650
"Get an interface index the hard way, i.e. using fcntl()"
1634
1651
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1635
1652
with contextlib.closing(socket.socket()) as s:
1636
1653
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1637
struct.pack(str(u"16s16x"),
1654
struct.pack(str("16s16x"),
1638
1655
interface))
1639
interface_index = struct.unpack(str(u"I"),
1656
interface_index = struct.unpack(str("I"),
1640
1657
ifreq[16:20])[0]
1641
1658
return interface_index
1642
1659
return if_nametoindex(interface)
1650
1667
sys.exit()
1651
1668
os.setsid()
1652
1669
if not nochdir:
1653
os.chdir(u"/")
1670
os.chdir("/")
1654
1671
if os.fork():
1655
1672
sys.exit()
1656
1673
if not noclose:
1658
1675
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1659
1676
if not stat.S_ISCHR(os.fstat(null).st_mode):
1660
1677
raise OSError(errno.ENODEV,
1661
u"%s not a character device"
1678
"%s not a character device"
1662
1679
% os.path.devnull)
1663
1680
os.dup2(null, sys.stdin.fileno())
1664
1681
os.dup2(null, sys.stdout.fileno())
1672
1689
##################################################################
1673
1690
# Parsing of options, both command line and config file
1674
1691
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]
1692
parser = argparse.ArgumentParser()
1693
parser.add_argument("-v", "--version", action="version",
1694
version = "%%(prog)s %s" % version,
1695
help="show version number and exit")
1696
parser.add_argument("-i", "--interface", metavar="IF",
1697
help="Bind to interface IF")
1698
parser.add_argument("-a", "--address",
1699
help="Address to listen for requests on")
1700
parser.add_argument("-p", "--port", type=int,
1701
help="Port number to receive requests on")
1702
parser.add_argument("--check", action="store_true",
1703
help="Run self-test")
1704
parser.add_argument("--debug", action="store_true",
1705
help="Debug mode; run in foreground and log"
1706
" to terminal")
1707
parser.add_argument("--debuglevel", metavar="LEVEL",
1708
help="Debug level for stdout output")
1709
parser.add_argument("--priority", help="GnuTLS"
1710
" priority string (see GnuTLS documentation)")
1711
parser.add_argument("--servicename",
1712
metavar="NAME", help="Zeroconf service name")
1713
parser.add_argument("--configdir",
1714
default="/etc/mandos", metavar="DIR",
1715
help="Directory to search for configuration"
1716
" files")
1717
parser.add_argument("--no-dbus", action="store_false",
1718
dest="use_dbus", help="Do not provide D-Bus"
1719
" system bus interface")
1720
parser.add_argument("--no-ipv6", action="store_false",
1721
dest="use_ipv6", help="Do not use IPv6")
1722
options = parser.parse_args()
1703
1723
1704
1724
if options.check:
1705
1725
import doctest
1707
1727
sys.exit()
1708
1728
1709
1729
# 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"",
1730
server_defaults = { "interface": "",
1731
"address": "",
1732
"port": "",
1733
"debug": "False",
1734
"priority":
1735
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1736
"servicename": "Mandos",
1737
"use_dbus": "True",
1738
"use_ipv6": "True",
1739
"debuglevel": "",
1720
1740
}
1721
1741
1722
1742
# Parse config file for server-global settings
1723
1743
server_config = configparser.SafeConfigParser(server_defaults)
1724
1744
del server_defaults
1725
1745
server_config.read(os.path.join(options.configdir,
1726
u"mandos.conf"))
1746
"mandos.conf"))
1727
1747
# Convert the SafeConfigParser object to a dict
1728
1748
server_settings = server_config.defaults()
1729
1749
# 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",
1750
for option in ("debug", "use_dbus", "use_ipv6"):
1751
server_settings[option] = server_config.getboolean("DEFAULT",
1732
1752
option)
1733
1753
if server_settings["port"]:
1734
server_settings["port"] = server_config.getint(u"DEFAULT",
1735
u"port")
1754
server_settings["port"] = server_config.getint("DEFAULT",
1755
"port")
1736
1756
del server_config
1737
1757
1738
1758
# Override the settings from the config file with command line
1739
1759
# 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"):
1760
for option in ("interface", "address", "port", "debug",
1761
"priority", "servicename", "configdir",
1762
"use_dbus", "use_ipv6", "debuglevel"):
1743
1763
value = getattr(options, option)
1744
1764
if value is not None:
1745
1765
server_settings[option] = value
1753
1773
##################################################################
1754
1774
1755
1775
# 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":
1776
debug = server_settings["debug"]
1777
debuglevel = server_settings["debuglevel"]
1778
use_dbus = server_settings["use_dbus"]
1779
use_ipv6 = server_settings["use_ipv6"]
1780
1781
if server_settings["servicename"] != "Mandos":
1762
1782
syslogger.setFormatter(logging.Formatter
1763
(u'Mandos (%s) [%%(process)d]:'
1764
u' %%(levelname)s: %%(message)s'
1765
% server_settings[u"servicename"]))
1783
('Mandos (%s) [%%(process)d]:'
1784
' %%(levelname)s: %%(message)s'
1785
% server_settings["servicename"]))
1766
1786
1767
1787
# 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",
1788
client_defaults = { "timeout": "5m",
1789
"extended_timeout": "15m",
1790
"interval": "2m",
1791
"checker": "fping -q -- %%(host)s",
1792
"host": "",
1793
"approval_delay": "0s",
1794
"approval_duration": "1s",
1774
1795
}
1775
1796
client_config = configparser.SafeConfigParser(client_defaults)
1776
client_config.read(os.path.join(server_settings[u"configdir"],
1777
u"clients.conf"))
1797
client_config.read(os.path.join(server_settings["configdir"],
1798
"clients.conf"))
1778
1799
1779
1800
global mandos_dbus_service
1780
1801
mandos_dbus_service = None
1781
1802
1782
tcp_server = MandosServer((server_settings[u"address"],
1783
server_settings[u"port"]),
1803
tcp_server = MandosServer((server_settings["address"],
1804
server_settings["port"]),
1784
1805
ClientHandler,
1785
interface=(server_settings[u"interface"]
1806
interface=(server_settings["interface"]
1786
1807
or None),
1787
1808
use_ipv6=use_ipv6,
1788
1809
gnutls_priority=
1789
server_settings[u"priority"],
1810
server_settings["priority"],
1790
1811
use_dbus=use_dbus)
1791
1812
if not debug:
1792
pidfilename = u"/var/run/mandos.pid"
1813
pidfilename = "/var/run/mandos.pid"
1793
1814
try:
1794
pidfile = open(pidfilename, u"w")
1815
pidfile = open(pidfilename, "w")
1795
1816
except IOError:
1796
logger.error(u"Could not open file %r", pidfilename)
1817
logger.error("Could not open file %r", pidfilename)
1797
1818
1798
1819
try:
1799
uid = pwd.getpwnam(u"_mandos").pw_uid
1800
gid = pwd.getpwnam(u"_mandos").pw_gid
1820
uid = pwd.getpwnam("_mandos").pw_uid
1821
gid = pwd.getpwnam("_mandos").pw_gid
1801
1822
except KeyError:
1802
1823
try:
1803
uid = pwd.getpwnam(u"mandos").pw_uid
1804
gid = pwd.getpwnam(u"mandos").pw_gid
1824
uid = pwd.getpwnam("mandos").pw_uid
1825
gid = pwd.getpwnam("mandos").pw_gid
1805
1826
except KeyError:
1806
1827
try:
1807
uid = pwd.getpwnam(u"nobody").pw_uid
1808
gid = pwd.getpwnam(u"nobody").pw_gid
1828
uid = pwd.getpwnam("nobody").pw_uid
1829
gid = pwd.getpwnam("nobody").pw_gid
1809
1830
except KeyError:
1810
1831
uid = 65534
1811
1832
gid = 65534
1812
1833
try:
1813
1834
os.setgid(gid)
1814
1835
os.setuid(uid)
1815
except OSError, error:
1836
except OSError as error:
1816
1837
if error[0] != errno.EPERM:
1817
1838
raise error
1818
1839
1823
1844
level = getattr(logging, debuglevel.upper())
1824
1845
syslogger.setLevel(level)
1825
1846
console.setLevel(level)
1826
1847
1827
1848
if debug:
1828
1849
# Enable all possible GnuTLS debugging
1829
1850
1833
1854
1834
1855
@gnutls.library.types.gnutls_log_func
1835
1856
def debug_gnutls(level, string):
1836
logger.debug(u"GnuTLS: %s", string[:-1])
1857
logger.debug("GnuTLS: %s", string[:-1])
1837
1858
1838
1859
(gnutls.library.functions
1839
1860
.gnutls_global_set_log_function(debug_gnutls))
1847
1868
# No console logging
1848
1869
logger.removeHandler(console)
1849
1870
1871
# Need to fork before connecting to D-Bus
1872
if not debug:
1873
# Close all input and output, do double fork, etc.
1874
daemon()
1850
1875
1851
1876
global main_loop
1852
1877
# From the Avahi example code
1856
1881
# End of Avahi example code
1857
1882
if use_dbus:
1858
1883
try:
1859
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
1884
bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",
1860
1885
bus, do_not_queue=True)
1861
except dbus.exceptions.NameExistsException, e:
1862
logger.error(unicode(e) + u", disabling D-Bus")
1886
except dbus.exceptions.NameExistsException as e:
1887
logger.error(unicode(e) + ", disabling D-Bus")
1863
1888
use_dbus = False
1864
server_settings[u"use_dbus"] = False
1889
server_settings["use_dbus"] = False
1865
1890
tcp_server.use_dbus = False
1866
1891
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1867
service = AvahiService(name = server_settings[u"servicename"],
1868
servicetype = u"_mandos._tcp",
1892
service = AvahiService(name = server_settings["servicename"],
1893
servicetype = "_mandos._tcp",
1869
1894
protocol = protocol, bus = bus)
1870
1895
if server_settings["interface"]:
1871
1896
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
1897
(str(server_settings["interface"])))
1898
1878
1899
global multiprocessing_manager
1879
1900
multiprocessing_manager = multiprocessing.Manager()
1880
1901
1899
1920
client_config, section)))
1900
1921
for section in client_config.sections()))
1901
1922
if not tcp_server.clients:
1902
logger.warning(u"No clients defined")
1923
logger.warning("No clients defined")
1903
1924
1904
1925
if not debug:
1905
1926
try:
1906
1927
with pidfile:
1907
1928
pid = os.getpid()
1908
pidfile.write(str(pid) + "\n")
1929
pidfile.write(str(pid) + "\n".encode("utf-8"))
1909
1930
del pidfile
1910
1931
except IOError:
1911
logger.error(u"Could not write to file %r with PID %d",
1932
logger.error("Could not write to file %r with PID %d",
1912
1933
pidfilename, pid)
1913
1934
except NameError:
1914
1935
# "pidfile" was never created
1916
1937
del pidfilename
1917
1938
1918
1939
signal.signal(signal.SIGINT, signal.SIG_IGN)
1919
1940
1920
1941
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1921
1942
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1922
1943
1924
1945
class MandosDBusService(dbus.service.Object):
1925
1946
"""A D-Bus proxy object"""
1926
1947
def __init__(self):
1927
dbus.service.Object.__init__(self, bus, u"/")
1928
_interface = u"se.bsnet.fukt.Mandos"
1948
dbus.service.Object.__init__(self, bus, "/")
1949
_interface = "se.bsnet.fukt.Mandos"
1929
1950
1930
@dbus.service.signal(_interface, signature=u"o")
1951
@dbus.service.signal(_interface, signature="o")
1931
1952
def ClientAdded(self, objpath):
1932
1953
"D-Bus signal"
1933
1954
pass
1934
1955
1935
@dbus.service.signal(_interface, signature=u"ss")
1956
@dbus.service.signal(_interface, signature="ss")
1936
1957
def ClientNotFound(self, fingerprint, address):
1937
1958
"D-Bus signal"
1938
1959
pass
1939
1960
1940
@dbus.service.signal(_interface, signature=u"os")
1961
@dbus.service.signal(_interface, signature="os")
1941
1962
def ClientRemoved(self, objpath, name):
1942
1963
"D-Bus signal"
1943
1964
pass
1944
1965
1945
@dbus.service.method(_interface, out_signature=u"ao")
1966
@dbus.service.method(_interface, out_signature="ao")
1946
1967
def GetAllClients(self):
1947
1968
"D-Bus method"
1948
1969
return dbus.Array(c.dbus_object_path
1949
1970
for c in tcp_server.clients)
1950
1971
1951
1972
@dbus.service.method(_interface,
1952
out_signature=u"a{oa{sv}}")
1973
out_signature="a{oa{sv}}")
1953
1974
def GetAllClientsWithProperties(self):
1954
1975
"D-Bus method"
1955
1976
return dbus.Dictionary(
1956
((c.dbus_object_path, c.GetAll(u""))
1977
((c.dbus_object_path, c.GetAll(""))
1957
1978
for c in tcp_server.clients),
1958
signature=u"oa{sv}")
1979
signature="oa{sv}")
1959
1980
1960
@dbus.service.method(_interface, in_signature=u"o")
1981
@dbus.service.method(_interface, in_signature="o")
1961
1982
def RemoveClient(self, object_path):
1962
1983
"D-Bus method"
1963
1984
for c in tcp_server.clients:
2005
2026
# Find out what port we got
2006
2027
service.port = tcp_server.socket.getsockname()[1]
2007
2028
if use_ipv6:
2008
logger.info(u"Now listening on address %r, port %d,"
2029
logger.info("Now listening on address %r, port %d,"
2009
2030
" flowinfo %d, scope_id %d"
2010
2031
% tcp_server.socket.getsockname())
2011
2032
else: # IPv4
2012
logger.info(u"Now listening on address %r, port %d"
2033
logger.info("Now listening on address %r, port %d"
2013
2034
% tcp_server.socket.getsockname())
2014
2035
2015
2036
#service.interface = tcp_server.socket.getsockname()[3]
2018
2039
# From the Avahi example code
2019
2040
try:
2020
2041
service.activate()
2021
except dbus.exceptions.DBusException, error:
2022
logger.critical(u"DBusException: %s", error)
2042
except dbus.exceptions.DBusException as error:
2043
logger.critical("DBusException: %s", error)
2023
2044
cleanup()
2024
2045
sys.exit(1)
2025
2046
# End of Avahi example code
2029
2050
(tcp_server.handle_request
2030
2051
(*args[2:], **kwargs) or True))
2031
2052
2032
logger.debug(u"Starting main loop")
2053
logger.debug("Starting main loop")
2033
2054
main_loop.run()
2034
except AvahiError, error:
2035
logger.critical(u"AvahiError: %s", error)
2055
except AvahiError as error:
2056
logger.critical("AvahiError: %s", error)
2036
2057
cleanup()
2037
2058
sys.exit(1)
2038
2059
except KeyboardInterrupt:
2039
2060
if debug:
2040
print >> sys.stderr
2041
logger.debug(u"Server received KeyboardInterrupt")
2042
logger.debug(u"Server exiting")
2061
print("", file=sys.stderr)
2062
logger.debug("Server received KeyboardInterrupt")
2063
logger.debug("Server exiting")
2043
2064
# Must run before the D-Bus bus name gets deregistered
2044
2065
cleanup()
2045
2066
2067
2046
2068
if __name__ == '__main__':
2047
2069
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0