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 441
- compare with another revision
- download diff
- download tarball
- view history from revision 441
- Committer: Teddy Hogeborn
- Date: 2010-09-25 23:52:17 UTC
- Revision ID: teddy@fukt.bsnet.se-20100925235217-4hhqfryz1ste6uw3
* mandos (ClientDBus.__init__): Bug fix: Translate "-" in client names
to "_" in D-Bus object paths.
(MandosServer.handle_ipc): Bug fix: Send only address string to
D-Bus signal, not whole tuple.
* mandos-ctl: New options "--approve-by-default", "--deny-by-default",
"--approval-delay", and "--approval-duration".
* mandos-ctl.xml (SYNOPSIS, OPTIONS): Document new options.
* mandos-monitor (MandosClientWidget.update): Fix spelling.
to "_" in D-Bus object paths.
(MandosServer.handle_ipc): Bug fix: Send only address string to
D-Bus signal, not whole tuple.
* mandos-ctl: New options "--approve-by-default", "--deny-by-default",
"--approval-delay", and "--approval-duration".
* mandos-ctl.xml (SYNOPSIS, OPTIONS): Document new options.
* mandos-monitor (MandosClientWidget.update): Fix spelling.
- files removed:
- debian/source
- files modified:
- .bzrignore
added
removed
mandos
11
11
# "AvahiService" class, 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
36
import SocketServer as socketserver
38
37
import socket
39
import argparse
38
import optparse
40
39
import datetime
41
40
import errno
42
41
import gnutls.crypto
82
81
SO_BINDTODEVICE = None
83
82
84
83
85
version = "1.3.1"
84
version = "1.0.14"
86
85
87
#logger = logging.getLogger('mandos')
88
logger = logging.Logger('mandos')
86
#logger = logging.getLogger(u'mandos')
87
logger = logging.Logger(u'mandos')
89
88
syslogger = (logging.handlers.SysLogHandler
90
89
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
91
address = str("/dev/log")))
90
address = "/dev/log"))
92
91
syslogger.setFormatter(logging.Formatter
93
('Mandos [%(process)d]: %(levelname)s:'
94
' %(message)s'))
92
(u'Mandos [%(process)d]: %(levelname)s:'
93
u' %(message)s'))
95
94
logger.addHandler(syslogger)
96
95
97
96
console = logging.StreamHandler()
98
console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'
99
' %(levelname)s:'
100
' %(message)s'))
97
console.setFormatter(logging.Formatter(u'%(name)s [%(process)d]:'
98
u' %(levelname)s:'
99
u' %(message)s'))
101
100
logger.addHandler(console)
102
101
103
102
class AvahiError(Exception):
120
119
Attributes:
121
120
interface: integer; avahi.IF_UNSPEC or an interface index.
122
121
Used to optionally bind to the specified interface.
123
name: string; Example: 'Mandos'
124
type: string; Example: '_mandos._tcp'.
122
name: string; Example: u'Mandos'
123
type: string; Example: u'_mandos._tcp'.
125
124
See <http://www.dns-sd.org/ServiceTypes.html>
126
125
port: integer; what port to announce
127
126
TXT: list of strings; TXT record for the service
136
135
"""
137
136
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
138
137
servicetype = None, port = None, TXT = None,
139
domain = "", host = "", max_renames = 32768,
138
domain = u"", host = u"", max_renames = 32768,
140
139
protocol = avahi.PROTO_UNSPEC, bus = None):
141
140
self.interface = interface
142
141
self.name = name
151
150
self.group = None # our entry group
152
151
self.server = None
153
152
self.bus = bus
154
self.entry_group_state_changed_match = None
155
153
def rename(self):
156
154
"""Derived from the Avahi example code"""
157
155
if self.rename_count >= self.max_renames:
158
logger.critical("No suitable Zeroconf service name found"
159
" after %i retries, exiting.",
156
logger.critical(u"No suitable Zeroconf service name found"
157
u" after %i retries, exiting.",
160
158
self.rename_count)
161
raise AvahiServiceError("Too many renames")
159
raise AvahiServiceError(u"Too many renames")
162
160
self.name = unicode(self.server.GetAlternativeServiceName(self.name))
163
logger.info("Changing Zeroconf service name to %r ...",
161
logger.info(u"Changing Zeroconf service name to %r ...",
164
162
self.name)
165
163
syslogger.setFormatter(logging.Formatter
166
('Mandos (%s) [%%(process)d]:'
167
' %%(levelname)s: %%(message)s'
164
(u'Mandos (%s) [%%(process)d]:'
165
u' %%(levelname)s: %%(message)s'
168
166
% self.name))
169
167
self.remove()
170
168
try:
171
169
self.add()
172
except dbus.exceptions.DBusException as error:
173
logger.critical("DBusException: %s", error)
170
except dbus.exceptions.DBusException, error:
171
logger.critical(u"DBusException: %s", error)
174
172
self.cleanup()
175
173
os._exit(1)
176
174
self.rename_count += 1
177
175
def remove(self):
178
176
"""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
177
if self.group is not None:
183
178
self.group.Reset()
184
179
def add(self):
185
180
"""Derived from the Avahi example code"""
186
self.remove()
187
181
if self.group is None:
188
182
self.group = dbus.Interface(
189
183
self.bus.get_object(avahi.DBUS_NAME,
190
184
self.server.EntryGroupNew()),
191
185
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' ...",
186
self.group.connect_to_signal('StateChanged',
187
self
188
.entry_group_state_changed)
189
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
196
190
self.name, self.type)
197
191
self.group.AddService(
198
192
self.interface,
205
199
self.group.Commit()
206
200
def entry_group_state_changed(self, state, error):
207
201
"""Derived from the Avahi example code"""
208
logger.debug("Avahi entry group state change: %i", state)
202
logger.debug(u"Avahi entry group state change: %i", state)
209
203
210
204
if state == avahi.ENTRY_GROUP_ESTABLISHED:
211
logger.debug("Zeroconf service established.")
205
logger.debug(u"Zeroconf service established.")
212
206
elif state == avahi.ENTRY_GROUP_COLLISION:
213
logger.info("Zeroconf service name collision.")
207
logger.warning(u"Zeroconf service name collision.")
214
208
self.rename()
215
209
elif state == avahi.ENTRY_GROUP_FAILURE:
216
logger.critical("Avahi: Error in group state changed %s",
210
logger.critical(u"Avahi: Error in group state changed %s",
217
211
unicode(error))
218
raise AvahiGroupError("State changed: %s"
212
raise AvahiGroupError(u"State changed: %s"
219
213
% unicode(error))
220
214
def cleanup(self):
221
215
"""Derived from the Avahi example code"""
222
216
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
217
self.group.Free()
228
218
self.group = None
229
self.remove()
230
def server_state_changed(self, state, error=None):
219
def server_state_changed(self, state):
231
220
"""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()
221
logger.debug(u"Avahi server state change: %i", state)
222
if state == avahi.SERVER_COLLISION:
223
logger.error(u"Zeroconf server name collision")
224
self.remove()
247
225
elif state == avahi.SERVER_RUNNING:
248
226
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
227
def activate(self):
255
228
"""Derived from the Avahi example code"""
256
229
if self.server is None:
257
230
self.server = dbus.Interface(
258
231
self.bus.get_object(avahi.DBUS_NAME,
259
avahi.DBUS_PATH_SERVER,
260
follow_name_owner_changes=True),
232
avahi.DBUS_PATH_SERVER),
261
233
avahi.DBUS_INTERFACE_SERVER)
262
self.server.connect_to_signal("StateChanged",
234
self.server.connect_to_signal(u"StateChanged",
263
235
self.server_state_changed)
264
236
self.server_state_changed(self.server.GetState())
265
237
266
238
267
def _timedelta_to_milliseconds(td):
268
"Convert a datetime.timedelta() to milliseconds"
269
return ((td.days * 24 * 60 * 60 * 1000)
270
+ (td.seconds * 1000)
271
+ (td.microseconds // 1000))
272
273
239
class Client(object):
274
240
"""A representation of a client host served by this server.
275
241
280
246
checker: subprocess.Popen(); a running checker process used
281
247
to see if the client lives.
282
248
'None' if no process is running.
283
checker_callback_tag: a gobject event source tag, or None
249
checker_callback_tag: - '' -
284
250
checker_command: string; External command which is run to check
285
251
if client lives. %() expansions are done at
286
252
runtime with vars(self) as dict, so that for
289
255
created: datetime.datetime(); (UTC) object creation
290
256
current_checker_command: string; current running checker_command
291
257
disable_hook: If set, called by disable() as disable_hook(self)
292
disable_initiator_tag: a gobject event source tag, or None
258
disable_initiator_tag: - '' -
293
259
enabled: bool()
294
260
fingerprint: string (40 or 32 hexadecimal digits); used to
295
261
uniquely identify the client
296
262
host: string; available for use by the checker command
297
263
interval: datetime.timedelta(); How often to start a new checker
298
last_approval_request: datetime.datetime(); (UTC) or None
299
264
last_checked_ok: datetime.datetime(); (UTC) or None
300
265
last_enabled: datetime.datetime(); (UTC)
301
266
name: string; from the config file, used in log messages and
303
268
secret: bytestring; sent verbatim (over TLS) to client
304
269
timeout: datetime.timedelta(); How long from last_checked_ok
305
270
until this client is disabled
306
extended_timeout: extra long timeout when password has been sent
307
271
runtime_expansions: Allowed attributes for runtime expansion.
308
expires: datetime.datetime(); time (UTC) when a client will be
309
disabled, or None
310
272
"""
311
273
312
runtime_expansions = ("approval_delay", "approval_duration",
313
"created", "enabled", "fingerprint",
314
"host", "interval", "last_checked_ok",
315
"last_enabled", "name", "timeout")
274
runtime_expansions = (u"approval_delay", u"approval_duration",
275
u"created", u"enabled", u"fingerprint",
276
u"host", u"interval", u"last_checked_ok",
277
u"last_enabled", u"name", u"timeout")
278
279
@staticmethod
280
def _timedelta_to_milliseconds(td):
281
"Convert a datetime.timedelta() to milliseconds"
282
return ((td.days * 24 * 60 * 60 * 1000)
283
+ (td.seconds * 1000)
284
+ (td.microseconds // 1000))
316
285
317
286
def timeout_milliseconds(self):
318
287
"Return the 'timeout' attribute in milliseconds"
319
return _timedelta_to_milliseconds(self.timeout)
320
321
def extended_timeout_milliseconds(self):
322
"Return the 'extended_timeout' attribute in milliseconds"
323
return _timedelta_to_milliseconds(self.extended_timeout)
288
return self._timedelta_to_milliseconds(self.timeout)
324
289
325
290
def interval_milliseconds(self):
326
291
"Return the 'interval' attribute in milliseconds"
327
return _timedelta_to_milliseconds(self.interval)
328
292
return self._timedelta_to_milliseconds(self.interval)
293
329
294
def approval_delay_milliseconds(self):
330
return _timedelta_to_milliseconds(self.approval_delay)
295
return self._timedelta_to_milliseconds(self.approval_delay)
331
296
332
297
def __init__(self, name = None, disable_hook=None, config=None):
333
298
"""Note: the 'checker' key in 'config' sets the
336
301
self.name = name
337
302
if config is None:
338
303
config = {}
339
logger.debug("Creating client %r", self.name)
304
logger.debug(u"Creating client %r", self.name)
340
305
# Uppercase and remove spaces from fingerprint for later
341
306
# comparison purposes with return value from the fingerprint()
342
307
# function
343
self.fingerprint = (config["fingerprint"].upper()
344
.replace(" ", ""))
345
logger.debug(" Fingerprint: %s", self.fingerprint)
346
if "secret" in config:
347
self.secret = config["secret"].decode("base64")
348
elif "secfile" in config:
308
self.fingerprint = (config[u"fingerprint"].upper()
309
.replace(u" ", u""))
310
logger.debug(u" Fingerprint: %s", self.fingerprint)
311
if u"secret" in config:
312
self.secret = config[u"secret"].decode(u"base64")
313
elif u"secfile" in config:
349
314
with open(os.path.expanduser(os.path.expandvars
350
(config["secfile"])),
315
(config[u"secfile"])),
351
316
"rb") as secfile:
352
317
self.secret = secfile.read()
353
318
else:
354
raise TypeError("No secret or secfile for client %s"
319
raise TypeError(u"No secret or secfile for client %s"
355
320
% self.name)
356
self.host = config.get("host", "")
321
self.host = config.get(u"host", u"")
357
322
self.created = datetime.datetime.utcnow()
358
323
self.enabled = False
359
self.last_approval_request = None
360
324
self.last_enabled = None
361
325
self.last_checked_ok = None
362
self.timeout = string_to_delta(config["timeout"])
363
self.extended_timeout = string_to_delta(config["extended_timeout"])
364
self.interval = string_to_delta(config["interval"])
326
self.timeout = string_to_delta(config[u"timeout"])
327
self.interval = string_to_delta(config[u"interval"])
365
328
self.disable_hook = disable_hook
366
329
self.checker = None
367
330
self.checker_initiator_tag = None
368
331
self.disable_initiator_tag = None
369
self.expires = None
370
332
self.checker_callback_tag = None
371
self.checker_command = config["checker"]
333
self.checker_command = config[u"checker"]
372
334
self.current_checker_command = None
373
335
self.last_connect = None
374
336
self._approved = None
375
self.approved_by_default = config.get("approved_by_default",
337
self.approved_by_default = config.get(u"approved_by_default",
376
338
True)
377
339
self.approvals_pending = 0
378
340
self.approval_delay = string_to_delta(
379
config["approval_delay"])
341
config[u"approval_delay"])
380
342
self.approval_duration = string_to_delta(
381
config["approval_duration"])
343
config[u"approval_duration"])
382
344
self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
383
345
384
346
def send_changedstate(self):
388
350
389
351
def enable(self):
390
352
"""Start this client's checker and timeout hooks"""
391
if getattr(self, "enabled", False):
353
if getattr(self, u"enabled", False):
392
354
# Already enabled
393
355
return
394
356
self.send_changedstate()
357
self.last_enabled = datetime.datetime.utcnow()
395
358
# Schedule a new checker to be started an 'interval' from now,
396
359
# and every interval from then on.
397
360
self.checker_initiator_tag = (gobject.timeout_add
398
361
(self.interval_milliseconds(),
399
362
self.start_checker))
400
363
# Schedule a disable() when 'timeout' has passed
401
self.expires = datetime.datetime.utcnow() + self.timeout
402
364
self.disable_initiator_tag = (gobject.timeout_add
403
365
(self.timeout_milliseconds(),
404
366
self.disable))
405
367
self.enabled = True
406
self.last_enabled = datetime.datetime.utcnow()
407
368
# Also start a new checker *right now*.
408
369
self.start_checker()
409
370
414
375
if not quiet:
415
376
self.send_changedstate()
416
377
if not quiet:
417
logger.info("Disabling client %s", self.name)
418
if getattr(self, "disable_initiator_tag", False):
378
logger.info(u"Disabling client %s", self.name)
379
if getattr(self, u"disable_initiator_tag", False):
419
380
gobject.source_remove(self.disable_initiator_tag)
420
381
self.disable_initiator_tag = None
421
self.expires = None
422
if getattr(self, "checker_initiator_tag", False):
382
if getattr(self, u"checker_initiator_tag", False):
423
383
gobject.source_remove(self.checker_initiator_tag)
424
384
self.checker_initiator_tag = None
425
385
self.stop_checker()
440
400
if os.WIFEXITED(condition):
441
401
exitstatus = os.WEXITSTATUS(condition)
442
402
if exitstatus == 0:
443
logger.info("Checker for %(name)s succeeded",
403
logger.info(u"Checker for %(name)s succeeded",
444
404
vars(self))
445
405
self.checked_ok()
446
406
else:
447
logger.info("Checker for %(name)s failed",
407
logger.info(u"Checker for %(name)s failed",
448
408
vars(self))
449
409
else:
450
logger.warning("Checker for %(name)s crashed?",
410
logger.warning(u"Checker for %(name)s crashed?",
451
411
vars(self))
452
412
453
def checked_ok(self, timeout=None):
413
def checked_ok(self):
454
414
"""Bump up the timeout for this client.
455
415
456
416
This should only be called when the client has been seen,
457
417
alive and well.
458
418
"""
459
if timeout is None:
460
timeout = self.timeout
461
419
self.last_checked_ok = datetime.datetime.utcnow()
462
420
gobject.source_remove(self.disable_initiator_tag)
463
self.expires = datetime.datetime.utcnow() + timeout
464
421
self.disable_initiator_tag = (gobject.timeout_add
465
(_timedelta_to_milliseconds(timeout),
422
(self.timeout_milliseconds(),
466
423
self.disable))
467
424
468
def need_approval(self):
469
self.last_approval_request = datetime.datetime.utcnow()
470
471
425
def start_checker(self):
472
426
"""Start a new checker subprocess if one is not running.
473
427
485
439
# If a checker exists, make sure it is not a zombie
486
440
try:
487
441
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
488
except (AttributeError, OSError) as error:
442
except (AttributeError, OSError), error:
489
443
if (isinstance(error, OSError)
490
444
and error.errno != errno.ECHILD):
491
445
raise error
492
446
else:
493
447
if pid:
494
logger.warning("Checker was a zombie")
448
logger.warning(u"Checker was a zombie")
495
449
gobject.source_remove(self.checker_callback_tag)
496
450
self.checker_callback(pid, status,
497
451
self.current_checker_command)
504
458
# Escape attributes for the shell
505
459
escaped_attrs = dict(
506
460
(attr,
507
re.escape(unicode(str(getattr(self, attr, "")),
461
re.escape(unicode(str(getattr(self, attr, u"")),
508
462
errors=
509
'replace')))
463
u'replace')))
510
464
for attr in
511
465
self.runtime_expansions)
512
466
513
467
try:
514
468
command = self.checker_command % escaped_attrs
515
except TypeError as error:
516
logger.error('Could not format string "%s":'
517
' %s', self.checker_command, error)
469
except TypeError, error:
470
logger.error(u'Could not format string "%s":'
471
u' %s', self.checker_command, error)
518
472
return True # Try again later
519
473
self.current_checker_command = command
520
474
try:
521
logger.info("Starting checker %r for %s",
475
logger.info(u"Starting checker %r for %s",
522
476
command, self.name)
523
477
# We don't need to redirect stdout and stderr, since
524
478
# in normal mode, that is already done by daemon(),
526
480
# always replaced by /dev/null.)
527
481
self.checker = subprocess.Popen(command,
528
482
close_fds=True,
529
shell=True, cwd="/")
483
shell=True, cwd=u"/")
530
484
self.checker_callback_tag = (gobject.child_watch_add
531
485
(self.checker.pid,
532
486
self.checker_callback,
537
491
if pid:
538
492
gobject.source_remove(self.checker_callback_tag)
539
493
self.checker_callback(pid, status, command)
540
except OSError as error:
541
logger.error("Failed to start subprocess: %s",
494
except OSError, error:
495
logger.error(u"Failed to start subprocess: %s",
542
496
error)
543
497
# Re-run this periodically if run by gobject.timeout_add
544
498
return True
548
502
if self.checker_callback_tag:
549
503
gobject.source_remove(self.checker_callback_tag)
550
504
self.checker_callback_tag = None
551
if getattr(self, "checker", None) is None:
505
if getattr(self, u"checker", None) is None:
552
506
return
553
logger.debug("Stopping checker for %(name)s", vars(self))
507
logger.debug(u"Stopping checker for %(name)s", vars(self))
554
508
try:
555
509
os.kill(self.checker.pid, signal.SIGTERM)
556
510
#time.sleep(0.5)
557
511
#if self.checker.poll() is None:
558
512
# os.kill(self.checker.pid, signal.SIGKILL)
559
except OSError as error:
513
except OSError, error:
560
514
if error.errno != errno.ESRCH: # No such process
561
515
raise
562
516
self.checker = None
563
517
564
565
def dbus_service_property(dbus_interface, signature="v",
566
access="readwrite", byte_arrays=False):
518
def dbus_service_property(dbus_interface, signature=u"v",
519
access=u"readwrite", byte_arrays=False):
567
520
"""Decorators for marking methods of a DBusObjectWithProperties to
568
521
become properties on the D-Bus.
569
522
576
529
"""
577
530
# Encoding deeply encoded byte arrays is not supported yet by the
578
531
# "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)
532
if byte_arrays and signature != u"ay":
533
raise ValueError(u"Byte arrays not supported for non-'ay'"
534
u" signature %r" % signature)
582
535
def decorator(func):
583
536
func._dbus_is_property = True
584
537
func._dbus_interface = dbus_interface
585
538
func._dbus_signature = signature
586
539
func._dbus_access = access
587
540
func._dbus_name = func.__name__
588
if func._dbus_name.endswith("_dbus_property"):
541
if func._dbus_name.endswith(u"_dbus_property"):
589
542
func._dbus_name = func._dbus_name[:-14]
590
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
543
func._dbus_get_args_options = {u'byte_arrays': byte_arrays }
591
544
return func
592
545
return decorator
593
546
613
566
614
567
class DBusObjectWithProperties(dbus.service.Object):
615
568
"""A D-Bus object with properties.
616
569
617
570
Classes inheriting from this can use the dbus_service_property
618
571
decorator to expose methods as D-Bus properties. It exposes the
619
572
standard Get(), Set(), and GetAll() methods on the D-Bus.
621
574
622
575
@staticmethod
623
576
def _is_dbus_property(obj):
624
return getattr(obj, "_dbus_is_property", False)
577
return getattr(obj, u"_dbus_is_property", False)
625
578
626
579
def _get_all_dbus_properties(self):
627
580
"""Returns a generator of (name, attribute) pairs
635
588
property with the specified name and interface.
636
589
"""
637
590
for name in (property_name,
638
property_name + "_dbus_property"):
591
property_name + u"_dbus_property"):
639
592
prop = getattr(self, name, None)
640
593
if (prop is None
641
594
or not self._is_dbus_property(prop)
645
598
continue
646
599
return prop
647
600
# No such property
648
raise DBusPropertyNotFound(self.dbus_object_path + ":"
649
+ interface_name + "."
601
raise DBusPropertyNotFound(self.dbus_object_path + u":"
602
+ interface_name + u"."
650
603
+ property_name)
651
604
652
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
653
out_signature="v")
605
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
606
out_signature=u"v")
654
607
def Get(self, interface_name, property_name):
655
608
"""Standard D-Bus property Get() method, see D-Bus standard.
656
609
"""
657
610
prop = self._get_dbus_property(interface_name, property_name)
658
if prop._dbus_access == "write":
611
if prop._dbus_access == u"write":
659
612
raise DBusPropertyAccessException(property_name)
660
613
value = prop()
661
if not hasattr(value, "variant_level"):
614
if not hasattr(value, u"variant_level"):
662
615
return value
663
616
return type(value)(value, variant_level=value.variant_level+1)
664
617
665
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
618
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
666
619
def Set(self, interface_name, property_name, value):
667
620
"""Standard D-Bus property Set() method, see D-Bus standard.
668
621
"""
669
622
prop = self._get_dbus_property(interface_name, property_name)
670
if prop._dbus_access == "read":
623
if prop._dbus_access == u"read":
671
624
raise DBusPropertyAccessException(property_name)
672
if prop._dbus_get_args_options["byte_arrays"]:
625
if prop._dbus_get_args_options[u"byte_arrays"]:
673
626
# The byte_arrays option is not supported yet on
674
627
# signatures other than "ay".
675
if prop._dbus_signature != "ay":
628
if prop._dbus_signature != u"ay":
676
629
raise ValueError
677
630
value = dbus.ByteArray(''.join(unichr(byte)
678
631
for byte in value))
679
632
prop(value)
680
633
681
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
682
out_signature="a{sv}")
634
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
635
out_signature=u"a{sv}")
683
636
def GetAll(self, interface_name):
684
637
"""Standard D-Bus property GetAll() method, see D-Bus
685
638
standard.
686
639
687
640
Note: Will not include properties with access="write".
688
641
"""
689
642
all = {}
693
646
# Interface non-empty but did not match
694
647
continue
695
648
# Ignore write-only properties
696
if prop._dbus_access == "write":
649
if prop._dbus_access == u"write":
697
650
continue
698
651
value = prop()
699
if not hasattr(value, "variant_level"):
652
if not hasattr(value, u"variant_level"):
700
653
all[name] = value
701
654
continue
702
655
all[name] = type(value)(value, variant_level=
703
656
value.variant_level+1)
704
return dbus.Dictionary(all, signature="sv")
657
return dbus.Dictionary(all, signature=u"sv")
705
658
706
659
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
707
out_signature="s",
660
out_signature=u"s",
708
661
path_keyword='object_path',
709
662
connection_keyword='connection')
710
663
def Introspect(self, object_path, connection):
715
668
try:
716
669
document = xml.dom.minidom.parseString(xmlstring)
717
670
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)
671
e = document.createElement(u"property")
672
e.setAttribute(u"name", name)
673
e.setAttribute(u"type", prop._dbus_signature)
674
e.setAttribute(u"access", prop._dbus_access)
722
675
return e
723
for if_tag in document.getElementsByTagName("interface"):
676
for if_tag in document.getElementsByTagName(u"interface"):
724
677
for tag in (make_tag(document, name, prop)
725
678
for name, prop
726
679
in self._get_all_dbus_properties()
727
680
if prop._dbus_interface
728
== if_tag.getAttribute("name")):
681
== if_tag.getAttribute(u"name")):
729
682
if_tag.appendChild(tag)
730
683
# Add the names to the return values for the
731
684
# "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")
685
if (if_tag.getAttribute(u"name")
686
== u"org.freedesktop.DBus.Properties"):
687
for cn in if_tag.getElementsByTagName(u"method"):
688
if cn.getAttribute(u"name") == u"Get":
689
for arg in cn.getElementsByTagName(u"arg"):
690
if (arg.getAttribute(u"direction")
691
== u"out"):
692
arg.setAttribute(u"name", u"value")
693
elif cn.getAttribute(u"name") == u"GetAll":
694
for arg in cn.getElementsByTagName(u"arg"):
695
if (arg.getAttribute(u"direction")
696
== u"out"):
697
arg.setAttribute(u"name", u"props")
698
xmlstring = document.toxml(u"utf-8")
746
699
document.unlink()
747
700
except (AttributeError, xml.dom.DOMException,
748
xml.parsers.expat.ExpatError) as error:
749
logger.error("Failed to override Introspection method",
701
xml.parsers.expat.ExpatError), error:
702
logger.error(u"Failed to override Introspection method",
750
703
error)
751
704
return xmlstring
752
705
753
706
754
def datetime_to_dbus (dt, variant_level=0):
755
"""Convert a UTC datetime.datetime() to a D-Bus type."""
756
if dt is None:
757
return dbus.String("", variant_level = variant_level)
758
return dbus.String(dt.isoformat(),
759
variant_level=variant_level)
760
761
762
707
class ClientDBus(Client, DBusObjectWithProperties):
763
708
"""A Client class using D-Bus
764
709
768
713
"""
769
714
770
715
runtime_expansions = (Client.runtime_expansions
771
+ ("dbus_object_path",))
716
+ (u"dbus_object_path",))
772
717
773
718
# dbus.service.Object doesn't use super(), so we can't either.
774
719
779
724
# Only now, when this client is initialized, can it show up on
780
725
# the D-Bus
781
726
client_object_name = unicode(self.name).translate(
782
{ord("."): ord("_"),
783
ord("-"): ord("_")})
727
{ord(u"."): ord(u"_"),
728
ord(u"-"): ord(u"_")})
784
729
self.dbus_object_path = (dbus.ObjectPath
785
("/clients/" + client_object_name))
730
(u"/clients/" + client_object_name))
786
731
DBusObjectWithProperties.__init__(self, self.bus,
787
732
self.dbus_object_path)
788
733
789
def notifychangeproperty(transform_func,
790
dbus_name, type_func=lambda x: x,
791
variant_level=1):
792
""" Modify a variable so that its a property that announce its
793
changes to DBus.
794
transform_fun: Function that takes a value and transform it to
795
DBus type.
796
dbus_name: DBus name of the variable
797
type_func: Function that transform the value before sending it
798
to DBus
799
variant_level: DBus variant level. default: 1
800
"""
801
real_value = [None,]
802
def setter(self, value):
803
old_value = real_value[0]
804
real_value[0] = value
805
if hasattr(self, "dbus_object_path"):
806
if type_func(old_value) != type_func(real_value[0]):
807
dbus_value = transform_func(type_func(real_value[0]),
808
variant_level)
809
self.PropertyChanged(dbus.String(dbus_name),
810
dbus_value)
811
812
return property(lambda self: real_value[0], setter)
813
814
815
expires = notifychangeproperty(datetime_to_dbus, "Expires")
816
approvals_pending = notifychangeproperty(dbus.Boolean,
817
"ApprovalPending",
818
type_func = bool)
819
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
820
last_enabled = notifychangeproperty(datetime_to_dbus,
821
"LastEnabled")
822
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
823
type_func = lambda checker: checker is not None)
824
last_checked_ok = notifychangeproperty(datetime_to_dbus,
825
"LastCheckedOK")
826
last_approval_request = notifychangeproperty(datetime_to_dbus,
827
"LastApprovalRequest")
828
approved_by_default = notifychangeproperty(dbus.Boolean,
829
"ApprovedByDefault")
830
approval_delay = notifychangeproperty(dbus.UInt16, "ApprovalDelay",
831
type_func = _timedelta_to_milliseconds)
832
approval_duration = notifychangeproperty(dbus.UInt16, "ApprovalDuration",
833
type_func = _timedelta_to_milliseconds)
834
host = notifychangeproperty(dbus.String, "Host")
835
timeout = notifychangeproperty(dbus.UInt16, "Timeout",
836
type_func = _timedelta_to_milliseconds)
837
extended_timeout = notifychangeproperty(dbus.UInt16, "ExtendedTimeout",
838
type_func = _timedelta_to_milliseconds)
839
interval = notifychangeproperty(dbus.UInt16, "Interval",
840
type_func = _timedelta_to_milliseconds)
841
checker_command = notifychangeproperty(dbus.String, "Checker")
842
843
del notifychangeproperty
734
def _get_approvals_pending(self):
735
return self._approvals_pending
736
def _set_approvals_pending(self, value):
737
old_value = self._approvals_pending
738
self._approvals_pending = value
739
bval = bool(value)
740
if (hasattr(self, "dbus_object_path")
741
and bval is not bool(old_value)):
742
dbus_bool = dbus.Boolean(bval, variant_level=1)
743
self.PropertyChanged(dbus.String(u"ApprovalPending"),
744
dbus_bool)
745
746
approvals_pending = property(_get_approvals_pending,
747
_set_approvals_pending)
748
del _get_approvals_pending, _set_approvals_pending
749
750
@staticmethod
751
def _datetime_to_dbus(dt, variant_level=0):
752
"""Convert a UTC datetime.datetime() to a D-Bus type."""
753
return dbus.String(dt.isoformat(),
754
variant_level=variant_level)
755
756
def enable(self):
757
oldstate = getattr(self, u"enabled", False)
758
r = Client.enable(self)
759
if oldstate != self.enabled:
760
# Emit D-Bus signals
761
self.PropertyChanged(dbus.String(u"Enabled"),
762
dbus.Boolean(True, variant_level=1))
763
self.PropertyChanged(
764
dbus.String(u"LastEnabled"),
765
self._datetime_to_dbus(self.last_enabled,
766
variant_level=1))
767
return r
768
769
def disable(self, quiet = False):
770
oldstate = getattr(self, u"enabled", False)
771
r = Client.disable(self, quiet=quiet)
772
if not quiet and oldstate != self.enabled:
773
# Emit D-Bus signal
774
self.PropertyChanged(dbus.String(u"Enabled"),
775
dbus.Boolean(False, variant_level=1))
776
return r
844
777
845
778
def __del__(self, *args, **kwargs):
846
779
try:
847
780
self.remove_from_connection()
848
781
except LookupError:
849
782
pass
850
if hasattr(DBusObjectWithProperties, "__del__"):
783
if hasattr(DBusObjectWithProperties, u"__del__"):
851
784
DBusObjectWithProperties.__del__(self, *args, **kwargs)
852
785
Client.__del__(self, *args, **kwargs)
853
786
855
788
*args, **kwargs):
856
789
self.checker_callback_tag = None
857
790
self.checker = None
791
# Emit D-Bus signal
792
self.PropertyChanged(dbus.String(u"CheckerRunning"),
793
dbus.Boolean(False, variant_level=1))
858
794
if os.WIFEXITED(condition):
859
795
exitstatus = os.WEXITSTATUS(condition)
860
796
# Emit D-Bus signal
870
806
return Client.checker_callback(self, pid, condition, command,
871
807
*args, **kwargs)
872
808
809
def checked_ok(self, *args, **kwargs):
810
r = Client.checked_ok(self, *args, **kwargs)
811
# Emit D-Bus signal
812
self.PropertyChanged(
813
dbus.String(u"LastCheckedOK"),
814
(self._datetime_to_dbus(self.last_checked_ok,
815
variant_level=1)))
816
return r
817
873
818
def start_checker(self, *args, **kwargs):
874
819
old_checker = self.checker
875
820
if self.checker is not None:
882
827
and old_checker_pid != self.checker.pid):
883
828
# Emit D-Bus signal
884
829
self.CheckerStarted(self.current_checker_command)
830
self.PropertyChanged(
831
dbus.String(u"CheckerRunning"),
832
dbus.Boolean(True, variant_level=1))
885
833
return r
886
834
835
def stop_checker(self, *args, **kwargs):
836
old_checker = getattr(self, u"checker", None)
837
r = Client.stop_checker(self, *args, **kwargs)
838
if (old_checker is not None
839
and getattr(self, u"checker", None) is None):
840
self.PropertyChanged(dbus.String(u"CheckerRunning"),
841
dbus.Boolean(False, variant_level=1))
842
return r
843
887
844
def _reset_approved(self):
888
845
self._approved = None
889
846
return False
891
848
def approve(self, value=True):
892
849
self.send_changedstate()
893
850
self._approved = value
894
gobject.timeout_add(_timedelta_to_milliseconds
851
gobject.timeout_add(self._timedelta_to_milliseconds
895
852
(self.approval_duration),
896
853
self._reset_approved)
897
854
898
855
899
856
## D-Bus methods, signals & properties
900
_interface = "se.bsnet.fukt.Mandos.Client"
857
_interface = u"se.bsnet.fukt.Mandos.Client"
901
858
902
859
## Signals
903
860
904
861
# CheckerCompleted - signal
905
@dbus.service.signal(_interface, signature="nxs")
862
@dbus.service.signal(_interface, signature=u"nxs")
906
863
def CheckerCompleted(self, exitcode, waitstatus, command):
907
864
"D-Bus signal"
908
865
pass
909
866
910
867
# CheckerStarted - signal
911
@dbus.service.signal(_interface, signature="s")
868
@dbus.service.signal(_interface, signature=u"s")
912
869
def CheckerStarted(self, command):
913
870
"D-Bus signal"
914
871
pass
915
872
916
873
# PropertyChanged - signal
917
@dbus.service.signal(_interface, signature="sv")
874
@dbus.service.signal(_interface, signature=u"sv")
918
875
def PropertyChanged(self, property, value):
919
876
"D-Bus signal"
920
877
pass
929
886
pass
930
887
931
888
# Rejected - signal
932
@dbus.service.signal(_interface, signature="s")
889
@dbus.service.signal(_interface, signature=u"s")
933
890
def Rejected(self, reason):
934
891
"D-Bus signal"
935
892
pass
936
893
937
894
# NeedApproval - signal
938
@dbus.service.signal(_interface, signature="tb")
895
@dbus.service.signal(_interface, signature=u"tb")
939
896
def NeedApproval(self, timeout, default):
940
897
"D-Bus signal"
941
return self.need_approval()
898
pass
942
899
943
900
## Methods
944
901
945
902
# Approve - method
946
@dbus.service.method(_interface, in_signature="b")
903
@dbus.service.method(_interface, in_signature=u"b")
947
904
def Approve(self, value):
948
905
self.approve(value)
949
906
950
907
# CheckedOK - method
951
908
@dbus.service.method(_interface)
952
909
def CheckedOK(self):
953
self.checked_ok()
910
return self.checked_ok()
954
911
955
912
# Enable - method
956
913
@dbus.service.method(_interface)
978
935
## Properties
979
936
980
937
# ApprovalPending - property
981
@dbus_service_property(_interface, signature="b", access="read")
938
@dbus_service_property(_interface, signature=u"b", access=u"read")
982
939
def ApprovalPending_dbus_property(self):
983
940
return dbus.Boolean(bool(self.approvals_pending))
984
941
985
942
# ApprovedByDefault - property
986
@dbus_service_property(_interface, signature="b",
987
access="readwrite")
943
@dbus_service_property(_interface, signature=u"b",
944
access=u"readwrite")
988
945
def ApprovedByDefault_dbus_property(self, value=None):
989
946
if value is None: # get
990
947
return dbus.Boolean(self.approved_by_default)
991
948
self.approved_by_default = bool(value)
949
# Emit D-Bus signal
950
self.PropertyChanged(dbus.String(u"ApprovedByDefault"),
951
dbus.Boolean(value, variant_level=1))
992
952
993
953
# ApprovalDelay - property
994
@dbus_service_property(_interface, signature="t",
995
access="readwrite")
954
@dbus_service_property(_interface, signature=u"t",
955
access=u"readwrite")
996
956
def ApprovalDelay_dbus_property(self, value=None):
997
957
if value is None: # get
998
958
return dbus.UInt64(self.approval_delay_milliseconds())
999
959
self.approval_delay = datetime.timedelta(0, 0, 0, value)
960
# Emit D-Bus signal
961
self.PropertyChanged(dbus.String(u"ApprovalDelay"),
962
dbus.UInt64(value, variant_level=1))
1000
963
1001
964
# ApprovalDuration - property
1002
@dbus_service_property(_interface, signature="t",
1003
access="readwrite")
965
@dbus_service_property(_interface, signature=u"t",
966
access=u"readwrite")
1004
967
def ApprovalDuration_dbus_property(self, value=None):
1005
968
if value is None: # get
1006
return dbus.UInt64(_timedelta_to_milliseconds(
969
return dbus.UInt64(self._timedelta_to_milliseconds(
1007
970
self.approval_duration))
1008
971
self.approval_duration = datetime.timedelta(0, 0, 0, value)
972
# Emit D-Bus signal
973
self.PropertyChanged(dbus.String(u"ApprovalDuration"),
974
dbus.UInt64(value, variant_level=1))
1009
975
1010
976
# Name - property
1011
@dbus_service_property(_interface, signature="s", access="read")
977
@dbus_service_property(_interface, signature=u"s", access=u"read")
1012
978
def Name_dbus_property(self):
1013
979
return dbus.String(self.name)
1014
980
1015
981
# Fingerprint - property
1016
@dbus_service_property(_interface, signature="s", access="read")
982
@dbus_service_property(_interface, signature=u"s", access=u"read")
1017
983
def Fingerprint_dbus_property(self):
1018
984
return dbus.String(self.fingerprint)
1019
985
1020
986
# Host - property
1021
@dbus_service_property(_interface, signature="s",
1022
access="readwrite")
987
@dbus_service_property(_interface, signature=u"s",
988
access=u"readwrite")
1023
989
def Host_dbus_property(self, value=None):
1024
990
if value is None: # get
1025
991
return dbus.String(self.host)
1026
992
self.host = value
993
# Emit D-Bus signal
994
self.PropertyChanged(dbus.String(u"Host"),
995
dbus.String(value, variant_level=1))
1027
996
1028
997
# Created - property
1029
@dbus_service_property(_interface, signature="s", access="read")
998
@dbus_service_property(_interface, signature=u"s", access=u"read")
1030
999
def Created_dbus_property(self):
1031
return dbus.String(datetime_to_dbus(self.created))
1000
return dbus.String(self._datetime_to_dbus(self.created))
1032
1001
1033
1002
# LastEnabled - property
1034
@dbus_service_property(_interface, signature="s", access="read")
1003
@dbus_service_property(_interface, signature=u"s", access=u"read")
1035
1004
def LastEnabled_dbus_property(self):
1036
return datetime_to_dbus(self.last_enabled)
1005
if self.last_enabled is None:
1006
return dbus.String(u"")
1007
return dbus.String(self._datetime_to_dbus(self.last_enabled))
1037
1008
1038
1009
# Enabled - property
1039
@dbus_service_property(_interface, signature="b",
1040
access="readwrite")
1010
@dbus_service_property(_interface, signature=u"b",
1011
access=u"readwrite")
1041
1012
def Enabled_dbus_property(self, value=None):
1042
1013
if value is None: # get
1043
1014
return dbus.Boolean(self.enabled)
1047
1018
self.disable()
1048
1019
1049
1020
# LastCheckedOK - property
1050
@dbus_service_property(_interface, signature="s",
1051
access="readwrite")
1021
@dbus_service_property(_interface, signature=u"s",
1022
access=u"readwrite")
1052
1023
def LastCheckedOK_dbus_property(self, value=None):
1053
1024
if value is not None:
1054
1025
self.checked_ok()
1055
1026
return
1056
return datetime_to_dbus(self.last_checked_ok)
1057
1058
# Expires - property
1059
@dbus_service_property(_interface, signature="s", access="read")
1060
def Expires_dbus_property(self):
1061
return datetime_to_dbus(self.expires)
1062
1063
# LastApprovalRequest - property
1064
@dbus_service_property(_interface, signature="s", access="read")
1065
def LastApprovalRequest_dbus_property(self):
1066
return datetime_to_dbus(self.last_approval_request)
1027
if self.last_checked_ok is None:
1028
return dbus.String(u"")
1029
return dbus.String(self._datetime_to_dbus(self
1030
.last_checked_ok))
1067
1031
1068
1032
# Timeout - property
1069
@dbus_service_property(_interface, signature="t",
1070
access="readwrite")
1033
@dbus_service_property(_interface, signature=u"t",
1034
access=u"readwrite")
1071
1035
def Timeout_dbus_property(self, value=None):
1072
1036
if value is None: # get
1073
1037
return dbus.UInt64(self.timeout_milliseconds())
1074
1038
self.timeout = datetime.timedelta(0, 0, 0, value)
1075
if getattr(self, "disable_initiator_tag", None) is None:
1039
# Emit D-Bus signal
1040
self.PropertyChanged(dbus.String(u"Timeout"),
1041
dbus.UInt64(value, variant_level=1))
1042
if getattr(self, u"disable_initiator_tag", None) is None:
1076
1043
return
1077
1044
# Reschedule timeout
1078
1045
gobject.source_remove(self.disable_initiator_tag)
1079
1046
self.disable_initiator_tag = None
1080
self.expires = None
1081
1047
time_to_die = (self.
1082
1048
_timedelta_to_milliseconds((self
1083
1049
.last_checked_ok
1088
1054
# The timeout has passed
1089
1055
self.disable()
1090
1056
else:
1091
self.expires = (datetime.datetime.utcnow()
1092
+ datetime.timedelta(milliseconds = time_to_die))
1093
1057
self.disable_initiator_tag = (gobject.timeout_add
1094
1058
(time_to_die, self.disable))
1095
1059
1096
# ExtendedTimeout - property
1097
@dbus_service_property(_interface, signature="t",
1098
access="readwrite")
1099
def ExtendedTimeout_dbus_property(self, value=None):
1100
if value is None: # get
1101
return dbus.UInt64(self.extended_timeout_milliseconds())
1102
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1103
1104
1060
# Interval - property
1105
@dbus_service_property(_interface, signature="t",
1106
access="readwrite")
1061
@dbus_service_property(_interface, signature=u"t",
1062
access=u"readwrite")
1107
1063
def Interval_dbus_property(self, value=None):
1108
1064
if value is None: # get
1109
1065
return dbus.UInt64(self.interval_milliseconds())
1110
1066
self.interval = datetime.timedelta(0, 0, 0, value)
1111
if getattr(self, "checker_initiator_tag", None) is None:
1067
# Emit D-Bus signal
1068
self.PropertyChanged(dbus.String(u"Interval"),
1069
dbus.UInt64(value, variant_level=1))
1070
if getattr(self, u"checker_initiator_tag", None) is None:
1112
1071
return
1113
1072
# Reschedule checker run
1114
1073
gobject.source_remove(self.checker_initiator_tag)
1115
1074
self.checker_initiator_tag = (gobject.timeout_add
1116
1075
(value, self.start_checker))
1117
1076
self.start_checker() # Start one now, too
1118
1077
1119
1078
# Checker - property
1120
@dbus_service_property(_interface, signature="s",
1121
access="readwrite")
1079
@dbus_service_property(_interface, signature=u"s",
1080
access=u"readwrite")
1122
1081
def Checker_dbus_property(self, value=None):
1123
1082
if value is None: # get
1124
1083
return dbus.String(self.checker_command)
1125
1084
self.checker_command = value
1085
# Emit D-Bus signal
1086
self.PropertyChanged(dbus.String(u"Checker"),
1087
dbus.String(self.checker_command,
1088
variant_level=1))
1126
1089
1127
1090
# CheckerRunning - property
1128
@dbus_service_property(_interface, signature="b",
1129
access="readwrite")
1091
@dbus_service_property(_interface, signature=u"b",
1092
access=u"readwrite")
1130
1093
def CheckerRunning_dbus_property(self, value=None):
1131
1094
if value is None: # get
1132
1095
return dbus.Boolean(self.checker is not None)
1136
1099
self.stop_checker()
1137
1100
1138
1101
# ObjectPath - property
1139
@dbus_service_property(_interface, signature="o", access="read")
1102
@dbus_service_property(_interface, signature=u"o", access=u"read")
1140
1103
def ObjectPath_dbus_property(self):
1141
1104
return self.dbus_object_path # is already a dbus.ObjectPath
1142
1105
1143
1106
# Secret = property
1144
@dbus_service_property(_interface, signature="ay",
1145
access="write", byte_arrays=True)
1107
@dbus_service_property(_interface, signature=u"ay",
1108
access=u"write", byte_arrays=True)
1146
1109
def Secret_dbus_property(self, value):
1147
1110
self.secret = str(value)
1148
1111
1155
1118
self._pipe.send(('init', fpr, address))
1156
1119
if not self._pipe.recv():
1157
1120
raise KeyError()
1158
1121
1159
1122
def __getattribute__(self, name):
1160
1123
if(name == '_pipe'):
1161
1124
return super(ProxyClient, self).__getattribute__(name)
1168
1131
self._pipe.send(('funcall', name, args, kwargs))
1169
1132
return self._pipe.recv()[1]
1170
1133
return func
1171
1134
1172
1135
def __setattr__(self, name, value):
1173
1136
if(name == '_pipe'):
1174
1137
return super(ProxyClient, self).__setattr__(name, value)
1183
1146
1184
1147
def handle(self):
1185
1148
with contextlib.closing(self.server.child_pipe) as child_pipe:
1186
logger.info("TCP connection from: %s",
1149
logger.info(u"TCP connection from: %s",
1187
1150
unicode(self.client_address))
1188
logger.debug("Pipe FD: %d",
1151
logger.debug(u"Pipe FD: %d",
1189
1152
self.server.child_pipe.fileno())
1190
1153
1191
1154
session = (gnutls.connection
1192
1155
.ClientSession(self.request,
1193
1156
gnutls.connection
1194
1157
.X509Credentials()))
1195
1158
1196
1159
# Note: gnutls.connection.X509Credentials is really a
1197
1160
# generic GnuTLS certificate credentials object so long as
1198
1161
# no X.509 keys are added to it. Therefore, we can use it
1199
1162
# here despite using OpenPGP certificates.
1200
1201
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1202
# "+AES-256-CBC", "+SHA1",
1203
# "+COMP-NULL", "+CTYPE-OPENPGP",
1204
# "+DHE-DSS"))
1163
1164
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
1165
# u"+AES-256-CBC", u"+SHA1",
1166
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
1167
# u"+DHE-DSS"))
1205
1168
# Use a fallback default, since this MUST be set.
1206
1169
priority = self.server.gnutls_priority
1207
1170
if priority is None:
1208
priority = "NORMAL"
1171
priority = u"NORMAL"
1209
1172
(gnutls.library.functions
1210
1173
.gnutls_priority_set_direct(session._c_object,
1211
1174
priority, None))
1212
1175
1213
1176
# Start communication using the Mandos protocol
1214
1177
# Get protocol number
1215
1178
line = self.request.makefile().readline()
1216
logger.debug("Protocol version: %r", line)
1179
logger.debug(u"Protocol version: %r", line)
1217
1180
try:
1218
1181
if int(line.strip().split()[0]) > 1:
1219
1182
raise RuntimeError
1220
except (ValueError, IndexError, RuntimeError) as error:
1221
logger.error("Unknown protocol version: %s", error)
1183
except (ValueError, IndexError, RuntimeError), error:
1184
logger.error(u"Unknown protocol version: %s", error)
1222
1185
return
1223
1186
1224
1187
# Start GnuTLS connection
1225
1188
try:
1226
1189
session.handshake()
1227
except gnutls.errors.GNUTLSError as error:
1228
logger.warning("Handshake failed: %s", error)
1190
except gnutls.errors.GNUTLSError, error:
1191
logger.warning(u"Handshake failed: %s", error)
1229
1192
# Do not run session.bye() here: the session is not
1230
1193
# established. Just abandon the request.
1231
1194
return
1232
logger.debug("Handshake succeeded")
1233
1195
logger.debug(u"Handshake succeeded")
1196
1234
1197
approval_required = False
1235
1198
try:
1236
1199
try:
1237
1200
fpr = self.fingerprint(self.peer_certificate
1238
1201
(session))
1239
except (TypeError,
1240
gnutls.errors.GNUTLSError) as error:
1241
logger.warning("Bad certificate: %s", error)
1202
except (TypeError, gnutls.errors.GNUTLSError), error:
1203
logger.warning(u"Bad certificate: %s", error)
1242
1204
return
1243
logger.debug("Fingerprint: %s", fpr)
1244
1205
logger.debug(u"Fingerprint: %s", fpr)
1206
1245
1207
try:
1246
1208
client = ProxyClient(child_pipe, fpr,
1247
1209
self.client_address)
1255
1217
1256
1218
while True:
1257
1219
if not client.enabled:
1258
logger.info("Client %s is disabled",
1220
logger.warning(u"Client %s is disabled",
1259
1221
client.name)
1260
1222
if self.server.use_dbus:
1261
1223
# Emit D-Bus signal
1266
1228
#We are approved or approval is disabled
1267
1229
break
1268
1230
elif client._approved is None:
1269
logger.info("Client %s needs approval",
1231
logger.info(u"Client %s needs approval",
1270
1232
client.name)
1271
1233
if self.server.use_dbus:
1272
1234
# Emit D-Bus signal
1274
1236
client.approval_delay_milliseconds(),
1275
1237
client.approved_by_default)
1276
1238
else:
1277
logger.warning("Client %s was not approved",
1239
logger.warning(u"Client %s was not approved",
1278
1240
client.name)
1279
1241
if self.server.use_dbus:
1280
1242
# Emit D-Bus signal
1306
1268
while sent_size < len(client.secret):
1307
1269
try:
1308
1270
sent = session.send(client.secret[sent_size:])
1309
except gnutls.errors.GNUTLSError as error:
1271
except (gnutls.errors.GNUTLSError), error:
1310
1272
logger.warning("gnutls send failed")
1311
1273
return
1312
logger.debug("Sent: %d, remaining: %d",
1274
logger.debug(u"Sent: %d, remaining: %d",
1313
1275
sent, len(client.secret)
1314
1276
- (sent_size + sent))
1315
1277
sent_size += sent
1316
1317
logger.info("Sending secret to %s", client.name)
1278
1279
logger.info(u"Sending secret to %s", client.name)
1318
1280
# bump the timeout as if seen
1319
client.checked_ok(client.extended_timeout)
1281
client.checked_ok()
1320
1282
if self.server.use_dbus:
1321
1283
# Emit D-Bus signal
1322
1284
client.GotSecret()
1326
1288
client.approvals_pending -= 1
1327
1289
try:
1328
1290
session.bye()
1329
except gnutls.errors.GNUTLSError as error:
1291
except (gnutls.errors.GNUTLSError), error:
1330
1292
logger.warning("GnuTLS bye failed")
1331
1293
1332
1294
@staticmethod
1343
1305
.gnutls_certificate_get_peers
1344
1306
(session._c_object, ctypes.byref(list_size)))
1345
1307
if not bool(cert_list) and list_size.value != 0:
1346
raise gnutls.errors.GNUTLSError("error getting peer"
1347
" certificate")
1308
raise gnutls.errors.GNUTLSError(u"error getting peer"
1309
u" certificate")
1348
1310
if list_size.value == 0:
1349
1311
return None
1350
1312
cert = cert_list[0]
1376
1338
if crtverify.value != 0:
1377
1339
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1378
1340
raise (gnutls.errors.CertificateSecurityError
1379
("Verify failed"))
1341
(u"Verify failed"))
1380
1342
# New buffer for the fingerprint
1381
1343
buf = ctypes.create_string_buffer(20)
1382
1344
buf_len = ctypes.c_size_t()
1389
1351
# Convert the buffer to a Python bytestring
1390
1352
fpr = ctypes.string_at(buf, buf_len.value)
1391
1353
# Convert the bytestring to hexadecimal notation
1392
hex_fpr = ''.join("%02X" % ord(char) for char in fpr)
1354
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
1393
1355
return hex_fpr
1394
1356
1395
1357
1407
1369
multiprocessing.Process(target = self.sub_process_main,
1408
1370
args = (request, address)).start()
1409
1371
1410
1411
1372
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1412
1373
""" adds a pipe to the MixIn """
1413
1374
def process_request(self, request, client_address):
1416
1377
This function creates a new pipe in self.pipe
1417
1378
"""
1418
1379
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1419
1380
1420
1381
super(MultiprocessingMixInWithPipe,
1421
1382
self).process_request(request, client_address)
1422
1383
self.child_pipe.close()
1423
1384
self.add_pipe(parent_pipe)
1424
1385
1425
1386
def add_pipe(self, parent_pipe):
1426
1387
"""Dummy function; override as necessary"""
1427
raise NotImplementedError
1428
1388
pass
1429
1389
1430
1390
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1431
1391
socketserver.TCPServer, object):
1449
1409
bind to an address or port if they were not specified."""
1450
1410
if self.interface is not None:
1451
1411
if SO_BINDTODEVICE is None:
1452
logger.error("SO_BINDTODEVICE does not exist;"
1453
" cannot bind to interface %s",
1412
logger.error(u"SO_BINDTODEVICE does not exist;"
1413
u" cannot bind to interface %s",
1454
1414
self.interface)
1455
1415
else:
1456
1416
try:
1457
1417
self.socket.setsockopt(socket.SOL_SOCKET,
1458
1418
SO_BINDTODEVICE,
1459
1419
str(self.interface
1460
+ '\0'))
1461
except socket.error as error:
1420
+ u'\0'))
1421
except socket.error, error:
1462
1422
if error[0] == errno.EPERM:
1463
logger.error("No permission to"
1464
" bind to interface %s",
1423
logger.error(u"No permission to"
1424
u" bind to interface %s",
1465
1425
self.interface)
1466
1426
elif error[0] == errno.ENOPROTOOPT:
1467
logger.error("SO_BINDTODEVICE not available;"
1468
" cannot bind to interface %s",
1427
logger.error(u"SO_BINDTODEVICE not available;"
1428
u" cannot bind to interface %s",
1469
1429
self.interface)
1470
1430
else:
1471
1431
raise
1473
1433
if self.server_address[0] or self.server_address[1]:
1474
1434
if not self.server_address[0]:
1475
1435
if self.address_family == socket.AF_INET6:
1476
any_address = "::" # in6addr_any
1436
any_address = u"::" # in6addr_any
1477
1437
else:
1478
1438
any_address = socket.INADDR_ANY
1479
1439
self.server_address = (any_address,
1528
1488
def handle_ipc(self, source, condition, parent_pipe=None,
1529
1489
client_object=None):
1530
1490
condition_names = {
1531
gobject.IO_IN: "IN", # There is data to read.
1532
gobject.IO_OUT: "OUT", # Data can be written (without
1491
gobject.IO_IN: u"IN", # There is data to read.
1492
gobject.IO_OUT: u"OUT", # Data can be written (without
1533
1493
# blocking).
1534
gobject.IO_PRI: "PRI", # There is urgent data to read.
1535
gobject.IO_ERR: "ERR", # Error condition.
1536
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1494
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1495
gobject.IO_ERR: u"ERR", # Error condition.
1496
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1537
1497
# broken, usually for pipes and
1538
1498
# sockets).
1539
1499
}
1558
1518
client = c
1559
1519
break
1560
1520
else:
1561
logger.info("Client not found for fingerprint: %s, ad"
1562
"dress: %s", fpr, address)
1521
logger.warning(u"Client not found for fingerprint: %s, ad"
1522
u"dress: %s", fpr, address)
1563
1523
if self.use_dbus:
1564
1524
# Emit D-Bus signal
1565
1525
mandos_dbus_service.ClientNotFound(fpr, address[0])
1580
1540
kwargs = request[3]
1581
1541
1582
1542
parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))
1583
1543
1584
1544
if command == 'getattr':
1585
1545
attrname = request[1]
1586
1546
if callable(client_object.__getattribute__(attrname)):
1592
1552
attrname = request[1]
1593
1553
value = request[2]
1594
1554
setattr(client_object, attrname, value)
1595
1555
1596
1556
return True
1597
1557
1598
1558
1599
1559
def string_to_delta(interval):
1600
1560
"""Parse a string and return a datetime.timedelta
1601
1561
1602
>>> string_to_delta('7d')
1562
>>> string_to_delta(u'7d')
1603
1563
datetime.timedelta(7)
1604
>>> string_to_delta('60s')
1564
>>> string_to_delta(u'60s')
1605
1565
datetime.timedelta(0, 60)
1606
>>> string_to_delta('60m')
1566
>>> string_to_delta(u'60m')
1607
1567
datetime.timedelta(0, 3600)
1608
>>> string_to_delta('24h')
1568
>>> string_to_delta(u'24h')
1609
1569
datetime.timedelta(1)
1610
>>> string_to_delta('1w')
1570
>>> string_to_delta(u'1w')
1611
1571
datetime.timedelta(7)
1612
>>> string_to_delta('5m 30s')
1572
>>> string_to_delta(u'5m 30s')
1613
1573
datetime.timedelta(0, 330)
1614
1574
"""
1615
1575
timevalue = datetime.timedelta(0)
1617
1577
try:
1618
1578
suffix = unicode(s[-1])
1619
1579
value = int(s[:-1])
1620
if suffix == "d":
1580
if suffix == u"d":
1621
1581
delta = datetime.timedelta(value)
1622
elif suffix == "s":
1582
elif suffix == u"s":
1623
1583
delta = datetime.timedelta(0, value)
1624
elif suffix == "m":
1584
elif suffix == u"m":
1625
1585
delta = datetime.timedelta(0, 0, 0, 0, value)
1626
elif suffix == "h":
1586
elif suffix == u"h":
1627
1587
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1628
elif suffix == "w":
1588
elif suffix == u"w":
1629
1589
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1630
1590
else:
1631
raise ValueError("Unknown suffix %r" % suffix)
1632
except (ValueError, IndexError) as e:
1633
raise ValueError(*(e.args))
1591
raise ValueError(u"Unknown suffix %r" % suffix)
1592
except (ValueError, IndexError), e:
1593
raise ValueError(e.message)
1634
1594
timevalue += delta
1635
1595
return timevalue
1636
1596
1642
1602
global if_nametoindex
1643
1603
try:
1644
1604
if_nametoindex = (ctypes.cdll.LoadLibrary
1645
(ctypes.util.find_library("c"))
1605
(ctypes.util.find_library(u"c"))
1646
1606
.if_nametoindex)
1647
1607
except (OSError, AttributeError):
1648
logger.warning("Doing if_nametoindex the hard way")
1608
logger.warning(u"Doing if_nametoindex the hard way")
1649
1609
def if_nametoindex(interface):
1650
1610
"Get an interface index the hard way, i.e. using fcntl()"
1651
1611
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1652
1612
with contextlib.closing(socket.socket()) as s:
1653
1613
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1654
struct.pack(str("16s16x"),
1614
struct.pack(str(u"16s16x"),
1655
1615
interface))
1656
interface_index = struct.unpack(str("I"),
1616
interface_index = struct.unpack(str(u"I"),
1657
1617
ifreq[16:20])[0]
1658
1618
return interface_index
1659
1619
return if_nametoindex(interface)
1667
1627
sys.exit()
1668
1628
os.setsid()
1669
1629
if not nochdir:
1670
os.chdir("/")
1630
os.chdir(u"/")
1671
1631
if os.fork():
1672
1632
sys.exit()
1673
1633
if not noclose:
1675
1635
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1676
1636
if not stat.S_ISCHR(os.fstat(null).st_mode):
1677
1637
raise OSError(errno.ENODEV,
1678
"%s not a character device"
1638
u"%s not a character device"
1679
1639
% os.path.devnull)
1680
1640
os.dup2(null, sys.stdin.fileno())
1681
1641
os.dup2(null, sys.stdout.fileno())
1689
1649
##################################################################
1690
1650
# Parsing of options, both command line and config file
1691
1651
1692
parser = argparse.ArgumentParser()
1693
parser.add_argument("-v", "--version", action="version",
1694
version = "%%(prog)s %s" % version,
1695
help="show version number and exit")
1696
parser.add_argument("-i", "--interface", metavar="IF",
1697
help="Bind to interface IF")
1698
parser.add_argument("-a", "--address",
1699
help="Address to listen for requests on")
1700
parser.add_argument("-p", "--port", type=int,
1701
help="Port number to receive requests on")
1702
parser.add_argument("--check", action="store_true",
1703
help="Run self-test")
1704
parser.add_argument("--debug", action="store_true",
1705
help="Debug mode; run in foreground and log"
1706
" to terminal")
1707
parser.add_argument("--debuglevel", metavar="LEVEL",
1708
help="Debug level for stdout output")
1709
parser.add_argument("--priority", help="GnuTLS"
1710
" priority string (see GnuTLS documentation)")
1711
parser.add_argument("--servicename",
1712
metavar="NAME", help="Zeroconf service name")
1713
parser.add_argument("--configdir",
1714
default="/etc/mandos", metavar="DIR",
1715
help="Directory to search for configuration"
1716
" files")
1717
parser.add_argument("--no-dbus", action="store_false",
1718
dest="use_dbus", help="Do not provide D-Bus"
1719
" system bus interface")
1720
parser.add_argument("--no-ipv6", action="store_false",
1721
dest="use_ipv6", help="Do not use IPv6")
1722
options = parser.parse_args()
1652
parser = optparse.OptionParser(version = "%%prog %s" % version)
1653
parser.add_option("-i", u"--interface", type=u"string",
1654
metavar="IF", help=u"Bind to interface IF")
1655
parser.add_option("-a", u"--address", type=u"string",
1656
help=u"Address to listen for requests on")
1657
parser.add_option("-p", u"--port", type=u"int",
1658
help=u"Port number to receive requests on")
1659
parser.add_option("--check", action=u"store_true",
1660
help=u"Run self-test")
1661
parser.add_option("--debug", action=u"store_true",
1662
help=u"Debug mode; run in foreground and log to"
1663
u" terminal")
1664
parser.add_option("--debuglevel", type=u"string", metavar="Level",
1665
help=u"Debug level for stdout output")
1666
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1667
u" priority string (see GnuTLS documentation)")
1668
parser.add_option("--servicename", type=u"string",
1669
metavar=u"NAME", help=u"Zeroconf service name")
1670
parser.add_option("--configdir", type=u"string",
1671
default=u"/etc/mandos", metavar=u"DIR",
1672
help=u"Directory to search for configuration"
1673
u" files")
1674
parser.add_option("--no-dbus", action=u"store_false",
1675
dest=u"use_dbus", help=u"Do not provide D-Bus"
1676
u" system bus interface")
1677
parser.add_option("--no-ipv6", action=u"store_false",
1678
dest=u"use_ipv6", help=u"Do not use IPv6")
1679
options = parser.parse_args()[0]
1723
1680
1724
1681
if options.check:
1725
1682
import doctest
1727
1684
sys.exit()
1728
1685
1729
1686
# Default values for config file for server-global settings
1730
server_defaults = { "interface": "",
1731
"address": "",
1732
"port": "",
1733
"debug": "False",
1734
"priority":
1735
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1736
"servicename": "Mandos",
1737
"use_dbus": "True",
1738
"use_ipv6": "True",
1739
"debuglevel": "",
1687
server_defaults = { u"interface": u"",
1688
u"address": u"",
1689
u"port": u"",
1690
u"debug": u"False",
1691
u"priority":
1692
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1693
u"servicename": u"Mandos",
1694
u"use_dbus": u"True",
1695
u"use_ipv6": u"True",
1696
u"debuglevel": u"",
1740
1697
}
1741
1698
1742
1699
# Parse config file for server-global settings
1743
1700
server_config = configparser.SafeConfigParser(server_defaults)
1744
1701
del server_defaults
1745
1702
server_config.read(os.path.join(options.configdir,
1746
"mandos.conf"))
1703
u"mandos.conf"))
1747
1704
# Convert the SafeConfigParser object to a dict
1748
1705
server_settings = server_config.defaults()
1749
1706
# Use the appropriate methods on the non-string config options
1750
for option in ("debug", "use_dbus", "use_ipv6"):
1751
server_settings[option] = server_config.getboolean("DEFAULT",
1707
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1708
server_settings[option] = server_config.getboolean(u"DEFAULT",
1752
1709
option)
1753
1710
if server_settings["port"]:
1754
server_settings["port"] = server_config.getint("DEFAULT",
1755
"port")
1711
server_settings["port"] = server_config.getint(u"DEFAULT",
1712
u"port")
1756
1713
del server_config
1757
1714
1758
1715
# Override the settings from the config file with command line
1759
1716
# options, if set.
1760
for option in ("interface", "address", "port", "debug",
1761
"priority", "servicename", "configdir",
1762
"use_dbus", "use_ipv6", "debuglevel"):
1717
for option in (u"interface", u"address", u"port", u"debug",
1718
u"priority", u"servicename", u"configdir",
1719
u"use_dbus", u"use_ipv6", u"debuglevel"):
1763
1720
value = getattr(options, option)
1764
1721
if value is not None:
1765
1722
server_settings[option] = value
1773
1730
##################################################################
1774
1731
1775
1732
# For convenience
1776
debug = server_settings["debug"]
1777
debuglevel = server_settings["debuglevel"]
1778
use_dbus = server_settings["use_dbus"]
1779
use_ipv6 = server_settings["use_ipv6"]
1780
1781
if server_settings["servicename"] != "Mandos":
1733
debug = server_settings[u"debug"]
1734
debuglevel = server_settings[u"debuglevel"]
1735
use_dbus = server_settings[u"use_dbus"]
1736
use_ipv6 = server_settings[u"use_ipv6"]
1737
1738
if server_settings[u"servicename"] != u"Mandos":
1782
1739
syslogger.setFormatter(logging.Formatter
1783
('Mandos (%s) [%%(process)d]:'
1784
' %%(levelname)s: %%(message)s'
1785
% server_settings["servicename"]))
1740
(u'Mandos (%s) [%%(process)d]:'
1741
u' %%(levelname)s: %%(message)s'
1742
% server_settings[u"servicename"]))
1786
1743
1787
1744
# Parse config file with clients
1788
client_defaults = { "timeout": "5m",
1789
"extended_timeout": "15m",
1790
"interval": "2m",
1791
"checker": "fping -q -- %%(host)s",
1792
"host": "",
1793
"approval_delay": "0s",
1794
"approval_duration": "1s",
1745
client_defaults = { u"timeout": u"1h",
1746
u"interval": u"5m",
1747
u"checker": u"fping -q -- %%(host)s",
1748
u"host": u"",
1749
u"approval_delay": u"0s",
1750
u"approval_duration": u"1s",
1795
1751
}
1796
1752
client_config = configparser.SafeConfigParser(client_defaults)
1797
client_config.read(os.path.join(server_settings["configdir"],
1798
"clients.conf"))
1753
client_config.read(os.path.join(server_settings[u"configdir"],
1754
u"clients.conf"))
1799
1755
1800
1756
global mandos_dbus_service
1801
1757
mandos_dbus_service = None
1802
1758
1803
tcp_server = MandosServer((server_settings["address"],
1804
server_settings["port"]),
1759
tcp_server = MandosServer((server_settings[u"address"],
1760
server_settings[u"port"]),
1805
1761
ClientHandler,
1806
interface=(server_settings["interface"]
1762
interface=(server_settings[u"interface"]
1807
1763
or None),
1808
1764
use_ipv6=use_ipv6,
1809
1765
gnutls_priority=
1810
server_settings["priority"],
1766
server_settings[u"priority"],
1811
1767
use_dbus=use_dbus)
1812
1768
if not debug:
1813
pidfilename = "/var/run/mandos.pid"
1769
pidfilename = u"/var/run/mandos.pid"
1814
1770
try:
1815
pidfile = open(pidfilename, "w")
1771
pidfile = open(pidfilename, u"w")
1816
1772
except IOError:
1817
logger.error("Could not open file %r", pidfilename)
1773
logger.error(u"Could not open file %r", pidfilename)
1818
1774
1819
1775
try:
1820
uid = pwd.getpwnam("_mandos").pw_uid
1821
gid = pwd.getpwnam("_mandos").pw_gid
1776
uid = pwd.getpwnam(u"_mandos").pw_uid
1777
gid = pwd.getpwnam(u"_mandos").pw_gid
1822
1778
except KeyError:
1823
1779
try:
1824
uid = pwd.getpwnam("mandos").pw_uid
1825
gid = pwd.getpwnam("mandos").pw_gid
1780
uid = pwd.getpwnam(u"mandos").pw_uid
1781
gid = pwd.getpwnam(u"mandos").pw_gid
1826
1782
except KeyError:
1827
1783
try:
1828
uid = pwd.getpwnam("nobody").pw_uid
1829
gid = pwd.getpwnam("nobody").pw_gid
1784
uid = pwd.getpwnam(u"nobody").pw_uid
1785
gid = pwd.getpwnam(u"nobody").pw_gid
1830
1786
except KeyError:
1831
1787
uid = 65534
1832
1788
gid = 65534
1833
1789
try:
1834
1790
os.setgid(gid)
1835
1791
os.setuid(uid)
1836
except OSError as error:
1792
except OSError, error:
1837
1793
if error[0] != errno.EPERM:
1838
1794
raise error
1839
1795
1844
1800
level = getattr(logging, debuglevel.upper())
1845
1801
syslogger.setLevel(level)
1846
1802
console.setLevel(level)
1847
1803
1848
1804
if debug:
1849
1805
# Enable all possible GnuTLS debugging
1850
1806
1854
1810
1855
1811
@gnutls.library.types.gnutls_log_func
1856
1812
def debug_gnutls(level, string):
1857
logger.debug("GnuTLS: %s", string[:-1])
1813
logger.debug(u"GnuTLS: %s", string[:-1])
1858
1814
1859
1815
(gnutls.library.functions
1860
1816
.gnutls_global_set_log_function(debug_gnutls))
1868
1824
# No console logging
1869
1825
logger.removeHandler(console)
1870
1826
1871
# Need to fork before connecting to D-Bus
1872
if not debug:
1873
# Close all input and output, do double fork, etc.
1874
daemon()
1875
1827
1876
1828
global main_loop
1877
1829
# From the Avahi example code
1881
1833
# End of Avahi example code
1882
1834
if use_dbus:
1883
1835
try:
1884
bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",
1836
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
1885
1837
bus, do_not_queue=True)
1886
except dbus.exceptions.NameExistsException as e:
1887
logger.error(unicode(e) + ", disabling D-Bus")
1838
except dbus.exceptions.NameExistsException, e:
1839
logger.error(unicode(e) + u", disabling D-Bus")
1888
1840
use_dbus = False
1889
server_settings["use_dbus"] = False
1841
server_settings[u"use_dbus"] = False
1890
1842
tcp_server.use_dbus = False
1891
1843
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1892
service = AvahiService(name = server_settings["servicename"],
1893
servicetype = "_mandos._tcp",
1844
service = AvahiService(name = server_settings[u"servicename"],
1845
servicetype = u"_mandos._tcp",
1894
1846
protocol = protocol, bus = bus)
1895
1847
if server_settings["interface"]:
1896
1848
service.interface = (if_nametoindex
1897
(str(server_settings["interface"])))
1898
1849
(str(server_settings[u"interface"])))
1850
1851
if not debug:
1852
# Close all input and output, do double fork, etc.
1853
daemon()
1854
1899
1855
global multiprocessing_manager
1900
1856
multiprocessing_manager = multiprocessing.Manager()
1901
1857
1920
1876
client_config, section)))
1921
1877
for section in client_config.sections()))
1922
1878
if not tcp_server.clients:
1923
logger.warning("No clients defined")
1879
logger.warning(u"No clients defined")
1924
1880
1925
1881
if not debug:
1926
1882
try:
1927
1883
with pidfile:
1928
1884
pid = os.getpid()
1929
pidfile.write(str(pid) + "\n".encode("utf-8"))
1885
pidfile.write(str(pid) + "\n")
1930
1886
del pidfile
1931
1887
except IOError:
1932
logger.error("Could not write to file %r with PID %d",
1888
logger.error(u"Could not write to file %r with PID %d",
1933
1889
pidfilename, pid)
1934
1890
except NameError:
1935
1891
# "pidfile" was never created
1937
1893
del pidfilename
1938
1894
1939
1895
signal.signal(signal.SIGINT, signal.SIG_IGN)
1940
1896
1941
1897
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1942
1898
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1943
1899
1945
1901
class MandosDBusService(dbus.service.Object):
1946
1902
"""A D-Bus proxy object"""
1947
1903
def __init__(self):
1948
dbus.service.Object.__init__(self, bus, "/")
1949
_interface = "se.bsnet.fukt.Mandos"
1904
dbus.service.Object.__init__(self, bus, u"/")
1905
_interface = u"se.bsnet.fukt.Mandos"
1950
1906
1951
@dbus.service.signal(_interface, signature="o")
1907
@dbus.service.signal(_interface, signature=u"o")
1952
1908
def ClientAdded(self, objpath):
1953
1909
"D-Bus signal"
1954
1910
pass
1955
1911
1956
@dbus.service.signal(_interface, signature="ss")
1912
@dbus.service.signal(_interface, signature=u"ss")
1957
1913
def ClientNotFound(self, fingerprint, address):
1958
1914
"D-Bus signal"
1959
1915
pass
1960
1916
1961
@dbus.service.signal(_interface, signature="os")
1917
@dbus.service.signal(_interface, signature=u"os")
1962
1918
def ClientRemoved(self, objpath, name):
1963
1919
"D-Bus signal"
1964
1920
pass
1965
1921
1966
@dbus.service.method(_interface, out_signature="ao")
1922
@dbus.service.method(_interface, out_signature=u"ao")
1967
1923
def GetAllClients(self):
1968
1924
"D-Bus method"
1969
1925
return dbus.Array(c.dbus_object_path
1970
1926
for c in tcp_server.clients)
1971
1927
1972
1928
@dbus.service.method(_interface,
1973
out_signature="a{oa{sv}}")
1929
out_signature=u"a{oa{sv}}")
1974
1930
def GetAllClientsWithProperties(self):
1975
1931
"D-Bus method"
1976
1932
return dbus.Dictionary(
1977
((c.dbus_object_path, c.GetAll(""))
1933
((c.dbus_object_path, c.GetAll(u""))
1978
1934
for c in tcp_server.clients),
1979
signature="oa{sv}")
1935
signature=u"oa{sv}")
1980
1936
1981
@dbus.service.method(_interface, in_signature="o")
1937
@dbus.service.method(_interface, in_signature=u"o")
1982
1938
def RemoveClient(self, object_path):
1983
1939
"D-Bus method"
1984
1940
for c in tcp_server.clients:
2026
1982
# Find out what port we got
2027
1983
service.port = tcp_server.socket.getsockname()[1]
2028
1984
if use_ipv6:
2029
logger.info("Now listening on address %r, port %d,"
1985
logger.info(u"Now listening on address %r, port %d,"
2030
1986
" flowinfo %d, scope_id %d"
2031
1987
% tcp_server.socket.getsockname())
2032
1988
else: # IPv4
2033
logger.info("Now listening on address %r, port %d"
1989
logger.info(u"Now listening on address %r, port %d"
2034
1990
% tcp_server.socket.getsockname())
2035
1991
2036
1992
#service.interface = tcp_server.socket.getsockname()[3]
2039
1995
# From the Avahi example code
2040
1996
try:
2041
1997
service.activate()
2042
except dbus.exceptions.DBusException as error:
2043
logger.critical("DBusException: %s", error)
1998
except dbus.exceptions.DBusException, error:
1999
logger.critical(u"DBusException: %s", error)
2044
2000
cleanup()
2045
2001
sys.exit(1)
2046
2002
# End of Avahi example code
2050
2006
(tcp_server.handle_request
2051
2007
(*args[2:], **kwargs) or True))
2052
2008
2053
logger.debug("Starting main loop")
2009
logger.debug(u"Starting main loop")
2054
2010
main_loop.run()
2055
except AvahiError as error:
2056
logger.critical("AvahiError: %s", error)
2011
except AvahiError, error:
2012
logger.critical(u"AvahiError: %s", error)
2057
2013
cleanup()
2058
2014
sys.exit(1)
2059
2015
except KeyboardInterrupt:
2060
2016
if debug:
2061
print("", file=sys.stderr)
2062
logger.debug("Server received KeyboardInterrupt")
2063
logger.debug("Server exiting")
2017
print >> sys.stderr
2018
logger.debug(u"Server received KeyboardInterrupt")
2019
logger.debug(u"Server exiting")
2064
2020
# Must run before the D-Bus bus name gets deregistered
2065
2021
cleanup()
2066
2022
2067
2068
2023
if __name__ == '__main__':
2069
2024
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0