To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 237.2.146
- compare with another revision
- download diff
- download tarball
- view history from revision 237.2.146
- Committer: Teddy Hogeborn
- Date: 2009-09-22 20:18:43 UTC
- mto: (24.1.146 mandos) (237.12.2 mandos-persistent) (299.1.1 release) (300.1.1 release) (301.1.1 release)
- mto: This revision was merged to the branch mainline in revision 270.
- Revision ID: teddy@fukt.bsnet.se-20090922201843-cd5uqnthf3eegg4l
* mandos (Client.start_checker): Bug fix: Fix race condition with
short intervals.
short intervals.
- 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
try:
402
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
403
except (AttributeError, OSError), error:
404
if (isinstance(error, OSError)
405
and error.errno != errno.ECHILD):
406
raise error
407
else:
408
if pid:
409
logger.warning(u"Checker was a zombie")
410
gobject.source_remove(self.checker_callback_tag)
411
self.checker_callback(pid, status,
412
self.current_checker_command)
413
# Start a new checker if needed
380
414
if self.checker is None:
381
415
try:
382
416
# In case checker_command has exactly one % operator
383
417
command = self.checker_command % self.host
384
418
except TypeError:
385
419
# Escape attributes for the shell
386
escaped_attrs = dict((key, re.escape(str(val)))
420
escaped_attrs = dict((key,
421
re.escape(unicode(str(val),
422
errors=
423
u'replace')))
387
424
for key, val in
388
425
vars(self).iteritems())
389
426
try:
392
429
logger.error(u'Could not format string "%s":'
393
430
u' %s', self.checker_command, error)
394
431
return True # Try again later
432
self.current_checker_command = command
395
433
try:
396
434
logger.info(u"Starting checker %r for %s",
397
435
command, self.name)
401
439
# always replaced by /dev/null.)
402
440
self.checker = subprocess.Popen(command,
403
441
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))
442
shell=True, cwd=u"/")
411
443
self.checker_callback_tag = (gobject.child_watch_add
412
444
(self.checker.pid,
413
445
self.checker_callback,
429
461
if self.checker_callback_tag:
430
462
gobject.source_remove(self.checker_callback_tag)
431
463
self.checker_callback_tag = None
432
if getattr(self, "checker", None) is None:
464
if getattr(self, u"checker", None) is None:
433
465
return
434
466
logger.debug(u"Stopping checker for %(name)s", vars(self))
435
467
try:
441
473
if error.errno != errno.ESRCH: # No such process
442
474
raise
443
475
self.checker = None
444
if self.use_dbus:
445
self.PropertyChanged(dbus.String(u"checker_running"),
446
dbus.Boolean(False, variant_level=1))
447
476
448
477
def still_valid(self):
449
478
"""Has the timeout not yet passed for this client?"""
450
if not getattr(self, "enabled", False):
479
if not getattr(self, u"enabled", False):
451
480
return False
452
481
now = datetime.datetime.utcnow()
453
482
if self.last_checked_ok is None:
454
483
return now < (self.created + self.timeout)
455
484
else:
456
485
return now < (self.last_checked_ok + self.timeout)
486
487
488
def dbus_service_property(dbus_interface, signature=u"v",
489
access=u"readwrite", byte_arrays=False):
490
"""Decorators for marking methods of a DBusObjectWithProperties to
491
become properties on the D-Bus.
492
493
The decorated method will be called with no arguments by "Get"
494
and with one argument by "Set".
495
496
The parameters, where they are supported, are the same as
497
dbus.service.method, except there is only "signature", since the
498
type from Get() and the type sent to Set() is the same.
499
"""
500
def decorator(func):
501
func._dbus_is_property = True
502
func._dbus_interface = dbus_interface
503
func._dbus_signature = signature
504
func._dbus_access = access
505
func._dbus_name = func.__name__
506
if func._dbus_name.endswith(u"_dbus_property"):
507
func._dbus_name = func._dbus_name[:-14]
508
func._dbus_get_args_options = {u'byte_arrays': byte_arrays }
509
return func
510
return decorator
511
512
513
class DBusPropertyException(dbus.exceptions.DBusException):
514
"""A base class for D-Bus property-related exceptions
515
"""
516
def __unicode__(self):
517
return unicode(str(self))
518
519
520
class DBusPropertyAccessException(DBusPropertyException):
521
"""A property's access permissions disallows an operation.
522
"""
523
pass
524
525
526
class DBusPropertyNotFound(DBusPropertyException):
527
"""An attempt was made to access a non-existing property.
528
"""
529
pass
530
531
532
class DBusObjectWithProperties(dbus.service.Object):
533
"""A D-Bus object with properties.
534
535
Classes inheriting from this can use the dbus_service_property
536
decorator to expose methods as D-Bus properties. It exposes the
537
standard Get(), Set(), and GetAll() methods on the D-Bus.
538
"""
539
540
@staticmethod
541
def _is_dbus_property(obj):
542
return getattr(obj, u"_dbus_is_property", False)
543
544
def _get_all_dbus_properties(self):
545
"""Returns a generator of (name, attribute) pairs
546
"""
547
return ((prop._dbus_name, prop)
548
for name, prop in
549
inspect.getmembers(self, self._is_dbus_property))
550
551
def _get_dbus_property(self, interface_name, property_name):
552
"""Returns a bound method if one exists which is a D-Bus
553
property with the specified name and interface.
554
"""
555
for name in (property_name,
556
property_name + u"_dbus_property"):
557
prop = getattr(self, name, None)
558
if (prop is None
559
or not self._is_dbus_property(prop)
560
or prop._dbus_name != property_name
561
or (interface_name and prop._dbus_interface
562
and interface_name != prop._dbus_interface)):
563
continue
564
return prop
565
# No such property
566
raise DBusPropertyNotFound(self.dbus_object_path + u":"
567
+ interface_name + u"."
568
+ property_name)
569
570
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
571
out_signature=u"v")
572
def Get(self, interface_name, property_name):
573
"""Standard D-Bus property Get() method, see D-Bus standard.
574
"""
575
prop = self._get_dbus_property(interface_name, property_name)
576
if prop._dbus_access == u"write":
577
raise DBusPropertyAccessException(property_name)
578
value = prop()
579
if not hasattr(value, u"variant_level"):
580
return value
581
return type(value)(value, variant_level=value.variant_level+1)
582
583
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
584
def Set(self, interface_name, property_name, value):
585
"""Standard D-Bus property Set() method, see D-Bus standard.
586
"""
587
prop = self._get_dbus_property(interface_name, property_name)
588
if prop._dbus_access == u"read":
589
raise DBusPropertyAccessException(property_name)
590
if prop._dbus_get_args_options[u"byte_arrays"]:
591
value = dbus.ByteArray(''.join(unichr(byte)
592
for byte in value))
593
prop(value)
594
595
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
596
out_signature=u"a{sv}")
597
def GetAll(self, interface_name):
598
"""Standard D-Bus property GetAll() method, see D-Bus
599
standard.
600
601
Note: Will not include properties with access="write".
602
"""
603
all = {}
604
for name, prop in self._get_all_dbus_properties():
605
if (interface_name
606
and interface_name != prop._dbus_interface):
607
# Interface non-empty but did not match
608
continue
609
# Ignore write-only properties
610
if prop._dbus_access == u"write":
611
continue
612
value = prop()
613
if not hasattr(value, u"variant_level"):
614
all[name] = value
615
continue
616
all[name] = type(value)(value, variant_level=
617
value.variant_level+1)
618
return dbus.Dictionary(all, signature=u"sv")
619
620
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
621
out_signature=u"s",
622
path_keyword='object_path',
623
connection_keyword='connection')
624
def Introspect(self, object_path, connection):
625
"""Standard D-Bus method, overloaded to insert property tags.
626
"""
627
xmlstring = dbus.service.Object.Introspect(self, object_path,
628
connection)
629
document = xml.dom.minidom.parseString(xmlstring)
630
del xmlstring
631
def make_tag(document, name, prop):
632
e = document.createElement(u"property")
633
e.setAttribute(u"name", name)
634
e.setAttribute(u"type", prop._dbus_signature)
635
e.setAttribute(u"access", prop._dbus_access)
636
return e
637
for if_tag in document.getElementsByTagName(u"interface"):
638
for tag in (make_tag(document, name, prop)
639
for name, prop
640
in self._get_all_dbus_properties()
641
if prop._dbus_interface
642
== if_tag.getAttribute(u"name")):
643
if_tag.appendChild(tag)
644
xmlstring = document.toxml(u"utf-8")
645
document.unlink()
646
return xmlstring
647
648
649
class ClientDBus(Client, DBusObjectWithProperties):
650
"""A Client class using D-Bus
651
652
Attributes:
653
dbus_object_path: dbus.ObjectPath
654
bus: dbus.SystemBus()
655
"""
656
# dbus.service.Object doesn't use super(), so we can't either.
657
658
def __init__(self, bus = None, *args, **kwargs):
659
self.bus = bus
660
Client.__init__(self, *args, **kwargs)
661
# Only now, when this client is initialized, can it show up on
662
# the D-Bus
663
self.dbus_object_path = (dbus.ObjectPath
664
(u"/clients/"
665
+ self.name.replace(u".", u"_")))
666
DBusObjectWithProperties.__init__(self, self.bus,
667
self.dbus_object_path)
668
669
@staticmethod
670
def _datetime_to_dbus(dt, variant_level=0):
671
"""Convert a UTC datetime.datetime() to a D-Bus type."""
672
return dbus.String(dt.isoformat(),
673
variant_level=variant_level)
674
675
def enable(self):
676
oldstate = getattr(self, u"enabled", False)
677
r = Client.enable(self)
678
if oldstate != self.enabled:
679
# Emit D-Bus signals
680
self.PropertyChanged(dbus.String(u"enabled"),
681
dbus.Boolean(True, variant_level=1))
682
self.PropertyChanged(
683
dbus.String(u"last_enabled"),
684
self._datetime_to_dbus(self.last_enabled,
685
variant_level=1))
686
return r
687
688
def disable(self, signal = True):
689
oldstate = getattr(self, u"enabled", False)
690
r = Client.disable(self)
691
if signal and oldstate != self.enabled:
692
# Emit D-Bus signal
693
self.PropertyChanged(dbus.String(u"enabled"),
694
dbus.Boolean(False, variant_level=1))
695
return r
696
697
def __del__(self, *args, **kwargs):
698
try:
699
self.remove_from_connection()
700
except LookupError:
701
pass
702
if hasattr(DBusObjectWithProperties, u"__del__"):
703
DBusObjectWithProperties.__del__(self, *args, **kwargs)
704
Client.__del__(self, *args, **kwargs)
705
706
def checker_callback(self, pid, condition, command,
707
*args, **kwargs):
708
self.checker_callback_tag = None
709
self.checker = None
710
# Emit D-Bus signal
711
self.PropertyChanged(dbus.String(u"checker_running"),
712
dbus.Boolean(False, variant_level=1))
713
if os.WIFEXITED(condition):
714
exitstatus = os.WEXITSTATUS(condition)
715
# Emit D-Bus signal
716
self.CheckerCompleted(dbus.Int16(exitstatus),
717
dbus.Int64(condition),
718
dbus.String(command))
719
else:
720
# Emit D-Bus signal
721
self.CheckerCompleted(dbus.Int16(-1),
722
dbus.Int64(condition),
723
dbus.String(command))
724
725
return Client.checker_callback(self, pid, condition, command,
726
*args, **kwargs)
727
728
def checked_ok(self, *args, **kwargs):
729
r = Client.checked_ok(self, *args, **kwargs)
730
# Emit D-Bus signal
731
self.PropertyChanged(
732
dbus.String(u"last_checked_ok"),
733
(self._datetime_to_dbus(self.last_checked_ok,
734
variant_level=1)))
735
return r
736
737
def start_checker(self, *args, **kwargs):
738
old_checker = self.checker
739
if self.checker is not None:
740
old_checker_pid = self.checker.pid
741
else:
742
old_checker_pid = None
743
r = Client.start_checker(self, *args, **kwargs)
744
# Only if new checker process was started
745
if (self.checker is not None
746
and old_checker_pid != self.checker.pid):
747
# Emit D-Bus signal
748
self.CheckerStarted(self.current_checker_command)
749
self.PropertyChanged(
750
dbus.String(u"checker_running"),
751
dbus.Boolean(True, variant_level=1))
752
return r
753
754
def stop_checker(self, *args, **kwargs):
755
old_checker = getattr(self, u"checker", None)
756
r = Client.stop_checker(self, *args, **kwargs)
757
if (old_checker is not None
758
and getattr(self, u"checker", None) is None):
759
self.PropertyChanged(dbus.String(u"checker_running"),
760
dbus.Boolean(False, variant_level=1))
761
return r
457
762
458
763
## D-Bus methods & signals
459
764
_interface = u"se.bsnet.fukt.Mandos.Client"
460
765
461
766
# CheckedOK - method
462
CheckedOK = dbus.service.method(_interface)(checked_ok)
463
CheckedOK.__name__ = "CheckedOK"
767
@dbus.service.method(_interface)
768
def CheckedOK(self):
769
return self.checked_ok()
464
770
465
771
# CheckerCompleted - signal
466
@dbus.service.signal(_interface, signature="nxs")
772
@dbus.service.signal(_interface, signature=u"nxs")
467
773
def CheckerCompleted(self, exitcode, waitstatus, command):
468
774
"D-Bus signal"
469
775
pass
470
776
471
777
# CheckerStarted - signal
472
@dbus.service.signal(_interface, signature="s")
778
@dbus.service.signal(_interface, signature=u"s")
473
779
def CheckerStarted(self, command):
474
780
"D-Bus signal"
475
781
pass
476
782
477
# GetAllProperties - method
478
@dbus.service.method(_interface, out_signature="a{sv}")
479
def GetAllProperties(self):
480
"D-Bus method"
481
return dbus.Dictionary({
482
dbus.String("name"):
483
dbus.String(self.name, variant_level=1),
484
dbus.String("fingerprint"):
485
dbus.String(self.fingerprint, variant_level=1),
486
dbus.String("host"):
487
dbus.String(self.host, variant_level=1),
488
dbus.String("created"):
489
_datetime_to_dbus(self.created, variant_level=1),
490
dbus.String("last_enabled"):
491
(_datetime_to_dbus(self.last_enabled,
492
variant_level=1)
493
if self.last_enabled is not None
494
else dbus.Boolean(False, variant_level=1)),
495
dbus.String("enabled"):
496
dbus.Boolean(self.enabled, variant_level=1),
497
dbus.String("last_checked_ok"):
498
(_datetime_to_dbus(self.last_checked_ok,
499
variant_level=1)
500
if self.last_checked_ok is not None
501
else dbus.Boolean (False, variant_level=1)),
502
dbus.String("timeout"):
503
dbus.UInt64(self.timeout_milliseconds(),
504
variant_level=1),
505
dbus.String("interval"):
506
dbus.UInt64(self.interval_milliseconds(),
507
variant_level=1),
508
dbus.String("checker"):
509
dbus.String(self.checker_command,
510
variant_level=1),
511
dbus.String("checker_running"):
512
dbus.Boolean(self.checker is not None,
513
variant_level=1),
514
dbus.String("object_path"):
515
dbus.ObjectPath(self.dbus_object_path,
516
variant_level=1)
517
}, signature="sv")
518
519
# IsStillValid - method
520
IsStillValid = (dbus.service.method(_interface, out_signature="b")
521
(still_valid))
522
IsStillValid.__name__ = "IsStillValid"
523
524
783
# PropertyChanged - signal
525
@dbus.service.signal(_interface, signature="sv")
784
@dbus.service.signal(_interface, signature=u"sv")
526
785
def PropertyChanged(self, property, value):
527
786
"D-Bus signal"
528
787
pass
529
788
530
# SetChecker - method
531
@dbus.service.method(_interface, in_signature="s")
532
def SetChecker(self, checker):
533
"D-Bus setter method"
534
self.checker_command = checker
535
# Emit D-Bus signal
536
self.PropertyChanged(dbus.String(u"checker"),
537
dbus.String(self.checker_command,
538
variant_level=1))
539
540
# SetHost - method
541
@dbus.service.method(_interface, in_signature="s")
542
def SetHost(self, host):
543
"D-Bus setter method"
544
self.host = host
545
# Emit D-Bus signal
546
self.PropertyChanged(dbus.String(u"host"),
547
dbus.String(self.host, variant_level=1))
548
549
# SetInterval - method
550
@dbus.service.method(_interface, in_signature="t")
551
def SetInterval(self, milliseconds):
552
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
553
# Emit D-Bus signal
554
self.PropertyChanged(dbus.String(u"interval"),
555
(dbus.UInt64(self.interval_milliseconds(),
556
variant_level=1)))
557
558
# SetSecret - method
559
@dbus.service.method(_interface, in_signature="ay",
560
byte_arrays=True)
561
def SetSecret(self, secret):
562
"D-Bus setter method"
563
self.secret = str(secret)
564
565
# SetTimeout - method
566
@dbus.service.method(_interface, in_signature="t")
567
def SetTimeout(self, milliseconds):
568
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
569
# Emit D-Bus signal
570
self.PropertyChanged(dbus.String(u"timeout"),
571
(dbus.UInt64(self.timeout_milliseconds(),
572
variant_level=1)))
789
# ReceivedSecret - signal
790
@dbus.service.signal(_interface)
791
def ReceivedSecret(self):
792
"D-Bus signal"
793
pass
794
795
# Rejected - signal
796
@dbus.service.signal(_interface)
797
def Rejected(self):
798
"D-Bus signal"
799
pass
573
800
574
801
# Enable - method
575
Enable = dbus.service.method(_interface)(enable)
576
Enable.__name__ = "Enable"
802
@dbus.service.method(_interface)
803
def Enable(self):
804
"D-Bus method"
805
self.enable()
577
806
578
807
# StartChecker - method
579
808
@dbus.service.method(_interface)
588
817
self.disable()
589
818
590
819
# StopChecker - method
591
StopChecker = dbus.service.method(_interface)(stop_checker)
592
StopChecker.__name__ = "StopChecker"
820
@dbus.service.method(_interface)
821
def StopChecker(self):
822
self.stop_checker()
823
824
# name - property
825
@dbus_service_property(_interface, signature=u"s", access=u"read")
826
def name_dbus_property(self):
827
return dbus.String(self.name)
828
829
# fingerprint - property
830
@dbus_service_property(_interface, signature=u"s", access=u"read")
831
def fingerprint_dbus_property(self):
832
return dbus.String(self.fingerprint)
833
834
# host - property
835
@dbus_service_property(_interface, signature=u"s",
836
access=u"readwrite")
837
def host_dbus_property(self, value=None):
838
if value is None: # get
839
return dbus.String(self.host)
840
self.host = value
841
# Emit D-Bus signal
842
self.PropertyChanged(dbus.String(u"host"),
843
dbus.String(value, variant_level=1))
844
845
# created - property
846
@dbus_service_property(_interface, signature=u"s", access=u"read")
847
def created_dbus_property(self):
848
return dbus.String(self._datetime_to_dbus(self.created))
849
850
# last_enabled - property
851
@dbus_service_property(_interface, signature=u"s", access=u"read")
852
def last_enabled_dbus_property(self):
853
if self.last_enabled is None:
854
return dbus.String(u"")
855
return dbus.String(self._datetime_to_dbus(self.last_enabled))
856
857
# enabled - property
858
@dbus_service_property(_interface, signature=u"b",
859
access=u"readwrite")
860
def enabled_dbus_property(self, value=None):
861
if value is None: # get
862
return dbus.Boolean(self.enabled)
863
if value:
864
self.enable()
865
else:
866
self.disable()
867
868
# last_checked_ok - property
869
@dbus_service_property(_interface, signature=u"s",
870
access=u"readwrite")
871
def last_checked_ok_dbus_property(self, value=None):
872
if value is not None:
873
self.checked_ok()
874
return
875
if self.last_checked_ok is None:
876
return dbus.String(u"")
877
return dbus.String(self._datetime_to_dbus(self
878
.last_checked_ok))
879
880
# timeout - property
881
@dbus_service_property(_interface, signature=u"t",
882
access=u"readwrite")
883
def timeout_dbus_property(self, value=None):
884
if value is None: # get
885
return dbus.UInt64(self.timeout_milliseconds())
886
self.timeout = datetime.timedelta(0, 0, 0, value)
887
# Emit D-Bus signal
888
self.PropertyChanged(dbus.String(u"timeout"),
889
dbus.UInt64(value, variant_level=1))
890
if getattr(self, u"disable_initiator_tag", None) is None:
891
return
892
# Reschedule timeout
893
gobject.source_remove(self.disable_initiator_tag)
894
self.disable_initiator_tag = None
895
time_to_die = (self.
896
_timedelta_to_milliseconds((self
897
.last_checked_ok
898
+ self.timeout)
899
- datetime.datetime
900
.utcnow()))
901
if time_to_die <= 0:
902
# The timeout has passed
903
self.disable()
904
else:
905
self.disable_initiator_tag = (gobject.timeout_add
906
(time_to_die, self.disable))
907
908
# interval - property
909
@dbus_service_property(_interface, signature=u"t",
910
access=u"readwrite")
911
def interval_dbus_property(self, value=None):
912
if value is None: # get
913
return dbus.UInt64(self.interval_milliseconds())
914
self.interval = datetime.timedelta(0, 0, 0, value)
915
# Emit D-Bus signal
916
self.PropertyChanged(dbus.String(u"interval"),
917
dbus.UInt64(value, variant_level=1))
918
if getattr(self, u"checker_initiator_tag", None) is None:
919
return
920
# Reschedule checker run
921
gobject.source_remove(self.checker_initiator_tag)
922
self.checker_initiator_tag = (gobject.timeout_add
923
(value, self.start_checker))
924
self.start_checker() # Start one now, too
925
926
# checker - property
927
@dbus_service_property(_interface, signature=u"s",
928
access=u"readwrite")
929
def checker_dbus_property(self, value=None):
930
if value is None: # get
931
return dbus.String(self.checker_command)
932
self.checker_command = value
933
# Emit D-Bus signal
934
self.PropertyChanged(dbus.String(u"checker"),
935
dbus.String(self.checker_command,
936
variant_level=1))
937
938
# checker_running - property
939
@dbus_service_property(_interface, signature=u"b",
940
access=u"readwrite")
941
def checker_running_dbus_property(self, value=None):
942
if value is None: # get
943
return dbus.Boolean(self.checker is not None)
944
if value:
945
self.start_checker()
946
else:
947
self.stop_checker()
948
949
# object_path - property
950
@dbus_service_property(_interface, signature=u"o", access=u"read")
951
def object_path_dbus_property(self):
952
return self.dbus_object_path # is already a dbus.ObjectPath
953
954
# secret = property
955
@dbus_service_property(_interface, signature=u"ay",
956
access=u"write", byte_arrays=True)
957
def secret_dbus_property(self, value):
958
self.secret = str(value)
593
959
594
960
del _interface
595
961
596
962
597
def peer_certificate(session):
598
"Return the peer's OpenPGP certificate as a bytestring"
599
# If not an OpenPGP certificate...
600
if (gnutls.library.functions
601
.gnutls_certificate_type_get(session._c_object)
602
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
603
# ...do the normal thing
604
return session.peer_certificate
605
list_size = ctypes.c_uint(1)
606
cert_list = (gnutls.library.functions
607
.gnutls_certificate_get_peers
608
(session._c_object, ctypes.byref(list_size)))
609
if not bool(cert_list) and list_size.value != 0:
610
raise gnutls.errors.GNUTLSError("error getting peer"
611
" certificate")
612
if list_size.value == 0:
613
return None
614
cert = cert_list[0]
615
return ctypes.string_at(cert.data, cert.size)
616
617
618
def fingerprint(openpgp):
619
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
620
# New GnuTLS "datum" with the OpenPGP public key
621
datum = (gnutls.library.types
622
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
623
ctypes.POINTER
624
(ctypes.c_ubyte)),
625
ctypes.c_uint(len(openpgp))))
626
# New empty GnuTLS certificate
627
crt = gnutls.library.types.gnutls_openpgp_crt_t()
628
(gnutls.library.functions
629
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
630
# Import the OpenPGP public key into the certificate
631
(gnutls.library.functions
632
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
633
gnutls.library.constants
634
.GNUTLS_OPENPGP_FMT_RAW))
635
# Verify the self signature in the key
636
crtverify = ctypes.c_uint()
637
(gnutls.library.functions
638
.gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
639
if crtverify.value != 0:
640
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
641
raise gnutls.errors.CertificateSecurityError("Verify failed")
642
# New buffer for the fingerprint
643
buf = ctypes.create_string_buffer(20)
644
buf_len = ctypes.c_size_t()
645
# Get the fingerprint from the certificate into the buffer
646
(gnutls.library.functions
647
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
648
ctypes.byref(buf_len)))
649
# Deinit the certificate
650
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
651
# Convert the buffer to a Python bytestring
652
fpr = ctypes.string_at(buf, buf_len.value)
653
# Convert the bytestring to hexadecimal notation
654
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
655
return hex_fpr
656
657
658
class TCP_handler(SocketServer.BaseRequestHandler, object):
659
"""A TCP request handler class.
660
Instantiated by IPv6_TCPServer for each request to handle it.
963
class ClientHandler(socketserver.BaseRequestHandler, object):
964
"""A class to handle client connections.
965
966
Instantiated once for each connection to handle it.
661
967
Note: This will run in its own forked process."""
662
968
663
969
def handle(self):
664
970
logger.info(u"TCP connection from: %s",
665
971
unicode(self.client_address))
666
session = (gnutls.connection
667
.ClientSession(self.request,
668
gnutls.connection
669
.X509Credentials()))
670
671
line = self.request.makefile().readline()
672
logger.debug(u"Protocol version: %r", line)
673
try:
674
if int(line.strip().split()[0]) > 1:
675
raise RuntimeError
676
except (ValueError, IndexError, RuntimeError), error:
677
logger.error(u"Unknown protocol version: %s", error)
678
return
679
680
# Note: gnutls.connection.X509Credentials is really a generic
681
# GnuTLS certificate credentials object so long as no X.509
682
# keys are added to it. Therefore, we can use it here despite
683
# using OpenPGP certificates.
684
685
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
686
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
687
# "+DHE-DSS"))
688
# Use a fallback default, since this MUST be set.
689
priority = self.server.settings.get("priority", "NORMAL")
690
(gnutls.library.functions
691
.gnutls_priority_set_direct(session._c_object,
692
priority, None))
693
694
try:
695
session.handshake()
696
except gnutls.errors.GNUTLSError, error:
697
logger.warning(u"Handshake failed: %s", error)
698
# Do not run session.bye() here: the session is not
699
# established. Just abandon the request.
700
return
701
logger.debug(u"Handshake succeeded")
702
try:
703
fpr = fingerprint(peer_certificate(session))
704
except (TypeError, gnutls.errors.GNUTLSError), error:
705
logger.warning(u"Bad certificate: %s", error)
706
session.bye()
707
return
708
logger.debug(u"Fingerprint: %s", fpr)
709
710
for c in self.server.clients:
711
if c.fingerprint == fpr:
712
client = c
713
break
714
else:
715
logger.warning(u"Client not found for fingerprint: %s",
716
fpr)
717
session.bye()
718
return
719
# Have to check if client.still_valid(), since it is possible
720
# that the client timed out while establishing the GnuTLS
721
# session.
722
if not client.still_valid():
723
logger.warning(u"Client %(name)s is invalid",
724
vars(client))
725
session.bye()
726
return
727
## This won't work here, since we're in a fork.
728
# client.checked_ok()
729
sent_size = 0
730
while sent_size < len(client.secret):
731
sent = session.send(client.secret[sent_size:])
732
logger.debug(u"Sent: %d, remaining: %d",
733
sent, len(client.secret)
734
- (sent_size + sent))
735
sent_size += sent
736
session.bye()
737
738
739
class IPv6_TCPServer(SocketServer.ForkingMixIn,
740
SocketServer.TCPServer, object):
741
"""IPv6 TCP server. Accepts 'None' as address and/or port.
972
logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])
973
# Open IPC pipe to parent process
974
with closing(os.fdopen(self.server.pipe[1], u"w", 1)) as ipc:
975
session = (gnutls.connection
976
.ClientSession(self.request,
977
gnutls.connection
978
.X509Credentials()))
979
980
line = self.request.makefile().readline()
981
logger.debug(u"Protocol version: %r", line)
982
try:
983
if int(line.strip().split()[0]) > 1:
984
raise RuntimeError
985
except (ValueError, IndexError, RuntimeError), error:
986
logger.error(u"Unknown protocol version: %s", error)
987
return
988
989
# Note: gnutls.connection.X509Credentials is really a
990
# generic GnuTLS certificate credentials object so long as
991
# no X.509 keys are added to it. Therefore, we can use it
992
# here despite using OpenPGP certificates.
993
994
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
995
# u"+AES-256-CBC", u"+SHA1",
996
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
997
# u"+DHE-DSS"))
998
# Use a fallback default, since this MUST be set.
999
priority = self.server.gnutls_priority
1000
if priority is None:
1001
priority = u"NORMAL"
1002
(gnutls.library.functions
1003
.gnutls_priority_set_direct(session._c_object,
1004
priority, None))
1005
1006
try:
1007
session.handshake()
1008
except gnutls.errors.GNUTLSError, error:
1009
logger.warning(u"Handshake failed: %s", error)
1010
# Do not run session.bye() here: the session is not
1011
# established. Just abandon the request.
1012
return
1013
logger.debug(u"Handshake succeeded")
1014
try:
1015
fpr = self.fingerprint(self.peer_certificate(session))
1016
except (TypeError, gnutls.errors.GNUTLSError), error:
1017
logger.warning(u"Bad certificate: %s", error)
1018
session.bye()
1019
return
1020
logger.debug(u"Fingerprint: %s", fpr)
1021
1022
for c in self.server.clients:
1023
if c.fingerprint == fpr:
1024
client = c
1025
break
1026
else:
1027
ipc.write(u"NOTFOUND %s %s\n"
1028
% (fpr, unicode(self.client_address)))
1029
session.bye()
1030
return
1031
# Have to check if client.still_valid(), since it is
1032
# possible that the client timed out while establishing
1033
# the GnuTLS session.
1034
if not client.still_valid():
1035
ipc.write(u"INVALID %s\n" % client.name)
1036
session.bye()
1037
return
1038
ipc.write(u"SENDING %s\n" % client.name)
1039
sent_size = 0
1040
while sent_size < len(client.secret):
1041
sent = session.send(client.secret[sent_size:])
1042
logger.debug(u"Sent: %d, remaining: %d",
1043
sent, len(client.secret)
1044
- (sent_size + sent))
1045
sent_size += sent
1046
session.bye()
1047
1048
@staticmethod
1049
def peer_certificate(session):
1050
"Return the peer's OpenPGP certificate as a bytestring"
1051
# If not an OpenPGP certificate...
1052
if (gnutls.library.functions
1053
.gnutls_certificate_type_get(session._c_object)
1054
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1055
# ...do the normal thing
1056
return session.peer_certificate
1057
list_size = ctypes.c_uint(1)
1058
cert_list = (gnutls.library.functions
1059
.gnutls_certificate_get_peers
1060
(session._c_object, ctypes.byref(list_size)))
1061
if not bool(cert_list) and list_size.value != 0:
1062
raise gnutls.errors.GNUTLSError(u"error getting peer"
1063
u" certificate")
1064
if list_size.value == 0:
1065
return None
1066
cert = cert_list[0]
1067
return ctypes.string_at(cert.data, cert.size)
1068
1069
@staticmethod
1070
def fingerprint(openpgp):
1071
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1072
# New GnuTLS "datum" with the OpenPGP public key
1073
datum = (gnutls.library.types
1074
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1075
ctypes.POINTER
1076
(ctypes.c_ubyte)),
1077
ctypes.c_uint(len(openpgp))))
1078
# New empty GnuTLS certificate
1079
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1080
(gnutls.library.functions
1081
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1082
# Import the OpenPGP public key into the certificate
1083
(gnutls.library.functions
1084
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1085
gnutls.library.constants
1086
.GNUTLS_OPENPGP_FMT_RAW))
1087
# Verify the self signature in the key
1088
crtverify = ctypes.c_uint()
1089
(gnutls.library.functions
1090
.gnutls_openpgp_crt_verify_self(crt, 0,
1091
ctypes.byref(crtverify)))
1092
if crtverify.value != 0:
1093
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1094
raise (gnutls.errors.CertificateSecurityError
1095
(u"Verify failed"))
1096
# New buffer for the fingerprint
1097
buf = ctypes.create_string_buffer(20)
1098
buf_len = ctypes.c_size_t()
1099
# Get the fingerprint from the certificate into the buffer
1100
(gnutls.library.functions
1101
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1102
ctypes.byref(buf_len)))
1103
# Deinit the certificate
1104
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1105
# Convert the buffer to a Python bytestring
1106
fpr = ctypes.string_at(buf, buf_len.value)
1107
# Convert the bytestring to hexadecimal notation
1108
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
1109
return hex_fpr
1110
1111
1112
class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):
1113
"""Like socketserver.ForkingMixIn, but also pass a pipe."""
1114
def process_request(self, request, client_address):
1115
"""Overrides and wraps the original process_request().
1116
1117
This function creates a new pipe in self.pipe
1118
"""
1119
self.pipe = os.pipe()
1120
super(ForkingMixInWithPipe,
1121
self).process_request(request, client_address)
1122
os.close(self.pipe[1]) # close write end
1123
self.add_pipe(self.pipe[0])
1124
def add_pipe(self, pipe):
1125
"""Dummy function; override as necessary"""
1126
os.close(pipe)
1127
1128
1129
class IPv6_TCPServer(ForkingMixInWithPipe,
1130
socketserver.TCPServer, object):
1131
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
1132
742
1133
Attributes:
743
settings: Server settings
744
clients: Set() of Client objects
745
1134
enabled: Boolean; whether this server is activated yet
1135
interface: None or a network interface name (string)
1136
use_ipv6: Boolean; to use IPv6 or not
746
1137
"""
747
address_family = socket.AF_INET6
748
def __init__(self, *args, **kwargs):
749
if "settings" in kwargs:
750
self.settings = kwargs["settings"]
751
del kwargs["settings"]
752
if "clients" in kwargs:
753
self.clients = kwargs["clients"]
754
del kwargs["clients"]
755
self.enabled = False
756
super(IPv6_TCPServer, self).__init__(*args, **kwargs)
1138
def __init__(self, server_address, RequestHandlerClass,
1139
interface=None, use_ipv6=True):
1140
self.interface = interface
1141
if use_ipv6:
1142
self.address_family = socket.AF_INET6
1143
socketserver.TCPServer.__init__(self, server_address,
1144
RequestHandlerClass)
757
1145
def server_bind(self):
758
1146
"""This overrides the normal server_bind() function
759
1147
to bind to an interface if one was specified, and also NOT to
760
1148
bind to an address or port if they were not specified."""
761
if self.settings["interface"]:
762
# 25 is from /usr/include/asm-i486/socket.h
763
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
764
try:
765
self.socket.setsockopt(socket.SOL_SOCKET,
766
SO_BINDTODEVICE,
767
self.settings["interface"])
768
except socket.error, error:
769
if error[0] == errno.EPERM:
770
logger.error(u"No permission to"
771
u" bind to interface %s",
772
self.settings["interface"])
773
else:
774
raise
1149
if self.interface is not None:
1150
if SO_BINDTODEVICE is None:
1151
logger.error(u"SO_BINDTODEVICE does not exist;"
1152
u" cannot bind to interface %s",
1153
self.interface)
1154
else:
1155
try:
1156
self.socket.setsockopt(socket.SOL_SOCKET,
1157
SO_BINDTODEVICE,
1158
str(self.interface
1159
+ u'\0'))
1160
except socket.error, error:
1161
if error[0] == errno.EPERM:
1162
logger.error(u"No permission to"
1163
u" bind to interface %s",
1164
self.interface)
1165
elif error[0] == errno.ENOPROTOOPT:
1166
logger.error(u"SO_BINDTODEVICE not available;"
1167
u" cannot bind to interface %s",
1168
self.interface)
1169
else:
1170
raise
775
1171
# Only bind(2) the socket if we really need to.
776
1172
if self.server_address[0] or self.server_address[1]:
777
1173
if not self.server_address[0]:
778
in6addr_any = "::"
779
self.server_address = (in6addr_any,
1174
if self.address_family == socket.AF_INET6:
1175
any_address = u"::" # in6addr_any
1176
else:
1177
any_address = socket.INADDR_ANY
1178
self.server_address = (any_address,
780
1179
self.server_address[1])
781
1180
elif not self.server_address[1]:
782
1181
self.server_address = (self.server_address[0],
783
1182
0)
784
# if self.settings["interface"]:
1183
# if self.interface:
785
1184
# self.server_address = (self.server_address[0],
786
1185
# 0, # port
787
1186
# 0, # flowinfo
788
1187
# if_nametoindex
789
# (self.settings
790
# ["interface"]))
791
return super(IPv6_TCPServer, self).server_bind()
1188
# (self.interface))
1189
return socketserver.TCPServer.server_bind(self)
1190
1191
1192
class MandosServer(IPv6_TCPServer):
1193
"""Mandos server.
1194
1195
Attributes:
1196
clients: set of Client objects
1197
gnutls_priority GnuTLS priority string
1198
use_dbus: Boolean; to emit D-Bus signals or not
1199
1200
Assumes a gobject.MainLoop event loop.
1201
"""
1202
def __init__(self, server_address, RequestHandlerClass,
1203
interface=None, use_ipv6=True, clients=None,
1204
gnutls_priority=None, use_dbus=True):
1205
self.enabled = False
1206
self.clients = clients
1207
if self.clients is None:
1208
self.clients = set()
1209
self.use_dbus = use_dbus
1210
self.gnutls_priority = gnutls_priority
1211
IPv6_TCPServer.__init__(self, server_address,
1212
RequestHandlerClass,
1213
interface = interface,
1214
use_ipv6 = use_ipv6)
792
1215
def server_activate(self):
793
1216
if self.enabled:
794
return super(IPv6_TCPServer, self).server_activate()
1217
return socketserver.TCPServer.server_activate(self)
795
1218
def enable(self):
796
1219
self.enabled = True
1220
def add_pipe(self, pipe):
1221
# Call "handle_ipc" for both data and EOF events
1222
gobject.io_add_watch(pipe, gobject.IO_IN | gobject.IO_HUP,
1223
self.handle_ipc)
1224
def handle_ipc(self, source, condition, file_objects={}):
1225
condition_names = {
1226
gobject.IO_IN: u"IN", # There is data to read.
1227
gobject.IO_OUT: u"OUT", # Data can be written (without
1228
# blocking).
1229
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1230
gobject.IO_ERR: u"ERR", # Error condition.
1231
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1232
# broken, usually for pipes and
1233
# sockets).
1234
}
1235
conditions_string = ' | '.join(name
1236
for cond, name in
1237
condition_names.iteritems()
1238
if cond & condition)
1239
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1240
conditions_string)
1241
1242
# Turn the pipe file descriptor into a Python file object
1243
if source not in file_objects:
1244
file_objects[source] = os.fdopen(source, u"r", 1)
1245
1246
# Read a line from the file object
1247
cmdline = file_objects[source].readline()
1248
if not cmdline: # Empty line means end of file
1249
# close the IPC pipe
1250
file_objects[source].close()
1251
del file_objects[source]
1252
1253
# Stop calling this function
1254
return False
1255
1256
logger.debug(u"IPC command: %r", cmdline)
1257
1258
# Parse and act on command
1259
cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)
1260
1261
if cmd == u"NOTFOUND":
1262
logger.warning(u"Client not found for fingerprint: %s",
1263
args)
1264
if self.use_dbus:
1265
# Emit D-Bus signal
1266
mandos_dbus_service.ClientNotFound(args)
1267
elif cmd == u"INVALID":
1268
for client in self.clients:
1269
if client.name == args:
1270
logger.warning(u"Client %s is invalid", args)
1271
if self.use_dbus:
1272
# Emit D-Bus signal
1273
client.Rejected()
1274
break
1275
else:
1276
logger.error(u"Unknown client %s is invalid", args)
1277
elif cmd == u"SENDING":
1278
for client in self.clients:
1279
if client.name == args:
1280
logger.info(u"Sending secret to %s", client.name)
1281
client.checked_ok()
1282
if self.use_dbus:
1283
# Emit D-Bus signal
1284
client.ReceivedSecret()
1285
break
1286
else:
1287
logger.error(u"Sending secret to unknown client %s",
1288
args)
1289
else:
1290
logger.error(u"Unknown IPC command: %r", cmdline)
1291
1292
# Keep calling this function
1293
return True
797
1294
798
1295
799
1296
def string_to_delta(interval):
800
1297
"""Parse a string and return a datetime.timedelta
801
1298
802
>>> string_to_delta('7d')
1299
>>> string_to_delta(u'7d')
803
1300
datetime.timedelta(7)
804
>>> string_to_delta('60s')
1301
>>> string_to_delta(u'60s')
805
1302
datetime.timedelta(0, 60)
806
>>> string_to_delta('60m')
1303
>>> string_to_delta(u'60m')
807
1304
datetime.timedelta(0, 3600)
808
>>> string_to_delta('24h')
1305
>>> string_to_delta(u'24h')
809
1306
datetime.timedelta(1)
810
1307
>>> string_to_delta(u'1w')
811
1308
datetime.timedelta(7)
812
>>> string_to_delta('5m 30s')
1309
>>> string_to_delta(u'5m 30s')
813
1310
datetime.timedelta(0, 330)
814
1311
"""
815
1312
timevalue = datetime.timedelta(0)
835
1332
return timevalue
836
1333
837
1334
838
def server_state_changed(state):
839
"""Derived from the Avahi example code"""
840
if state == avahi.SERVER_COLLISION:
841
logger.error(u"Zeroconf server name collision")
842
service.remove()
843
elif state == avahi.SERVER_RUNNING:
844
service.add()
845
846
847
def entry_group_state_changed(state, error):
848
"""Derived from the Avahi example code"""
849
logger.debug(u"Avahi state change: %i", state)
850
851
if state == avahi.ENTRY_GROUP_ESTABLISHED:
852
logger.debug(u"Zeroconf service established.")
853
elif state == avahi.ENTRY_GROUP_COLLISION:
854
logger.warning(u"Zeroconf service name collision.")
855
service.rename()
856
elif state == avahi.ENTRY_GROUP_FAILURE:
857
logger.critical(u"Avahi: Error in group state changed %s",
858
unicode(error))
859
raise AvahiGroupError(u"State changed: %s" % unicode(error))
860
861
1335
def if_nametoindex(interface):
862
"""Call the C function if_nametoindex(), or equivalent"""
1336
"""Call the C function if_nametoindex(), or equivalent
1337
1338
Note: This function cannot accept a unicode string."""
863
1339
global if_nametoindex
864
1340
try:
865
1341
if_nametoindex = (ctypes.cdll.LoadLibrary
866
(ctypes.util.find_library("c"))
1342
(ctypes.util.find_library(u"c"))
867
1343
.if_nametoindex)
868
1344
except (OSError, AttributeError):
869
if "struct" not in sys.modules:
870
import struct
871
if "fcntl" not in sys.modules:
872
import fcntl
1345
logger.warning(u"Doing if_nametoindex the hard way")
873
1346
def if_nametoindex(interface):
874
1347
"Get an interface index the hard way, i.e. using fcntl()"
875
1348
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
876
1349
with closing(socket.socket()) as s:
877
1350
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
878
struct.pack("16s16x", interface))
879
interface_index = struct.unpack("I", ifreq[16:20])[0]
1351
struct.pack(str(u"16s16x"),
1352
interface))
1353
interface_index = struct.unpack(str(u"I"),
1354
ifreq[16:20])[0]
880
1355
return interface_index
881
1356
return if_nametoindex(interface)
882
1357
883
1358
884
1359
def daemon(nochdir = False, noclose = False):
885
1360
"""See daemon(3). Standard BSD Unix function.
1361
886
1362
This should really exist as os.daemon, but it doesn't (yet)."""
887
1363
if os.fork():
888
1364
sys.exit()
889
1365
os.setsid()
890
1366
if not nochdir:
891
os.chdir("/")
1367
os.chdir(u"/")
892
1368
if os.fork():
893
1369
sys.exit()
894
1370
if not noclose:
896
1372
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
897
1373
if not stat.S_ISCHR(os.fstat(null).st_mode):
898
1374
raise OSError(errno.ENODEV,
899
"/dev/null not a character device")
1375
u"/dev/null not a character device")
900
1376
os.dup2(null, sys.stdin.fileno())
901
1377
os.dup2(null, sys.stdout.fileno())
902
1378
os.dup2(null, sys.stderr.fileno())
905
1381
906
1382
907
1383
def main():
1384
1385
##################################################################
1386
# Parsing of options, both command line and config file
1387
908
1388
parser = optparse.OptionParser(version = "%%prog %s" % version)
909
parser.add_option("-i", "--interface", type="string",
910
metavar="IF", help="Bind to interface IF")
911
parser.add_option("-a", "--address", type="string",
912
help="Address to listen for requests on")
913
parser.add_option("-p", "--port", type="int",
914
help="Port number to receive requests on")
915
parser.add_option("--check", action="store_true",
916
help="Run self-test")
917
parser.add_option("--debug", action="store_true",
918
help="Debug mode; run in foreground and log to"
919
" terminal")
920
parser.add_option("--priority", type="string", help="GnuTLS"
921
" priority string (see GnuTLS documentation)")
922
parser.add_option("--servicename", type="string", metavar="NAME",
923
help="Zeroconf service name")
924
parser.add_option("--configdir", type="string",
925
default="/etc/mandos", metavar="DIR",
926
help="Directory to search for configuration"
927
" files")
928
parser.add_option("--no-dbus", action="store_false",
929
dest="use_dbus",
930
help="Do not provide D-Bus system bus"
931
" interface")
1389
parser.add_option("-i", u"--interface", type=u"string",
1390
metavar="IF", help=u"Bind to interface IF")
1391
parser.add_option("-a", u"--address", type=u"string",
1392
help=u"Address to listen for requests on")
1393
parser.add_option("-p", u"--port", type=u"int",
1394
help=u"Port number to receive requests on")
1395
parser.add_option("--check", action=u"store_true",
1396
help=u"Run self-test")
1397
parser.add_option("--debug", action=u"store_true",
1398
help=u"Debug mode; run in foreground and log to"
1399
u" terminal")
1400
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1401
u" priority string (see GnuTLS documentation)")
1402
parser.add_option("--servicename", type=u"string",
1403
metavar=u"NAME", help=u"Zeroconf service name")
1404
parser.add_option("--configdir", type=u"string",
1405
default=u"/etc/mandos", metavar=u"DIR",
1406
help=u"Directory to search for configuration"
1407
u" files")
1408
parser.add_option("--no-dbus", action=u"store_false",
1409
dest=u"use_dbus", help=u"Do not provide D-Bus"
1410
u" system bus interface")
1411
parser.add_option("--no-ipv6", action=u"store_false",
1412
dest=u"use_ipv6", help=u"Do not use IPv6")
932
1413
options = parser.parse_args()[0]
933
1414
934
1415
if options.check:
937
1418
sys.exit()
938
1419
939
1420
# Default values for config file for server-global settings
940
server_defaults = { "interface": "",
941
"address": "",
942
"port": "",
943
"debug": "False",
944
"priority":
945
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
946
"servicename": "Mandos",
947
"use_dbus": "True",
1421
server_defaults = { u"interface": u"",
1422
u"address": u"",
1423
u"port": u"",
1424
u"debug": u"False",
1425
u"priority":
1426
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1427
u"servicename": u"Mandos",
1428
u"use_dbus": u"True",
1429
u"use_ipv6": u"True",
948
1430
}
949
1431
950
1432
# Parse config file for server-global settings
951
server_config = ConfigParser.SafeConfigParser(server_defaults)
1433
server_config = configparser.SafeConfigParser(server_defaults)
952
1434
del server_defaults
953
server_config.read(os.path.join(options.configdir, "mandos.conf"))
1435
server_config.read(os.path.join(options.configdir,
1436
u"mandos.conf"))
954
1437
# Convert the SafeConfigParser object to a dict
955
1438
server_settings = server_config.defaults()
956
1439
# Use the appropriate methods on the non-string config options
957
server_settings["debug"] = server_config.getboolean("DEFAULT",
958
"debug")
959
server_settings["use_dbus"] = server_config.getboolean("DEFAULT",
960
"use_dbus")
1440
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1441
server_settings[option] = server_config.getboolean(u"DEFAULT",
1442
option)
961
1443
if server_settings["port"]:
962
server_settings["port"] = server_config.getint("DEFAULT",
963
"port")
1444
server_settings["port"] = server_config.getint(u"DEFAULT",
1445
u"port")
964
1446
del server_config
965
1447
966
1448
# Override the settings from the config file with command line
967
1449
# options, if set.
968
for option in ("interface", "address", "port", "debug",
969
"priority", "servicename", "configdir",
970
"use_dbus"):
1450
for option in (u"interface", u"address", u"port", u"debug",
1451
u"priority", u"servicename", u"configdir",
1452
u"use_dbus", u"use_ipv6"):
971
1453
value = getattr(options, option)
972
1454
if value is not None:
973
1455
server_settings[option] = value
974
1456
del options
1457
# Force all strings to be unicode
1458
for option in server_settings.keys():
1459
if type(server_settings[option]) is str:
1460
server_settings[option] = unicode(server_settings[option])
975
1461
# Now we have our good server settings in "server_settings"
976
1462
1463
##################################################################
1464
977
1465
# For convenience
978
debug = server_settings["debug"]
979
use_dbus = server_settings["use_dbus"]
1466
debug = server_settings[u"debug"]
1467
use_dbus = server_settings[u"use_dbus"]
1468
use_ipv6 = server_settings[u"use_ipv6"]
980
1469
981
1470
if not debug:
982
1471
syslogger.setLevel(logging.WARNING)
983
1472
console.setLevel(logging.WARNING)
984
1473
985
if server_settings["servicename"] != "Mandos":
1474
if server_settings[u"servicename"] != u"Mandos":
986
1475
syslogger.setFormatter(logging.Formatter
987
('Mandos (%s): %%(levelname)s:'
988
' %%(message)s'
989
% server_settings["servicename"]))
1476
(u'Mandos (%s) [%%(process)d]:'
1477
u' %%(levelname)s: %%(message)s'
1478
% server_settings[u"servicename"]))
990
1479
991
1480
# Parse config file with clients
992
client_defaults = { "timeout": "1h",
993
"interval": "5m",
994
"checker": "fping -q -- %%(host)s",
995
"host": "",
1481
client_defaults = { u"timeout": u"1h",
1482
u"interval": u"5m",
1483
u"checker": u"fping -q -- %%(host)s",
1484
u"host": u"",
996
1485
}
997
client_config = ConfigParser.SafeConfigParser(client_defaults)
998
client_config.read(os.path.join(server_settings["configdir"],
999
"clients.conf"))
1000
1001
clients = Set()
1002
tcp_server = IPv6_TCPServer((server_settings["address"],
1003
server_settings["port"]),
1004
TCP_handler,
1005
settings=server_settings,
1006
clients=clients)
1007
pidfilename = "/var/run/mandos.pid"
1486
client_config = configparser.SafeConfigParser(client_defaults)
1487
client_config.read(os.path.join(server_settings[u"configdir"],
1488
u"clients.conf"))
1489
1490
global mandos_dbus_service
1491
mandos_dbus_service = None
1492
1493
tcp_server = MandosServer((server_settings[u"address"],
1494
server_settings[u"port"]),
1495
ClientHandler,
1496
interface=server_settings[u"interface"],
1497
use_ipv6=use_ipv6,
1498
gnutls_priority=
1499
server_settings[u"priority"],
1500
use_dbus=use_dbus)
1501
pidfilename = u"/var/run/mandos.pid"
1008
1502
try:
1009
pidfile = open(pidfilename, "w")
1503
pidfile = open(pidfilename, u"w")
1010
1504
except IOError:
1011
logger.error("Could not open file %r", pidfilename)
1505
logger.error(u"Could not open file %r", pidfilename)
1012
1506
1013
1507
try:
1014
uid = pwd.getpwnam("_mandos").pw_uid
1015
gid = pwd.getpwnam("_mandos").pw_gid
1508
uid = pwd.getpwnam(u"_mandos").pw_uid
1509
gid = pwd.getpwnam(u"_mandos").pw_gid
1016
1510
except KeyError:
1017
1511
try:
1018
uid = pwd.getpwnam("mandos").pw_uid
1019
gid = pwd.getpwnam("mandos").pw_gid
1512
uid = pwd.getpwnam(u"mandos").pw_uid
1513
gid = pwd.getpwnam(u"mandos").pw_gid
1020
1514
except KeyError:
1021
1515
try:
1022
uid = pwd.getpwnam("nobody").pw_uid
1023
gid = pwd.getpwnam("nogroup").pw_gid
1516
uid = pwd.getpwnam(u"nobody").pw_uid
1517
gid = pwd.getpwnam(u"nobody").pw_gid
1024
1518
except KeyError:
1025
1519
uid = 65534
1026
1520
gid = 65534
1039
1533
1040
1534
@gnutls.library.types.gnutls_log_func
1041
1535
def debug_gnutls(level, string):
1042
logger.debug("GnuTLS: %s", string[:-1])
1536
logger.debug(u"GnuTLS: %s", string[:-1])
1043
1537
1044
1538
(gnutls.library.functions
1045
1539
.gnutls_global_set_log_function(debug_gnutls))
1046
1540
1047
global service
1048
service = AvahiService(name = server_settings["servicename"],
1049
servicetype = "_mandos._tcp", )
1050
if server_settings["interface"]:
1051
service.interface = (if_nametoindex
1052
(server_settings["interface"]))
1053
1054
1541
global main_loop
1055
global bus
1056
global server
1057
1542
# From the Avahi example code
1058
1543
DBusGMainLoop(set_as_default=True )
1059
1544
main_loop = gobject.MainLoop()
1060
1545
bus = dbus.SystemBus()
1061
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1062
avahi.DBUS_PATH_SERVER),
1063
avahi.DBUS_INTERFACE_SERVER)
1064
1546
# End of Avahi example code
1065
1547
if use_dbus:
1066
1548
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
1549
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1550
service = AvahiService(name = server_settings[u"servicename"],
1551
servicetype = u"_mandos._tcp",
1552
protocol = protocol, bus = bus)
1553
if server_settings["interface"]:
1554
service.interface = (if_nametoindex
1555
(str(server_settings[u"interface"])))
1067
1556
1068
clients.update(Set(Client(name = section,
1069
config
1070
= dict(client_config.items(section)),
1071
use_dbus = use_dbus)
1072
for section in client_config.sections()))
1073
if not clients:
1557
client_class = Client
1558
if use_dbus:
1559
client_class = functools.partial(ClientDBus, bus = bus)
1560
tcp_server.clients.update(set(
1561
client_class(name = section,
1562
config= dict(client_config.items(section)))
1563
for section in client_config.sections()))
1564
if not tcp_server.clients:
1074
1565
logger.warning(u"No clients defined")
1075
1566
1076
1567
if debug:
1086
1577
daemon()
1087
1578
1088
1579
try:
1089
pid = os.getpid()
1090
pidfile.write(str(pid) + "\n")
1091
pidfile.close()
1580
with closing(pidfile):
1581
pid = os.getpid()
1582
pidfile.write(str(pid) + "\n")
1092
1583
del pidfile
1093
1584
except IOError:
1094
1585
logger.error(u"Could not write to file %r with PID %d",
1100
1591
1101
1592
def cleanup():
1102
1593
"Cleanup function; run on exit"
1103
global group
1104
# From the Avahi example code
1105
if not group is None:
1106
group.Free()
1107
group = None
1108
# End of Avahi example code
1594
service.cleanup()
1109
1595
1110
while clients:
1111
client = clients.pop()
1596
while tcp_server.clients:
1597
client = tcp_server.clients.pop()
1112
1598
client.disable_hook = None
1113
1599
client.disable()
1114
1600
1120
1606
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1121
1607
1122
1608
if use_dbus:
1123
class MandosServer(dbus.service.Object):
1609
class MandosDBusService(dbus.service.Object):
1124
1610
"""A D-Bus proxy object"""
1125
1611
def __init__(self):
1126
dbus.service.Object.__init__(self, bus, "/")
1612
dbus.service.Object.__init__(self, bus, u"/")
1127
1613
_interface = u"se.bsnet.fukt.Mandos"
1128
1614
1129
@dbus.service.signal(_interface, signature="oa{sv}")
1615
@dbus.service.signal(_interface, signature=u"oa{sv}")
1130
1616
def ClientAdded(self, objpath, properties):
1131
1617
"D-Bus signal"
1132
1618
pass
1133
1619
1134
@dbus.service.signal(_interface, signature="os")
1620
@dbus.service.signal(_interface, signature=u"s")
1621
def ClientNotFound(self, fingerprint):
1622
"D-Bus signal"
1623
pass
1624
1625
@dbus.service.signal(_interface, signature=u"os")
1135
1626
def ClientRemoved(self, objpath, name):
1136
1627
"D-Bus signal"
1137
1628
pass
1138
1629
1139
@dbus.service.method(_interface, out_signature="ao")
1630
@dbus.service.method(_interface, out_signature=u"ao")
1140
1631
def GetAllClients(self):
1141
1632
"D-Bus method"
1142
return dbus.Array(c.dbus_object_path for c in clients)
1633
return dbus.Array(c.dbus_object_path
1634
for c in tcp_server.clients)
1143
1635
1144
@dbus.service.method(_interface, out_signature="a{oa{sv}}")
1636
@dbus.service.method(_interface,
1637
out_signature=u"a{oa{sv}}")
1145
1638
def GetAllClientsWithProperties(self):
1146
1639
"D-Bus method"
1147
1640
return dbus.Dictionary(
1148
((c.dbus_object_path, c.GetAllProperties())
1149
for c in clients),
1150
signature="oa{sv}")
1641
((c.dbus_object_path, c.GetAll(u""))
1642
for c in tcp_server.clients),
1643
signature=u"oa{sv}")
1151
1644
1152
@dbus.service.method(_interface, in_signature="o")
1645
@dbus.service.method(_interface, in_signature=u"o")
1153
1646
def RemoveClient(self, object_path):
1154
1647
"D-Bus method"
1155
for c in clients:
1648
for c in tcp_server.clients:
1156
1649
if c.dbus_object_path == object_path:
1157
clients.remove(c)
1650
tcp_server.clients.remove(c)
1651
c.remove_from_connection()
1158
1652
# Don't signal anything except ClientRemoved
1159
c.use_dbus = False
1160
c.disable()
1653
c.disable(signal=False)
1161
1654
# Emit D-Bus signal
1162
1655
self.ClientRemoved(object_path, c.name)
1163
1656
return
1165
1658
1166
1659
del _interface
1167
1660
1168
mandos_server = MandosServer()
1661
mandos_dbus_service = MandosDBusService()
1169
1662
1170
for client in clients:
1663
for client in tcp_server.clients:
1171
1664
if use_dbus:
1172
1665
# Emit D-Bus signal
1173
mandos_server.ClientAdded(client.dbus_object_path,
1174
client.GetAllProperties())
1666
mandos_dbus_service.ClientAdded(client.dbus_object_path,
1667
client.GetAll(u""))
1175
1668
client.enable()
1176
1669
1177
1670
tcp_server.enable()
1179
1672
1180
1673
# Find out what port we got
1181
1674
service.port = tcp_server.socket.getsockname()[1]
1182
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
1183
u" scope_id %d" % tcp_server.socket.getsockname())
1675
if use_ipv6:
1676
logger.info(u"Now listening on address %r, port %d,"
1677
" flowinfo %d, scope_id %d"
1678
% tcp_server.socket.getsockname())
1679
else: # IPv4
1680
logger.info(u"Now listening on address %r, port %d"
1681
% tcp_server.socket.getsockname())
1184
1682
1185
1683
#service.interface = tcp_server.socket.getsockname()[3]
1186
1684
1187
1685
try:
1188
1686
# From the Avahi example code
1189
server.connect_to_signal("StateChanged", server_state_changed)
1190
1687
try:
1191
server_state_changed(server.GetState())
1688
service.activate()
1192
1689
except dbus.exceptions.DBusException, error:
1193
1690
logger.critical(u"DBusException: %s", error)
1194
1691
sys.exit(1)
1207
1704
except KeyboardInterrupt:
1208
1705
if debug:
1209
1706
print >> sys.stderr
1210
logger.debug("Server received KeyboardInterrupt")
1211
logger.debug("Server exiting")
1707
logger.debug(u"Server received KeyboardInterrupt")
1708
logger.debug(u"Server exiting")
1212
1709
1213
1710
if __name__ == '__main__':
1214
1711
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0