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 319
- compare with another revision
- download diff
- download tarball
- view history from revision 319
- Committer: Teddy Hogeborn
- Date: 2009-02-15 09:28:06 UTC
- Revision ID: teddy@fukt.bsnet.se-20090215092806-l0uq42v3j1rq3gmi
* INSTALL: Changed "Python 2.4" to "Python 2.5".
* mandos.lsm: - '' -
* mandos.lsm: - '' -
- 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.6"
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
80
console = logging.StreamHandler()
81
console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'
82
' %(levelname)s: %(message)s'))
83
logger.addHandler(console)
74
84
75
85
class AvahiError(Exception):
76
def __init__(self, value):
86
def __init__(self, value, *args, **kwargs):
77
87
self.value = value
78
def __str__(self):
79
return repr(self.value)
88
super(AvahiError, self).__init__(value, *args, **kwargs)
89
def __unicode__(self):
90
return unicode(repr(self.value))
80
91
81
92
class AvahiServiceError(AvahiError):
82
93
pass
102
113
a sensible number of times
103
114
"""
104
115
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
105
type = None, port = None, TXT = None, domain = "",
106
host = "", max_renames = 32768):
116
servicetype = None, port = None, TXT = None,
117
domain = "", host = "", max_renames = 32768,
118
protocol = avahi.PROTO_UNSPEC):
107
119
self.interface = interface
108
120
self.name = name
109
self.type = type
121
self.type = servicetype
110
122
self.port = port
111
if TXT is None:
112
self.TXT = []
113
else:
114
self.TXT = TXT
123
self.TXT = TXT if TXT is not None else []
115
124
self.domain = domain
116
125
self.host = host
117
126
self.rename_count = 0
127
self.max_renames = max_renames
128
self.protocol = protocol
118
129
def rename(self):
119
130
"""Derived from the Avahi example code"""
120
131
if self.rename_count >= self.max_renames:
121
logger.critical(u"No suitable service name found after %i"
122
u" retries, exiting.", rename_count)
123
raise AvahiServiceError("Too many renames")
124
name = server.GetAlternativeServiceName(name)
125
logger.error(u"Changing name to %r ...", name)
126
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
127
140
('Mandos (%s): %%(levelname)s:'
128
' %%(message)s' % name))
141
' %%(message)s' % self.name))
129
142
self.remove()
130
143
self.add()
131
144
self.rename_count += 1
137
150
"""Derived from the Avahi example code"""
138
151
global group
139
152
if group is None:
140
group = dbus.Interface\
141
(bus.get_object(avahi.DBUS_NAME,
153
group = dbus.Interface(bus.get_object
154
(avahi.DBUS_NAME,
142
155
server.EntryGroupNew()),
143
avahi.DBUS_INTERFACE_ENTRY_GROUP)
156
avahi.DBUS_INTERFACE_ENTRY_GROUP)
144
157
group.connect_to_signal('StateChanged',
145
158
entry_group_state_changed)
146
logger.debug(u"Adding service '%s' of type '%s' ...",
159
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
147
160
service.name, service.type)
148
161
group.AddService(
149
162
self.interface, # interface
150
avahi.PROTO_INET6, # protocol
163
self.protocol, # protocol
151
164
dbus.UInt32(0), # flags
152
165
self.name, self.type,
153
166
self.domain, self.host,
160
173
# End of Avahi example code
161
174
162
175
163
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):
164
182
"""A representation of a client host served by this server.
165
183
Attributes:
166
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
167
186
fingerprint: string (40 or 32 hexadecimal digits); used to
168
187
uniquely identify the client
169
secret: bytestring; sent verbatim (over TLS) to client
170
host: string; available for use by the checker command
171
created: datetime.datetime(); object creation, not client host
172
last_checked_ok: datetime.datetime() or None if not yet checked OK
173
timeout: datetime.timedelta(); How long from last_checked_ok
174
until this client is invalid
175
interval: datetime.timedelta(); How often to start a new checker
176
stop_hook: If set, called by stop() as stop_hook(self)
177
checker: subprocess.Popen(); a running checker process used
178
to see if the client lives.
179
'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.
180
201
checker_initiator_tag: a gobject event source tag, or None
181
stop_initiator_tag: - '' -
202
disable_initiator_tag: - '' -
182
203
checker_callback_tag: - '' -
183
204
checker_command: string; External command which is run to check if
184
205
client lives. %() expansions are done at
185
206
runtime with vars(self) as dict, so that for
186
207
instance %(name)s can be used in the command.
187
Private attibutes:
188
_timeout: Real variable for 'timeout'
189
_interval: Real variable for 'interval'
190
_timeout_milliseconds: Used when calling gobject.timeout_add()
191
_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
192
211
"""
193
def _set_timeout(self, timeout):
194
"Setter function for 'timeout' attribute"
195
self._timeout = timeout
196
self._timeout_milliseconds = ((self.timeout.days
197
* 24 * 60 * 60 * 1000)
198
+ (self.timeout.seconds * 1000)
199
+ (self.timeout.microseconds
200
// 1000))
201
timeout = property(lambda self: self._timeout,
202
_set_timeout)
203
del _set_timeout
204
def _set_interval(self, interval):
205
"Setter function for 'interval' attribute"
206
self._interval = interval
207
self._interval_milliseconds = ((self.interval.days
208
* 24 * 60 * 60 * 1000)
209
+ (self.interval.seconds
210
* 1000)
211
+ (self.interval.microseconds
212
// 1000))
213
interval = property(lambda self: self._interval,
214
_set_interval)
215
del _set_interval
216
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):
217
226
"""Note: the 'checker' key in 'config' sets the
218
227
'checker_command' attribute and *not* the 'checker'
219
228
attribute."""
220
229
self.name = name
230
if config is None:
231
config = {}
221
232
logger.debug(u"Creating client %r", self.name)
233
self.use_dbus = False # During __init__
222
234
# Uppercase and remove spaces from fingerprint for later
223
235
# comparison purposes with return value from the fingerprint()
224
236
# function
225
self.fingerprint = config["fingerprint"].upper()\
226
.replace(u" ", u"")
237
self.fingerprint = (config["fingerprint"].upper()
238
.replace(u" ", u""))
227
239
logger.debug(u" Fingerprint: %s", self.fingerprint)
228
240
if "secret" in config:
229
241
self.secret = config["secret"].decode(u"base64")
230
242
elif "secfile" in config:
231
sf = open(config["secfile"])
232
self.secret = sf.read()
233
sf.close()
243
with closing(open(os.path.expanduser
244
(os.path.expandvars
245
(config["secfile"])))) as secfile:
246
self.secret = secfile.read()
234
247
else:
235
248
raise TypeError(u"No secret or secfile for client %s"
236
249
% self.name)
237
250
self.host = config.get("host", "")
238
self.created = datetime.datetime.now()
251
self.created = datetime.datetime.utcnow()
252
self.enabled = False
253
self.last_enabled = None
239
254
self.last_checked_ok = None
240
255
self.timeout = string_to_delta(config["timeout"])
241
256
self.interval = string_to_delta(config["interval"])
242
self.stop_hook = stop_hook
257
self.disable_hook = disable_hook
243
258
self.checker = None
244
259
self.checker_initiator_tag = None
245
self.stop_initiator_tag = None
260
self.disable_initiator_tag = None
246
261
self.checker_callback_tag = None
247
self.check_command = config["checker"]
248
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):
249
276
"""Start this client's checker and timeout hooks"""
277
self.last_enabled = datetime.datetime.utcnow()
250
278
# Schedule a new checker to be started an 'interval' from now,
251
279
# and every interval from then on.
252
self.checker_initiator_tag = gobject.timeout_add\
253
(self._interval_milliseconds,
254
self.start_checker)
280
self.checker_initiator_tag = (gobject.timeout_add
281
(self.interval_milliseconds(),
282
self.start_checker))
255
283
# Also start a new checker *right now*.
256
284
self.start_checker()
257
# Schedule a stop() when 'timeout' has passed
258
self.stop_initiator_tag = gobject.timeout_add\
259
(self._timeout_milliseconds,
260
self.stop)
261
def stop(self):
262
"""Stop this client.
263
The possibility that a client might be restarted is left open,
264
but not currently used."""
265
# If this client doesn't have a secret, it is already stopped.
266
if hasattr(self, "secret") and self.secret:
267
logger.info(u"Stopping client %s", self.name)
268
self.secret = None
269
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):
270
301
return False
271
if getattr(self, "stop_initiator_tag", False):
272
gobject.source_remove(self.stop_initiator_tag)
273
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
274
306
if getattr(self, "checker_initiator_tag", False):
275
307
gobject.source_remove(self.checker_initiator_tag)
276
308
self.checker_initiator_tag = None
277
309
self.stop_checker()
278
if self.stop_hook:
279
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))
280
317
# Do not run this again if called by a gobject.timeout_add
281
318
return False
319
282
320
def __del__(self):
283
self.stop_hook = None
284
self.stop()
285
def checker_callback(self, pid, condition):
321
self.disable_hook = None
322
self.disable()
323
324
def checker_callback(self, pid, condition, command):
286
325
"""The checker has completed, so take appropriate actions."""
287
now = datetime.datetime.now()
288
326
self.checker_callback_tag = None
289
327
self.checker = None
290
if os.WIFEXITED(condition) \
291
and (os.WEXITSTATUS(condition) == 0):
292
logger.info(u"Checker for %(name)s succeeded",
293
vars(self))
294
self.last_checked_ok = now
295
gobject.source_remove(self.stop_initiator_tag)
296
self.stop_initiator_tag = gobject.timeout_add\
297
(self._timeout_milliseconds,
298
self.stop)
299
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:
300
347
logger.warning(u"Checker for %(name)s crashed?",
301
348
vars(self))
302
else:
303
logger.info(u"Checker for %(name)s failed",
304
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
305
372
def start_checker(self):
306
373
"""Start a new checker subprocess if one is not running.
307
374
If a checker already exists, leave it running and do
314
381
# checkers alone, the checker would have to take more time
315
382
# than 'timeout' for the client to be declared invalid, which
316
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
317
394
if self.checker is None:
318
395
try:
319
# In case check_command has exactly one % operator
320
command = self.check_command % self.host
396
# In case checker_command has exactly one % operator
397
command = self.checker_command % self.host
321
398
except TypeError:
322
399
# Escape attributes for the shell
323
400
escaped_attrs = dict((key, re.escape(str(val)))
324
401
for key, val in
325
402
vars(self).iteritems())
326
403
try:
327
command = self.check_command % escaped_attrs
404
command = self.checker_command % escaped_attrs
328
405
except TypeError, error:
329
406
logger.error(u'Could not format string "%s":'
330
u' %s', self.check_command, error)
407
u' %s', self.checker_command, error)
331
408
return True # Try again later
409
self.current_checker_command = command
332
410
try:
333
411
logger.info(u"Starting checker %r for %s",
334
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.)
335
417
self.checker = subprocess.Popen(command,
336
418
close_fds=True,
337
419
shell=True, cwd="/")
338
self.checker_callback_tag = gobject.child_watch_add\
339
(self.checker.pid,
340
self.checker_callback)
341
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:
342
437
logger.error(u"Failed to start subprocess: %s",
343
438
error)
344
439
# Re-run this periodically if run by gobject.timeout_add
345
440
return True
441
346
442
def stop_checker(self):
347
443
"""Force the checker process, if any, to stop."""
348
444
if self.checker_callback_tag:
360
456
if error.errno != errno.ESRCH: # No such process
361
457
raise
362
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
363
463
def still_valid(self):
364
464
"""Has the timeout not yet passed for this client?"""
365
now = datetime.datetime.now()
465
if not getattr(self, "enabled", False):
466
return False
467
now = datetime.datetime.utcnow()
366
468
if self.last_checked_ok is None:
367
469
return now < (self.created + self.timeout)
368
470
else:
369
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
370
610
371
611
372
612
def peer_certificate(session):
373
613
"Return the peer's OpenPGP certificate as a bytestring"
374
614
# If not an OpenPGP certificate...
375
if gnutls.library.functions.gnutls_certificate_type_get\
376
(session._c_object) \
377
!= 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):
378
618
# ...do the normal thing
379
619
return session.peer_certificate
380
list_size = ctypes.c_uint()
381
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
382
(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")
383
627
if list_size.value == 0:
384
628
return None
385
629
cert = cert_list[0]
389
633
def fingerprint(openpgp):
390
634
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
391
635
# New GnuTLS "datum" with the OpenPGP public key
392
datum = gnutls.library.types.gnutls_datum_t\
393
(ctypes.cast(ctypes.c_char_p(openpgp),
394
ctypes.POINTER(ctypes.c_ubyte)),
395
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))))
396
641
# New empty GnuTLS certificate
397
642
crt = gnutls.library.types.gnutls_openpgp_crt_t()
398
gnutls.library.functions.gnutls_openpgp_crt_init\
399
(ctypes.byref(crt))
643
(gnutls.library.functions
644
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
400
645
# Import the OpenPGP public key into the certificate
401
gnutls.library.functions.gnutls_openpgp_crt_import\
402
(crt, ctypes.byref(datum),
403
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")
404
657
# New buffer for the fingerprint
405
buffer = ctypes.create_string_buffer(20)
406
buffer_length = ctypes.c_size_t()
658
buf = ctypes.create_string_buffer(20)
659
buf_len = ctypes.c_size_t()
407
660
# Get the fingerprint from the certificate into the buffer
408
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
409
(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)))
410
664
# Deinit the certificate
411
665
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
412
666
# Convert the buffer to a Python bytestring
413
fpr = ctypes.string_at(buffer, buffer_length.value)
667
fpr = ctypes.string_at(buf, buf_len.value)
414
668
# Convert the bytestring to hexadecimal notation
415
669
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
416
670
return hex_fpr
417
671
418
672
419
class tcp_handler(SocketServer.BaseRequestHandler, object):
673
class TCP_handler(SocketServer.BaseRequestHandler, object):
420
674
"""A TCP request handler class.
421
675
Instantiated by IPv6_TCPServer for each request to handle it.
422
676
Note: This will run in its own forked process."""
423
677
424
678
def handle(self):
425
679
logger.info(u"TCP connection from: %s",
426
unicode(self.client_address))
427
session = gnutls.connection.ClientSession\
428
(self.request, gnutls.connection.X509Credentials())
680
unicode(self.client_address))
681
session = (gnutls.connection
682
.ClientSession(self.request,
683
gnutls.connection
684
.X509Credentials()))
429
685
430
686
line = self.request.makefile().readline()
431
687
logger.debug(u"Protocol version: %r", line)
442
698
# using OpenPGP certificates.
443
699
444
700
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
445
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
446
# "+DHE-DSS"))
447
priority = "NORMAL" # Fallback default, since this
448
# MUST be set.
449
if self.server.settings["priority"]:
450
priority = self.server.settings["priority"]
451
gnutls.library.functions.gnutls_priority_set_direct\
452
(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))
453
708
454
709
try:
455
710
session.handshake()
458
713
# Do not run session.bye() here: the session is not
459
714
# established. Just abandon the request.
460
715
return
716
logger.debug(u"Handshake succeeded")
461
717
try:
462
718
fpr = fingerprint(peer_certificate(session))
463
719
except (TypeError, gnutls.errors.GNUTLSError), error:
465
721
session.bye()
466
722
return
467
723
logger.debug(u"Fingerprint: %s", fpr)
468
client = None
724
469
725
for c in self.server.clients:
470
726
if c.fingerprint == fpr:
471
727
client = c
472
728
break
473
if not client:
729
else:
474
730
logger.warning(u"Client not found for fingerprint: %s",
475
731
fpr)
476
732
session.bye()
483
739
vars(client))
484
740
session.bye()
485
741
return
742
## This won't work here, since we're in a fork.
743
# client.checked_ok()
486
744
sent_size = 0
487
745
while sent_size < len(client.secret):
488
746
sent = session.send(client.secret[sent_size:])
493
751
session.bye()
494
752
495
753
496
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
497
"""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
498
757
Attributes:
499
758
settings: Server settings
500
759
clients: Set() of Client objects
760
enabled: Boolean; whether this server is activated yet
501
761
"""
502
762
address_family = socket.AF_INET6
503
763
def __init__(self, *args, **kwargs):
507
767
if "clients" in kwargs:
508
768
self.clients = kwargs["clients"]
509
769
del kwargs["clients"]
510
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)
511
776
def server_bind(self):
512
777
"""This overrides the normal server_bind() function
513
778
to bind to an interface if one was specified, and also NOT to
525
790
u" bind to interface %s",
526
791
self.settings["interface"])
527
792
else:
528
raise error
793
raise
529
794
# Only bind(2) the socket if we really need to.
530
795
if self.server_address[0] or self.server_address[1]:
531
796
if not self.server_address[0]:
532
in6addr_any = "::"
533
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,
534
802
self.server_address[1])
535
803
elif not self.server_address[1]:
536
804
self.server_address = (self.server_address[0],
542
810
# if_nametoindex
543
811
# (self.settings
544
812
# ["interface"]))
545
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
546
819
547
820
548
821
def string_to_delta(interval):
549
822
"""Parse a string and return a datetime.timedelta
550
823
551
824
>>> string_to_delta('7d')
552
825
datetime.timedelta(7)
553
826
>>> string_to_delta('60s')
558
831
datetime.timedelta(1)
559
832
>>> string_to_delta(u'1w')
560
833
datetime.timedelta(7)
834
>>> string_to_delta('5m 30s')
835
datetime.timedelta(0, 330)
561
836
"""
562
try:
563
suffix=unicode(interval[-1])
564
value=int(interval[:-1])
565
if suffix == u"d":
566
delta = datetime.timedelta(value)
567
elif suffix == u"s":
568
delta = datetime.timedelta(0, value)
569
elif suffix == u"m":
570
delta = datetime.timedelta(0, 0, 0, 0, value)
571
elif suffix == u"h":
572
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
573
elif suffix == u"w":
574
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
575
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):
576
855
raise ValueError
577
except (ValueError, IndexError):
578
raise ValueError
579
return delta
856
timevalue += delta
857
return timevalue
580
858
581
859
582
860
def server_state_changed(state):
583
861
"""Derived from the Avahi example code"""
584
862
if state == avahi.SERVER_COLLISION:
585
logger.error(u"Server name collision")
863
logger.error(u"Zeroconf server name collision")
586
864
service.remove()
587
865
elif state == avahi.SERVER_RUNNING:
588
866
service.add()
590
868
591
869
def entry_group_state_changed(state, error):
592
870
"""Derived from the Avahi example code"""
593
logger.debug(u"state change: %i", state)
871
logger.debug(u"Avahi state change: %i", state)
594
872
595
873
if state == avahi.ENTRY_GROUP_ESTABLISHED:
596
logger.debug(u"Service established.")
874
logger.debug(u"Zeroconf service established.")
597
875
elif state == avahi.ENTRY_GROUP_COLLISION:
598
logger.warning(u"Service name collision.")
876
logger.warning(u"Zeroconf service name collision.")
599
877
service.rename()
600
878
elif state == avahi.ENTRY_GROUP_FAILURE:
601
logger.critical(u"Error in group state changed %s",
879
logger.critical(u"Avahi: Error in group state changed %s",
602
880
unicode(error))
603
raise AvahiGroupError("State changed: %s", str(error))
881
raise AvahiGroupError(u"State changed: %s" % unicode(error))
604
882
605
883
def if_nametoindex(interface):
606
884
"""Call the C function if_nametoindex(), or equivalent"""
607
885
global if_nametoindex
608
886
try:
609
if "ctypes.util" not in sys.modules:
610
import ctypes.util
611
if_nametoindex = ctypes.cdll.LoadLibrary\
612
(ctypes.util.find_library("c")).if_nametoindex
887
if_nametoindex = (ctypes.cdll.LoadLibrary
888
(ctypes.util.find_library("c"))
889
.if_nametoindex)
613
890
except (OSError, AttributeError):
614
891
if "struct" not in sys.modules:
615
892
import struct
618
895
def if_nametoindex(interface):
619
896
"Get an interface index the hard way, i.e. using fcntl()"
620
897
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
621
s = socket.socket()
622
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
623
struct.pack("16s16x", interface))
624
s.close()
898
with closing(socket.socket()) as s:
899
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
900
struct.pack("16s16x", interface))
625
901
interface_index = struct.unpack("I", ifreq[16:20])[0]
626
902
return interface_index
627
903
return if_nametoindex(interface)
651
927
652
928
653
929
def main():
654
global main_loop_started
655
main_loop_started = False
656
657
parser = OptionParser(version = "Mandos server %s" % version)
930
parser = optparse.OptionParser(version = "%%prog %s" % version)
658
931
parser.add_option("-i", "--interface", type="string",
659
932
metavar="IF", help="Bind to interface IF")
660
933
parser.add_option("-a", "--address", type="string",
661
934
help="Address to listen for requests on")
662
935
parser.add_option("-p", "--port", type="int",
663
936
help="Port number to receive requests on")
664
parser.add_option("--check", action="store_true", default=False,
937
parser.add_option("--check", action="store_true",
665
938
help="Run self-test")
666
939
parser.add_option("--debug", action="store_true",
667
940
help="Debug mode; run in foreground and log to"
674
947
default="/etc/mandos", metavar="DIR",
675
948
help="Directory to search for configuration"
676
949
" files")
677
(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]
678
957
679
958
if options.check:
680
959
import doctest
689
968
"priority":
690
969
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
691
970
"servicename": "Mandos",
971
"use_dbus": "True",
972
"use_ipv6": "True",
692
973
}
693
974
694
975
# Parse config file for server-global settings
695
976
server_config = ConfigParser.SafeConfigParser(server_defaults)
696
977
del server_defaults
697
978
server_config.read(os.path.join(options.configdir, "mandos.conf"))
698
server_section = "server"
699
979
# Convert the SafeConfigParser object to a dict
700
server_settings = dict(server_config.items(server_section))
701
# Use getboolean on the boolean config option
702
server_settings["debug"] = server_config.getboolean\
703
(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")
704
991
del server_config
705
992
706
993
# Override the settings from the config file with command line
707
994
# options, if set.
708
995
for option in ("interface", "address", "port", "debug",
709
"priority", "servicename", "configdir"):
996
"priority", "servicename", "configdir",
997
"use_dbus", "use_ipv6"):
710
998
value = getattr(options, option)
711
999
if value is not None:
712
1000
server_settings[option] = value
713
1001
del options
714
1002
# Now we have our good server settings in "server_settings"
715
1003
1004
# For convenience
716
1005
debug = server_settings["debug"]
1006
use_dbus = server_settings["use_dbus"]
1007
use_ipv6 = server_settings["use_ipv6"]
717
1008
718
1009
if not debug:
719
1010
syslogger.setLevel(logging.WARNING)
1011
console.setLevel(logging.WARNING)
720
1012
721
1013
if server_settings["servicename"] != "Mandos":
722
syslogger.setFormatter(logging.Formatter\
1014
syslogger.setFormatter(logging.Formatter
723
1015
('Mandos (%s): %%(levelname)s:'
724
1016
' %%(message)s'
725
1017
% server_settings["servicename"]))
728
1020
client_defaults = { "timeout": "1h",
729
1021
"interval": "5m",
730
1022
"checker": "fping -q -- %%(host)s",
1023
"host": "",
731
1024
}
732
1025
client_config = ConfigParser.SafeConfigParser(client_defaults)
733
1026
client_config.read(os.path.join(server_settings["configdir"],
734
1027
"clients.conf"))
735
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
736
1075
global service
1076
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
737
1077
service = AvahiService(name = server_settings["servicename"],
738
type = "_mandos._tcp", );
1078
servicetype = "_mandos._tcp",
1079
protocol = protocol)
739
1080
if server_settings["interface"]:
740
service.interface = if_nametoindex(server_settings["interface"])
1081
service.interface = (if_nametoindex
1082
(server_settings["interface"]))
741
1083
742
1084
global main_loop
743
1085
global bus
746
1088
DBusGMainLoop(set_as_default=True )
747
1089
main_loop = gobject.MainLoop()
748
1090
bus = dbus.SystemBus()
749
server = dbus.Interface(
750
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
751
avahi.DBUS_INTERFACE_SERVER )
1091
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1092
avahi.DBUS_PATH_SERVER),
1093
avahi.DBUS_INTERFACE_SERVER)
752
1094
# End of Avahi example code
753
754
if debug:
755
console = logging.StreamHandler()
756
# console.setLevel(logging.DEBUG)
757
console.setFormatter(logging.Formatter\
758
('%(levelname)s: %(message)s'))
759
logger.addHandler(console)
760
del console
761
762
clients = Set()
763
def remove_from_clients(client):
764
clients.remove(client)
765
if not clients:
766
logger.critical(u"No clients left, exiting")
767
sys.exit()
1095
if use_dbus:
1096
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
768
1097
769
1098
clients.update(Set(Client(name = section,
770
stop_hook = remove_from_clients,
771
1099
config
772
= dict(client_config.items(section)))
1100
= dict(client_config.items(section)),
1101
use_dbus = use_dbus)
773
1102
for section in client_config.sections()))
774
1103
if not clients:
775
logger.critical(u"No clients defined")
776
sys.exit(1)
1104
logger.warning(u"No clients defined")
777
1105
778
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
1114
logger.removeHandler(console)
1115
# Close all input and output, do double fork, etc.
779
1116
daemon()
780
1117
781
pidfilename = "/var/run/mandos/mandos.pid"
782
pid = os.getpid()
783
1118
try:
784
pidfile = open(pidfilename, "w")
1119
pid = os.getpid()
785
1120
pidfile.write(str(pid) + "\n")
786
1121
pidfile.close()
787
1122
del pidfile
788
except IOError, err:
789
logger.error(u"Could not write %s file with PID %d",
790
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
791
1130
792
1131
def cleanup():
793
1132
"Cleanup function; run on exit"
800
1139
801
1140
while clients:
802
1141
client = clients.pop()
803
client.stop_hook = None
804
client.stop()
1142
client.disable_hook = None
1143
client.disable()
805
1144
806
1145
atexit.register(cleanup)
807
1146
810
1149
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
811
1150
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
812
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
813
1200
for client in clients:
814
client.start()
815
816
tcp_server = IPv6_TCPServer((server_settings["address"],
817
server_settings["port"]),
818
tcp_handler,
819
settings=server_settings,
820
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
821
1210
# Find out what port we got
822
1211
service.port = tcp_server.socket.getsockname()[1]
823
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
824
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())
825
1219
826
1220
#service.interface = tcp_server.socket.getsockname()[3]
827
1221
837
1231
838
1232
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
839
1233
lambda *args, **kwargs:
840
tcp_server.handle_request\
841
(*args[2:], **kwargs) or True)
1234
(tcp_server.handle_request
1235
(*args[2:], **kwargs) or True))
842
1236
843
1237
logger.debug(u"Starting main loop")
844
main_loop_started = True
845
1238
main_loop.run()
846
1239
except AvahiError, error:
847
logger.critical(u"AvahiError: %s" + unicode(error))
1240
logger.critical(u"AvahiError: %s", error)
848
1241
sys.exit(1)
849
1242
except KeyboardInterrupt:
850
1243
if debug:
851
print
1244
print >> sys.stderr
1245
logger.debug("Server received KeyboardInterrupt")
1246
logger.debug("Server exiting")
852
1247
853
1248
if __name__ == '__main__':
854
1249
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0