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