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 24.1.113
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.113
- Committer: Björn Påhlsson
- Date: 2008-11-12 05:46:49 UTC
- mfrom: (237.1.2 mandos)
- mto: (24.1.154 mandos) (237.4.3 mandos-release)
- mto: This revision was merged to the branch mainline in revision 240.
- Revision ID: belorn@braxen-20081112054649-g3m4i22ncnaf5hbi
merge
- files added:
- debian/mandos-client.config
- files removed:
- debian/watch
- files modified:
- INSTALL
added
removed
mandos
11
11
# and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2008,2009 Teddy Hogeborn
15
# Copyright © 2008,2009 Björn Påhlsson
14
# Copyright © 2008 Teddy Hogeborn
15
# Copyright © 2008 Björn Påhlsson
16
16
#
17
17
# This program is free software: you can redistribute it and/or modify
18
18
# it under the terms of the GNU General Public License as published by
35
35
36
36
import SocketServer
37
37
import socket
38
import optparse
38
from optparse import OptionParser
39
39
import datetime
40
40
import errno
41
41
import gnutls.crypto
66
66
import ctypes
67
67
import ctypes.util
68
68
69
version = "1.0.5"
69
version = "1.0.2"
70
70
71
71
logger = logging.Logger('mandos')
72
72
syslogger = (logging.handlers.SysLogHandler
82
82
logger.addHandler(console)
83
83
84
84
class AvahiError(Exception):
85
def __init__(self, value, *args, **kwargs):
85
def __init__(self, value):
86
86
self.value = value
87
super(AvahiError, self).__init__(value, *args, **kwargs)
88
def __unicode__(self):
89
return unicode(repr(self.value))
87
super(AvahiError, self).__init__()
88
def __str__(self):
89
return repr(self.value)
90
90
91
91
class AvahiServiceError(AvahiError):
92
92
pass
129
129
logger.critical(u"No suitable Zeroconf service name found"
130
130
u" after %i retries, exiting.",
131
131
self.rename_count)
132
raise AvahiServiceError(u"Too many renames")
132
raise AvahiServiceError("Too many renames")
133
133
self.name = server.GetAlternativeServiceName(self.name)
134
134
logger.info(u"Changing Zeroconf service name to %r ...",
135
135
str(self.name))
170
170
# End of Avahi example code
171
171
172
172
173
def _datetime_to_dbus(dt, variant_level=0):
174
"""Convert a UTC datetime.datetime() to a D-Bus type."""
175
return dbus.String(dt.isoformat(), variant_level=variant_level)
176
177
178
173
class Client(dbus.service.Object):
179
174
"""A representation of a client host served by this server.
180
175
Attributes:
181
name: string; from the config file, used in log messages and
182
D-Bus identifiers
176
name: string; from the config file, used in log messages
183
177
fingerprint: string (40 or 32 hexadecimal digits); used to
184
178
uniquely identify the client
185
secret: bytestring; sent verbatim (over TLS) to client
186
host: string; available for use by the checker command
187
created: datetime.datetime(); (UTC) object creation
188
last_enabled: datetime.datetime(); (UTC)
189
enabled: bool()
179
secret: bytestring; sent verbatim (over TLS) to client
180
host: string; available for use by the checker command
181
created: datetime.datetime(); (UTC) object creation
182
started: datetime.datetime(); (UTC) last started
190
183
last_checked_ok: datetime.datetime(); (UTC) or None
191
timeout: datetime.timedelta(); How long from last_checked_ok
192
until this client is invalid
193
interval: datetime.timedelta(); How often to start a new checker
194
disable_hook: If set, called by disable() as disable_hook(self)
195
checker: subprocess.Popen(); a running checker process used
196
to see if the client lives.
197
'None' if no process is running.
184
timeout: datetime.timedelta(); How long from last_checked_ok
185
until this client is invalid
186
interval: datetime.timedelta(); How often to start a new checker
187
stop_hook: If set, called by stop() as stop_hook(self)
188
checker: subprocess.Popen(); a running checker process used
189
to see if the client lives.
190
'None' if no process is running.
198
191
checker_initiator_tag: a gobject event source tag, or None
199
disable_initiator_tag: - '' -
192
stop_initiator_tag: - '' -
200
193
checker_callback_tag: - '' -
201
194
checker_command: string; External command which is run to check if
202
195
client lives. %() expansions are done at
203
196
runtime with vars(self) as dict, so that for
204
197
instance %(name)s can be used in the command.
205
use_dbus: bool(); Whether to provide D-Bus interface and signals
206
dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus
198
Private attibutes:
199
_timeout: Real variable for 'timeout'
200
_interval: Real variable for 'interval'
201
_timeout_milliseconds: Used when calling gobject.timeout_add()
202
_interval_milliseconds: - '' -
207
203
"""
208
def timeout_milliseconds(self):
209
"Return the 'timeout' attribute in milliseconds"
210
return ((self.timeout.days * 24 * 60 * 60 * 1000)
211
+ (self.timeout.seconds * 1000)
212
+ (self.timeout.microseconds // 1000))
213
214
def interval_milliseconds(self):
215
"Return the 'interval' attribute in milliseconds"
216
return ((self.interval.days * 24 * 60 * 60 * 1000)
217
+ (self.interval.seconds * 1000)
218
+ (self.interval.microseconds // 1000))
219
220
def __init__(self, name = None, disable_hook=None, config=None,
221
use_dbus=True):
204
def _set_timeout(self, timeout):
205
"Setter function for the 'timeout' attribute"
206
self._timeout = timeout
207
self._timeout_milliseconds = ((self.timeout.days
208
* 24 * 60 * 60 * 1000)
209
+ (self.timeout.seconds * 1000)
210
+ (self.timeout.microseconds
211
// 1000))
212
# Emit D-Bus signal
213
self.TimeoutChanged(self._timeout_milliseconds)
214
timeout = property(lambda self: self._timeout, _set_timeout)
215
del _set_timeout
216
217
def _set_interval(self, interval):
218
"Setter function for the 'interval' attribute"
219
self._interval = interval
220
self._interval_milliseconds = ((self.interval.days
221
* 24 * 60 * 60 * 1000)
222
+ (self.interval.seconds
223
* 1000)
224
+ (self.interval.microseconds
225
// 1000))
226
# Emit D-Bus signal
227
self.IntervalChanged(self._interval_milliseconds)
228
interval = property(lambda self: self._interval, _set_interval)
229
del _set_interval
230
231
def __init__(self, name = None, stop_hook=None, config=None):
222
232
"""Note: the 'checker' key in 'config' sets the
223
233
'checker_command' attribute and *not* the 'checker'
224
234
attribute."""
225
self.name = name
235
dbus.service.Object.__init__(self, bus,
236
"/Mandos/clients/%s"
237
% name.replace(".", "_"))
226
238
if config is None:
227
239
config = {}
240
self.name = name
228
241
logger.debug(u"Creating client %r", self.name)
229
self.use_dbus = False # During __init__
230
242
# Uppercase and remove spaces from fingerprint for later
231
243
# comparison purposes with return value from the fingerprint()
232
244
# function
245
257
% self.name)
246
258
self.host = config.get("host", "")
247
259
self.created = datetime.datetime.utcnow()
248
self.enabled = False
249
self.last_enabled = None
260
self.started = None
250
261
self.last_checked_ok = None
251
262
self.timeout = string_to_delta(config["timeout"])
252
263
self.interval = string_to_delta(config["interval"])
253
self.disable_hook = disable_hook
264
self.stop_hook = stop_hook
254
265
self.checker = None
255
266
self.checker_initiator_tag = None
256
self.disable_initiator_tag = None
267
self.stop_initiator_tag = None
257
268
self.checker_callback_tag = None
258
self.checker_command = config["checker"]
259
self.last_connect = None
260
# Only now, when this client is initialized, can it show up on
261
# the D-Bus
262
self.use_dbus = use_dbus
263
if self.use_dbus:
264
self.dbus_object_path = (dbus.ObjectPath
265
("/clients/"
266
+ self.name.replace(".", "_")))
267
dbus.service.Object.__init__(self, bus,
268
self.dbus_object_path)
269
self.check_command = config["checker"]
269
270
270
def enable(self):
271
def start(self):
271
272
"""Start this client's checker and timeout hooks"""
272
self.last_enabled = datetime.datetime.utcnow()
273
self.started = datetime.datetime.utcnow()
273
274
# Schedule a new checker to be started an 'interval' from now,
274
275
# and every interval from then on.
275
276
self.checker_initiator_tag = (gobject.timeout_add
276
(self.interval_milliseconds(),
277
(self._interval_milliseconds,
277
278
self.start_checker))
278
279
# Also start a new checker *right now*.
279
280
self.start_checker()
280
# Schedule a disable() when 'timeout' has passed
281
self.disable_initiator_tag = (gobject.timeout_add
282
(self.timeout_milliseconds(),
283
self.disable))
284
self.enabled = True
285
if self.use_dbus:
286
# Emit D-Bus signals
287
self.PropertyChanged(dbus.String(u"enabled"),
288
dbus.Boolean(True, variant_level=1))
289
self.PropertyChanged(dbus.String(u"last_enabled"),
290
(_datetime_to_dbus(self.last_enabled,
291
variant_level=1)))
281
# Schedule a stop() when 'timeout' has passed
282
self.stop_initiator_tag = (gobject.timeout_add
283
(self._timeout_milliseconds,
284
self.stop))
285
# Emit D-Bus signal
286
self.StateChanged(True)
292
287
293
def disable(self):
294
"""Disable this client."""
295
if not getattr(self, "enabled", False):
288
def stop(self):
289
"""Stop this client."""
290
if getattr(self, "started", None) is not None:
291
logger.info(u"Stopping client %s", self.name)
292
else:
296
293
return False
297
logger.info(u"Disabling client %s", self.name)
298
if getattr(self, "disable_initiator_tag", False):
299
gobject.source_remove(self.disable_initiator_tag)
300
self.disable_initiator_tag = None
294
if getattr(self, "stop_initiator_tag", False):
295
gobject.source_remove(self.stop_initiator_tag)
296
self.stop_initiator_tag = None
301
297
if getattr(self, "checker_initiator_tag", False):
302
298
gobject.source_remove(self.checker_initiator_tag)
303
299
self.checker_initiator_tag = None
304
300
self.stop_checker()
305
if self.disable_hook:
306
self.disable_hook(self)
307
self.enabled = False
308
if self.use_dbus:
309
# Emit D-Bus signal
310
self.PropertyChanged(dbus.String(u"enabled"),
311
dbus.Boolean(False, variant_level=1))
301
if self.stop_hook:
302
self.stop_hook(self)
303
self.started = None
304
# Emit D-Bus signal
305
self.StateChanged(False)
312
306
# Do not run this again if called by a gobject.timeout_add
313
307
return False
314
308
315
309
def __del__(self):
316
self.disable_hook = None
317
self.disable()
310
self.stop_hook = None
311
self.stop()
318
312
319
def checker_callback(self, pid, condition, command):
313
def checker_callback(self, pid, condition):
320
314
"""The checker has completed, so take appropriate actions."""
321
315
self.checker_callback_tag = None
322
316
self.checker = None
323
if self.use_dbus:
317
if (os.WIFEXITED(condition)
318
and (os.WEXITSTATUS(condition) == 0)):
319
logger.info(u"Checker for %(name)s succeeded",
320
vars(self))
324
321
# Emit D-Bus signal
325
self.PropertyChanged(dbus.String(u"checker_running"),
326
dbus.Boolean(False, variant_level=1))
327
if os.WIFEXITED(condition):
328
exitstatus = os.WEXITSTATUS(condition)
329
if exitstatus == 0:
330
logger.info(u"Checker for %(name)s succeeded",
331
vars(self))
332
self.checked_ok()
333
else:
334
logger.info(u"Checker for %(name)s failed",
335
vars(self))
336
if self.use_dbus:
337
# Emit D-Bus signal
338
self.CheckerCompleted(dbus.Int16(exitstatus),
339
dbus.Int64(condition),
340
dbus.String(command))
341
else:
322
self.CheckerCompleted(True)
323
self.bump_timeout()
324
elif not os.WIFEXITED(condition):
342
325
logger.warning(u"Checker for %(name)s crashed?",
343
326
vars(self))
344
if self.use_dbus:
345
# Emit D-Bus signal
346
self.CheckerCompleted(dbus.Int16(-1),
347
dbus.Int64(condition),
348
dbus.String(command))
327
# Emit D-Bus signal
328
self.CheckerCompleted(False)
329
else:
330
logger.info(u"Checker for %(name)s failed",
331
vars(self))
332
# Emit D-Bus signal
333
self.CheckerCompleted(False)
349
334
350
def checked_ok(self):
335
def bump_timeout(self):
351
336
"""Bump up the timeout for this client.
352
337
This should only be called when the client has been seen,
353
338
alive and well.
354
339
"""
355
340
self.last_checked_ok = datetime.datetime.utcnow()
356
gobject.source_remove(self.disable_initiator_tag)
357
self.disable_initiator_tag = (gobject.timeout_add
358
(self.timeout_milliseconds(),
359
self.disable))
360
if self.use_dbus:
361
# Emit D-Bus signal
362
self.PropertyChanged(
363
dbus.String(u"last_checked_ok"),
364
(_datetime_to_dbus(self.last_checked_ok,
365
variant_level=1)))
341
gobject.source_remove(self.stop_initiator_tag)
342
self.stop_initiator_tag = (gobject.timeout_add
343
(self._timeout_milliseconds,
344
self.stop))
366
345
367
346
def start_checker(self):
368
347
"""Start a new checker subprocess if one is not running.
378
357
# is as it should be.
379
358
if self.checker is None:
380
359
try:
381
# In case checker_command has exactly one % operator
382
command = self.checker_command % self.host
360
# In case check_command has exactly one % operator
361
command = self.check_command % self.host
383
362
except TypeError:
384
363
# Escape attributes for the shell
385
364
escaped_attrs = dict((key, re.escape(str(val)))
386
365
for key, val in
387
366
vars(self).iteritems())
388
367
try:
389
command = self.checker_command % escaped_attrs
368
command = self.check_command % escaped_attrs
390
369
except TypeError, error:
391
370
logger.error(u'Could not format string "%s":'
392
u' %s', self.checker_command, error)
371
u' %s', self.check_command, error)
393
372
return True # Try again later
394
373
try:
395
374
logger.info(u"Starting checker %r for %s",
401
380
self.checker = subprocess.Popen(command,
402
381
close_fds=True,
403
382
shell=True, cwd="/")
404
if self.use_dbus:
405
# Emit D-Bus signal
406
self.CheckerStarted(command)
407
self.PropertyChanged(
408
dbus.String("checker_running"),
409
dbus.Boolean(True, variant_level=1))
410
383
self.checker_callback_tag = (gobject.child_watch_add
411
384
(self.checker.pid,
412
self.checker_callback,
413
data=command))
385
self.checker_callback))
386
# Emit D-Bus signal
387
self.CheckerStarted(command)
414
388
except OSError, error:
415
389
logger.error(u"Failed to start subprocess: %s",
416
390
error)
434
408
if error.errno != errno.ESRCH: # No such process
435
409
raise
436
410
self.checker = None
437
if self.use_dbus:
438
self.PropertyChanged(dbus.String(u"checker_running"),
439
dbus.Boolean(False, variant_level=1))
440
411
441
412
def still_valid(self):
442
413
"""Has the timeout not yet passed for this client?"""
443
if not getattr(self, "enabled", False):
414
if not self.started:
444
415
return False
445
416
now = datetime.datetime.utcnow()
446
417
if self.last_checked_ok is None:
449
420
return now < (self.last_checked_ok + self.timeout)
450
421
451
422
## D-Bus methods & signals
452
_interface = u"se.bsnet.fukt.Mandos.Client"
453
454
# CheckedOK - method
455
CheckedOK = dbus.service.method(_interface)(checked_ok)
456
CheckedOK.__name__ = "CheckedOK"
423
_interface = u"org.mandos_system.Mandos.Client"
424
425
def _datetime_to_dbus_struct(dt):
426
return dbus.Struct(dt.year, dt.month, dt.day, dt.hour,
427
dt.minute, dt.second, dt.microsecond,
428
signature="nyyyyyu")
429
430
# BumpTimeout - method
431
BumpTimeout = dbus.service.method(_interface)(bump_timeout)
432
BumpTimeout.__name__ = "BumpTimeout"
433
434
# IntervalChanged - signal
435
@dbus.service.signal(_interface, signature="t")
436
def IntervalChanged(self, t):
437
"D-Bus signal"
438
pass
457
439
458
440
# CheckerCompleted - signal
459
@dbus.service.signal(_interface, signature="nxs")
460
def CheckerCompleted(self, exitcode, waitstatus, command):
441
@dbus.service.signal(_interface, signature="b")
442
def CheckerCompleted(self, success):
461
443
"D-Bus signal"
462
444
pass
463
445
446
# CheckerIsRunning - method
447
@dbus.service.method(_interface, out_signature="b")
448
def CheckerIsRunning(self):
449
"D-Bus getter method"
450
return self.checker is not None
451
464
452
# CheckerStarted - signal
465
453
@dbus.service.signal(_interface, signature="s")
466
454
def CheckerStarted(self, command):
467
455
"D-Bus signal"
468
456
pass
469
457
470
# GetAllProperties - method
471
@dbus.service.method(_interface, out_signature="a{sv}")
472
def GetAllProperties(self):
473
"D-Bus method"
474
return dbus.Dictionary({
475
dbus.String("name"):
476
dbus.String(self.name, variant_level=1),
477
dbus.String("fingerprint"):
478
dbus.String(self.fingerprint, variant_level=1),
479
dbus.String("host"):
480
dbus.String(self.host, variant_level=1),
481
dbus.String("created"):
482
_datetime_to_dbus(self.created, variant_level=1),
483
dbus.String("last_enabled"):
484
(_datetime_to_dbus(self.last_enabled,
485
variant_level=1)
486
if self.last_enabled is not None
487
else dbus.Boolean(False, variant_level=1)),
488
dbus.String("enabled"):
489
dbus.Boolean(self.enabled, variant_level=1),
490
dbus.String("last_checked_ok"):
491
(_datetime_to_dbus(self.last_checked_ok,
492
variant_level=1)
493
if self.last_checked_ok is not None
494
else dbus.Boolean (False, variant_level=1)),
495
dbus.String("timeout"):
496
dbus.UInt64(self.timeout_milliseconds(),
497
variant_level=1),
498
dbus.String("interval"):
499
dbus.UInt64(self.interval_milliseconds(),
500
variant_level=1),
501
dbus.String("checker"):
502
dbus.String(self.checker_command,
503
variant_level=1),
504
dbus.String("checker_running"):
505
dbus.Boolean(self.checker is not None,
506
variant_level=1),
507
dbus.String("object_path"):
508
dbus.ObjectPath(self.dbus_object_path,
509
variant_level=1)
510
}, signature="sv")
511
512
# IsStillValid - method
513
IsStillValid = (dbus.service.method(_interface, out_signature="b")
514
(still_valid))
515
IsStillValid.__name__ = "IsStillValid"
516
517
# PropertyChanged - signal
518
@dbus.service.signal(_interface, signature="sv")
519
def PropertyChanged(self, property, value):
520
"D-Bus signal"
521
pass
458
# GetChecker - method
459
@dbus.service.method(_interface, out_signature="s")
460
def GetChecker(self):
461
"D-Bus getter method"
462
return self.checker_command
463
464
# GetCreated - method
465
@dbus.service.method(_interface, out_signature="(nyyyyyu)")
466
def GetCreated(self):
467
"D-Bus getter method"
468
return datetime_to_dbus_struct(self.created)
469
470
# GetFingerprint - method
471
@dbus.service.method(_interface, out_signature="s")
472
def GetFingerprint(self):
473
"D-Bus getter method"
474
return self.fingerprint
475
476
# GetHost - method
477
@dbus.service.method(_interface, out_signature="s")
478
def GetHost(self):
479
"D-Bus getter method"
480
return self.host
481
482
# GetInterval - method
483
@dbus.service.method(_interface, out_signature="t")
484
def GetInterval(self):
485
"D-Bus getter method"
486
return self._interval_milliseconds
487
488
# GetName - method
489
@dbus.service.method(_interface, out_signature="s")
490
def GetName(self):
491
"D-Bus getter method"
492
return self.name
493
494
# GetStarted - method
495
@dbus.service.method(_interface, out_signature="(nyyyyyu)")
496
def GetStarted(self):
497
"D-Bus getter method"
498
if self.started is not None:
499
return datetime_to_dbus_struct(self.started)
500
else:
501
return dbus.Struct(0, 0, 0, 0, 0, 0, 0,
502
signature="nyyyyyu")
503
504
# GetTimeout - method
505
@dbus.service.method(_interface, out_signature="t")
506
def GetTimeout(self):
507
"D-Bus getter method"
508
return self._timeout_milliseconds
522
509
523
510
# SetChecker - method
524
511
@dbus.service.method(_interface, in_signature="s")
525
512
def SetChecker(self, checker):
526
513
"D-Bus setter method"
527
514
self.checker_command = checker
528
# Emit D-Bus signal
529
self.PropertyChanged(dbus.String(u"checker"),
530
dbus.String(self.checker_command,
531
variant_level=1))
532
515
533
516
# SetHost - method
534
517
@dbus.service.method(_interface, in_signature="s")
535
518
def SetHost(self, host):
536
519
"D-Bus setter method"
537
520
self.host = host
538
# Emit D-Bus signal
539
self.PropertyChanged(dbus.String(u"host"),
540
dbus.String(self.host, variant_level=1))
541
521
542
522
# SetInterval - method
543
523
@dbus.service.method(_interface, in_signature="t")
544
524
def SetInterval(self, milliseconds):
545
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
546
# Emit D-Bus signal
547
self.PropertyChanged(dbus.String(u"interval"),
548
(dbus.UInt64(self.interval_milliseconds(),
549
variant_level=1)))
525
self.interval = datetime.timdeelta(0, 0, 0, milliseconds)
526
527
# SetTimeout - method
528
@dbus.service.method(_interface, in_signature="t")
529
def SetTimeout(self, milliseconds):
530
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
550
531
551
532
# SetSecret - method
552
533
@dbus.service.method(_interface, in_signature="ay",
555
536
"D-Bus setter method"
556
537
self.secret = str(secret)
557
538
558
# SetTimeout - method
559
@dbus.service.method(_interface, in_signature="t")
560
def SetTimeout(self, milliseconds):
561
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
562
# Emit D-Bus signal
563
self.PropertyChanged(dbus.String(u"timeout"),
564
(dbus.UInt64(self.timeout_milliseconds(),
565
variant_level=1)))
566
567
# Enable - method
568
Enable = dbus.service.method(_interface)(enable)
569
Enable.__name__ = "Enable"
539
# Start - method
540
Start = dbus.service.method(_interface)(start)
541
Start.__name__ = "Start"
570
542
571
543
# StartChecker - method
572
@dbus.service.method(_interface)
573
def StartChecker(self):
574
"D-Bus method"
575
self.start_checker()
576
577
# Disable - method
578
@dbus.service.method(_interface)
579
def Disable(self):
580
"D-Bus method"
581
self.disable()
544
StartChecker = dbus.service.method(_interface)(start_checker)
545
StartChecker.__name__ = "StartChecker"
546
547
# StateChanged - signal
548
@dbus.service.signal(_interface, signature="b")
549
def StateChanged(self, started):
550
"D-Bus signal"
551
pass
552
553
# StillValid - method
554
StillValid = (dbus.service.method(_interface, out_signature="b")
555
(still_valid))
556
StillValid.__name__ = "StillValid"
557
558
# Stop - method
559
Stop = dbus.service.method(_interface)(stop)
560
Stop.__name__ = "Stop"
582
561
583
562
# StopChecker - method
584
563
StopChecker = dbus.service.method(_interface)(stop_checker)
585
564
StopChecker.__name__ = "StopChecker"
586
565
566
# TimeoutChanged - signal
567
@dbus.service.signal(_interface, signature="t")
568
def TimeoutChanged(self, t):
569
"D-Bus signal"
570
pass
571
572
del _datetime_to_dbus_struct
587
573
del _interface
588
574
589
575
595
581
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
596
582
# ...do the normal thing
597
583
return session.peer_certificate
598
list_size = ctypes.c_uint(1)
584
list_size = ctypes.c_uint()
599
585
cert_list = (gnutls.library.functions
600
586
.gnutls_certificate_get_peers
601
587
(session._c_object, ctypes.byref(list_size)))
602
if not bool(cert_list) and list_size.value != 0:
603
raise gnutls.errors.GNUTLSError("error getting peer"
604
" certificate")
605
588
if list_size.value == 0:
606
589
return None
607
590
cert = cert_list[0]
691
674
# Do not run session.bye() here: the session is not
692
675
# established. Just abandon the request.
693
676
return
694
logger.debug(u"Handshake succeeded")
695
677
try:
696
678
fpr = fingerprint(peer_certificate(session))
697
679
except (TypeError, gnutls.errors.GNUTLSError), error:
717
699
session.bye()
718
700
return
719
701
## This won't work here, since we're in a fork.
720
# client.checked_ok()
702
# client.bump_timeout()
721
703
sent_size = 0
722
704
while sent_size < len(client.secret):
723
705
sent = session.send(client.secret[sent_size:])
848
830
elif state == avahi.ENTRY_GROUP_FAILURE:
849
831
logger.critical(u"Avahi: Error in group state changed %s",
850
832
unicode(error))
851
raise AvahiGroupError(u"State changed: %s" % unicode(error))
833
raise AvahiGroupError("State changed: %s", str(error))
852
834
853
835
def if_nametoindex(interface):
854
836
"""Call the C function if_nametoindex(), or equivalent"""
897
879
898
880
899
881
def main():
900
parser = optparse.OptionParser(version = "%%prog %s" % version)
882
parser = OptionParser(version = "%%prog %s" % version)
901
883
parser.add_option("-i", "--interface", type="string",
902
884
metavar="IF", help="Bind to interface IF")
903
885
parser.add_option("-a", "--address", type="string",
904
886
help="Address to listen for requests on")
905
887
parser.add_option("-p", "--port", type="int",
906
888
help="Port number to receive requests on")
907
parser.add_option("--check", action="store_true",
889
parser.add_option("--check", action="store_true", default=False,
908
890
help="Run self-test")
909
891
parser.add_option("--debug", action="store_true",
910
892
help="Debug mode; run in foreground and log to"
917
899
default="/etc/mandos", metavar="DIR",
918
900
help="Directory to search for configuration"
919
901
" files")
920
parser.add_option("--no-dbus", action="store_false",
921
dest="use_dbus",
922
help="Do not provide D-Bus system bus"
923
" interface")
924
902
options = parser.parse_args()[0]
925
903
926
904
if options.check:
936
914
"priority":
937
915
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
938
916
"servicename": "Mandos",
939
"use_dbus": "True",
940
917
}
941
918
942
919
# Parse config file for server-global settings
945
922
server_config.read(os.path.join(options.configdir, "mandos.conf"))
946
923
# Convert the SafeConfigParser object to a dict
947
924
server_settings = server_config.defaults()
948
# Use the appropriate methods on the non-string config options
949
server_settings["debug"] = server_config.getboolean("DEFAULT",
950
"debug")
951
server_settings["use_dbus"] = server_config.getboolean("DEFAULT",
952
"use_dbus")
953
if server_settings["port"]:
954
server_settings["port"] = server_config.getint("DEFAULT",
955
"port")
925
# Use getboolean on the boolean config option
926
server_settings["debug"] = (server_config.getboolean
927
("DEFAULT", "debug"))
956
928
del server_config
957
929
958
930
# Override the settings from the config file with command line
959
931
# options, if set.
960
932
for option in ("interface", "address", "port", "debug",
961
"priority", "servicename", "configdir",
962
"use_dbus"):
933
"priority", "servicename", "configdir"):
963
934
value = getattr(options, option)
964
935
if value is not None:
965
936
server_settings[option] = value
966
937
del options
967
938
# Now we have our good server settings in "server_settings"
968
939
969
# For convenience
970
940
debug = server_settings["debug"]
971
use_dbus = server_settings["use_dbus"]
972
941
973
942
if not debug:
974
943
syslogger.setLevel(logging.WARNING)
983
952
# Parse config file with clients
984
953
client_defaults = { "timeout": "1h",
985
954
"interval": "5m",
986
"checker": "fping -q -- %%(host)s",
955
"checker": "fping -q -- %(host)s",
987
956
"host": "",
988
957
}
989
958
client_config = ConfigParser.SafeConfigParser(client_defaults)
1002
971
except IOError, error:
1003
972
logger.error("Could not open file %r", pidfilename)
1004
973
1005
try:
1006
uid = pwd.getpwnam("_mandos").pw_uid
1007
gid = pwd.getpwnam("_mandos").pw_gid
1008
except KeyError:
1009
try:
1010
uid = pwd.getpwnam("mandos").pw_uid
1011
gid = pwd.getpwnam("mandos").pw_gid
1012
except KeyError:
1013
try:
1014
uid = pwd.getpwnam("nobody").pw_uid
1015
gid = pwd.getpwnam("nogroup").pw_gid
1016
except KeyError:
1017
uid = 65534
1018
gid = 65534
974
uid = 65534
975
gid = 65534
976
try:
977
uid = pwd.getpwnam("mandos").pw_uid
978
except KeyError:
979
try:
980
uid = pwd.getpwnam("nobody").pw_uid
981
except KeyError:
982
pass
983
try:
984
gid = pwd.getpwnam("mandos").pw_gid
985
except KeyError:
986
try:
987
gid = pwd.getpwnam("nogroup").pw_gid
988
except KeyError:
989
pass
1019
990
try:
1020
991
os.setuid(uid)
1021
992
os.setgid(gid)
1041
1012
avahi.DBUS_PATH_SERVER),
1042
1013
avahi.DBUS_INTERFACE_SERVER)
1043
1014
# End of Avahi example code
1044
if use_dbus:
1045
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
1015
bus_name = dbus.service.BusName(u"org.mandos-system.Mandos", bus)
1016
1017
def remove_from_clients(client):
1018
clients.remove(client)
1019
if not clients:
1020
logger.critical(u"No clients left, exiting")
1021
sys.exit()
1046
1022
1047
1023
clients.update(Set(Client(name = section,
1024
stop_hook = remove_from_clients,
1048
1025
config
1049
= dict(client_config.items(section)),
1050
use_dbus = use_dbus)
1026
= dict(client_config.items(section)))
1051
1027
for section in client_config.sections()))
1052
1028
if not clients:
1053
logger.warning(u"No clients defined")
1029
logger.critical(u"No clients defined")
1030
sys.exit(1)
1054
1031
1055
1032
if debug:
1056
1033
# Redirect stdin so all checkers get /dev/null
1088
1065
1089
1066
while clients:
1090
1067
client = clients.pop()
1091
client.disable_hook = None
1092
client.disable()
1068
client.stop_hook = None
1069
client.stop()
1093
1070
1094
1071
atexit.register(cleanup)
1095
1072
1098
1075
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1099
1076
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1100
1077
1101
if use_dbus:
1102
class MandosServer(dbus.service.Object):
1103
"""A D-Bus proxy object"""
1104
def __init__(self):
1105
dbus.service.Object.__init__(self, bus, "/")
1106
_interface = u"se.bsnet.fukt.Mandos"
1107
1108
@dbus.service.signal(_interface, signature="oa{sv}")
1109
def ClientAdded(self, objpath, properties):
1110
"D-Bus signal"
1111
pass
1112
1113
@dbus.service.signal(_interface, signature="os")
1114
def ClientRemoved(self, objpath, name):
1115
"D-Bus signal"
1116
pass
1117
1118
@dbus.service.method(_interface, out_signature="ao")
1119
def GetAllClients(self):
1120
"D-Bus method"
1121
return dbus.Array(c.dbus_object_path for c in clients)
1122
1123
@dbus.service.method(_interface, out_signature="a{oa{sv}}")
1124
def GetAllClientsWithProperties(self):
1125
"D-Bus method"
1126
return dbus.Dictionary(
1127
((c.dbus_object_path, c.GetAllProperties())
1128
for c in clients),
1129
signature="oa{sv}")
1130
1131
@dbus.service.method(_interface, in_signature="o")
1132
def RemoveClient(self, object_path):
1133
"D-Bus method"
1134
for c in clients:
1135
if c.dbus_object_path == object_path:
1136
clients.remove(c)
1137
# Don't signal anything except ClientRemoved
1138
c.use_dbus = False
1139
c.disable()
1140
# Emit D-Bus signal
1141
self.ClientRemoved(object_path, c.name)
1142
return
1143
raise KeyError
1144
1145
del _interface
1146
1147
mandos_server = MandosServer()
1148
1149
1078
for client in clients:
1150
if use_dbus:
1151
# Emit D-Bus signal
1152
mandos_server.ClientAdded(client.dbus_object_path,
1153
client.GetAllProperties())
1154
client.enable()
1079
client.start()
1155
1080
1156
1081
tcp_server.enable()
1157
1082
tcp_server.server_activate()
1181
1106
logger.debug(u"Starting main loop")
1182
1107
main_loop.run()
1183
1108
except AvahiError, error:
1184
logger.critical(u"AvahiError: %s", error)
1109
logger.critical(u"AvahiError: %s" + unicode(error))
1185
1110
sys.exit(1)
1186
1111
except KeyboardInterrupt:
1187
1112
if debug:
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0