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