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