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 291
- compare with another revision
- download diff
- download tarball
- view history from revision 291
- Committer: Teddy Hogeborn
- Date: 2009-01-31 10:33:17 UTC
- mfrom: (24.1.129 mandos)
- Revision ID: teddy@fukt.bsnet.se-20090131103317-wzqvyr532sjcjt7u
Merge from Björn:
* mandos-ctl: New option "--remove-client". Only default to listing
clients if no clients were given on the command line.
* plugins.d/mandos-client.c: Lower kernel log level while bringing up
network interface. New option "--delay"
to control the maximum delay to wait for
running interface.
* plugins.d/mandos-client.xml (SYNOPSIS, OPTIONS): New option
"--delay".
* mandos-ctl: New option "--remove-client". Only default to listing
clients if no clients were given on the command line.
* plugins.d/mandos-client.c: Lower kernel log level while bringing up
network interface. New option "--delay"
to control the maximum delay to wait for
running interface.
* plugins.d/mandos-client.xml (SYNOPSIS, OPTIONS): New option
"--delay".
- files removed:
- DBUS-API
- debian/source
- network-hooks.d
- 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", "remove", "server_state_changed",
10
# "entry_group_state_changed", "cleanup", and "activate" in the
11
# "AvahiService" class, and some lines in "main".
9
# methods "add" and "remove" in the "AvahiService" class, the
10
# "server_state_changed" and "entry_group_state_changed" functions,
11
# and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2008-2012 Teddy Hogeborn
15
# Copyright © 2008-2012 Björn Påhlsson
14
# Copyright © 2008,2009 Teddy Hogeborn
15
# Copyright © 2008,2009 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
28
28
# along with this program. If not, see
29
29
# <http://www.gnu.org/licenses/>.
30
30
#
31
# Contact the authors at <mandos@recompile.se>.
31
# Contact the authors at <mandos@fukt.bsnet.se>.
32
32
#
33
33
34
from __future__ import (division, absolute_import, print_function,
35
unicode_literals)
36
37
from future_builtins import *
38
39
import SocketServer as socketserver
34
from __future__ import division, with_statement, absolute_import
35
36
import SocketServer
40
37
import socket
41
import argparse
38
import optparse
42
39
import datetime
43
40
import errno
44
41
import gnutls.crypto
47
44
import gnutls.library.functions
48
45
import gnutls.library.constants
49
46
import gnutls.library.types
50
import ConfigParser as configparser
47
import ConfigParser
51
48
import sys
52
49
import re
53
50
import os
54
51
import signal
52
from sets import Set
55
53
import subprocess
56
54
import atexit
57
55
import stat
58
56
import logging
59
57
import logging.handlers
60
58
import pwd
61
import contextlib
62
import struct
63
import fcntl
64
import functools
65
import cPickle as pickle
66
import multiprocessing
67
import types
68
import binascii
69
import tempfile
70
import itertools
71
import collections
59
from contextlib import closing
72
60
73
61
import dbus
74
62
import dbus.service
77
65
from dbus.mainloop.glib import DBusGMainLoop
78
66
import ctypes
79
67
import ctypes.util
80
import xml.dom.minidom
81
import inspect
82
import GnuPGInterface
83
84
try:
85
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
86
except AttributeError:
87
try:
88
from IN import SO_BINDTODEVICE
89
except ImportError:
90
SO_BINDTODEVICE = None
91
92
version = "1.6.0"
93
stored_state_file = "clients.pickle"
94
95
logger = logging.getLogger()
68
69
version = "1.0.5"
70
71
logger = logging.Logger('mandos')
96
72
syslogger = (logging.handlers.SysLogHandler
97
73
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
98
address = str("/dev/log")))
99
100
try:
101
if_nametoindex = (ctypes.cdll.LoadLibrary
102
(ctypes.util.find_library("c"))
103
.if_nametoindex)
104
except (OSError, AttributeError):
105
def if_nametoindex(interface):
106
"Get an interface index the hard way, i.e. using fcntl()"
107
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
108
with contextlib.closing(socket.socket()) as s:
109
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
110
struct.pack(str("16s16x"),
111
interface))
112
interface_index = struct.unpack(str("I"),
113
ifreq[16:20])[0]
114
return interface_index
115
116
117
def initlogger(debug, level=logging.WARNING):
118
"""init logger and add loglevel"""
119
120
syslogger.setFormatter(logging.Formatter
121
('Mandos [%(process)d]: %(levelname)s:'
122
' %(message)s'))
123
logger.addHandler(syslogger)
124
125
if debug:
126
console = logging.StreamHandler()
127
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
128
' [%(process)d]:'
129
' %(levelname)s:'
130
' %(message)s'))
131
logger.addHandler(console)
132
logger.setLevel(level)
133
134
135
class PGPError(Exception):
136
"""Exception if encryption/decryption fails"""
137
pass
138
139
140
class PGPEngine(object):
141
"""A simple class for OpenPGP symmetric encryption & decryption"""
142
def __init__(self):
143
self.gnupg = GnuPGInterface.GnuPG()
144
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
145
self.gnupg = GnuPGInterface.GnuPG()
146
self.gnupg.options.meta_interactive = False
147
self.gnupg.options.homedir = self.tempdir
148
self.gnupg.options.extra_args.extend(['--force-mdc',
149
'--quiet',
150
'--no-use-agent'])
151
152
def __enter__(self):
153
return self
154
155
def __exit__(self, exc_type, exc_value, traceback):
156
self._cleanup()
157
return False
158
159
def __del__(self):
160
self._cleanup()
161
162
def _cleanup(self):
163
if self.tempdir is not None:
164
# Delete contents of tempdir
165
for root, dirs, files in os.walk(self.tempdir,
166
topdown = False):
167
for filename in files:
168
os.remove(os.path.join(root, filename))
169
for dirname in dirs:
170
os.rmdir(os.path.join(root, dirname))
171
# Remove tempdir
172
os.rmdir(self.tempdir)
173
self.tempdir = None
174
175
def password_encode(self, password):
176
# Passphrase can not be empty and can not contain newlines or
177
# NUL bytes. So we prefix it and hex encode it.
178
return b"mandos" + binascii.hexlify(password)
179
180
def encrypt(self, data, password):
181
self.gnupg.passphrase = self.password_encode(password)
182
with open(os.devnull, "w") as devnull:
183
try:
184
proc = self.gnupg.run(['--symmetric'],
185
create_fhs=['stdin', 'stdout'],
186
attach_fhs={'stderr': devnull})
187
with contextlib.closing(proc.handles['stdin']) as f:
188
f.write(data)
189
with contextlib.closing(proc.handles['stdout']) as f:
190
ciphertext = f.read()
191
proc.wait()
192
except IOError as e:
193
raise PGPError(e)
194
self.gnupg.passphrase = None
195
return ciphertext
196
197
def decrypt(self, data, password):
198
self.gnupg.passphrase = self.password_encode(password)
199
with open(os.devnull, "w") as devnull:
200
try:
201
proc = self.gnupg.run(['--decrypt'],
202
create_fhs=['stdin', 'stdout'],
203
attach_fhs={'stderr': devnull})
204
with contextlib.closing(proc.handles['stdin']) as f:
205
f.write(data)
206
with contextlib.closing(proc.handles['stdout']) as f:
207
decrypted_plaintext = f.read()
208
proc.wait()
209
except IOError as e:
210
raise PGPError(e)
211
self.gnupg.passphrase = None
212
return decrypted_plaintext
213
74
address = "/dev/log"))
75
syslogger.setFormatter(logging.Formatter
76
('Mandos: %(levelname)s: %(message)s'))
77
logger.addHandler(syslogger)
78
79
console = logging.StreamHandler()
80
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
81
' %(message)s'))
82
logger.addHandler(console)
214
83
215
84
class AvahiError(Exception):
216
85
def __init__(self, value, *args, **kwargs):
228
97
229
98
class AvahiService(object):
230
99
"""An Avahi (Zeroconf) service.
231
232
100
Attributes:
233
101
interface: integer; avahi.IF_UNSPEC or an interface index.
234
102
Used to optionally bind to the specified interface.
242
110
max_renames: integer; maximum number of renames
243
111
rename_count: integer; counter so we only rename after collisions
244
112
a sensible number of times
245
group: D-Bus Entry Group
246
server: D-Bus Server
247
bus: dbus.SystemBus()
248
113
"""
249
250
114
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
251
115
servicetype = None, port = None, TXT = None,
252
domain = "", host = "", max_renames = 32768,
253
protocol = avahi.PROTO_UNSPEC, bus = None):
116
domain = "", host = "", max_renames = 32768):
254
117
self.interface = interface
255
118
self.name = name
256
119
self.type = servicetype
260
123
self.host = host
261
124
self.rename_count = 0
262
125
self.max_renames = max_renames
263
self.protocol = protocol
264
self.group = None # our entry group
265
self.server = None
266
self.bus = bus
267
self.entry_group_state_changed_match = None
268
269
126
def rename(self):
270
127
"""Derived from the Avahi example code"""
271
128
if self.rename_count >= self.max_renames:
272
logger.critical("No suitable Zeroconf service name found"
273
" after %i retries, exiting.",
129
logger.critical(u"No suitable Zeroconf service name found"
130
u" after %i retries, exiting.",
274
131
self.rename_count)
275
raise AvahiServiceError("Too many renames")
276
self.name = unicode(self.server
277
.GetAlternativeServiceName(self.name))
278
logger.info("Changing Zeroconf service name to %r ...",
279
self.name)
132
raise AvahiServiceError(u"Too many renames")
133
self.name = server.GetAlternativeServiceName(self.name)
134
logger.info(u"Changing Zeroconf service name to %r ...",
135
str(self.name))
136
syslogger.setFormatter(logging.Formatter
137
('Mandos (%s): %%(levelname)s:'
138
' %%(message)s' % self.name))
280
139
self.remove()
281
try:
282
self.add()
283
except dbus.exceptions.DBusException as error:
284
logger.critical("D-Bus Exception", exc_info=error)
285
self.cleanup()
286
os._exit(1)
140
self.add()
287
141
self.rename_count += 1
288
289
142
def remove(self):
290
143
"""Derived from the Avahi example code"""
291
if self.entry_group_state_changed_match is not None:
292
self.entry_group_state_changed_match.remove()
293
self.entry_group_state_changed_match = None
294
if self.group is not None:
295
self.group.Reset()
296
144
if group is not None:
145
group.Reset()
297
146
def add(self):
298
147
"""Derived from the Avahi example code"""
299
self.remove()
300
if self.group is None:
301
self.group = dbus.Interface(
302
self.bus.get_object(avahi.DBUS_NAME,
303
self.server.EntryGroupNew()),
304
avahi.DBUS_INTERFACE_ENTRY_GROUP)
305
self.entry_group_state_changed_match = (
306
self.group.connect_to_signal(
307
'StateChanged', self.entry_group_state_changed))
308
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
309
self.name, self.type)
310
self.group.AddService(
311
self.interface,
312
self.protocol,
313
dbus.UInt32(0), # flags
314
self.name, self.type,
315
self.domain, self.host,
316
dbus.UInt16(self.port),
317
avahi.string_array_to_txt_array(self.TXT))
318
self.group.Commit()
319
320
def entry_group_state_changed(self, state, error):
321
"""Derived from the Avahi example code"""
322
logger.debug("Avahi entry group state change: %i", state)
323
324
if state == avahi.ENTRY_GROUP_ESTABLISHED:
325
logger.debug("Zeroconf service established.")
326
elif state == avahi.ENTRY_GROUP_COLLISION:
327
logger.info("Zeroconf service name collision.")
328
self.rename()
329
elif state == avahi.ENTRY_GROUP_FAILURE:
330
logger.critical("Avahi: Error in group state changed %s",
331
unicode(error))
332
raise AvahiGroupError("State changed: {0!s}"
333
.format(error))
334
335
def cleanup(self):
336
"""Derived from the Avahi example code"""
337
if self.group is not None:
338
try:
339
self.group.Free()
340
except (dbus.exceptions.UnknownMethodException,
341
dbus.exceptions.DBusException):
342
pass
343
self.group = None
344
self.remove()
345
346
def server_state_changed(self, state, error=None):
347
"""Derived from the Avahi example code"""
348
logger.debug("Avahi server state change: %i", state)
349
bad_states = { avahi.SERVER_INVALID:
350
"Zeroconf server invalid",
351
avahi.SERVER_REGISTERING: None,
352
avahi.SERVER_COLLISION:
353
"Zeroconf server name collision",
354
avahi.SERVER_FAILURE:
355
"Zeroconf server failure" }
356
if state in bad_states:
357
if bad_states[state] is not None:
358
if error is None:
359
logger.error(bad_states[state])
360
else:
361
logger.error(bad_states[state] + ": %r", error)
362
self.cleanup()
363
elif state == avahi.SERVER_RUNNING:
364
self.add()
365
else:
366
if error is None:
367
logger.debug("Unknown state: %r", state)
368
else:
369
logger.debug("Unknown state: %r: %r", state, error)
370
371
def activate(self):
372
"""Derived from the Avahi example code"""
373
if self.server is None:
374
self.server = dbus.Interface(
375
self.bus.get_object(avahi.DBUS_NAME,
376
avahi.DBUS_PATH_SERVER,
377
follow_name_owner_changes=True),
378
avahi.DBUS_INTERFACE_SERVER)
379
self.server.connect_to_signal("StateChanged",
380
self.server_state_changed)
381
self.server_state_changed(self.server.GetState())
382
383
384
class AvahiServiceToSyslog(AvahiService):
385
def rename(self):
386
"""Add the new name to the syslog messages"""
387
ret = AvahiService.rename(self)
388
syslogger.setFormatter(logging.Formatter
389
('Mandos ({0}) [%(process)d]:'
390
' %(levelname)s: %(message)s'
391
.format(self.name)))
392
return ret
393
394
395
def timedelta_to_milliseconds(td):
396
"Convert a datetime.timedelta() to milliseconds"
397
return ((td.days * 24 * 60 * 60 * 1000)
398
+ (td.seconds * 1000)
399
+ (td.microseconds // 1000))
400
401
402
class Client(object):
148
global group
149
if group is None:
150
group = dbus.Interface(bus.get_object
151
(avahi.DBUS_NAME,
152
server.EntryGroupNew()),
153
avahi.DBUS_INTERFACE_ENTRY_GROUP)
154
group.connect_to_signal('StateChanged',
155
entry_group_state_changed)
156
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
157
service.name, service.type)
158
group.AddService(
159
self.interface, # interface
160
avahi.PROTO_INET6, # protocol
161
dbus.UInt32(0), # flags
162
self.name, self.type,
163
self.domain, self.host,
164
dbus.UInt16(self.port),
165
avahi.string_array_to_txt_array(self.TXT))
166
group.Commit()
167
168
# From the Avahi example code:
169
group = None # our entry group
170
# End of Avahi example code
171
172
173
def _datetime_to_dbus(dt, variant_level=0):
174
"""Convert a UTC datetime.datetime() to a D-Bus type."""
175
return dbus.String(dt.isoformat(), variant_level=variant_level)
176
177
178
class Client(dbus.service.Object):
403
179
"""A representation of a client host served by this server.
404
405
180
Attributes:
406
approved: bool(); 'None' if not yet approved/disapproved
407
approval_delay: datetime.timedelta(); Time to wait for approval
408
approval_duration: datetime.timedelta(); Duration of one approval
181
name: string; from the config file, used in log messages and
182
D-Bus identifiers
183
fingerprint: string (40 or 32 hexadecimal digits); used to
184
uniquely identify the client
185
secret: bytestring; sent verbatim (over TLS) to client
186
host: string; available for use by the checker command
187
created: datetime.datetime(); (UTC) object creation
188
last_enabled: datetime.datetime(); (UTC)
189
enabled: bool()
190
last_checked_ok: datetime.datetime(); (UTC) or None
191
timeout: datetime.timedelta(); How long from last_checked_ok
192
until this client is invalid
193
interval: datetime.timedelta(); How often to start a new checker
194
disable_hook: If set, called by disable() as disable_hook(self)
409
195
checker: subprocess.Popen(); a running checker process used
410
196
to see if the client lives.
411
197
'None' if no process is running.
412
checker_callback_tag: a gobject event source tag, or None
413
checker_command: string; External command which is run to check
414
if client lives. %() expansions are done at
198
checker_initiator_tag: a gobject event source tag, or None
199
disable_initiator_tag: - '' -
200
checker_callback_tag: - '' -
201
checker_command: string; External command which is run to check if
202
client lives. %() expansions are done at
415
203
runtime with vars(self) as dict, so that for
416
204
instance %(name)s can be used in the command.
417
checker_initiator_tag: a gobject event source tag, or None
418
created: datetime.datetime(); (UTC) object creation
419
client_structure: Object describing what attributes a client has
420
and is used for storing the client at exit
421
current_checker_command: string; current running checker_command
422
disable_initiator_tag: a gobject event source tag, or None
423
enabled: bool()
424
fingerprint: string (40 or 32 hexadecimal digits); used to
425
uniquely identify the client
426
host: string; available for use by the checker command
427
interval: datetime.timedelta(); How often to start a new checker
428
last_approval_request: datetime.datetime(); (UTC) or None
429
last_checked_ok: datetime.datetime(); (UTC) or None
430
last_checker_status: integer between 0 and 255 reflecting exit
431
status of last checker. -1 reflects crashed
432
checker, -2 means no checker completed yet.
433
last_enabled: datetime.datetime(); (UTC) or None
434
name: string; from the config file, used in log messages and
435
D-Bus identifiers
436
secret: bytestring; sent verbatim (over TLS) to client
437
timeout: datetime.timedelta(); How long from last_checked_ok
438
until this client is disabled
439
extended_timeout: extra long timeout when secret has been sent
440
runtime_expansions: Allowed attributes for runtime expansion.
441
expires: datetime.datetime(); time (UTC) when a client will be
442
disabled, or None
205
use_dbus: bool(); Whether to provide D-Bus interface and signals
206
dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus
443
207
"""
444
445
runtime_expansions = ("approval_delay", "approval_duration",
446
"created", "enabled", "expires",
447
"fingerprint", "host", "interval",
448
"last_approval_request", "last_checked_ok",
449
"last_enabled", "name", "timeout")
450
client_defaults = { "timeout": "PT5M",
451
"extended_timeout": "PT15M",
452
"interval": "PT2M",
453
"checker": "fping -q -- %%(host)s",
454
"host": "",
455
"approval_delay": "PT0S",
456
"approval_duration": "PT1S",
457
"approved_by_default": "True",
458
"enabled": "True",
459
}
460
461
208
def timeout_milliseconds(self):
462
209
"Return the 'timeout' attribute in milliseconds"
463
return timedelta_to_milliseconds(self.timeout)
464
465
def extended_timeout_milliseconds(self):
466
"Return the 'extended_timeout' attribute in milliseconds"
467
return timedelta_to_milliseconds(self.extended_timeout)
210
return ((self.timeout.days * 24 * 60 * 60 * 1000)
211
+ (self.timeout.seconds * 1000)
212
+ (self.timeout.microseconds // 1000))
468
213
469
214
def interval_milliseconds(self):
470
215
"Return the 'interval' attribute in milliseconds"
471
return timedelta_to_milliseconds(self.interval)
472
473
def approval_delay_milliseconds(self):
474
return timedelta_to_milliseconds(self.approval_delay)
475
476
@staticmethod
477
def config_parser(config):
478
"""Construct a new dict of client settings of this form:
479
{ client_name: {setting_name: value, ...}, ...}
480
with exceptions for any special settings as defined above.
481
NOTE: Must be a pure function. Must return the same result
482
value given the same arguments.
483
"""
484
settings = {}
485
for client_name in config.sections():
486
section = dict(config.items(client_name))
487
client = settings[client_name] = {}
488
489
client["host"] = section["host"]
490
# Reformat values from string types to Python types
491
client["approved_by_default"] = config.getboolean(
492
client_name, "approved_by_default")
493
client["enabled"] = config.getboolean(client_name,
494
"enabled")
495
496
client["fingerprint"] = (section["fingerprint"].upper()
497
.replace(" ", ""))
498
if "secret" in section:
499
client["secret"] = section["secret"].decode("base64")
500
elif "secfile" in section:
501
with open(os.path.expanduser(os.path.expandvars
502
(section["secfile"])),
503
"rb") as secfile:
504
client["secret"] = secfile.read()
505
else:
506
raise TypeError("No secret or secfile for section {0}"
507
.format(section))
508
client["timeout"] = string_to_delta(section["timeout"])
509
client["extended_timeout"] = string_to_delta(
510
section["extended_timeout"])
511
client["interval"] = string_to_delta(section["interval"])
512
client["approval_delay"] = string_to_delta(
513
section["approval_delay"])
514
client["approval_duration"] = string_to_delta(
515
section["approval_duration"])
516
client["checker_command"] = section["checker"]
517
client["last_approval_request"] = None
518
client["last_checked_ok"] = None
519
client["last_checker_status"] = -2
520
521
return settings
522
523
def __init__(self, settings, name = None):
216
return ((self.interval.days * 24 * 60 * 60 * 1000)
217
+ (self.interval.seconds * 1000)
218
+ (self.interval.microseconds // 1000))
219
220
def __init__(self, name = None, disable_hook=None, config=None,
221
use_dbus=True):
222
"""Note: the 'checker' key in 'config' sets the
223
'checker_command' attribute and *not* the 'checker'
224
attribute."""
524
225
self.name = name
525
# adding all client settings
526
for setting, value in settings.iteritems():
527
setattr(self, setting, value)
528
529
if self.enabled:
530
if not hasattr(self, "last_enabled"):
531
self.last_enabled = datetime.datetime.utcnow()
532
if not hasattr(self, "expires"):
533
self.expires = (datetime.datetime.utcnow()
534
+ self.timeout)
535
else:
536
self.last_enabled = None
537
self.expires = None
538
539
logger.debug("Creating client %r", self.name)
226
if config is None:
227
config = {}
228
logger.debug(u"Creating client %r", self.name)
229
self.use_dbus = False # During __init__
540
230
# Uppercase and remove spaces from fingerprint for later
541
231
# comparison purposes with return value from the fingerprint()
542
232
# function
543
logger.debug(" Fingerprint: %s", self.fingerprint)
544
self.created = settings.get("created",
545
datetime.datetime.utcnow())
546
547
# attributes specific for this server instance
233
self.fingerprint = (config["fingerprint"].upper()
234
.replace(u" ", u""))
235
logger.debug(u" Fingerprint: %s", self.fingerprint)
236
if "secret" in config:
237
self.secret = config["secret"].decode(u"base64")
238
elif "secfile" in config:
239
with closing(open(os.path.expanduser
240
(os.path.expandvars
241
(config["secfile"])))) as secfile:
242
self.secret = secfile.read()
243
else:
244
raise TypeError(u"No secret or secfile for client %s"
245
% self.name)
246
self.host = config.get("host", "")
247
self.created = datetime.datetime.utcnow()
248
self.enabled = False
249
self.last_enabled = None
250
self.last_checked_ok = None
251
self.timeout = string_to_delta(config["timeout"])
252
self.interval = string_to_delta(config["interval"])
253
self.disable_hook = disable_hook
548
254
self.checker = None
549
255
self.checker_initiator_tag = None
550
256
self.disable_initiator_tag = None
551
257
self.checker_callback_tag = None
552
self.current_checker_command = None
553
self.approved = None
554
self.approvals_pending = 0
555
self.changedstate = (multiprocessing_manager
556
.Condition(multiprocessing_manager
557
.Lock()))
558
self.client_structure = [attr for attr in
559
self.__dict__.iterkeys()
560
if not attr.startswith("_")]
561
self.client_structure.append("client_structure")
562
563
for name, t in inspect.getmembers(type(self),
564
lambda obj:
565
isinstance(obj,
566
property)):
567
if not name.startswith("_"):
568
self.client_structure.append(name)
569
570
# Send notice to process children that client state has changed
571
def send_changedstate(self):
572
with self.changedstate:
573
self.changedstate.notify_all()
258
self.checker_command = config["checker"]
259
self.last_connect = None
260
# Only now, when this client is initialized, can it show up on
261
# the D-Bus
262
self.use_dbus = use_dbus
263
if self.use_dbus:
264
self.dbus_object_path = (dbus.ObjectPath
265
("/clients/"
266
+ self.name.replace(".", "_")))
267
dbus.service.Object.__init__(self, bus,
268
self.dbus_object_path)
574
269
575
270
def enable(self):
576
271
"""Start this client's checker and timeout hooks"""
577
if getattr(self, "enabled", False):
578
# Already enabled
579
return
580
self.expires = datetime.datetime.utcnow() + self.timeout
581
self.enabled = True
582
272
self.last_enabled = datetime.datetime.utcnow()
583
self.init_checker()
584
self.send_changedstate()
585
586
def disable(self, quiet=True):
587
"""Disable this client."""
588
if not getattr(self, "enabled", False):
589
return False
590
if not quiet:
591
logger.info("Disabling client %s", self.name)
592
if getattr(self, "disable_initiator_tag", None) is not None:
593
gobject.source_remove(self.disable_initiator_tag)
594
self.disable_initiator_tag = None
595
self.expires = None
596
if getattr(self, "checker_initiator_tag", None) is not None:
597
gobject.source_remove(self.checker_initiator_tag)
598
self.checker_initiator_tag = None
599
self.stop_checker()
600
self.enabled = False
601
if not quiet:
602
self.send_changedstate()
603
# Do not run this again if called by a gobject.timeout_add
604
return False
605
606
def __del__(self):
607
self.disable()
608
609
def init_checker(self):
610
273
# Schedule a new checker to be started an 'interval' from now,
611
274
# and every interval from then on.
612
if self.checker_initiator_tag is not None:
613
gobject.source_remove(self.checker_initiator_tag)
614
275
self.checker_initiator_tag = (gobject.timeout_add
615
276
(self.interval_milliseconds(),
616
277
self.start_checker))
278
# Also start a new checker *right now*.
279
self.start_checker()
617
280
# Schedule a disable() when 'timeout' has passed
618
if self.disable_initiator_tag is not None:
619
gobject.source_remove(self.disable_initiator_tag)
620
281
self.disable_initiator_tag = (gobject.timeout_add
621
282
(self.timeout_milliseconds(),
622
283
self.disable))
623
# Also start a new checker *right now*.
624
self.start_checker()
284
self.enabled = True
285
if self.use_dbus:
286
# Emit D-Bus signals
287
self.PropertyChanged(dbus.String(u"enabled"),
288
dbus.Boolean(True, variant_level=1))
289
self.PropertyChanged(dbus.String(u"last_enabled"),
290
(_datetime_to_dbus(self.last_enabled,
291
variant_level=1)))
292
293
def disable(self):
294
"""Disable this client."""
295
if not getattr(self, "enabled", False):
296
return False
297
logger.info(u"Disabling client %s", self.name)
298
if getattr(self, "disable_initiator_tag", False):
299
gobject.source_remove(self.disable_initiator_tag)
300
self.disable_initiator_tag = None
301
if getattr(self, "checker_initiator_tag", False):
302
gobject.source_remove(self.checker_initiator_tag)
303
self.checker_initiator_tag = None
304
self.stop_checker()
305
if self.disable_hook:
306
self.disable_hook(self)
307
self.enabled = False
308
if self.use_dbus:
309
# Emit D-Bus signal
310
self.PropertyChanged(dbus.String(u"enabled"),
311
dbus.Boolean(False, variant_level=1))
312
# Do not run this again if called by a gobject.timeout_add
313
return False
314
315
def __del__(self):
316
self.disable_hook = None
317
self.disable()
625
318
626
319
def checker_callback(self, pid, condition, command):
627
320
"""The checker has completed, so take appropriate actions."""
628
321
self.checker_callback_tag = None
629
322
self.checker = None
323
if self.use_dbus:
324
# Emit D-Bus signal
325
self.PropertyChanged(dbus.String(u"checker_running"),
326
dbus.Boolean(False, variant_level=1))
630
327
if os.WIFEXITED(condition):
631
self.last_checker_status = os.WEXITSTATUS(condition)
632
if self.last_checker_status == 0:
633
logger.info("Checker for %(name)s succeeded",
328
exitstatus = os.WEXITSTATUS(condition)
329
if exitstatus == 0:
330
logger.info(u"Checker for %(name)s succeeded",
634
331
vars(self))
635
332
self.checked_ok()
636
333
else:
637
logger.info("Checker for %(name)s failed",
334
logger.info(u"Checker for %(name)s failed",
638
335
vars(self))
336
if self.use_dbus:
337
# Emit D-Bus signal
338
self.CheckerCompleted(dbus.Int16(exitstatus),
339
dbus.Int64(condition),
340
dbus.String(command))
639
341
else:
640
self.last_checker_status = -1
641
logger.warning("Checker for %(name)s crashed?",
342
logger.warning(u"Checker for %(name)s crashed?",
642
343
vars(self))
344
if self.use_dbus:
345
# Emit D-Bus signal
346
self.CheckerCompleted(dbus.Int16(-1),
347
dbus.Int64(condition),
348
dbus.String(command))
643
349
644
350
def checked_ok(self):
645
"""Assert that the client has been seen, alive and well."""
351
"""Bump up the timeout for this client.
352
This should only be called when the client has been seen,
353
alive and well.
354
"""
646
355
self.last_checked_ok = datetime.datetime.utcnow()
647
self.last_checker_status = 0
648
self.bump_timeout()
649
650
def bump_timeout(self, timeout=None):
651
"""Bump up the timeout for this client."""
652
if timeout is None:
653
timeout = self.timeout
654
if self.disable_initiator_tag is not None:
655
gobject.source_remove(self.disable_initiator_tag)
656
self.disable_initiator_tag = None
657
if getattr(self, "enabled", False):
658
self.disable_initiator_tag = (gobject.timeout_add
659
(timedelta_to_milliseconds
660
(timeout), self.disable))
661
self.expires = datetime.datetime.utcnow() + timeout
662
663
def need_approval(self):
664
self.last_approval_request = datetime.datetime.utcnow()
356
gobject.source_remove(self.disable_initiator_tag)
357
self.disable_initiator_tag = (gobject.timeout_add
358
(self.timeout_milliseconds(),
359
self.disable))
360
if self.use_dbus:
361
# Emit D-Bus signal
362
self.PropertyChanged(
363
dbus.String(u"last_checked_ok"),
364
(_datetime_to_dbus(self.last_checked_ok,
365
variant_level=1)))
665
366
666
367
def start_checker(self):
667
368
"""Start a new checker subprocess if one is not running.
668
669
369
If a checker already exists, leave it running and do
670
370
nothing."""
671
371
# The reason for not killing a running checker is that if we
672
# did that, and if a checker (for some reason) started running
673
# slowly and taking more than 'interval' time, then the client
674
# would inevitably timeout, since no checker would get a
675
# chance to run to completion. If we instead leave running
372
# did that, then if a checker (for some reason) started
373
# running slowly and taking more than 'interval' time, the
374
# client would inevitably timeout, since no checker would get
375
# a chance to run to completion. If we instead leave running
676
376
# checkers alone, the checker would have to take more time
677
# than 'timeout' for the client to be disabled, which is as it
678
# should be.
679
680
# If a checker exists, make sure it is not a zombie
681
try:
682
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
683
except (AttributeError, OSError) as error:
684
if (isinstance(error, OSError)
685
and error.errno != errno.ECHILD):
686
raise error
687
else:
688
if pid:
689
logger.warning("Checker was a zombie")
690
gobject.source_remove(self.checker_callback_tag)
691
self.checker_callback(pid, status,
692
self.current_checker_command)
693
# Start a new checker if needed
377
# than 'timeout' for the client to be declared invalid, which
378
# is as it should be.
694
379
if self.checker is None:
695
# Escape attributes for the shell
696
escaped_attrs = dict(
697
(attr, re.escape(unicode(getattr(self, attr))))
698
for attr in
699
self.runtime_expansions)
700
try:
701
command = self.checker_command % escaped_attrs
702
except TypeError as error:
703
logger.error('Could not format string "%s"',
704
self.checker_command, exc_info=error)
705
return True # Try again later
706
self.current_checker_command = command
707
try:
708
logger.info("Starting checker %r for %s",
380
try:
381
# In case checker_command has exactly one % operator
382
command = self.checker_command % self.host
383
except TypeError:
384
# Escape attributes for the shell
385
escaped_attrs = dict((key, re.escape(str(val)))
386
for key, val in
387
vars(self).iteritems())
388
try:
389
command = self.checker_command % escaped_attrs
390
except TypeError, error:
391
logger.error(u'Could not format string "%s":'
392
u' %s', self.checker_command, error)
393
return True # Try again later
394
try:
395
logger.info(u"Starting checker %r for %s",
709
396
command, self.name)
710
397
# We don't need to redirect stdout and stderr, since
711
398
# in normal mode, that is already done by daemon(),
714
401
self.checker = subprocess.Popen(command,
715
402
close_fds=True,
716
403
shell=True, cwd="/")
717
except OSError as error:
718
logger.error("Failed to start subprocess",
719
exc_info=error)
720
self.checker_callback_tag = (gobject.child_watch_add
721
(self.checker.pid,
722
self.checker_callback,
723
data=command))
724
# The checker may have completed before the gobject
725
# watch was added. Check for this.
726
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
727
if pid:
728
gobject.source_remove(self.checker_callback_tag)
729
self.checker_callback(pid, status, command)
404
if self.use_dbus:
405
# Emit D-Bus signal
406
self.CheckerStarted(command)
407
self.PropertyChanged(
408
dbus.String("checker_running"),
409
dbus.Boolean(True, variant_level=1))
410
self.checker_callback_tag = (gobject.child_watch_add
411
(self.checker.pid,
412
self.checker_callback,
413
data=command))
414
except OSError, error:
415
logger.error(u"Failed to start subprocess: %s",
416
error)
730
417
# Re-run this periodically if run by gobject.timeout_add
731
418
return True
732
419
737
424
self.checker_callback_tag = None
738
425
if getattr(self, "checker", None) is None:
739
426
return
740
logger.debug("Stopping checker for %(name)s", vars(self))
427
logger.debug(u"Stopping checker for %(name)s", vars(self))
741
428
try:
742
self.checker.terminate()
743
#time.sleep(0.5)
429
os.kill(self.checker.pid, signal.SIGTERM)
430
#os.sleep(0.5)
744
431
#if self.checker.poll() is None:
745
# self.checker.kill()
746
except OSError as error:
432
# os.kill(self.checker.pid, signal.SIGKILL)
433
except OSError, error:
747
434
if error.errno != errno.ESRCH: # No such process
748
435
raise
749
436
self.checker = None
750
751
752
def dbus_service_property(dbus_interface, signature="v",
753
access="readwrite", byte_arrays=False):
754
"""Decorators for marking methods of a DBusObjectWithProperties to
755
become properties on the D-Bus.
756
757
The decorated method will be called with no arguments by "Get"
758
and with one argument by "Set".
759
760
The parameters, where they are supported, are the same as
761
dbus.service.method, except there is only "signature", since the
762
type from Get() and the type sent to Set() is the same.
763
"""
764
# Encoding deeply encoded byte arrays is not supported yet by the
765
# "Set" method, so we fail early here:
766
if byte_arrays and signature != "ay":
767
raise ValueError("Byte arrays not supported for non-'ay'"
768
" signature {0!r}".format(signature))
769
def decorator(func):
770
func._dbus_is_property = True
771
func._dbus_interface = dbus_interface
772
func._dbus_signature = signature
773
func._dbus_access = access
774
func._dbus_name = func.__name__
775
if func._dbus_name.endswith("_dbus_property"):
776
func._dbus_name = func._dbus_name[:-14]
777
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
778
return func
779
return decorator
780
781
782
def dbus_interface_annotations(dbus_interface):
783
"""Decorator for marking functions returning interface annotations
784
785
Usage:
786
787
@dbus_interface_annotations("org.example.Interface")
788
def _foo(self): # Function name does not matter
789
return {"org.freedesktop.DBus.Deprecated": "true",
790
"org.freedesktop.DBus.Property.EmitsChangedSignal":
791
"false"}
792
"""
793
def decorator(func):
794
func._dbus_is_interface = True
795
func._dbus_interface = dbus_interface
796
func._dbus_name = dbus_interface
797
return func
798
return decorator
799
800
801
def dbus_annotations(annotations):
802
"""Decorator to annotate D-Bus methods, signals or properties
803
Usage:
804
805
@dbus_service_property("org.example.Interface", signature="b",
806
access="r")
807
@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
808
"org.freedesktop.DBus.Property."
809
"EmitsChangedSignal": "false"})
810
def Property_dbus_property(self):
811
return dbus.Boolean(False)
812
"""
813
def decorator(func):
814
func._dbus_annotations = annotations
815
return func
816
return decorator
817
818
819
class DBusPropertyException(dbus.exceptions.DBusException):
820
"""A base class for D-Bus property-related exceptions
821
"""
822
def __unicode__(self):
823
return unicode(str(self))
824
825
826
class DBusPropertyAccessException(DBusPropertyException):
827
"""A property's access permissions disallows an operation.
828
"""
829
pass
830
831
832
class DBusPropertyNotFound(DBusPropertyException):
833
"""An attempt was made to access a non-existing property.
834
"""
835
pass
836
837
838
class DBusObjectWithProperties(dbus.service.Object):
839
"""A D-Bus object with properties.
840
841
Classes inheriting from this can use the dbus_service_property
842
decorator to expose methods as D-Bus properties. It exposes the
843
standard Get(), Set(), and GetAll() methods on the D-Bus.
844
"""
845
846
@staticmethod
847
def _is_dbus_thing(thing):
848
"""Returns a function testing if an attribute is a D-Bus thing
849
850
If called like _is_dbus_thing("method") it returns a function
851
suitable for use as predicate to inspect.getmembers().
852
"""
853
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
854
False)
855
856
def _get_all_dbus_things(self, thing):
857
"""Returns a generator of (name, attribute) pairs
858
"""
859
return ((getattr(athing.__get__(self), "_dbus_name",
860
name),
861
athing.__get__(self))
862
for cls in self.__class__.__mro__
863
for name, athing in
864
inspect.getmembers(cls,
865
self._is_dbus_thing(thing)))
866
867
def _get_dbus_property(self, interface_name, property_name):
868
"""Returns a bound method if one exists which is a D-Bus
869
property with the specified name and interface.
870
"""
871
for cls in self.__class__.__mro__:
872
for name, value in (inspect.getmembers
873
(cls,
874
self._is_dbus_thing("property"))):
875
if (value._dbus_name == property_name
876
and value._dbus_interface == interface_name):
877
return value.__get__(self)
878
879
# No such property
880
raise DBusPropertyNotFound(self.dbus_object_path + ":"
881
+ interface_name + "."
882
+ property_name)
883
884
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
885
out_signature="v")
886
def Get(self, interface_name, property_name):
887
"""Standard D-Bus property Get() method, see D-Bus standard.
888
"""
889
prop = self._get_dbus_property(interface_name, property_name)
890
if prop._dbus_access == "write":
891
raise DBusPropertyAccessException(property_name)
892
value = prop()
893
if not hasattr(value, "variant_level"):
894
return value
895
return type(value)(value, variant_level=value.variant_level+1)
896
897
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
898
def Set(self, interface_name, property_name, value):
899
"""Standard D-Bus property Set() method, see D-Bus standard.
900
"""
901
prop = self._get_dbus_property(interface_name, property_name)
902
if prop._dbus_access == "read":
903
raise DBusPropertyAccessException(property_name)
904
if prop._dbus_get_args_options["byte_arrays"]:
905
# The byte_arrays option is not supported yet on
906
# signatures other than "ay".
907
if prop._dbus_signature != "ay":
908
raise ValueError
909
value = dbus.ByteArray(b''.join(chr(byte)
910
for byte in value))
911
prop(value)
912
913
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
914
out_signature="a{sv}")
915
def GetAll(self, interface_name):
916
"""Standard D-Bus property GetAll() method, see D-Bus
917
standard.
918
919
Note: Will not include properties with access="write".
920
"""
921
properties = {}
922
for name, prop in self._get_all_dbus_things("property"):
923
if (interface_name
924
and interface_name != prop._dbus_interface):
925
# Interface non-empty but did not match
926
continue
927
# Ignore write-only properties
928
if prop._dbus_access == "write":
929
continue
930
value = prop()
931
if not hasattr(value, "variant_level"):
932
properties[name] = value
933
continue
934
properties[name] = type(value)(value, variant_level=
935
value.variant_level+1)
936
return dbus.Dictionary(properties, signature="sv")
937
938
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
939
out_signature="s",
940
path_keyword='object_path',
941
connection_keyword='connection')
942
def Introspect(self, object_path, connection):
943
"""Overloading of standard D-Bus method.
944
945
Inserts property tags and interface annotation tags.
946
"""
947
xmlstring = dbus.service.Object.Introspect(self, object_path,
948
connection)
949
try:
950
document = xml.dom.minidom.parseString(xmlstring)
951
def make_tag(document, name, prop):
952
e = document.createElement("property")
953
e.setAttribute("name", name)
954
e.setAttribute("type", prop._dbus_signature)
955
e.setAttribute("access", prop._dbus_access)
956
return e
957
for if_tag in document.getElementsByTagName("interface"):
958
# Add property tags
959
for tag in (make_tag(document, name, prop)
960
for name, prop
961
in self._get_all_dbus_things("property")
962
if prop._dbus_interface
963
== if_tag.getAttribute("name")):
964
if_tag.appendChild(tag)
965
# Add annotation tags
966
for typ in ("method", "signal", "property"):
967
for tag in if_tag.getElementsByTagName(typ):
968
annots = dict()
969
for name, prop in (self.
970
_get_all_dbus_things(typ)):
971
if (name == tag.getAttribute("name")
972
and prop._dbus_interface
973
== if_tag.getAttribute("name")):
974
annots.update(getattr
975
(prop,
976
"_dbus_annotations",
977
{}))
978
for name, value in annots.iteritems():
979
ann_tag = document.createElement(
980
"annotation")
981
ann_tag.setAttribute("name", name)
982
ann_tag.setAttribute("value", value)
983
tag.appendChild(ann_tag)
984
# Add interface annotation tags
985
for annotation, value in dict(
986
itertools.chain.from_iterable(
987
annotations().iteritems()
988
for name, annotations in
989
self._get_all_dbus_things("interface")
990
if name == if_tag.getAttribute("name")
991
)).iteritems():
992
ann_tag = document.createElement("annotation")
993
ann_tag.setAttribute("name", annotation)
994
ann_tag.setAttribute("value", value)
995
if_tag.appendChild(ann_tag)
996
# Add the names to the return values for the
997
# "org.freedesktop.DBus.Properties" methods
998
if (if_tag.getAttribute("name")
999
== "org.freedesktop.DBus.Properties"):
1000
for cn in if_tag.getElementsByTagName("method"):
1001
if cn.getAttribute("name") == "Get":
1002
for arg in cn.getElementsByTagName("arg"):
1003
if (arg.getAttribute("direction")
1004
== "out"):
1005
arg.setAttribute("name", "value")
1006
elif cn.getAttribute("name") == "GetAll":
1007
for arg in cn.getElementsByTagName("arg"):
1008
if (arg.getAttribute("direction")
1009
== "out"):
1010
arg.setAttribute("name", "props")
1011
xmlstring = document.toxml("utf-8")
1012
document.unlink()
1013
except (AttributeError, xml.dom.DOMException,
1014
xml.parsers.expat.ExpatError) as error:
1015
logger.error("Failed to override Introspection method",
1016
exc_info=error)
1017
return xmlstring
1018
1019
1020
def datetime_to_dbus(dt, variant_level=0):
1021
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1022
if dt is None:
1023
return dbus.String("", variant_level = variant_level)
1024
return dbus.String(dt.isoformat(),
1025
variant_level=variant_level)
1026
1027
1028
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1029
"""A class decorator; applied to a subclass of
1030
dbus.service.Object, it will add alternate D-Bus attributes with
1031
interface names according to the "alt_interface_names" mapping.
1032
Usage:
1033
1034
@alternate_dbus_interfaces({"org.example.Interface":
1035
"net.example.AlternateInterface"})
1036
class SampleDBusObject(dbus.service.Object):
1037
@dbus.service.method("org.example.Interface")
1038
def SampleDBusMethod():
1039
pass
1040
1041
The above "SampleDBusMethod" on "SampleDBusObject" will be
1042
reachable via two interfaces: "org.example.Interface" and
1043
"net.example.AlternateInterface", the latter of which will have
1044
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1045
"true", unless "deprecate" is passed with a False value.
1046
1047
This works for methods and signals, and also for D-Bus properties
1048
(from DBusObjectWithProperties) and interfaces (from the
1049
dbus_interface_annotations decorator).
1050
"""
1051
def wrapper(cls):
1052
for orig_interface_name, alt_interface_name in (
1053
alt_interface_names.iteritems()):
1054
attr = {}
1055
interface_names = set()
1056
# Go though all attributes of the class
1057
for attrname, attribute in inspect.getmembers(cls):
1058
# Ignore non-D-Bus attributes, and D-Bus attributes
1059
# with the wrong interface name
1060
if (not hasattr(attribute, "_dbus_interface")
1061
or not attribute._dbus_interface
1062
.startswith(orig_interface_name)):
1063
continue
1064
# Create an alternate D-Bus interface name based on
1065
# the current name
1066
alt_interface = (attribute._dbus_interface
1067
.replace(orig_interface_name,
1068
alt_interface_name))
1069
interface_names.add(alt_interface)
1070
# Is this a D-Bus signal?
1071
if getattr(attribute, "_dbus_is_signal", False):
1072
# Extract the original non-method function by
1073
# black magic
1074
nonmethod_func = (dict(
1075
zip(attribute.func_code.co_freevars,
1076
attribute.__closure__))["func"]
1077
.cell_contents)
1078
# Create a new, but exactly alike, function
1079
# object, and decorate it to be a new D-Bus signal
1080
# with the alternate D-Bus interface name
1081
new_function = (dbus.service.signal
1082
(alt_interface,
1083
attribute._dbus_signature)
1084
(types.FunctionType(
1085
nonmethod_func.func_code,
1086
nonmethod_func.func_globals,
1087
nonmethod_func.func_name,
1088
nonmethod_func.func_defaults,
1089
nonmethod_func.func_closure)))
1090
# Copy annotations, if any
1091
try:
1092
new_function._dbus_annotations = (
1093
dict(attribute._dbus_annotations))
1094
except AttributeError:
1095
pass
1096
# Define a creator of a function to call both the
1097
# original and alternate functions, so both the
1098
# original and alternate signals gets sent when
1099
# the function is called
1100
def fixscope(func1, func2):
1101
"""This function is a scope container to pass
1102
func1 and func2 to the "call_both" function
1103
outside of its arguments"""
1104
def call_both(*args, **kwargs):
1105
"""This function will emit two D-Bus
1106
signals by calling func1 and func2"""
1107
func1(*args, **kwargs)
1108
func2(*args, **kwargs)
1109
return call_both
1110
# Create the "call_both" function and add it to
1111
# the class
1112
attr[attrname] = fixscope(attribute, new_function)
1113
# Is this a D-Bus method?
1114
elif getattr(attribute, "_dbus_is_method", False):
1115
# Create a new, but exactly alike, function
1116
# object. Decorate it to be a new D-Bus method
1117
# with the alternate D-Bus interface name. Add it
1118
# to the class.
1119
attr[attrname] = (dbus.service.method
1120
(alt_interface,
1121
attribute._dbus_in_signature,
1122
attribute._dbus_out_signature)
1123
(types.FunctionType
1124
(attribute.func_code,
1125
attribute.func_globals,
1126
attribute.func_name,
1127
attribute.func_defaults,
1128
attribute.func_closure)))
1129
# Copy annotations, if any
1130
try:
1131
attr[attrname]._dbus_annotations = (
1132
dict(attribute._dbus_annotations))
1133
except AttributeError:
1134
pass
1135
# Is this a D-Bus property?
1136
elif getattr(attribute, "_dbus_is_property", False):
1137
# Create a new, but exactly alike, function
1138
# object, and decorate it to be a new D-Bus
1139
# property with the alternate D-Bus interface
1140
# name. Add it to the class.
1141
attr[attrname] = (dbus_service_property
1142
(alt_interface,
1143
attribute._dbus_signature,
1144
attribute._dbus_access,
1145
attribute
1146
._dbus_get_args_options
1147
["byte_arrays"])
1148
(types.FunctionType
1149
(attribute.func_code,
1150
attribute.func_globals,
1151
attribute.func_name,
1152
attribute.func_defaults,
1153
attribute.func_closure)))
1154
# Copy annotations, if any
1155
try:
1156
attr[attrname]._dbus_annotations = (
1157
dict(attribute._dbus_annotations))
1158
except AttributeError:
1159
pass
1160
# Is this a D-Bus interface?
1161
elif getattr(attribute, "_dbus_is_interface", False):
1162
# Create a new, but exactly alike, function
1163
# object. Decorate it to be a new D-Bus interface
1164
# with the alternate D-Bus interface name. Add it
1165
# to the class.
1166
attr[attrname] = (dbus_interface_annotations
1167
(alt_interface)
1168
(types.FunctionType
1169
(attribute.func_code,
1170
attribute.func_globals,
1171
attribute.func_name,
1172
attribute.func_defaults,
1173
attribute.func_closure)))
1174
if deprecate:
1175
# Deprecate all alternate interfaces
1176
iname="_AlternateDBusNames_interface_annotation{0}"
1177
for interface_name in interface_names:
1178
@dbus_interface_annotations(interface_name)
1179
def func(self):
1180
return { "org.freedesktop.DBus.Deprecated":
1181
"true" }
1182
# Find an unused name
1183
for aname in (iname.format(i)
1184
for i in itertools.count()):
1185
if aname not in attr:
1186
attr[aname] = func
1187
break
1188
if interface_names:
1189
# Replace the class with a new subclass of it with
1190
# methods, signals, etc. as created above.
1191
cls = type(b"{0}Alternate".format(cls.__name__),
1192
(cls,), attr)
1193
return cls
1194
return wrapper
1195
1196
1197
@alternate_dbus_interfaces({"se.recompile.Mandos":
1198
"se.bsnet.fukt.Mandos"})
1199
class ClientDBus(Client, DBusObjectWithProperties):
1200
"""A Client class using D-Bus
1201
1202
Attributes:
1203
dbus_object_path: dbus.ObjectPath
1204
bus: dbus.SystemBus()
1205
"""
1206
1207
runtime_expansions = (Client.runtime_expansions
1208
+ ("dbus_object_path",))
1209
1210
# dbus.service.Object doesn't use super(), so we can't either.
1211
1212
def __init__(self, bus = None, *args, **kwargs):
1213
self.bus = bus
1214
Client.__init__(self, *args, **kwargs)
1215
# Only now, when this client is initialized, can it show up on
1216
# the D-Bus
1217
client_object_name = unicode(self.name).translate(
1218
{ord("."): ord("_"),
1219
ord("-"): ord("_")})
1220
self.dbus_object_path = (dbus.ObjectPath
1221
("/clients/" + client_object_name))
1222
DBusObjectWithProperties.__init__(self, self.bus,
1223
self.dbus_object_path)
1224
1225
def notifychangeproperty(transform_func,
1226
dbus_name, type_func=lambda x: x,
1227
variant_level=1):
1228
""" Modify a variable so that it's a property which announces
1229
its changes to DBus.
1230
1231
transform_fun: Function that takes a value and a variant_level
1232
and transforms it to a D-Bus type.
1233
dbus_name: D-Bus name of the variable
1234
type_func: Function that transform the value before sending it
1235
to the D-Bus. Default: no transform
1236
variant_level: D-Bus variant level. Default: 1
1237
"""
1238
attrname = "_{0}".format(dbus_name)
1239
def setter(self, value):
1240
if hasattr(self, "dbus_object_path"):
1241
if (not hasattr(self, attrname) or
1242
type_func(getattr(self, attrname, None))
1243
!= type_func(value)):
1244
dbus_value = transform_func(type_func(value),
1245
variant_level
1246
=variant_level)
1247
self.PropertyChanged(dbus.String(dbus_name),
1248
dbus_value)
1249
setattr(self, attrname, value)
1250
1251
return property(lambda self: getattr(self, attrname), setter)
1252
1253
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1254
approvals_pending = notifychangeproperty(dbus.Boolean,
1255
"ApprovalPending",
1256
type_func = bool)
1257
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1258
last_enabled = notifychangeproperty(datetime_to_dbus,
1259
"LastEnabled")
1260
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
1261
type_func = lambda checker:
1262
checker is not None)
1263
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1264
"LastCheckedOK")
1265
last_checker_status = notifychangeproperty(dbus.Int16,
1266
"LastCheckerStatus")
1267
last_approval_request = notifychangeproperty(
1268
datetime_to_dbus, "LastApprovalRequest")
1269
approved_by_default = notifychangeproperty(dbus.Boolean,
1270
"ApprovedByDefault")
1271
approval_delay = notifychangeproperty(dbus.UInt64,
1272
"ApprovalDelay",
1273
type_func =
1274
timedelta_to_milliseconds)
1275
approval_duration = notifychangeproperty(
1276
dbus.UInt64, "ApprovalDuration",
1277
type_func = timedelta_to_milliseconds)
1278
host = notifychangeproperty(dbus.String, "Host")
1279
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1280
type_func =
1281
timedelta_to_milliseconds)
1282
extended_timeout = notifychangeproperty(
1283
dbus.UInt64, "ExtendedTimeout",
1284
type_func = timedelta_to_milliseconds)
1285
interval = notifychangeproperty(dbus.UInt64,
1286
"Interval",
1287
type_func =
1288
timedelta_to_milliseconds)
1289
checker_command = notifychangeproperty(dbus.String, "Checker")
1290
1291
del notifychangeproperty
1292
1293
def __del__(self, *args, **kwargs):
1294
try:
1295
self.remove_from_connection()
1296
except LookupError:
1297
pass
1298
if hasattr(DBusObjectWithProperties, "__del__"):
1299
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1300
Client.__del__(self, *args, **kwargs)
1301
1302
def checker_callback(self, pid, condition, command,
1303
*args, **kwargs):
1304
self.checker_callback_tag = None
1305
self.checker = None
1306
if os.WIFEXITED(condition):
1307
exitstatus = os.WEXITSTATUS(condition)
1308
# Emit D-Bus signal
1309
self.CheckerCompleted(dbus.Int16(exitstatus),
1310
dbus.Int64(condition),
1311
dbus.String(command))
1312
else:
1313
# Emit D-Bus signal
1314
self.CheckerCompleted(dbus.Int16(-1),
1315
dbus.Int64(condition),
1316
dbus.String(command))
1317
1318
return Client.checker_callback(self, pid, condition, command,
1319
*args, **kwargs)
1320
1321
def start_checker(self, *args, **kwargs):
1322
old_checker = self.checker
1323
if self.checker is not None:
1324
old_checker_pid = self.checker.pid
1325
else:
1326
old_checker_pid = None
1327
r = Client.start_checker(self, *args, **kwargs)
1328
# Only if new checker process was started
1329
if (self.checker is not None
1330
and old_checker_pid != self.checker.pid):
1331
# Emit D-Bus signal
1332
self.CheckerStarted(self.current_checker_command)
1333
return r
1334
1335
def _reset_approved(self):
1336
self.approved = None
1337
return False
1338
1339
def approve(self, value=True):
1340
self.approved = value
1341
gobject.timeout_add(timedelta_to_milliseconds
1342
(self.approval_duration),
1343
self._reset_approved)
1344
self.send_changedstate()
1345
1346
## D-Bus methods, signals & properties
1347
_interface = "se.recompile.Mandos.Client"
1348
1349
## Interfaces
1350
1351
@dbus_interface_annotations(_interface)
1352
def _foo(self):
1353
return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
1354
"false"}
1355
1356
## Signals
437
if self.use_dbus:
438
self.PropertyChanged(dbus.String(u"checker_running"),
439
dbus.Boolean(False, variant_level=1))
440
441
def still_valid(self):
442
"""Has the timeout not yet passed for this client?"""
443
if not getattr(self, "enabled", False):
444
return False
445
now = datetime.datetime.utcnow()
446
if self.last_checked_ok is None:
447
return now < (self.created + self.timeout)
448
else:
449
return now < (self.last_checked_ok + self.timeout)
450
451
## D-Bus methods & signals
452
_interface = u"se.bsnet.fukt.Mandos.Client"
453
454
# CheckedOK - method
455
CheckedOK = dbus.service.method(_interface)(checked_ok)
456
CheckedOK.__name__ = "CheckedOK"
1357
457
1358
458
# CheckerCompleted - signal
1359
459
@dbus.service.signal(_interface, signature="nxs")
1367
467
"D-Bus signal"
1368
468
pass
1369
469
470
# GetAllProperties - method
471
@dbus.service.method(_interface, out_signature="a{sv}")
472
def GetAllProperties(self):
473
"D-Bus method"
474
return dbus.Dictionary({
475
dbus.String("name"):
476
dbus.String(self.name, variant_level=1),
477
dbus.String("fingerprint"):
478
dbus.String(self.fingerprint, variant_level=1),
479
dbus.String("host"):
480
dbus.String(self.host, variant_level=1),
481
dbus.String("created"):
482
_datetime_to_dbus(self.created, variant_level=1),
483
dbus.String("last_enabled"):
484
(_datetime_to_dbus(self.last_enabled,
485
variant_level=1)
486
if self.last_enabled is not None
487
else dbus.Boolean(False, variant_level=1)),
488
dbus.String("enabled"):
489
dbus.Boolean(self.enabled, variant_level=1),
490
dbus.String("last_checked_ok"):
491
(_datetime_to_dbus(self.last_checked_ok,
492
variant_level=1)
493
if self.last_checked_ok is not None
494
else dbus.Boolean (False, variant_level=1)),
495
dbus.String("timeout"):
496
dbus.UInt64(self.timeout_milliseconds(),
497
variant_level=1),
498
dbus.String("interval"):
499
dbus.UInt64(self.interval_milliseconds(),
500
variant_level=1),
501
dbus.String("checker"):
502
dbus.String(self.checker_command,
503
variant_level=1),
504
dbus.String("checker_running"):
505
dbus.Boolean(self.checker is not None,
506
variant_level=1),
507
dbus.String("object_path"):
508
dbus.ObjectPath(self.dbus_object_path,
509
variant_level=1)
510
}, signature="sv")
511
512
# IsStillValid - method
513
IsStillValid = (dbus.service.method(_interface, out_signature="b")
514
(still_valid))
515
IsStillValid.__name__ = "IsStillValid"
516
1370
517
# PropertyChanged - signal
1371
518
@dbus.service.signal(_interface, signature="sv")
1372
519
def PropertyChanged(self, property, value):
1373
520
"D-Bus signal"
1374
521
pass
1375
522
1376
# GotSecret - signal
1377
@dbus.service.signal(_interface)
1378
def GotSecret(self):
1379
"""D-Bus signal
1380
Is sent after a successful transfer of secret from the Mandos
1381
server to mandos-client
1382
"""
1383
pass
1384
1385
# Rejected - signal
1386
@dbus.service.signal(_interface, signature="s")
1387
def Rejected(self, reason):
1388
"D-Bus signal"
1389
pass
1390
1391
# NeedApproval - signal
1392
@dbus.service.signal(_interface, signature="tb")
1393
def NeedApproval(self, timeout, default):
1394
"D-Bus signal"
1395
return self.need_approval()
1396
1397
## Methods
1398
1399
# Approve - method
1400
@dbus.service.method(_interface, in_signature="b")
1401
def Approve(self, value):
1402
self.approve(value)
1403
1404
# CheckedOK - method
1405
@dbus.service.method(_interface)
1406
def CheckedOK(self):
1407
self.checked_ok()
523
# SetChecker - method
524
@dbus.service.method(_interface, in_signature="s")
525
def SetChecker(self, checker):
526
"D-Bus setter method"
527
self.checker_command = checker
528
# Emit D-Bus signal
529
self.PropertyChanged(dbus.String(u"checker"),
530
dbus.String(self.checker_command,
531
variant_level=1))
532
533
# SetHost - method
534
@dbus.service.method(_interface, in_signature="s")
535
def SetHost(self, host):
536
"D-Bus setter method"
537
self.host = host
538
# Emit D-Bus signal
539
self.PropertyChanged(dbus.String(u"host"),
540
dbus.String(self.host, variant_level=1))
541
542
# SetInterval - method
543
@dbus.service.method(_interface, in_signature="t")
544
def SetInterval(self, milliseconds):
545
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
546
# Emit D-Bus signal
547
self.PropertyChanged(dbus.String(u"interval"),
548
(dbus.UInt64(self.interval_milliseconds(),
549
variant_level=1)))
550
551
# SetSecret - method
552
@dbus.service.method(_interface, in_signature="ay",
553
byte_arrays=True)
554
def SetSecret(self, secret):
555
"D-Bus setter method"
556
self.secret = str(secret)
557
558
# SetTimeout - method
559
@dbus.service.method(_interface, in_signature="t")
560
def SetTimeout(self, milliseconds):
561
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
562
# Emit D-Bus signal
563
self.PropertyChanged(dbus.String(u"timeout"),
564
(dbus.UInt64(self.timeout_milliseconds(),
565
variant_level=1)))
1408
566
1409
567
# Enable - method
1410
@dbus.service.method(_interface)
1411
def Enable(self):
1412
"D-Bus method"
1413
self.enable()
568
Enable = dbus.service.method(_interface)(enable)
569
Enable.__name__ = "Enable"
1414
570
1415
571
# StartChecker - method
1416
572
@dbus.service.method(_interface)
1425
581
self.disable()
1426
582
1427
583
# StopChecker - method
1428
@dbus.service.method(_interface)
1429
def StopChecker(self):
1430
self.stop_checker()
1431
1432
## Properties
1433
1434
# ApprovalPending - property
1435
@dbus_service_property(_interface, signature="b", access="read")
1436
def ApprovalPending_dbus_property(self):
1437
return dbus.Boolean(bool(self.approvals_pending))
1438
1439
# ApprovedByDefault - property
1440
@dbus_service_property(_interface, signature="b",
1441
access="readwrite")
1442
def ApprovedByDefault_dbus_property(self, value=None):
1443
if value is None: # get
1444
return dbus.Boolean(self.approved_by_default)
1445
self.approved_by_default = bool(value)
1446
1447
# ApprovalDelay - property
1448
@dbus_service_property(_interface, signature="t",
1449
access="readwrite")
1450
def ApprovalDelay_dbus_property(self, value=None):
1451
if value is None: # get
1452
return dbus.UInt64(self.approval_delay_milliseconds())
1453
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1454
1455
# ApprovalDuration - property
1456
@dbus_service_property(_interface, signature="t",
1457
access="readwrite")
1458
def ApprovalDuration_dbus_property(self, value=None):
1459
if value is None: # get
1460
return dbus.UInt64(timedelta_to_milliseconds(
1461
self.approval_duration))
1462
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1463
1464
# Name - property
1465
@dbus_service_property(_interface, signature="s", access="read")
1466
def Name_dbus_property(self):
1467
return dbus.String(self.name)
1468
1469
# Fingerprint - property
1470
@dbus_service_property(_interface, signature="s", access="read")
1471
def Fingerprint_dbus_property(self):
1472
return dbus.String(self.fingerprint)
1473
1474
# Host - property
1475
@dbus_service_property(_interface, signature="s",
1476
access="readwrite")
1477
def Host_dbus_property(self, value=None):
1478
if value is None: # get
1479
return dbus.String(self.host)
1480
self.host = unicode(value)
1481
1482
# Created - property
1483
@dbus_service_property(_interface, signature="s", access="read")
1484
def Created_dbus_property(self):
1485
return datetime_to_dbus(self.created)
1486
1487
# LastEnabled - property
1488
@dbus_service_property(_interface, signature="s", access="read")
1489
def LastEnabled_dbus_property(self):
1490
return datetime_to_dbus(self.last_enabled)
1491
1492
# Enabled - property
1493
@dbus_service_property(_interface, signature="b",
1494
access="readwrite")
1495
def Enabled_dbus_property(self, value=None):
1496
if value is None: # get
1497
return dbus.Boolean(self.enabled)
1498
if value:
1499
self.enable()
1500
else:
1501
self.disable()
1502
1503
# LastCheckedOK - property
1504
@dbus_service_property(_interface, signature="s",
1505
access="readwrite")
1506
def LastCheckedOK_dbus_property(self, value=None):
1507
if value is not None:
1508
self.checked_ok()
1509
return
1510
return datetime_to_dbus(self.last_checked_ok)
1511
1512
# LastCheckerStatus - property
1513
@dbus_service_property(_interface, signature="n",
1514
access="read")
1515
def LastCheckerStatus_dbus_property(self):
1516
return dbus.Int16(self.last_checker_status)
1517
1518
# Expires - property
1519
@dbus_service_property(_interface, signature="s", access="read")
1520
def Expires_dbus_property(self):
1521
return datetime_to_dbus(self.expires)
1522
1523
# LastApprovalRequest - property
1524
@dbus_service_property(_interface, signature="s", access="read")
1525
def LastApprovalRequest_dbus_property(self):
1526
return datetime_to_dbus(self.last_approval_request)
1527
1528
# Timeout - property
1529
@dbus_service_property(_interface, signature="t",
1530
access="readwrite")
1531
def Timeout_dbus_property(self, value=None):
1532
if value is None: # get
1533
return dbus.UInt64(self.timeout_milliseconds())
1534
old_timeout = self.timeout
1535
self.timeout = datetime.timedelta(0, 0, 0, value)
1536
# Reschedule disabling
1537
if self.enabled:
1538
now = datetime.datetime.utcnow()
1539
self.expires += self.timeout - old_timeout
1540
if self.expires <= now:
1541
# The timeout has passed
1542
self.disable()
1543
else:
1544
if (getattr(self, "disable_initiator_tag", None)
1545
is None):
1546
return
1547
gobject.source_remove(self.disable_initiator_tag)
1548
self.disable_initiator_tag = (
1549
gobject.timeout_add(
1550
timedelta_to_milliseconds(self.expires - now),
1551
self.disable))
1552
1553
# ExtendedTimeout - property
1554
@dbus_service_property(_interface, signature="t",
1555
access="readwrite")
1556
def ExtendedTimeout_dbus_property(self, value=None):
1557
if value is None: # get
1558
return dbus.UInt64(self.extended_timeout_milliseconds())
1559
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1560
1561
# Interval - property
1562
@dbus_service_property(_interface, signature="t",
1563
access="readwrite")
1564
def Interval_dbus_property(self, value=None):
1565
if value is None: # get
1566
return dbus.UInt64(self.interval_milliseconds())
1567
self.interval = datetime.timedelta(0, 0, 0, value)
1568
if getattr(self, "checker_initiator_tag", None) is None:
1569
return
1570
if self.enabled:
1571
# Reschedule checker run
1572
gobject.source_remove(self.checker_initiator_tag)
1573
self.checker_initiator_tag = (gobject.timeout_add
1574
(value, self.start_checker))
1575
self.start_checker() # Start one now, too
1576
1577
# Checker - property
1578
@dbus_service_property(_interface, signature="s",
1579
access="readwrite")
1580
def Checker_dbus_property(self, value=None):
1581
if value is None: # get
1582
return dbus.String(self.checker_command)
1583
self.checker_command = unicode(value)
1584
1585
# CheckerRunning - property
1586
@dbus_service_property(_interface, signature="b",
1587
access="readwrite")
1588
def CheckerRunning_dbus_property(self, value=None):
1589
if value is None: # get
1590
return dbus.Boolean(self.checker is not None)
1591
if value:
1592
self.start_checker()
1593
else:
1594
self.stop_checker()
1595
1596
# ObjectPath - property
1597
@dbus_service_property(_interface, signature="o", access="read")
1598
def ObjectPath_dbus_property(self):
1599
return self.dbus_object_path # is already a dbus.ObjectPath
1600
1601
# Secret = property
1602
@dbus_service_property(_interface, signature="ay",
1603
access="write", byte_arrays=True)
1604
def Secret_dbus_property(self, value):
1605
self.secret = str(value)
584
StopChecker = dbus.service.method(_interface)(stop_checker)
585
StopChecker.__name__ = "StopChecker"
1606
586
1607
587
del _interface
1608
588
1609
589
1610
class ProxyClient(object):
1611
def __init__(self, child_pipe, fpr, address):
1612
self._pipe = child_pipe
1613
self._pipe.send(('init', fpr, address))
1614
if not self._pipe.recv():
1615
raise KeyError()
1616
1617
def __getattribute__(self, name):
1618
if name == '_pipe':
1619
return super(ProxyClient, self).__getattribute__(name)
1620
self._pipe.send(('getattr', name))
1621
data = self._pipe.recv()
1622
if data[0] == 'data':
1623
return data[1]
1624
if data[0] == 'function':
1625
def func(*args, **kwargs):
1626
self._pipe.send(('funcall', name, args, kwargs))
1627
return self._pipe.recv()[1]
1628
return func
1629
1630
def __setattr__(self, name, value):
1631
if name == '_pipe':
1632
return super(ProxyClient, self).__setattr__(name, value)
1633
self._pipe.send(('setattr', name, value))
1634
1635
1636
class ClientHandler(socketserver.BaseRequestHandler, object):
1637
"""A class to handle client connections.
1638
1639
Instantiated once for each connection to handle it.
590
def peer_certificate(session):
591
"Return the peer's OpenPGP certificate as a bytestring"
592
# If not an OpenPGP certificate...
593
if (gnutls.library.functions
594
.gnutls_certificate_type_get(session._c_object)
595
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
596
# ...do the normal thing
597
return session.peer_certificate
598
list_size = ctypes.c_uint(1)
599
cert_list = (gnutls.library.functions
600
.gnutls_certificate_get_peers
601
(session._c_object, ctypes.byref(list_size)))
602
if not bool(cert_list) and list_size.value != 0:
603
raise gnutls.errors.GNUTLSError("error getting peer"
604
" certificate")
605
if list_size.value == 0:
606
return None
607
cert = cert_list[0]
608
return ctypes.string_at(cert.data, cert.size)
609
610
611
def fingerprint(openpgp):
612
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
613
# New GnuTLS "datum" with the OpenPGP public key
614
datum = (gnutls.library.types
615
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
616
ctypes.POINTER
617
(ctypes.c_ubyte)),
618
ctypes.c_uint(len(openpgp))))
619
# New empty GnuTLS certificate
620
crt = gnutls.library.types.gnutls_openpgp_crt_t()
621
(gnutls.library.functions
622
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
623
# Import the OpenPGP public key into the certificate
624
(gnutls.library.functions
625
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
626
gnutls.library.constants
627
.GNUTLS_OPENPGP_FMT_RAW))
628
# Verify the self signature in the key
629
crtverify = ctypes.c_uint()
630
(gnutls.library.functions
631
.gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
632
if crtverify.value != 0:
633
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
634
raise gnutls.errors.CertificateSecurityError("Verify failed")
635
# New buffer for the fingerprint
636
buf = ctypes.create_string_buffer(20)
637
buf_len = ctypes.c_size_t()
638
# Get the fingerprint from the certificate into the buffer
639
(gnutls.library.functions
640
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
641
ctypes.byref(buf_len)))
642
# Deinit the certificate
643
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
644
# Convert the buffer to a Python bytestring
645
fpr = ctypes.string_at(buf, buf_len.value)
646
# Convert the bytestring to hexadecimal notation
647
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
648
return hex_fpr
649
650
651
class TCP_handler(SocketServer.BaseRequestHandler, object):
652
"""A TCP request handler class.
653
Instantiated by IPv6_TCPServer for each request to handle it.
1640
654
Note: This will run in its own forked process."""
1641
655
1642
656
def handle(self):
1643
with contextlib.closing(self.server.child_pipe) as child_pipe:
1644
logger.info("TCP connection from: %s",
1645
unicode(self.client_address))
1646
logger.debug("Pipe FD: %d",
1647
self.server.child_pipe.fileno())
1648
1649
session = (gnutls.connection
1650
.ClientSession(self.request,
1651
gnutls.connection
1652
.X509Credentials()))
1653
1654
# Note: gnutls.connection.X509Credentials is really a
1655
# generic GnuTLS certificate credentials object so long as
1656
# no X.509 keys are added to it. Therefore, we can use it
1657
# here despite using OpenPGP certificates.
1658
1659
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1660
# "+AES-256-CBC", "+SHA1",
1661
# "+COMP-NULL", "+CTYPE-OPENPGP",
1662
# "+DHE-DSS"))
1663
# Use a fallback default, since this MUST be set.
1664
priority = self.server.gnutls_priority
1665
if priority is None:
1666
priority = "NORMAL"
1667
(gnutls.library.functions
1668
.gnutls_priority_set_direct(session._c_object,
1669
priority, None))
1670
1671
# Start communication using the Mandos protocol
1672
# Get protocol number
1673
line = self.request.makefile().readline()
1674
logger.debug("Protocol version: %r", line)
1675
try:
1676
if int(line.strip().split()[0]) > 1:
1677
raise RuntimeError
1678
except (ValueError, IndexError, RuntimeError) as error:
1679
logger.error("Unknown protocol version: %s", error)
1680
return
1681
1682
# Start GnuTLS connection
1683
try:
1684
session.handshake()
1685
except gnutls.errors.GNUTLSError as error:
1686
logger.warning("Handshake failed: %s", error)
1687
# Do not run session.bye() here: the session is not
1688
# established. Just abandon the request.
1689
return
1690
logger.debug("Handshake succeeded")
1691
1692
approval_required = False
1693
try:
1694
try:
1695
fpr = self.fingerprint(self.peer_certificate
1696
(session))
1697
except (TypeError,
1698
gnutls.errors.GNUTLSError) as error:
1699
logger.warning("Bad certificate: %s", error)
1700
return
1701
logger.debug("Fingerprint: %s", fpr)
1702
1703
try:
1704
client = ProxyClient(child_pipe, fpr,
1705
self.client_address)
1706
except KeyError:
1707
return
1708
1709
if client.approval_delay:
1710
delay = client.approval_delay
1711
client.approvals_pending += 1
1712
approval_required = True
1713
1714
while True:
1715
if not client.enabled:
1716
logger.info("Client %s is disabled",
1717
client.name)
1718
if self.server.use_dbus:
1719
# Emit D-Bus signal
1720
client.Rejected("Disabled")
1721
return
1722
1723
if client.approved or not client.approval_delay:
1724
#We are approved or approval is disabled
1725
break
1726
elif client.approved is None:
1727
logger.info("Client %s needs approval",
1728
client.name)
1729
if self.server.use_dbus:
1730
# Emit D-Bus signal
1731
client.NeedApproval(
1732
client.approval_delay_milliseconds(),
1733
client.approved_by_default)
1734
else:
1735
logger.warning("Client %s was not approved",
1736
client.name)
1737
if self.server.use_dbus:
1738
# Emit D-Bus signal
1739
client.Rejected("Denied")
1740
return
1741
1742
#wait until timeout or approved
1743
time = datetime.datetime.now()
1744
client.changedstate.acquire()
1745
client.changedstate.wait(
1746
float(timedelta_to_milliseconds(delay)
1747
/ 1000))
1748
client.changedstate.release()
1749
time2 = datetime.datetime.now()
1750
if (time2 - time) >= delay:
1751
if not client.approved_by_default:
1752
logger.warning("Client %s timed out while"
1753
" waiting for approval",
1754
client.name)
1755
if self.server.use_dbus:
1756
# Emit D-Bus signal
1757
client.Rejected("Approval timed out")
1758
return
1759
else:
1760
break
1761
else:
1762
delay -= time2 - time
1763
1764
sent_size = 0
1765
while sent_size < len(client.secret):
1766
try:
1767
sent = session.send(client.secret[sent_size:])
1768
except gnutls.errors.GNUTLSError as error:
1769
logger.warning("gnutls send failed",
1770
exc_info=error)
1771
return
1772
logger.debug("Sent: %d, remaining: %d",
1773
sent, len(client.secret)
1774
- (sent_size + sent))
1775
sent_size += sent
1776
1777
logger.info("Sending secret to %s", client.name)
1778
# bump the timeout using extended_timeout
1779
client.bump_timeout(client.extended_timeout)
1780
if self.server.use_dbus:
1781
# Emit D-Bus signal
1782
client.GotSecret()
1783
1784
finally:
1785
if approval_required:
1786
client.approvals_pending -= 1
1787
try:
1788
session.bye()
1789
except gnutls.errors.GNUTLSError as error:
1790
logger.warning("GnuTLS bye failed",
1791
exc_info=error)
1792
1793
@staticmethod
1794
def peer_certificate(session):
1795
"Return the peer's OpenPGP certificate as a bytestring"
1796
# If not an OpenPGP certificate...
1797
if (gnutls.library.functions
1798
.gnutls_certificate_type_get(session._c_object)
1799
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1800
# ...do the normal thing
1801
return session.peer_certificate
1802
list_size = ctypes.c_uint(1)
1803
cert_list = (gnutls.library.functions
1804
.gnutls_certificate_get_peers
1805
(session._c_object, ctypes.byref(list_size)))
1806
if not bool(cert_list) and list_size.value != 0:
1807
raise gnutls.errors.GNUTLSError("error getting peer"
1808
" certificate")
1809
if list_size.value == 0:
1810
return None
1811
cert = cert_list[0]
1812
return ctypes.string_at(cert.data, cert.size)
1813
1814
@staticmethod
1815
def fingerprint(openpgp):
1816
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1817
# New GnuTLS "datum" with the OpenPGP public key
1818
datum = (gnutls.library.types
1819
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1820
ctypes.POINTER
1821
(ctypes.c_ubyte)),
1822
ctypes.c_uint(len(openpgp))))
1823
# New empty GnuTLS certificate
1824
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1825
(gnutls.library.functions
1826
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1827
# Import the OpenPGP public key into the certificate
1828
(gnutls.library.functions
1829
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1830
gnutls.library.constants
1831
.GNUTLS_OPENPGP_FMT_RAW))
1832
# Verify the self signature in the key
1833
crtverify = ctypes.c_uint()
1834
(gnutls.library.functions
1835
.gnutls_openpgp_crt_verify_self(crt, 0,
1836
ctypes.byref(crtverify)))
1837
if crtverify.value != 0:
1838
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1839
raise (gnutls.errors.CertificateSecurityError
1840
("Verify failed"))
1841
# New buffer for the fingerprint
1842
buf = ctypes.create_string_buffer(20)
1843
buf_len = ctypes.c_size_t()
1844
# Get the fingerprint from the certificate into the buffer
1845
(gnutls.library.functions
1846
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1847
ctypes.byref(buf_len)))
1848
# Deinit the certificate
1849
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1850
# Convert the buffer to a Python bytestring
1851
fpr = ctypes.string_at(buf, buf_len.value)
1852
# Convert the bytestring to hexadecimal notation
1853
hex_fpr = binascii.hexlify(fpr).upper()
1854
return hex_fpr
1855
1856
1857
class MultiprocessingMixIn(object):
1858
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1859
def sub_process_main(self, request, address):
1860
try:
1861
self.finish_request(request, address)
1862
except Exception:
1863
self.handle_error(request, address)
1864
self.close_request(request)
1865
1866
def process_request(self, request, address):
1867
"""Start a new process to process the request."""
1868
proc = multiprocessing.Process(target = self.sub_process_main,
1869
args = (request, address))
1870
proc.start()
1871
return proc
1872
1873
1874
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1875
""" adds a pipe to the MixIn """
1876
def process_request(self, request, client_address):
1877
"""Overrides and wraps the original process_request().
1878
1879
This function creates a new pipe in self.pipe
1880
"""
1881
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1882
1883
proc = MultiprocessingMixIn.process_request(self, request,
1884
client_address)
1885
self.child_pipe.close()
1886
self.add_pipe(parent_pipe, proc)
1887
1888
def add_pipe(self, parent_pipe, proc):
1889
"""Dummy function; override as necessary"""
1890
raise NotImplementedError
1891
1892
1893
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1894
socketserver.TCPServer, object):
1895
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
1896
657
logger.info(u"TCP connection from: %s",
658
unicode(self.client_address))
659
session = (gnutls.connection
660
.ClientSession(self.request,
661
gnutls.connection
662
.X509Credentials()))
663
664
line = self.request.makefile().readline()
665
logger.debug(u"Protocol version: %r", line)
666
try:
667
if int(line.strip().split()[0]) > 1:
668
raise RuntimeError
669
except (ValueError, IndexError, RuntimeError), error:
670
logger.error(u"Unknown protocol version: %s", error)
671
return
672
673
# Note: gnutls.connection.X509Credentials is really a generic
674
# GnuTLS certificate credentials object so long as no X.509
675
# keys are added to it. Therefore, we can use it here despite
676
# using OpenPGP certificates.
677
678
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
679
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
680
# "+DHE-DSS"))
681
# Use a fallback default, since this MUST be set.
682
priority = self.server.settings.get("priority", "NORMAL")
683
(gnutls.library.functions
684
.gnutls_priority_set_direct(session._c_object,
685
priority, None))
686
687
try:
688
session.handshake()
689
except gnutls.errors.GNUTLSError, error:
690
logger.warning(u"Handshake failed: %s", error)
691
# Do not run session.bye() here: the session is not
692
# established. Just abandon the request.
693
return
694
logger.debug(u"Handshake succeeded")
695
try:
696
fpr = fingerprint(peer_certificate(session))
697
except (TypeError, gnutls.errors.GNUTLSError), error:
698
logger.warning(u"Bad certificate: %s", error)
699
session.bye()
700
return
701
logger.debug(u"Fingerprint: %s", fpr)
702
703
for c in self.server.clients:
704
if c.fingerprint == fpr:
705
client = c
706
break
707
else:
708
logger.warning(u"Client not found for fingerprint: %s",
709
fpr)
710
session.bye()
711
return
712
# Have to check if client.still_valid(), since it is possible
713
# that the client timed out while establishing the GnuTLS
714
# session.
715
if not client.still_valid():
716
logger.warning(u"Client %(name)s is invalid",
717
vars(client))
718
session.bye()
719
return
720
## This won't work here, since we're in a fork.
721
# client.checked_ok()
722
sent_size = 0
723
while sent_size < len(client.secret):
724
sent = session.send(client.secret[sent_size:])
725
logger.debug(u"Sent: %d, remaining: %d",
726
sent, len(client.secret)
727
- (sent_size + sent))
728
sent_size += sent
729
session.bye()
730
731
732
class IPv6_TCPServer(SocketServer.ForkingMixIn,
733
SocketServer.TCPServer, object):
734
"""IPv6 TCP server. Accepts 'None' as address and/or port.
1897
735
Attributes:
736
settings: Server settings
737
clients: Set() of Client objects
1898
738
enabled: Boolean; whether this server is activated yet
1899
interface: None or a network interface name (string)
1900
use_ipv6: Boolean; to use IPv6 or not
1901
739
"""
1902
def __init__(self, server_address, RequestHandlerClass,
1903
interface=None, use_ipv6=True, socketfd=None):
1904
"""If socketfd is set, use that file descriptor instead of
1905
creating a new one with socket.socket().
1906
"""
1907
self.interface = interface
1908
if use_ipv6:
1909
self.address_family = socket.AF_INET6
1910
if socketfd is not None:
1911
# Save the file descriptor
1912
self.socketfd = socketfd
1913
# Save the original socket.socket() function
1914
self.socket_socket = socket.socket
1915
# To implement --socket, we monkey patch socket.socket.
1916
#
1917
# (When socketserver.TCPServer is a new-style class, we
1918
# could make self.socket into a property instead of monkey
1919
# patching socket.socket.)
1920
#
1921
# Create a one-time-only replacement for socket.socket()
1922
@functools.wraps(socket.socket)
1923
def socket_wrapper(*args, **kwargs):
1924
# Restore original function so subsequent calls are
1925
# not affected.
1926
socket.socket = self.socket_socket
1927
del self.socket_socket
1928
# This time only, return a new socket object from the
1929
# saved file descriptor.
1930
return socket.fromfd(self.socketfd, *args, **kwargs)
1931
# Replace socket.socket() function with wrapper
1932
socket.socket = socket_wrapper
1933
# The socketserver.TCPServer.__init__ will call
1934
# socket.socket(), which might be our replacement,
1935
# socket_wrapper(), if socketfd was set.
1936
socketserver.TCPServer.__init__(self, server_address,
1937
RequestHandlerClass)
1938
740
address_family = socket.AF_INET6
741
def __init__(self, *args, **kwargs):
742
if "settings" in kwargs:
743
self.settings = kwargs["settings"]
744
del kwargs["settings"]
745
if "clients" in kwargs:
746
self.clients = kwargs["clients"]
747
del kwargs["clients"]
748
self.enabled = False
749
super(IPv6_TCPServer, self).__init__(*args, **kwargs)
1939
750
def server_bind(self):
1940
751
"""This overrides the normal server_bind() function
1941
752
to bind to an interface if one was specified, and also NOT to
1942
753
bind to an address or port if they were not specified."""
1943
if self.interface is not None:
1944
if SO_BINDTODEVICE is None:
1945
logger.error("SO_BINDTODEVICE does not exist;"
1946
" cannot bind to interface %s",
1947
self.interface)
1948
else:
1949
try:
1950
self.socket.setsockopt(socket.SOL_SOCKET,
1951
SO_BINDTODEVICE,
1952
str(self.interface + '\0'))
1953
except socket.error as error:
1954
if error.errno == errno.EPERM:
1955
logger.error("No permission to bind to"
1956
" interface %s", self.interface)
1957
elif error.errno == errno.ENOPROTOOPT:
1958
logger.error("SO_BINDTODEVICE not available;"
1959
" cannot bind to interface %s",
1960
self.interface)
1961
elif error.errno == errno.ENODEV:
1962
logger.error("Interface %s does not exist,"
1963
" cannot bind", self.interface)
1964
else:
1965
raise
754
if self.settings["interface"]:
755
# 25 is from /usr/include/asm-i486/socket.h
756
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
757
try:
758
self.socket.setsockopt(socket.SOL_SOCKET,
759
SO_BINDTODEVICE,
760
self.settings["interface"])
761
except socket.error, error:
762
if error[0] == errno.EPERM:
763
logger.error(u"No permission to"
764
u" bind to interface %s",
765
self.settings["interface"])
766
else:
767
raise error
1966
768
# Only bind(2) the socket if we really need to.
1967
769
if self.server_address[0] or self.server_address[1]:
1968
770
if not self.server_address[0]:
1969
if self.address_family == socket.AF_INET6:
1970
any_address = "::" # in6addr_any
1971
else:
1972
any_address = socket.INADDR_ANY
1973
self.server_address = (any_address,
771
in6addr_any = "::"
772
self.server_address = (in6addr_any,
1974
773
self.server_address[1])
1975
774
elif not self.server_address[1]:
1976
775
self.server_address = (self.server_address[0],
1977
776
0)
1978
# if self.interface:
777
# if self.settings["interface"]:
1979
778
# self.server_address = (self.server_address[0],
1980
779
# 0, # port
1981
780
# 0, # flowinfo
1982
781
# if_nametoindex
1983
# (self.interface))
1984
return socketserver.TCPServer.server_bind(self)
1985
1986
1987
class MandosServer(IPv6_TCPServer):
1988
"""Mandos server.
1989
1990
Attributes:
1991
clients: set of Client objects
1992
gnutls_priority GnuTLS priority string
1993
use_dbus: Boolean; to emit D-Bus signals or not
1994
1995
Assumes a gobject.MainLoop event loop.
1996
"""
1997
def __init__(self, server_address, RequestHandlerClass,
1998
interface=None, use_ipv6=True, clients=None,
1999
gnutls_priority=None, use_dbus=True, socketfd=None):
2000
self.enabled = False
2001
self.clients = clients
2002
if self.clients is None:
2003
self.clients = {}
2004
self.use_dbus = use_dbus
2005
self.gnutls_priority = gnutls_priority
2006
IPv6_TCPServer.__init__(self, server_address,
2007
RequestHandlerClass,
2008
interface = interface,
2009
use_ipv6 = use_ipv6,
2010
socketfd = socketfd)
782
# (self.settings
783
# ["interface"]))
784
return super(IPv6_TCPServer, self).server_bind()
2011
785
def server_activate(self):
2012
786
if self.enabled:
2013
return socketserver.TCPServer.server_activate(self)
2014
787
return super(IPv6_TCPServer, self).server_activate()
2015
788
def enable(self):
2016
789
self.enabled = True
2017
2018
def add_pipe(self, parent_pipe, proc):
2019
# Call "handle_ipc" for both data and EOF events
2020
gobject.io_add_watch(parent_pipe.fileno(),
2021
gobject.IO_IN | gobject.IO_HUP,
2022
functools.partial(self.handle_ipc,
2023
parent_pipe =
2024
parent_pipe,
2025
proc = proc))
2026
2027
def handle_ipc(self, source, condition, parent_pipe=None,
2028
proc = None, client_object=None):
2029
# error, or the other end of multiprocessing.Pipe has closed
2030
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2031
# Wait for other process to exit
2032
proc.join()
2033
return False
2034
2035
# Read a request from the child
2036
request = parent_pipe.recv()
2037
command = request[0]
2038
2039
if command == 'init':
2040
fpr = request[1]
2041
address = request[2]
2042
2043
for c in self.clients.itervalues():
2044
if c.fingerprint == fpr:
2045
client = c
2046
break
2047
else:
2048
logger.info("Client not found for fingerprint: %s, ad"
2049
"dress: %s", fpr, address)
2050
if self.use_dbus:
2051
# Emit D-Bus signal
2052
mandos_dbus_service.ClientNotFound(fpr,
2053
address[0])
2054
parent_pipe.send(False)
2055
return False
2056
2057
gobject.io_add_watch(parent_pipe.fileno(),
2058
gobject.IO_IN | gobject.IO_HUP,
2059
functools.partial(self.handle_ipc,
2060
parent_pipe =
2061
parent_pipe,
2062
proc = proc,
2063
client_object =
2064
client))
2065
parent_pipe.send(True)
2066
# remove the old hook in favor of the new above hook on
2067
# same fileno
2068
return False
2069
if command == 'funcall':
2070
funcname = request[1]
2071
args = request[2]
2072
kwargs = request[3]
2073
2074
parent_pipe.send(('data', getattr(client_object,
2075
funcname)(*args,
2076
**kwargs)))
2077
2078
if command == 'getattr':
2079
attrname = request[1]
2080
if callable(client_object.__getattribute__(attrname)):
2081
parent_pipe.send(('function',))
2082
else:
2083
parent_pipe.send(('data', client_object
2084
.__getattribute__(attrname)))
2085
2086
if command == 'setattr':
2087
attrname = request[1]
2088
value = request[2]
2089
setattr(client_object, attrname, value)
2090
2091
return True
2092
2093
2094
def rfc3339_duration_to_delta(duration):
2095
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2096
2097
>>> rfc3339_duration_to_delta("P7D")
2098
datetime.timedelta(7)
2099
>>> rfc3339_duration_to_delta("PT60S")
2100
datetime.timedelta(0, 60)
2101
>>> rfc3339_duration_to_delta("PT60M")
2102
datetime.timedelta(0, 3600)
2103
>>> rfc3339_duration_to_delta("PT24H")
2104
datetime.timedelta(1)
2105
>>> rfc3339_duration_to_delta("P1W")
2106
datetime.timedelta(7)
2107
>>> rfc3339_duration_to_delta("PT5M30S")
2108
datetime.timedelta(0, 330)
2109
>>> rfc3339_duration_to_delta("P1DT3M20S")
2110
datetime.timedelta(1, 200)
2111
"""
2112
2113
# Parsing an RFC 3339 duration with regular expressions is not
2114
# possible - there would have to be multiple places for the same
2115
# values, like seconds. The current code, while more esoteric, is
2116
# cleaner without depending on a parsing library. If Python had a
2117
# built-in library for parsing we would use it, but we'd like to
2118
# avoid excessive use of external libraries.
2119
2120
# New type for defining tokens, syntax, and semantics all-in-one
2121
Token = collections.namedtuple("Token",
2122
("regexp", # To match token; if
2123
# "value" is not None,
2124
# must have a "group"
2125
# containing digits
2126
"value", # datetime.timedelta or
2127
# None
2128
"followers")) # Tokens valid after
2129
# this token
2130
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2131
# the "duration" ABNF definition in RFC 3339, Appendix A.
2132
token_end = Token(re.compile(r"$"), None, frozenset())
2133
token_second = Token(re.compile(r"(\d+)S"),
2134
datetime.timedelta(seconds=1),
2135
frozenset((token_end,)))
2136
token_minute = Token(re.compile(r"(\d+)M"),
2137
datetime.timedelta(minutes=1),
2138
frozenset((token_second, token_end)))
2139
token_hour = Token(re.compile(r"(\d+)H"),
2140
datetime.timedelta(hours=1),
2141
frozenset((token_minute, token_end)))
2142
token_time = Token(re.compile(r"T"),
2143
None,
2144
frozenset((token_hour, token_minute,
2145
token_second)))
2146
token_day = Token(re.compile(r"(\d+)D"),
2147
datetime.timedelta(days=1),
2148
frozenset((token_time, token_end)))
2149
token_month = Token(re.compile(r"(\d+)M"),
2150
datetime.timedelta(weeks=4),
2151
frozenset((token_day, token_end)))
2152
token_year = Token(re.compile(r"(\d+)Y"),
2153
datetime.timedelta(weeks=52),
2154
frozenset((token_month, token_end)))
2155
token_week = Token(re.compile(r"(\d+)W"),
2156
datetime.timedelta(weeks=1),
2157
frozenset((token_end,)))
2158
token_duration = Token(re.compile(r"P"), None,
2159
frozenset((token_year, token_month,
2160
token_day, token_time,
2161
token_week))),
2162
# Define starting values
2163
value = datetime.timedelta() # Value so far
2164
found_token = None
2165
followers = frozenset(token_duration,) # Following valid tokens
2166
s = duration # String left to parse
2167
# Loop until end token is found
2168
while found_token is not token_end:
2169
# Search for any currently valid tokens
2170
for token in followers:
2171
match = token.regexp.match(s)
2172
if match is not None:
2173
# Token found
2174
if token.value is not None:
2175
# Value found, parse digits
2176
factor = int(match.group(1), 10)
2177
# Add to value so far
2178
value += factor * token.value
2179
# Strip token from string
2180
s = token.regexp.sub("", s, 1)
2181
# Go to found token
2182
found_token = token
2183
# Set valid next tokens
2184
followers = found_token.followers
2185
break
2186
else:
2187
# No currently valid tokens were found
2188
raise ValueError("Invalid RFC 3339 duration")
2189
# End token found
2190
return value
2191
790
2192
791
2193
792
def string_to_delta(interval):
2201
800
datetime.timedelta(0, 3600)
2202
801
>>> string_to_delta('24h')
2203
802
datetime.timedelta(1)
2204
>>> string_to_delta('1w')
803
>>> string_to_delta(u'1w')
2205
804
datetime.timedelta(7)
2206
805
>>> string_to_delta('5m 30s')
2207
806
datetime.timedelta(0, 330)
2208
807
"""
2209
2210
try:
2211
return rfc3339_duration_to_delta(interval)
2212
except ValueError:
2213
pass
2214
2215
808
timevalue = datetime.timedelta(0)
2216
809
for s in interval.split():
2217
810
try:
2218
811
suffix = unicode(s[-1])
2219
812
value = int(s[:-1])
2220
if suffix == "d":
813
if suffix == u"d":
2221
814
delta = datetime.timedelta(value)
2222
elif suffix == "s":
815
elif suffix == u"s":
2223
816
delta = datetime.timedelta(0, value)
2224
elif suffix == "m":
817
elif suffix == u"m":
2225
818
delta = datetime.timedelta(0, 0, 0, 0, value)
2226
elif suffix == "h":
819
elif suffix == u"h":
2227
820
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
2228
elif suffix == "w":
821
elif suffix == u"w":
2229
822
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2230
823
else:
2231
raise ValueError("Unknown suffix {0!r}"
2232
.format(suffix))
2233
except (ValueError, IndexError) as e:
2234
raise ValueError(*(e.args))
824
raise ValueError
825
except (ValueError, IndexError):
826
raise ValueError
2235
827
timevalue += delta
2236
828
return timevalue
2237
829
2238
830
831
def server_state_changed(state):
832
"""Derived from the Avahi example code"""
833
if state == avahi.SERVER_COLLISION:
834
logger.error(u"Zeroconf server name collision")
835
service.remove()
836
elif state == avahi.SERVER_RUNNING:
837
service.add()
838
839
840
def entry_group_state_changed(state, error):
841
"""Derived from the Avahi example code"""
842
logger.debug(u"Avahi state change: %i", state)
843
844
if state == avahi.ENTRY_GROUP_ESTABLISHED:
845
logger.debug(u"Zeroconf service established.")
846
elif state == avahi.ENTRY_GROUP_COLLISION:
847
logger.warning(u"Zeroconf service name collision.")
848
service.rename()
849
elif state == avahi.ENTRY_GROUP_FAILURE:
850
logger.critical(u"Avahi: Error in group state changed %s",
851
unicode(error))
852
raise AvahiGroupError(u"State changed: %s" % unicode(error))
853
854
def if_nametoindex(interface):
855
"""Call the C function if_nametoindex(), or equivalent"""
856
global if_nametoindex
857
try:
858
if_nametoindex = (ctypes.cdll.LoadLibrary
859
(ctypes.util.find_library("c"))
860
.if_nametoindex)
861
except (OSError, AttributeError):
862
if "struct" not in sys.modules:
863
import struct
864
if "fcntl" not in sys.modules:
865
import fcntl
866
def if_nametoindex(interface):
867
"Get an interface index the hard way, i.e. using fcntl()"
868
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
869
with closing(socket.socket()) as s:
870
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
871
struct.pack("16s16x", interface))
872
interface_index = struct.unpack("I", ifreq[16:20])[0]
873
return interface_index
874
return if_nametoindex(interface)
875
876
2239
877
def daemon(nochdir = False, noclose = False):
2240
878
"""See daemon(3). Standard BSD Unix function.
2241
2242
879
This should really exist as os.daemon, but it doesn't (yet)."""
2243
880
if os.fork():
2244
881
sys.exit()
2249
886
sys.exit()
2250
887
if not noclose:
2251
888
# Close all standard open file descriptors
2252
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
889
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2253
890
if not stat.S_ISCHR(os.fstat(null).st_mode):
2254
891
raise OSError(errno.ENODEV,
2255
"{0} not a character device"
2256
.format(os.devnull))
892
"/dev/null not a character device")
2257
893
os.dup2(null, sys.stdin.fileno())
2258
894
os.dup2(null, sys.stdout.fileno())
2259
895
os.dup2(null, sys.stderr.fileno())
2262
898
2263
899
2264
900
def main():
2265
2266
##################################################################
2267
# Parsing of options, both command line and config file
2268
2269
parser = argparse.ArgumentParser()
2270
parser.add_argument("-v", "--version", action="version",
2271
version = "%(prog)s {0}".format(version),
2272
help="show version number and exit")
2273
parser.add_argument("-i", "--interface", metavar="IF",
2274
help="Bind to interface IF")
2275
parser.add_argument("-a", "--address",
2276
help="Address to listen for requests on")
2277
parser.add_argument("-p", "--port", type=int,
2278
help="Port number to receive requests on")
2279
parser.add_argument("--check", action="store_true",
2280
help="Run self-test")
2281
parser.add_argument("--debug", action="store_true",
2282
help="Debug mode; run in foreground and log"
2283
" to terminal")
2284
parser.add_argument("--debuglevel", metavar="LEVEL",
2285
help="Debug level for stdout output")
2286
parser.add_argument("--priority", help="GnuTLS"
2287
" priority string (see GnuTLS documentation)")
2288
parser.add_argument("--servicename",
2289
metavar="NAME", help="Zeroconf service name")
2290
parser.add_argument("--configdir",
2291
default="/etc/mandos", metavar="DIR",
2292
help="Directory to search for configuration"
2293
" files")
2294
parser.add_argument("--no-dbus", action="store_false",
2295
dest="use_dbus", help="Do not provide D-Bus"
2296
" system bus interface")
2297
parser.add_argument("--no-ipv6", action="store_false",
2298
dest="use_ipv6", help="Do not use IPv6")
2299
parser.add_argument("--no-restore", action="store_false",
2300
dest="restore", help="Do not restore stored"
2301
" state")
2302
parser.add_argument("--socket", type=int,
2303
help="Specify a file descriptor to a network"
2304
" socket to use instead of creating one")
2305
parser.add_argument("--statedir", metavar="DIR",
2306
help="Directory to save/restore state in")
2307
parser.add_argument("--foreground", action="store_true",
2308
help="Run in foreground")
2309
2310
options = parser.parse_args()
901
parser = optparse.OptionParser(version = "%%prog %s" % version)
902
parser.add_option("-i", "--interface", type="string",
903
metavar="IF", help="Bind to interface IF")
904
parser.add_option("-a", "--address", type="string",
905
help="Address to listen for requests on")
906
parser.add_option("-p", "--port", type="int",
907
help="Port number to receive requests on")
908
parser.add_option("--check", action="store_true",
909
help="Run self-test")
910
parser.add_option("--debug", action="store_true",
911
help="Debug mode; run in foreground and log to"
912
" terminal")
913
parser.add_option("--priority", type="string", help="GnuTLS"
914
" priority string (see GnuTLS documentation)")
915
parser.add_option("--servicename", type="string", metavar="NAME",
916
help="Zeroconf service name")
917
parser.add_option("--configdir", type="string",
918
default="/etc/mandos", metavar="DIR",
919
help="Directory to search for configuration"
920
" files")
921
parser.add_option("--no-dbus", action="store_false",
922
dest="use_dbus",
923
help="Do not provide D-Bus system bus"
924
" interface")
925
options = parser.parse_args()[0]
2311
926
2312
927
if options.check:
2313
928
import doctest
2323
938
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2324
939
"servicename": "Mandos",
2325
940
"use_dbus": "True",
2326
"use_ipv6": "True",
2327
"debuglevel": "",
2328
"restore": "True",
2329
"socket": "",
2330
"statedir": "/var/lib/mandos",
2331
"foreground": "False",
2332
941
}
2333
942
2334
943
# Parse config file for server-global settings
2335
server_config = configparser.SafeConfigParser(server_defaults)
944
server_config = ConfigParser.SafeConfigParser(server_defaults)
2336
945
del server_defaults
2337
server_config.read(os.path.join(options.configdir,
2338
"mandos.conf"))
946
server_config.read(os.path.join(options.configdir, "mandos.conf"))
2339
947
# Convert the SafeConfigParser object to a dict
2340
948
server_settings = server_config.defaults()
2341
949
# Use the appropriate methods on the non-string config options
2342
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2343
server_settings[option] = server_config.getboolean("DEFAULT",
2344
option)
950
server_settings["debug"] = server_config.getboolean("DEFAULT",
951
"debug")
952
server_settings["use_dbus"] = server_config.getboolean("DEFAULT",
953
"use_dbus")
2345
954
if server_settings["port"]:
2346
955
server_settings["port"] = server_config.getint("DEFAULT",
2347
956
"port")
2348
if server_settings["socket"]:
2349
server_settings["socket"] = server_config.getint("DEFAULT",
2350
"socket")
2351
# Later, stdin will, and stdout and stderr might, be dup'ed
2352
# over with an opened os.devnull. But we don't want this to
2353
# happen with a supplied network socket.
2354
if 0 <= server_settings["socket"] <= 2:
2355
server_settings["socket"] = os.dup(server_settings
2356
["socket"])
2357
957
del server_config
2358
958
2359
959
# Override the settings from the config file with command line
2360
960
# options, if set.
2361
961
for option in ("interface", "address", "port", "debug",
2362
962
"priority", "servicename", "configdir",
2363
"use_dbus", "use_ipv6", "debuglevel", "restore",
2364
"statedir", "socket", "foreground"):
963
"use_dbus"):
2365
964
value = getattr(options, option)
2366
965
if value is not None:
2367
966
server_settings[option] = value
2368
967
del options
2369
# Force all strings to be unicode
2370
for option in server_settings.keys():
2371
if type(server_settings[option]) is str:
2372
server_settings[option] = unicode(server_settings[option])
2373
# Debug implies foreground
2374
if server_settings["debug"]:
2375
server_settings["foreground"] = True
2376
968
# Now we have our good server settings in "server_settings"
2377
969
2378
##################################################################
2379
2380
970
# For convenience
2381
971
debug = server_settings["debug"]
2382
debuglevel = server_settings["debuglevel"]
2383
972
use_dbus = server_settings["use_dbus"]
2384
use_ipv6 = server_settings["use_ipv6"]
2385
stored_state_path = os.path.join(server_settings["statedir"],
2386
stored_state_file)
2387
foreground = server_settings["foreground"]
973
974
def sigsegvhandler(signum, frame):
975
raise RuntimeError('Segmentation fault')
2388
976
2389
if debug:
2390
initlogger(debug, logging.DEBUG)
977
if not debug:
978
syslogger.setLevel(logging.WARNING)
979
console.setLevel(logging.WARNING)
2391
980
else:
2392
if not debuglevel:
2393
initlogger(debug)
2394
else:
2395
level = getattr(logging, debuglevel.upper())
2396
initlogger(debug, level)
981
signal.signal(signal.SIGSEGV, sigsegvhandler)
2397
982
2398
983
if server_settings["servicename"] != "Mandos":
2399
984
syslogger.setFormatter(logging.Formatter
2400
('Mandos ({0}) [%(process)d]:'
2401
' %(levelname)s: %(message)s'
2402
.format(server_settings
2403
["servicename"])))
985
('Mandos (%s): %%(levelname)s:'
986
' %%(message)s'
987
% server_settings["servicename"]))
2404
988
2405
989
# Parse config file with clients
2406
client_config = configparser.SafeConfigParser(Client
2407
.client_defaults)
990
client_defaults = { "timeout": "1h",
991
"interval": "5m",
992
"checker": "fping -q -- %%(host)s",
993
"host": "",
994
}
995
client_config = ConfigParser.SafeConfigParser(client_defaults)
2408
996
client_config.read(os.path.join(server_settings["configdir"],
2409
997
"clients.conf"))
2410
998
2411
global mandos_dbus_service
2412
mandos_dbus_service = None
2413
2414
tcp_server = MandosServer((server_settings["address"],
2415
server_settings["port"]),
2416
ClientHandler,
2417
interface=(server_settings["interface"]
2418
or None),
2419
use_ipv6=use_ipv6,
2420
gnutls_priority=
2421
server_settings["priority"],
2422
use_dbus=use_dbus,
2423
socketfd=(server_settings["socket"]
2424
or None))
2425
if not foreground:
2426
pidfilename = "/var/run/mandos.pid"
2427
pidfile = None
2428
try:
2429
pidfile = open(pidfilename, "w")
2430
except IOError as e:
2431
logger.error("Could not open file %r", pidfilename,
2432
exc_info=e)
2433
2434
for name in ("_mandos", "mandos", "nobody"):
2435
try:
2436
uid = pwd.getpwnam(name).pw_uid
2437
gid = pwd.getpwnam(name).pw_gid
2438
break
999
clients = Set()
1000
tcp_server = IPv6_TCPServer((server_settings["address"],
1001
server_settings["port"]),
1002
TCP_handler,
1003
settings=server_settings,
1004
clients=clients)
1005
pidfilename = "/var/run/mandos.pid"
1006
try:
1007
pidfile = open(pidfilename, "w")
1008
except IOError, error:
1009
logger.error("Could not open file %r", pidfilename)
1010
1011
try:
1012
uid = pwd.getpwnam("_mandos").pw_uid
1013
gid = pwd.getpwnam("_mandos").pw_gid
1014
except KeyError:
1015
try:
1016
uid = pwd.getpwnam("mandos").pw_uid
1017
gid = pwd.getpwnam("mandos").pw_gid
2439
1018
except KeyError:
2440
continue
2441
else:
2442
uid = 65534
2443
gid = 65534
1019
try:
1020
uid = pwd.getpwnam("nobody").pw_uid
1021
gid = pwd.getpwnam("nogroup").pw_gid
1022
except KeyError:
1023
uid = 65534
1024
gid = 65534
2444
1025
try:
2445
1026
os.setgid(gid)
2446
1027
os.setuid(uid)
2447
except OSError as error:
2448
if error.errno != errno.EPERM:
1028
except OSError, error:
1029
if error[0] != errno.EPERM:
2449
1030
raise error
2450
1031
1032
# Enable all possible GnuTLS debugging
2451
1033
if debug:
2452
# Enable all possible GnuTLS debugging
2453
2454
1034
# "Use a log level over 10 to enable all debugging options."
2455
1035
# - GnuTLS manual
2456
1036
gnutls.library.functions.gnutls_global_set_log_level(11)
2461
1041
2462
1042
(gnutls.library.functions
2463
1043
.gnutls_global_set_log_function(debug_gnutls))
2464
2465
# Redirect stdin so all checkers get /dev/null
2466
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2467
os.dup2(null, sys.stdin.fileno())
2468
if null > 2:
2469
os.close(null)
2470
2471
# Need to fork before connecting to D-Bus
2472
if not foreground:
2473
# Close all input and output, do double fork, etc.
2474
daemon()
2475
2476
# multiprocessing will use threads, so before we use gobject we
2477
# need to inform gobject that threads will be used.
2478
gobject.threads_init()
1044
1045
global service
1046
service = AvahiService(name = server_settings["servicename"],
1047
servicetype = "_mandos._tcp", )
1048
if server_settings["interface"]:
1049
service.interface = (if_nametoindex
1050
(server_settings["interface"]))
2479
1051
2480
1052
global main_loop
1053
global bus
1054
global server
2481
1055
# From the Avahi example code
2482
DBusGMainLoop(set_as_default=True)
1056
DBusGMainLoop(set_as_default=True )
2483
1057
main_loop = gobject.MainLoop()
2484
1058
bus = dbus.SystemBus()
1059
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1060
avahi.DBUS_PATH_SERVER),
1061
avahi.DBUS_INTERFACE_SERVER)
2485
1062
# End of Avahi example code
2486
1063
if use_dbus:
2487
try:
2488
bus_name = dbus.service.BusName("se.recompile.Mandos",
2489
bus, do_not_queue=True)
2490
old_bus_name = (dbus.service.BusName
2491
("se.bsnet.fukt.Mandos", bus,
2492
do_not_queue=True))
2493
except dbus.exceptions.NameExistsException as e:
2494
logger.error("Disabling D-Bus:", exc_info=e)
2495
use_dbus = False
2496
server_settings["use_dbus"] = False
2497
tcp_server.use_dbus = False
2498
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2499
service = AvahiServiceToSyslog(name =
2500
server_settings["servicename"],
2501
servicetype = "_mandos._tcp",
2502
protocol = protocol, bus = bus)
2503
if server_settings["interface"]:
2504
service.interface = (if_nametoindex
2505
(str(server_settings["interface"])))
2506
2507
global multiprocessing_manager
2508
multiprocessing_manager = multiprocessing.Manager()
2509
2510
client_class = Client
2511
if use_dbus:
2512
client_class = functools.partial(ClientDBus, bus = bus)
2513
2514
client_settings = Client.config_parser(client_config)
2515
old_client_settings = {}
2516
clients_data = {}
2517
2518
# Get client data and settings from last running state.
2519
if server_settings["restore"]:
2520
try:
2521
with open(stored_state_path, "rb") as stored_state:
2522
clients_data, old_client_settings = (pickle.load
2523
(stored_state))
2524
os.remove(stored_state_path)
2525
except IOError as e:
2526
if e.errno == errno.ENOENT:
2527
logger.warning("Could not load persistent state: {0}"
2528
.format(os.strerror(e.errno)))
2529
else:
2530
logger.critical("Could not load persistent state:",
2531
exc_info=e)
2532
raise
2533
except EOFError as e:
2534
logger.warning("Could not load persistent state: "
2535
"EOFError:", exc_info=e)
2536
2537
with PGPEngine() as pgp:
2538
for client_name, client in clients_data.iteritems():
2539
# Decide which value to use after restoring saved state.
2540
# We have three different values: Old config file,
2541
# new config file, and saved state.
2542
# New config value takes precedence if it differs from old
2543
# config value, otherwise use saved state.
2544
for name, value in client_settings[client_name].items():
2545
try:
2546
# For each value in new config, check if it
2547
# differs from the old config value (Except for
2548
# the "secret" attribute)
2549
if (name != "secret" and
2550
value != old_client_settings[client_name]
2551
[name]):
2552
client[name] = value
2553
except KeyError:
2554
pass
2555
2556
# Clients who has passed its expire date can still be
2557
# enabled if its last checker was successful. Clients
2558
# whose checker succeeded before we stored its state is
2559
# assumed to have successfully run all checkers during
2560
# downtime.
2561
if client["enabled"]:
2562
if datetime.datetime.utcnow() >= client["expires"]:
2563
if not client["last_checked_ok"]:
2564
logger.warning(
2565
"disabling client {0} - Client never "
2566
"performed a successful checker"
2567
.format(client_name))
2568
client["enabled"] = False
2569
elif client["last_checker_status"] != 0:
2570
logger.warning(
2571
"disabling client {0} - Client "
2572
"last checker failed with error code {1}"
2573
.format(client_name,
2574
client["last_checker_status"]))
2575
client["enabled"] = False
2576
else:
2577
client["expires"] = (datetime.datetime
2578
.utcnow()
2579
+ client["timeout"])
2580
logger.debug("Last checker succeeded,"
2581
" keeping {0} enabled"
2582
.format(client_name))
2583
try:
2584
client["secret"] = (
2585
pgp.decrypt(client["encrypted_secret"],
2586
client_settings[client_name]
2587
["secret"]))
2588
except PGPError:
2589
# If decryption fails, we use secret from new settings
2590
logger.debug("Failed to decrypt {0} old secret"
2591
.format(client_name))
2592
client["secret"] = (
2593
client_settings[client_name]["secret"])
2594
2595
# Add/remove clients based on new changes made to config
2596
for client_name in (set(old_client_settings)
2597
- set(client_settings)):
2598
del clients_data[client_name]
2599
for client_name in (set(client_settings)
2600
- set(old_client_settings)):
2601
clients_data[client_name] = client_settings[client_name]
2602
2603
# Create all client objects
2604
for client_name, client in clients_data.iteritems():
2605
tcp_server.clients[client_name] = client_class(
2606
name = client_name, settings = client)
2607
2608
if not tcp_server.clients:
2609
logger.warning("No clients defined")
2610
2611
if not foreground:
2612
if pidfile is not None:
2613
try:
2614
with pidfile:
2615
pid = os.getpid()
2616
pidfile.write(str(pid) + "\n".encode("utf-8"))
2617
except IOError:
2618
logger.error("Could not write to file %r with PID %d",
2619
pidfilename, pid)
1064
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
1065
1066
clients.update(Set(Client(name = section,
1067
config
1068
= dict(client_config.items(section)),
1069
use_dbus = use_dbus)
1070
for section in client_config.sections()))
1071
if not clients:
1072
logger.warning(u"No clients defined")
1073
1074
if debug:
1075
# Redirect stdin so all checkers get /dev/null
1076
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1077
os.dup2(null, sys.stdin.fileno())
1078
if null > 2:
1079
os.close(null)
1080
else:
1081
# No console logging
1082
logger.removeHandler(console)
1083
# Close all input and output, do double fork, etc.
1084
daemon()
1085
1086
try:
1087
pid = os.getpid()
1088
pidfile.write(str(pid) + "\n")
1089
pidfile.close()
2620
1090
del pidfile
2621
del pidfilename
2622
1091
except IOError:
1092
logger.error(u"Could not write to file %r with PID %d",
1093
pidfilename, pid)
1094
except NameError:
1095
# "pidfile" was never created
1096
pass
1097
del pidfilename
1098
1099
def cleanup():
1100
"Cleanup function; run on exit"
1101
global group
1102
# From the Avahi example code
1103
if not group is None:
1104
group.Free()
1105
group = None
1106
# End of Avahi example code
1107
1108
while clients:
1109
client = clients.pop()
1110
client.disable_hook = None
1111
client.disable()
1112
1113
atexit.register(cleanup)
1114
1115
if not debug:
1116
signal.signal(signal.SIGINT, signal.SIG_IGN)
2623
1117
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2624
1118
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2625
1119
2626
1120
if use_dbus:
2627
@alternate_dbus_interfaces({"se.recompile.Mandos":
2628
"se.bsnet.fukt.Mandos"})
2629
class MandosDBusService(DBusObjectWithProperties):
1121
class MandosServer(dbus.service.Object):
2630
1122
"""A D-Bus proxy object"""
2631
1123
def __init__(self):
2632
1124
dbus.service.Object.__init__(self, bus, "/")
2633
_interface = "se.recompile.Mandos"
2634
2635
@dbus_interface_annotations(_interface)
2636
def _foo(self):
2637
return { "org.freedesktop.DBus.Property"
2638
".EmitsChangedSignal":
2639
"false"}
2640
2641
@dbus.service.signal(_interface, signature="o")
2642
def ClientAdded(self, objpath):
2643
"D-Bus signal"
2644
pass
2645
2646
@dbus.service.signal(_interface, signature="ss")
2647
def ClientNotFound(self, fingerprint, address):
1125
_interface = u"se.bsnet.fukt.Mandos"
1126
1127
@dbus.service.signal(_interface, signature="oa{sv}")
1128
def ClientAdded(self, objpath, properties):
2648
1129
"D-Bus signal"
2649
1130
pass
2650
1131
2656
1137
@dbus.service.method(_interface, out_signature="ao")
2657
1138
def GetAllClients(self):
2658
1139
"D-Bus method"
2659
return dbus.Array(c.dbus_object_path
2660
for c in
2661
tcp_server.clients.itervalues())
1140
return dbus.Array(c.dbus_object_path for c in clients)
2662
1141
2663
@dbus.service.method(_interface,
2664
out_signature="a{oa{sv}}")
1142
@dbus.service.method(_interface, out_signature="a{oa{sv}}")
2665
1143
def GetAllClientsWithProperties(self):
2666
1144
"D-Bus method"
2667
1145
return dbus.Dictionary(
2668
((c.dbus_object_path, c.GetAll(""))
2669
for c in tcp_server.clients.itervalues()),
1146
((c.dbus_object_path, c.GetAllProperties())
1147
for c in clients),
2670
1148
signature="oa{sv}")
2671
1149
2672
1150
@dbus.service.method(_interface, in_signature="o")
2673
1151
def RemoveClient(self, object_path):
2674
1152
"D-Bus method"
2675
for c in tcp_server.clients.itervalues():
1153
for c in clients:
2676
1154
if c.dbus_object_path == object_path:
2677
del tcp_server.clients[c.name]
2678
c.remove_from_connection()
1155
clients.remove(c)
2679
1156
# Don't signal anything except ClientRemoved
2680
c.disable(quiet=True)
1157
c.use_dbus = False
1158
c.disable()
2681
1159
# Emit D-Bus signal
2682
1160
self.ClientRemoved(object_path, c.name)
2683
1161
return
2684
raise KeyError(object_path)
1162
raise KeyError
2685
1163
2686
1164
del _interface
2687
1165
2688
mandos_dbus_service = MandosDBusService()
2689
2690
def cleanup():
2691
"Cleanup function; run on exit"
2692
service.cleanup()
2693
2694
multiprocessing.active_children()
2695
if not (tcp_server.clients or client_settings):
2696
return
2697
2698
# Store client before exiting. Secrets are encrypted with key
2699
# based on what config file has. If config file is
2700
# removed/edited, old secret will thus be unrecovable.
2701
clients = {}
2702
with PGPEngine() as pgp:
2703
for client in tcp_server.clients.itervalues():
2704
key = client_settings[client.name]["secret"]
2705
client.encrypted_secret = pgp.encrypt(client.secret,
2706
key)
2707
client_dict = {}
2708
2709
# A list of attributes that can not be pickled
2710
# + secret.
2711
exclude = set(("bus", "changedstate", "secret",
2712
"checker"))
2713
for name, typ in (inspect.getmembers
2714
(dbus.service.Object)):
2715
exclude.add(name)
2716
2717
client_dict["encrypted_secret"] = (client
2718
.encrypted_secret)
2719
for attr in client.client_structure:
2720
if attr not in exclude:
2721
client_dict[attr] = getattr(client, attr)
2722
2723
clients[client.name] = client_dict
2724
del client_settings[client.name]["secret"]
2725
2726
try:
2727
with (tempfile.NamedTemporaryFile
2728
(mode='wb', suffix=".pickle", prefix='clients-',
2729
dir=os.path.dirname(stored_state_path),
2730
delete=False)) as stored_state:
2731
pickle.dump((clients, client_settings), stored_state)
2732
tempname=stored_state.name
2733
os.rename(tempname, stored_state_path)
2734
except (IOError, OSError) as e:
2735
if not debug:
2736
try:
2737
os.remove(tempname)
2738
except NameError:
2739
pass
2740
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2741
logger.warning("Could not save persistent state: {0}"
2742
.format(os.strerror(e.errno)))
2743
else:
2744
logger.warning("Could not save persistent state:",
2745
exc_info=e)
2746
raise e
2747
2748
# Delete all clients, and settings from config
2749
while tcp_server.clients:
2750
name, client = tcp_server.clients.popitem()
2751
if use_dbus:
2752
client.remove_from_connection()
2753
# Don't signal anything except ClientRemoved
2754
client.disable(quiet=True)
2755
if use_dbus:
2756
# Emit D-Bus signal
2757
mandos_dbus_service.ClientRemoved(client
2758
.dbus_object_path,
2759
client.name)
2760
client_settings.clear()
2761
2762
atexit.register(cleanup)
2763
2764
for client in tcp_server.clients.itervalues():
1166
mandos_server = MandosServer()
1167
1168
for client in clients:
2765
1169
if use_dbus:
2766
1170
# Emit D-Bus signal
2767
mandos_dbus_service.ClientAdded(client.dbus_object_path)
2768
# Need to initiate checking of clients
2769
if client.enabled:
2770
client.init_checker()
1171
mandos_server.ClientAdded(client.dbus_object_path,
1172
client.GetAllProperties())
1173
client.enable()
2771
1174
2772
1175
tcp_server.enable()
2773
1176
tcp_server.server_activate()
2774
1177
2775
1178
# Find out what port we got
2776
1179
service.port = tcp_server.socket.getsockname()[1]
2777
if use_ipv6:
2778
logger.info("Now listening on address %r, port %d,"
2779
" flowinfo %d, scope_id %d",
2780
*tcp_server.socket.getsockname())
2781
else: # IPv4
2782
logger.info("Now listening on address %r, port %d",
2783
*tcp_server.socket.getsockname())
1180
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
1181
u" scope_id %d" % tcp_server.socket.getsockname())
2784
1182
2785
1183
#service.interface = tcp_server.socket.getsockname()[3]
2786
1184
2787
1185
try:
2788
1186
# From the Avahi example code
1187
server.connect_to_signal("StateChanged", server_state_changed)
2789
1188
try:
2790
service.activate()
2791
except dbus.exceptions.DBusException as error:
2792
logger.critical("D-Bus Exception", exc_info=error)
2793
cleanup()
1189
server_state_changed(server.GetState())
1190
except dbus.exceptions.DBusException, error:
1191
logger.critical(u"DBusException: %s", error)
2794
1192
sys.exit(1)
2795
1193
# End of Avahi example code
2796
1194
2799
1197
(tcp_server.handle_request
2800
1198
(*args[2:], **kwargs) or True))
2801
1199
2802
logger.debug("Starting main loop")
1200
logger.debug(u"Starting main loop")
2803
1201
main_loop.run()
2804
except AvahiError as error:
2805
logger.critical("Avahi Error", exc_info=error)
2806
cleanup()
1202
except AvahiError, error:
1203
logger.critical(u"AvahiError: %s", error)
2807
1204
sys.exit(1)
2808
1205
except KeyboardInterrupt:
2809
1206
if debug:
2810
print("", file=sys.stderr)
2811
logger.debug("Server received KeyboardInterrupt")
2812
logger.debug("Server exiting")
2813
# Must run before the D-Bus bus name gets deregistered
2814
cleanup()
1207
print
2815
1208
2816
1209
if __name__ == '__main__':
2817
1210
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0