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.145
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.145
- Committer: Björn Påhlsson
- Date: 2009-11-16 14:41:32 UTC
- mto: (24.1.154 mandos) (237.4.3 mandos-release)
- mto: This revision was merged to the branch mainline in revision 415.
- Revision ID: belorn@braxen-20091116144132-89ake84mbhgkhcah
todo
- files modified:
- INSTALL
added
removed
mandos
6
6
# This program is partly derived from an example program for an Avahi
7
7
# service publisher, downloaded from
8
8
# <http://avahi.org/wiki/PythonPublishExample>. This includes the
9
# methods "add" and "remove" in the "AvahiService" class, the
10
# "server_state_changed" and "entry_group_state_changed" functions,
11
# and some lines in "main".
9
# methods "add", "remove", "server_state_changed",
10
# "entry_group_state_changed", "cleanup", and "activate" in the
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
14
# Copyright © 2008,2009 Teddy Hogeborn
33
33
34
34
from __future__ import division, with_statement, absolute_import
35
35
36
import SocketServer
36
import SocketServer as socketserver
37
37
import socket
38
38
import optparse
39
39
import datetime
44
44
import gnutls.library.functions
45
45
import gnutls.library.constants
46
46
import gnutls.library.types
47
import ConfigParser
47
import ConfigParser as configparser
48
48
import sys
49
49
import re
50
50
import os
51
51
import signal
52
from sets import Set
53
52
import subprocess
54
53
import atexit
55
54
import stat
57
56
import logging.handlers
58
57
import pwd
59
58
from contextlib import closing
59
import struct
60
import fcntl
61
import functools
60
62
61
63
import dbus
62
64
import dbus.service
65
67
from dbus.mainloop.glib import DBusGMainLoop
66
68
import ctypes
67
69
import ctypes.util
68
69
version = "1.0.5"
70
71
logger = logging.Logger('mandos')
70
import xml.dom.minidom
71
import inspect
72
73
try:
74
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
75
except AttributeError:
76
try:
77
from IN import SO_BINDTODEVICE
78
except ImportError:
79
SO_BINDTODEVICE = None
80
81
82
version = "1.0.12"
83
84
logger = logging.Logger(u'mandos')
72
85
syslogger = (logging.handlers.SysLogHandler
73
86
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
74
87
address = "/dev/log"))
75
88
syslogger.setFormatter(logging.Formatter
76
('Mandos [%(process)d]: %(levelname)s:'
77
' %(message)s'))
89
(u'Mandos [%(process)d]: %(levelname)s:'
90
u' %(message)s'))
78
91
logger.addHandler(syslogger)
79
92
80
93
console = logging.StreamHandler()
81
console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'
82
' %(levelname)s: %(message)s'))
94
console.setFormatter(logging.Formatter(u'%(name)s [%(process)d]:'
95
u' %(levelname)s:'
96
u' %(message)s'))
83
97
logger.addHandler(console)
84
98
85
99
class AvahiError(Exception):
98
112
99
113
class AvahiService(object):
100
114
"""An Avahi (Zeroconf) service.
115
101
116
Attributes:
102
117
interface: integer; avahi.IF_UNSPEC or an interface index.
103
118
Used to optionally bind to the specified interface.
104
name: string; Example: 'Mandos'
105
type: string; Example: '_mandos._tcp'.
119
name: string; Example: u'Mandos'
120
type: string; Example: u'_mandos._tcp'.
106
121
See <http://www.dns-sd.org/ServiceTypes.html>
107
122
port: integer; what port to announce
108
123
TXT: list of strings; TXT record for the service
111
126
max_renames: integer; maximum number of renames
112
127
rename_count: integer; counter so we only rename after collisions
113
128
a sensible number of times
129
group: D-Bus Entry Group
130
server: D-Bus Server
131
bus: dbus.SystemBus()
114
132
"""
115
133
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
116
134
servicetype = None, port = None, TXT = None,
117
domain = "", host = "", max_renames = 32768):
135
domain = u"", host = u"", max_renames = 32768,
136
protocol = avahi.PROTO_UNSPEC, bus = None):
118
137
self.interface = interface
119
138
self.name = name
120
139
self.type = servicetype
124
143
self.host = host
125
144
self.rename_count = 0
126
145
self.max_renames = max_renames
146
self.protocol = protocol
147
self.group = None # our entry group
148
self.server = None
149
self.bus = bus
127
150
def rename(self):
128
151
"""Derived from the Avahi example code"""
129
152
if self.rename_count >= self.max_renames:
131
154
u" after %i retries, exiting.",
132
155
self.rename_count)
133
156
raise AvahiServiceError(u"Too many renames")
134
self.name = server.GetAlternativeServiceName(self.name)
157
self.name = self.server.GetAlternativeServiceName(self.name)
135
158
logger.info(u"Changing Zeroconf service name to %r ...",
136
str(self.name))
159
unicode(self.name))
137
160
syslogger.setFormatter(logging.Formatter
138
('Mandos (%s): %%(levelname)s:'
139
' %%(message)s' % self.name))
161
(u'Mandos (%s) [%%(process)d]:'
162
u' %%(levelname)s: %%(message)s'
163
% self.name))
140
164
self.remove()
141
165
self.add()
142
166
self.rename_count += 1
143
167
def remove(self):
144
168
"""Derived from the Avahi example code"""
145
if group is not None:
146
group.Reset()
169
if self.group is not None:
170
self.group.Reset()
147
171
def add(self):
148
172
"""Derived from the Avahi example code"""
149
global group
150
if group is None:
151
group = dbus.Interface(bus.get_object
152
(avahi.DBUS_NAME,
153
server.EntryGroupNew()),
154
avahi.DBUS_INTERFACE_ENTRY_GROUP)
155
group.connect_to_signal('StateChanged',
156
entry_group_state_changed)
173
if self.group is None:
174
self.group = dbus.Interface(
175
self.bus.get_object(avahi.DBUS_NAME,
176
self.server.EntryGroupNew()),
177
avahi.DBUS_INTERFACE_ENTRY_GROUP)
178
self.group.connect_to_signal('StateChanged',
179
self
180
.entry_group_state_changed)
157
181
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
158
service.name, service.type)
159
group.AddService(
160
self.interface, # interface
161
avahi.PROTO_INET6, # protocol
162
dbus.UInt32(0), # flags
163
self.name, self.type,
164
self.domain, self.host,
165
dbus.UInt16(self.port),
166
avahi.string_array_to_txt_array(self.TXT))
167
group.Commit()
168
169
# From the Avahi example code:
170
group = None # our entry group
171
# End of Avahi example code
172
173
174
def _datetime_to_dbus(dt, variant_level=0):
175
"""Convert a UTC datetime.datetime() to a D-Bus type."""
176
return dbus.String(dt.isoformat(), variant_level=variant_level)
177
178
179
class Client(dbus.service.Object):
182
self.name, self.type)
183
self.group.AddService(
184
self.interface,
185
self.protocol,
186
dbus.UInt32(0), # flags
187
self.name, self.type,
188
self.domain, self.host,
189
dbus.UInt16(self.port),
190
avahi.string_array_to_txt_array(self.TXT))
191
self.group.Commit()
192
def entry_group_state_changed(self, state, error):
193
"""Derived from the Avahi example code"""
194
logger.debug(u"Avahi state change: %i", state)
195
196
if state == avahi.ENTRY_GROUP_ESTABLISHED:
197
logger.debug(u"Zeroconf service established.")
198
elif state == avahi.ENTRY_GROUP_COLLISION:
199
logger.warning(u"Zeroconf service name collision.")
200
self.rename()
201
elif state == avahi.ENTRY_GROUP_FAILURE:
202
logger.critical(u"Avahi: Error in group state changed %s",
203
unicode(error))
204
raise AvahiGroupError(u"State changed: %s"
205
% unicode(error))
206
def cleanup(self):
207
"""Derived from the Avahi example code"""
208
if self.group is not None:
209
self.group.Free()
210
self.group = None
211
def server_state_changed(self, state):
212
"""Derived from the Avahi example code"""
213
if state == avahi.SERVER_COLLISION:
214
logger.error(u"Zeroconf server name collision")
215
self.remove()
216
elif state == avahi.SERVER_RUNNING:
217
self.add()
218
def activate(self):
219
"""Derived from the Avahi example code"""
220
if self.server is None:
221
self.server = dbus.Interface(
222
self.bus.get_object(avahi.DBUS_NAME,
223
avahi.DBUS_PATH_SERVER),
224
avahi.DBUS_INTERFACE_SERVER)
225
self.server.connect_to_signal(u"StateChanged",
226
self.server_state_changed)
227
self.server_state_changed(self.server.GetState())
228
229
230
class Client(object):
180
231
"""A representation of a client host served by this server.
232
181
233
Attributes:
182
234
name: string; from the config file, used in log messages and
183
235
D-Bus identifiers
197
249
to see if the client lives.
198
250
'None' if no process is running.
199
251
checker_initiator_tag: a gobject event source tag, or None
200
disable_initiator_tag: - '' -
252
disable_initiator_tag: - '' -
201
253
checker_callback_tag: - '' -
202
254
checker_command: string; External command which is run to check if
203
255
client lives. %() expansions are done at
204
256
runtime with vars(self) as dict, so that for
205
257
instance %(name)s can be used in the command.
206
use_dbus: bool(); Whether to provide D-Bus interface and signals
207
dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus
258
current_checker_command: string; current running checker_command
208
259
"""
260
261
@staticmethod
262
def _timedelta_to_milliseconds(td):
263
"Convert a datetime.timedelta() to milliseconds"
264
return ((td.days * 24 * 60 * 60 * 1000)
265
+ (td.seconds * 1000)
266
+ (td.microseconds // 1000))
267
209
268
def timeout_milliseconds(self):
210
269
"Return the 'timeout' attribute in milliseconds"
211
return ((self.timeout.days * 24 * 60 * 60 * 1000)
212
+ (self.timeout.seconds * 1000)
213
+ (self.timeout.microseconds // 1000))
270
return self._timedelta_to_milliseconds(self.timeout)
214
271
215
272
def interval_milliseconds(self):
216
273
"Return the 'interval' attribute in milliseconds"
217
return ((self.interval.days * 24 * 60 * 60 * 1000)
218
+ (self.interval.seconds * 1000)
219
+ (self.interval.microseconds // 1000))
274
return self._timedelta_to_milliseconds(self.interval)
220
275
221
def __init__(self, name = None, disable_hook=None, config=None,
222
use_dbus=True):
276
def __init__(self, name = None, disable_hook=None, config=None):
223
277
"""Note: the 'checker' key in 'config' sets the
224
278
'checker_command' attribute and *not* the 'checker'
225
279
attribute."""
227
281
if config is None:
228
282
config = {}
229
283
logger.debug(u"Creating client %r", self.name)
230
self.use_dbus = False # During __init__
231
284
# Uppercase and remove spaces from fingerprint for later
232
285
# comparison purposes with return value from the fingerprint()
233
286
# function
234
self.fingerprint = (config["fingerprint"].upper()
287
self.fingerprint = (config[u"fingerprint"].upper()
235
288
.replace(u" ", u""))
236
289
logger.debug(u" Fingerprint: %s", self.fingerprint)
237
if "secret" in config:
238
self.secret = config["secret"].decode(u"base64")
239
elif "secfile" in config:
290
if u"secret" in config:
291
self.secret = config[u"secret"].decode(u"base64")
292
elif u"secfile" in config:
240
293
with closing(open(os.path.expanduser
241
294
(os.path.expandvars
242
(config["secfile"])))) as secfile:
295
(config[u"secfile"])))) as secfile:
243
296
self.secret = secfile.read()
244
297
else:
245
298
raise TypeError(u"No secret or secfile for client %s"
246
299
% self.name)
247
self.host = config.get("host", "")
300
self.host = config.get(u"host", u"")
248
301
self.created = datetime.datetime.utcnow()
249
302
self.enabled = False
250
303
self.last_enabled = None
251
304
self.last_checked_ok = None
252
self.timeout = string_to_delta(config["timeout"])
253
self.interval = string_to_delta(config["interval"])
305
self.timeout = string_to_delta(config[u"timeout"])
306
self.interval = string_to_delta(config[u"interval"])
254
307
self.disable_hook = disable_hook
255
308
self.checker = None
256
309
self.checker_initiator_tag = None
257
310
self.disable_initiator_tag = None
258
311
self.checker_callback_tag = None
259
self.checker_command = config["checker"]
312
self.checker_command = config[u"checker"]
313
self.current_checker_command = None
260
314
self.last_connect = None
261
# Only now, when this client is initialized, can it show up on
262
# the D-Bus
263
self.use_dbus = use_dbus
264
if self.use_dbus:
265
self.dbus_object_path = (dbus.ObjectPath
266
("/clients/"
267
+ self.name.replace(".", "_")))
268
dbus.service.Object.__init__(self, bus,
269
self.dbus_object_path)
270
315
271
316
def enable(self):
272
317
"""Start this client's checker and timeout hooks"""
318
if getattr(self, u"enabled", False):
319
# Already enabled
320
return
273
321
self.last_enabled = datetime.datetime.utcnow()
274
322
# Schedule a new checker to be started an 'interval' from now,
275
323
# and every interval from then on.
283
331
(self.timeout_milliseconds(),
284
332
self.disable))
285
333
self.enabled = True
286
if self.use_dbus:
287
# Emit D-Bus signals
288
self.PropertyChanged(dbus.String(u"enabled"),
289
dbus.Boolean(True, variant_level=1))
290
self.PropertyChanged(dbus.String(u"last_enabled"),
291
(_datetime_to_dbus(self.last_enabled,
292
variant_level=1)))
293
334
294
335
def disable(self):
295
336
"""Disable this client."""
296
337
if not getattr(self, "enabled", False):
297
338
return False
298
339
logger.info(u"Disabling client %s", self.name)
299
if getattr(self, "disable_initiator_tag", False):
340
if getattr(self, u"disable_initiator_tag", False):
300
341
gobject.source_remove(self.disable_initiator_tag)
301
342
self.disable_initiator_tag = None
302
if getattr(self, "checker_initiator_tag", False):
343
if getattr(self, u"checker_initiator_tag", False):
303
344
gobject.source_remove(self.checker_initiator_tag)
304
345
self.checker_initiator_tag = None
305
346
self.stop_checker()
306
347
if self.disable_hook:
307
348
self.disable_hook(self)
308
349
self.enabled = False
309
if self.use_dbus:
310
# Emit D-Bus signal
311
self.PropertyChanged(dbus.String(u"enabled"),
312
dbus.Boolean(False, variant_level=1))
313
350
# Do not run this again if called by a gobject.timeout_add
314
351
return False
315
352
321
358
"""The checker has completed, so take appropriate actions."""
322
359
self.checker_callback_tag = None
323
360
self.checker = None
324
if self.use_dbus:
325
# Emit D-Bus signal
326
self.PropertyChanged(dbus.String(u"checker_running"),
327
dbus.Boolean(False, variant_level=1))
328
361
if os.WIFEXITED(condition):
329
362
exitstatus = os.WEXITSTATUS(condition)
330
363
if exitstatus == 0:
334
367
else:
335
368
logger.info(u"Checker for %(name)s failed",
336
369
vars(self))
337
if self.use_dbus:
338
# Emit D-Bus signal
339
self.CheckerCompleted(dbus.Int16(exitstatus),
340
dbus.Int64(condition),
341
dbus.String(command))
342
370
else:
343
371
logger.warning(u"Checker for %(name)s crashed?",
344
372
vars(self))
345
if self.use_dbus:
346
# Emit D-Bus signal
347
self.CheckerCompleted(dbus.Int16(-1),
348
dbus.Int64(condition),
349
dbus.String(command))
350
373
351
374
def checked_ok(self):
352
375
"""Bump up the timeout for this client.
376
353
377
This should only be called when the client has been seen,
354
378
alive and well.
355
379
"""
358
382
self.disable_initiator_tag = (gobject.timeout_add
359
383
(self.timeout_milliseconds(),
360
384
self.disable))
361
if self.use_dbus:
362
# Emit D-Bus signal
363
self.PropertyChanged(
364
dbus.String(u"last_checked_ok"),
365
(_datetime_to_dbus(self.last_checked_ok,
366
variant_level=1)))
367
385
368
386
def start_checker(self):
369
387
"""Start a new checker subprocess if one is not running.
388
370
389
If a checker already exists, leave it running and do
371
390
nothing."""
372
391
# The reason for not killing a running checker is that if we
377
396
# checkers alone, the checker would have to take more time
378
397
# than 'timeout' for the client to be declared invalid, which
379
398
# is as it should be.
399
400
# If a checker exists, make sure it is not a zombie
401
if self.checker is not None:
402
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
403
if pid:
404
logger.warning(u"Checker was a zombie")
405
gobject.source_remove(self.checker_callback_tag)
406
self.checker_callback(pid, status,
407
self.current_checker_command)
408
# Start a new checker if needed
380
409
if self.checker is None:
381
410
try:
382
411
# In case checker_command has exactly one % operator
383
412
command = self.checker_command % self.host
384
413
except TypeError:
385
414
# Escape attributes for the shell
386
escaped_attrs = dict((key, re.escape(str(val)))
415
escaped_attrs = dict((key,
416
re.escape(unicode(str(val),
417
errors=
418
u'replace')))
387
419
for key, val in
388
420
vars(self).iteritems())
389
421
try:
392
424
logger.error(u'Could not format string "%s":'
393
425
u' %s', self.checker_command, error)
394
426
return True # Try again later
427
self.current_checker_command = command
395
428
try:
396
429
logger.info(u"Starting checker %r for %s",
397
430
command, self.name)
401
434
# always replaced by /dev/null.)
402
435
self.checker = subprocess.Popen(command,
403
436
close_fds=True,
404
shell=True, cwd="/")
405
if self.use_dbus:
406
# Emit D-Bus signal
407
self.CheckerStarted(command)
408
self.PropertyChanged(
409
dbus.String("checker_running"),
410
dbus.Boolean(True, variant_level=1))
437
shell=True, cwd=u"/")
411
438
self.checker_callback_tag = (gobject.child_watch_add
412
439
(self.checker.pid,
413
440
self.checker_callback,
414
441
data=command))
442
# The checker may have completed before the gobject
443
# watch was added. Check for this.
444
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
445
if pid:
446
gobject.source_remove(self.checker_callback_tag)
447
self.checker_callback(pid, status, command)
415
448
except OSError, error:
416
449
logger.error(u"Failed to start subprocess: %s",
417
450
error)
423
456
if self.checker_callback_tag:
424
457
gobject.source_remove(self.checker_callback_tag)
425
458
self.checker_callback_tag = None
426
if getattr(self, "checker", None) is None:
459
if getattr(self, u"checker", None) is None:
427
460
return
428
461
logger.debug(u"Stopping checker for %(name)s", vars(self))
429
462
try:
435
468
if error.errno != errno.ESRCH: # No such process
436
469
raise
437
470
self.checker = None
438
if self.use_dbus:
439
self.PropertyChanged(dbus.String(u"checker_running"),
440
dbus.Boolean(False, variant_level=1))
441
471
442
472
def still_valid(self):
443
473
"""Has the timeout not yet passed for this client?"""
444
if not getattr(self, "enabled", False):
474
if not getattr(self, u"enabled", False):
445
475
return False
446
476
now = datetime.datetime.utcnow()
447
477
if self.last_checked_ok is None:
448
478
return now < (self.created + self.timeout)
449
479
else:
450
480
return now < (self.last_checked_ok + self.timeout)
481
482
483
def dbus_service_property(dbus_interface, signature=u"v",
484
access=u"readwrite", byte_arrays=False):
485
"""Decorators for marking methods of a DBusObjectWithProperties to
486
become properties on the D-Bus.
487
488
The decorated method will be called with no arguments by "Get"
489
and with one argument by "Set".
490
491
The parameters, where they are supported, are the same as
492
dbus.service.method, except there is only "signature", since the
493
type from Get() and the type sent to Set() is the same.
494
"""
495
def decorator(func):
496
func._dbus_is_property = True
497
func._dbus_interface = dbus_interface
498
func._dbus_signature = signature
499
func._dbus_access = access
500
func._dbus_name = func.__name__
501
if func._dbus_name.endswith(u"_dbus_property"):
502
func._dbus_name = func._dbus_name[:-14]
503
func._dbus_get_args_options = {u'byte_arrays': byte_arrays }
504
return func
505
return decorator
506
507
508
class DBusPropertyException(dbus.exceptions.DBusException):
509
"""A base class for D-Bus property-related exceptions
510
"""
511
def __unicode__(self):
512
return unicode(str(self))
513
514
515
class DBusPropertyAccessException(DBusPropertyException):
516
"""A property's access permissions disallows an operation.
517
"""
518
pass
519
520
521
class DBusPropertyNotFound(DBusPropertyException):
522
"""An attempt was made to access a non-existing property.
523
"""
524
pass
525
526
527
class DBusObjectWithProperties(dbus.service.Object):
528
"""A D-Bus object with properties.
529
530
Classes inheriting from this can use the dbus_service_property
531
decorator to expose methods as D-Bus properties. It exposes the
532
standard Get(), Set(), and GetAll() methods on the D-Bus.
533
"""
534
535
@staticmethod
536
def _is_dbus_property(obj):
537
return getattr(obj, u"_dbus_is_property", False)
538
539
def _get_all_dbus_properties(self):
540
"""Returns a generator of (name, attribute) pairs
541
"""
542
return ((prop._dbus_name, prop)
543
for name, prop in
544
inspect.getmembers(self, self._is_dbus_property))
545
546
def _get_dbus_property(self, interface_name, property_name):
547
"""Returns a bound method if one exists which is a D-Bus
548
property with the specified name and interface.
549
"""
550
for name in (property_name,
551
property_name + u"_dbus_property"):
552
prop = getattr(self, name, None)
553
if (prop is None
554
or not self._is_dbus_property(prop)
555
or prop._dbus_name != property_name
556
or (interface_name and prop._dbus_interface
557
and interface_name != prop._dbus_interface)):
558
continue
559
return prop
560
# No such property
561
raise DBusPropertyNotFound(self.dbus_object_path + u":"
562
+ interface_name + u"."
563
+ property_name)
564
565
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
566
out_signature=u"v")
567
def Get(self, interface_name, property_name):
568
"""Standard D-Bus property Get() method, see D-Bus standard.
569
"""
570
prop = self._get_dbus_property(interface_name, property_name)
571
if prop._dbus_access == u"write":
572
raise DBusPropertyAccessException(property_name)
573
value = prop()
574
if not hasattr(value, u"variant_level"):
575
return value
576
return type(value)(value, variant_level=value.variant_level+1)
577
578
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
579
def Set(self, interface_name, property_name, value):
580
"""Standard D-Bus property Set() method, see D-Bus standard.
581
"""
582
prop = self._get_dbus_property(interface_name, property_name)
583
if prop._dbus_access == u"read":
584
raise DBusPropertyAccessException(property_name)
585
if prop._dbus_get_args_options[u"byte_arrays"]:
586
value = dbus.ByteArray(''.join(unichr(byte)
587
for byte in value))
588
prop(value)
589
590
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
591
out_signature=u"a{sv}")
592
def GetAll(self, interface_name):
593
"""Standard D-Bus property GetAll() method, see D-Bus
594
standard.
595
596
Note: Will not include properties with access="write".
597
"""
598
all = {}
599
for name, prop in self._get_all_dbus_properties():
600
if (interface_name
601
and interface_name != prop._dbus_interface):
602
# Interface non-empty but did not match
603
continue
604
# Ignore write-only properties
605
if prop._dbus_access == u"write":
606
continue
607
value = prop()
608
if not hasattr(value, u"variant_level"):
609
all[name] = value
610
continue
611
all[name] = type(value)(value, variant_level=
612
value.variant_level+1)
613
return dbus.Dictionary(all, signature=u"sv")
614
615
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
616
out_signature=u"s",
617
path_keyword='object_path',
618
connection_keyword='connection')
619
def Introspect(self, object_path, connection):
620
"""Standard D-Bus method, overloaded to insert property tags.
621
"""
622
xmlstring = dbus.service.Object.Introspect(self, object_path,
623
connection)
624
document = xml.dom.minidom.parseString(xmlstring)
625
del xmlstring
626
def make_tag(document, name, prop):
627
e = document.createElement(u"property")
628
e.setAttribute(u"name", name)
629
e.setAttribute(u"type", prop._dbus_signature)
630
e.setAttribute(u"access", prop._dbus_access)
631
return e
632
for if_tag in document.getElementsByTagName(u"interface"):
633
for tag in (make_tag(document, name, prop)
634
for name, prop
635
in self._get_all_dbus_properties()
636
if prop._dbus_interface
637
== if_tag.getAttribute(u"name")):
638
if_tag.appendChild(tag)
639
xmlstring = document.toxml(u"utf-8")
640
document.unlink()
641
return xmlstring
642
643
644
class ClientDBus(Client, DBusObjectWithProperties):
645
"""A Client class using D-Bus
646
647
Attributes:
648
dbus_object_path: dbus.ObjectPath
649
bus: dbus.SystemBus()
650
"""
651
# dbus.service.Object doesn't use super(), so we can't either.
652
653
def __init__(self, bus = None, *args, **kwargs):
654
self.bus = bus
655
Client.__init__(self, *args, **kwargs)
656
# Only now, when this client is initialized, can it show up on
657
# the D-Bus
658
self.dbus_object_path = (dbus.ObjectPath
659
(u"/clients/"
660
+ self.name.replace(u".", u"_")))
661
DBusObjectWithProperties.__init__(self, self.bus,
662
self.dbus_object_path)
663
664
@staticmethod
665
def _datetime_to_dbus(dt, variant_level=0):
666
"""Convert a UTC datetime.datetime() to a D-Bus type."""
667
return dbus.String(dt.isoformat(),
668
variant_level=variant_level)
669
670
def enable(self):
671
oldstate = getattr(self, u"enabled", False)
672
r = Client.enable(self)
673
if oldstate != self.enabled:
674
# Emit D-Bus signals
675
self.PropertyChanged(dbus.String(u"enabled"),
676
dbus.Boolean(True, variant_level=1))
677
self.PropertyChanged(
678
dbus.String(u"last_enabled"),
679
self._datetime_to_dbus(self.last_enabled,
680
variant_level=1))
681
return r
682
683
def disable(self, signal = True):
684
oldstate = getattr(self, u"enabled", False)
685
r = Client.disable(self)
686
if signal and oldstate != self.enabled:
687
# Emit D-Bus signal
688
self.PropertyChanged(dbus.String(u"enabled"),
689
dbus.Boolean(False, variant_level=1))
690
return r
691
692
def __del__(self, *args, **kwargs):
693
try:
694
self.remove_from_connection()
695
except LookupError:
696
pass
697
if hasattr(DBusObjectWithProperties, u"__del__"):
698
DBusObjectWithProperties.__del__(self, *args, **kwargs)
699
Client.__del__(self, *args, **kwargs)
700
701
def checker_callback(self, pid, condition, command,
702
*args, **kwargs):
703
self.checker_callback_tag = None
704
self.checker = None
705
# Emit D-Bus signal
706
self.PropertyChanged(dbus.String(u"checker_running"),
707
dbus.Boolean(False, variant_level=1))
708
if os.WIFEXITED(condition):
709
exitstatus = os.WEXITSTATUS(condition)
710
# Emit D-Bus signal
711
self.CheckerCompleted(dbus.Int16(exitstatus),
712
dbus.Int64(condition),
713
dbus.String(command))
714
else:
715
# Emit D-Bus signal
716
self.CheckerCompleted(dbus.Int16(-1),
717
dbus.Int64(condition),
718
dbus.String(command))
719
720
return Client.checker_callback(self, pid, condition, command,
721
*args, **kwargs)
722
723
def checked_ok(self, *args, **kwargs):
724
r = Client.checked_ok(self, *args, **kwargs)
725
# Emit D-Bus signal
726
self.PropertyChanged(
727
dbus.String(u"last_checked_ok"),
728
(self._datetime_to_dbus(self.last_checked_ok,
729
variant_level=1)))
730
return r
731
732
def start_checker(self, *args, **kwargs):
733
old_checker = self.checker
734
if self.checker is not None:
735
old_checker_pid = self.checker.pid
736
else:
737
old_checker_pid = None
738
r = Client.start_checker(self, *args, **kwargs)
739
# Only if new checker process was started
740
if (self.checker is not None
741
and old_checker_pid != self.checker.pid):
742
# Emit D-Bus signal
743
self.CheckerStarted(self.current_checker_command)
744
self.PropertyChanged(
745
dbus.String(u"checker_running"),
746
dbus.Boolean(True, variant_level=1))
747
return r
748
749
def stop_checker(self, *args, **kwargs):
750
old_checker = getattr(self, u"checker", None)
751
r = Client.stop_checker(self, *args, **kwargs)
752
if (old_checker is not None
753
and getattr(self, u"checker", None) is None):
754
self.PropertyChanged(dbus.String(u"checker_running"),
755
dbus.Boolean(False, variant_level=1))
756
return r
451
757
452
758
## D-Bus methods & signals
453
759
_interface = u"se.bsnet.fukt.Mandos.Client"
454
760
455
# CheckedOK - method
456
CheckedOK = dbus.service.method(_interface)(checked_ok)
457
CheckedOK.__name__ = "CheckedOK"
458
459
761
# CheckerCompleted - signal
460
@dbus.service.signal(_interface, signature="nxs")
762
@dbus.service.signal(_interface, signature=u"nxs")
461
763
def CheckerCompleted(self, exitcode, waitstatus, command):
462
764
"D-Bus signal"
463
765
pass
464
766
465
767
# CheckerStarted - signal
466
@dbus.service.signal(_interface, signature="s")
768
@dbus.service.signal(_interface, signature=u"s")
467
769
def CheckerStarted(self, command):
468
770
"D-Bus signal"
469
771
pass
470
772
471
# GetAllProperties - method
472
@dbus.service.method(_interface, out_signature="a{sv}")
473
def GetAllProperties(self):
474
"D-Bus method"
475
return dbus.Dictionary({
476
dbus.String("name"):
477
dbus.String(self.name, variant_level=1),
478
dbus.String("fingerprint"):
479
dbus.String(self.fingerprint, variant_level=1),
480
dbus.String("host"):
481
dbus.String(self.host, variant_level=1),
482
dbus.String("created"):
483
_datetime_to_dbus(self.created, variant_level=1),
484
dbus.String("last_enabled"):
485
(_datetime_to_dbus(self.last_enabled,
486
variant_level=1)
487
if self.last_enabled is not None
488
else dbus.Boolean(False, variant_level=1)),
489
dbus.String("enabled"):
490
dbus.Boolean(self.enabled, variant_level=1),
491
dbus.String("last_checked_ok"):
492
(_datetime_to_dbus(self.last_checked_ok,
493
variant_level=1)
494
if self.last_checked_ok is not None
495
else dbus.Boolean (False, variant_level=1)),
496
dbus.String("timeout"):
497
dbus.UInt64(self.timeout_milliseconds(),
498
variant_level=1),
499
dbus.String("interval"):
500
dbus.UInt64(self.interval_milliseconds(),
501
variant_level=1),
502
dbus.String("checker"):
503
dbus.String(self.checker_command,
504
variant_level=1),
505
dbus.String("checker_running"):
506
dbus.Boolean(self.checker is not None,
507
variant_level=1),
508
dbus.String("object_path"):
509
dbus.ObjectPath(self.dbus_object_path,
510
variant_level=1)
511
}, signature="sv")
512
513
# IsStillValid - method
514
IsStillValid = (dbus.service.method(_interface, out_signature="b")
515
(still_valid))
516
IsStillValid.__name__ = "IsStillValid"
517
518
773
# PropertyChanged - signal
519
@dbus.service.signal(_interface, signature="sv")
774
@dbus.service.signal(_interface, signature=u"sv")
520
775
def PropertyChanged(self, property, value):
521
776
"D-Bus signal"
522
777
pass
523
778
524
# SetChecker - method
525
@dbus.service.method(_interface, in_signature="s")
526
def SetChecker(self, checker):
527
"D-Bus setter method"
528
self.checker_command = checker
779
# ReceivedSecret - signal
780
@dbus.service.signal(_interface)
781
def ReceivedSecret(self):
782
"D-Bus signal"
783
pass
784
785
# Rejected - signal
786
@dbus.service.signal(_interface)
787
def Rejected(self):
788
"D-Bus signal"
789
pass
790
791
# name - property
792
@dbus_service_property(_interface, signature=u"s", access=u"read")
793
def name_dbus_property(self):
794
return dbus.String(self.name)
795
796
# fingerprint - property
797
@dbus_service_property(_interface, signature=u"s", access=u"read")
798
def fingerprint_dbus_property(self):
799
return dbus.String(self.fingerprint)
800
801
# host - property
802
@dbus_service_property(_interface, signature=u"s",
803
access=u"readwrite")
804
def host_dbus_property(self, value=None):
805
if value is None: # get
806
return dbus.String(self.host)
807
self.host = value
808
# Emit D-Bus signal
809
self.PropertyChanged(dbus.String(u"host"),
810
dbus.String(value, variant_level=1))
811
812
# created - property
813
@dbus_service_property(_interface, signature=u"s", access=u"read")
814
def created_dbus_property(self):
815
return dbus.String(self._datetime_to_dbus(self.created))
816
817
# last_enabled - property
818
@dbus_service_property(_interface, signature=u"s", access=u"read")
819
def last_enabled_dbus_property(self):
820
if self.last_enabled is None:
821
return dbus.String(u"")
822
return dbus.String(self._datetime_to_dbus(self.last_enabled))
823
824
# enabled - property
825
@dbus_service_property(_interface, signature=u"b",
826
access=u"readwrite")
827
def enabled_dbus_property(self, value=None):
828
if value is None: # get
829
return dbus.Boolean(self.enabled)
830
if value:
831
self.enable()
832
else:
833
self.disable()
834
835
# last_checked_ok - property
836
@dbus_service_property(_interface, signature=u"s", access=u"read")
837
def last_checked_ok_dbus_property(self):
838
if self.last_checked_ok is None:
839
return dbus.String(u"")
840
return dbus.String(self._datetime_to_dbus(self
841
.last_checked_ok))
842
843
# timeout - property
844
@dbus_service_property(_interface, signature=u"t",
845
access=u"readwrite")
846
def timeout_dbus_property(self, value=None):
847
if value is None: # get
848
return dbus.UInt64(self.timeout_milliseconds())
849
self.timeout = datetime.timedelta(0, 0, 0, value)
850
# Emit D-Bus signal
851
self.PropertyChanged(dbus.String(u"timeout"),
852
dbus.UInt64(value, variant_level=1))
853
if getattr(self, u"disable_initiator_tag", None) is None:
854
return
855
# Reschedule timeout
856
gobject.source_remove(self.disable_initiator_tag)
857
self.disable_initiator_tag = None
858
time_to_die = (self.
859
_timedelta_to_milliseconds((self
860
.last_checked_ok
861
+ self.timeout)
862
- datetime.datetime
863
.utcnow()))
864
if time_to_die <= 0:
865
# The timeout has passed
866
self.disable()
867
else:
868
self.disable_initiator_tag = (gobject.timeout_add
869
(time_to_die, self.disable))
870
871
# interval - property
872
@dbus_service_property(_interface, signature=u"t",
873
access=u"readwrite")
874
def interval_dbus_property(self, value=None):
875
if value is None: # get
876
return dbus.UInt64(self.interval_milliseconds())
877
self.interval = datetime.timedelta(0, 0, 0, value)
878
# Emit D-Bus signal
879
self.PropertyChanged(dbus.String(u"interval"),
880
dbus.UInt64(value, variant_level=1))
881
if getattr(self, u"checker_initiator_tag", None) is None:
882
return
883
# Reschedule checker run
884
gobject.source_remove(self.checker_initiator_tag)
885
self.checker_initiator_tag = (gobject.timeout_add
886
(value, self.start_checker))
887
self.start_checker() # Start one now, too
888
889
# checker - property
890
@dbus_service_property(_interface, signature=u"s",
891
access=u"readwrite")
892
def checker_dbus_property(self, value=None):
893
if value is None: # get
894
return dbus.String(self.checker_command)
895
self.checker_command = value
529
896
# Emit D-Bus signal
530
897
self.PropertyChanged(dbus.String(u"checker"),
531
898
dbus.String(self.checker_command,
532
899
variant_level=1))
533
900
534
# SetHost - method
535
@dbus.service.method(_interface, in_signature="s")
536
def SetHost(self, host):
537
"D-Bus setter method"
538
self.host = host
539
# Emit D-Bus signal
540
self.PropertyChanged(dbus.String(u"host"),
541
dbus.String(self.host, variant_level=1))
542
543
# SetInterval - method
544
@dbus.service.method(_interface, in_signature="t")
545
def SetInterval(self, milliseconds):
546
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
547
# Emit D-Bus signal
548
self.PropertyChanged(dbus.String(u"interval"),
549
(dbus.UInt64(self.interval_milliseconds(),
550
variant_level=1)))
551
552
# SetSecret - method
553
@dbus.service.method(_interface, in_signature="ay",
554
byte_arrays=True)
555
def SetSecret(self, secret):
556
"D-Bus setter method"
557
self.secret = str(secret)
558
559
# SetTimeout - method
560
@dbus.service.method(_interface, in_signature="t")
561
def SetTimeout(self, milliseconds):
562
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
563
# Emit D-Bus signal
564
self.PropertyChanged(dbus.String(u"timeout"),
565
(dbus.UInt64(self.timeout_milliseconds(),
566
variant_level=1)))
567
568
# Enable - method
569
Enable = dbus.service.method(_interface)(enable)
570
Enable.__name__ = "Enable"
571
572
# StartChecker - method
573
@dbus.service.method(_interface)
574
def StartChecker(self):
575
"D-Bus method"
576
self.start_checker()
577
578
# Disable - method
579
@dbus.service.method(_interface)
580
def Disable(self):
581
"D-Bus method"
582
self.disable()
583
584
# StopChecker - method
585
StopChecker = dbus.service.method(_interface)(stop_checker)
586
StopChecker.__name__ = "StopChecker"
901
# checker_running - property
902
@dbus_service_property(_interface, signature=u"b",
903
access=u"readwrite")
904
def checker_running_dbus_property(self, value=None):
905
if value is None: # get
906
return dbus.Boolean(self.checker is not None)
907
if value:
908
self.start_checker()
909
else:
910
self.stop_checker()
911
912
# object_path - property
913
@dbus_service_property(_interface, signature=u"o", access=u"read")
914
def object_path_dbus_property(self):
915
return self.dbus_object_path # is already a dbus.ObjectPath
916
917
# secret = property xxx
918
@dbus_service_property(_interface, signature=u"ay",
919
access=u"write", byte_arrays=True)
920
def secret_dbus_property(self, value):
921
self.secret = str(value)
587
922
588
923
del _interface
589
924
590
925
591
def peer_certificate(session):
592
"Return the peer's OpenPGP certificate as a bytestring"
593
# If not an OpenPGP certificate...
594
if (gnutls.library.functions
595
.gnutls_certificate_type_get(session._c_object)
596
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
597
# ...do the normal thing
598
return session.peer_certificate
599
list_size = ctypes.c_uint(1)
600
cert_list = (gnutls.library.functions
601
.gnutls_certificate_get_peers
602
(session._c_object, ctypes.byref(list_size)))
603
if not bool(cert_list) and list_size.value != 0:
604
raise gnutls.errors.GNUTLSError("error getting peer"
605
" certificate")
606
if list_size.value == 0:
607
return None
608
cert = cert_list[0]
609
return ctypes.string_at(cert.data, cert.size)
610
611
612
def fingerprint(openpgp):
613
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
614
# New GnuTLS "datum" with the OpenPGP public key
615
datum = (gnutls.library.types
616
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
617
ctypes.POINTER
618
(ctypes.c_ubyte)),
619
ctypes.c_uint(len(openpgp))))
620
# New empty GnuTLS certificate
621
crt = gnutls.library.types.gnutls_openpgp_crt_t()
622
(gnutls.library.functions
623
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
624
# Import the OpenPGP public key into the certificate
625
(gnutls.library.functions
626
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
627
gnutls.library.constants
628
.GNUTLS_OPENPGP_FMT_RAW))
629
# Verify the self signature in the key
630
crtverify = ctypes.c_uint()
631
(gnutls.library.functions
632
.gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
633
if crtverify.value != 0:
634
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
635
raise gnutls.errors.CertificateSecurityError("Verify failed")
636
# New buffer for the fingerprint
637
buf = ctypes.create_string_buffer(20)
638
buf_len = ctypes.c_size_t()
639
# Get the fingerprint from the certificate into the buffer
640
(gnutls.library.functions
641
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
642
ctypes.byref(buf_len)))
643
# Deinit the certificate
644
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
645
# Convert the buffer to a Python bytestring
646
fpr = ctypes.string_at(buf, buf_len.value)
647
# Convert the bytestring to hexadecimal notation
648
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
649
return hex_fpr
650
651
652
class TCP_handler(SocketServer.BaseRequestHandler, object):
653
"""A TCP request handler class.
654
Instantiated by IPv6_TCPServer for each request to handle it.
926
class ClientHandler(socketserver.BaseRequestHandler, object):
927
"""A class to handle client connections.
928
929
Instantiated once for each connection to handle it.
655
930
Note: This will run in its own forked process."""
656
931
657
932
def handle(self):
658
933
logger.info(u"TCP connection from: %s",
659
934
unicode(self.client_address))
660
session = (gnutls.connection
661
.ClientSession(self.request,
662
gnutls.connection
663
.X509Credentials()))
664
665
line = self.request.makefile().readline()
666
logger.debug(u"Protocol version: %r", line)
667
try:
668
if int(line.strip().split()[0]) > 1:
669
raise RuntimeError
670
except (ValueError, IndexError, RuntimeError), error:
671
logger.error(u"Unknown protocol version: %s", error)
672
return
673
674
# Note: gnutls.connection.X509Credentials is really a generic
675
# GnuTLS certificate credentials object so long as no X.509
676
# keys are added to it. Therefore, we can use it here despite
677
# using OpenPGP certificates.
678
679
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
680
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
681
# "+DHE-DSS"))
682
# Use a fallback default, since this MUST be set.
683
priority = self.server.settings.get("priority", "NORMAL")
684
(gnutls.library.functions
685
.gnutls_priority_set_direct(session._c_object,
686
priority, None))
687
688
try:
689
session.handshake()
690
except gnutls.errors.GNUTLSError, error:
691
logger.warning(u"Handshake failed: %s", error)
692
# Do not run session.bye() here: the session is not
693
# established. Just abandon the request.
694
return
695
logger.debug(u"Handshake succeeded")
696
try:
697
fpr = fingerprint(peer_certificate(session))
698
except (TypeError, gnutls.errors.GNUTLSError), error:
699
logger.warning(u"Bad certificate: %s", error)
700
session.bye()
701
return
702
logger.debug(u"Fingerprint: %s", fpr)
703
704
for c in self.server.clients:
705
if c.fingerprint == fpr:
706
client = c
707
break
708
else:
709
logger.warning(u"Client not found for fingerprint: %s",
710
fpr)
711
session.bye()
712
return
713
# Have to check if client.still_valid(), since it is possible
714
# that the client timed out while establishing the GnuTLS
715
# session.
716
if not client.still_valid():
717
logger.warning(u"Client %(name)s is invalid",
718
vars(client))
719
session.bye()
720
return
721
## This won't work here, since we're in a fork.
722
# client.checked_ok()
723
sent_size = 0
724
while sent_size < len(client.secret):
725
sent = session.send(client.secret[sent_size:])
726
logger.debug(u"Sent: %d, remaining: %d",
727
sent, len(client.secret)
728
- (sent_size + sent))
729
sent_size += sent
730
session.bye()
731
732
733
class IPv6_TCPServer(SocketServer.ForkingMixIn,
734
SocketServer.TCPServer, object):
735
"""IPv6 TCP server. Accepts 'None' as address and/or port.
935
logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])
936
# Open IPC pipe to parent process
937
with closing(os.fdopen(self.server.pipe[1], u"w", 1)) as ipc:
938
session = (gnutls.connection
939
.ClientSession(self.request,
940
gnutls.connection
941
.X509Credentials()))
942
943
line = self.request.makefile().readline()
944
logger.debug(u"Protocol version: %r", line)
945
try:
946
if int(line.strip().split()[0]) > 1:
947
raise RuntimeError
948
except (ValueError, IndexError, RuntimeError), error:
949
logger.error(u"Unknown protocol version: %s", error)
950
return
951
952
# Note: gnutls.connection.X509Credentials is really a
953
# generic GnuTLS certificate credentials object so long as
954
# no X.509 keys are added to it. Therefore, we can use it
955
# here despite using OpenPGP certificates.
956
957
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
958
# u"+AES-256-CBC", u"+SHA1",
959
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
960
# u"+DHE-DSS"))
961
# Use a fallback default, since this MUST be set.
962
priority = self.server.gnutls_priority
963
if priority is None:
964
priority = u"NORMAL"
965
(gnutls.library.functions
966
.gnutls_priority_set_direct(session._c_object,
967
priority, None))
968
969
try:
970
session.handshake()
971
except gnutls.errors.GNUTLSError, error:
972
logger.warning(u"Handshake failed: %s", error)
973
# Do not run session.bye() here: the session is not
974
# established. Just abandon the request.
975
return
976
logger.debug(u"Handshake succeeded")
977
try:
978
fpr = self.fingerprint(self.peer_certificate(session))
979
except (TypeError, gnutls.errors.GNUTLSError), error:
980
logger.warning(u"Bad certificate: %s", error)
981
session.bye()
982
return
983
logger.debug(u"Fingerprint: %s", fpr)
984
985
for c in self.server.clients:
986
if c.fingerprint == fpr:
987
client = c
988
break
989
else:
990
ipc.write(u"NOTFOUND %s %s\n"
991
% (fpr, unicode(self.client_address)))
992
session.bye()
993
return
994
# Have to check if client.still_valid(), since it is
995
# possible that the client timed out while establishing
996
# the GnuTLS session.
997
if not client.still_valid():
998
ipc.write(u"INVALID %s\n" % client.name)
999
session.bye()
1000
return
1001
ipc.write(u"SENDING %s\n" % client.name)
1002
sent_size = 0
1003
while sent_size < len(client.secret):
1004
sent = session.send(client.secret[sent_size:])
1005
logger.debug(u"Sent: %d, remaining: %d",
1006
sent, len(client.secret)
1007
- (sent_size + sent))
1008
sent_size += sent
1009
session.bye()
1010
1011
@staticmethod
1012
def peer_certificate(session):
1013
"Return the peer's OpenPGP certificate as a bytestring"
1014
# If not an OpenPGP certificate...
1015
if (gnutls.library.functions
1016
.gnutls_certificate_type_get(session._c_object)
1017
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1018
# ...do the normal thing
1019
return session.peer_certificate
1020
list_size = ctypes.c_uint(1)
1021
cert_list = (gnutls.library.functions
1022
.gnutls_certificate_get_peers
1023
(session._c_object, ctypes.byref(list_size)))
1024
if not bool(cert_list) and list_size.value != 0:
1025
raise gnutls.errors.GNUTLSError(u"error getting peer"
1026
u" certificate")
1027
if list_size.value == 0:
1028
return None
1029
cert = cert_list[0]
1030
return ctypes.string_at(cert.data, cert.size)
1031
1032
@staticmethod
1033
def fingerprint(openpgp):
1034
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1035
# New GnuTLS "datum" with the OpenPGP public key
1036
datum = (gnutls.library.types
1037
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1038
ctypes.POINTER
1039
(ctypes.c_ubyte)),
1040
ctypes.c_uint(len(openpgp))))
1041
# New empty GnuTLS certificate
1042
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1043
(gnutls.library.functions
1044
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1045
# Import the OpenPGP public key into the certificate
1046
(gnutls.library.functions
1047
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1048
gnutls.library.constants
1049
.GNUTLS_OPENPGP_FMT_RAW))
1050
# Verify the self signature in the key
1051
crtverify = ctypes.c_uint()
1052
(gnutls.library.functions
1053
.gnutls_openpgp_crt_verify_self(crt, 0,
1054
ctypes.byref(crtverify)))
1055
if crtverify.value != 0:
1056
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1057
raise (gnutls.errors.CertificateSecurityError
1058
(u"Verify failed"))
1059
# New buffer for the fingerprint
1060
buf = ctypes.create_string_buffer(20)
1061
buf_len = ctypes.c_size_t()
1062
# Get the fingerprint from the certificate into the buffer
1063
(gnutls.library.functions
1064
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1065
ctypes.byref(buf_len)))
1066
# Deinit the certificate
1067
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1068
# Convert the buffer to a Python bytestring
1069
fpr = ctypes.string_at(buf, buf_len.value)
1070
# Convert the bytestring to hexadecimal notation
1071
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
1072
return hex_fpr
1073
1074
1075
class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):
1076
"""Like socketserver.ForkingMixIn, but also pass a pipe."""
1077
def process_request(self, request, client_address):
1078
"""Overrides and wraps the original process_request().
1079
1080
This function creates a new pipe in self.pipe
1081
"""
1082
self.pipe = os.pipe()
1083
super(ForkingMixInWithPipe,
1084
self).process_request(request, client_address)
1085
os.close(self.pipe[1]) # close write end
1086
self.add_pipe(self.pipe[0])
1087
def add_pipe(self, pipe):
1088
"""Dummy function; override as necessary"""
1089
os.close(pipe)
1090
1091
1092
class IPv6_TCPServer(ForkingMixInWithPipe,
1093
socketserver.TCPServer, object):
1094
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
1095
736
1096
Attributes:
737
settings: Server settings
738
clients: Set() of Client objects
739
1097
enabled: Boolean; whether this server is activated yet
1098
interface: None or a network interface name (string)
1099
use_ipv6: Boolean; to use IPv6 or not
740
1100
"""
741
address_family = socket.AF_INET6
742
def __init__(self, *args, **kwargs):
743
if "settings" in kwargs:
744
self.settings = kwargs["settings"]
745
del kwargs["settings"]
746
if "clients" in kwargs:
747
self.clients = kwargs["clients"]
748
del kwargs["clients"]
749
self.enabled = False
750
super(IPv6_TCPServer, self).__init__(*args, **kwargs)
1101
def __init__(self, server_address, RequestHandlerClass,
1102
interface=None, use_ipv6=True):
1103
self.interface = interface
1104
if use_ipv6:
1105
self.address_family = socket.AF_INET6
1106
socketserver.TCPServer.__init__(self, server_address,
1107
RequestHandlerClass)
751
1108
def server_bind(self):
752
1109
"""This overrides the normal server_bind() function
753
1110
to bind to an interface if one was specified, and also NOT to
754
1111
bind to an address or port if they were not specified."""
755
if self.settings["interface"]:
756
# 25 is from /usr/include/asm-i486/socket.h
757
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
758
try:
759
self.socket.setsockopt(socket.SOL_SOCKET,
760
SO_BINDTODEVICE,
761
self.settings["interface"])
762
except socket.error, error:
763
if error[0] == errno.EPERM:
764
logger.error(u"No permission to"
765
u" bind to interface %s",
766
self.settings["interface"])
767
else:
768
raise
1112
if self.interface is not None:
1113
if SO_BINDTODEVICE is None:
1114
logger.error(u"SO_BINDTODEVICE does not exist;"
1115
u" cannot bind to interface %s",
1116
self.interface)
1117
else:
1118
try:
1119
self.socket.setsockopt(socket.SOL_SOCKET,
1120
SO_BINDTODEVICE,
1121
str(self.interface
1122
+ u'\0'))
1123
except socket.error, error:
1124
if error[0] == errno.EPERM:
1125
logger.error(u"No permission to"
1126
u" bind to interface %s",
1127
self.interface)
1128
elif error[0] == errno.ENOPROTOOPT:
1129
logger.error(u"SO_BINDTODEVICE not available;"
1130
u" cannot bind to interface %s",
1131
self.interface)
1132
else:
1133
raise
769
1134
# Only bind(2) the socket if we really need to.
770
1135
if self.server_address[0] or self.server_address[1]:
771
1136
if not self.server_address[0]:
772
in6addr_any = "::"
773
self.server_address = (in6addr_any,
1137
if self.address_family == socket.AF_INET6:
1138
any_address = u"::" # in6addr_any
1139
else:
1140
any_address = socket.INADDR_ANY
1141
self.server_address = (any_address,
774
1142
self.server_address[1])
775
1143
elif not self.server_address[1]:
776
1144
self.server_address = (self.server_address[0],
777
1145
0)
778
# if self.settings["interface"]:
1146
# if self.interface:
779
1147
# self.server_address = (self.server_address[0],
780
1148
# 0, # port
781
1149
# 0, # flowinfo
782
1150
# if_nametoindex
783
# (self.settings
784
# ["interface"]))
785
return super(IPv6_TCPServer, self).server_bind()
1151
# (self.interface))
1152
return socketserver.TCPServer.server_bind(self)
1153
1154
1155
class MandosServer(IPv6_TCPServer):
1156
"""Mandos server.
1157
1158
Attributes:
1159
clients: set of Client objects
1160
gnutls_priority GnuTLS priority string
1161
use_dbus: Boolean; to emit D-Bus signals or not
1162
1163
Assumes a gobject.MainLoop event loop.
1164
"""
1165
def __init__(self, server_address, RequestHandlerClass,
1166
interface=None, use_ipv6=True, clients=None,
1167
gnutls_priority=None, use_dbus=True):
1168
self.enabled = False
1169
self.clients = clients
1170
if self.clients is None:
1171
self.clients = set()
1172
self.use_dbus = use_dbus
1173
self.gnutls_priority = gnutls_priority
1174
IPv6_TCPServer.__init__(self, server_address,
1175
RequestHandlerClass,
1176
interface = interface,
1177
use_ipv6 = use_ipv6)
786
1178
def server_activate(self):
787
1179
if self.enabled:
788
return super(IPv6_TCPServer, self).server_activate()
1180
return socketserver.TCPServer.server_activate(self)
789
1181
def enable(self):
790
1182
self.enabled = True
1183
def add_pipe(self, pipe):
1184
# Call "handle_ipc" for both data and EOF events
1185
gobject.io_add_watch(pipe, gobject.IO_IN | gobject.IO_HUP,
1186
self.handle_ipc)
1187
def handle_ipc(self, source, condition, file_objects={}):
1188
condition_names = {
1189
gobject.IO_IN: u"IN", # There is data to read.
1190
gobject.IO_OUT: u"OUT", # Data can be written (without
1191
# blocking).
1192
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1193
gobject.IO_ERR: u"ERR", # Error condition.
1194
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1195
# broken, usually for pipes and
1196
# sockets).
1197
}
1198
conditions_string = ' | '.join(name
1199
for cond, name in
1200
condition_names.iteritems()
1201
if cond & condition)
1202
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1203
conditions_string)
1204
1205
# Turn the pipe file descriptor into a Python file object
1206
if source not in file_objects:
1207
file_objects[source] = os.fdopen(source, u"r", 1)
1208
1209
# Read a line from the file object
1210
cmdline = file_objects[source].readline()
1211
if not cmdline: # Empty line means end of file
1212
# close the IPC pipe
1213
file_objects[source].close()
1214
del file_objects[source]
1215
1216
# Stop calling this function
1217
return False
1218
1219
logger.debug(u"IPC command: %r", cmdline)
1220
1221
# Parse and act on command
1222
cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)
1223
1224
if cmd == u"NOTFOUND":
1225
logger.warning(u"Client not found for fingerprint: %s",
1226
args)
1227
if self.use_dbus:
1228
# Emit D-Bus signal
1229
mandos_dbus_service.ClientNotFound(args)
1230
elif cmd == u"INVALID":
1231
for client in self.clients:
1232
if client.name == args:
1233
logger.warning(u"Client %s is invalid", args)
1234
if self.use_dbus:
1235
# Emit D-Bus signal
1236
client.Rejected()
1237
break
1238
else:
1239
logger.error(u"Unknown client %s is invalid", args)
1240
elif cmd == u"SENDING":
1241
for client in self.clients:
1242
if client.name == args:
1243
logger.info(u"Sending secret to %s", client.name)
1244
client.checked_ok()
1245
if self.use_dbus:
1246
# Emit D-Bus signal
1247
client.ReceivedSecret()
1248
break
1249
else:
1250
logger.error(u"Sending secret to unknown client %s",
1251
args)
1252
else:
1253
logger.error(u"Unknown IPC command: %r", cmdline)
1254
1255
# Keep calling this function
1256
return True
791
1257
792
1258
793
1259
def string_to_delta(interval):
794
1260
"""Parse a string and return a datetime.timedelta
795
1261
796
>>> string_to_delta('7d')
1262
>>> string_to_delta(u'7d')
797
1263
datetime.timedelta(7)
798
>>> string_to_delta('60s')
1264
>>> string_to_delta(u'60s')
799
1265
datetime.timedelta(0, 60)
800
>>> string_to_delta('60m')
1266
>>> string_to_delta(u'60m')
801
1267
datetime.timedelta(0, 3600)
802
>>> string_to_delta('24h')
1268
>>> string_to_delta(u'24h')
803
1269
datetime.timedelta(1)
804
1270
>>> string_to_delta(u'1w')
805
1271
datetime.timedelta(7)
806
>>> string_to_delta('5m 30s')
1272
>>> string_to_delta(u'5m 30s')
807
1273
datetime.timedelta(0, 330)
808
1274
"""
809
1275
timevalue = datetime.timedelta(0)
829
1295
return timevalue
830
1296
831
1297
832
def server_state_changed(state):
833
"""Derived from the Avahi example code"""
834
if state == avahi.SERVER_COLLISION:
835
logger.error(u"Zeroconf server name collision")
836
service.remove()
837
elif state == avahi.SERVER_RUNNING:
838
service.add()
839
840
841
def entry_group_state_changed(state, error):
842
"""Derived from the Avahi example code"""
843
logger.debug(u"Avahi state change: %i", state)
844
845
if state == avahi.ENTRY_GROUP_ESTABLISHED:
846
logger.debug(u"Zeroconf service established.")
847
elif state == avahi.ENTRY_GROUP_COLLISION:
848
logger.warning(u"Zeroconf service name collision.")
849
service.rename()
850
elif state == avahi.ENTRY_GROUP_FAILURE:
851
logger.critical(u"Avahi: Error in group state changed %s",
852
unicode(error))
853
raise AvahiGroupError(u"State changed: %s" % unicode(error))
854
855
1298
def if_nametoindex(interface):
856
"""Call the C function if_nametoindex(), or equivalent"""
1299
"""Call the C function if_nametoindex(), or equivalent
1300
1301
Note: This function cannot accept a unicode string."""
857
1302
global if_nametoindex
858
1303
try:
859
1304
if_nametoindex = (ctypes.cdll.LoadLibrary
860
(ctypes.util.find_library("c"))
1305
(ctypes.util.find_library(u"c"))
861
1306
.if_nametoindex)
862
1307
except (OSError, AttributeError):
863
if "struct" not in sys.modules:
864
import struct
865
if "fcntl" not in sys.modules:
866
import fcntl
1308
logger.warning(u"Doing if_nametoindex the hard way")
867
1309
def if_nametoindex(interface):
868
1310
"Get an interface index the hard way, i.e. using fcntl()"
869
1311
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
870
1312
with closing(socket.socket()) as s:
871
1313
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
872
struct.pack("16s16x", interface))
873
interface_index = struct.unpack("I", ifreq[16:20])[0]
1314
struct.pack(str(u"16s16x"),
1315
interface))
1316
interface_index = struct.unpack(str(u"I"),
1317
ifreq[16:20])[0]
874
1318
return interface_index
875
1319
return if_nametoindex(interface)
876
1320
877
1321
878
1322
def daemon(nochdir = False, noclose = False):
879
1323
"""See daemon(3). Standard BSD Unix function.
1324
880
1325
This should really exist as os.daemon, but it doesn't (yet)."""
881
1326
if os.fork():
882
1327
sys.exit()
883
1328
os.setsid()
884
1329
if not nochdir:
885
os.chdir("/")
1330
os.chdir(u"/")
886
1331
if os.fork():
887
1332
sys.exit()
888
1333
if not noclose:
890
1335
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
891
1336
if not stat.S_ISCHR(os.fstat(null).st_mode):
892
1337
raise OSError(errno.ENODEV,
893
"/dev/null not a character device")
1338
u"/dev/null not a character device")
894
1339
os.dup2(null, sys.stdin.fileno())
895
1340
os.dup2(null, sys.stdout.fileno())
896
1341
os.dup2(null, sys.stderr.fileno())
899
1344
900
1345
901
1346
def main():
1347
1348
##################################################################
1349
# Parsing of options, both command line and config file
1350
902
1351
parser = optparse.OptionParser(version = "%%prog %s" % version)
903
parser.add_option("-i", "--interface", type="string",
904
metavar="IF", help="Bind to interface IF")
905
parser.add_option("-a", "--address", type="string",
906
help="Address to listen for requests on")
907
parser.add_option("-p", "--port", type="int",
908
help="Port number to receive requests on")
909
parser.add_option("--check", action="store_true",
910
help="Run self-test")
911
parser.add_option("--debug", action="store_true",
912
help="Debug mode; run in foreground and log to"
913
" terminal")
914
parser.add_option("--priority", type="string", help="GnuTLS"
915
" priority string (see GnuTLS documentation)")
916
parser.add_option("--servicename", type="string", metavar="NAME",
917
help="Zeroconf service name")
918
parser.add_option("--configdir", type="string",
919
default="/etc/mandos", metavar="DIR",
920
help="Directory to search for configuration"
921
" files")
922
parser.add_option("--no-dbus", action="store_false",
923
dest="use_dbus",
924
help="Do not provide D-Bus system bus"
925
" interface")
1352
parser.add_option("-i", u"--interface", type=u"string",
1353
metavar="IF", help=u"Bind to interface IF")
1354
parser.add_option("-a", u"--address", type=u"string",
1355
help=u"Address to listen for requests on")
1356
parser.add_option("-p", u"--port", type=u"int",
1357
help=u"Port number to receive requests on")
1358
parser.add_option("--check", action=u"store_true",
1359
help=u"Run self-test")
1360
parser.add_option("--debug", action=u"store_true",
1361
help=u"Debug mode; run in foreground and log to"
1362
u" terminal")
1363
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1364
u" priority string (see GnuTLS documentation)")
1365
parser.add_option("--servicename", type=u"string",
1366
metavar=u"NAME", help=u"Zeroconf service name")
1367
parser.add_option("--configdir", type=u"string",
1368
default=u"/etc/mandos", metavar=u"DIR",
1369
help=u"Directory to search for configuration"
1370
u" files")
1371
parser.add_option("--no-dbus", action=u"store_false",
1372
dest=u"use_dbus", help=u"Do not provide D-Bus"
1373
u" system bus interface")
1374
parser.add_option("--no-ipv6", action=u"store_false",
1375
dest=u"use_ipv6", help=u"Do not use IPv6")
926
1376
options = parser.parse_args()[0]
927
1377
928
1378
if options.check:
931
1381
sys.exit()
932
1382
933
1383
# Default values for config file for server-global settings
934
server_defaults = { "interface": "",
935
"address": "",
936
"port": "",
937
"debug": "False",
938
"priority":
939
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
940
"servicename": "Mandos",
941
"use_dbus": "True",
1384
server_defaults = { u"interface": u"",
1385
u"address": u"",
1386
u"port": u"",
1387
u"debug": u"False",
1388
u"priority":
1389
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1390
u"servicename": u"Mandos",
1391
u"use_dbus": u"True",
1392
u"use_ipv6": u"True",
942
1393
}
943
1394
944
1395
# Parse config file for server-global settings
945
server_config = ConfigParser.SafeConfigParser(server_defaults)
1396
server_config = configparser.SafeConfigParser(server_defaults)
946
1397
del server_defaults
947
server_config.read(os.path.join(options.configdir, "mandos.conf"))
1398
server_config.read(os.path.join(options.configdir,
1399
u"mandos.conf"))
948
1400
# Convert the SafeConfigParser object to a dict
949
1401
server_settings = server_config.defaults()
950
1402
# Use the appropriate methods on the non-string config options
951
server_settings["debug"] = server_config.getboolean("DEFAULT",
952
"debug")
953
server_settings["use_dbus"] = server_config.getboolean("DEFAULT",
954
"use_dbus")
1403
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1404
server_settings[option] = server_config.getboolean(u"DEFAULT",
1405
option)
955
1406
if server_settings["port"]:
956
server_settings["port"] = server_config.getint("DEFAULT",
957
"port")
1407
server_settings["port"] = server_config.getint(u"DEFAULT",
1408
u"port")
958
1409
del server_config
959
1410
960
1411
# Override the settings from the config file with command line
961
1412
# options, if set.
962
for option in ("interface", "address", "port", "debug",
963
"priority", "servicename", "configdir",
964
"use_dbus"):
1413
for option in (u"interface", u"address", u"port", u"debug",
1414
u"priority", u"servicename", u"configdir",
1415
u"use_dbus", u"use_ipv6"):
965
1416
value = getattr(options, option)
966
1417
if value is not None:
967
1418
server_settings[option] = value
968
1419
del options
1420
# Force all strings to be unicode
1421
for option in server_settings.keys():
1422
if type(server_settings[option]) is str:
1423
server_settings[option] = unicode(server_settings[option])
969
1424
# Now we have our good server settings in "server_settings"
970
1425
1426
##################################################################
1427
971
1428
# For convenience
972
debug = server_settings["debug"]
973
use_dbus = server_settings["use_dbus"]
1429
debug = server_settings[u"debug"]
1430
use_dbus = server_settings[u"use_dbus"]
1431
use_ipv6 = server_settings[u"use_ipv6"]
974
1432
975
1433
if not debug:
976
1434
syslogger.setLevel(logging.WARNING)
977
1435
console.setLevel(logging.WARNING)
978
1436
979
if server_settings["servicename"] != "Mandos":
1437
if server_settings[u"servicename"] != u"Mandos":
980
1438
syslogger.setFormatter(logging.Formatter
981
('Mandos (%s): %%(levelname)s:'
982
' %%(message)s'
983
% server_settings["servicename"]))
1439
(u'Mandos (%s) [%%(process)d]:'
1440
u' %%(levelname)s: %%(message)s'
1441
% server_settings[u"servicename"]))
984
1442
985
1443
# Parse config file with clients
986
client_defaults = { "timeout": "1h",
987
"interval": "5m",
988
"checker": "fping -q -- %%(host)s",
989
"host": "",
1444
client_defaults = { u"timeout": u"1h",
1445
u"interval": u"5m",
1446
u"checker": u"fping -q -- %%(host)s",
1447
u"host": u"",
990
1448
}
991
client_config = ConfigParser.SafeConfigParser(client_defaults)
992
client_config.read(os.path.join(server_settings["configdir"],
993
"clients.conf"))
994
995
clients = Set()
996
tcp_server = IPv6_TCPServer((server_settings["address"],
997
server_settings["port"]),
998
TCP_handler,
999
settings=server_settings,
1000
clients=clients)
1001
pidfilename = "/var/run/mandos.pid"
1449
client_config = configparser.SafeConfigParser(client_defaults)
1450
client_config.read(os.path.join(server_settings[u"configdir"],
1451
u"clients.conf"))
1452
1453
global mandos_dbus_service
1454
mandos_dbus_service = None
1455
1456
tcp_server = MandosServer((server_settings[u"address"],
1457
server_settings[u"port"]),
1458
ClientHandler,
1459
interface=server_settings[u"interface"],
1460
use_ipv6=use_ipv6,
1461
gnutls_priority=
1462
server_settings[u"priority"],
1463
use_dbus=use_dbus)
1464
pidfilename = u"/var/run/mandos.pid"
1002
1465
try:
1003
pidfile = open(pidfilename, "w")
1466
pidfile = open(pidfilename, u"w")
1004
1467
except IOError:
1005
logger.error("Could not open file %r", pidfilename)
1468
logger.error(u"Could not open file %r", pidfilename)
1006
1469
1007
1470
try:
1008
uid = pwd.getpwnam("_mandos").pw_uid
1009
gid = pwd.getpwnam("_mandos").pw_gid
1471
uid = pwd.getpwnam(u"_mandos").pw_uid
1472
gid = pwd.getpwnam(u"_mandos").pw_gid
1010
1473
except KeyError:
1011
1474
try:
1012
uid = pwd.getpwnam("mandos").pw_uid
1013
gid = pwd.getpwnam("mandos").pw_gid
1475
uid = pwd.getpwnam(u"mandos").pw_uid
1476
gid = pwd.getpwnam(u"mandos").pw_gid
1014
1477
except KeyError:
1015
1478
try:
1016
uid = pwd.getpwnam("nobody").pw_uid
1017
gid = pwd.getpwnam("nogroup").pw_gid
1479
uid = pwd.getpwnam(u"nobody").pw_uid
1480
gid = pwd.getpwnam(u"nobody").pw_gid
1018
1481
except KeyError:
1019
1482
uid = 65534
1020
1483
gid = 65534
1033
1496
1034
1497
@gnutls.library.types.gnutls_log_func
1035
1498
def debug_gnutls(level, string):
1036
logger.debug("GnuTLS: %s", string[:-1])
1499
logger.debug(u"GnuTLS: %s", string[:-1])
1037
1500
1038
1501
(gnutls.library.functions
1039
1502
.gnutls_global_set_log_function(debug_gnutls))
1040
1503
1041
global service
1042
service = AvahiService(name = server_settings["servicename"],
1043
servicetype = "_mandos._tcp", )
1044
if server_settings["interface"]:
1045
service.interface = (if_nametoindex
1046
(server_settings["interface"]))
1047
1048
1504
global main_loop
1049
global bus
1050
global server
1051
1505
# From the Avahi example code
1052
1506
DBusGMainLoop(set_as_default=True )
1053
1507
main_loop = gobject.MainLoop()
1054
1508
bus = dbus.SystemBus()
1055
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1056
avahi.DBUS_PATH_SERVER),
1057
avahi.DBUS_INTERFACE_SERVER)
1058
1509
# End of Avahi example code
1059
1510
if use_dbus:
1060
1511
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
1512
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1513
service = AvahiService(name = server_settings[u"servicename"],
1514
servicetype = u"_mandos._tcp",
1515
protocol = protocol, bus = bus)
1516
if server_settings["interface"]:
1517
service.interface = (if_nametoindex
1518
(str(server_settings[u"interface"])))
1061
1519
1062
clients.update(Set(Client(name = section,
1063
config
1064
= dict(client_config.items(section)),
1065
use_dbus = use_dbus)
1066
for section in client_config.sections()))
1067
if not clients:
1520
client_class = Client
1521
if use_dbus:
1522
client_class = functools.partial(ClientDBus, bus = bus)
1523
tcp_server.clients.update(set(
1524
client_class(name = section,
1525
config= dict(client_config.items(section)))
1526
for section in client_config.sections()))
1527
if not tcp_server.clients:
1068
1528
logger.warning(u"No clients defined")
1069
1529
1070
1530
if debug:
1080
1540
daemon()
1081
1541
1082
1542
try:
1083
pid = os.getpid()
1084
pidfile.write(str(pid) + "\n")
1085
pidfile.close()
1543
with closing(pidfile):
1544
pid = os.getpid()
1545
pidfile.write(str(pid) + "\n")
1086
1546
del pidfile
1087
1547
except IOError:
1088
1548
logger.error(u"Could not write to file %r with PID %d",
1094
1554
1095
1555
def cleanup():
1096
1556
"Cleanup function; run on exit"
1097
global group
1098
# From the Avahi example code
1099
if not group is None:
1100
group.Free()
1101
group = None
1102
# End of Avahi example code
1557
service.cleanup()
1103
1558
1104
while clients:
1105
client = clients.pop()
1559
while tcp_server.clients:
1560
client = tcp_server.clients.pop()
1106
1561
client.disable_hook = None
1107
1562
client.disable()
1108
1563
1114
1569
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1115
1570
1116
1571
if use_dbus:
1117
class MandosServer(dbus.service.Object):
1572
class MandosDBusService(dbus.service.Object):
1118
1573
"""A D-Bus proxy object"""
1119
1574
def __init__(self):
1120
dbus.service.Object.__init__(self, bus, "/")
1575
dbus.service.Object.__init__(self, bus, u"/")
1121
1576
_interface = u"se.bsnet.fukt.Mandos"
1122
1577
1123
@dbus.service.signal(_interface, signature="oa{sv}")
1578
@dbus.service.signal(_interface, signature=u"oa{sv}")
1124
1579
def ClientAdded(self, objpath, properties):
1125
1580
"D-Bus signal"
1126
1581
pass
1127
1582
1128
@dbus.service.signal(_interface, signature="os")
1583
@dbus.service.signal(_interface, signature=u"s")
1584
def ClientNotFound(self, fingerprint):
1585
"D-Bus signal"
1586
pass
1587
1588
@dbus.service.signal(_interface, signature=u"os")
1129
1589
def ClientRemoved(self, objpath, name):
1130
1590
"D-Bus signal"
1131
1591
pass
1132
1592
1133
@dbus.service.method(_interface, out_signature="ao")
1593
@dbus.service.method(_interface, out_signature=u"ao")
1134
1594
def GetAllClients(self):
1135
1595
"D-Bus method"
1136
return dbus.Array(c.dbus_object_path for c in clients)
1596
return dbus.Array(c.dbus_object_path
1597
for c in tcp_server.clients)
1137
1598
1138
@dbus.service.method(_interface, out_signature="a{oa{sv}}")
1599
@dbus.service.method(_interface,
1600
out_signature=u"a{oa{sv}}")
1139
1601
def GetAllClientsWithProperties(self):
1140
1602
"D-Bus method"
1141
1603
return dbus.Dictionary(
1142
((c.dbus_object_path, c.GetAllProperties())
1143
for c in clients),
1144
signature="oa{sv}")
1604
((c.dbus_object_path, c.GetAll(u""))
1605
for c in tcp_server.clients),
1606
signature=u"oa{sv}")
1145
1607
1146
@dbus.service.method(_interface, in_signature="o")
1608
@dbus.service.method(_interface, in_signature=u"o")
1147
1609
def RemoveClient(self, object_path):
1148
1610
"D-Bus method"
1149
for c in clients:
1611
for c in tcp_server.clients:
1150
1612
if c.dbus_object_path == object_path:
1151
clients.remove(c)
1613
tcp_server.clients.remove(c)
1614
c.remove_from_connection()
1152
1615
# Don't signal anything except ClientRemoved
1153
c.use_dbus = False
1154
c.disable()
1616
c.disable(signal=False)
1155
1617
# Emit D-Bus signal
1156
1618
self.ClientRemoved(object_path, c.name)
1157
1619
return
1159
1621
1160
1622
del _interface
1161
1623
1162
mandos_server = MandosServer()
1624
mandos_dbus_service = MandosDBusService()
1163
1625
1164
for client in clients:
1626
for client in tcp_server.clients:
1165
1627
if use_dbus:
1166
1628
# Emit D-Bus signal
1167
mandos_server.ClientAdded(client.dbus_object_path,
1168
client.GetAllProperties())
1629
mandos_dbus_service.ClientAdded(client.dbus_object_path,
1630
client.GetAll(u""))
1169
1631
client.enable()
1170
1632
1171
1633
tcp_server.enable()
1173
1635
1174
1636
# Find out what port we got
1175
1637
service.port = tcp_server.socket.getsockname()[1]
1176
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
1177
u" scope_id %d" % tcp_server.socket.getsockname())
1638
if use_ipv6:
1639
logger.info(u"Now listening on address %r, port %d,"
1640
" flowinfo %d, scope_id %d"
1641
% tcp_server.socket.getsockname())
1642
else: # IPv4
1643
logger.info(u"Now listening on address %r, port %d"
1644
% tcp_server.socket.getsockname())
1178
1645
1179
1646
#service.interface = tcp_server.socket.getsockname()[3]
1180
1647
1181
1648
try:
1182
1649
# From the Avahi example code
1183
server.connect_to_signal("StateChanged", server_state_changed)
1184
1650
try:
1185
server_state_changed(server.GetState())
1651
service.activate()
1186
1652
except dbus.exceptions.DBusException, error:
1187
1653
logger.critical(u"DBusException: %s", error)
1188
1654
sys.exit(1)
1201
1667
except KeyboardInterrupt:
1202
1668
if debug:
1203
1669
print >> sys.stderr
1204
logger.debug("Server received KeyboardInterrupt")
1205
logger.debug("Server exiting")
1670
logger.debug(u"Server received KeyboardInterrupt")
1671
logger.debug(u"Server exiting")
1206
1672
1207
1673
if __name__ == '__main__':
1208
1674
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0