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