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 433
- compare with another revision
- download diff
- download tarball
- view history from revision 433
- Committer: teddy at bsnet
- Date: 2010-09-15 17:33:14 UTC
- Revision ID: teddy@fukt.bsnet.se-20100915173314-iiy6ljrwa1mdcbge
* debian/mandos.dirs: Added "etc/dbus-1/system.d".
- files removed:
- debian/source
- files modified:
- .bzrignore
added
removed
mandos
11
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2008-2011 Teddy Hogeborn
15
# Copyright © 2008-2011 Björn Påhlsson
14
# Copyright © 2008,2009 Teddy Hogeborn
15
# Copyright © 2008,2009 Björn Påhlsson
16
16
#
17
17
# This program is free software: you can redistribute it and/or modify
18
18
# it under the terms of the GNU General Public License as published by
31
31
# Contact the authors at <mandos@fukt.bsnet.se>.
32
32
#
33
33
34
from __future__ import (division, absolute_import, print_function,
35
unicode_literals)
34
from __future__ import division, with_statement, absolute_import
36
35
37
36
import SocketServer as socketserver
38
37
import socket
39
import argparse
38
import optparse
40
39
import datetime
41
40
import errno
42
41
import gnutls.crypto
82
81
SO_BINDTODEVICE = None
83
82
84
83
85
version = "1.3.0"
84
version = "1.0.14"
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
268
240
"""A representation of a client host served by this server.
269
241
270
242
Attributes:
271
_approved: bool(); 'None' if not yet approved/disapproved
272
approval_delay: datetime.timedelta(); Time to wait for approval
273
approval_duration: datetime.timedelta(); Duration of one approval
243
name: string; from the config file, used in log messages and
244
D-Bus identifiers
245
fingerprint: string (40 or 32 hexadecimal digits); used to
246
uniquely identify the client
247
secret: bytestring; sent verbatim (over TLS) to client
248
host: string; available for use by the checker command
249
created: datetime.datetime(); (UTC) object creation
250
last_enabled: datetime.datetime(); (UTC)
251
enabled: bool()
252
last_checked_ok: datetime.datetime(); (UTC) or None
253
timeout: datetime.timedelta(); How long from last_checked_ok
254
until this client is disabled
255
interval: datetime.timedelta(); How often to start a new checker
256
disable_hook: If set, called by disable() as disable_hook(self)
274
257
checker: subprocess.Popen(); a running checker process used
275
258
to see if the client lives.
276
259
'None' if no process is running.
277
checker_callback_tag: a gobject event source tag, or None
278
checker_command: string; External command which is run to check
279
if client lives. %() expansions are done at
260
checker_initiator_tag: a gobject event source tag, or None
261
disable_initiator_tag: - '' -
262
checker_callback_tag: - '' -
263
checker_command: string; External command which is run to check if
264
client lives. %() expansions are done at
280
265
runtime with vars(self) as dict, so that for
281
266
instance %(name)s can be used in the command.
282
checker_initiator_tag: a gobject event source tag, or None
283
created: datetime.datetime(); (UTC) object creation
284
267
current_checker_command: string; current running checker_command
285
disable_hook: If set, called by disable() as disable_hook(self)
286
disable_initiator_tag: a gobject event source tag, or None
287
enabled: bool()
288
fingerprint: string (40 or 32 hexadecimal digits); used to
289
uniquely identify the client
290
host: string; available for use by the checker command
291
interval: datetime.timedelta(); How often to start a new checker
292
last_approval_request: datetime.datetime(); (UTC) or None
293
last_checked_ok: datetime.datetime(); (UTC) or None
294
last_enabled: datetime.datetime(); (UTC)
295
name: string; from the config file, used in log messages and
296
D-Bus identifiers
297
secret: bytestring; sent verbatim (over TLS) to client
298
timeout: datetime.timedelta(); How long from last_checked_ok
299
until this client is disabled
300
runtime_expansions: Allowed attributes for runtime expansion.
268
approval_delay: datetime.timedelta(); Time to wait for approval
269
_approved: bool(); 'None' if not yet approved/disapproved
270
approval_duration: datetime.timedelta(); Duration of one approval
301
271
"""
302
272
303
runtime_expansions = ("approval_delay", "approval_duration",
304
"created", "enabled", "fingerprint",
305
"host", "interval", "last_checked_ok",
306
"last_enabled", "name", "timeout")
307
308
273
@staticmethod
309
274
def _timedelta_to_milliseconds(td):
310
275
"Convert a datetime.timedelta() to milliseconds"
330
295
self.name = name
331
296
if config is None:
332
297
config = {}
333
logger.debug("Creating client %r", self.name)
298
logger.debug(u"Creating client %r", self.name)
334
299
# Uppercase and remove spaces from fingerprint for later
335
300
# comparison purposes with return value from the fingerprint()
336
301
# function
337
self.fingerprint = (config["fingerprint"].upper()
338
.replace(" ", ""))
339
logger.debug(" Fingerprint: %s", self.fingerprint)
340
if "secret" in config:
341
self.secret = config["secret"].decode("base64")
342
elif "secfile" in config:
302
self.fingerprint = (config[u"fingerprint"].upper()
303
.replace(u" ", u""))
304
logger.debug(u" Fingerprint: %s", self.fingerprint)
305
if u"secret" in config:
306
self.secret = config[u"secret"].decode(u"base64")
307
elif u"secfile" in config:
343
308
with open(os.path.expanduser(os.path.expandvars
344
(config["secfile"])),
309
(config[u"secfile"])),
345
310
"rb") as secfile:
346
311
self.secret = secfile.read()
347
312
else:
348
raise TypeError("No secret or secfile for client %s"
313
raise TypeError(u"No secret or secfile for client %s"
349
314
% self.name)
350
self.host = config.get("host", "")
315
self.host = config.get(u"host", u"")
351
316
self.created = datetime.datetime.utcnow()
352
317
self.enabled = False
353
self.last_approval_request = None
354
318
self.last_enabled = None
355
319
self.last_checked_ok = None
356
self.timeout = string_to_delta(config["timeout"])
357
self.interval = string_to_delta(config["interval"])
320
self.timeout = string_to_delta(config[u"timeout"])
321
self.interval = string_to_delta(config[u"interval"])
358
322
self.disable_hook = disable_hook
359
323
self.checker = None
360
324
self.checker_initiator_tag = None
361
325
self.disable_initiator_tag = None
362
326
self.checker_callback_tag = None
363
self.checker_command = config["checker"]
327
self.checker_command = config[u"checker"]
364
328
self.current_checker_command = None
365
329
self.last_connect = None
366
330
self._approved = None
367
self.approved_by_default = config.get("approved_by_default",
331
self.approved_by_default = config.get(u"approved_by_default",
368
332
True)
369
333
self.approvals_pending = 0
370
334
self.approval_delay = string_to_delta(
371
config["approval_delay"])
335
config[u"approval_delay"])
372
336
self.approval_duration = string_to_delta(
373
config["approval_duration"])
337
config[u"approval_duration"])
374
338
self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
375
339
376
340
def send_changedstate(self):
380
344
381
345
def enable(self):
382
346
"""Start this client's checker and timeout hooks"""
383
if getattr(self, "enabled", False):
347
if getattr(self, u"enabled", False):
384
348
# Already enabled
385
349
return
386
350
self.send_changedstate()
405
369
if not quiet:
406
370
self.send_changedstate()
407
371
if not quiet:
408
logger.info("Disabling client %s", self.name)
409
if getattr(self, "disable_initiator_tag", False):
372
logger.info(u"Disabling client %s", self.name)
373
if getattr(self, u"disable_initiator_tag", False):
410
374
gobject.source_remove(self.disable_initiator_tag)
411
375
self.disable_initiator_tag = None
412
if getattr(self, "checker_initiator_tag", False):
376
if getattr(self, u"checker_initiator_tag", False):
413
377
gobject.source_remove(self.checker_initiator_tag)
414
378
self.checker_initiator_tag = None
415
379
self.stop_checker()
430
394
if os.WIFEXITED(condition):
431
395
exitstatus = os.WEXITSTATUS(condition)
432
396
if exitstatus == 0:
433
logger.info("Checker for %(name)s succeeded",
397
logger.info(u"Checker for %(name)s succeeded",
434
398
vars(self))
435
399
self.checked_ok()
436
400
else:
437
logger.info("Checker for %(name)s failed",
401
logger.info(u"Checker for %(name)s failed",
438
402
vars(self))
439
403
else:
440
logger.warning("Checker for %(name)s crashed?",
404
logger.warning(u"Checker for %(name)s crashed?",
441
405
vars(self))
442
406
443
407
def checked_ok(self):
452
416
(self.timeout_milliseconds(),
453
417
self.disable))
454
418
455
def need_approval(self):
456
self.last_approval_request = datetime.datetime.utcnow()
457
458
419
def start_checker(self):
459
420
"""Start a new checker subprocess if one is not running.
460
421
472
433
# If a checker exists, make sure it is not a zombie
473
434
try:
474
435
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
475
except (AttributeError, OSError) as error:
436
except (AttributeError, OSError), error:
476
437
if (isinstance(error, OSError)
477
438
and error.errno != errno.ECHILD):
478
439
raise error
479
440
else:
480
441
if pid:
481
logger.warning("Checker was a zombie")
442
logger.warning(u"Checker was a zombie")
482
443
gobject.source_remove(self.checker_callback_tag)
483
444
self.checker_callback(pid, status,
484
445
self.current_checker_command)
489
450
command = self.checker_command % self.host
490
451
except TypeError:
491
452
# Escape attributes for the shell
492
escaped_attrs = dict(
493
(attr,
494
re.escape(unicode(str(getattr(self, attr, "")),
495
errors=
496
'replace')))
497
for attr in
498
self.runtime_expansions)
499
453
escaped_attrs = dict((key,
454
re.escape(unicode(str(val),
455
errors=
456
u'replace')))
457
for key, val in
458
vars(self).iteritems())
500
459
try:
501
460
command = self.checker_command % escaped_attrs
502
except TypeError as error:
503
logger.error('Could not format string "%s":'
504
' %s', self.checker_command, error)
461
except TypeError, error:
462
logger.error(u'Could not format string "%s":'
463
u' %s', self.checker_command, error)
505
464
return True # Try again later
506
465
self.current_checker_command = command
507
466
try:
508
logger.info("Starting checker %r for %s",
467
logger.info(u"Starting checker %r for %s",
509
468
command, self.name)
510
469
# We don't need to redirect stdout and stderr, since
511
470
# in normal mode, that is already done by daemon(),
513
472
# always replaced by /dev/null.)
514
473
self.checker = subprocess.Popen(command,
515
474
close_fds=True,
516
shell=True, cwd="/")
475
shell=True, cwd=u"/")
517
476
self.checker_callback_tag = (gobject.child_watch_add
518
477
(self.checker.pid,
519
478
self.checker_callback,
524
483
if pid:
525
484
gobject.source_remove(self.checker_callback_tag)
526
485
self.checker_callback(pid, status, command)
527
except OSError as error:
528
logger.error("Failed to start subprocess: %s",
486
except OSError, error:
487
logger.error(u"Failed to start subprocess: %s",
529
488
error)
530
489
# Re-run this periodically if run by gobject.timeout_add
531
490
return True
535
494
if self.checker_callback_tag:
536
495
gobject.source_remove(self.checker_callback_tag)
537
496
self.checker_callback_tag = None
538
if getattr(self, "checker", None) is None:
497
if getattr(self, u"checker", None) is None:
539
498
return
540
logger.debug("Stopping checker for %(name)s", vars(self))
499
logger.debug(u"Stopping checker for %(name)s", vars(self))
541
500
try:
542
501
os.kill(self.checker.pid, signal.SIGTERM)
543
502
#time.sleep(0.5)
544
503
#if self.checker.poll() is None:
545
504
# os.kill(self.checker.pid, signal.SIGKILL)
546
except OSError as error:
505
except OSError, error:
547
506
if error.errno != errno.ESRCH: # No such process
548
507
raise
549
508
self.checker = None
550
509
551
def dbus_service_property(dbus_interface, signature="v",
552
access="readwrite", byte_arrays=False):
510
def dbus_service_property(dbus_interface, signature=u"v",
511
access=u"readwrite", byte_arrays=False):
553
512
"""Decorators for marking methods of a DBusObjectWithProperties to
554
513
become properties on the D-Bus.
555
514
562
521
"""
563
522
# Encoding deeply encoded byte arrays is not supported yet by the
564
523
# "Set" method, so we fail early here:
565
if byte_arrays and signature != "ay":
566
raise ValueError("Byte arrays not supported for non-'ay'"
567
" signature %r" % signature)
524
if byte_arrays and signature != u"ay":
525
raise ValueError(u"Byte arrays not supported for non-'ay'"
526
u" signature %r" % signature)
568
527
def decorator(func):
569
528
func._dbus_is_property = True
570
529
func._dbus_interface = dbus_interface
571
530
func._dbus_signature = signature
572
531
func._dbus_access = access
573
532
func._dbus_name = func.__name__
574
if func._dbus_name.endswith("_dbus_property"):
533
if func._dbus_name.endswith(u"_dbus_property"):
575
534
func._dbus_name = func._dbus_name[:-14]
576
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
535
func._dbus_get_args_options = {u'byte_arrays': byte_arrays }
577
536
return func
578
537
return decorator
579
538
607
566
608
567
@staticmethod
609
568
def _is_dbus_property(obj):
610
return getattr(obj, "_dbus_is_property", False)
569
return getattr(obj, u"_dbus_is_property", False)
611
570
612
571
def _get_all_dbus_properties(self):
613
572
"""Returns a generator of (name, attribute) pairs
621
580
property with the specified name and interface.
622
581
"""
623
582
for name in (property_name,
624
property_name + "_dbus_property"):
583
property_name + u"_dbus_property"):
625
584
prop = getattr(self, name, None)
626
585
if (prop is None
627
586
or not self._is_dbus_property(prop)
631
590
continue
632
591
return prop
633
592
# No such property
634
raise DBusPropertyNotFound(self.dbus_object_path + ":"
635
+ interface_name + "."
593
raise DBusPropertyNotFound(self.dbus_object_path + u":"
594
+ interface_name + u"."
636
595
+ property_name)
637
596
638
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
639
out_signature="v")
597
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
598
out_signature=u"v")
640
599
def Get(self, interface_name, property_name):
641
600
"""Standard D-Bus property Get() method, see D-Bus standard.
642
601
"""
643
602
prop = self._get_dbus_property(interface_name, property_name)
644
if prop._dbus_access == "write":
603
if prop._dbus_access == u"write":
645
604
raise DBusPropertyAccessException(property_name)
646
605
value = prop()
647
if not hasattr(value, "variant_level"):
606
if not hasattr(value, u"variant_level"):
648
607
return value
649
608
return type(value)(value, variant_level=value.variant_level+1)
650
609
651
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
610
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
652
611
def Set(self, interface_name, property_name, value):
653
612
"""Standard D-Bus property Set() method, see D-Bus standard.
654
613
"""
655
614
prop = self._get_dbus_property(interface_name, property_name)
656
if prop._dbus_access == "read":
615
if prop._dbus_access == u"read":
657
616
raise DBusPropertyAccessException(property_name)
658
if prop._dbus_get_args_options["byte_arrays"]:
617
if prop._dbus_get_args_options[u"byte_arrays"]:
659
618
# The byte_arrays option is not supported yet on
660
619
# signatures other than "ay".
661
if prop._dbus_signature != "ay":
620
if prop._dbus_signature != u"ay":
662
621
raise ValueError
663
622
value = dbus.ByteArray(''.join(unichr(byte)
664
623
for byte in value))
665
624
prop(value)
666
625
667
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
668
out_signature="a{sv}")
626
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
627
out_signature=u"a{sv}")
669
628
def GetAll(self, interface_name):
670
629
"""Standard D-Bus property GetAll() method, see D-Bus
671
630
standard.
679
638
# Interface non-empty but did not match
680
639
continue
681
640
# Ignore write-only properties
682
if prop._dbus_access == "write":
641
if prop._dbus_access == u"write":
683
642
continue
684
643
value = prop()
685
if not hasattr(value, "variant_level"):
644
if not hasattr(value, u"variant_level"):
686
645
all[name] = value
687
646
continue
688
647
all[name] = type(value)(value, variant_level=
689
648
value.variant_level+1)
690
return dbus.Dictionary(all, signature="sv")
649
return dbus.Dictionary(all, signature=u"sv")
691
650
692
651
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
693
out_signature="s",
652
out_signature=u"s",
694
653
path_keyword='object_path',
695
654
connection_keyword='connection')
696
655
def Introspect(self, object_path, connection):
701
660
try:
702
661
document = xml.dom.minidom.parseString(xmlstring)
703
662
def make_tag(document, name, prop):
704
e = document.createElement("property")
705
e.setAttribute("name", name)
706
e.setAttribute("type", prop._dbus_signature)
707
e.setAttribute("access", prop._dbus_access)
663
e = document.createElement(u"property")
664
e.setAttribute(u"name", name)
665
e.setAttribute(u"type", prop._dbus_signature)
666
e.setAttribute(u"access", prop._dbus_access)
708
667
return e
709
for if_tag in document.getElementsByTagName("interface"):
668
for if_tag in document.getElementsByTagName(u"interface"):
710
669
for tag in (make_tag(document, name, prop)
711
670
for name, prop
712
671
in self._get_all_dbus_properties()
713
672
if prop._dbus_interface
714
== if_tag.getAttribute("name")):
673
== if_tag.getAttribute(u"name")):
715
674
if_tag.appendChild(tag)
716
675
# Add the names to the return values for the
717
676
# "org.freedesktop.DBus.Properties" methods
718
if (if_tag.getAttribute("name")
719
== "org.freedesktop.DBus.Properties"):
720
for cn in if_tag.getElementsByTagName("method"):
721
if cn.getAttribute("name") == "Get":
722
for arg in cn.getElementsByTagName("arg"):
723
if (arg.getAttribute("direction")
724
== "out"):
725
arg.setAttribute("name", "value")
726
elif cn.getAttribute("name") == "GetAll":
727
for arg in cn.getElementsByTagName("arg"):
728
if (arg.getAttribute("direction")
729
== "out"):
730
arg.setAttribute("name", "props")
731
xmlstring = document.toxml("utf-8")
677
if (if_tag.getAttribute(u"name")
678
== u"org.freedesktop.DBus.Properties"):
679
for cn in if_tag.getElementsByTagName(u"method"):
680
if cn.getAttribute(u"name") == u"Get":
681
for arg in cn.getElementsByTagName(u"arg"):
682
if (arg.getAttribute(u"direction")
683
== u"out"):
684
arg.setAttribute(u"name", u"value")
685
elif cn.getAttribute(u"name") == u"GetAll":
686
for arg in cn.getElementsByTagName(u"arg"):
687
if (arg.getAttribute(u"direction")
688
== u"out"):
689
arg.setAttribute(u"name", u"props")
690
xmlstring = document.toxml(u"utf-8")
732
691
document.unlink()
733
692
except (AttributeError, xml.dom.DOMException,
734
xml.parsers.expat.ExpatError) as error:
735
logger.error("Failed to override Introspection method",
693
xml.parsers.expat.ExpatError), error:
694
logger.error(u"Failed to override Introspection method",
736
695
error)
737
696
return xmlstring
738
697
744
703
dbus_object_path: dbus.ObjectPath
745
704
bus: dbus.SystemBus()
746
705
"""
747
748
runtime_expansions = (Client.runtime_expansions
749
+ ("dbus_object_path",))
750
751
706
# dbus.service.Object doesn't use super(), so we can't either.
752
707
753
708
def __init__(self, bus = None, *args, **kwargs):
756
711
Client.__init__(self, *args, **kwargs)
757
712
# Only now, when this client is initialized, can it show up on
758
713
# the D-Bus
759
client_object_name = unicode(self.name).translate(
760
{ord("."): ord("_"),
761
ord("-"): ord("_")})
762
714
self.dbus_object_path = (dbus.ObjectPath
763
("/clients/" + client_object_name))
715
(u"/clients/"
716
+ self.name.replace(u".", u"_")))
764
717
DBusObjectWithProperties.__init__(self, self.bus,
765
718
self.dbus_object_path)
766
719
773
726
if (hasattr(self, "dbus_object_path")
774
727
and bval is not bool(old_value)):
775
728
dbus_bool = dbus.Boolean(bval, variant_level=1)
776
self.PropertyChanged(dbus.String("ApprovalPending"),
729
self.PropertyChanged(dbus.String(u"ApprovalPending"),
777
730
dbus_bool)
778
731
779
732
approvals_pending = property(_get_approvals_pending,
787
740
variant_level=variant_level)
788
741
789
742
def enable(self):
790
oldstate = getattr(self, "enabled", False)
743
oldstate = getattr(self, u"enabled", False)
791
744
r = Client.enable(self)
792
745
if oldstate != self.enabled:
793
746
# Emit D-Bus signals
794
self.PropertyChanged(dbus.String("Enabled"),
747
self.PropertyChanged(dbus.String(u"Enabled"),
795
748
dbus.Boolean(True, variant_level=1))
796
749
self.PropertyChanged(
797
dbus.String("LastEnabled"),
750
dbus.String(u"LastEnabled"),
798
751
self._datetime_to_dbus(self.last_enabled,
799
752
variant_level=1))
800
753
return r
801
754
802
755
def disable(self, quiet = False):
803
oldstate = getattr(self, "enabled", False)
756
oldstate = getattr(self, u"enabled", False)
804
757
r = Client.disable(self, quiet=quiet)
805
758
if not quiet and oldstate != self.enabled:
806
759
# Emit D-Bus signal
807
self.PropertyChanged(dbus.String("Enabled"),
760
self.PropertyChanged(dbus.String(u"Enabled"),
808
761
dbus.Boolean(False, variant_level=1))
809
762
return r
810
763
813
766
self.remove_from_connection()
814
767
except LookupError:
815
768
pass
816
if hasattr(DBusObjectWithProperties, "__del__"):
769
if hasattr(DBusObjectWithProperties, u"__del__"):
817
770
DBusObjectWithProperties.__del__(self, *args, **kwargs)
818
771
Client.__del__(self, *args, **kwargs)
819
772
822
775
self.checker_callback_tag = None
823
776
self.checker = None
824
777
# Emit D-Bus signal
825
self.PropertyChanged(dbus.String("CheckerRunning"),
778
self.PropertyChanged(dbus.String(u"CheckerRunning"),
826
779
dbus.Boolean(False, variant_level=1))
827
780
if os.WIFEXITED(condition):
828
781
exitstatus = os.WEXITSTATUS(condition)
840
793
*args, **kwargs)
841
794
842
795
def checked_ok(self, *args, **kwargs):
843
Client.checked_ok(self, *args, **kwargs)
796
r = Client.checked_ok(self, *args, **kwargs)
844
797
# Emit D-Bus signal
845
798
self.PropertyChanged(
846
dbus.String("LastCheckedOK"),
799
dbus.String(u"LastCheckedOK"),
847
800
(self._datetime_to_dbus(self.last_checked_ok,
848
801
variant_level=1)))
849
850
def need_approval(self, *args, **kwargs):
851
r = Client.need_approval(self, *args, **kwargs)
852
# Emit D-Bus signal
853
self.PropertyChanged(
854
dbus.String("LastApprovalRequest"),
855
(self._datetime_to_dbus(self.last_approval_request,
856
variant_level=1)))
857
802
return r
858
803
859
804
def start_checker(self, *args, **kwargs):
869
814
# Emit D-Bus signal
870
815
self.CheckerStarted(self.current_checker_command)
871
816
self.PropertyChanged(
872
dbus.String("CheckerRunning"),
817
dbus.String(u"CheckerRunning"),
873
818
dbus.Boolean(True, variant_level=1))
874
819
return r
875
820
876
821
def stop_checker(self, *args, **kwargs):
877
old_checker = getattr(self, "checker", None)
822
old_checker = getattr(self, u"checker", None)
878
823
r = Client.stop_checker(self, *args, **kwargs)
879
824
if (old_checker is not None
880
and getattr(self, "checker", None) is None):
881
self.PropertyChanged(dbus.String("CheckerRunning"),
825
and getattr(self, u"checker", None) is None):
826
self.PropertyChanged(dbus.String(u"CheckerRunning"),
882
827
dbus.Boolean(False, variant_level=1))
883
828
return r
884
829
895
840
896
841
897
842
## D-Bus methods, signals & properties
898
_interface = "se.bsnet.fukt.Mandos.Client"
843
_interface = u"se.bsnet.fukt.Mandos.Client"
899
844
900
845
## Signals
901
846
902
847
# CheckerCompleted - signal
903
@dbus.service.signal(_interface, signature="nxs")
848
@dbus.service.signal(_interface, signature=u"nxs")
904
849
def CheckerCompleted(self, exitcode, waitstatus, command):
905
850
"D-Bus signal"
906
851
pass
907
852
908
853
# CheckerStarted - signal
909
@dbus.service.signal(_interface, signature="s")
854
@dbus.service.signal(_interface, signature=u"s")
910
855
def CheckerStarted(self, command):
911
856
"D-Bus signal"
912
857
pass
913
858
914
859
# PropertyChanged - signal
915
@dbus.service.signal(_interface, signature="sv")
860
@dbus.service.signal(_interface, signature=u"sv")
916
861
def PropertyChanged(self, property, value):
917
862
"D-Bus signal"
918
863
pass
927
872
pass
928
873
929
874
# Rejected - signal
930
@dbus.service.signal(_interface, signature="s")
875
@dbus.service.signal(_interface, signature=u"s")
931
876
def Rejected(self, reason):
932
877
"D-Bus signal"
933
878
pass
934
879
935
880
# NeedApproval - signal
936
@dbus.service.signal(_interface, signature="tb")
881
@dbus.service.signal(_interface, signature=u"tb")
937
882
def NeedApproval(self, timeout, default):
938
883
"D-Bus signal"
939
return self.need_approval()
884
pass
940
885
941
886
## Methods
942
887
943
888
# Approve - method
944
@dbus.service.method(_interface, in_signature="b")
889
@dbus.service.method(_interface, in_signature=u"b")
945
890
def Approve(self, value):
946
891
self.approve(value)
947
892
948
893
# CheckedOK - method
949
894
@dbus.service.method(_interface)
950
895
def CheckedOK(self):
951
self.checked_ok()
896
return self.checked_ok()
952
897
953
898
# Enable - method
954
899
@dbus.service.method(_interface)
976
921
## Properties
977
922
978
923
# ApprovalPending - property
979
@dbus_service_property(_interface, signature="b", access="read")
924
@dbus_service_property(_interface, signature=u"b", access=u"read")
980
925
def ApprovalPending_dbus_property(self):
981
926
return dbus.Boolean(bool(self.approvals_pending))
982
927
983
928
# ApprovedByDefault - property
984
@dbus_service_property(_interface, signature="b",
985
access="readwrite")
929
@dbus_service_property(_interface, signature=u"b",
930
access=u"readwrite")
986
931
def ApprovedByDefault_dbus_property(self, value=None):
987
932
if value is None: # get
988
933
return dbus.Boolean(self.approved_by_default)
989
934
self.approved_by_default = bool(value)
990
935
# Emit D-Bus signal
991
self.PropertyChanged(dbus.String("ApprovedByDefault"),
936
self.PropertyChanged(dbus.String(u"ApprovedByDefault"),
992
937
dbus.Boolean(value, variant_level=1))
993
938
994
939
# ApprovalDelay - property
995
@dbus_service_property(_interface, signature="t",
996
access="readwrite")
940
@dbus_service_property(_interface, signature=u"t",
941
access=u"readwrite")
997
942
def ApprovalDelay_dbus_property(self, value=None):
998
943
if value is None: # get
999
944
return dbus.UInt64(self.approval_delay_milliseconds())
1000
945
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1001
946
# Emit D-Bus signal
1002
self.PropertyChanged(dbus.String("ApprovalDelay"),
947
self.PropertyChanged(dbus.String(u"ApprovalDelay"),
1003
948
dbus.UInt64(value, variant_level=1))
1004
949
1005
950
# ApprovalDuration - property
1006
@dbus_service_property(_interface, signature="t",
1007
access="readwrite")
951
@dbus_service_property(_interface, signature=u"t",
952
access=u"readwrite")
1008
953
def ApprovalDuration_dbus_property(self, value=None):
1009
954
if value is None: # get
1010
955
return dbus.UInt64(self._timedelta_to_milliseconds(
1011
956
self.approval_duration))
1012
957
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1013
958
# Emit D-Bus signal
1014
self.PropertyChanged(dbus.String("ApprovalDuration"),
959
self.PropertyChanged(dbus.String(u"ApprovalDuration"),
1015
960
dbus.UInt64(value, variant_level=1))
1016
961
1017
962
# Name - property
1018
@dbus_service_property(_interface, signature="s", access="read")
963
@dbus_service_property(_interface, signature=u"s", access=u"read")
1019
964
def Name_dbus_property(self):
1020
965
return dbus.String(self.name)
1021
966
1022
967
# Fingerprint - property
1023
@dbus_service_property(_interface, signature="s", access="read")
968
@dbus_service_property(_interface, signature=u"s", access=u"read")
1024
969
def Fingerprint_dbus_property(self):
1025
970
return dbus.String(self.fingerprint)
1026
971
1027
972
# Host - property
1028
@dbus_service_property(_interface, signature="s",
1029
access="readwrite")
973
@dbus_service_property(_interface, signature=u"s",
974
access=u"readwrite")
1030
975
def Host_dbus_property(self, value=None):
1031
976
if value is None: # get
1032
977
return dbus.String(self.host)
1033
978
self.host = value
1034
979
# Emit D-Bus signal
1035
self.PropertyChanged(dbus.String("Host"),
980
self.PropertyChanged(dbus.String(u"Host"),
1036
981
dbus.String(value, variant_level=1))
1037
982
1038
983
# Created - property
1039
@dbus_service_property(_interface, signature="s", access="read")
984
@dbus_service_property(_interface, signature=u"s", access=u"read")
1040
985
def Created_dbus_property(self):
1041
986
return dbus.String(self._datetime_to_dbus(self.created))
1042
987
1043
988
# LastEnabled - property
1044
@dbus_service_property(_interface, signature="s", access="read")
989
@dbus_service_property(_interface, signature=u"s", access=u"read")
1045
990
def LastEnabled_dbus_property(self):
1046
991
if self.last_enabled is None:
1047
return dbus.String("")
992
return dbus.String(u"")
1048
993
return dbus.String(self._datetime_to_dbus(self.last_enabled))
1049
994
1050
995
# Enabled - property
1051
@dbus_service_property(_interface, signature="b",
1052
access="readwrite")
996
@dbus_service_property(_interface, signature=u"b",
997
access=u"readwrite")
1053
998
def Enabled_dbus_property(self, value=None):
1054
999
if value is None: # get
1055
1000
return dbus.Boolean(self.enabled)
1059
1004
self.disable()
1060
1005
1061
1006
# LastCheckedOK - property
1062
@dbus_service_property(_interface, signature="s",
1063
access="readwrite")
1007
@dbus_service_property(_interface, signature=u"s",
1008
access=u"readwrite")
1064
1009
def LastCheckedOK_dbus_property(self, value=None):
1065
1010
if value is not None:
1066
1011
self.checked_ok()
1067
1012
return
1068
1013
if self.last_checked_ok is None:
1069
return dbus.String("")
1014
return dbus.String(u"")
1070
1015
return dbus.String(self._datetime_to_dbus(self
1071
1016
.last_checked_ok))
1072
1017
1073
# LastApprovalRequest - property
1074
@dbus_service_property(_interface, signature="s", access="read")
1075
def LastApprovalRequest_dbus_property(self):
1076
if self.last_approval_request is None:
1077
return dbus.String("")
1078
return dbus.String(self.
1079
_datetime_to_dbus(self
1080
.last_approval_request))
1081
1082
1018
# Timeout - property
1083
@dbus_service_property(_interface, signature="t",
1084
access="readwrite")
1019
@dbus_service_property(_interface, signature=u"t",
1020
access=u"readwrite")
1085
1021
def Timeout_dbus_property(self, value=None):
1086
1022
if value is None: # get
1087
1023
return dbus.UInt64(self.timeout_milliseconds())
1088
1024
self.timeout = datetime.timedelta(0, 0, 0, value)
1089
1025
# Emit D-Bus signal
1090
self.PropertyChanged(dbus.String("Timeout"),
1026
self.PropertyChanged(dbus.String(u"Timeout"),
1091
1027
dbus.UInt64(value, variant_level=1))
1092
if getattr(self, "disable_initiator_tag", None) is None:
1028
if getattr(self, u"disable_initiator_tag", None) is None:
1093
1029
return
1094
1030
# Reschedule timeout
1095
1031
gobject.source_remove(self.disable_initiator_tag)
1108
1044
(time_to_die, self.disable))
1109
1045
1110
1046
# Interval - property
1111
@dbus_service_property(_interface, signature="t",
1112
access="readwrite")
1047
@dbus_service_property(_interface, signature=u"t",
1048
access=u"readwrite")
1113
1049
def Interval_dbus_property(self, value=None):
1114
1050
if value is None: # get
1115
1051
return dbus.UInt64(self.interval_milliseconds())
1116
1052
self.interval = datetime.timedelta(0, 0, 0, value)
1117
1053
# Emit D-Bus signal
1118
self.PropertyChanged(dbus.String("Interval"),
1054
self.PropertyChanged(dbus.String(u"Interval"),
1119
1055
dbus.UInt64(value, variant_level=1))
1120
if getattr(self, "checker_initiator_tag", None) is None:
1056
if getattr(self, u"checker_initiator_tag", None) is None:
1121
1057
return
1122
1058
# Reschedule checker run
1123
1059
gobject.source_remove(self.checker_initiator_tag)
1126
1062
self.start_checker() # Start one now, too
1127
1063
1128
1064
# Checker - property
1129
@dbus_service_property(_interface, signature="s",
1130
access="readwrite")
1065
@dbus_service_property(_interface, signature=u"s",
1066
access=u"readwrite")
1131
1067
def Checker_dbus_property(self, value=None):
1132
1068
if value is None: # get
1133
1069
return dbus.String(self.checker_command)
1134
1070
self.checker_command = value
1135
1071
# Emit D-Bus signal
1136
self.PropertyChanged(dbus.String("Checker"),
1072
self.PropertyChanged(dbus.String(u"Checker"),
1137
1073
dbus.String(self.checker_command,
1138
1074
variant_level=1))
1139
1075
1140
1076
# CheckerRunning - property
1141
@dbus_service_property(_interface, signature="b",
1142
access="readwrite")
1077
@dbus_service_property(_interface, signature=u"b",
1078
access=u"readwrite")
1143
1079
def CheckerRunning_dbus_property(self, value=None):
1144
1080
if value is None: # get
1145
1081
return dbus.Boolean(self.checker is not None)
1149
1085
self.stop_checker()
1150
1086
1151
1087
# ObjectPath - property
1152
@dbus_service_property(_interface, signature="o", access="read")
1088
@dbus_service_property(_interface, signature=u"o", access=u"read")
1153
1089
def ObjectPath_dbus_property(self):
1154
1090
return self.dbus_object_path # is already a dbus.ObjectPath
1155
1091
1156
1092
# Secret = property
1157
@dbus_service_property(_interface, signature="ay",
1158
access="write", byte_arrays=True)
1093
@dbus_service_property(_interface, signature=u"ay",
1094
access=u"write", byte_arrays=True)
1159
1095
def Secret_dbus_property(self, value):
1160
1096
self.secret = str(value)
1161
1097
1196
1132
1197
1133
def handle(self):
1198
1134
with contextlib.closing(self.server.child_pipe) as child_pipe:
1199
logger.info("TCP connection from: %s",
1135
logger.info(u"TCP connection from: %s",
1200
1136
unicode(self.client_address))
1201
logger.debug("Pipe FD: %d",
1137
logger.debug(u"Pipe FD: %d",
1202
1138
self.server.child_pipe.fileno())
1203
1139
1204
1140
session = (gnutls.connection
1211
1147
# no X.509 keys are added to it. Therefore, we can use it
1212
1148
# here despite using OpenPGP certificates.
1213
1149
1214
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1215
# "+AES-256-CBC", "+SHA1",
1216
# "+COMP-NULL", "+CTYPE-OPENPGP",
1217
# "+DHE-DSS"))
1150
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
1151
# u"+AES-256-CBC", u"+SHA1",
1152
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
1153
# u"+DHE-DSS"))
1218
1154
# Use a fallback default, since this MUST be set.
1219
1155
priority = self.server.gnutls_priority
1220
1156
if priority is None:
1221
priority = "NORMAL"
1157
priority = u"NORMAL"
1222
1158
(gnutls.library.functions
1223
1159
.gnutls_priority_set_direct(session._c_object,
1224
1160
priority, None))
1226
1162
# Start communication using the Mandos protocol
1227
1163
# Get protocol number
1228
1164
line = self.request.makefile().readline()
1229
logger.debug("Protocol version: %r", line)
1165
logger.debug(u"Protocol version: %r", line)
1230
1166
try:
1231
1167
if int(line.strip().split()[0]) > 1:
1232
1168
raise RuntimeError
1233
except (ValueError, IndexError, RuntimeError) as error:
1234
logger.error("Unknown protocol version: %s", error)
1169
except (ValueError, IndexError, RuntimeError), error:
1170
logger.error(u"Unknown protocol version: %s", error)
1235
1171
return
1236
1172
1237
1173
# Start GnuTLS connection
1238
1174
try:
1239
1175
session.handshake()
1240
except gnutls.errors.GNUTLSError as error:
1241
logger.warning("Handshake failed: %s", error)
1176
except gnutls.errors.GNUTLSError, error:
1177
logger.warning(u"Handshake failed: %s", error)
1242
1178
# Do not run session.bye() here: the session is not
1243
1179
# established. Just abandon the request.
1244
1180
return
1245
logger.debug("Handshake succeeded")
1181
logger.debug(u"Handshake succeeded")
1246
1182
1247
1183
approval_required = False
1248
1184
try:
1249
1185
try:
1250
1186
fpr = self.fingerprint(self.peer_certificate
1251
1187
(session))
1252
except (TypeError,
1253
gnutls.errors.GNUTLSError) as error:
1254
logger.warning("Bad certificate: %s", error)
1188
except (TypeError, gnutls.errors.GNUTLSError), error:
1189
logger.warning(u"Bad certificate: %s", error)
1255
1190
return
1256
logger.debug("Fingerprint: %s", fpr)
1191
logger.debug(u"Fingerprint: %s", fpr)
1257
1192
1258
1193
try:
1259
1194
client = ProxyClient(child_pipe, fpr,
1268
1203
1269
1204
while True:
1270
1205
if not client.enabled:
1271
logger.info("Client %s is disabled",
1206
logger.warning(u"Client %s is disabled",
1272
1207
client.name)
1273
1208
if self.server.use_dbus:
1274
1209
# Emit D-Bus signal
1279
1214
#We are approved or approval is disabled
1280
1215
break
1281
1216
elif client._approved is None:
1282
logger.info("Client %s needs approval",
1217
logger.info(u"Client %s needs approval",
1283
1218
client.name)
1284
1219
if self.server.use_dbus:
1285
1220
# Emit D-Bus signal
1287
1222
client.approval_delay_milliseconds(),
1288
1223
client.approved_by_default)
1289
1224
else:
1290
logger.warning("Client %s was not approved",
1225
logger.warning(u"Client %s was not approved",
1291
1226
client.name)
1292
1227
if self.server.use_dbus:
1293
1228
# Emit D-Bus signal
1319
1254
while sent_size < len(client.secret):
1320
1255
try:
1321
1256
sent = session.send(client.secret[sent_size:])
1322
except gnutls.errors.GNUTLSError as error:
1257
except (gnutls.errors.GNUTLSError), error:
1323
1258
logger.warning("gnutls send failed")
1324
1259
return
1325
logger.debug("Sent: %d, remaining: %d",
1260
logger.debug(u"Sent: %d, remaining: %d",
1326
1261
sent, len(client.secret)
1327
1262
- (sent_size + sent))
1328
1263
sent_size += sent
1329
1264
1330
logger.info("Sending secret to %s", client.name)
1265
logger.info(u"Sending secret to %s", client.name)
1331
1266
# bump the timeout as if seen
1332
1267
client.checked_ok()
1333
1268
if self.server.use_dbus:
1339
1274
client.approvals_pending -= 1
1340
1275
try:
1341
1276
session.bye()
1342
except gnutls.errors.GNUTLSError as error:
1277
except (gnutls.errors.GNUTLSError), error:
1343
1278
logger.warning("GnuTLS bye failed")
1344
1279
1345
1280
@staticmethod
1356
1291
.gnutls_certificate_get_peers
1357
1292
(session._c_object, ctypes.byref(list_size)))
1358
1293
if not bool(cert_list) and list_size.value != 0:
1359
raise gnutls.errors.GNUTLSError("error getting peer"
1360
" certificate")
1294
raise gnutls.errors.GNUTLSError(u"error getting peer"
1295
u" certificate")
1361
1296
if list_size.value == 0:
1362
1297
return None
1363
1298
cert = cert_list[0]
1389
1324
if crtverify.value != 0:
1390
1325
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1391
1326
raise (gnutls.errors.CertificateSecurityError
1392
("Verify failed"))
1327
(u"Verify failed"))
1393
1328
# New buffer for the fingerprint
1394
1329
buf = ctypes.create_string_buffer(20)
1395
1330
buf_len = ctypes.c_size_t()
1402
1337
# Convert the buffer to a Python bytestring
1403
1338
fpr = ctypes.string_at(buf, buf_len.value)
1404
1339
# Convert the bytestring to hexadecimal notation
1405
hex_fpr = ''.join("%02X" % ord(char) for char in fpr)
1340
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
1406
1341
return hex_fpr
1407
1342
1408
1343
1436
1371
1437
1372
def add_pipe(self, parent_pipe):
1438
1373
"""Dummy function; override as necessary"""
1439
raise NotImplementedError
1374
pass
1440
1375
1441
1376
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1442
1377
socketserver.TCPServer, object):
1460
1395
bind to an address or port if they were not specified."""
1461
1396
if self.interface is not None:
1462
1397
if SO_BINDTODEVICE is None:
1463
logger.error("SO_BINDTODEVICE does not exist;"
1464
" cannot bind to interface %s",
1398
logger.error(u"SO_BINDTODEVICE does not exist;"
1399
u" cannot bind to interface %s",
1465
1400
self.interface)
1466
1401
else:
1467
1402
try:
1468
1403
self.socket.setsockopt(socket.SOL_SOCKET,
1469
1404
SO_BINDTODEVICE,
1470
1405
str(self.interface
1471
+ '\0'))
1472
except socket.error as error:
1406
+ u'\0'))
1407
except socket.error, error:
1473
1408
if error[0] == errno.EPERM:
1474
logger.error("No permission to"
1475
" bind to interface %s",
1409
logger.error(u"No permission to"
1410
u" bind to interface %s",
1476
1411
self.interface)
1477
1412
elif error[0] == errno.ENOPROTOOPT:
1478
logger.error("SO_BINDTODEVICE not available;"
1479
" cannot bind to interface %s",
1413
logger.error(u"SO_BINDTODEVICE not available;"
1414
u" cannot bind to interface %s",
1480
1415
self.interface)
1481
1416
else:
1482
1417
raise
1484
1419
if self.server_address[0] or self.server_address[1]:
1485
1420
if not self.server_address[0]:
1486
1421
if self.address_family == socket.AF_INET6:
1487
any_address = "::" # in6addr_any
1422
any_address = u"::" # in6addr_any
1488
1423
else:
1489
1424
any_address = socket.INADDR_ANY
1490
1425
self.server_address = (any_address,
1539
1474
def handle_ipc(self, source, condition, parent_pipe=None,
1540
1475
client_object=None):
1541
1476
condition_names = {
1542
gobject.IO_IN: "IN", # There is data to read.
1543
gobject.IO_OUT: "OUT", # Data can be written (without
1477
gobject.IO_IN: u"IN", # There is data to read.
1478
gobject.IO_OUT: u"OUT", # Data can be written (without
1544
1479
# blocking).
1545
gobject.IO_PRI: "PRI", # There is urgent data to read.
1546
gobject.IO_ERR: "ERR", # Error condition.
1547
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1480
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1481
gobject.IO_ERR: u"ERR", # Error condition.
1482
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1548
1483
# broken, usually for pipes and
1549
1484
# sockets).
1550
1485
}
1569
1504
client = c
1570
1505
break
1571
1506
else:
1572
logger.info("Client not found for fingerprint: %s, ad"
1573
"dress: %s", fpr, address)
1507
logger.warning(u"Client not found for fingerprint: %s, ad"
1508
u"dress: %s", fpr, address)
1574
1509
if self.use_dbus:
1575
1510
# Emit D-Bus signal
1576
mandos_dbus_service.ClientNotFound(fpr, address[0])
1511
mandos_dbus_service.ClientNotFound(fpr, address)
1577
1512
parent_pipe.send(False)
1578
1513
return False
1579
1514
1610
1545
def string_to_delta(interval):
1611
1546
"""Parse a string and return a datetime.timedelta
1612
1547
1613
>>> string_to_delta('7d')
1548
>>> string_to_delta(u'7d')
1614
1549
datetime.timedelta(7)
1615
>>> string_to_delta('60s')
1550
>>> string_to_delta(u'60s')
1616
1551
datetime.timedelta(0, 60)
1617
>>> string_to_delta('60m')
1552
>>> string_to_delta(u'60m')
1618
1553
datetime.timedelta(0, 3600)
1619
>>> string_to_delta('24h')
1554
>>> string_to_delta(u'24h')
1620
1555
datetime.timedelta(1)
1621
>>> string_to_delta('1w')
1556
>>> string_to_delta(u'1w')
1622
1557
datetime.timedelta(7)
1623
>>> string_to_delta('5m 30s')
1558
>>> string_to_delta(u'5m 30s')
1624
1559
datetime.timedelta(0, 330)
1625
1560
"""
1626
1561
timevalue = datetime.timedelta(0)
1628
1563
try:
1629
1564
suffix = unicode(s[-1])
1630
1565
value = int(s[:-1])
1631
if suffix == "d":
1566
if suffix == u"d":
1632
1567
delta = datetime.timedelta(value)
1633
elif suffix == "s":
1568
elif suffix == u"s":
1634
1569
delta = datetime.timedelta(0, value)
1635
elif suffix == "m":
1570
elif suffix == u"m":
1636
1571
delta = datetime.timedelta(0, 0, 0, 0, value)
1637
elif suffix == "h":
1572
elif suffix == u"h":
1638
1573
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1639
elif suffix == "w":
1574
elif suffix == u"w":
1640
1575
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1641
1576
else:
1642
raise ValueError("Unknown suffix %r" % suffix)
1643
except (ValueError, IndexError) as e:
1644
raise ValueError(*(e.args))
1577
raise ValueError(u"Unknown suffix %r" % suffix)
1578
except (ValueError, IndexError), e:
1579
raise ValueError(e.message)
1645
1580
timevalue += delta
1646
1581
return timevalue
1647
1582
1653
1588
global if_nametoindex
1654
1589
try:
1655
1590
if_nametoindex = (ctypes.cdll.LoadLibrary
1656
(ctypes.util.find_library("c"))
1591
(ctypes.util.find_library(u"c"))
1657
1592
.if_nametoindex)
1658
1593
except (OSError, AttributeError):
1659
logger.warning("Doing if_nametoindex the hard way")
1594
logger.warning(u"Doing if_nametoindex the hard way")
1660
1595
def if_nametoindex(interface):
1661
1596
"Get an interface index the hard way, i.e. using fcntl()"
1662
1597
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1663
1598
with contextlib.closing(socket.socket()) as s:
1664
1599
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1665
struct.pack(str("16s16x"),
1600
struct.pack(str(u"16s16x"),
1666
1601
interface))
1667
interface_index = struct.unpack(str("I"),
1602
interface_index = struct.unpack(str(u"I"),
1668
1603
ifreq[16:20])[0]
1669
1604
return interface_index
1670
1605
return if_nametoindex(interface)
1678
1613
sys.exit()
1679
1614
os.setsid()
1680
1615
if not nochdir:
1681
os.chdir("/")
1616
os.chdir(u"/")
1682
1617
if os.fork():
1683
1618
sys.exit()
1684
1619
if not noclose:
1686
1621
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1687
1622
if not stat.S_ISCHR(os.fstat(null).st_mode):
1688
1623
raise OSError(errno.ENODEV,
1689
"%s not a character device"
1624
u"%s not a character device"
1690
1625
% os.path.devnull)
1691
1626
os.dup2(null, sys.stdin.fileno())
1692
1627
os.dup2(null, sys.stdout.fileno())
1700
1635
##################################################################
1701
1636
# Parsing of options, both command line and config file
1702
1637
1703
parser = argparse.ArgumentParser()
1704
parser.add_argument("-v", "--version", action="version",
1705
version = "%%(prog)s %s" % version,
1706
help="show version number and exit")
1707
parser.add_argument("-i", "--interface", metavar="IF",
1708
help="Bind to interface IF")
1709
parser.add_argument("-a", "--address",
1710
help="Address to listen for requests on")
1711
parser.add_argument("-p", "--port", type=int,
1712
help="Port number to receive requests on")
1713
parser.add_argument("--check", action="store_true",
1714
help="Run self-test")
1715
parser.add_argument("--debug", action="store_true",
1716
help="Debug mode; run in foreground and log"
1717
" to terminal")
1718
parser.add_argument("--debuglevel", metavar="LEVEL",
1719
help="Debug level for stdout output")
1720
parser.add_argument("--priority", help="GnuTLS"
1721
" priority string (see GnuTLS documentation)")
1722
parser.add_argument("--servicename",
1723
metavar="NAME", help="Zeroconf service name")
1724
parser.add_argument("--configdir",
1725
default="/etc/mandos", metavar="DIR",
1726
help="Directory to search for configuration"
1727
" files")
1728
parser.add_argument("--no-dbus", action="store_false",
1729
dest="use_dbus", help="Do not provide D-Bus"
1730
" system bus interface")
1731
parser.add_argument("--no-ipv6", action="store_false",
1732
dest="use_ipv6", help="Do not use IPv6")
1733
options = parser.parse_args()
1638
parser = optparse.OptionParser(version = "%%prog %s" % version)
1639
parser.add_option("-i", u"--interface", type=u"string",
1640
metavar="IF", help=u"Bind to interface IF")
1641
parser.add_option("-a", u"--address", type=u"string",
1642
help=u"Address to listen for requests on")
1643
parser.add_option("-p", u"--port", type=u"int",
1644
help=u"Port number to receive requests on")
1645
parser.add_option("--check", action=u"store_true",
1646
help=u"Run self-test")
1647
parser.add_option("--debug", action=u"store_true",
1648
help=u"Debug mode; run in foreground and log to"
1649
u" terminal")
1650
parser.add_option("--debuglevel", type=u"string", metavar="Level",
1651
help=u"Debug level for stdout output")
1652
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1653
u" priority string (see GnuTLS documentation)")
1654
parser.add_option("--servicename", type=u"string",
1655
metavar=u"NAME", help=u"Zeroconf service name")
1656
parser.add_option("--configdir", type=u"string",
1657
default=u"/etc/mandos", metavar=u"DIR",
1658
help=u"Directory to search for configuration"
1659
u" files")
1660
parser.add_option("--no-dbus", action=u"store_false",
1661
dest=u"use_dbus", help=u"Do not provide D-Bus"
1662
u" system bus interface")
1663
parser.add_option("--no-ipv6", action=u"store_false",
1664
dest=u"use_ipv6", help=u"Do not use IPv6")
1665
options = parser.parse_args()[0]
1734
1666
1735
1667
if options.check:
1736
1668
import doctest
1738
1670
sys.exit()
1739
1671
1740
1672
# Default values for config file for server-global settings
1741
server_defaults = { "interface": "",
1742
"address": "",
1743
"port": "",
1744
"debug": "False",
1745
"priority":
1746
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1747
"servicename": "Mandos",
1748
"use_dbus": "True",
1749
"use_ipv6": "True",
1750
"debuglevel": "",
1673
server_defaults = { u"interface": u"",
1674
u"address": u"",
1675
u"port": u"",
1676
u"debug": u"False",
1677
u"priority":
1678
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1679
u"servicename": u"Mandos",
1680
u"use_dbus": u"True",
1681
u"use_ipv6": u"True",
1682
u"debuglevel": u"",
1751
1683
}
1752
1684
1753
1685
# Parse config file for server-global settings
1754
1686
server_config = configparser.SafeConfigParser(server_defaults)
1755
1687
del server_defaults
1756
1688
server_config.read(os.path.join(options.configdir,
1757
"mandos.conf"))
1689
u"mandos.conf"))
1758
1690
# Convert the SafeConfigParser object to a dict
1759
1691
server_settings = server_config.defaults()
1760
1692
# Use the appropriate methods on the non-string config options
1761
for option in ("debug", "use_dbus", "use_ipv6"):
1762
server_settings[option] = server_config.getboolean("DEFAULT",
1693
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1694
server_settings[option] = server_config.getboolean(u"DEFAULT",
1763
1695
option)
1764
1696
if server_settings["port"]:
1765
server_settings["port"] = server_config.getint("DEFAULT",
1766
"port")
1697
server_settings["port"] = server_config.getint(u"DEFAULT",
1698
u"port")
1767
1699
del server_config
1768
1700
1769
1701
# Override the settings from the config file with command line
1770
1702
# options, if set.
1771
for option in ("interface", "address", "port", "debug",
1772
"priority", "servicename", "configdir",
1773
"use_dbus", "use_ipv6", "debuglevel"):
1703
for option in (u"interface", u"address", u"port", u"debug",
1704
u"priority", u"servicename", u"configdir",
1705
u"use_dbus", u"use_ipv6", u"debuglevel"):
1774
1706
value = getattr(options, option)
1775
1707
if value is not None:
1776
1708
server_settings[option] = value
1784
1716
##################################################################
1785
1717
1786
1718
# For convenience
1787
debug = server_settings["debug"]
1788
debuglevel = server_settings["debuglevel"]
1789
use_dbus = server_settings["use_dbus"]
1790
use_ipv6 = server_settings["use_ipv6"]
1719
debug = server_settings[u"debug"]
1720
debuglevel = server_settings[u"debuglevel"]
1721
use_dbus = server_settings[u"use_dbus"]
1722
use_ipv6 = server_settings[u"use_ipv6"]
1791
1723
1792
if server_settings["servicename"] != "Mandos":
1724
if server_settings[u"servicename"] != u"Mandos":
1793
1725
syslogger.setFormatter(logging.Formatter
1794
('Mandos (%s) [%%(process)d]:'
1795
' %%(levelname)s: %%(message)s'
1796
% server_settings["servicename"]))
1726
(u'Mandos (%s) [%%(process)d]:'
1727
u' %%(levelname)s: %%(message)s'
1728
% server_settings[u"servicename"]))
1797
1729
1798
1730
# Parse config file with clients
1799
client_defaults = { "timeout": "1h",
1800
"interval": "5m",
1801
"checker": "fping -q -- %%(host)s",
1802
"host": "",
1803
"approval_delay": "0s",
1804
"approval_duration": "1s",
1731
client_defaults = { u"timeout": u"1h",
1732
u"interval": u"5m",
1733
u"checker": u"fping -q -- %%(host)s",
1734
u"host": u"",
1735
u"approval_delay": u"0s",
1736
u"approval_duration": u"1s",
1805
1737
}
1806
1738
client_config = configparser.SafeConfigParser(client_defaults)
1807
client_config.read(os.path.join(server_settings["configdir"],
1808
"clients.conf"))
1739
client_config.read(os.path.join(server_settings[u"configdir"],
1740
u"clients.conf"))
1809
1741
1810
1742
global mandos_dbus_service
1811
1743
mandos_dbus_service = None
1812
1744
1813
tcp_server = MandosServer((server_settings["address"],
1814
server_settings["port"]),
1745
tcp_server = MandosServer((server_settings[u"address"],
1746
server_settings[u"port"]),
1815
1747
ClientHandler,
1816
interface=(server_settings["interface"]
1748
interface=(server_settings[u"interface"]
1817
1749
or None),
1818
1750
use_ipv6=use_ipv6,
1819
1751
gnutls_priority=
1820
server_settings["priority"],
1752
server_settings[u"priority"],
1821
1753
use_dbus=use_dbus)
1822
if not debug:
1823
pidfilename = "/var/run/mandos.pid"
1824
try:
1825
pidfile = open(pidfilename, "w")
1826
except IOError:
1827
logger.error("Could not open file %r", pidfilename)
1754
pidfilename = u"/var/run/mandos.pid"
1755
try:
1756
pidfile = open(pidfilename, u"w")
1757
except IOError:
1758
logger.error(u"Could not open file %r", pidfilename)
1828
1759
1829
1760
try:
1830
uid = pwd.getpwnam("_mandos").pw_uid
1831
gid = pwd.getpwnam("_mandos").pw_gid
1761
uid = pwd.getpwnam(u"_mandos").pw_uid
1762
gid = pwd.getpwnam(u"_mandos").pw_gid
1832
1763
except KeyError:
1833
1764
try:
1834
uid = pwd.getpwnam("mandos").pw_uid
1835
gid = pwd.getpwnam("mandos").pw_gid
1765
uid = pwd.getpwnam(u"mandos").pw_uid
1766
gid = pwd.getpwnam(u"mandos").pw_gid
1836
1767
except KeyError:
1837
1768
try:
1838
uid = pwd.getpwnam("nobody").pw_uid
1839
gid = pwd.getpwnam("nobody").pw_gid
1769
uid = pwd.getpwnam(u"nobody").pw_uid
1770
gid = pwd.getpwnam(u"nobody").pw_gid
1840
1771
except KeyError:
1841
1772
uid = 65534
1842
1773
gid = 65534
1843
1774
try:
1844
1775
os.setgid(gid)
1845
1776
os.setuid(uid)
1846
except OSError as error:
1777
except OSError, error:
1847
1778
if error[0] != errno.EPERM:
1848
1779
raise error
1849
1780
1864
1795
1865
1796
@gnutls.library.types.gnutls_log_func
1866
1797
def debug_gnutls(level, string):
1867
logger.debug("GnuTLS: %s", string[:-1])
1798
logger.debug(u"GnuTLS: %s", string[:-1])
1868
1799
1869
1800
(gnutls.library.functions
1870
1801
.gnutls_global_set_log_function(debug_gnutls))
1878
1809
# No console logging
1879
1810
logger.removeHandler(console)
1880
1811
1881
# Need to fork before connecting to D-Bus
1882
if not debug:
1883
# Close all input and output, do double fork, etc.
1884
daemon()
1885
1812
1886
1813
global main_loop
1887
1814
# From the Avahi example code
1891
1818
# End of Avahi example code
1892
1819
if use_dbus:
1893
1820
try:
1894
bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",
1821
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
1895
1822
bus, do_not_queue=True)
1896
except dbus.exceptions.NameExistsException as e:
1897
logger.error(unicode(e) + ", disabling D-Bus")
1823
except dbus.exceptions.NameExistsException, e:
1824
logger.error(unicode(e) + u", disabling D-Bus")
1898
1825
use_dbus = False
1899
server_settings["use_dbus"] = False
1826
server_settings[u"use_dbus"] = False
1900
1827
tcp_server.use_dbus = False
1901
1828
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1902
service = AvahiService(name = server_settings["servicename"],
1903
servicetype = "_mandos._tcp",
1829
service = AvahiService(name = server_settings[u"servicename"],
1830
servicetype = u"_mandos._tcp",
1904
1831
protocol = protocol, bus = bus)
1905
1832
if server_settings["interface"]:
1906
1833
service.interface = (if_nametoindex
1907
(str(server_settings["interface"])))
1908
1834
(str(server_settings[u"interface"])))
1835
1836
if not debug:
1837
# Close all input and output, do double fork, etc.
1838
daemon()
1839
1909
1840
global multiprocessing_manager
1910
1841
multiprocessing_manager = multiprocessing.Manager()
1911
1842
1930
1861
client_config, section)))
1931
1862
for section in client_config.sections()))
1932
1863
if not tcp_server.clients:
1933
logger.warning("No clients defined")
1864
logger.warning(u"No clients defined")
1934
1865
1866
try:
1867
with pidfile:
1868
pid = os.getpid()
1869
pidfile.write(str(pid) + "\n")
1870
del pidfile
1871
except IOError:
1872
logger.error(u"Could not write to file %r with PID %d",
1873
pidfilename, pid)
1874
except NameError:
1875
# "pidfile" was never created
1876
pass
1877
del pidfilename
1878
1935
1879
if not debug:
1936
try:
1937
with pidfile:
1938
pid = os.getpid()
1939
pidfile.write(str(pid) + "\n".encode("utf-8"))
1940
del pidfile
1941
except IOError:
1942
logger.error("Could not write to file %r with PID %d",
1943
pidfilename, pid)
1944
except NameError:
1945
# "pidfile" was never created
1946
pass
1947
del pidfilename
1948
1949
1880
signal.signal(signal.SIGINT, signal.SIG_IGN)
1950
1951
1881
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1952
1882
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1953
1883
1955
1885
class MandosDBusService(dbus.service.Object):
1956
1886
"""A D-Bus proxy object"""
1957
1887
def __init__(self):
1958
dbus.service.Object.__init__(self, bus, "/")
1959
_interface = "se.bsnet.fukt.Mandos"
1888
dbus.service.Object.__init__(self, bus, u"/")
1889
_interface = u"se.bsnet.fukt.Mandos"
1960
1890
1961
@dbus.service.signal(_interface, signature="o")
1891
@dbus.service.signal(_interface, signature=u"o")
1962
1892
def ClientAdded(self, objpath):
1963
1893
"D-Bus signal"
1964
1894
pass
1965
1895
1966
@dbus.service.signal(_interface, signature="ss")
1896
@dbus.service.signal(_interface, signature=u"ss")
1967
1897
def ClientNotFound(self, fingerprint, address):
1968
1898
"D-Bus signal"
1969
1899
pass
1970
1900
1971
@dbus.service.signal(_interface, signature="os")
1901
@dbus.service.signal(_interface, signature=u"os")
1972
1902
def ClientRemoved(self, objpath, name):
1973
1903
"D-Bus signal"
1974
1904
pass
1975
1905
1976
@dbus.service.method(_interface, out_signature="ao")
1906
@dbus.service.method(_interface, out_signature=u"ao")
1977
1907
def GetAllClients(self):
1978
1908
"D-Bus method"
1979
1909
return dbus.Array(c.dbus_object_path
1980
1910
for c in tcp_server.clients)
1981
1911
1982
1912
@dbus.service.method(_interface,
1983
out_signature="a{oa{sv}}")
1913
out_signature=u"a{oa{sv}}")
1984
1914
def GetAllClientsWithProperties(self):
1985
1915
"D-Bus method"
1986
1916
return dbus.Dictionary(
1987
((c.dbus_object_path, c.GetAll(""))
1917
((c.dbus_object_path, c.GetAll(u""))
1988
1918
for c in tcp_server.clients),
1989
signature="oa{sv}")
1919
signature=u"oa{sv}")
1990
1920
1991
@dbus.service.method(_interface, in_signature="o")
1921
@dbus.service.method(_interface, in_signature=u"o")
1992
1922
def RemoveClient(self, object_path):
1993
1923
"D-Bus method"
1994
1924
for c in tcp_server.clients:
2036
1966
# Find out what port we got
2037
1967
service.port = tcp_server.socket.getsockname()[1]
2038
1968
if use_ipv6:
2039
logger.info("Now listening on address %r, port %d,"
1969
logger.info(u"Now listening on address %r, port %d,"
2040
1970
" flowinfo %d, scope_id %d"
2041
1971
% tcp_server.socket.getsockname())
2042
1972
else: # IPv4
2043
logger.info("Now listening on address %r, port %d"
1973
logger.info(u"Now listening on address %r, port %d"
2044
1974
% tcp_server.socket.getsockname())
2045
1975
2046
1976
#service.interface = tcp_server.socket.getsockname()[3]
2049
1979
# From the Avahi example code
2050
1980
try:
2051
1981
service.activate()
2052
except dbus.exceptions.DBusException as error:
2053
logger.critical("DBusException: %s", error)
1982
except dbus.exceptions.DBusException, error:
1983
logger.critical(u"DBusException: %s", error)
2054
1984
cleanup()
2055
1985
sys.exit(1)
2056
1986
# End of Avahi example code
2060
1990
(tcp_server.handle_request
2061
1991
(*args[2:], **kwargs) or True))
2062
1992
2063
logger.debug("Starting main loop")
1993
logger.debug(u"Starting main loop")
2064
1994
main_loop.run()
2065
except AvahiError as error:
2066
logger.critical("AvahiError: %s", error)
1995
except AvahiError, error:
1996
logger.critical(u"AvahiError: %s", error)
2067
1997
cleanup()
2068
1998
sys.exit(1)
2069
1999
except KeyboardInterrupt:
2070
2000
if debug:
2071
print("", file=sys.stderr)
2072
logger.debug("Server received KeyboardInterrupt")
2073
logger.debug("Server exiting")
2001
print >> sys.stderr
2002
logger.debug(u"Server received KeyboardInterrupt")
2003
logger.debug(u"Server exiting")
2074
2004
# Must run before the D-Bus bus name gets deregistered
2075
2005
cleanup()
2076
2006
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0