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.67
- compare with another revision
- download diff
- download tarball
- view history from revision 237.2.67
- Committer: Teddy Hogeborn
- Date: 2009-02-09 02:01:13 UTC
- mto: (24.1.133 mandos) (237.4.2 mandos-pipe-ipc) (299.1.1 release) (300.1.1 release) (301.1.1 release)
- mto: This revision was merged to the branch mainline in revision 250.
- Revision ID: teddy@fukt.bsnet.se-20090209020113-726hq380zvp8zt97
Four new interrelated features:
1. Support using a different network interface via both initramfs.conf
(the DEVICE setting) and the kernel command line (sixth field of
the "ip=" option as in Linux' Documentation/nfsroot.txt).
2. Support connecting to a specified Mandos server directly using a
kernel command line option ("mandos=connect:<ADDRESS>:<PORT>").
3. Support connecting directly to an IPv4 address (and port) using the
"--connect" option of mandos-client.
4. Support an empty string to the --interface option to mandos-client.
* Makefile (WARN): Increase strictness by changing to
"-Wstrict-aliasing=1".
* debian/mandos-client.README.Debian (Use the Correct Network
Interface): Changed to refer to initramfs.conf and nfsroot.txt.
(Test the Server): Improve wording.
(Non-local Connection): New section.
* initramfs-tools-script: Obey DEVICE environment variable and setting
from "/conf/initramfs.conf". Also let any
"ip=" kernel command line option override
it. Support new "mandos=connect" option.
Call "configure_networking" to set up IP
address on interface if necessary.
* plugin-runner.conf: Change example.
* plugins.d/mandos-client.c: Some whitespace and comment changes.
(start_mandos_communication): Take an additional argument for
address family, all callers changed.
Connect to an IPv4 address if address
family is AF_INET. Only set IPv6
scope_id for link-local addresses.
(main): Accept empty interface name; this will not bring up any
interface and leave the interface as unspecified. Also do
not restore kernel log level if lowering it failed.
* plugins.d/mandos-client.xml (OPTIONS): Document that the
"--interface" option accepts
an empty string.
(EXAMPLE): Change example IPv6 address to a link-local address.
1. Support using a different network interface via both initramfs.conf
(the DEVICE setting) and the kernel command line (sixth field of
the "ip=" option as in Linux' Documentation/nfsroot.txt).
2. Support connecting to a specified Mandos server directly using a
kernel command line option ("mandos=connect:<ADDRESS>:<PORT>").
3. Support connecting directly to an IPv4 address (and port) using the
"--connect" option of mandos-client.
4. Support an empty string to the --interface option to mandos-client.
* Makefile (WARN): Increase strictness by changing to
"-Wstrict-aliasing=1".
* debian/mandos-client.README.Debian (Use the Correct Network
Interface): Changed to refer to initramfs.conf and nfsroot.txt.
(Test the Server): Improve wording.
(Non-local Connection): New section.
* initramfs-tools-script: Obey DEVICE environment variable and setting
from "/conf/initramfs.conf". Also let any
"ip=" kernel command line option override
it. Support new "mandos=connect" option.
Call "configure_networking" to set up IP
address on interface if necessary.
* plugin-runner.conf: Change example.
* plugins.d/mandos-client.c: Some whitespace and comment changes.
(start_mandos_communication): Take an additional argument for
address family, all callers changed.
Connect to an IPv4 address if address
family is AF_INET. Only set IPv6
scope_id for link-local addresses.
(main): Accept empty interface name; this will not bring up any
interface and leave the interface as unspecified. Also do
not restore kernel log level if lowering it failed.
* plugins.d/mandos-client.xml (OPTIONS): Document that the
"--interface" option accepts
an empty string.
(EXAMPLE): Change example IPv6 address to a link-local address.
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", "remove", "server_state_changed",
10
# "entry_group_state_changed", "cleanup", and "activate" in the
11
# "AvahiService" class, and some lines in "main".
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".
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 as socketserver
36
import 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 as configparser
47
import ConfigParser
48
48
import sys
49
49
import re
50
50
import os
51
51
import signal
52
from sets import Set
52
53
import subprocess
53
54
import atexit
54
55
import stat
55
56
import logging
56
57
import logging.handlers
57
58
import pwd
58
import contextlib
59
import struct
60
import fcntl
61
import functools
62
import cPickle as pickle
63
import multiprocessing
59
from contextlib import closing
64
60
65
61
import dbus
66
62
import dbus.service
69
65
from dbus.mainloop.glib import DBusGMainLoop
70
66
import ctypes
71
67
import ctypes.util
72
import xml.dom.minidom
73
import inspect
74
75
try:
76
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
77
except AttributeError:
78
try:
79
from IN import SO_BINDTODEVICE
80
except ImportError:
81
SO_BINDTODEVICE = None
82
83
84
version = "1.0.14"
85
86
#logger = logging.getLogger(u'mandos')
87
logger = logging.Logger(u'mandos')
68
69
version = "1.0.5"
70
71
logger = logging.Logger('mandos')
88
72
syslogger = (logging.handlers.SysLogHandler
89
73
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
90
74
address = "/dev/log"))
91
75
syslogger.setFormatter(logging.Formatter
92
(u'Mandos [%(process)d]: %(levelname)s:'
93
u' %(message)s'))
76
('Mandos [%(process)d]: %(levelname)s:'
77
' %(message)s'))
94
78
logger.addHandler(syslogger)
95
79
96
80
console = logging.StreamHandler()
97
console.setFormatter(logging.Formatter(u'%(name)s [%(process)d]:'
98
u' %(levelname)s:'
99
u' %(message)s'))
81
console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'
82
' %(levelname)s: %(message)s'))
100
83
logger.addHandler(console)
101
84
102
85
class AvahiError(Exception):
115
98
116
99
class AvahiService(object):
117
100
"""An Avahi (Zeroconf) service.
118
119
101
Attributes:
120
102
interface: integer; avahi.IF_UNSPEC or an interface index.
121
103
Used to optionally bind to the specified interface.
122
name: string; Example: u'Mandos'
123
type: string; Example: u'_mandos._tcp'.
104
name: string; Example: 'Mandos'
105
type: string; Example: '_mandos._tcp'.
124
106
See <http://www.dns-sd.org/ServiceTypes.html>
125
107
port: integer; what port to announce
126
108
TXT: list of strings; TXT record for the service
129
111
max_renames: integer; maximum number of renames
130
112
rename_count: integer; counter so we only rename after collisions
131
113
a sensible number of times
132
group: D-Bus Entry Group
133
server: D-Bus Server
134
bus: dbus.SystemBus()
135
114
"""
136
115
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
137
116
servicetype = None, port = None, TXT = None,
138
domain = u"", host = u"", max_renames = 32768,
139
protocol = avahi.PROTO_UNSPEC, bus = None):
117
domain = "", host = "", max_renames = 32768):
140
118
self.interface = interface
141
119
self.name = name
142
120
self.type = servicetype
146
124
self.host = host
147
125
self.rename_count = 0
148
126
self.max_renames = max_renames
149
self.protocol = protocol
150
self.group = None # our entry group
151
self.server = None
152
self.bus = bus
153
127
def rename(self):
154
128
"""Derived from the Avahi example code"""
155
129
if self.rename_count >= self.max_renames:
157
131
u" after %i retries, exiting.",
158
132
self.rename_count)
159
133
raise AvahiServiceError(u"Too many renames")
160
self.name = unicode(self.server.GetAlternativeServiceName(self.name))
134
self.name = server.GetAlternativeServiceName(self.name)
161
135
logger.info(u"Changing Zeroconf service name to %r ...",
162
self.name)
136
str(self.name))
163
137
syslogger.setFormatter(logging.Formatter
164
(u'Mandos (%s) [%%(process)d]:'
165
u' %%(levelname)s: %%(message)s'
166
% self.name))
138
('Mandos (%s): %%(levelname)s:'
139
' %%(message)s' % self.name))
167
140
self.remove()
168
try:
169
self.add()
170
except dbus.exceptions.DBusException, error:
171
logger.critical(u"DBusException: %s", error)
172
self.cleanup()
173
os._exit(1)
141
self.add()
174
142
self.rename_count += 1
175
143
def remove(self):
176
144
"""Derived from the Avahi example code"""
177
if self.group is not None:
178
self.group.Reset()
145
if group is not None:
146
group.Reset()
179
147
def add(self):
180
148
"""Derived from the Avahi example code"""
181
if self.group is None:
182
self.group = dbus.Interface(
183
self.bus.get_object(avahi.DBUS_NAME,
184
self.server.EntryGroupNew()),
185
avahi.DBUS_INTERFACE_ENTRY_GROUP)
186
self.group.connect_to_signal('StateChanged',
187
self
188
.entry_group_state_changed)
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)
189
157
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
190
self.name, self.type)
191
self.group.AddService(
192
self.interface,
193
self.protocol,
194
dbus.UInt32(0), # flags
195
self.name, self.type,
196
self.domain, self.host,
197
dbus.UInt16(self.port),
198
avahi.string_array_to_txt_array(self.TXT))
199
self.group.Commit()
200
def entry_group_state_changed(self, state, error):
201
"""Derived from the Avahi example code"""
202
logger.debug(u"Avahi entry group state change: %i", state)
203
204
if state == avahi.ENTRY_GROUP_ESTABLISHED:
205
logger.debug(u"Zeroconf service established.")
206
elif state == avahi.ENTRY_GROUP_COLLISION:
207
logger.warning(u"Zeroconf service name collision.")
208
self.rename()
209
elif state == avahi.ENTRY_GROUP_FAILURE:
210
logger.critical(u"Avahi: Error in group state changed %s",
211
unicode(error))
212
raise AvahiGroupError(u"State changed: %s"
213
% unicode(error))
214
def cleanup(self):
215
"""Derived from the Avahi example code"""
216
if self.group is not None:
217
self.group.Free()
218
self.group = None
219
def server_state_changed(self, state):
220
"""Derived from the Avahi example code"""
221
logger.debug(u"Avahi server state change: %i", state)
222
if state == avahi.SERVER_COLLISION:
223
logger.error(u"Zeroconf server name collision")
224
self.remove()
225
elif state == avahi.SERVER_RUNNING:
226
self.add()
227
def activate(self):
228
"""Derived from the Avahi example code"""
229
if self.server is None:
230
self.server = dbus.Interface(
231
self.bus.get_object(avahi.DBUS_NAME,
232
avahi.DBUS_PATH_SERVER),
233
avahi.DBUS_INTERFACE_SERVER)
234
self.server.connect_to_signal(u"StateChanged",
235
self.server_state_changed)
236
self.server_state_changed(self.server.GetState())
237
238
239
class Client(object):
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):
240
180
"""A representation of a client host served by this server.
241
242
181
Attributes:
243
_approved: bool(); 'None' if not yet approved/disapproved
244
approval_delay: datetime.timedelta(); Time to wait for approval
245
approval_duration: datetime.timedelta(); Duration of one approval
182
name: string; from the config file, used in log messages and
183
D-Bus identifiers
184
fingerprint: string (40 or 32 hexadecimal digits); used to
185
uniquely identify the client
186
secret: bytestring; sent verbatim (over TLS) to client
187
host: string; available for use by the checker command
188
created: datetime.datetime(); (UTC) object creation
189
last_enabled: datetime.datetime(); (UTC)
190
enabled: bool()
191
last_checked_ok: datetime.datetime(); (UTC) or None
192
timeout: datetime.timedelta(); How long from last_checked_ok
193
until this client is invalid
194
interval: datetime.timedelta(); How often to start a new checker
195
disable_hook: If set, called by disable() as disable_hook(self)
246
196
checker: subprocess.Popen(); a running checker process used
247
197
to see if the client lives.
248
198
'None' if no process is running.
199
checker_initiator_tag: a gobject event source tag, or None
200
disable_initiator_tag: - '' -
249
201
checker_callback_tag: - '' -
250
checker_command: string; External command which is run to check
251
if client lives. %() expansions are done at
202
checker_command: string; External command which is run to check if
203
client lives. %() expansions are done at
252
204
runtime with vars(self) as dict, so that for
253
205
instance %(name)s can be used in the command.
254
checker_initiator_tag: a gobject event source tag, or None
255
created: datetime.datetime(); (UTC) object creation
256
current_checker_command: string; current running checker_command
257
disable_hook: If set, called by disable() as disable_hook(self)
258
disable_initiator_tag: - '' -
259
enabled: bool()
260
fingerprint: string (40 or 32 hexadecimal digits); used to
261
uniquely identify the client
262
host: string; available for use by the checker command
263
interval: datetime.timedelta(); How often to start a new checker
264
last_checked_ok: datetime.datetime(); (UTC) or None
265
last_enabled: datetime.datetime(); (UTC)
266
name: string; from the config file, used in log messages and
267
D-Bus identifiers
268
secret: bytestring; sent verbatim (over TLS) to client
269
timeout: datetime.timedelta(); How long from last_checked_ok
270
until this client is disabled
271
runtime_expansions: Allowed attributes for runtime expansion.
206
use_dbus: bool(); Whether to provide D-Bus interface and signals
207
dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus
272
208
"""
273
274
runtime_expansions = (u"approval_delay", u"approval_duration",
275
u"created", u"enabled", u"fingerprint",
276
u"host", u"interval", u"last_checked_ok",
277
u"last_enabled", u"name", u"timeout")
278
279
@staticmethod
280
def _timedelta_to_milliseconds(td):
281
"Convert a datetime.timedelta() to milliseconds"
282
return ((td.days * 24 * 60 * 60 * 1000)
283
+ (td.seconds * 1000)
284
+ (td.microseconds // 1000))
285
286
209
def timeout_milliseconds(self):
287
210
"Return the 'timeout' attribute in milliseconds"
288
return self._timedelta_to_milliseconds(self.timeout)
211
return ((self.timeout.days * 24 * 60 * 60 * 1000)
212
+ (self.timeout.seconds * 1000)
213
+ (self.timeout.microseconds // 1000))
289
214
290
215
def interval_milliseconds(self):
291
216
"Return the 'interval' attribute in milliseconds"
292
return self._timedelta_to_milliseconds(self.interval)
293
294
def approval_delay_milliseconds(self):
295
return self._timedelta_to_milliseconds(self.approval_delay)
217
return ((self.interval.days * 24 * 60 * 60 * 1000)
218
+ (self.interval.seconds * 1000)
219
+ (self.interval.microseconds // 1000))
296
220
297
def __init__(self, name = None, disable_hook=None, config=None):
221
def __init__(self, name = None, disable_hook=None, config=None,
222
use_dbus=True):
298
223
"""Note: the 'checker' key in 'config' sets the
299
224
'checker_command' attribute and *not* the 'checker'
300
225
attribute."""
302
227
if config is None:
303
228
config = {}
304
229
logger.debug(u"Creating client %r", self.name)
230
self.use_dbus = False # During __init__
305
231
# Uppercase and remove spaces from fingerprint for later
306
232
# comparison purposes with return value from the fingerprint()
307
233
# function
308
self.fingerprint = (config[u"fingerprint"].upper()
234
self.fingerprint = (config["fingerprint"].upper()
309
235
.replace(u" ", u""))
310
236
logger.debug(u" Fingerprint: %s", self.fingerprint)
311
if u"secret" in config:
312
self.secret = config[u"secret"].decode(u"base64")
313
elif u"secfile" in config:
314
with open(os.path.expanduser(os.path.expandvars
315
(config[u"secfile"])),
316
"rb") as secfile:
237
if "secret" in config:
238
self.secret = config["secret"].decode(u"base64")
239
elif "secfile" in config:
240
with closing(open(os.path.expanduser
241
(os.path.expandvars
242
(config["secfile"])))) as secfile:
317
243
self.secret = secfile.read()
318
244
else:
319
245
raise TypeError(u"No secret or secfile for client %s"
320
246
% self.name)
321
self.host = config.get(u"host", u"")
247
self.host = config.get("host", "")
322
248
self.created = datetime.datetime.utcnow()
323
249
self.enabled = False
324
250
self.last_enabled = None
325
251
self.last_checked_ok = None
326
self.timeout = string_to_delta(config[u"timeout"])
327
self.interval = string_to_delta(config[u"interval"])
252
self.timeout = string_to_delta(config["timeout"])
253
self.interval = string_to_delta(config["interval"])
328
254
self.disable_hook = disable_hook
329
255
self.checker = None
330
256
self.checker_initiator_tag = None
331
257
self.disable_initiator_tag = None
332
258
self.checker_callback_tag = None
333
self.checker_command = config[u"checker"]
334
self.current_checker_command = None
259
self.checker_command = config["checker"]
335
260
self.last_connect = None
336
self._approved = None
337
self.approved_by_default = config.get(u"approved_by_default",
338
True)
339
self.approvals_pending = 0
340
self.approval_delay = string_to_delta(
341
config[u"approval_delay"])
342
self.approval_duration = string_to_delta(
343
config[u"approval_duration"])
344
self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
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)
345
270
346
def send_changedstate(self):
347
self.changedstate.acquire()
348
self.changedstate.notify_all()
349
self.changedstate.release()
350
351
271
def enable(self):
352
272
"""Start this client's checker and timeout hooks"""
353
if getattr(self, u"enabled", False):
354
# Already enabled
355
return
356
self.send_changedstate()
357
273
self.last_enabled = datetime.datetime.utcnow()
358
274
# Schedule a new checker to be started an 'interval' from now,
359
275
# and every interval from then on.
360
276
self.checker_initiator_tag = (gobject.timeout_add
361
277
(self.interval_milliseconds(),
362
278
self.start_checker))
279
# Also start a new checker *right now*.
280
self.start_checker()
363
281
# Schedule a disable() when 'timeout' has passed
364
282
self.disable_initiator_tag = (gobject.timeout_add
365
283
(self.timeout_milliseconds(),
366
284
self.disable))
367
285
self.enabled = True
368
# Also start a new checker *right now*.
369
self.start_checker()
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)))
370
293
371
def disable(self, quiet=True):
294
def disable(self):
372
295
"""Disable this client."""
373
296
if not getattr(self, "enabled", False):
374
297
return False
375
if not quiet:
376
self.send_changedstate()
377
if not quiet:
378
logger.info(u"Disabling client %s", self.name)
379
if getattr(self, u"disable_initiator_tag", False):
298
logger.info(u"Disabling client %s", self.name)
299
if getattr(self, "disable_initiator_tag", False):
380
300
gobject.source_remove(self.disable_initiator_tag)
381
301
self.disable_initiator_tag = None
382
if getattr(self, u"checker_initiator_tag", False):
302
if getattr(self, "checker_initiator_tag", False):
383
303
gobject.source_remove(self.checker_initiator_tag)
384
304
self.checker_initiator_tag = None
385
305
self.stop_checker()
386
306
if self.disable_hook:
387
307
self.disable_hook(self)
388
308
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))
389
313
# Do not run this again if called by a gobject.timeout_add
390
314
return False
391
315
397
321
"""The checker has completed, so take appropriate actions."""
398
322
self.checker_callback_tag = None
399
323
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))
400
328
if os.WIFEXITED(condition):
401
329
exitstatus = os.WEXITSTATUS(condition)
402
330
if exitstatus == 0:
406
334
else:
407
335
logger.info(u"Checker for %(name)s failed",
408
336
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))
409
342
else:
410
343
logger.warning(u"Checker for %(name)s crashed?",
411
344
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))
412
350
413
351
def checked_ok(self):
414
352
"""Bump up the timeout for this client.
415
416
353
This should only be called when the client has been seen,
417
354
alive and well.
418
355
"""
421
358
self.disable_initiator_tag = (gobject.timeout_add
422
359
(self.timeout_milliseconds(),
423
360
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)))
424
367
425
368
def start_checker(self):
426
369
"""Start a new checker subprocess if one is not running.
427
428
370
If a checker already exists, leave it running and do
429
371
nothing."""
430
372
# The reason for not killing a running checker is that if we
433
375
# client would inevitably timeout, since no checker would get
434
376
# a chance to run to completion. If we instead leave running
435
377
# checkers alone, the checker would have to take more time
436
# than 'timeout' for the client to be disabled, which is as it
437
# should be.
438
439
# If a checker exists, make sure it is not a zombie
440
try:
441
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
442
except (AttributeError, OSError), error:
443
if (isinstance(error, OSError)
444
and error.errno != errno.ECHILD):
445
raise error
446
else:
447
if pid:
448
logger.warning(u"Checker was a zombie")
449
gobject.source_remove(self.checker_callback_tag)
450
self.checker_callback(pid, status,
451
self.current_checker_command)
452
# Start a new checker if needed
378
# than 'timeout' for the client to be declared invalid, which
379
# is as it should be.
453
380
if self.checker is None:
454
381
try:
455
382
# In case checker_command has exactly one % operator
456
383
command = self.checker_command % self.host
457
384
except TypeError:
458
385
# Escape attributes for the shell
459
escaped_attrs = dict(
460
(attr,
461
re.escape(unicode(str(getattr(self, attr, u"")),
462
errors=
463
u'replace')))
464
for attr in
465
self.runtime_expansions)
466
386
escaped_attrs = dict((key, re.escape(str(val)))
387
for key, val in
388
vars(self).iteritems())
467
389
try:
468
390
command = self.checker_command % escaped_attrs
469
391
except TypeError, error:
470
392
logger.error(u'Could not format string "%s":'
471
393
u' %s', self.checker_command, error)
472
394
return True # Try again later
473
self.current_checker_command = command
474
395
try:
475
396
logger.info(u"Starting checker %r for %s",
476
397
command, self.name)
480
401
# always replaced by /dev/null.)
481
402
self.checker = subprocess.Popen(command,
482
403
close_fds=True,
483
shell=True, cwd=u"/")
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))
484
411
self.checker_callback_tag = (gobject.child_watch_add
485
412
(self.checker.pid,
486
413
self.checker_callback,
487
414
data=command))
488
# The checker may have completed before the gobject
489
# watch was added. Check for this.
490
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
491
if pid:
492
gobject.source_remove(self.checker_callback_tag)
493
self.checker_callback(pid, status, command)
494
415
except OSError, error:
495
416
logger.error(u"Failed to start subprocess: %s",
496
417
error)
502
423
if self.checker_callback_tag:
503
424
gobject.source_remove(self.checker_callback_tag)
504
425
self.checker_callback_tag = None
505
if getattr(self, u"checker", None) is None:
426
if getattr(self, "checker", None) is None:
506
427
return
507
428
logger.debug(u"Stopping checker for %(name)s", vars(self))
508
429
try:
509
430
os.kill(self.checker.pid, signal.SIGTERM)
510
#time.sleep(0.5)
431
#os.sleep(0.5)
511
432
#if self.checker.poll() is None:
512
433
# os.kill(self.checker.pid, signal.SIGKILL)
513
434
except OSError, error:
514
435
if error.errno != errno.ESRCH: # No such process
515
436
raise
516
437
self.checker = None
517
518
def dbus_service_property(dbus_interface, signature=u"v",
519
access=u"readwrite", byte_arrays=False):
520
"""Decorators for marking methods of a DBusObjectWithProperties to
521
become properties on the D-Bus.
522
523
The decorated method will be called with no arguments by "Get"
524
and with one argument by "Set".
525
526
The parameters, where they are supported, are the same as
527
dbus.service.method, except there is only "signature", since the
528
type from Get() and the type sent to Set() is the same.
529
"""
530
# Encoding deeply encoded byte arrays is not supported yet by the
531
# "Set" method, so we fail early here:
532
if byte_arrays and signature != u"ay":
533
raise ValueError(u"Byte arrays not supported for non-'ay'"
534
u" signature %r" % signature)
535
def decorator(func):
536
func._dbus_is_property = True
537
func._dbus_interface = dbus_interface
538
func._dbus_signature = signature
539
func._dbus_access = access
540
func._dbus_name = func.__name__
541
if func._dbus_name.endswith(u"_dbus_property"):
542
func._dbus_name = func._dbus_name[:-14]
543
func._dbus_get_args_options = {u'byte_arrays': byte_arrays }
544
return func
545
return decorator
546
547
548
class DBusPropertyException(dbus.exceptions.DBusException):
549
"""A base class for D-Bus property-related exceptions
550
"""
551
def __unicode__(self):
552
return unicode(str(self))
553
554
555
class DBusPropertyAccessException(DBusPropertyException):
556
"""A property's access permissions disallows an operation.
557
"""
558
pass
559
560
561
class DBusPropertyNotFound(DBusPropertyException):
562
"""An attempt was made to access a non-existing property.
563
"""
564
pass
565
566
567
class DBusObjectWithProperties(dbus.service.Object):
568
"""A D-Bus object with properties.
569
570
Classes inheriting from this can use the dbus_service_property
571
decorator to expose methods as D-Bus properties. It exposes the
572
standard Get(), Set(), and GetAll() methods on the D-Bus.
573
"""
574
575
@staticmethod
576
def _is_dbus_property(obj):
577
return getattr(obj, u"_dbus_is_property", False)
578
579
def _get_all_dbus_properties(self):
580
"""Returns a generator of (name, attribute) pairs
581
"""
582
return ((prop._dbus_name, prop)
583
for name, prop in
584
inspect.getmembers(self, self._is_dbus_property))
585
586
def _get_dbus_property(self, interface_name, property_name):
587
"""Returns a bound method if one exists which is a D-Bus
588
property with the specified name and interface.
589
"""
590
for name in (property_name,
591
property_name + u"_dbus_property"):
592
prop = getattr(self, name, None)
593
if (prop is None
594
or not self._is_dbus_property(prop)
595
or prop._dbus_name != property_name
596
or (interface_name and prop._dbus_interface
597
and interface_name != prop._dbus_interface)):
598
continue
599
return prop
600
# No such property
601
raise DBusPropertyNotFound(self.dbus_object_path + u":"
602
+ interface_name + u"."
603
+ property_name)
604
605
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
606
out_signature=u"v")
607
def Get(self, interface_name, property_name):
608
"""Standard D-Bus property Get() method, see D-Bus standard.
609
"""
610
prop = self._get_dbus_property(interface_name, property_name)
611
if prop._dbus_access == u"write":
612
raise DBusPropertyAccessException(property_name)
613
value = prop()
614
if not hasattr(value, u"variant_level"):
615
return value
616
return type(value)(value, variant_level=value.variant_level+1)
617
618
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
619
def Set(self, interface_name, property_name, value):
620
"""Standard D-Bus property Set() method, see D-Bus standard.
621
"""
622
prop = self._get_dbus_property(interface_name, property_name)
623
if prop._dbus_access == u"read":
624
raise DBusPropertyAccessException(property_name)
625
if prop._dbus_get_args_options[u"byte_arrays"]:
626
# The byte_arrays option is not supported yet on
627
# signatures other than "ay".
628
if prop._dbus_signature != u"ay":
629
raise ValueError
630
value = dbus.ByteArray(''.join(unichr(byte)
631
for byte in value))
632
prop(value)
633
634
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
635
out_signature=u"a{sv}")
636
def GetAll(self, interface_name):
637
"""Standard D-Bus property GetAll() method, see D-Bus
638
standard.
639
640
Note: Will not include properties with access="write".
641
"""
642
all = {}
643
for name, prop in self._get_all_dbus_properties():
644
if (interface_name
645
and interface_name != prop._dbus_interface):
646
# Interface non-empty but did not match
647
continue
648
# Ignore write-only properties
649
if prop._dbus_access == u"write":
650
continue
651
value = prop()
652
if not hasattr(value, u"variant_level"):
653
all[name] = value
654
continue
655
all[name] = type(value)(value, variant_level=
656
value.variant_level+1)
657
return dbus.Dictionary(all, signature=u"sv")
658
659
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
660
out_signature=u"s",
661
path_keyword='object_path',
662
connection_keyword='connection')
663
def Introspect(self, object_path, connection):
664
"""Standard D-Bus method, overloaded to insert property tags.
665
"""
666
xmlstring = dbus.service.Object.Introspect(self, object_path,
667
connection)
668
try:
669
document = xml.dom.minidom.parseString(xmlstring)
670
def make_tag(document, name, prop):
671
e = document.createElement(u"property")
672
e.setAttribute(u"name", name)
673
e.setAttribute(u"type", prop._dbus_signature)
674
e.setAttribute(u"access", prop._dbus_access)
675
return e
676
for if_tag in document.getElementsByTagName(u"interface"):
677
for tag in (make_tag(document, name, prop)
678
for name, prop
679
in self._get_all_dbus_properties()
680
if prop._dbus_interface
681
== if_tag.getAttribute(u"name")):
682
if_tag.appendChild(tag)
683
# Add the names to the return values for the
684
# "org.freedesktop.DBus.Properties" methods
685
if (if_tag.getAttribute(u"name")
686
== u"org.freedesktop.DBus.Properties"):
687
for cn in if_tag.getElementsByTagName(u"method"):
688
if cn.getAttribute(u"name") == u"Get":
689
for arg in cn.getElementsByTagName(u"arg"):
690
if (arg.getAttribute(u"direction")
691
== u"out"):
692
arg.setAttribute(u"name", u"value")
693
elif cn.getAttribute(u"name") == u"GetAll":
694
for arg in cn.getElementsByTagName(u"arg"):
695
if (arg.getAttribute(u"direction")
696
== u"out"):
697
arg.setAttribute(u"name", u"props")
698
xmlstring = document.toxml(u"utf-8")
699
document.unlink()
700
except (AttributeError, xml.dom.DOMException,
701
xml.parsers.expat.ExpatError), error:
702
logger.error(u"Failed to override Introspection method",
703
error)
704
return xmlstring
705
706
707
class ClientDBus(Client, DBusObjectWithProperties):
708
"""A Client class using D-Bus
709
710
Attributes:
711
dbus_object_path: dbus.ObjectPath
712
bus: dbus.SystemBus()
713
"""
714
715
runtime_expansions = (Client.runtime_expansions
716
+ (u"dbus_object_path",))
717
718
# dbus.service.Object doesn't use super(), so we can't either.
719
720
def __init__(self, bus = None, *args, **kwargs):
721
self._approvals_pending = 0
722
self.bus = bus
723
Client.__init__(self, *args, **kwargs)
724
# Only now, when this client is initialized, can it show up on
725
# the D-Bus
726
self.dbus_object_path = (dbus.ObjectPath
727
(u"/clients/"
728
+ self.name.replace(u".", u"_")))
729
DBusObjectWithProperties.__init__(self, self.bus,
730
self.dbus_object_path)
731
732
def _get_approvals_pending(self):
733
return self._approvals_pending
734
def _set_approvals_pending(self, value):
735
old_value = self._approvals_pending
736
self._approvals_pending = value
737
bval = bool(value)
738
if (hasattr(self, "dbus_object_path")
739
and bval is not bool(old_value)):
740
dbus_bool = dbus.Boolean(bval, variant_level=1)
741
self.PropertyChanged(dbus.String(u"ApprovalPending"),
742
dbus_bool)
743
744
approvals_pending = property(_get_approvals_pending,
745
_set_approvals_pending)
746
del _get_approvals_pending, _set_approvals_pending
747
748
@staticmethod
749
def _datetime_to_dbus(dt, variant_level=0):
750
"""Convert a UTC datetime.datetime() to a D-Bus type."""
751
return dbus.String(dt.isoformat(),
752
variant_level=variant_level)
753
754
def enable(self):
755
oldstate = getattr(self, u"enabled", False)
756
r = Client.enable(self)
757
if oldstate != self.enabled:
758
# Emit D-Bus signals
759
self.PropertyChanged(dbus.String(u"Enabled"),
760
dbus.Boolean(True, variant_level=1))
761
self.PropertyChanged(
762
dbus.String(u"LastEnabled"),
763
self._datetime_to_dbus(self.last_enabled,
764
variant_level=1))
765
return r
766
767
def disable(self, quiet = False):
768
oldstate = getattr(self, u"enabled", False)
769
r = Client.disable(self, quiet=quiet)
770
if not quiet and oldstate != self.enabled:
771
# Emit D-Bus signal
772
self.PropertyChanged(dbus.String(u"Enabled"),
773
dbus.Boolean(False, variant_level=1))
774
return r
775
776
def __del__(self, *args, **kwargs):
777
try:
778
self.remove_from_connection()
779
except LookupError:
780
pass
781
if hasattr(DBusObjectWithProperties, u"__del__"):
782
DBusObjectWithProperties.__del__(self, *args, **kwargs)
783
Client.__del__(self, *args, **kwargs)
784
785
def checker_callback(self, pid, condition, command,
786
*args, **kwargs):
787
self.checker_callback_tag = None
788
self.checker = None
789
# Emit D-Bus signal
790
self.PropertyChanged(dbus.String(u"CheckerRunning"),
791
dbus.Boolean(False, variant_level=1))
792
if os.WIFEXITED(condition):
793
exitstatus = os.WEXITSTATUS(condition)
794
# Emit D-Bus signal
795
self.CheckerCompleted(dbus.Int16(exitstatus),
796
dbus.Int64(condition),
797
dbus.String(command))
798
else:
799
# Emit D-Bus signal
800
self.CheckerCompleted(dbus.Int16(-1),
801
dbus.Int64(condition),
802
dbus.String(command))
803
804
return Client.checker_callback(self, pid, condition, command,
805
*args, **kwargs)
806
807
def checked_ok(self, *args, **kwargs):
808
r = Client.checked_ok(self, *args, **kwargs)
809
# Emit D-Bus signal
810
self.PropertyChanged(
811
dbus.String(u"LastCheckedOK"),
812
(self._datetime_to_dbus(self.last_checked_ok,
813
variant_level=1)))
814
return r
815
816
def start_checker(self, *args, **kwargs):
817
old_checker = self.checker
818
if self.checker is not None:
819
old_checker_pid = self.checker.pid
820
else:
821
old_checker_pid = None
822
r = Client.start_checker(self, *args, **kwargs)
823
# Only if new checker process was started
824
if (self.checker is not None
825
and old_checker_pid != self.checker.pid):
826
# Emit D-Bus signal
827
self.CheckerStarted(self.current_checker_command)
828
self.PropertyChanged(
829
dbus.String(u"CheckerRunning"),
830
dbus.Boolean(True, variant_level=1))
831
return r
832
833
def stop_checker(self, *args, **kwargs):
834
old_checker = getattr(self, u"checker", None)
835
r = Client.stop_checker(self, *args, **kwargs)
836
if (old_checker is not None
837
and getattr(self, u"checker", None) is None):
838
self.PropertyChanged(dbus.String(u"CheckerRunning"),
839
dbus.Boolean(False, variant_level=1))
840
return r
841
842
def _reset_approved(self):
843
self._approved = None
844
return False
845
846
def approve(self, value=True):
847
self.send_changedstate()
848
self._approved = value
849
gobject.timeout_add(self._timedelta_to_milliseconds
850
(self.approval_duration),
851
self._reset_approved)
852
853
854
## D-Bus methods, signals & properties
438
if self.use_dbus:
439
self.PropertyChanged(dbus.String(u"checker_running"),
440
dbus.Boolean(False, variant_level=1))
441
442
def still_valid(self):
443
"""Has the timeout not yet passed for this client?"""
444
if not getattr(self, "enabled", False):
445
return False
446
now = datetime.datetime.utcnow()
447
if self.last_checked_ok is None:
448
return now < (self.created + self.timeout)
449
else:
450
return now < (self.last_checked_ok + self.timeout)
451
452
## D-Bus methods & signals
855
453
_interface = u"se.bsnet.fukt.Mandos.Client"
856
454
857
## Signals
455
# CheckedOK - method
456
CheckedOK = dbus.service.method(_interface)(checked_ok)
457
CheckedOK.__name__ = "CheckedOK"
858
458
859
459
# CheckerCompleted - signal
860
@dbus.service.signal(_interface, signature=u"nxs")
460
@dbus.service.signal(_interface, signature="nxs")
861
461
def CheckerCompleted(self, exitcode, waitstatus, command):
862
462
"D-Bus signal"
863
463
pass
864
464
865
465
# CheckerStarted - signal
866
@dbus.service.signal(_interface, signature=u"s")
466
@dbus.service.signal(_interface, signature="s")
867
467
def CheckerStarted(self, command):
868
468
"D-Bus signal"
869
469
pass
870
470
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
871
518
# PropertyChanged - signal
872
@dbus.service.signal(_interface, signature=u"sv")
519
@dbus.service.signal(_interface, signature="sv")
873
520
def PropertyChanged(self, property, value):
874
521
"D-Bus signal"
875
522
pass
876
523
877
# GotSecret - signal
878
@dbus.service.signal(_interface)
879
def GotSecret(self):
880
"""D-Bus signal
881
Is sent after a successful transfer of secret from the Mandos
882
server to mandos-client
883
"""
884
pass
885
886
# Rejected - signal
887
@dbus.service.signal(_interface, signature=u"s")
888
def Rejected(self, reason):
889
"D-Bus signal"
890
pass
891
892
# NeedApproval - signal
893
@dbus.service.signal(_interface, signature=u"tb")
894
def NeedApproval(self, timeout, default):
895
"D-Bus signal"
896
pass
897
898
## Methods
899
900
# Approve - method
901
@dbus.service.method(_interface, in_signature=u"b")
902
def Approve(self, value):
903
self.approve(value)
904
905
# CheckedOK - method
906
@dbus.service.method(_interface)
907
def CheckedOK(self):
908
return self.checked_ok()
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
529
# Emit D-Bus signal
530
self.PropertyChanged(dbus.String(u"checker"),
531
dbus.String(self.checker_command,
532
variant_level=1))
533
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)))
909
567
910
568
# Enable - method
911
@dbus.service.method(_interface)
912
def Enable(self):
913
"D-Bus method"
914
self.enable()
569
Enable = dbus.service.method(_interface)(enable)
570
Enable.__name__ = "Enable"
915
571
916
572
# StartChecker - method
917
573
@dbus.service.method(_interface)
926
582
self.disable()
927
583
928
584
# StopChecker - method
929
@dbus.service.method(_interface)
930
def StopChecker(self):
931
self.stop_checker()
932
933
## Properties
934
935
# ApprovalPending - property
936
@dbus_service_property(_interface, signature=u"b", access=u"read")
937
def ApprovalPending_dbus_property(self):
938
return dbus.Boolean(bool(self.approvals_pending))
939
940
# ApprovedByDefault - property
941
@dbus_service_property(_interface, signature=u"b",
942
access=u"readwrite")
943
def ApprovedByDefault_dbus_property(self, value=None):
944
if value is None: # get
945
return dbus.Boolean(self.approved_by_default)
946
self.approved_by_default = bool(value)
947
# Emit D-Bus signal
948
self.PropertyChanged(dbus.String(u"ApprovedByDefault"),
949
dbus.Boolean(value, variant_level=1))
950
951
# ApprovalDelay - property
952
@dbus_service_property(_interface, signature=u"t",
953
access=u"readwrite")
954
def ApprovalDelay_dbus_property(self, value=None):
955
if value is None: # get
956
return dbus.UInt64(self.approval_delay_milliseconds())
957
self.approval_delay = datetime.timedelta(0, 0, 0, value)
958
# Emit D-Bus signal
959
self.PropertyChanged(dbus.String(u"ApprovalDelay"),
960
dbus.UInt64(value, variant_level=1))
961
962
# ApprovalDuration - property
963
@dbus_service_property(_interface, signature=u"t",
964
access=u"readwrite")
965
def ApprovalDuration_dbus_property(self, value=None):
966
if value is None: # get
967
return dbus.UInt64(self._timedelta_to_milliseconds(
968
self.approval_duration))
969
self.approval_duration = datetime.timedelta(0, 0, 0, value)
970
# Emit D-Bus signal
971
self.PropertyChanged(dbus.String(u"ApprovalDuration"),
972
dbus.UInt64(value, variant_level=1))
973
974
# Name - property
975
@dbus_service_property(_interface, signature=u"s", access=u"read")
976
def Name_dbus_property(self):
977
return dbus.String(self.name)
978
979
# Fingerprint - property
980
@dbus_service_property(_interface, signature=u"s", access=u"read")
981
def Fingerprint_dbus_property(self):
982
return dbus.String(self.fingerprint)
983
984
# Host - property
985
@dbus_service_property(_interface, signature=u"s",
986
access=u"readwrite")
987
def Host_dbus_property(self, value=None):
988
if value is None: # get
989
return dbus.String(self.host)
990
self.host = value
991
# Emit D-Bus signal
992
self.PropertyChanged(dbus.String(u"Host"),
993
dbus.String(value, variant_level=1))
994
995
# Created - property
996
@dbus_service_property(_interface, signature=u"s", access=u"read")
997
def Created_dbus_property(self):
998
return dbus.String(self._datetime_to_dbus(self.created))
999
1000
# LastEnabled - property
1001
@dbus_service_property(_interface, signature=u"s", access=u"read")
1002
def LastEnabled_dbus_property(self):
1003
if self.last_enabled is None:
1004
return dbus.String(u"")
1005
return dbus.String(self._datetime_to_dbus(self.last_enabled))
1006
1007
# Enabled - property
1008
@dbus_service_property(_interface, signature=u"b",
1009
access=u"readwrite")
1010
def Enabled_dbus_property(self, value=None):
1011
if value is None: # get
1012
return dbus.Boolean(self.enabled)
1013
if value:
1014
self.enable()
1015
else:
1016
self.disable()
1017
1018
# LastCheckedOK - property
1019
@dbus_service_property(_interface, signature=u"s",
1020
access=u"readwrite")
1021
def LastCheckedOK_dbus_property(self, value=None):
1022
if value is not None:
1023
self.checked_ok()
1024
return
1025
if self.last_checked_ok is None:
1026
return dbus.String(u"")
1027
return dbus.String(self._datetime_to_dbus(self
1028
.last_checked_ok))
1029
1030
# Timeout - property
1031
@dbus_service_property(_interface, signature=u"t",
1032
access=u"readwrite")
1033
def Timeout_dbus_property(self, value=None):
1034
if value is None: # get
1035
return dbus.UInt64(self.timeout_milliseconds())
1036
self.timeout = datetime.timedelta(0, 0, 0, value)
1037
# Emit D-Bus signal
1038
self.PropertyChanged(dbus.String(u"Timeout"),
1039
dbus.UInt64(value, variant_level=1))
1040
if getattr(self, u"disable_initiator_tag", None) is None:
1041
return
1042
# Reschedule timeout
1043
gobject.source_remove(self.disable_initiator_tag)
1044
self.disable_initiator_tag = None
1045
time_to_die = (self.
1046
_timedelta_to_milliseconds((self
1047
.last_checked_ok
1048
+ self.timeout)
1049
- datetime.datetime
1050
.utcnow()))
1051
if time_to_die <= 0:
1052
# The timeout has passed
1053
self.disable()
1054
else:
1055
self.disable_initiator_tag = (gobject.timeout_add
1056
(time_to_die, self.disable))
1057
1058
# Interval - property
1059
@dbus_service_property(_interface, signature=u"t",
1060
access=u"readwrite")
1061
def Interval_dbus_property(self, value=None):
1062
if value is None: # get
1063
return dbus.UInt64(self.interval_milliseconds())
1064
self.interval = datetime.timedelta(0, 0, 0, value)
1065
# Emit D-Bus signal
1066
self.PropertyChanged(dbus.String(u"Interval"),
1067
dbus.UInt64(value, variant_level=1))
1068
if getattr(self, u"checker_initiator_tag", None) is None:
1069
return
1070
# Reschedule checker run
1071
gobject.source_remove(self.checker_initiator_tag)
1072
self.checker_initiator_tag = (gobject.timeout_add
1073
(value, self.start_checker))
1074
self.start_checker() # Start one now, too
1075
1076
# Checker - property
1077
@dbus_service_property(_interface, signature=u"s",
1078
access=u"readwrite")
1079
def Checker_dbus_property(self, value=None):
1080
if value is None: # get
1081
return dbus.String(self.checker_command)
1082
self.checker_command = value
1083
# Emit D-Bus signal
1084
self.PropertyChanged(dbus.String(u"Checker"),
1085
dbus.String(self.checker_command,
1086
variant_level=1))
1087
1088
# CheckerRunning - property
1089
@dbus_service_property(_interface, signature=u"b",
1090
access=u"readwrite")
1091
def CheckerRunning_dbus_property(self, value=None):
1092
if value is None: # get
1093
return dbus.Boolean(self.checker is not None)
1094
if value:
1095
self.start_checker()
1096
else:
1097
self.stop_checker()
1098
1099
# ObjectPath - property
1100
@dbus_service_property(_interface, signature=u"o", access=u"read")
1101
def ObjectPath_dbus_property(self):
1102
return self.dbus_object_path # is already a dbus.ObjectPath
1103
1104
# Secret = property
1105
@dbus_service_property(_interface, signature=u"ay",
1106
access=u"write", byte_arrays=True)
1107
def Secret_dbus_property(self, value):
1108
self.secret = str(value)
585
StopChecker = dbus.service.method(_interface)(stop_checker)
586
StopChecker.__name__ = "StopChecker"
1109
587
1110
588
del _interface
1111
589
1112
590
1113
class ProxyClient(object):
1114
def __init__(self, child_pipe, fpr, address):
1115
self._pipe = child_pipe
1116
self._pipe.send(('init', fpr, address))
1117
if not self._pipe.recv():
1118
raise KeyError()
1119
1120
def __getattribute__(self, name):
1121
if(name == '_pipe'):
1122
return super(ProxyClient, self).__getattribute__(name)
1123
self._pipe.send(('getattr', name))
1124
data = self._pipe.recv()
1125
if data[0] == 'data':
1126
return data[1]
1127
if data[0] == 'function':
1128
def func(*args, **kwargs):
1129
self._pipe.send(('funcall', name, args, kwargs))
1130
return self._pipe.recv()[1]
1131
return func
1132
1133
def __setattr__(self, name, value):
1134
if(name == '_pipe'):
1135
return super(ProxyClient, self).__setattr__(name, value)
1136
self._pipe.send(('setattr', name, value))
1137
1138
1139
class ClientHandler(socketserver.BaseRequestHandler, object):
1140
"""A class to handle client connections.
1141
1142
Instantiated once for each connection to handle it.
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.
1143
655
Note: This will run in its own forked process."""
1144
656
1145
657
def handle(self):
1146
with contextlib.closing(self.server.child_pipe) as child_pipe:
1147
logger.info(u"TCP connection from: %s",
1148
unicode(self.client_address))
1149
logger.debug(u"Pipe FD: %d",
1150
self.server.child_pipe.fileno())
1151
1152
session = (gnutls.connection
1153
.ClientSession(self.request,
1154
gnutls.connection
1155
.X509Credentials()))
1156
1157
# Note: gnutls.connection.X509Credentials is really a
1158
# generic GnuTLS certificate credentials object so long as
1159
# no X.509 keys are added to it. Therefore, we can use it
1160
# here despite using OpenPGP certificates.
1161
1162
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
1163
# u"+AES-256-CBC", u"+SHA1",
1164
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
1165
# u"+DHE-DSS"))
1166
# Use a fallback default, since this MUST be set.
1167
priority = self.server.gnutls_priority
1168
if priority is None:
1169
priority = u"NORMAL"
1170
(gnutls.library.functions
1171
.gnutls_priority_set_direct(session._c_object,
1172
priority, None))
1173
1174
# Start communication using the Mandos protocol
1175
# Get protocol number
1176
line = self.request.makefile().readline()
1177
logger.debug(u"Protocol version: %r", line)
1178
try:
1179
if int(line.strip().split()[0]) > 1:
1180
raise RuntimeError
1181
except (ValueError, IndexError, RuntimeError), error:
1182
logger.error(u"Unknown protocol version: %s", error)
1183
return
1184
1185
# Start GnuTLS connection
1186
try:
1187
session.handshake()
1188
except gnutls.errors.GNUTLSError, error:
1189
logger.warning(u"Handshake failed: %s", error)
1190
# Do not run session.bye() here: the session is not
1191
# established. Just abandon the request.
1192
return
1193
logger.debug(u"Handshake succeeded")
1194
1195
approval_required = False
1196
try:
1197
try:
1198
fpr = self.fingerprint(self.peer_certificate
1199
(session))
1200
except (TypeError, gnutls.errors.GNUTLSError), error:
1201
logger.warning(u"Bad certificate: %s", error)
1202
return
1203
logger.debug(u"Fingerprint: %s", fpr)
1204
1205
try:
1206
client = ProxyClient(child_pipe, fpr,
1207
self.client_address)
1208
except KeyError:
1209
return
1210
1211
if client.approval_delay:
1212
delay = client.approval_delay
1213
client.approvals_pending += 1
1214
approval_required = True
1215
1216
while True:
1217
if not client.enabled:
1218
logger.warning(u"Client %s is disabled",
1219
client.name)
1220
if self.server.use_dbus:
1221
# Emit D-Bus signal
1222
client.Rejected("Disabled")
1223
return
1224
1225
if client._approved or not client.approval_delay:
1226
#We are approved or approval is disabled
1227
break
1228
elif client._approved is None:
1229
logger.info(u"Client %s needs approval",
1230
client.name)
1231
if self.server.use_dbus:
1232
# Emit D-Bus signal
1233
client.NeedApproval(
1234
client.approval_delay_milliseconds(),
1235
client.approved_by_default)
1236
else:
1237
logger.warning(u"Client %s was not approved",
1238
client.name)
1239
if self.server.use_dbus:
1240
# Emit D-Bus signal
1241
client.Rejected("Denied")
1242
return
1243
1244
#wait until timeout or approved
1245
#x = float(client._timedelta_to_milliseconds(delay))
1246
time = datetime.datetime.now()
1247
client.changedstate.acquire()
1248
client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))
1249
client.changedstate.release()
1250
time2 = datetime.datetime.now()
1251
if (time2 - time) >= delay:
1252
if not client.approved_by_default:
1253
logger.warning("Client %s timed out while"
1254
" waiting for approval",
1255
client.name)
1256
if self.server.use_dbus:
1257
# Emit D-Bus signal
1258
client.Rejected("Approval timed out")
1259
return
1260
else:
1261
break
1262
else:
1263
delay -= time2 - time
1264
1265
sent_size = 0
1266
while sent_size < len(client.secret):
1267
try:
1268
sent = session.send(client.secret[sent_size:])
1269
except (gnutls.errors.GNUTLSError), error:
1270
logger.warning("gnutls send failed")
1271
return
1272
logger.debug(u"Sent: %d, remaining: %d",
1273
sent, len(client.secret)
1274
- (sent_size + sent))
1275
sent_size += sent
1276
1277
logger.info(u"Sending secret to %s", client.name)
1278
# bump the timeout as if seen
1279
client.checked_ok()
1280
if self.server.use_dbus:
1281
# Emit D-Bus signal
1282
client.GotSecret()
1283
1284
finally:
1285
if approval_required:
1286
client.approvals_pending -= 1
1287
try:
1288
session.bye()
1289
except (gnutls.errors.GNUTLSError), error:
1290
logger.warning("GnuTLS bye failed")
1291
1292
@staticmethod
1293
def peer_certificate(session):
1294
"Return the peer's OpenPGP certificate as a bytestring"
1295
# If not an OpenPGP certificate...
1296
if (gnutls.library.functions
1297
.gnutls_certificate_type_get(session._c_object)
1298
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1299
# ...do the normal thing
1300
return session.peer_certificate
1301
list_size = ctypes.c_uint(1)
1302
cert_list = (gnutls.library.functions
1303
.gnutls_certificate_get_peers
1304
(session._c_object, ctypes.byref(list_size)))
1305
if not bool(cert_list) and list_size.value != 0:
1306
raise gnutls.errors.GNUTLSError(u"error getting peer"
1307
u" certificate")
1308
if list_size.value == 0:
1309
return None
1310
cert = cert_list[0]
1311
return ctypes.string_at(cert.data, cert.size)
1312
1313
@staticmethod
1314
def fingerprint(openpgp):
1315
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1316
# New GnuTLS "datum" with the OpenPGP public key
1317
datum = (gnutls.library.types
1318
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1319
ctypes.POINTER
1320
(ctypes.c_ubyte)),
1321
ctypes.c_uint(len(openpgp))))
1322
# New empty GnuTLS certificate
1323
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1324
(gnutls.library.functions
1325
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1326
# Import the OpenPGP public key into the certificate
1327
(gnutls.library.functions
1328
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1329
gnutls.library.constants
1330
.GNUTLS_OPENPGP_FMT_RAW))
1331
# Verify the self signature in the key
1332
crtverify = ctypes.c_uint()
1333
(gnutls.library.functions
1334
.gnutls_openpgp_crt_verify_self(crt, 0,
1335
ctypes.byref(crtverify)))
1336
if crtverify.value != 0:
1337
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1338
raise (gnutls.errors.CertificateSecurityError
1339
(u"Verify failed"))
1340
# New buffer for the fingerprint
1341
buf = ctypes.create_string_buffer(20)
1342
buf_len = ctypes.c_size_t()
1343
# Get the fingerprint from the certificate into the buffer
1344
(gnutls.library.functions
1345
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1346
ctypes.byref(buf_len)))
1347
# Deinit the certificate
1348
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1349
# Convert the buffer to a Python bytestring
1350
fpr = ctypes.string_at(buf, buf_len.value)
1351
# Convert the bytestring to hexadecimal notation
1352
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
1353
return hex_fpr
1354
1355
1356
class MultiprocessingMixIn(object):
1357
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1358
def sub_process_main(self, request, address):
1359
try:
1360
self.finish_request(request, address)
1361
except:
1362
self.handle_error(request, address)
1363
self.close_request(request)
1364
1365
def process_request(self, request, address):
1366
"""Start a new process to process the request."""
1367
multiprocessing.Process(target = self.sub_process_main,
1368
args = (request, address)).start()
1369
1370
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1371
""" adds a pipe to the MixIn """
1372
def process_request(self, request, client_address):
1373
"""Overrides and wraps the original process_request().
1374
1375
This function creates a new pipe in self.pipe
1376
"""
1377
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1378
1379
super(MultiprocessingMixInWithPipe,
1380
self).process_request(request, client_address)
1381
self.child_pipe.close()
1382
self.add_pipe(parent_pipe)
1383
1384
def add_pipe(self, parent_pipe):
1385
"""Dummy function; override as necessary"""
1386
pass
1387
1388
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1389
socketserver.TCPServer, object):
1390
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
1391
658
logger.info(u"TCP connection from: %s",
659
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.
1392
736
Attributes:
737
settings: Server settings
738
clients: Set() of Client objects
1393
739
enabled: Boolean; whether this server is activated yet
1394
interface: None or a network interface name (string)
1395
use_ipv6: Boolean; to use IPv6 or not
1396
740
"""
1397
def __init__(self, server_address, RequestHandlerClass,
1398
interface=None, use_ipv6=True):
1399
self.interface = interface
1400
if use_ipv6:
1401
self.address_family = socket.AF_INET6
1402
socketserver.TCPServer.__init__(self, server_address,
1403
RequestHandlerClass)
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)
1404
751
def server_bind(self):
1405
752
"""This overrides the normal server_bind() function
1406
753
to bind to an interface if one was specified, and also NOT to
1407
754
bind to an address or port if they were not specified."""
1408
if self.interface is not None:
1409
if SO_BINDTODEVICE is None:
1410
logger.error(u"SO_BINDTODEVICE does not exist;"
1411
u" cannot bind to interface %s",
1412
self.interface)
1413
else:
1414
try:
1415
self.socket.setsockopt(socket.SOL_SOCKET,
1416
SO_BINDTODEVICE,
1417
str(self.interface
1418
+ u'\0'))
1419
except socket.error, error:
1420
if error[0] == errno.EPERM:
1421
logger.error(u"No permission to"
1422
u" bind to interface %s",
1423
self.interface)
1424
elif error[0] == errno.ENOPROTOOPT:
1425
logger.error(u"SO_BINDTODEVICE not available;"
1426
u" cannot bind to interface %s",
1427
self.interface)
1428
else:
1429
raise
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
1430
769
# Only bind(2) the socket if we really need to.
1431
770
if self.server_address[0] or self.server_address[1]:
1432
771
if not self.server_address[0]:
1433
if self.address_family == socket.AF_INET6:
1434
any_address = u"::" # in6addr_any
1435
else:
1436
any_address = socket.INADDR_ANY
1437
self.server_address = (any_address,
772
in6addr_any = "::"
773
self.server_address = (in6addr_any,
1438
774
self.server_address[1])
1439
775
elif not self.server_address[1]:
1440
776
self.server_address = (self.server_address[0],
1441
777
0)
1442
# if self.interface:
778
# if self.settings["interface"]:
1443
779
# self.server_address = (self.server_address[0],
1444
780
# 0, # port
1445
781
# 0, # flowinfo
1446
782
# if_nametoindex
1447
# (self.interface))
1448
return socketserver.TCPServer.server_bind(self)
1449
1450
1451
class MandosServer(IPv6_TCPServer):
1452
"""Mandos server.
1453
1454
Attributes:
1455
clients: set of Client objects
1456
gnutls_priority GnuTLS priority string
1457
use_dbus: Boolean; to emit D-Bus signals or not
1458
1459
Assumes a gobject.MainLoop event loop.
1460
"""
1461
def __init__(self, server_address, RequestHandlerClass,
1462
interface=None, use_ipv6=True, clients=None,
1463
gnutls_priority=None, use_dbus=True):
1464
self.enabled = False
1465
self.clients = clients
1466
if self.clients is None:
1467
self.clients = set()
1468
self.use_dbus = use_dbus
1469
self.gnutls_priority = gnutls_priority
1470
IPv6_TCPServer.__init__(self, server_address,
1471
RequestHandlerClass,
1472
interface = interface,
1473
use_ipv6 = use_ipv6)
783
# (self.settings
784
# ["interface"]))
785
return super(IPv6_TCPServer, self).server_bind()
1474
786
def server_activate(self):
1475
787
if self.enabled:
1476
return socketserver.TCPServer.server_activate(self)
788
return super(IPv6_TCPServer, self).server_activate()
1477
789
def enable(self):
1478
790
self.enabled = True
1479
def add_pipe(self, parent_pipe):
1480
# Call "handle_ipc" for both data and EOF events
1481
gobject.io_add_watch(parent_pipe.fileno(),
1482
gobject.IO_IN | gobject.IO_HUP,
1483
functools.partial(self.handle_ipc,
1484
parent_pipe = parent_pipe))
1485
1486
def handle_ipc(self, source, condition, parent_pipe=None,
1487
client_object=None):
1488
condition_names = {
1489
gobject.IO_IN: u"IN", # There is data to read.
1490
gobject.IO_OUT: u"OUT", # Data can be written (without
1491
# blocking).
1492
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1493
gobject.IO_ERR: u"ERR", # Error condition.
1494
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1495
# broken, usually for pipes and
1496
# sockets).
1497
}
1498
conditions_string = ' | '.join(name
1499
for cond, name in
1500
condition_names.iteritems()
1501
if cond & condition)
1502
# error or the other end of multiprocessing.Pipe has closed
1503
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1504
return False
1505
1506
# Read a request from the child
1507
request = parent_pipe.recv()
1508
command = request[0]
1509
1510
if command == 'init':
1511
fpr = request[1]
1512
address = request[2]
1513
1514
for c in self.clients:
1515
if c.fingerprint == fpr:
1516
client = c
1517
break
1518
else:
1519
logger.warning(u"Client not found for fingerprint: %s, ad"
1520
u"dress: %s", fpr, address)
1521
if self.use_dbus:
1522
# Emit D-Bus signal
1523
mandos_dbus_service.ClientNotFound(fpr, address)
1524
parent_pipe.send(False)
1525
return False
1526
1527
gobject.io_add_watch(parent_pipe.fileno(),
1528
gobject.IO_IN | gobject.IO_HUP,
1529
functools.partial(self.handle_ipc,
1530
parent_pipe = parent_pipe,
1531
client_object = client))
1532
parent_pipe.send(True)
1533
# remove the old hook in favor of the new above hook on same fileno
1534
return False
1535
if command == 'funcall':
1536
funcname = request[1]
1537
args = request[2]
1538
kwargs = request[3]
1539
1540
parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))
1541
1542
if command == 'getattr':
1543
attrname = request[1]
1544
if callable(client_object.__getattribute__(attrname)):
1545
parent_pipe.send(('function',))
1546
else:
1547
parent_pipe.send(('data', client_object.__getattribute__(attrname)))
1548
1549
if command == 'setattr':
1550
attrname = request[1]
1551
value = request[2]
1552
setattr(client_object, attrname, value)
1553
1554
return True
1555
791
1556
792
1557
793
def string_to_delta(interval):
1558
794
"""Parse a string and return a datetime.timedelta
1559
795
1560
>>> string_to_delta(u'7d')
796
>>> string_to_delta('7d')
1561
797
datetime.timedelta(7)
1562
>>> string_to_delta(u'60s')
798
>>> string_to_delta('60s')
1563
799
datetime.timedelta(0, 60)
1564
>>> string_to_delta(u'60m')
800
>>> string_to_delta('60m')
1565
801
datetime.timedelta(0, 3600)
1566
>>> string_to_delta(u'24h')
802
>>> string_to_delta('24h')
1567
803
datetime.timedelta(1)
1568
804
>>> string_to_delta(u'1w')
1569
805
datetime.timedelta(7)
1570
>>> string_to_delta(u'5m 30s')
806
>>> string_to_delta('5m 30s')
1571
807
datetime.timedelta(0, 330)
1572
808
"""
1573
809
timevalue = datetime.timedelta(0)
1586
822
elif suffix == u"w":
1587
823
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1588
824
else:
1589
raise ValueError(u"Unknown suffix %r" % suffix)
1590
except (ValueError, IndexError), e:
1591
raise ValueError(e.message)
825
raise ValueError
826
except (ValueError, IndexError):
827
raise ValueError
1592
828
timevalue += delta
1593
829
return timevalue
1594
830
1595
831
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
1596
855
def if_nametoindex(interface):
1597
"""Call the C function if_nametoindex(), or equivalent
1598
1599
Note: This function cannot accept a unicode string."""
856
"""Call the C function if_nametoindex(), or equivalent"""
1600
857
global if_nametoindex
1601
858
try:
1602
859
if_nametoindex = (ctypes.cdll.LoadLibrary
1603
(ctypes.util.find_library(u"c"))
860
(ctypes.util.find_library("c"))
1604
861
.if_nametoindex)
1605
862
except (OSError, AttributeError):
1606
logger.warning(u"Doing if_nametoindex the hard way")
863
if "struct" not in sys.modules:
864
import struct
865
if "fcntl" not in sys.modules:
866
import fcntl
1607
867
def if_nametoindex(interface):
1608
868
"Get an interface index the hard way, i.e. using fcntl()"
1609
869
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1610
with contextlib.closing(socket.socket()) as s:
870
with closing(socket.socket()) as s:
1611
871
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1612
struct.pack(str(u"16s16x"),
1613
interface))
1614
interface_index = struct.unpack(str(u"I"),
1615
ifreq[16:20])[0]
872
struct.pack("16s16x", interface))
873
interface_index = struct.unpack("I", ifreq[16:20])[0]
1616
874
return interface_index
1617
875
return if_nametoindex(interface)
1618
876
1619
877
1620
878
def daemon(nochdir = False, noclose = False):
1621
879
"""See daemon(3). Standard BSD Unix function.
1622
1623
880
This should really exist as os.daemon, but it doesn't (yet)."""
1624
881
if os.fork():
1625
882
sys.exit()
1626
883
os.setsid()
1627
884
if not nochdir:
1628
os.chdir(u"/")
885
os.chdir("/")
1629
886
if os.fork():
1630
887
sys.exit()
1631
888
if not noclose:
1633
890
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1634
891
if not stat.S_ISCHR(os.fstat(null).st_mode):
1635
892
raise OSError(errno.ENODEV,
1636
u"%s not a character device"
1637
% os.path.devnull)
893
"/dev/null not a character device")
1638
894
os.dup2(null, sys.stdin.fileno())
1639
895
os.dup2(null, sys.stdout.fileno())
1640
896
os.dup2(null, sys.stderr.fileno())
1643
899
1644
900
1645
901
def main():
1646
1647
##################################################################
1648
# Parsing of options, both command line and config file
1649
1650
902
parser = optparse.OptionParser(version = "%%prog %s" % version)
1651
parser.add_option("-i", u"--interface", type=u"string",
1652
metavar="IF", help=u"Bind to interface IF")
1653
parser.add_option("-a", u"--address", type=u"string",
1654
help=u"Address to listen for requests on")
1655
parser.add_option("-p", u"--port", type=u"int",
1656
help=u"Port number to receive requests on")
1657
parser.add_option("--check", action=u"store_true",
1658
help=u"Run self-test")
1659
parser.add_option("--debug", action=u"store_true",
1660
help=u"Debug mode; run in foreground and log to"
1661
u" terminal")
1662
parser.add_option("--debuglevel", type=u"string", metavar="Level",
1663
help=u"Debug level for stdout output")
1664
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1665
u" priority string (see GnuTLS documentation)")
1666
parser.add_option("--servicename", type=u"string",
1667
metavar=u"NAME", help=u"Zeroconf service name")
1668
parser.add_option("--configdir", type=u"string",
1669
default=u"/etc/mandos", metavar=u"DIR",
1670
help=u"Directory to search for configuration"
1671
u" files")
1672
parser.add_option("--no-dbus", action=u"store_false",
1673
dest=u"use_dbus", help=u"Do not provide D-Bus"
1674
u" system bus interface")
1675
parser.add_option("--no-ipv6", action=u"store_false",
1676
dest=u"use_ipv6", help=u"Do not use IPv6")
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")
1677
926
options = parser.parse_args()[0]
1678
927
1679
928
if options.check:
1682
931
sys.exit()
1683
932
1684
933
# Default values for config file for server-global settings
1685
server_defaults = { u"interface": u"",
1686
u"address": u"",
1687
u"port": u"",
1688
u"debug": u"False",
1689
u"priority":
1690
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1691
u"servicename": u"Mandos",
1692
u"use_dbus": u"True",
1693
u"use_ipv6": u"True",
1694
u"debuglevel": u"",
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",
1695
942
}
1696
943
1697
944
# Parse config file for server-global settings
1698
server_config = configparser.SafeConfigParser(server_defaults)
945
server_config = ConfigParser.SafeConfigParser(server_defaults)
1699
946
del server_defaults
1700
server_config.read(os.path.join(options.configdir,
1701
u"mandos.conf"))
947
server_config.read(os.path.join(options.configdir, "mandos.conf"))
1702
948
# Convert the SafeConfigParser object to a dict
1703
949
server_settings = server_config.defaults()
1704
950
# Use the appropriate methods on the non-string config options
1705
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1706
server_settings[option] = server_config.getboolean(u"DEFAULT",
1707
option)
951
server_settings["debug"] = server_config.getboolean("DEFAULT",
952
"debug")
953
server_settings["use_dbus"] = server_config.getboolean("DEFAULT",
954
"use_dbus")
1708
955
if server_settings["port"]:
1709
server_settings["port"] = server_config.getint(u"DEFAULT",
1710
u"port")
956
server_settings["port"] = server_config.getint("DEFAULT",
957
"port")
1711
958
del server_config
1712
959
1713
960
# Override the settings from the config file with command line
1714
961
# options, if set.
1715
for option in (u"interface", u"address", u"port", u"debug",
1716
u"priority", u"servicename", u"configdir",
1717
u"use_dbus", u"use_ipv6", u"debuglevel"):
962
for option in ("interface", "address", "port", "debug",
963
"priority", "servicename", "configdir",
964
"use_dbus"):
1718
965
value = getattr(options, option)
1719
966
if value is not None:
1720
967
server_settings[option] = value
1721
968
del options
1722
# Force all strings to be unicode
1723
for option in server_settings.keys():
1724
if type(server_settings[option]) is str:
1725
server_settings[option] = unicode(server_settings[option])
1726
969
# Now we have our good server settings in "server_settings"
1727
970
1728
##################################################################
1729
1730
971
# For convenience
1731
debug = server_settings[u"debug"]
1732
debuglevel = server_settings[u"debuglevel"]
1733
use_dbus = server_settings[u"use_dbus"]
1734
use_ipv6 = server_settings[u"use_ipv6"]
1735
1736
if server_settings[u"servicename"] != u"Mandos":
972
debug = server_settings["debug"]
973
use_dbus = server_settings["use_dbus"]
974
975
if not debug:
976
syslogger.setLevel(logging.WARNING)
977
console.setLevel(logging.WARNING)
978
979
if server_settings["servicename"] != "Mandos":
1737
980
syslogger.setFormatter(logging.Formatter
1738
(u'Mandos (%s) [%%(process)d]:'
1739
u' %%(levelname)s: %%(message)s'
1740
% server_settings[u"servicename"]))
981
('Mandos (%s): %%(levelname)s:'
982
' %%(message)s'
983
% server_settings["servicename"]))
1741
984
1742
985
# Parse config file with clients
1743
client_defaults = { u"timeout": u"1h",
1744
u"interval": u"5m",
1745
u"checker": u"fping -q -- %%(host)s",
1746
u"host": u"",
1747
u"approval_delay": u"0s",
1748
u"approval_duration": u"1s",
986
client_defaults = { "timeout": "1h",
987
"interval": "5m",
988
"checker": "fping -q -- %%(host)s",
989
"host": "",
1749
990
}
1750
client_config = configparser.SafeConfigParser(client_defaults)
1751
client_config.read(os.path.join(server_settings[u"configdir"],
1752
u"clients.conf"))
1753
1754
global mandos_dbus_service
1755
mandos_dbus_service = None
1756
1757
tcp_server = MandosServer((server_settings[u"address"],
1758
server_settings[u"port"]),
1759
ClientHandler,
1760
interface=(server_settings[u"interface"]
1761
or None),
1762
use_ipv6=use_ipv6,
1763
gnutls_priority=
1764
server_settings[u"priority"],
1765
use_dbus=use_dbus)
1766
pidfilename = u"/var/run/mandos.pid"
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"
1767
1002
try:
1768
pidfile = open(pidfilename, u"w")
1003
pidfile = open(pidfilename, "w")
1769
1004
except IOError:
1770
logger.error(u"Could not open file %r", pidfilename)
1005
logger.error("Could not open file %r", pidfilename)
1771
1006
1772
1007
try:
1773
uid = pwd.getpwnam(u"_mandos").pw_uid
1774
gid = pwd.getpwnam(u"_mandos").pw_gid
1008
uid = pwd.getpwnam("_mandos").pw_uid
1009
gid = pwd.getpwnam("_mandos").pw_gid
1775
1010
except KeyError:
1776
1011
try:
1777
uid = pwd.getpwnam(u"mandos").pw_uid
1778
gid = pwd.getpwnam(u"mandos").pw_gid
1012
uid = pwd.getpwnam("mandos").pw_uid
1013
gid = pwd.getpwnam("mandos").pw_gid
1779
1014
except KeyError:
1780
1015
try:
1781
uid = pwd.getpwnam(u"nobody").pw_uid
1782
gid = pwd.getpwnam(u"nobody").pw_gid
1016
uid = pwd.getpwnam("nobody").pw_uid
1017
gid = pwd.getpwnam("nogroup").pw_gid
1783
1018
except KeyError:
1784
1019
uid = 65534
1785
1020
gid = 65534
1790
1025
if error[0] != errno.EPERM:
1791
1026
raise error
1792
1027
1793
if not debug and not debuglevel:
1794
syslogger.setLevel(logging.WARNING)
1795
console.setLevel(logging.WARNING)
1796
if debuglevel:
1797
level = getattr(logging, debuglevel.upper())
1798
syslogger.setLevel(level)
1799
console.setLevel(level)
1800
1028
# Enable all possible GnuTLS debugging
1801
1029
if debug:
1802
# Enable all possible GnuTLS debugging
1803
1804
1030
# "Use a log level over 10 to enable all debugging options."
1805
1031
# - GnuTLS manual
1806
1032
gnutls.library.functions.gnutls_global_set_log_level(11)
1807
1033
1808
1034
@gnutls.library.types.gnutls_log_func
1809
1035
def debug_gnutls(level, string):
1810
logger.debug(u"GnuTLS: %s", string[:-1])
1036
logger.debug("GnuTLS: %s", string[:-1])
1811
1037
1812
1038
(gnutls.library.functions
1813
1039
.gnutls_global_set_log_function(debug_gnutls))
1814
1815
# Redirect stdin so all checkers get /dev/null
1816
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1817
os.dup2(null, sys.stdin.fileno())
1818
if null > 2:
1819
os.close(null)
1820
else:
1821
# No console logging
1822
logger.removeHandler(console)
1823
1040
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"]))
1824
1047
1825
1048
global main_loop
1049
global bus
1050
global server
1826
1051
# From the Avahi example code
1827
1052
DBusGMainLoop(set_as_default=True )
1828
1053
main_loop = gobject.MainLoop()
1829
1054
bus = dbus.SystemBus()
1055
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1056
avahi.DBUS_PATH_SERVER),
1057
avahi.DBUS_INTERFACE_SERVER)
1830
1058
# End of Avahi example code
1831
1059
if use_dbus:
1832
try:
1833
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
1834
bus, do_not_queue=True)
1835
except dbus.exceptions.NameExistsException, e:
1836
logger.error(unicode(e) + u", disabling D-Bus")
1837
use_dbus = False
1838
server_settings[u"use_dbus"] = False
1839
tcp_server.use_dbus = False
1840
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1841
service = AvahiService(name = server_settings[u"servicename"],
1842
servicetype = u"_mandos._tcp",
1843
protocol = protocol, bus = bus)
1844
if server_settings["interface"]:
1845
service.interface = (if_nametoindex
1846
(str(server_settings[u"interface"])))
1847
1848
if not debug:
1060
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
1061
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:
1068
logger.warning(u"No clients defined")
1069
1070
if debug:
1071
# Redirect stdin so all checkers get /dev/null
1072
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1073
os.dup2(null, sys.stdin.fileno())
1074
if null > 2:
1075
os.close(null)
1076
else:
1077
# No console logging
1078
logger.removeHandler(console)
1849
1079
# Close all input and output, do double fork, etc.
1850
1080
daemon()
1851
1852
global multiprocessing_manager
1853
multiprocessing_manager = multiprocessing.Manager()
1854
1855
client_class = Client
1856
if use_dbus:
1857
client_class = functools.partial(ClientDBus, bus = bus)
1858
def client_config_items(config, section):
1859
special_settings = {
1860
"approved_by_default":
1861
lambda: config.getboolean(section,
1862
"approved_by_default"),
1863
}
1864
for name, value in config.items(section):
1865
try:
1866
yield (name, special_settings[name]())
1867
except KeyError:
1868
yield (name, value)
1869
1870
tcp_server.clients.update(set(
1871
client_class(name = section,
1872
config= dict(client_config_items(
1873
client_config, section)))
1874
for section in client_config.sections()))
1875
if not tcp_server.clients:
1876
logger.warning(u"No clients defined")
1877
1081
1878
1082
try:
1879
with pidfile:
1880
pid = os.getpid()
1881
pidfile.write(str(pid) + "\n")
1083
pid = os.getpid()
1084
pidfile.write(str(pid) + "\n")
1085
pidfile.close()
1882
1086
del pidfile
1883
1087
except IOError:
1884
1088
logger.error(u"Could not write to file %r with PID %d",
1888
1092
pass
1889
1093
del pidfilename
1890
1094
1095
def cleanup():
1096
"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
1103
1104
while clients:
1105
client = clients.pop()
1106
client.disable_hook = None
1107
client.disable()
1108
1109
atexit.register(cleanup)
1110
1891
1111
if not debug:
1892
1112
signal.signal(signal.SIGINT, signal.SIG_IGN)
1893
1113
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1894
1114
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1895
1115
1896
1116
if use_dbus:
1897
class MandosDBusService(dbus.service.Object):
1117
class MandosServer(dbus.service.Object):
1898
1118
"""A D-Bus proxy object"""
1899
1119
def __init__(self):
1900
dbus.service.Object.__init__(self, bus, u"/")
1120
dbus.service.Object.__init__(self, bus, "/")
1901
1121
_interface = u"se.bsnet.fukt.Mandos"
1902
1122
1903
@dbus.service.signal(_interface, signature=u"o")
1904
def ClientAdded(self, objpath):
1905
"D-Bus signal"
1906
pass
1907
1908
@dbus.service.signal(_interface, signature=u"ss")
1909
def ClientNotFound(self, fingerprint, address):
1910
"D-Bus signal"
1911
pass
1912
1913
@dbus.service.signal(_interface, signature=u"os")
1123
@dbus.service.signal(_interface, signature="oa{sv}")
1124
def ClientAdded(self, objpath, properties):
1125
"D-Bus signal"
1126
pass
1127
1128
@dbus.service.signal(_interface, signature="os")
1914
1129
def ClientRemoved(self, objpath, name):
1915
1130
"D-Bus signal"
1916
1131
pass
1917
1132
1918
@dbus.service.method(_interface, out_signature=u"ao")
1133
@dbus.service.method(_interface, out_signature="ao")
1919
1134
def GetAllClients(self):
1920
1135
"D-Bus method"
1921
return dbus.Array(c.dbus_object_path
1922
for c in tcp_server.clients)
1136
return dbus.Array(c.dbus_object_path for c in clients)
1923
1137
1924
@dbus.service.method(_interface,
1925
out_signature=u"a{oa{sv}}")
1138
@dbus.service.method(_interface, out_signature="a{oa{sv}}")
1926
1139
def GetAllClientsWithProperties(self):
1927
1140
"D-Bus method"
1928
1141
return dbus.Dictionary(
1929
((c.dbus_object_path, c.GetAll(u""))
1930
for c in tcp_server.clients),
1931
signature=u"oa{sv}")
1142
((c.dbus_object_path, c.GetAllProperties())
1143
for c in clients),
1144
signature="oa{sv}")
1932
1145
1933
@dbus.service.method(_interface, in_signature=u"o")
1146
@dbus.service.method(_interface, in_signature="o")
1934
1147
def RemoveClient(self, object_path):
1935
1148
"D-Bus method"
1936
for c in tcp_server.clients:
1149
for c in clients:
1937
1150
if c.dbus_object_path == object_path:
1938
tcp_server.clients.remove(c)
1939
c.remove_from_connection()
1151
clients.remove(c)
1940
1152
# Don't signal anything except ClientRemoved
1941
c.disable(quiet=True)
1153
c.use_dbus = False
1154
c.disable()
1942
1155
# Emit D-Bus signal
1943
1156
self.ClientRemoved(object_path, c.name)
1944
1157
return
1945
raise KeyError(object_path)
1158
raise KeyError
1946
1159
1947
1160
del _interface
1948
1161
1949
mandos_dbus_service = MandosDBusService()
1950
1951
def cleanup():
1952
"Cleanup function; run on exit"
1953
service.cleanup()
1954
1955
while tcp_server.clients:
1956
client = tcp_server.clients.pop()
1957
if use_dbus:
1958
client.remove_from_connection()
1959
client.disable_hook = None
1960
# Don't signal anything except ClientRemoved
1961
client.disable(quiet=True)
1962
if use_dbus:
1963
# Emit D-Bus signal
1964
mandos_dbus_service.ClientRemoved(client.dbus_object_path,
1965
client.name)
1966
1967
atexit.register(cleanup)
1968
1969
for client in tcp_server.clients:
1162
mandos_server = MandosServer()
1163
1164
for client in clients:
1970
1165
if use_dbus:
1971
1166
# Emit D-Bus signal
1972
mandos_dbus_service.ClientAdded(client.dbus_object_path)
1167
mandos_server.ClientAdded(client.dbus_object_path,
1168
client.GetAllProperties())
1973
1169
client.enable()
1974
1170
1975
1171
tcp_server.enable()
1977
1173
1978
1174
# Find out what port we got
1979
1175
service.port = tcp_server.socket.getsockname()[1]
1980
if use_ipv6:
1981
logger.info(u"Now listening on address %r, port %d,"
1982
" flowinfo %d, scope_id %d"
1983
% tcp_server.socket.getsockname())
1984
else: # IPv4
1985
logger.info(u"Now listening on address %r, port %d"
1986
% tcp_server.socket.getsockname())
1176
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
1177
u" scope_id %d" % tcp_server.socket.getsockname())
1987
1178
1988
1179
#service.interface = tcp_server.socket.getsockname()[3]
1989
1180
1990
1181
try:
1991
1182
# From the Avahi example code
1183
server.connect_to_signal("StateChanged", server_state_changed)
1992
1184
try:
1993
service.activate()
1185
server_state_changed(server.GetState())
1994
1186
except dbus.exceptions.DBusException, error:
1995
1187
logger.critical(u"DBusException: %s", error)
1996
cleanup()
1997
1188
sys.exit(1)
1998
1189
# End of Avahi example code
1999
1190
2006
1197
main_loop.run()
2007
1198
except AvahiError, error:
2008
1199
logger.critical(u"AvahiError: %s", error)
2009
cleanup()
2010
1200
sys.exit(1)
2011
1201
except KeyboardInterrupt:
2012
1202
if debug:
2013
1203
print >> sys.stderr
2014
logger.debug(u"Server received KeyboardInterrupt")
2015
logger.debug(u"Server exiting")
2016
# Must run before the D-Bus bus name gets deregistered
2017
cleanup()
1204
logger.debug("Server received KeyboardInterrupt")
1205
logger.debug("Server exiting")
2018
1206
2019
1207
if __name__ == '__main__':
2020
1208
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0