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 324
- compare with another revision
- download diff
- download tarball
- view history from revision 324
- Committer: Teddy Hogeborn
- Date: 2009-02-25 01:47:45 UTC
- mfrom: (237.2.18 mandos-release)
- Revision ID: teddy@fukt.bsnet.se-20090225014745-8yyzt3b2q56nzk9l
Merge from release branch.
- files added:
- .bzr-builddeb
- debian
- debian/po
- files removed:
- network-protocol.txt
- files renamed:
- mandos-client.c => plugin-runner.c
- mandos-client.xml => plugin-runner.xml
- plugins.d/password-request.c => plugins.d/mandos-client.c
- plugins.d/password-request.xml => plugins.d/mandos-client.xml
- files modified:
- Makefile
added
removed
mandos
11
11
# and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
14
# Copyright © 2008,2009 Teddy Hogeborn
15
# Copyright © 2008,2009 Björn Påhlsson
15
16
#
16
17
# This program is free software: you can redistribute it and/or modify
17
18
# it under the terms of the GNU General Public License as published by
24
25
# GNU General Public License for more details.
25
26
#
26
27
# You should have received a copy of the GNU General Public License
27
# along with this program. If not, see <http://www.gnu.org/licenses/>.
28
# along with this program. If not, see
29
# <http://www.gnu.org/licenses/>.
28
30
#
29
31
# Contact the authors at <mandos@fukt.bsnet.se>.
30
32
#
31
33
32
from __future__ import division
34
from __future__ import division, with_statement, absolute_import
33
35
34
36
import SocketServer
35
37
import socket
36
import select
37
from optparse import OptionParser
38
import optparse
38
39
import datetime
39
40
import errno
40
41
import gnutls.crypto
54
55
import stat
55
56
import logging
56
57
import logging.handlers
58
import pwd
59
from contextlib import closing
57
60
58
61
import dbus
62
import dbus.service
59
63
import gobject
60
64
import avahi
61
65
from dbus.mainloop.glib import DBusGMainLoop
62
66
import ctypes
67
import ctypes.util
63
68
64
version = "1.0"
69
version = "1.0.8"
65
70
66
71
logger = logging.Logger('mandos')
67
syslogger = logging.handlers.SysLogHandler\
68
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
69
address = "/dev/log")
70
syslogger.setFormatter(logging.Formatter\
71
('Mandos: %(levelname)s: %(message)s'))
72
syslogger = (logging.handlers.SysLogHandler
73
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
74
address = "/dev/log"))
75
syslogger.setFormatter(logging.Formatter
76
('Mandos [%(process)d]: %(levelname)s:'
77
' %(message)s'))
72
78
logger.addHandler(syslogger)
73
79
74
80
console = logging.StreamHandler()
75
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
76
' %(message)s'))
81
console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'
82
' %(levelname)s: %(message)s'))
77
83
logger.addHandler(console)
78
84
79
85
class AvahiError(Exception):
80
def __init__(self, value):
86
def __init__(self, value, *args, **kwargs):
81
87
self.value = value
82
def __str__(self):
83
return repr(self.value)
88
super(AvahiError, self).__init__(value, *args, **kwargs)
89
def __unicode__(self):
90
return unicode(repr(self.value))
84
91
85
92
class AvahiServiceError(AvahiError):
86
93
pass
106
113
a sensible number of times
107
114
"""
108
115
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
109
type = None, port = None, TXT = None, domain = "",
110
host = "", max_renames = 32768):
116
servicetype = None, port = None, TXT = None,
117
domain = "", host = "", max_renames = 32768,
118
protocol = avahi.PROTO_UNSPEC):
111
119
self.interface = interface
112
120
self.name = name
113
self.type = type
121
self.type = servicetype
114
122
self.port = port
115
if TXT is None:
116
self.TXT = []
117
else:
118
self.TXT = TXT
123
self.TXT = TXT if TXT is not None else []
119
124
self.domain = domain
120
125
self.host = host
121
126
self.rename_count = 0
127
self.max_renames = max_renames
128
self.protocol = protocol
122
129
def rename(self):
123
130
"""Derived from the Avahi example code"""
124
131
if self.rename_count >= self.max_renames:
125
logger.critical(u"No suitable service name found after %i"
126
u" retries, exiting.", rename_count)
127
raise AvahiServiceError("Too many renames")
128
name = server.GetAlternativeServiceName(name)
129
logger.error(u"Changing name to %r ...", name)
130
syslogger.setFormatter(logging.Formatter\
132
logger.critical(u"No suitable Zeroconf service name found"
133
u" after %i retries, exiting.",
134
self.rename_count)
135
raise AvahiServiceError(u"Too many renames")
136
self.name = server.GetAlternativeServiceName(self.name)
137
logger.info(u"Changing Zeroconf service name to %r ...",
138
str(self.name))
139
syslogger.setFormatter(logging.Formatter
131
140
('Mandos (%s): %%(levelname)s:'
132
' %%(message)s' % name))
141
' %%(message)s' % self.name))
133
142
self.remove()
134
143
self.add()
135
144
self.rename_count += 1
141
150
"""Derived from the Avahi example code"""
142
151
global group
143
152
if group is None:
144
group = dbus.Interface\
145
(bus.get_object(avahi.DBUS_NAME,
153
group = dbus.Interface(bus.get_object
154
(avahi.DBUS_NAME,
146
155
server.EntryGroupNew()),
147
avahi.DBUS_INTERFACE_ENTRY_GROUP)
156
avahi.DBUS_INTERFACE_ENTRY_GROUP)
148
157
group.connect_to_signal('StateChanged',
149
158
entry_group_state_changed)
150
logger.debug(u"Adding service '%s' of type '%s' ...",
159
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
151
160
service.name, service.type)
152
161
group.AddService(
153
162
self.interface, # interface
154
avahi.PROTO_INET6, # protocol
163
self.protocol, # protocol
155
164
dbus.UInt32(0), # flags
156
165
self.name, self.type,
157
166
self.domain, self.host,
164
173
# End of Avahi example code
165
174
166
175
167
class Client(object):
176
def _datetime_to_dbus(dt, variant_level=0):
177
"""Convert a UTC datetime.datetime() to a D-Bus type."""
178
return dbus.String(dt.isoformat(), variant_level=variant_level)
179
180
181
class Client(dbus.service.Object):
168
182
"""A representation of a client host served by this server.
169
183
Attributes:
170
name: string; from the config file, used in log messages
184
name: string; from the config file, used in log messages and
185
D-Bus identifiers
171
186
fingerprint: string (40 or 32 hexadecimal digits); used to
172
187
uniquely identify the client
173
secret: bytestring; sent verbatim (over TLS) to client
174
host: string; available for use by the checker command
175
created: datetime.datetime(); object creation, not client host
176
last_checked_ok: datetime.datetime() or None if not yet checked OK
177
timeout: datetime.timedelta(); How long from last_checked_ok
178
until this client is invalid
179
interval: datetime.timedelta(); How often to start a new checker
180
stop_hook: If set, called by stop() as stop_hook(self)
181
checker: subprocess.Popen(); a running checker process used
182
to see if the client lives.
183
'None' if no process is running.
188
secret: bytestring; sent verbatim (over TLS) to client
189
host: string; available for use by the checker command
190
created: datetime.datetime(); (UTC) object creation
191
last_enabled: datetime.datetime(); (UTC)
192
enabled: bool()
193
last_checked_ok: datetime.datetime(); (UTC) or None
194
timeout: datetime.timedelta(); How long from last_checked_ok
195
until this client is invalid
196
interval: datetime.timedelta(); How often to start a new checker
197
disable_hook: If set, called by disable() as disable_hook(self)
198
checker: subprocess.Popen(); a running checker process used
199
to see if the client lives.
200
'None' if no process is running.
184
201
checker_initiator_tag: a gobject event source tag, or None
185
stop_initiator_tag: - '' -
202
disable_initiator_tag: - '' -
186
203
checker_callback_tag: - '' -
187
204
checker_command: string; External command which is run to check if
188
205
client lives. %() expansions are done at
189
206
runtime with vars(self) as dict, so that for
190
207
instance %(name)s can be used in the command.
191
Private attibutes:
192
_timeout: Real variable for 'timeout'
193
_interval: Real variable for 'interval'
194
_timeout_milliseconds: Used when calling gobject.timeout_add()
195
_interval_milliseconds: - '' -
208
current_checker_command: string; current running checker_command
209
use_dbus: bool(); Whether to provide D-Bus interface and signals
210
dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus
196
211
"""
197
def _set_timeout(self, timeout):
198
"Setter function for 'timeout' attribute"
199
self._timeout = timeout
200
self._timeout_milliseconds = ((self.timeout.days
201
* 24 * 60 * 60 * 1000)
202
+ (self.timeout.seconds * 1000)
203
+ (self.timeout.microseconds
204
// 1000))
205
timeout = property(lambda self: self._timeout,
206
_set_timeout)
207
del _set_timeout
208
def _set_interval(self, interval):
209
"Setter function for 'interval' attribute"
210
self._interval = interval
211
self._interval_milliseconds = ((self.interval.days
212
* 24 * 60 * 60 * 1000)
213
+ (self.interval.seconds
214
* 1000)
215
+ (self.interval.microseconds
216
// 1000))
217
interval = property(lambda self: self._interval,
218
_set_interval)
219
del _set_interval
220
def __init__(self, name = None, stop_hook=None, config={}):
212
def timeout_milliseconds(self):
213
"Return the 'timeout' attribute in milliseconds"
214
return ((self.timeout.days * 24 * 60 * 60 * 1000)
215
+ (self.timeout.seconds * 1000)
216
+ (self.timeout.microseconds // 1000))
217
218
def interval_milliseconds(self):
219
"Return the 'interval' attribute in milliseconds"
220
return ((self.interval.days * 24 * 60 * 60 * 1000)
221
+ (self.interval.seconds * 1000)
222
+ (self.interval.microseconds // 1000))
223
224
def __init__(self, name = None, disable_hook=None, config=None,
225
use_dbus=True):
221
226
"""Note: the 'checker' key in 'config' sets the
222
227
'checker_command' attribute and *not* the 'checker'
223
228
attribute."""
224
229
self.name = name
230
if config is None:
231
config = {}
225
232
logger.debug(u"Creating client %r", self.name)
233
self.use_dbus = False # During __init__
226
234
# Uppercase and remove spaces from fingerprint for later
227
235
# comparison purposes with return value from the fingerprint()
228
236
# function
229
self.fingerprint = config["fingerprint"].upper()\
230
.replace(u" ", u"")
237
self.fingerprint = (config["fingerprint"].upper()
238
.replace(u" ", u""))
231
239
logger.debug(u" Fingerprint: %s", self.fingerprint)
232
240
if "secret" in config:
233
241
self.secret = config["secret"].decode(u"base64")
234
242
elif "secfile" in config:
235
sf = open(config["secfile"])
236
self.secret = sf.read()
237
sf.close()
243
with closing(open(os.path.expanduser
244
(os.path.expandvars
245
(config["secfile"])))) as secfile:
246
self.secret = secfile.read()
238
247
else:
239
248
raise TypeError(u"No secret or secfile for client %s"
240
249
% self.name)
241
250
self.host = config.get("host", "")
242
self.created = datetime.datetime.now()
251
self.created = datetime.datetime.utcnow()
252
self.enabled = False
253
self.last_enabled = None
243
254
self.last_checked_ok = None
244
255
self.timeout = string_to_delta(config["timeout"])
245
256
self.interval = string_to_delta(config["interval"])
246
self.stop_hook = stop_hook
257
self.disable_hook = disable_hook
247
258
self.checker = None
248
259
self.checker_initiator_tag = None
249
self.stop_initiator_tag = None
260
self.disable_initiator_tag = None
250
261
self.checker_callback_tag = None
251
self.check_command = config["checker"]
252
def start(self):
262
self.checker_command = config["checker"]
263
self.current_checker_command = None
264
self.last_connect = None
265
# Only now, when this client is initialized, can it show up on
266
# the D-Bus
267
self.use_dbus = use_dbus
268
if self.use_dbus:
269
self.dbus_object_path = (dbus.ObjectPath
270
("/clients/"
271
+ self.name.replace(".", "_")))
272
dbus.service.Object.__init__(self, bus,
273
self.dbus_object_path)
274
275
def enable(self):
253
276
"""Start this client's checker and timeout hooks"""
277
self.last_enabled = datetime.datetime.utcnow()
254
278
# Schedule a new checker to be started an 'interval' from now,
255
279
# and every interval from then on.
256
self.checker_initiator_tag = gobject.timeout_add\
257
(self._interval_milliseconds,
258
self.start_checker)
280
self.checker_initiator_tag = (gobject.timeout_add
281
(self.interval_milliseconds(),
282
self.start_checker))
259
283
# Also start a new checker *right now*.
260
284
self.start_checker()
261
# Schedule a stop() when 'timeout' has passed
262
self.stop_initiator_tag = gobject.timeout_add\
263
(self._timeout_milliseconds,
264
self.stop)
265
def stop(self):
266
"""Stop this client.
267
The possibility that a client might be restarted is left open,
268
but not currently used."""
269
# If this client doesn't have a secret, it is already stopped.
270
if hasattr(self, "secret") and self.secret:
271
logger.info(u"Stopping client %s", self.name)
272
self.secret = None
273
else:
285
# Schedule a disable() when 'timeout' has passed
286
self.disable_initiator_tag = (gobject.timeout_add
287
(self.timeout_milliseconds(),
288
self.disable))
289
self.enabled = True
290
if self.use_dbus:
291
# Emit D-Bus signals
292
self.PropertyChanged(dbus.String(u"enabled"),
293
dbus.Boolean(True, variant_level=1))
294
self.PropertyChanged(dbus.String(u"last_enabled"),
295
(_datetime_to_dbus(self.last_enabled,
296
variant_level=1)))
297
298
def disable(self):
299
"""Disable this client."""
300
if not getattr(self, "enabled", False):
274
301
return False
275
if getattr(self, "stop_initiator_tag", False):
276
gobject.source_remove(self.stop_initiator_tag)
277
self.stop_initiator_tag = None
302
logger.info(u"Disabling client %s", self.name)
303
if getattr(self, "disable_initiator_tag", False):
304
gobject.source_remove(self.disable_initiator_tag)
305
self.disable_initiator_tag = None
278
306
if getattr(self, "checker_initiator_tag", False):
279
307
gobject.source_remove(self.checker_initiator_tag)
280
308
self.checker_initiator_tag = None
281
309
self.stop_checker()
282
if self.stop_hook:
283
self.stop_hook(self)
310
if self.disable_hook:
311
self.disable_hook(self)
312
self.enabled = False
313
if self.use_dbus:
314
# Emit D-Bus signal
315
self.PropertyChanged(dbus.String(u"enabled"),
316
dbus.Boolean(False, variant_level=1))
284
317
# Do not run this again if called by a gobject.timeout_add
285
318
return False
319
286
320
def __del__(self):
287
self.stop_hook = None
288
self.stop()
289
def checker_callback(self, pid, condition):
321
self.disable_hook = None
322
self.disable()
323
324
def checker_callback(self, pid, condition, command):
290
325
"""The checker has completed, so take appropriate actions."""
291
now = datetime.datetime.now()
292
326
self.checker_callback_tag = None
293
327
self.checker = None
294
if os.WIFEXITED(condition) \
295
and (os.WEXITSTATUS(condition) == 0):
296
logger.info(u"Checker for %(name)s succeeded",
297
vars(self))
298
self.last_checked_ok = now
299
gobject.source_remove(self.stop_initiator_tag)
300
self.stop_initiator_tag = gobject.timeout_add\
301
(self._timeout_milliseconds,
302
self.stop)
303
elif not os.WIFEXITED(condition):
328
if self.use_dbus:
329
# Emit D-Bus signal
330
self.PropertyChanged(dbus.String(u"checker_running"),
331
dbus.Boolean(False, variant_level=1))
332
if os.WIFEXITED(condition):
333
exitstatus = os.WEXITSTATUS(condition)
334
if exitstatus == 0:
335
logger.info(u"Checker for %(name)s succeeded",
336
vars(self))
337
self.checked_ok()
338
else:
339
logger.info(u"Checker for %(name)s failed",
340
vars(self))
341
if self.use_dbus:
342
# Emit D-Bus signal
343
self.CheckerCompleted(dbus.Int16(exitstatus),
344
dbus.Int64(condition),
345
dbus.String(command))
346
else:
304
347
logger.warning(u"Checker for %(name)s crashed?",
305
348
vars(self))
306
else:
307
logger.info(u"Checker for %(name)s failed",
308
vars(self))
349
if self.use_dbus:
350
# Emit D-Bus signal
351
self.CheckerCompleted(dbus.Int16(-1),
352
dbus.Int64(condition),
353
dbus.String(command))
354
355
def checked_ok(self):
356
"""Bump up the timeout for this client.
357
This should only be called when the client has been seen,
358
alive and well.
359
"""
360
self.last_checked_ok = datetime.datetime.utcnow()
361
gobject.source_remove(self.disable_initiator_tag)
362
self.disable_initiator_tag = (gobject.timeout_add
363
(self.timeout_milliseconds(),
364
self.disable))
365
if self.use_dbus:
366
# Emit D-Bus signal
367
self.PropertyChanged(
368
dbus.String(u"last_checked_ok"),
369
(_datetime_to_dbus(self.last_checked_ok,
370
variant_level=1)))
371
309
372
def start_checker(self):
310
373
"""Start a new checker subprocess if one is not running.
311
374
If a checker already exists, leave it running and do
318
381
# checkers alone, the checker would have to take more time
319
382
# than 'timeout' for the client to be declared invalid, which
320
383
# is as it should be.
384
385
# If a checker exists, make sure it is not a zombie
386
if self.checker is not None:
387
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
388
if pid:
389
logger.warning("Checker was a zombie")
390
gobject.source_remove(self.checker_callback_tag)
391
self.checker_callback(pid, status,
392
self.current_checker_command)
393
# Start a new checker if needed
321
394
if self.checker is None:
322
395
try:
323
# In case check_command has exactly one % operator
324
command = self.check_command % self.host
396
# In case checker_command has exactly one % operator
397
command = self.checker_command % self.host
325
398
except TypeError:
326
399
# Escape attributes for the shell
327
400
escaped_attrs = dict((key, re.escape(str(val)))
328
401
for key, val in
329
402
vars(self).iteritems())
330
403
try:
331
command = self.check_command % escaped_attrs
404
command = self.checker_command % escaped_attrs
332
405
except TypeError, error:
333
406
logger.error(u'Could not format string "%s":'
334
u' %s', self.check_command, error)
407
u' %s', self.checker_command, error)
335
408
return True # Try again later
409
self.current_checker_command = command
336
410
try:
337
411
logger.info(u"Starting checker %r for %s",
338
412
command, self.name)
413
# We don't need to redirect stdout and stderr, since
414
# in normal mode, that is already done by daemon(),
415
# and in debug mode we don't want to. (Stdin is
416
# always replaced by /dev/null.)
339
417
self.checker = subprocess.Popen(command,
340
418
close_fds=True,
341
419
shell=True, cwd="/")
342
self.checker_callback_tag = gobject.child_watch_add\
343
(self.checker.pid,
344
self.checker_callback)
345
except subprocess.OSError, error:
420
if self.use_dbus:
421
# Emit D-Bus signal
422
self.CheckerStarted(command)
423
self.PropertyChanged(
424
dbus.String("checker_running"),
425
dbus.Boolean(True, variant_level=1))
426
self.checker_callback_tag = (gobject.child_watch_add
427
(self.checker.pid,
428
self.checker_callback,
429
data=command))
430
# The checker may have completed before the gobject
431
# watch was added. Check for this.
432
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
433
if pid:
434
gobject.source_remove(self.checker_callback_tag)
435
self.checker_callback(pid, status, command)
436
except OSError, error:
346
437
logger.error(u"Failed to start subprocess: %s",
347
438
error)
348
439
# Re-run this periodically if run by gobject.timeout_add
349
440
return True
441
350
442
def stop_checker(self):
351
443
"""Force the checker process, if any, to stop."""
352
444
if self.checker_callback_tag:
364
456
if error.errno != errno.ESRCH: # No such process
365
457
raise
366
458
self.checker = None
459
if self.use_dbus:
460
self.PropertyChanged(dbus.String(u"checker_running"),
461
dbus.Boolean(False, variant_level=1))
462
367
463
def still_valid(self):
368
464
"""Has the timeout not yet passed for this client?"""
369
now = datetime.datetime.now()
465
if not getattr(self, "enabled", False):
466
return False
467
now = datetime.datetime.utcnow()
370
468
if self.last_checked_ok is None:
371
469
return now < (self.created + self.timeout)
372
470
else:
373
471
return now < (self.last_checked_ok + self.timeout)
472
473
## D-Bus methods & signals
474
_interface = u"se.bsnet.fukt.Mandos.Client"
475
476
# CheckedOK - method
477
CheckedOK = dbus.service.method(_interface)(checked_ok)
478
CheckedOK.__name__ = "CheckedOK"
479
480
# CheckerCompleted - signal
481
@dbus.service.signal(_interface, signature="nxs")
482
def CheckerCompleted(self, exitcode, waitstatus, command):
483
"D-Bus signal"
484
pass
485
486
# CheckerStarted - signal
487
@dbus.service.signal(_interface, signature="s")
488
def CheckerStarted(self, command):
489
"D-Bus signal"
490
pass
491
492
# GetAllProperties - method
493
@dbus.service.method(_interface, out_signature="a{sv}")
494
def GetAllProperties(self):
495
"D-Bus method"
496
return dbus.Dictionary({
497
dbus.String("name"):
498
dbus.String(self.name, variant_level=1),
499
dbus.String("fingerprint"):
500
dbus.String(self.fingerprint, variant_level=1),
501
dbus.String("host"):
502
dbus.String(self.host, variant_level=1),
503
dbus.String("created"):
504
_datetime_to_dbus(self.created, variant_level=1),
505
dbus.String("last_enabled"):
506
(_datetime_to_dbus(self.last_enabled,
507
variant_level=1)
508
if self.last_enabled is not None
509
else dbus.Boolean(False, variant_level=1)),
510
dbus.String("enabled"):
511
dbus.Boolean(self.enabled, variant_level=1),
512
dbus.String("last_checked_ok"):
513
(_datetime_to_dbus(self.last_checked_ok,
514
variant_level=1)
515
if self.last_checked_ok is not None
516
else dbus.Boolean (False, variant_level=1)),
517
dbus.String("timeout"):
518
dbus.UInt64(self.timeout_milliseconds(),
519
variant_level=1),
520
dbus.String("interval"):
521
dbus.UInt64(self.interval_milliseconds(),
522
variant_level=1),
523
dbus.String("checker"):
524
dbus.String(self.checker_command,
525
variant_level=1),
526
dbus.String("checker_running"):
527
dbus.Boolean(self.checker is not None,
528
variant_level=1),
529
dbus.String("object_path"):
530
dbus.ObjectPath(self.dbus_object_path,
531
variant_level=1)
532
}, signature="sv")
533
534
# IsStillValid - method
535
IsStillValid = (dbus.service.method(_interface, out_signature="b")
536
(still_valid))
537
IsStillValid.__name__ = "IsStillValid"
538
539
# PropertyChanged - signal
540
@dbus.service.signal(_interface, signature="sv")
541
def PropertyChanged(self, property, value):
542
"D-Bus signal"
543
pass
544
545
# SetChecker - method
546
@dbus.service.method(_interface, in_signature="s")
547
def SetChecker(self, checker):
548
"D-Bus setter method"
549
self.checker_command = checker
550
# Emit D-Bus signal
551
self.PropertyChanged(dbus.String(u"checker"),
552
dbus.String(self.checker_command,
553
variant_level=1))
554
555
# SetHost - method
556
@dbus.service.method(_interface, in_signature="s")
557
def SetHost(self, host):
558
"D-Bus setter method"
559
self.host = host
560
# Emit D-Bus signal
561
self.PropertyChanged(dbus.String(u"host"),
562
dbus.String(self.host, variant_level=1))
563
564
# SetInterval - method
565
@dbus.service.method(_interface, in_signature="t")
566
def SetInterval(self, milliseconds):
567
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
568
# Emit D-Bus signal
569
self.PropertyChanged(dbus.String(u"interval"),
570
(dbus.UInt64(self.interval_milliseconds(),
571
variant_level=1)))
572
573
# SetSecret - method
574
@dbus.service.method(_interface, in_signature="ay",
575
byte_arrays=True)
576
def SetSecret(self, secret):
577
"D-Bus setter method"
578
self.secret = str(secret)
579
580
# SetTimeout - method
581
@dbus.service.method(_interface, in_signature="t")
582
def SetTimeout(self, milliseconds):
583
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
584
# Emit D-Bus signal
585
self.PropertyChanged(dbus.String(u"timeout"),
586
(dbus.UInt64(self.timeout_milliseconds(),
587
variant_level=1)))
588
589
# Enable - method
590
Enable = dbus.service.method(_interface)(enable)
591
Enable.__name__ = "Enable"
592
593
# StartChecker - method
594
@dbus.service.method(_interface)
595
def StartChecker(self):
596
"D-Bus method"
597
self.start_checker()
598
599
# Disable - method
600
@dbus.service.method(_interface)
601
def Disable(self):
602
"D-Bus method"
603
self.disable()
604
605
# StopChecker - method
606
StopChecker = dbus.service.method(_interface)(stop_checker)
607
StopChecker.__name__ = "StopChecker"
608
609
del _interface
374
610
375
611
376
612
def peer_certificate(session):
377
613
"Return the peer's OpenPGP certificate as a bytestring"
378
614
# If not an OpenPGP certificate...
379
if gnutls.library.functions.gnutls_certificate_type_get\
380
(session._c_object) \
381
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
615
if (gnutls.library.functions
616
.gnutls_certificate_type_get(session._c_object)
617
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
382
618
# ...do the normal thing
383
619
return session.peer_certificate
384
list_size = ctypes.c_uint()
385
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
386
(session._c_object, ctypes.byref(list_size))
620
list_size = ctypes.c_uint(1)
621
cert_list = (gnutls.library.functions
622
.gnutls_certificate_get_peers
623
(session._c_object, ctypes.byref(list_size)))
624
if not bool(cert_list) and list_size.value != 0:
625
raise gnutls.errors.GNUTLSError("error getting peer"
626
" certificate")
387
627
if list_size.value == 0:
388
628
return None
389
629
cert = cert_list[0]
393
633
def fingerprint(openpgp):
394
634
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
395
635
# New GnuTLS "datum" with the OpenPGP public key
396
datum = gnutls.library.types.gnutls_datum_t\
397
(ctypes.cast(ctypes.c_char_p(openpgp),
398
ctypes.POINTER(ctypes.c_ubyte)),
399
ctypes.c_uint(len(openpgp)))
636
datum = (gnutls.library.types
637
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
638
ctypes.POINTER
639
(ctypes.c_ubyte)),
640
ctypes.c_uint(len(openpgp))))
400
641
# New empty GnuTLS certificate
401
642
crt = gnutls.library.types.gnutls_openpgp_crt_t()
402
gnutls.library.functions.gnutls_openpgp_crt_init\
403
(ctypes.byref(crt))
643
(gnutls.library.functions
644
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
404
645
# Import the OpenPGP public key into the certificate
405
gnutls.library.functions.gnutls_openpgp_crt_import\
406
(crt, ctypes.byref(datum),
407
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
646
(gnutls.library.functions
647
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
648
gnutls.library.constants
649
.GNUTLS_OPENPGP_FMT_RAW))
650
# Verify the self signature in the key
651
crtverify = ctypes.c_uint()
652
(gnutls.library.functions
653
.gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
654
if crtverify.value != 0:
655
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
656
raise gnutls.errors.CertificateSecurityError("Verify failed")
408
657
# New buffer for the fingerprint
409
buffer = ctypes.create_string_buffer(20)
410
buffer_length = ctypes.c_size_t()
658
buf = ctypes.create_string_buffer(20)
659
buf_len = ctypes.c_size_t()
411
660
# Get the fingerprint from the certificate into the buffer
412
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
413
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
661
(gnutls.library.functions
662
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
663
ctypes.byref(buf_len)))
414
664
# Deinit the certificate
415
665
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
416
666
# Convert the buffer to a Python bytestring
417
fpr = ctypes.string_at(buffer, buffer_length.value)
667
fpr = ctypes.string_at(buf, buf_len.value)
418
668
# Convert the bytestring to hexadecimal notation
419
669
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
420
670
return hex_fpr
421
671
422
672
423
class tcp_handler(SocketServer.BaseRequestHandler, object):
673
class TCP_handler(SocketServer.BaseRequestHandler, object):
424
674
"""A TCP request handler class.
425
675
Instantiated by IPv6_TCPServer for each request to handle it.
426
676
Note: This will run in its own forked process."""
427
677
428
678
def handle(self):
429
679
logger.info(u"TCP connection from: %s",
430
unicode(self.client_address))
431
session = gnutls.connection.ClientSession\
432
(self.request, gnutls.connection.X509Credentials())
680
unicode(self.client_address))
681
session = (gnutls.connection
682
.ClientSession(self.request,
683
gnutls.connection
684
.X509Credentials()))
433
685
434
686
line = self.request.makefile().readline()
435
687
logger.debug(u"Protocol version: %r", line)
446
698
# using OpenPGP certificates.
447
699
448
700
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
449
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
450
# "+DHE-DSS"))
451
priority = "NORMAL" # Fallback default, since this
452
# MUST be set.
453
if self.server.settings["priority"]:
454
priority = self.server.settings["priority"]
455
gnutls.library.functions.gnutls_priority_set_direct\
456
(session._c_object, priority, None);
701
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
702
# "+DHE-DSS"))
703
# Use a fallback default, since this MUST be set.
704
priority = self.server.settings.get("priority", "NORMAL")
705
(gnutls.library.functions
706
.gnutls_priority_set_direct(session._c_object,
707
priority, None))
457
708
458
709
try:
459
710
session.handshake()
462
713
# Do not run session.bye() here: the session is not
463
714
# established. Just abandon the request.
464
715
return
716
logger.debug(u"Handshake succeeded")
465
717
try:
466
718
fpr = fingerprint(peer_certificate(session))
467
719
except (TypeError, gnutls.errors.GNUTLSError), error:
469
721
session.bye()
470
722
return
471
723
logger.debug(u"Fingerprint: %s", fpr)
472
client = None
724
473
725
for c in self.server.clients:
474
726
if c.fingerprint == fpr:
475
727
client = c
476
728
break
477
if not client:
729
else:
478
730
logger.warning(u"Client not found for fingerprint: %s",
479
731
fpr)
480
732
session.bye()
487
739
vars(client))
488
740
session.bye()
489
741
return
742
## This won't work here, since we're in a fork.
743
# client.checked_ok()
490
744
sent_size = 0
491
745
while sent_size < len(client.secret):
492
746
sent = session.send(client.secret[sent_size:])
497
751
session.bye()
498
752
499
753
500
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
501
"""IPv6 TCP server. Accepts 'None' as address and/or port.
754
class IPv6_TCPServer(SocketServer.ForkingMixIn,
755
SocketServer.TCPServer, object):
756
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
502
757
Attributes:
503
758
settings: Server settings
504
759
clients: Set() of Client objects
760
enabled: Boolean; whether this server is activated yet
505
761
"""
506
762
address_family = socket.AF_INET6
507
763
def __init__(self, *args, **kwargs):
511
767
if "clients" in kwargs:
512
768
self.clients = kwargs["clients"]
513
769
del kwargs["clients"]
514
return super(type(self), self).__init__(*args, **kwargs)
770
if "use_ipv6" in kwargs:
771
if not kwargs["use_ipv6"]:
772
self.address_family = socket.AF_INET
773
del kwargs["use_ipv6"]
774
self.enabled = False
775
super(IPv6_TCPServer, self).__init__(*args, **kwargs)
515
776
def server_bind(self):
516
777
"""This overrides the normal server_bind() function
517
778
to bind to an interface if one was specified, and also NOT to
529
790
u" bind to interface %s",
530
791
self.settings["interface"])
531
792
else:
532
raise error
793
raise
533
794
# Only bind(2) the socket if we really need to.
534
795
if self.server_address[0] or self.server_address[1]:
535
796
if not self.server_address[0]:
536
in6addr_any = "::"
537
self.server_address = (in6addr_any,
797
if self.address_family == socket.AF_INET6:
798
any_address = "::" # in6addr_any
799
else:
800
any_address = socket.INADDR_ANY
801
self.server_address = (any_address,
538
802
self.server_address[1])
539
803
elif not self.server_address[1]:
540
804
self.server_address = (self.server_address[0],
546
810
# if_nametoindex
547
811
# (self.settings
548
812
# ["interface"]))
549
return super(type(self), self).server_bind()
813
return super(IPv6_TCPServer, self).server_bind()
814
def server_activate(self):
815
if self.enabled:
816
return super(IPv6_TCPServer, self).server_activate()
817
def enable(self):
818
self.enabled = True
550
819
551
820
552
821
def string_to_delta(interval):
553
822
"""Parse a string and return a datetime.timedelta
554
823
555
824
>>> string_to_delta('7d')
556
825
datetime.timedelta(7)
557
826
>>> string_to_delta('60s')
562
831
datetime.timedelta(1)
563
832
>>> string_to_delta(u'1w')
564
833
datetime.timedelta(7)
834
>>> string_to_delta('5m 30s')
835
datetime.timedelta(0, 330)
565
836
"""
566
try:
567
suffix=unicode(interval[-1])
568
value=int(interval[:-1])
569
if suffix == u"d":
570
delta = datetime.timedelta(value)
571
elif suffix == u"s":
572
delta = datetime.timedelta(0, value)
573
elif suffix == u"m":
574
delta = datetime.timedelta(0, 0, 0, 0, value)
575
elif suffix == u"h":
576
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
577
elif suffix == u"w":
578
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
579
else:
837
timevalue = datetime.timedelta(0)
838
for s in interval.split():
839
try:
840
suffix = unicode(s[-1])
841
value = int(s[:-1])
842
if suffix == u"d":
843
delta = datetime.timedelta(value)
844
elif suffix == u"s":
845
delta = datetime.timedelta(0, value)
846
elif suffix == u"m":
847
delta = datetime.timedelta(0, 0, 0, 0, value)
848
elif suffix == u"h":
849
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
850
elif suffix == u"w":
851
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
852
else:
853
raise ValueError
854
except (ValueError, IndexError):
580
855
raise ValueError
581
except (ValueError, IndexError):
582
raise ValueError
583
return delta
856
timevalue += delta
857
return timevalue
584
858
585
859
586
860
def server_state_changed(state):
587
861
"""Derived from the Avahi example code"""
588
862
if state == avahi.SERVER_COLLISION:
589
logger.error(u"Server name collision")
863
logger.error(u"Zeroconf server name collision")
590
864
service.remove()
591
865
elif state == avahi.SERVER_RUNNING:
592
866
service.add()
594
868
595
869
def entry_group_state_changed(state, error):
596
870
"""Derived from the Avahi example code"""
597
logger.debug(u"state change: %i", state)
871
logger.debug(u"Avahi state change: %i", state)
598
872
599
873
if state == avahi.ENTRY_GROUP_ESTABLISHED:
600
logger.debug(u"Service established.")
874
logger.debug(u"Zeroconf service established.")
601
875
elif state == avahi.ENTRY_GROUP_COLLISION:
602
logger.warning(u"Service name collision.")
876
logger.warning(u"Zeroconf service name collision.")
603
877
service.rename()
604
878
elif state == avahi.ENTRY_GROUP_FAILURE:
605
logger.critical(u"Error in group state changed %s",
879
logger.critical(u"Avahi: Error in group state changed %s",
606
880
unicode(error))
607
raise AvahiGroupError("State changed: %s", str(error))
881
raise AvahiGroupError(u"State changed: %s" % unicode(error))
608
882
609
883
def if_nametoindex(interface):
610
884
"""Call the C function if_nametoindex(), or equivalent"""
611
885
global if_nametoindex
612
886
try:
613
if "ctypes.util" not in sys.modules:
614
import ctypes.util
615
if_nametoindex = ctypes.cdll.LoadLibrary\
616
(ctypes.util.find_library("c")).if_nametoindex
887
if_nametoindex = (ctypes.cdll.LoadLibrary
888
(ctypes.util.find_library("c"))
889
.if_nametoindex)
617
890
except (OSError, AttributeError):
618
891
if "struct" not in sys.modules:
619
892
import struct
622
895
def if_nametoindex(interface):
623
896
"Get an interface index the hard way, i.e. using fcntl()"
624
897
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
625
s = socket.socket()
626
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
627
struct.pack("16s16x", interface))
628
s.close()
898
with closing(socket.socket()) as s:
899
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
900
struct.pack("16s16x", interface))
629
901
interface_index = struct.unpack("I", ifreq[16:20])[0]
630
902
return interface_index
631
903
return if_nametoindex(interface)
655
927
656
928
657
929
def main():
658
global main_loop_started
659
main_loop_started = False
660
661
parser = OptionParser(version = "%%prog %s" % version)
930
parser = optparse.OptionParser(version = "%%prog %s" % version)
662
931
parser.add_option("-i", "--interface", type="string",
663
932
metavar="IF", help="Bind to interface IF")
664
933
parser.add_option("-a", "--address", type="string",
665
934
help="Address to listen for requests on")
666
935
parser.add_option("-p", "--port", type="int",
667
936
help="Port number to receive requests on")
668
parser.add_option("--check", action="store_true", default=False,
937
parser.add_option("--check", action="store_true",
669
938
help="Run self-test")
670
939
parser.add_option("--debug", action="store_true",
671
940
help="Debug mode; run in foreground and log to"
678
947
default="/etc/mandos", metavar="DIR",
679
948
help="Directory to search for configuration"
680
949
" files")
681
(options, args) = parser.parse_args()
950
parser.add_option("--no-dbus", action="store_false",
951
dest="use_dbus",
952
help="Do not provide D-Bus system bus"
953
" interface")
954
parser.add_option("--no-ipv6", action="store_false",
955
dest="use_ipv6", help="Do not use IPv6")
956
options = parser.parse_args()[0]
682
957
683
958
if options.check:
684
959
import doctest
693
968
"priority":
694
969
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
695
970
"servicename": "Mandos",
971
"use_dbus": "True",
972
"use_ipv6": "True",
696
973
}
697
974
698
975
# Parse config file for server-global settings
699
976
server_config = ConfigParser.SafeConfigParser(server_defaults)
700
977
del server_defaults
701
978
server_config.read(os.path.join(options.configdir, "mandos.conf"))
702
server_section = "server"
703
979
# Convert the SafeConfigParser object to a dict
704
server_settings = dict(server_config.items(server_section))
705
# Use getboolean on the boolean config option
706
server_settings["debug"] = server_config.getboolean\
707
(server_section, "debug")
980
server_settings = server_config.defaults()
981
# Use the appropriate methods on the non-string config options
982
server_settings["debug"] = server_config.getboolean("DEFAULT",
983
"debug")
984
server_settings["use_dbus"] = server_config.getboolean("DEFAULT",
985
"use_dbus")
986
server_settings["use_ipv6"] = server_config.getboolean("DEFAULT",
987
"use_ipv6")
988
if server_settings["port"]:
989
server_settings["port"] = server_config.getint("DEFAULT",
990
"port")
708
991
del server_config
709
992
710
993
# Override the settings from the config file with command line
711
994
# options, if set.
712
995
for option in ("interface", "address", "port", "debug",
713
"priority", "servicename", "configdir"):
996
"priority", "servicename", "configdir",
997
"use_dbus", "use_ipv6"):
714
998
value = getattr(options, option)
715
999
if value is not None:
716
1000
server_settings[option] = value
717
1001
del options
718
1002
# Now we have our good server settings in "server_settings"
719
1003
1004
# For convenience
720
1005
debug = server_settings["debug"]
1006
use_dbus = server_settings["use_dbus"]
1007
use_ipv6 = server_settings["use_ipv6"]
721
1008
722
1009
if not debug:
723
1010
syslogger.setLevel(logging.WARNING)
724
1011
console.setLevel(logging.WARNING)
725
1012
726
1013
if server_settings["servicename"] != "Mandos":
727
syslogger.setFormatter(logging.Formatter\
1014
syslogger.setFormatter(logging.Formatter
728
1015
('Mandos (%s): %%(levelname)s:'
729
1016
' %%(message)s'
730
1017
% server_settings["servicename"]))
733
1020
client_defaults = { "timeout": "1h",
734
1021
"interval": "5m",
735
1022
"checker": "fping -q -- %%(host)s",
1023
"host": "",
736
1024
}
737
1025
client_config = ConfigParser.SafeConfigParser(client_defaults)
738
1026
client_config.read(os.path.join(server_settings["configdir"],
739
1027
"clients.conf"))
740
1028
1029
clients = Set()
1030
tcp_server = IPv6_TCPServer((server_settings["address"],
1031
server_settings["port"]),
1032
TCP_handler,
1033
settings=server_settings,
1034
clients=clients, use_ipv6=use_ipv6)
1035
pidfilename = "/var/run/mandos.pid"
1036
try:
1037
pidfile = open(pidfilename, "w")
1038
except IOError:
1039
logger.error("Could not open file %r", pidfilename)
1040
1041
try:
1042
uid = pwd.getpwnam("_mandos").pw_uid
1043
gid = pwd.getpwnam("_mandos").pw_gid
1044
except KeyError:
1045
try:
1046
uid = pwd.getpwnam("mandos").pw_uid
1047
gid = pwd.getpwnam("mandos").pw_gid
1048
except KeyError:
1049
try:
1050
uid = pwd.getpwnam("nobody").pw_uid
1051
gid = pwd.getpwnam("nogroup").pw_gid
1052
except KeyError:
1053
uid = 65534
1054
gid = 65534
1055
try:
1056
os.setgid(gid)
1057
os.setuid(uid)
1058
except OSError, error:
1059
if error[0] != errno.EPERM:
1060
raise error
1061
1062
# Enable all possible GnuTLS debugging
1063
if debug:
1064
# "Use a log level over 10 to enable all debugging options."
1065
# - GnuTLS manual
1066
gnutls.library.functions.gnutls_global_set_log_level(11)
1067
1068
@gnutls.library.types.gnutls_log_func
1069
def debug_gnutls(level, string):
1070
logger.debug("GnuTLS: %s", string[:-1])
1071
1072
(gnutls.library.functions
1073
.gnutls_global_set_log_function(debug_gnutls))
1074
741
1075
global service
1076
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
742
1077
service = AvahiService(name = server_settings["servicename"],
743
type = "_mandos._tcp", );
1078
servicetype = "_mandos._tcp",
1079
protocol = protocol)
744
1080
if server_settings["interface"]:
745
service.interface = if_nametoindex(server_settings["interface"])
1081
service.interface = (if_nametoindex
1082
(server_settings["interface"]))
746
1083
747
1084
global main_loop
748
1085
global bus
751
1088
DBusGMainLoop(set_as_default=True )
752
1089
main_loop = gobject.MainLoop()
753
1090
bus = dbus.SystemBus()
754
server = dbus.Interface(
755
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
756
avahi.DBUS_INTERFACE_SERVER )
1091
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1092
avahi.DBUS_PATH_SERVER),
1093
avahi.DBUS_INTERFACE_SERVER)
757
1094
# End of Avahi example code
758
759
clients = Set()
760
def remove_from_clients(client):
761
clients.remove(client)
762
if not clients:
763
logger.critical(u"No clients left, exiting")
764
sys.exit()
1095
if use_dbus:
1096
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
765
1097
766
1098
clients.update(Set(Client(name = section,
767
stop_hook = remove_from_clients,
768
1099
config
769
= dict(client_config.items(section)))
1100
= dict(client_config.items(section)),
1101
use_dbus = use_dbus)
770
1102
for section in client_config.sections()))
771
1103
if not clients:
772
logger.critical(u"No clients defined")
773
sys.exit(1)
1104
logger.warning(u"No clients defined")
774
1105
775
if not debug:
1106
if debug:
1107
# Redirect stdin so all checkers get /dev/null
1108
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1109
os.dup2(null, sys.stdin.fileno())
1110
if null > 2:
1111
os.close(null)
1112
else:
1113
# No console logging
776
1114
logger.removeHandler(console)
1115
# Close all input and output, do double fork, etc.
777
1116
daemon()
778
1117
779
pidfilename = "/var/run/mandos/mandos.pid"
780
pid = os.getpid()
781
1118
try:
782
pidfile = open(pidfilename, "w")
1119
pid = os.getpid()
783
1120
pidfile.write(str(pid) + "\n")
784
1121
pidfile.close()
785
1122
del pidfile
786
except IOError, err:
787
logger.error(u"Could not write %s file with PID %d",
788
pidfilename, os.getpid())
1123
except IOError:
1124
logger.error(u"Could not write to file %r with PID %d",
1125
pidfilename, pid)
1126
except NameError:
1127
# "pidfile" was never created
1128
pass
1129
del pidfilename
789
1130
790
1131
def cleanup():
791
1132
"Cleanup function; run on exit"
798
1139
799
1140
while clients:
800
1141
client = clients.pop()
801
client.stop_hook = None
802
client.stop()
1142
client.disable_hook = None
1143
client.disable()
803
1144
804
1145
atexit.register(cleanup)
805
1146
808
1149
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
809
1150
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
810
1151
1152
if use_dbus:
1153
class MandosServer(dbus.service.Object):
1154
"""A D-Bus proxy object"""
1155
def __init__(self):
1156
dbus.service.Object.__init__(self, bus, "/")
1157
_interface = u"se.bsnet.fukt.Mandos"
1158
1159
@dbus.service.signal(_interface, signature="oa{sv}")
1160
def ClientAdded(self, objpath, properties):
1161
"D-Bus signal"
1162
pass
1163
1164
@dbus.service.signal(_interface, signature="os")
1165
def ClientRemoved(self, objpath, name):
1166
"D-Bus signal"
1167
pass
1168
1169
@dbus.service.method(_interface, out_signature="ao")
1170
def GetAllClients(self):
1171
"D-Bus method"
1172
return dbus.Array(c.dbus_object_path for c in clients)
1173
1174
@dbus.service.method(_interface, out_signature="a{oa{sv}}")
1175
def GetAllClientsWithProperties(self):
1176
"D-Bus method"
1177
return dbus.Dictionary(
1178
((c.dbus_object_path, c.GetAllProperties())
1179
for c in clients),
1180
signature="oa{sv}")
1181
1182
@dbus.service.method(_interface, in_signature="o")
1183
def RemoveClient(self, object_path):
1184
"D-Bus method"
1185
for c in clients:
1186
if c.dbus_object_path == object_path:
1187
clients.remove(c)
1188
# Don't signal anything except ClientRemoved
1189
c.use_dbus = False
1190
c.disable()
1191
# Emit D-Bus signal
1192
self.ClientRemoved(object_path, c.name)
1193
return
1194
raise KeyError
1195
1196
del _interface
1197
1198
mandos_server = MandosServer()
1199
811
1200
for client in clients:
812
client.start()
813
814
tcp_server = IPv6_TCPServer((server_settings["address"],
815
server_settings["port"]),
816
tcp_handler,
817
settings=server_settings,
818
clients=clients)
1201
if use_dbus:
1202
# Emit D-Bus signal
1203
mandos_server.ClientAdded(client.dbus_object_path,
1204
client.GetAllProperties())
1205
client.enable()
1206
1207
tcp_server.enable()
1208
tcp_server.server_activate()
1209
819
1210
# Find out what port we got
820
1211
service.port = tcp_server.socket.getsockname()[1]
821
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
822
u" scope_id %d" % tcp_server.socket.getsockname())
1212
if use_ipv6:
1213
logger.info(u"Now listening on address %r, port %d,"
1214
" flowinfo %d, scope_id %d"
1215
% tcp_server.socket.getsockname())
1216
else: # IPv4
1217
logger.info(u"Now listening on address %r, port %d"
1218
% tcp_server.socket.getsockname())
823
1219
824
1220
#service.interface = tcp_server.socket.getsockname()[3]
825
1221
835
1231
836
1232
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
837
1233
lambda *args, **kwargs:
838
tcp_server.handle_request\
839
(*args[2:], **kwargs) or True)
1234
(tcp_server.handle_request
1235
(*args[2:], **kwargs) or True))
840
1236
841
1237
logger.debug(u"Starting main loop")
842
main_loop_started = True
843
1238
main_loop.run()
844
1239
except AvahiError, error:
845
logger.critical(u"AvahiError: %s" + unicode(error))
1240
logger.critical(u"AvahiError: %s", error)
846
1241
sys.exit(1)
847
1242
except KeyboardInterrupt:
848
1243
if debug:
849
print
1244
print >> sys.stderr
1245
logger.debug("Server received KeyboardInterrupt")
1246
logger.debug("Server exiting")
850
1247
851
1248
if __name__ == '__main__':
852
1249
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0