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