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 609
- compare with another revision
- download diff
- download tarball
- view history from revision 609
- Committer: Teddy Hogeborn
- Date: 2012-06-23 00:58:49 UTC
- Revision ID: teddy@recompile.se-20120623005849-02wj82cng433rt2k
* clients.conf: Convert all time intervals to new RFC 3339 syntax.
* mandos: All client options for time intervals now take an RFC 3339
duration.
(rfc3339_duration_to_delta): New function.
(string_to_delta): Try rfc3339_duration_to_delta first.
* mandos-clients.conf.xml (OPTIONS/timeout): Document new format.
(EXAMPLE): Update to new interval format.
(SEE ALSO): Reference RFC 3339.
* mandos: All client options for time intervals now take an RFC 3339
duration.
(rfc3339_duration_to_delta): New function.
(string_to_delta): Try rfc3339_duration_to_delta first.
* mandos-clients.conf.xml (OPTIONS/timeout): Document new format.
(EXAMPLE): Update to new interval format.
(SEE ALSO): Reference RFC 3339.
- files added:
- .bzr-builddeb
- debian
- debian/po
- debian/source
- network-hooks.d
- files removed:
- plugins.d/usplash
- files renamed:
- plugins.d/password-request.c => plugins.d/mandos-client.c
- plugins.d/password-request.xml => plugins.d/mandos-client.xml
- files modified:
- .bzrignore
added
removed
mandos
6
6
# This program is partly derived from an example program for an Avahi
7
7
# service publisher, downloaded from
8
8
# <http://avahi.org/wiki/PythonPublishExample>. This includes the
9
# methods "add" and "remove" in the "AvahiService" class, the
10
# "server_state_changed" and "entry_group_state_changed" functions,
11
# and some lines in "main".
9
# methods "add", "remove", "server_state_changed",
10
# "entry_group_state_changed", "cleanup", and "activate" in the
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
14
# Copyright © 2008-2012 Teddy Hogeborn
15
# Copyright © 2008-2012 Björn Påhlsson
15
16
#
16
17
# This program is free software: you can redistribute it and/or modify
17
18
# it under the terms of the GNU General Public License as published by
27
28
# along with this program. If not, see
28
29
# <http://www.gnu.org/licenses/>.
29
30
#
30
# Contact the authors at <mandos@fukt.bsnet.se>.
31
# Contact the authors at <mandos@recompile.se>.
31
32
#
32
33
33
from __future__ import division
34
35
import SocketServer
34
from __future__ import (division, absolute_import, print_function,
35
unicode_literals)
36
37
from future_builtins import *
38
39
import SocketServer as socketserver
36
40
import socket
37
import select
38
from optparse import OptionParser
41
import argparse
39
42
import datetime
40
43
import errno
41
44
import gnutls.crypto
44
47
import gnutls.library.functions
45
48
import gnutls.library.constants
46
49
import gnutls.library.types
47
import ConfigParser
50
import ConfigParser as configparser
48
51
import sys
49
52
import re
50
53
import os
51
54
import signal
52
from sets import Set
53
55
import subprocess
54
56
import atexit
55
57
import stat
56
58
import logging
57
59
import logging.handlers
60
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
58
72
59
73
import dbus
74
import dbus.service
60
75
import gobject
61
76
import avahi
62
77
from dbus.mainloop.glib import DBusGMainLoop
63
78
import ctypes
64
65
version = "1.0"
66
67
logger = logging.Logger('mandos')
68
syslogger = logging.handlers.SysLogHandler\
69
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
70
address = "/dev/log")
71
syslogger.setFormatter(logging.Formatter\
72
('Mandos: %(levelname)s: %(message)s'))
73
logger.addHandler(syslogger)
74
75
console = logging.StreamHandler()
76
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
77
' %(message)s'))
78
logger.addHandler(console)
79
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()
96
syslogger = (logging.handlers.SysLogHandler
97
(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
79
214
80
215
class AvahiError(Exception):
81
def __init__(self, value):
216
def __init__(self, value, *args, **kwargs):
82
217
self.value = value
83
def __str__(self):
84
return repr(self.value)
218
super(AvahiError, self).__init__(value, *args, **kwargs)
219
def __unicode__(self):
220
return unicode(repr(self.value))
85
221
86
222
class AvahiServiceError(AvahiError):
87
223
pass
92
228
93
229
class AvahiService(object):
94
230
"""An Avahi (Zeroconf) service.
231
95
232
Attributes:
96
233
interface: integer; avahi.IF_UNSPEC or an interface index.
97
234
Used to optionally bind to the specified interface.
105
242
max_renames: integer; maximum number of renames
106
243
rename_count: integer; counter so we only rename after collisions
107
244
a sensible number of times
245
group: D-Bus Entry Group
246
server: D-Bus Server
247
bus: dbus.SystemBus()
108
248
"""
249
109
250
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
110
type = None, port = None, TXT = None, domain = "",
111
host = "", max_renames = 32768):
251
servicetype = None, port = None, TXT = None,
252
domain = "", host = "", max_renames = 32768,
253
protocol = avahi.PROTO_UNSPEC, bus = None):
112
254
self.interface = interface
113
255
self.name = name
114
self.type = type
256
self.type = servicetype
115
257
self.port = port
116
if TXT is None:
117
self.TXT = []
118
else:
119
self.TXT = TXT
258
self.TXT = TXT if TXT is not None else []
120
259
self.domain = domain
121
260
self.host = host
122
261
self.rename_count = 0
123
262
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
124
269
def rename(self):
125
270
"""Derived from the Avahi example code"""
126
271
if self.rename_count >= self.max_renames:
127
logger.critical(u"No suitable Zeroconf service name found"
128
u" after %i retries, exiting.",
129
rename_count)
272
logger.critical("No suitable Zeroconf service name found"
273
" after %i retries, exiting.",
274
self.rename_count)
130
275
raise AvahiServiceError("Too many renames")
131
self.name = server.GetAlternativeServiceName(self.name)
132
logger.info(u"Changing Zeroconf service name to %r ...",
133
str(self.name))
134
syslogger.setFormatter(logging.Formatter\
135
('Mandos (%s): %%(levelname)s:'
136
' %%(message)s' % self.name))
276
self.name = unicode(self.server
277
.GetAlternativeServiceName(self.name))
278
logger.info("Changing Zeroconf service name to %r ...",
279
self.name)
137
280
self.remove()
138
self.add()
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)
139
287
self.rename_count += 1
288
140
289
def remove(self):
141
290
"""Derived from the Avahi example code"""
142
if group is not None:
143
group.Reset()
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
297
def add(self):
145
298
"""Derived from the Avahi example code"""
146
global group
147
if group is None:
148
group = dbus.Interface\
149
(bus.get_object(avahi.DBUS_NAME,
150
server.EntryGroupNew()),
151
avahi.DBUS_INTERFACE_ENTRY_GROUP)
152
group.connect_to_signal('StateChanged',
153
entry_group_state_changed)
154
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
155
service.name, service.type)
156
group.AddService(
157
self.interface, # interface
158
avahi.PROTO_INET6, # protocol
159
dbus.UInt32(0), # flags
160
self.name, self.type,
161
self.domain, self.host,
162
dbus.UInt16(self.port),
163
avahi.string_array_to_txt_array(self.TXT))
164
group.Commit()
165
166
# From the Avahi example code:
167
group = None # our entry group
168
# End of 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))
169
400
170
401
171
402
class Client(object):
172
403
"""A representation of a client host served by this server.
404
173
405
Attributes:
174
name: string; from the config file, used in log messages
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
409
checker: subprocess.Popen(); a running checker process used
410
to see if the client lives.
411
'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
415
runtime with vars(self) as dict, so that for
416
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()
175
424
fingerprint: string (40 or 32 hexadecimal digits); used to
176
425
uniquely identify the client
177
secret: bytestring; sent verbatim (over TLS) to client
178
host: string; available for use by the checker command
179
created: datetime.datetime(); object creation, not client host
180
last_checked_ok: datetime.datetime() or None if not yet checked OK
181
timeout: datetime.timedelta(); How long from last_checked_ok
182
until this client is invalid
183
interval: datetime.timedelta(); How often to start a new checker
184
stop_hook: If set, called by stop() as stop_hook(self)
185
checker: subprocess.Popen(); a running checker process used
186
to see if the client lives.
187
'None' if no process is running.
188
checker_initiator_tag: a gobject event source tag, or None
189
stop_initiator_tag: - '' -
190
checker_callback_tag: - '' -
191
checker_command: string; External command which is run to check if
192
client lives. %() expansions are done at
193
runtime with vars(self) as dict, so that for
194
instance %(name)s can be used in the command.
195
Private attibutes:
196
_timeout: Real variable for 'timeout'
197
_interval: Real variable for 'interval'
198
_timeout_milliseconds: Used when calling gobject.timeout_add()
199
_interval_milliseconds: - '' -
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
200
443
"""
201
def _set_timeout(self, timeout):
202
"Setter function for 'timeout' attribute"
203
self._timeout = timeout
204
self._timeout_milliseconds = ((self.timeout.days
205
* 24 * 60 * 60 * 1000)
206
+ (self.timeout.seconds * 1000)
207
+ (self.timeout.microseconds
208
// 1000))
209
timeout = property(lambda self: self._timeout,
210
_set_timeout)
211
del _set_timeout
212
def _set_interval(self, interval):
213
"Setter function for 'interval' attribute"
214
self._interval = interval
215
self._interval_milliseconds = ((self.interval.days
216
* 24 * 60 * 60 * 1000)
217
+ (self.interval.seconds
218
* 1000)
219
+ (self.interval.microseconds
220
// 1000))
221
interval = property(lambda self: self._interval,
222
_set_interval)
223
del _set_interval
224
def __init__(self, name = None, stop_hook=None, config={}):
225
"""Note: the 'checker' key in 'config' sets the
226
'checker_command' attribute and *not* the 'checker'
227
attribute."""
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
def timeout_milliseconds(self):
462
"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)
468
469
def interval_milliseconds(self):
470
"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):
228
524
self.name = name
229
logger.debug(u"Creating client %r", self.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)
230
540
# Uppercase and remove spaces from fingerprint for later
231
541
# comparison purposes with return value from the fingerprint()
232
542
# function
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
sf = open(config["secfile"])
240
self.secret = sf.read()
241
sf.close()
242
else:
243
raise TypeError(u"No secret or secfile for client %s"
244
% self.name)
245
self.host = config.get("host", "")
246
self.created = datetime.datetime.now()
247
self.last_checked_ok = None
248
self.timeout = string_to_delta(config["timeout"])
249
self.interval = string_to_delta(config["interval"])
250
self.stop_hook = stop_hook
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
251
548
self.checker = None
252
549
self.checker_initiator_tag = None
253
self.stop_initiator_tag = None
550
self.disable_initiator_tag = None
254
551
self.checker_callback_tag = None
255
self.check_command = config["checker"]
256
def start(self):
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()
574
575
def enable(self):
257
576
"""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
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):
258
610
# Schedule a new checker to be started an 'interval' from now,
259
611
# and every interval from then on.
260
self.checker_initiator_tag = gobject.timeout_add\
261
(self._interval_milliseconds,
262
self.start_checker)
612
if self.checker_initiator_tag is not None:
613
gobject.source_remove(self.checker_initiator_tag)
614
self.checker_initiator_tag = (gobject.timeout_add
615
(self.interval_milliseconds(),
616
self.start_checker))
617
# 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
self.disable_initiator_tag = (gobject.timeout_add
621
(self.timeout_milliseconds(),
622
self.disable))
263
623
# Also start a new checker *right now*.
264
624
self.start_checker()
265
# Schedule a stop() when 'timeout' has passed
266
self.stop_initiator_tag = gobject.timeout_add\
267
(self._timeout_milliseconds,
268
self.stop)
269
def stop(self):
270
"""Stop this client.
271
The possibility that a client might be restarted is left open,
272
but not currently used."""
273
# If this client doesn't have a secret, it is already stopped.
274
if hasattr(self, "secret") and self.secret:
275
logger.info(u"Stopping client %s", self.name)
276
self.secret = None
277
else:
278
return False
279
if getattr(self, "stop_initiator_tag", False):
280
gobject.source_remove(self.stop_initiator_tag)
281
self.stop_initiator_tag = None
282
if getattr(self, "checker_initiator_tag", False):
283
gobject.source_remove(self.checker_initiator_tag)
284
self.checker_initiator_tag = None
285
self.stop_checker()
286
if self.stop_hook:
287
self.stop_hook(self)
288
# Do not run this again if called by a gobject.timeout_add
289
return False
290
def __del__(self):
291
self.stop_hook = None
292
self.stop()
293
def checker_callback(self, pid, condition):
625
626
def checker_callback(self, pid, condition, command):
294
627
"""The checker has completed, so take appropriate actions."""
295
now = datetime.datetime.now()
296
628
self.checker_callback_tag = None
297
629
self.checker = None
298
if os.WIFEXITED(condition) \
299
and (os.WEXITSTATUS(condition) == 0):
300
logger.info(u"Checker for %(name)s succeeded",
301
vars(self))
302
self.last_checked_ok = now
303
gobject.source_remove(self.stop_initiator_tag)
304
self.stop_initiator_tag = gobject.timeout_add\
305
(self._timeout_milliseconds,
306
self.stop)
307
elif not os.WIFEXITED(condition):
308
logger.warning(u"Checker for %(name)s crashed?",
630
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",
634
vars(self))
635
self.checked_ok()
636
else:
637
logger.info("Checker for %(name)s failed",
638
vars(self))
639
else:
640
self.last_checker_status = -1
641
logger.warning("Checker for %(name)s crashed?",
309
642
vars(self))
310
else:
311
logger.info(u"Checker for %(name)s failed",
312
vars(self))
643
644
def checked_ok(self):
645
"""Assert that the client has been seen, alive and well."""
646
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()
665
313
666
def start_checker(self):
314
667
"""Start a new checker subprocess if one is not running.
668
315
669
If a checker already exists, leave it running and do
316
670
nothing."""
317
671
# The reason for not killing a running checker is that if we
318
# did that, then if a checker (for some reason) started
319
# running slowly and taking more than 'interval' time, the
320
# client would inevitably timeout, since no checker would get
321
# a chance to run to completion. If we instead leave running
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
322
676
# checkers alone, the checker would have to take more time
323
# than 'timeout' for the client to be declared invalid, which
324
# is as it should be.
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
325
694
if self.checker is None:
326
try:
327
# In case check_command has exactly one % operator
328
command = self.check_command % self.host
329
except TypeError:
330
# Escape attributes for the shell
331
escaped_attrs = dict((key, re.escape(str(val)))
332
for key, val in
333
vars(self).iteritems())
334
try:
335
command = self.check_command % escaped_attrs
336
except TypeError, error:
337
logger.error(u'Could not format string "%s":'
338
u' %s', self.check_command, error)
339
return True # Try again later
340
try:
341
logger.info(u"Starting checker %r for %s",
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",
342
709
command, self.name)
343
710
# We don't need to redirect stdout and stderr, since
344
711
# in normal mode, that is already done by daemon(),
347
714
self.checker = subprocess.Popen(command,
348
715
close_fds=True,
349
716
shell=True, cwd="/")
350
self.checker_callback_tag = gobject.child_watch_add\
351
(self.checker.pid,
352
self.checker_callback)
353
except OSError, error:
354
logger.error(u"Failed to start subprocess: %s",
355
error)
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)
356
730
# Re-run this periodically if run by gobject.timeout_add
357
731
return True
732
358
733
def stop_checker(self):
359
734
"""Force the checker process, if any, to stop."""
360
735
if self.checker_callback_tag:
362
737
self.checker_callback_tag = None
363
738
if getattr(self, "checker", None) is None:
364
739
return
365
logger.debug(u"Stopping checker for %(name)s", vars(self))
740
logger.debug("Stopping checker for %(name)s", vars(self))
366
741
try:
367
os.kill(self.checker.pid, signal.SIGTERM)
368
#os.sleep(0.5)
742
self.checker.terminate()
743
#time.sleep(0.5)
369
744
#if self.checker.poll() is None:
370
# os.kill(self.checker.pid, signal.SIGKILL)
371
except OSError, error:
745
# self.checker.kill()
746
except OSError as error:
372
747
if error.errno != errno.ESRCH: # No such process
373
748
raise
374
749
self.checker = None
375
def still_valid(self):
376
"""Has the timeout not yet passed for this client?"""
377
now = datetime.datetime.now()
378
if self.last_checked_ok is None:
379
return now < (self.created + self.timeout)
380
else:
381
return now < (self.last_checked_ok + self.timeout)
382
383
384
def peer_certificate(session):
385
"Return the peer's OpenPGP certificate as a bytestring"
386
# If not an OpenPGP certificate...
387
if gnutls.library.functions.gnutls_certificate_type_get\
388
(session._c_object) \
389
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
390
# ...do the normal thing
391
return session.peer_certificate
392
list_size = ctypes.c_uint()
393
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
394
(session._c_object, ctypes.byref(list_size))
395
if list_size.value == 0:
396
return None
397
cert = cert_list[0]
398
return ctypes.string_at(cert.data, cert.size)
399
400
401
def fingerprint(openpgp):
402
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
403
# New GnuTLS "datum" with the OpenPGP public key
404
datum = gnutls.library.types.gnutls_datum_t\
405
(ctypes.cast(ctypes.c_char_p(openpgp),
406
ctypes.POINTER(ctypes.c_ubyte)),
407
ctypes.c_uint(len(openpgp)))
408
# New empty GnuTLS certificate
409
crt = gnutls.library.types.gnutls_openpgp_crt_t()
410
gnutls.library.functions.gnutls_openpgp_crt_init\
411
(ctypes.byref(crt))
412
# Import the OpenPGP public key into the certificate
413
gnutls.library.functions.gnutls_openpgp_crt_import\
414
(crt, ctypes.byref(datum),
415
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
416
# Verify the self signature in the key
417
crtverify = ctypes.c_uint();
418
gnutls.library.functions.gnutls_openpgp_crt_verify_self\
419
(crt, 0, ctypes.byref(crtverify))
420
if crtverify.value != 0:
421
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
422
raise gnutls.errors.CertificateSecurityError("Verify failed")
423
# New buffer for the fingerprint
424
buffer = ctypes.create_string_buffer(20)
425
buffer_length = ctypes.c_size_t()
426
# Get the fingerprint from the certificate into the buffer
427
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
428
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
429
# Deinit the certificate
430
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
431
# Convert the buffer to a Python bytestring
432
fpr = ctypes.string_at(buffer, buffer_length.value)
433
# Convert the bytestring to hexadecimal notation
434
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
435
return hex_fpr
436
437
438
class tcp_handler(SocketServer.BaseRequestHandler, object):
439
"""A TCP request handler class.
440
Instantiated by IPv6_TCPServer for each request to handle it.
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
1357
1358
# CheckerCompleted - signal
1359
@dbus.service.signal(_interface, signature="nxs")
1360
def CheckerCompleted(self, exitcode, waitstatus, command):
1361
"D-Bus signal"
1362
pass
1363
1364
# CheckerStarted - signal
1365
@dbus.service.signal(_interface, signature="s")
1366
def CheckerStarted(self, command):
1367
"D-Bus signal"
1368
pass
1369
1370
# PropertyChanged - signal
1371
@dbus.service.signal(_interface, signature="sv")
1372
def PropertyChanged(self, property, value):
1373
"D-Bus signal"
1374
pass
1375
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()
1408
1409
# Enable - method
1410
@dbus.service.method(_interface)
1411
def Enable(self):
1412
"D-Bus method"
1413
self.enable()
1414
1415
# StartChecker - method
1416
@dbus.service.method(_interface)
1417
def StartChecker(self):
1418
"D-Bus method"
1419
self.start_checker()
1420
1421
# Disable - method
1422
@dbus.service.method(_interface)
1423
def Disable(self):
1424
"D-Bus method"
1425
self.disable()
1426
1427
# 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)
1606
1607
del _interface
1608
1609
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.
441
1640
Note: This will run in its own forked process."""
442
1641
443
1642
def handle(self):
444
logger.info(u"TCP connection from: %s",
445
unicode(self.client_address))
446
session = gnutls.connection.ClientSession\
447
(self.request, gnutls.connection.X509Credentials())
448
449
line = self.request.makefile().readline()
450
logger.debug(u"Protocol version: %r", line)
451
try:
452
if int(line.strip().split()[0]) > 1:
453
raise RuntimeError
454
except (ValueError, IndexError, RuntimeError), error:
455
logger.error(u"Unknown protocol version: %s", error)
456
return
457
458
# Note: gnutls.connection.X509Credentials is really a generic
459
# GnuTLS certificate credentials object so long as no X.509
460
# keys are added to it. Therefore, we can use it here despite
461
# using OpenPGP certificates.
462
463
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
464
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
465
# "+DHE-DSS"))
466
priority = "NORMAL" # Fallback default, since this
467
# MUST be set.
468
if self.server.settings["priority"]:
469
priority = self.server.settings["priority"]
470
gnutls.library.functions.gnutls_priority_set_direct\
471
(session._c_object, priority, None);
472
473
try:
474
session.handshake()
475
except gnutls.errors.GNUTLSError, error:
476
logger.warning(u"Handshake failed: %s", error)
477
# Do not run session.bye() here: the session is not
478
# established. Just abandon the request.
479
return
480
try:
481
fpr = fingerprint(peer_certificate(session))
482
except (TypeError, gnutls.errors.GNUTLSError), error:
483
logger.warning(u"Bad certificate: %s", error)
484
session.bye()
485
return
486
logger.debug(u"Fingerprint: %s", fpr)
487
client = None
488
for c in self.server.clients:
489
if c.fingerprint == fpr:
490
client = c
491
break
492
if not client:
493
logger.warning(u"Client not found for fingerprint: %s",
494
fpr)
495
session.bye()
496
return
497
# Have to check if client.still_valid(), since it is possible
498
# that the client timed out while establishing the GnuTLS
499
# session.
500
if not client.still_valid():
501
logger.warning(u"Client %(name)s is invalid",
502
vars(client))
503
session.bye()
504
return
505
sent_size = 0
506
while sent_size < len(client.secret):
507
sent = session.send(client.secret[sent_size:])
508
logger.debug(u"Sent: %d, remaining: %d",
509
sent, len(client.secret)
510
- (sent_size + sent))
511
sent_size += sent
512
session.bye()
513
514
515
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
516
"""IPv6 TCP server. Accepts 'None' as address and/or port.
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
517
1897
Attributes:
518
settings: Server settings
519
clients: Set() of Client objects
1898
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
520
1901
"""
521
address_family = socket.AF_INET6
522
def __init__(self, *args, **kwargs):
523
if "settings" in kwargs:
524
self.settings = kwargs["settings"]
525
del kwargs["settings"]
526
if "clients" in kwargs:
527
self.clients = kwargs["clients"]
528
del kwargs["clients"]
529
return super(type(self), self).__init__(*args, **kwargs)
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
530
1939
def server_bind(self):
531
1940
"""This overrides the normal server_bind() function
532
1941
to bind to an interface if one was specified, and also NOT to
533
1942
bind to an address or port if they were not specified."""
534
if self.settings["interface"]:
535
# 25 is from /usr/include/asm-i486/socket.h
536
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
537
try:
538
self.socket.setsockopt(socket.SOL_SOCKET,
539
SO_BINDTODEVICE,
540
self.settings["interface"])
541
except socket.error, error:
542
if error[0] == errno.EPERM:
543
logger.error(u"No permission to"
544
u" bind to interface %s",
545
self.settings["interface"])
546
else:
547
raise error
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
548
1966
# Only bind(2) the socket if we really need to.
549
1967
if self.server_address[0] or self.server_address[1]:
550
1968
if not self.server_address[0]:
551
in6addr_any = "::"
552
self.server_address = (in6addr_any,
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,
553
1974
self.server_address[1])
554
1975
elif not self.server_address[1]:
555
1976
self.server_address = (self.server_address[0],
556
1977
0)
557
# if self.settings["interface"]:
1978
# if self.interface:
558
1979
# self.server_address = (self.server_address[0],
559
1980
# 0, # port
560
1981
# 0, # flowinfo
561
1982
# if_nametoindex
562
# (self.settings
563
# ["interface"]))
564
return super(type(self), self).server_bind()
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)
2011
def server_activate(self):
2012
if self.enabled:
2013
return socketserver.TCPServer.server_activate(self)
2014
2015
def enable(self):
2016
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
565
2191
566
2192
567
2193
def string_to_delta(interval):
568
2194
"""Parse a string and return a datetime.timedelta
569
2195
570
2196
>>> string_to_delta('7d')
571
2197
datetime.timedelta(7)
572
2198
>>> string_to_delta('60s')
575
2201
datetime.timedelta(0, 3600)
576
2202
>>> string_to_delta('24h')
577
2203
datetime.timedelta(1)
578
>>> string_to_delta(u'1w')
2204
>>> string_to_delta('1w')
579
2205
datetime.timedelta(7)
580
2206
>>> string_to_delta('5m 30s')
581
2207
datetime.timedelta(0, 330)
582
2208
"""
2209
2210
try:
2211
return rfc3339_duration_to_delta(interval)
2212
except ValueError:
2213
pass
2214
583
2215
timevalue = datetime.timedelta(0)
584
2216
for s in interval.split():
585
2217
try:
586
suffix=unicode(s[-1])
587
value=int(s[:-1])
588
if suffix == u"d":
2218
suffix = unicode(s[-1])
2219
value = int(s[:-1])
2220
if suffix == "d":
589
2221
delta = datetime.timedelta(value)
590
elif suffix == u"s":
2222
elif suffix == "s":
591
2223
delta = datetime.timedelta(0, value)
592
elif suffix == u"m":
2224
elif suffix == "m":
593
2225
delta = datetime.timedelta(0, 0, 0, 0, value)
594
elif suffix == u"h":
2226
elif suffix == "h":
595
2227
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
596
elif suffix == u"w":
2228
elif suffix == "w":
597
2229
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
598
2230
else:
599
raise ValueError
600
except (ValueError, IndexError):
601
raise ValueError
2231
raise ValueError("Unknown suffix {0!r}"
2232
.format(suffix))
2233
except (ValueError, IndexError) as e:
2234
raise ValueError(*(e.args))
602
2235
timevalue += delta
603
2236
return timevalue
604
2237
605
2238
606
def server_state_changed(state):
607
"""Derived from the Avahi example code"""
608
if state == avahi.SERVER_COLLISION:
609
logger.error(u"Zeroconf server name collision")
610
service.remove()
611
elif state == avahi.SERVER_RUNNING:
612
service.add()
613
614
615
def entry_group_state_changed(state, error):
616
"""Derived from the Avahi example code"""
617
logger.debug(u"Avahi state change: %i", state)
618
619
if state == avahi.ENTRY_GROUP_ESTABLISHED:
620
logger.debug(u"Zeroconf service established.")
621
elif state == avahi.ENTRY_GROUP_COLLISION:
622
logger.warning(u"Zeroconf service name collision.")
623
service.rename()
624
elif state == avahi.ENTRY_GROUP_FAILURE:
625
logger.critical(u"Avahi: Error in group state changed %s",
626
unicode(error))
627
raise AvahiGroupError("State changed: %s", str(error))
628
629
def if_nametoindex(interface):
630
"""Call the C function if_nametoindex(), or equivalent"""
631
global if_nametoindex
632
try:
633
if "ctypes.util" not in sys.modules:
634
import ctypes.util
635
if_nametoindex = ctypes.cdll.LoadLibrary\
636
(ctypes.util.find_library("c")).if_nametoindex
637
except (OSError, AttributeError):
638
if "struct" not in sys.modules:
639
import struct
640
if "fcntl" not in sys.modules:
641
import fcntl
642
def if_nametoindex(interface):
643
"Get an interface index the hard way, i.e. using fcntl()"
644
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
645
s = socket.socket()
646
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
647
struct.pack("16s16x", interface))
648
s.close()
649
interface_index = struct.unpack("I", ifreq[16:20])[0]
650
return interface_index
651
return if_nametoindex(interface)
652
653
654
2239
def daemon(nochdir = False, noclose = False):
655
2240
"""See daemon(3). Standard BSD Unix function.
2241
656
2242
This should really exist as os.daemon, but it doesn't (yet)."""
657
2243
if os.fork():
658
2244
sys.exit()
663
2249
sys.exit()
664
2250
if not noclose:
665
2251
# Close all standard open file descriptors
666
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2252
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
667
2253
if not stat.S_ISCHR(os.fstat(null).st_mode):
668
2254
raise OSError(errno.ENODEV,
669
"/dev/null not a character device")
2255
"{0} not a character device"
2256
.format(os.devnull))
670
2257
os.dup2(null, sys.stdin.fileno())
671
2258
os.dup2(null, sys.stdout.fileno())
672
2259
os.dup2(null, sys.stderr.fileno())
675
2262
676
2263
677
2264
def main():
678
global main_loop_started
679
main_loop_started = False
680
681
parser = OptionParser(version = "%%prog %s" % version)
682
parser.add_option("-i", "--interface", type="string",
683
metavar="IF", help="Bind to interface IF")
684
parser.add_option("-a", "--address", type="string",
685
help="Address to listen for requests on")
686
parser.add_option("-p", "--port", type="int",
687
help="Port number to receive requests on")
688
parser.add_option("--check", action="store_true", default=False,
689
help="Run self-test")
690
parser.add_option("--debug", action="store_true",
691
help="Debug mode; run in foreground and log to"
692
" terminal")
693
parser.add_option("--priority", type="string", help="GnuTLS"
694
" priority string (see GnuTLS documentation)")
695
parser.add_option("--servicename", type="string", metavar="NAME",
696
help="Zeroconf service name")
697
parser.add_option("--configdir", type="string",
698
default="/etc/mandos", metavar="DIR",
699
help="Directory to search for configuration"
700
" files")
701
(options, args) = parser.parse_args()
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()
702
2311
703
2312
if options.check:
704
2313
import doctest
713
2322
"priority":
714
2323
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
715
2324
"servicename": "Mandos",
2325
"use_dbus": "True",
2326
"use_ipv6": "True",
2327
"debuglevel": "",
2328
"restore": "True",
2329
"socket": "",
2330
"statedir": "/var/lib/mandos",
2331
"foreground": "False",
716
2332
}
717
2333
718
2334
# Parse config file for server-global settings
719
server_config = ConfigParser.SafeConfigParser(server_defaults)
2335
server_config = configparser.SafeConfigParser(server_defaults)
720
2336
del server_defaults
721
server_config.read(os.path.join(options.configdir, "mandos.conf"))
2337
server_config.read(os.path.join(options.configdir,
2338
"mandos.conf"))
722
2339
# Convert the SafeConfigParser object to a dict
723
2340
server_settings = server_config.defaults()
724
# Use getboolean on the boolean config option
725
server_settings["debug"] = server_config.getboolean\
726
("DEFAULT", "debug")
2341
# 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)
2345
if server_settings["port"]:
2346
server_settings["port"] = server_config.getint("DEFAULT",
2347
"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"])
727
2357
del server_config
728
2358
729
2359
# Override the settings from the config file with command line
730
2360
# options, if set.
731
2361
for option in ("interface", "address", "port", "debug",
732
"priority", "servicename", "configdir"):
2362
"priority", "servicename", "configdir",
2363
"use_dbus", "use_ipv6", "debuglevel", "restore",
2364
"statedir", "socket", "foreground"):
733
2365
value = getattr(options, option)
734
2366
if value is not None:
735
2367
server_settings[option] = value
736
2368
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
737
2376
# Now we have our good server settings in "server_settings"
738
2377
2378
##################################################################
2379
2380
# For convenience
739
2381
debug = server_settings["debug"]
2382
debuglevel = server_settings["debuglevel"]
2383
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"]
740
2388
741
if not debug:
742
syslogger.setLevel(logging.WARNING)
743
console.setLevel(logging.WARNING)
2389
if debug:
2390
initlogger(debug, logging.DEBUG)
2391
else:
2392
if not debuglevel:
2393
initlogger(debug)
2394
else:
2395
level = getattr(logging, debuglevel.upper())
2396
initlogger(debug, level)
744
2397
745
2398
if server_settings["servicename"] != "Mandos":
746
syslogger.setFormatter(logging.Formatter\
747
('Mandos (%s): %%(levelname)s:'
748
' %%(message)s'
749
% server_settings["servicename"]))
2399
syslogger.setFormatter(logging.Formatter
2400
('Mandos ({0}) [%(process)d]:'
2401
' %(levelname)s: %(message)s'
2402
.format(server_settings
2403
["servicename"])))
750
2404
751
2405
# Parse config file with clients
752
client_defaults = { "timeout": "1h",
753
"interval": "5m",
754
"checker": "fping -q -- %(host)s",
755
"host": "",
756
}
757
client_config = ConfigParser.SafeConfigParser(client_defaults)
2406
client_config = configparser.SafeConfigParser(Client
2407
.client_defaults)
758
2408
client_config.read(os.path.join(server_settings["configdir"],
759
2409
"clients.conf"))
760
2410
761
global service
762
service = AvahiService(name = server_settings["servicename"],
763
type = "_mandos._tcp", );
764
if server_settings["interface"]:
765
service.interface = if_nametoindex\
766
(server_settings["interface"])
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
2439
except KeyError:
2440
continue
2441
else:
2442
uid = 65534
2443
gid = 65534
2444
try:
2445
os.setgid(gid)
2446
os.setuid(uid)
2447
except OSError as error:
2448
if error.errno != errno.EPERM:
2449
raise error
2450
2451
if debug:
2452
# Enable all possible GnuTLS debugging
2453
2454
# "Use a log level over 10 to enable all debugging options."
2455
# - GnuTLS manual
2456
gnutls.library.functions.gnutls_global_set_log_level(11)
2457
2458
@gnutls.library.types.gnutls_log_func
2459
def debug_gnutls(level, string):
2460
logger.debug("GnuTLS: %s", string[:-1])
2461
2462
(gnutls.library.functions
2463
.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()
767
2479
768
2480
global main_loop
769
global bus
770
global server
771
2481
# From the Avahi example code
772
DBusGMainLoop(set_as_default=True )
2482
DBusGMainLoop(set_as_default=True)
773
2483
main_loop = gobject.MainLoop()
774
2484
bus = dbus.SystemBus()
775
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
776
avahi.DBUS_PATH_SERVER),
777
avahi.DBUS_INTERFACE_SERVER)
778
2485
# End of Avahi example code
779
780
clients = Set()
781
def remove_from_clients(client):
782
clients.remove(client)
783
if not clients:
784
logger.critical(u"No clients left, exiting")
785
sys.exit()
786
787
clients.update(Set(Client(name = section,
788
stop_hook = remove_from_clients,
789
config
790
= dict(client_config.items(section)))
791
for section in client_config.sections()))
792
if not clients:
793
logger.critical(u"No clients defined")
794
sys.exit(1)
795
796
if debug:
797
# Redirect stdin so all checkers get /dev/null
798
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
799
os.dup2(null, sys.stdin.fileno())
800
if null > 2:
801
os.close(null)
802
else:
803
# No console logging
804
logger.removeHandler(console)
805
# Close all input and output, do double fork, etc.
806
daemon()
807
808
pidfilename = "/var/run/mandos/mandos.pid"
809
pid = os.getpid()
810
try:
811
pidfile = open(pidfilename, "w")
812
pidfile.write(str(pid) + "\n")
813
pidfile.close()
2486
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)
814
2620
del pidfile
815
except IOError, err:
816
logger.error(u"Could not write %s file with PID %d",
817
pidfilename, os.getpid())
2621
del pidfilename
2622
2623
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2624
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2625
2626
if use_dbus:
2627
@alternate_dbus_interfaces({"se.recompile.Mandos":
2628
"se.bsnet.fukt.Mandos"})
2629
class MandosDBusService(DBusObjectWithProperties):
2630
"""A D-Bus proxy object"""
2631
def __init__(self):
2632
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):
2648
"D-Bus signal"
2649
pass
2650
2651
@dbus.service.signal(_interface, signature="os")
2652
def ClientRemoved(self, objpath, name):
2653
"D-Bus signal"
2654
pass
2655
2656
@dbus.service.method(_interface, out_signature="ao")
2657
def GetAllClients(self):
2658
"D-Bus method"
2659
return dbus.Array(c.dbus_object_path
2660
for c in
2661
tcp_server.clients.itervalues())
2662
2663
@dbus.service.method(_interface,
2664
out_signature="a{oa{sv}}")
2665
def GetAllClientsWithProperties(self):
2666
"D-Bus method"
2667
return dbus.Dictionary(
2668
((c.dbus_object_path, c.GetAll(""))
2669
for c in tcp_server.clients.itervalues()),
2670
signature="oa{sv}")
2671
2672
@dbus.service.method(_interface, in_signature="o")
2673
def RemoveClient(self, object_path):
2674
"D-Bus method"
2675
for c in tcp_server.clients.itervalues():
2676
if c.dbus_object_path == object_path:
2677
del tcp_server.clients[c.name]
2678
c.remove_from_connection()
2679
# Don't signal anything except ClientRemoved
2680
c.disable(quiet=True)
2681
# Emit D-Bus signal
2682
self.ClientRemoved(object_path, c.name)
2683
return
2684
raise KeyError(object_path)
2685
2686
del _interface
2687
2688
mandos_dbus_service = MandosDBusService()
818
2689
819
2690
def cleanup():
820
2691
"Cleanup function; run on exit"
821
global group
822
# From the Avahi example code
823
if not group is None:
824
group.Free()
825
group = None
826
# End of Avahi example code
827
828
while clients:
829
client = clients.pop()
830
client.stop_hook = None
831
client.stop()
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()
832
2761
833
2762
atexit.register(cleanup)
834
2763
835
if not debug:
836
signal.signal(signal.SIGINT, signal.SIG_IGN)
837
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
838
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
839
840
for client in clients:
841
client.start()
842
843
tcp_server = IPv6_TCPServer((server_settings["address"],
844
server_settings["port"]),
845
tcp_handler,
846
settings=server_settings,
847
clients=clients)
2764
for client in tcp_server.clients.itervalues():
2765
if use_dbus:
2766
# 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()
2771
2772
tcp_server.enable()
2773
tcp_server.server_activate()
2774
848
2775
# Find out what port we got
849
2776
service.port = tcp_server.socket.getsockname()[1]
850
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
851
u" scope_id %d" % tcp_server.socket.getsockname())
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())
852
2784
853
2785
#service.interface = tcp_server.socket.getsockname()[3]
854
2786
855
2787
try:
856
2788
# From the Avahi example code
857
server.connect_to_signal("StateChanged", server_state_changed)
858
2789
try:
859
server_state_changed(server.GetState())
860
except dbus.exceptions.DBusException, error:
861
logger.critical(u"DBusException: %s", error)
2790
service.activate()
2791
except dbus.exceptions.DBusException as error:
2792
logger.critical("D-Bus Exception", exc_info=error)
2793
cleanup()
862
2794
sys.exit(1)
863
2795
# End of Avahi example code
864
2796
865
2797
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
866
2798
lambda *args, **kwargs:
867
tcp_server.handle_request\
868
(*args[2:], **kwargs) or True)
2799
(tcp_server.handle_request
2800
(*args[2:], **kwargs) or True))
869
2801
870
logger.debug(u"Starting main loop")
871
main_loop_started = True
2802
logger.debug("Starting main loop")
872
2803
main_loop.run()
873
except AvahiError, error:
874
logger.critical(u"AvahiError: %s" + unicode(error))
2804
except AvahiError as error:
2805
logger.critical("Avahi Error", exc_info=error)
2806
cleanup()
875
2807
sys.exit(1)
876
2808
except KeyboardInterrupt:
877
2809
if debug:
878
print
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()
879
2815
880
2816
if __name__ == '__main__':
881
2817
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0