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