To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 24.1.157
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.157
- Committer: Björn Påhlsson
- Date: 2010-09-07 18:48:56 UTC
- mto: (237.7.1 mandos)
- mto: This revision was merged to the branch mainline in revision 270.
- Revision ID: belorn@fukt.bsnet.se-20100907184856-waz6cvxbm7ranha2
added the actually plugin file for plymouth
- files added:
- plugins.d/plymouth
- files removed:
- DBUS-API
- 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
try:
171
self.add()
172
except dbus.exceptions.DBusException as error:
173
logger.critical("DBusException: %s", error)
174
self.cleanup()
175
os._exit(1)
168
self.add()
176
169
self.rename_count += 1
177
170
def remove(self):
178
171
"""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
172
if self.group is not None:
183
173
self.group.Reset()
184
174
def add(self):
185
175
"""Derived from the Avahi example code"""
186
self.remove()
187
176
if self.group is None:
188
177
self.group = dbus.Interface(
189
178
self.bus.get_object(avahi.DBUS_NAME,
190
179
self.server.EntryGroupNew()),
191
180
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' ...",
181
self.group.connect_to_signal('StateChanged',
182
self
183
.entry_group_state_changed)
184
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
196
185
self.name, self.type)
197
186
self.group.AddService(
198
187
self.interface,
205
194
self.group.Commit()
206
195
def entry_group_state_changed(self, state, error):
207
196
"""Derived from the Avahi example code"""
208
logger.debug("Avahi entry group state change: %i", state)
197
logger.debug(u"Avahi entry group state change: %i", state)
209
198
210
199
if state == avahi.ENTRY_GROUP_ESTABLISHED:
211
logger.debug("Zeroconf service established.")
200
logger.debug(u"Zeroconf service established.")
212
201
elif state == avahi.ENTRY_GROUP_COLLISION:
213
logger.info("Zeroconf service name collision.")
202
logger.warning(u"Zeroconf service name collision.")
214
203
self.rename()
215
204
elif state == avahi.ENTRY_GROUP_FAILURE:
216
logger.critical("Avahi: Error in group state changed %s",
205
logger.critical(u"Avahi: Error in group state changed %s",
217
206
unicode(error))
218
raise AvahiGroupError("State changed: %s"
207
raise AvahiGroupError(u"State changed: %s"
219
208
% unicode(error))
220
209
def cleanup(self):
221
210
"""Derived from the Avahi example code"""
222
211
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
212
self.group.Free()
228
213
self.group = None
229
self.remove()
230
def server_state_changed(self, state, error=None):
214
def server_state_changed(self, state):
231
215
"""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()
216
logger.debug(u"Avahi server state change: %i", state)
217
if state == avahi.SERVER_COLLISION:
218
logger.error(u"Zeroconf server name collision")
219
self.remove()
247
220
elif state == avahi.SERVER_RUNNING:
248
221
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
222
def activate(self):
255
223
"""Derived from the Avahi example code"""
256
224
if self.server is None:
257
225
self.server = dbus.Interface(
258
226
self.bus.get_object(avahi.DBUS_NAME,
259
avahi.DBUS_PATH_SERVER,
260
follow_name_owner_changes=True),
227
avahi.DBUS_PATH_SERVER),
261
228
avahi.DBUS_INTERFACE_SERVER)
262
self.server.connect_to_signal("StateChanged",
229
self.server.connect_to_signal(u"StateChanged",
263
230
self.server_state_changed)
264
231
self.server_state_changed(self.server.GetState())
265
232
268
235
"""A representation of a client host served by this server.
269
236
270
237
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
238
name: string; from the config file, used in log messages and
239
D-Bus identifiers
240
fingerprint: string (40 or 32 hexadecimal digits); used to
241
uniquely identify the client
242
secret: bytestring; sent verbatim (over TLS) to client
243
host: string; available for use by the checker command
244
created: datetime.datetime(); (UTC) object creation
245
last_enabled: datetime.datetime(); (UTC)
246
enabled: bool()
247
last_checked_ok: datetime.datetime(); (UTC) or None
248
timeout: datetime.timedelta(); How long from last_checked_ok
249
until this client is disabled
250
interval: datetime.timedelta(); How often to start a new checker
251
disable_hook: If set, called by disable() as disable_hook(self)
274
252
checker: subprocess.Popen(); a running checker process used
275
253
to see if the client lives.
276
254
'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
255
checker_initiator_tag: a gobject event source tag, or None
256
disable_initiator_tag: - '' -
257
checker_callback_tag: - '' -
258
checker_command: string; External command which is run to check if
259
client lives. %() expansions are done at
280
260
runtime with vars(self) as dict, so that for
281
261
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
262
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
263
approved_delay: datetime.timedelta(); Time to wait for approval
264
_approved: bool(); 'None' if not yet approved/disapproved
265
approved_duration: datetime.timedelta(); Duration of one approval
304
266
"""
305
267
306
runtime_expansions = ("approval_delay", "approval_duration",
307
"created", "enabled", "fingerprint",
308
"host", "interval", "last_checked_ok",
309
"last_enabled", "name", "timeout")
310
311
268
@staticmethod
312
269
def _timedelta_to_milliseconds(td):
313
270
"Convert a datetime.timedelta() to milliseconds"
318
275
def timeout_milliseconds(self):
319
276
"Return the 'timeout' attribute in milliseconds"
320
277
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)
325
278
326
279
def interval_milliseconds(self):
327
280
"Return the 'interval' attribute in milliseconds"
328
281
return self._timedelta_to_milliseconds(self.interval)
329
282
330
def approval_delay_milliseconds(self):
331
return self._timedelta_to_milliseconds(self.approval_delay)
283
def approved_delay_milliseconds(self):
284
return self._timedelta_to_milliseconds(self.approved_delay)
332
285
333
286
def __init__(self, name = None, disable_hook=None, config=None):
334
287
"""Note: the 'checker' key in 'config' sets the
337
290
self.name = name
338
291
if config is None:
339
292
config = {}
340
logger.debug("Creating client %r", self.name)
293
logger.debug(u"Creating client %r", self.name)
341
294
# Uppercase and remove spaces from fingerprint for later
342
295
# comparison purposes with return value from the fingerprint()
343
296
# function
344
self.fingerprint = (config["fingerprint"].upper()
345
.replace(" ", ""))
346
logger.debug(" Fingerprint: %s", self.fingerprint)
347
if "secret" in config:
348
self.secret = config["secret"].decode("base64")
349
elif "secfile" in config:
297
self.fingerprint = (config[u"fingerprint"].upper()
298
.replace(u" ", u""))
299
logger.debug(u" Fingerprint: %s", self.fingerprint)
300
if u"secret" in config:
301
self.secret = config[u"secret"].decode(u"base64")
302
elif u"secfile" in config:
350
303
with open(os.path.expanduser(os.path.expandvars
351
(config["secfile"])),
304
(config[u"secfile"])),
352
305
"rb") as secfile:
353
306
self.secret = secfile.read()
354
307
else:
355
raise TypeError("No secret or secfile for client %s"
308
raise TypeError(u"No secret or secfile for client %s"
356
309
% self.name)
357
self.host = config.get("host", "")
310
self.host = config.get(u"host", u"")
358
311
self.created = datetime.datetime.utcnow()
359
312
self.enabled = False
360
self.last_approval_request = None
361
313
self.last_enabled = None
362
314
self.last_checked_ok = None
363
self.timeout = string_to_delta(config["timeout"])
364
self.extended_timeout = string_to_delta(config["extended_timeout"])
365
self.interval = string_to_delta(config["interval"])
315
self.timeout = string_to_delta(config[u"timeout"])
316
self.interval = string_to_delta(config[u"interval"])
366
317
self.disable_hook = disable_hook
367
318
self.checker = None
368
319
self.checker_initiator_tag = None
369
320
self.disable_initiator_tag = None
370
self.expires = None
371
321
self.checker_callback_tag = None
372
self.checker_command = config["checker"]
322
self.checker_command = config[u"checker"]
373
323
self.current_checker_command = None
374
324
self.last_connect = None
375
325
self._approved = None
376
self.approved_by_default = config.get("approved_by_default",
326
self.approved_by_default = config.get(u"approved_by_default",
377
327
True)
378
328
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"])
329
self.approved_delay = string_to_delta(
330
config[u"approved_delay"])
331
self.approved_duration = string_to_delta(
332
config[u"approved_duration"])
383
333
self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
384
334
385
335
def send_changedstate(self):
389
339
390
340
def enable(self):
391
341
"""Start this client's checker and timeout hooks"""
392
if getattr(self, "enabled", False):
342
if getattr(self, u"enabled", False):
393
343
# Already enabled
394
344
return
395
345
self.send_changedstate()
400
350
(self.interval_milliseconds(),
401
351
self.start_checker))
402
352
# Schedule a disable() when 'timeout' has passed
403
self.expires = datetime.datetime.utcnow() + self.timeout
404
353
self.disable_initiator_tag = (gobject.timeout_add
405
354
(self.timeout_milliseconds(),
406
355
self.disable))
415
364
if not quiet:
416
365
self.send_changedstate()
417
366
if not quiet:
418
logger.info("Disabling client %s", self.name)
419
if getattr(self, "disable_initiator_tag", False):
367
logger.info(u"Disabling client %s", self.name)
368
if getattr(self, u"disable_initiator_tag", False):
420
369
gobject.source_remove(self.disable_initiator_tag)
421
370
self.disable_initiator_tag = None
422
self.expires = None
423
if getattr(self, "checker_initiator_tag", False):
371
if getattr(self, u"checker_initiator_tag", False):
424
372
gobject.source_remove(self.checker_initiator_tag)
425
373
self.checker_initiator_tag = None
426
374
self.stop_checker()
441
389
if os.WIFEXITED(condition):
442
390
exitstatus = os.WEXITSTATUS(condition)
443
391
if exitstatus == 0:
444
logger.info("Checker for %(name)s succeeded",
392
logger.info(u"Checker for %(name)s succeeded",
445
393
vars(self))
446
394
self.checked_ok()
447
395
else:
448
logger.info("Checker for %(name)s failed",
396
logger.info(u"Checker for %(name)s failed",
449
397
vars(self))
450
398
else:
451
logger.warning("Checker for %(name)s crashed?",
399
logger.warning(u"Checker for %(name)s crashed?",
452
400
vars(self))
453
401
454
def checked_ok(self, timeout=None):
402
def checked_ok(self):
455
403
"""Bump up the timeout for this client.
456
404
457
405
This should only be called when the client has been seen,
458
406
alive and well.
459
407
"""
460
if timeout is None:
461
timeout = self.timeout
462
408
self.last_checked_ok = datetime.datetime.utcnow()
463
409
gobject.source_remove(self.disable_initiator_tag)
464
self.expires = datetime.datetime.utcnow() + timeout
465
410
self.disable_initiator_tag = (gobject.timeout_add
466
(self._timedelta_to_milliseconds(timeout),
411
(self.timeout_milliseconds(),
467
412
self.disable))
468
413
469
def need_approval(self):
470
self.last_approval_request = datetime.datetime.utcnow()
471
472
414
def start_checker(self):
473
415
"""Start a new checker subprocess if one is not running.
474
416
486
428
# If a checker exists, make sure it is not a zombie
487
429
try:
488
430
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
489
except (AttributeError, OSError) as error:
431
except (AttributeError, OSError), error:
490
432
if (isinstance(error, OSError)
491
433
and error.errno != errno.ECHILD):
492
434
raise error
493
435
else:
494
436
if pid:
495
logger.warning("Checker was a zombie")
437
logger.warning(u"Checker was a zombie")
496
438
gobject.source_remove(self.checker_callback_tag)
497
439
self.checker_callback(pid, status,
498
440
self.current_checker_command)
503
445
command = self.checker_command % self.host
504
446
except TypeError:
505
447
# 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
448
escaped_attrs = dict((key,
449
re.escape(unicode(str(val),
450
errors=
451
u'replace')))
452
for key, val in
453
vars(self).iteritems())
514
454
try:
515
455
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)
456
except TypeError, error:
457
logger.error(u'Could not format string "%s":'
458
u' %s', self.checker_command, error)
519
459
return True # Try again later
520
460
self.current_checker_command = command
521
461
try:
522
logger.info("Starting checker %r for %s",
462
logger.info(u"Starting checker %r for %s",
523
463
command, self.name)
524
464
# We don't need to redirect stdout and stderr, since
525
465
# in normal mode, that is already done by daemon(),
527
467
# always replaced by /dev/null.)
528
468
self.checker = subprocess.Popen(command,
529
469
close_fds=True,
530
shell=True, cwd="/")
470
shell=True, cwd=u"/")
531
471
self.checker_callback_tag = (gobject.child_watch_add
532
472
(self.checker.pid,
533
473
self.checker_callback,
538
478
if pid:
539
479
gobject.source_remove(self.checker_callback_tag)
540
480
self.checker_callback(pid, status, command)
541
except OSError as error:
542
logger.error("Failed to start subprocess: %s",
481
except OSError, error:
482
logger.error(u"Failed to start subprocess: %s",
543
483
error)
544
484
# Re-run this periodically if run by gobject.timeout_add
545
485
return True
549
489
if self.checker_callback_tag:
550
490
gobject.source_remove(self.checker_callback_tag)
551
491
self.checker_callback_tag = None
552
if getattr(self, "checker", None) is None:
492
if getattr(self, u"checker", None) is None:
553
493
return
554
logger.debug("Stopping checker for %(name)s", vars(self))
494
logger.debug(u"Stopping checker for %(name)s", vars(self))
555
495
try:
556
496
os.kill(self.checker.pid, signal.SIGTERM)
557
497
#time.sleep(0.5)
558
498
#if self.checker.poll() is None:
559
499
# os.kill(self.checker.pid, signal.SIGKILL)
560
except OSError as error:
500
except OSError, error:
561
501
if error.errno != errno.ESRCH: # No such process
562
502
raise
563
503
self.checker = None
564
504
565
def dbus_service_property(dbus_interface, signature="v",
566
access="readwrite", byte_arrays=False):
505
def dbus_service_property(dbus_interface, signature=u"v",
506
access=u"readwrite", byte_arrays=False):
567
507
"""Decorators for marking methods of a DBusObjectWithProperties to
568
508
become properties on the D-Bus.
569
509
576
516
"""
577
517
# Encoding deeply encoded byte arrays is not supported yet by the
578
518
# "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)
519
if byte_arrays and signature != u"ay":
520
raise ValueError(u"Byte arrays not supported for non-'ay'"
521
u" signature %r" % signature)
582
522
def decorator(func):
583
523
func._dbus_is_property = True
584
524
func._dbus_interface = dbus_interface
585
525
func._dbus_signature = signature
586
526
func._dbus_access = access
587
527
func._dbus_name = func.__name__
588
if func._dbus_name.endswith("_dbus_property"):
528
if func._dbus_name.endswith(u"_dbus_property"):
589
529
func._dbus_name = func._dbus_name[:-14]
590
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
530
func._dbus_get_args_options = {u'byte_arrays': byte_arrays }
591
531
return func
592
532
return decorator
593
533
621
561
622
562
@staticmethod
623
563
def _is_dbus_property(obj):
624
return getattr(obj, "_dbus_is_property", False)
564
return getattr(obj, u"_dbus_is_property", False)
625
565
626
566
def _get_all_dbus_properties(self):
627
567
"""Returns a generator of (name, attribute) pairs
635
575
property with the specified name and interface.
636
576
"""
637
577
for name in (property_name,
638
property_name + "_dbus_property"):
578
property_name + u"_dbus_property"):
639
579
prop = getattr(self, name, None)
640
580
if (prop is None
641
581
or not self._is_dbus_property(prop)
645
585
continue
646
586
return prop
647
587
# No such property
648
raise DBusPropertyNotFound(self.dbus_object_path + ":"
649
+ interface_name + "."
588
raise DBusPropertyNotFound(self.dbus_object_path + u":"
589
+ interface_name + u"."
650
590
+ property_name)
651
591
652
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
653
out_signature="v")
592
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
593
out_signature=u"v")
654
594
def Get(self, interface_name, property_name):
655
595
"""Standard D-Bus property Get() method, see D-Bus standard.
656
596
"""
657
597
prop = self._get_dbus_property(interface_name, property_name)
658
if prop._dbus_access == "write":
598
if prop._dbus_access == u"write":
659
599
raise DBusPropertyAccessException(property_name)
660
600
value = prop()
661
if not hasattr(value, "variant_level"):
601
if not hasattr(value, u"variant_level"):
662
602
return value
663
603
return type(value)(value, variant_level=value.variant_level+1)
664
604
665
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
605
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
666
606
def Set(self, interface_name, property_name, value):
667
607
"""Standard D-Bus property Set() method, see D-Bus standard.
668
608
"""
669
609
prop = self._get_dbus_property(interface_name, property_name)
670
if prop._dbus_access == "read":
610
if prop._dbus_access == u"read":
671
611
raise DBusPropertyAccessException(property_name)
672
if prop._dbus_get_args_options["byte_arrays"]:
612
if prop._dbus_get_args_options[u"byte_arrays"]:
673
613
# The byte_arrays option is not supported yet on
674
614
# signatures other than "ay".
675
if prop._dbus_signature != "ay":
615
if prop._dbus_signature != u"ay":
676
616
raise ValueError
677
617
value = dbus.ByteArray(''.join(unichr(byte)
678
618
for byte in value))
679
619
prop(value)
680
620
681
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
682
out_signature="a{sv}")
621
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
622
out_signature=u"a{sv}")
683
623
def GetAll(self, interface_name):
684
624
"""Standard D-Bus property GetAll() method, see D-Bus
685
625
standard.
693
633
# Interface non-empty but did not match
694
634
continue
695
635
# Ignore write-only properties
696
if prop._dbus_access == "write":
636
if prop._dbus_access == u"write":
697
637
continue
698
638
value = prop()
699
if not hasattr(value, "variant_level"):
639
if not hasattr(value, u"variant_level"):
700
640
all[name] = value
701
641
continue
702
642
all[name] = type(value)(value, variant_level=
703
643
value.variant_level+1)
704
return dbus.Dictionary(all, signature="sv")
644
return dbus.Dictionary(all, signature=u"sv")
705
645
706
646
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
707
out_signature="s",
647
out_signature=u"s",
708
648
path_keyword='object_path',
709
649
connection_keyword='connection')
710
650
def Introspect(self, object_path, connection):
715
655
try:
716
656
document = xml.dom.minidom.parseString(xmlstring)
717
657
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)
658
e = document.createElement(u"property")
659
e.setAttribute(u"name", name)
660
e.setAttribute(u"type", prop._dbus_signature)
661
e.setAttribute(u"access", prop._dbus_access)
722
662
return e
723
for if_tag in document.getElementsByTagName("interface"):
663
for if_tag in document.getElementsByTagName(u"interface"):
724
664
for tag in (make_tag(document, name, prop)
725
665
for name, prop
726
666
in self._get_all_dbus_properties()
727
667
if prop._dbus_interface
728
== if_tag.getAttribute("name")):
668
== if_tag.getAttribute(u"name")):
729
669
if_tag.appendChild(tag)
730
670
# Add the names to the return values for the
731
671
# "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")
672
if (if_tag.getAttribute(u"name")
673
== u"org.freedesktop.DBus.Properties"):
674
for cn in if_tag.getElementsByTagName(u"method"):
675
if cn.getAttribute(u"name") == u"Get":
676
for arg in cn.getElementsByTagName(u"arg"):
677
if (arg.getAttribute(u"direction")
678
== u"out"):
679
arg.setAttribute(u"name", u"value")
680
elif cn.getAttribute(u"name") == u"GetAll":
681
for arg in cn.getElementsByTagName(u"arg"):
682
if (arg.getAttribute(u"direction")
683
== u"out"):
684
arg.setAttribute(u"name", u"props")
685
xmlstring = document.toxml(u"utf-8")
746
686
document.unlink()
747
687
except (AttributeError, xml.dom.DOMException,
748
xml.parsers.expat.ExpatError) as error:
749
logger.error("Failed to override Introspection method",
688
xml.parsers.expat.ExpatError), error:
689
logger.error(u"Failed to override Introspection method",
750
690
error)
751
691
return xmlstring
752
692
758
698
dbus_object_path: dbus.ObjectPath
759
699
bus: dbus.SystemBus()
760
700
"""
761
762
runtime_expansions = (Client.runtime_expansions
763
+ ("dbus_object_path",))
764
765
701
# dbus.service.Object doesn't use super(), so we can't either.
766
702
767
703
def __init__(self, bus = None, *args, **kwargs):
770
706
Client.__init__(self, *args, **kwargs)
771
707
# Only now, when this client is initialized, can it show up on
772
708
# the D-Bus
773
client_object_name = unicode(self.name).translate(
774
{ord("."): ord("_"),
775
ord("-"): ord("_")})
776
709
self.dbus_object_path = (dbus.ObjectPath
777
("/clients/" + client_object_name))
710
(u"/clients/"
711
+ self.name.replace(u".", u"_")))
778
712
DBusObjectWithProperties.__init__(self, self.bus,
779
713
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
714
791
715
def _get_approvals_pending(self):
792
716
return self._approvals_pending
793
717
def _set_approvals_pending(self, value):
797
721
if (hasattr(self, "dbus_object_path")
798
722
and bval is not bool(old_value)):
799
723
dbus_bool = dbus.Boolean(bval, variant_level=1)
800
self.PropertyChanged(dbus.String("ApprovalPending"),
724
self.PropertyChanged(dbus.String(u"approved_pending"),
801
725
dbus_bool)
802
726
803
727
approvals_pending = property(_get_approvals_pending,
807
731
@staticmethod
808
732
def _datetime_to_dbus(dt, variant_level=0):
809
733
"""Convert a UTC datetime.datetime() to a D-Bus type."""
810
if dt is None:
811
return dbus.String("", variant_level = variant_level)
812
734
return dbus.String(dt.isoformat(),
813
735
variant_level=variant_level)
814
736
815
737
def enable(self):
816
oldstate = getattr(self, "enabled", False)
738
oldstate = getattr(self, u"enabled", False)
817
739
r = Client.enable(self)
818
740
if oldstate != self.enabled:
819
741
# Emit D-Bus signals
820
self.PropertyChanged(dbus.String("Enabled"),
742
self.PropertyChanged(dbus.String(u"enabled"),
821
743
dbus.Boolean(True, variant_level=1))
822
744
self.PropertyChanged(
823
dbus.String("LastEnabled"),
745
dbus.String(u"last_enabled"),
824
746
self._datetime_to_dbus(self.last_enabled,
825
747
variant_level=1))
826
748
return r
827
749
828
750
def disable(self, quiet = False):
829
oldstate = getattr(self, "enabled", False)
751
oldstate = getattr(self, u"enabled", False)
830
752
r = Client.disable(self, quiet=quiet)
831
753
if not quiet and oldstate != self.enabled:
832
754
# Emit D-Bus signal
833
self.PropertyChanged(dbus.String("Enabled"),
755
self.PropertyChanged(dbus.String(u"enabled"),
834
756
dbus.Boolean(False, variant_level=1))
835
757
return r
836
758
839
761
self.remove_from_connection()
840
762
except LookupError:
841
763
pass
842
if hasattr(DBusObjectWithProperties, "__del__"):
764
if hasattr(DBusObjectWithProperties, u"__del__"):
843
765
DBusObjectWithProperties.__del__(self, *args, **kwargs)
844
766
Client.__del__(self, *args, **kwargs)
845
767
848
770
self.checker_callback_tag = None
849
771
self.checker = None
850
772
# Emit D-Bus signal
851
self.PropertyChanged(dbus.String("CheckerRunning"),
773
self.PropertyChanged(dbus.String(u"checker_running"),
852
774
dbus.Boolean(False, variant_level=1))
853
775
if os.WIFEXITED(condition):
854
776
exitstatus = os.WEXITSTATUS(condition)
866
788
*args, **kwargs)
867
789
868
790
def checked_ok(self, *args, **kwargs):
869
Client.checked_ok(self, *args, **kwargs)
791
r = Client.checked_ok(self, *args, **kwargs)
870
792
# Emit D-Bus signal
871
793
self.PropertyChanged(
872
dbus.String("LastCheckedOK"),
794
dbus.String(u"last_checked_ok"),
873
795
(self._datetime_to_dbus(self.last_checked_ok,
874
796
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)))
883
797
return r
884
798
885
799
def start_checker(self, *args, **kwargs):
895
809
# Emit D-Bus signal
896
810
self.CheckerStarted(self.current_checker_command)
897
811
self.PropertyChanged(
898
dbus.String("CheckerRunning"),
812
dbus.String(u"checker_running"),
899
813
dbus.Boolean(True, variant_level=1))
900
814
return r
901
815
902
816
def stop_checker(self, *args, **kwargs):
903
old_checker = getattr(self, "checker", None)
817
old_checker = getattr(self, u"checker", None)
904
818
r = Client.stop_checker(self, *args, **kwargs)
905
819
if (old_checker is not None
906
and getattr(self, "checker", None) is None):
907
self.PropertyChanged(dbus.String("CheckerRunning"),
820
and getattr(self, u"checker", None) is None):
821
self.PropertyChanged(dbus.String(u"checker_running"),
908
822
dbus.Boolean(False, variant_level=1))
909
823
return r
910
824
915
829
def approve(self, value=True):
916
830
self.send_changedstate()
917
831
self._approved = value
918
gobject.timeout_add(self._timedelta_to_milliseconds
919
(self.approval_duration),
832
gobject.timeout_add(self._timedelta_to_milliseconds(self.approved_duration),
920
833
self._reset_approved)
921
834
922
835
923
836
## D-Bus methods, signals & properties
924
_interface = "se.bsnet.fukt.Mandos.Client"
837
_interface = u"se.bsnet.fukt.Mandos.Client"
925
838
926
839
## Signals
927
840
928
841
# CheckerCompleted - signal
929
@dbus.service.signal(_interface, signature="nxs")
842
@dbus.service.signal(_interface, signature=u"nxs")
930
843
def CheckerCompleted(self, exitcode, waitstatus, command):
931
844
"D-Bus signal"
932
845
pass
933
846
934
847
# CheckerStarted - signal
935
@dbus.service.signal(_interface, signature="s")
848
@dbus.service.signal(_interface, signature=u"s")
936
849
def CheckerStarted(self, command):
937
850
"D-Bus signal"
938
851
pass
939
852
940
853
# PropertyChanged - signal
941
@dbus.service.signal(_interface, signature="sv")
854
@dbus.service.signal(_interface, signature=u"sv")
942
855
def PropertyChanged(self, property, value):
943
856
"D-Bus signal"
944
857
pass
953
866
pass
954
867
955
868
# Rejected - signal
956
@dbus.service.signal(_interface, signature="s")
869
@dbus.service.signal(_interface, signature=u"s")
957
870
def Rejected(self, reason):
958
871
"D-Bus signal"
959
872
pass
960
873
961
874
# NeedApproval - signal
962
@dbus.service.signal(_interface, signature="tb")
875
@dbus.service.signal(_interface, signature=u"db")
963
876
def NeedApproval(self, timeout, default):
964
877
"D-Bus signal"
965
return self.need_approval()
878
pass
966
879
967
880
## Methods
968
881
969
882
# Approve - method
970
@dbus.service.method(_interface, in_signature="b")
883
@dbus.service.method(_interface, in_signature=u"b")
971
884
def Approve(self, value):
972
885
self.approve(value)
973
886
974
887
# CheckedOK - method
975
888
@dbus.service.method(_interface)
976
889
def CheckedOK(self):
977
self.checked_ok()
890
return self.checked_ok()
978
891
979
892
# Enable - method
980
893
@dbus.service.method(_interface)
1001
914
1002
915
## Properties
1003
916
1004
# ApprovalPending - property
1005
@dbus_service_property(_interface, signature="b", access="read")
1006
def ApprovalPending_dbus_property(self):
917
# approved_pending - property
918
@dbus_service_property(_interface, signature=u"b", access=u"read")
919
def approved_pending_dbus_property(self):
1007
920
return dbus.Boolean(bool(self.approvals_pending))
1008
921
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):
922
# approved_by_default - property
923
@dbus_service_property(_interface, signature=u"b",
924
access=u"readwrite")
925
def approved_by_default_dbus_property(self):
926
return dbus.Boolean(self.approved_by_default)
927
928
# approved_delay - property
929
@dbus_service_property(_interface, signature=u"t",
930
access=u"readwrite")
931
def approved_delay_dbus_property(self):
932
return dbus.UInt64(self.approved_delay_milliseconds())
933
934
# approved_duration - property
935
@dbus_service_property(_interface, signature=u"t",
936
access=u"readwrite")
937
def approved_duration_dbus_property(self):
938
return dbus.UInt64(self._timedelta_to_milliseconds(
939
self.approved_duration))
940
941
# name - property
942
@dbus_service_property(_interface, signature=u"s", access=u"read")
943
def name_dbus_property(self):
1052
944
return dbus.String(self.name)
1053
945
1054
# Fingerprint - property
1055
@dbus_service_property(_interface, signature="s", access="read")
1056
def Fingerprint_dbus_property(self):
946
# fingerprint - property
947
@dbus_service_property(_interface, signature=u"s", access=u"read")
948
def fingerprint_dbus_property(self):
1057
949
return dbus.String(self.fingerprint)
1058
950
1059
# Host - property
1060
@dbus_service_property(_interface, signature="s",
1061
access="readwrite")
1062
def Host_dbus_property(self, value=None):
951
# host - property
952
@dbus_service_property(_interface, signature=u"s",
953
access=u"readwrite")
954
def host_dbus_property(self, value=None):
1063
955
if value is None: # get
1064
956
return dbus.String(self.host)
1065
old_value = self.host
1066
957
self.host = value
1067
958
# Emit D-Bus signal
1068
if old_value != self.host:
1069
self.PropertyChanged(dbus.String("Host"),
1070
dbus.String(value, variant_level=1))
959
self.PropertyChanged(dbus.String(u"host"),
960
dbus.String(value, variant_level=1))
1071
961
1072
# Created - property
1073
@dbus_service_property(_interface, signature="s", access="read")
1074
def Created_dbus_property(self):
962
# created - property
963
@dbus_service_property(_interface, signature=u"s", access=u"read")
964
def created_dbus_property(self):
1075
965
return dbus.String(self._datetime_to_dbus(self.created))
1076
966
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)
967
# last_enabled - property
968
@dbus_service_property(_interface, signature=u"s", access=u"read")
969
def last_enabled_dbus_property(self):
970
if self.last_enabled is None:
971
return dbus.String(u"")
972
return dbus.String(self._datetime_to_dbus(self.last_enabled))
1081
973
1082
# Enabled - property
1083
@dbus_service_property(_interface, signature="b",
1084
access="readwrite")
1085
def Enabled_dbus_property(self, value=None):
974
# enabled - property
975
@dbus_service_property(_interface, signature=u"b",
976
access=u"readwrite")
977
def enabled_dbus_property(self, value=None):
1086
978
if value is None: # get
1087
979
return dbus.Boolean(self.enabled)
1088
980
if value:
1090
982
else:
1091
983
self.disable()
1092
984
1093
# LastCheckedOK - property
1094
@dbus_service_property(_interface, signature="s",
1095
access="readwrite")
1096
def LastCheckedOK_dbus_property(self, value=None):
985
# last_checked_ok - property
986
@dbus_service_property(_interface, signature=u"s",
987
access=u"readwrite")
988
def last_checked_ok_dbus_property(self, value=None):
1097
989
if value is not None:
1098
990
self.checked_ok()
1099
991
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):
992
if self.last_checked_ok is None:
993
return dbus.String(u"")
994
return dbus.String(self._datetime_to_dbus(self
995
.last_checked_ok))
996
997
# timeout - property
998
@dbus_service_property(_interface, signature=u"t",
999
access=u"readwrite")
1000
def timeout_dbus_property(self, value=None):
1116
1001
if value is None: # get
1117
1002
return dbus.UInt64(self.timeout_milliseconds())
1118
old_value = self.timeout
1119
1003
self.timeout = datetime.timedelta(0, 0, 0, value)
1120
1004
# 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:
1005
self.PropertyChanged(dbus.String(u"timeout"),
1006
dbus.UInt64(value, variant_level=1))
1007
if getattr(self, u"disable_initiator_tag", None) is None:
1125
1008
return
1126
1009
# Reschedule timeout
1127
1010
gobject.source_remove(self.disable_initiator_tag)
1128
1011
self.disable_initiator_tag = None
1129
self.expires = None
1130
1012
time_to_die = (self.
1131
1013
_timedelta_to_milliseconds((self
1132
1014
.last_checked_ok
1137
1019
# The timeout has passed
1138
1020
self.disable()
1139
1021
else:
1140
self.expires = (datetime.datetime.utcnow()
1141
+ datetime.timedelta(milliseconds = time_to_die))
1142
1022
self.disable_initiator_tag = (gobject.timeout_add
1143
1023
(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):
1024
1025
# interval - property
1026
@dbus_service_property(_interface, signature=u"t",
1027
access=u"readwrite")
1028
def interval_dbus_property(self, value=None):
1162
1029
if value is None: # get
1163
1030
return dbus.UInt64(self.interval_milliseconds())
1164
old_value = self.interval
1165
1031
self.interval = datetime.timedelta(0, 0, 0, value)
1166
1032
# 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:
1033
self.PropertyChanged(dbus.String(u"interval"),
1034
dbus.UInt64(value, variant_level=1))
1035
if getattr(self, u"checker_initiator_tag", None) is None:
1171
1036
return
1172
1037
# Reschedule checker run
1173
1038
gobject.source_remove(self.checker_initiator_tag)
1175
1040
(value, self.start_checker))
1176
1041
self.start_checker() # Start one now, too
1177
1042
1178
# Checker - property
1179
@dbus_service_property(_interface, signature="s",
1180
access="readwrite")
1181
def Checker_dbus_property(self, value=None):
1043
# checker - property
1044
@dbus_service_property(_interface, signature=u"s",
1045
access=u"readwrite")
1046
def checker_dbus_property(self, value=None):
1182
1047
if value is None: # get
1183
1048
return dbus.String(self.checker_command)
1184
old_value = self.checker_command
1185
1049
self.checker_command = value
1186
1050
# 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))
1051
self.PropertyChanged(dbus.String(u"checker"),
1052
dbus.String(self.checker_command,
1053
variant_level=1))
1191
1054
1192
# CheckerRunning - property
1193
@dbus_service_property(_interface, signature="b",
1194
access="readwrite")
1195
def CheckerRunning_dbus_property(self, value=None):
1055
# checker_running - property
1056
@dbus_service_property(_interface, signature=u"b",
1057
access=u"readwrite")
1058
def checker_running_dbus_property(self, value=None):
1196
1059
if value is None: # get
1197
1060
return dbus.Boolean(self.checker is not None)
1198
1061
if value:
1200
1063
else:
1201
1064
self.stop_checker()
1202
1065
1203
# ObjectPath - property
1204
@dbus_service_property(_interface, signature="o", access="read")
1205
def ObjectPath_dbus_property(self):
1066
# object_path - property
1067
@dbus_service_property(_interface, signature=u"o", access=u"read")
1068
def object_path_dbus_property(self):
1206
1069
return self.dbus_object_path # is already a dbus.ObjectPath
1207
1070
1208
# Secret = property
1209
@dbus_service_property(_interface, signature="ay",
1210
access="write", byte_arrays=True)
1211
def Secret_dbus_property(self, value):
1071
# secret = property
1072
@dbus_service_property(_interface, signature=u"ay",
1073
access=u"write", byte_arrays=True)
1074
def secret_dbus_property(self, value):
1212
1075
self.secret = str(value)
1213
1076
1214
1077
del _interface
1248
1111
1249
1112
def handle(self):
1250
1113
with contextlib.closing(self.server.child_pipe) as child_pipe:
1251
logger.info("TCP connection from: %s",
1114
logger.info(u"TCP connection from: %s",
1252
1115
unicode(self.client_address))
1253
logger.debug("Pipe FD: %d",
1116
logger.debug(u"Pipe FD: %d",
1254
1117
self.server.child_pipe.fileno())
1255
1118
1256
1119
session = (gnutls.connection
1263
1126
# no X.509 keys are added to it. Therefore, we can use it
1264
1127
# here despite using OpenPGP certificates.
1265
1128
1266
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1267
# "+AES-256-CBC", "+SHA1",
1268
# "+COMP-NULL", "+CTYPE-OPENPGP",
1269
# "+DHE-DSS"))
1129
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
1130
# u"+AES-256-CBC", u"+SHA1",
1131
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
1132
# u"+DHE-DSS"))
1270
1133
# Use a fallback default, since this MUST be set.
1271
1134
priority = self.server.gnutls_priority
1272
1135
if priority is None:
1273
priority = "NORMAL"
1136
priority = u"NORMAL"
1274
1137
(gnutls.library.functions
1275
1138
.gnutls_priority_set_direct(session._c_object,
1276
1139
priority, None))
1278
1141
# Start communication using the Mandos protocol
1279
1142
# Get protocol number
1280
1143
line = self.request.makefile().readline()
1281
logger.debug("Protocol version: %r", line)
1144
logger.debug(u"Protocol version: %r", line)
1282
1145
try:
1283
1146
if int(line.strip().split()[0]) > 1:
1284
1147
raise RuntimeError
1285
except (ValueError, IndexError, RuntimeError) as error:
1286
logger.error("Unknown protocol version: %s", error)
1148
except (ValueError, IndexError, RuntimeError), error:
1149
logger.error(u"Unknown protocol version: %s", error)
1287
1150
return
1288
1151
1289
1152
# Start GnuTLS connection
1290
1153
try:
1291
1154
session.handshake()
1292
except gnutls.errors.GNUTLSError as error:
1293
logger.warning("Handshake failed: %s", error)
1155
except gnutls.errors.GNUTLSError, error:
1156
logger.warning(u"Handshake failed: %s", error)
1294
1157
# Do not run session.bye() here: the session is not
1295
1158
# established. Just abandon the request.
1296
1159
return
1297
logger.debug("Handshake succeeded")
1160
logger.debug(u"Handshake succeeded")
1298
1161
1299
1162
approval_required = False
1300
1163
try:
1301
1164
try:
1302
1165
fpr = self.fingerprint(self.peer_certificate
1303
1166
(session))
1304
except (TypeError,
1305
gnutls.errors.GNUTLSError) as error:
1306
logger.warning("Bad certificate: %s", error)
1167
except (TypeError, gnutls.errors.GNUTLSError), error:
1168
logger.warning(u"Bad certificate: %s", error)
1307
1169
return
1308
logger.debug("Fingerprint: %s", fpr)
1170
logger.debug(u"Fingerprint: %s", fpr)
1309
1171
1310
1172
try:
1311
1173
client = ProxyClient(child_pipe, fpr,
1313
1175
except KeyError:
1314
1176
return
1315
1177
1316
if client.approval_delay:
1317
delay = client.approval_delay
1178
if client.approved_delay:
1179
delay = client.approved_delay
1318
1180
client.approvals_pending += 1
1319
1181
approval_required = True
1320
1182
1321
1183
while True:
1322
1184
if not client.enabled:
1323
logger.info("Client %s is disabled",
1185
logger.warning(u"Client %s is disabled",
1324
1186
client.name)
1325
1187
if self.server.use_dbus:
1326
1188
# Emit D-Bus signal
1327
1189
client.Rejected("Disabled")
1328
1190
return
1329
1191
1330
if client._approved or not client.approval_delay:
1192
if client._approved or not client.approved_delay:
1331
1193
#We are approved or approval is disabled
1332
1194
break
1333
1195
elif client._approved is None:
1334
logger.info("Client %s needs approval",
1196
logger.info(u"Client %s need approval",
1335
1197
client.name)
1336
1198
if self.server.use_dbus:
1337
1199
# Emit D-Bus signal
1338
1200
client.NeedApproval(
1339
client.approval_delay_milliseconds(),
1201
client.approved_delay_milliseconds(),
1340
1202
client.approved_by_default)
1341
1203
else:
1342
logger.warning("Client %s was not approved",
1204
logger.warning(u"Client %s was not approved",
1343
1205
client.name)
1344
1206
if self.server.use_dbus:
1345
1207
# Emit D-Bus signal
1346
client.Rejected("Denied")
1208
client.Rejected("Disapproved")
1347
1209
return
1348
1210
1349
1211
#wait until timeout or approved
1360
1222
client.name)
1361
1223
if self.server.use_dbus:
1362
1224
# Emit D-Bus signal
1363
client.Rejected("Approval timed out")
1225
client.Rejected("Time out")
1364
1226
return
1365
1227
else:
1366
1228
break
1371
1233
while sent_size < len(client.secret):
1372
1234
try:
1373
1235
sent = session.send(client.secret[sent_size:])
1374
except gnutls.errors.GNUTLSError as error:
1236
except (gnutls.errors.GNUTLSError), error:
1375
1237
logger.warning("gnutls send failed")
1376
1238
return
1377
logger.debug("Sent: %d, remaining: %d",
1239
logger.debug(u"Sent: %d, remaining: %d",
1378
1240
sent, len(client.secret)
1379
1241
- (sent_size + sent))
1380
1242
sent_size += sent
1381
1243
1382
logger.info("Sending secret to %s", client.name)
1244
logger.info(u"Sending secret to %s", client.name)
1383
1245
# bump the timeout as if seen
1384
client.checked_ok(client.extended_timeout)
1246
client.checked_ok()
1385
1247
if self.server.use_dbus:
1386
1248
# Emit D-Bus signal
1387
1249
client.GotSecret()
1391
1253
client.approvals_pending -= 1
1392
1254
try:
1393
1255
session.bye()
1394
except gnutls.errors.GNUTLSError as error:
1395
logger.warning("GnuTLS bye failed")
1256
except (gnutls.errors.GNUTLSError), error:
1257
logger.warning("gnutls bye failed")
1396
1258
1397
1259
@staticmethod
1398
1260
def peer_certificate(session):
1408
1270
.gnutls_certificate_get_peers
1409
1271
(session._c_object, ctypes.byref(list_size)))
1410
1272
if not bool(cert_list) and list_size.value != 0:
1411
raise gnutls.errors.GNUTLSError("error getting peer"
1412
" certificate")
1273
raise gnutls.errors.GNUTLSError(u"error getting peer"
1274
u" certificate")
1413
1275
if list_size.value == 0:
1414
1276
return None
1415
1277
cert = cert_list[0]
1441
1303
if crtverify.value != 0:
1442
1304
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1443
1305
raise (gnutls.errors.CertificateSecurityError
1444
("Verify failed"))
1306
(u"Verify failed"))
1445
1307
# New buffer for the fingerprint
1446
1308
buf = ctypes.create_string_buffer(20)
1447
1309
buf_len = ctypes.c_size_t()
1454
1316
# Convert the buffer to a Python bytestring
1455
1317
fpr = ctypes.string_at(buf, buf_len.value)
1456
1318
# Convert the bytestring to hexadecimal notation
1457
hex_fpr = ''.join("%02X" % ord(char) for char in fpr)
1319
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
1458
1320
return hex_fpr
1459
1321
1460
1322
1488
1350
1489
1351
def add_pipe(self, parent_pipe):
1490
1352
"""Dummy function; override as necessary"""
1491
raise NotImplementedError
1353
pass
1492
1354
1493
1355
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1494
1356
socketserver.TCPServer, object):
1512
1374
bind to an address or port if they were not specified."""
1513
1375
if self.interface is not None:
1514
1376
if SO_BINDTODEVICE is None:
1515
logger.error("SO_BINDTODEVICE does not exist;"
1516
" cannot bind to interface %s",
1377
logger.error(u"SO_BINDTODEVICE does not exist;"
1378
u" cannot bind to interface %s",
1517
1379
self.interface)
1518
1380
else:
1519
1381
try:
1520
1382
self.socket.setsockopt(socket.SOL_SOCKET,
1521
1383
SO_BINDTODEVICE,
1522
1384
str(self.interface
1523
+ '\0'))
1524
except socket.error as error:
1385
+ u'\0'))
1386
except socket.error, error:
1525
1387
if error[0] == errno.EPERM:
1526
logger.error("No permission to"
1527
" bind to interface %s",
1388
logger.error(u"No permission to"
1389
u" bind to interface %s",
1528
1390
self.interface)
1529
1391
elif error[0] == errno.ENOPROTOOPT:
1530
logger.error("SO_BINDTODEVICE not available;"
1531
" cannot bind to interface %s",
1392
logger.error(u"SO_BINDTODEVICE not available;"
1393
u" cannot bind to interface %s",
1532
1394
self.interface)
1533
1395
else:
1534
1396
raise
1536
1398
if self.server_address[0] or self.server_address[1]:
1537
1399
if not self.server_address[0]:
1538
1400
if self.address_family == socket.AF_INET6:
1539
any_address = "::" # in6addr_any
1401
any_address = u"::" # in6addr_any
1540
1402
else:
1541
1403
any_address = socket.INADDR_ANY
1542
1404
self.server_address = (any_address,
1591
1453
def handle_ipc(self, source, condition, parent_pipe=None,
1592
1454
client_object=None):
1593
1455
condition_names = {
1594
gobject.IO_IN: "IN", # There is data to read.
1595
gobject.IO_OUT: "OUT", # Data can be written (without
1456
gobject.IO_IN: u"IN", # There is data to read.
1457
gobject.IO_OUT: u"OUT", # Data can be written (without
1596
1458
# blocking).
1597
gobject.IO_PRI: "PRI", # There is urgent data to read.
1598
gobject.IO_ERR: "ERR", # Error condition.
1599
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1459
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1460
gobject.IO_ERR: u"ERR", # Error condition.
1461
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1600
1462
# broken, usually for pipes and
1601
1463
# sockets).
1602
1464
}
1604
1466
for cond, name in
1605
1467
condition_names.iteritems()
1606
1468
if cond & condition)
1469
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1470
conditions_string)
1471
1607
1472
# error or the other end of multiprocessing.Pipe has closed
1608
1473
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1609
1474
return False
1610
1475
1611
1476
# Read a request from the child
1612
1477
request = parent_pipe.recv()
1478
logger.debug(u"IPC request: %s", repr(request))
1613
1479
command = request[0]
1614
1480
1615
1481
if command == 'init':
1621
1487
client = c
1622
1488
break
1623
1489
else:
1624
logger.info("Client not found for fingerprint: %s, ad"
1625
"dress: %s", fpr, address)
1490
logger.warning(u"Client not found for fingerprint: %s, ad"
1491
u"dress: %s", fpr, address)
1626
1492
if self.use_dbus:
1627
1493
# Emit D-Bus signal
1628
mandos_dbus_service.ClientNotFound(fpr, address[0])
1494
mandos_dbus_service.ClientNotFound(fpr, address)
1629
1495
parent_pipe.send(False)
1630
1496
return False
1631
1497
1662
1528
def string_to_delta(interval):
1663
1529
"""Parse a string and return a datetime.timedelta
1664
1530
1665
>>> string_to_delta('7d')
1531
>>> string_to_delta(u'7d')
1666
1532
datetime.timedelta(7)
1667
>>> string_to_delta('60s')
1533
>>> string_to_delta(u'60s')
1668
1534
datetime.timedelta(0, 60)
1669
>>> string_to_delta('60m')
1535
>>> string_to_delta(u'60m')
1670
1536
datetime.timedelta(0, 3600)
1671
>>> string_to_delta('24h')
1537
>>> string_to_delta(u'24h')
1672
1538
datetime.timedelta(1)
1673
>>> string_to_delta('1w')
1539
>>> string_to_delta(u'1w')
1674
1540
datetime.timedelta(7)
1675
>>> string_to_delta('5m 30s')
1541
>>> string_to_delta(u'5m 30s')
1676
1542
datetime.timedelta(0, 330)
1677
1543
"""
1678
1544
timevalue = datetime.timedelta(0)
1680
1546
try:
1681
1547
suffix = unicode(s[-1])
1682
1548
value = int(s[:-1])
1683
if suffix == "d":
1549
if suffix == u"d":
1684
1550
delta = datetime.timedelta(value)
1685
elif suffix == "s":
1551
elif suffix == u"s":
1686
1552
delta = datetime.timedelta(0, value)
1687
elif suffix == "m":
1553
elif suffix == u"m":
1688
1554
delta = datetime.timedelta(0, 0, 0, 0, value)
1689
elif suffix == "h":
1555
elif suffix == u"h":
1690
1556
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1691
elif suffix == "w":
1557
elif suffix == u"w":
1692
1558
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1693
1559
else:
1694
raise ValueError("Unknown suffix %r" % suffix)
1695
except (ValueError, IndexError) as e:
1696
raise ValueError(*(e.args))
1560
raise ValueError(u"Unknown suffix %r" % suffix)
1561
except (ValueError, IndexError), e:
1562
raise ValueError(e.message)
1697
1563
timevalue += delta
1698
1564
return timevalue
1699
1565
1705
1571
global if_nametoindex
1706
1572
try:
1707
1573
if_nametoindex = (ctypes.cdll.LoadLibrary
1708
(ctypes.util.find_library("c"))
1574
(ctypes.util.find_library(u"c"))
1709
1575
.if_nametoindex)
1710
1576
except (OSError, AttributeError):
1711
logger.warning("Doing if_nametoindex the hard way")
1577
logger.warning(u"Doing if_nametoindex the hard way")
1712
1578
def if_nametoindex(interface):
1713
1579
"Get an interface index the hard way, i.e. using fcntl()"
1714
1580
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1715
1581
with contextlib.closing(socket.socket()) as s:
1716
1582
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1717
struct.pack(str("16s16x"),
1583
struct.pack(str(u"16s16x"),
1718
1584
interface))
1719
interface_index = struct.unpack(str("I"),
1585
interface_index = struct.unpack(str(u"I"),
1720
1586
ifreq[16:20])[0]
1721
1587
return interface_index
1722
1588
return if_nametoindex(interface)
1730
1596
sys.exit()
1731
1597
os.setsid()
1732
1598
if not nochdir:
1733
os.chdir("/")
1599
os.chdir(u"/")
1734
1600
if os.fork():
1735
1601
sys.exit()
1736
1602
if not noclose:
1738
1604
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1739
1605
if not stat.S_ISCHR(os.fstat(null).st_mode):
1740
1606
raise OSError(errno.ENODEV,
1741
"%s not a character device"
1607
u"%s not a character device"
1742
1608
% os.path.devnull)
1743
1609
os.dup2(null, sys.stdin.fileno())
1744
1610
os.dup2(null, sys.stdout.fileno())
1752
1618
##################################################################
1753
1619
# Parsing of options, both command line and config file
1754
1620
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()
1621
parser = optparse.OptionParser(version = "%%prog %s" % version)
1622
parser.add_option("-i", u"--interface", type=u"string",
1623
metavar="IF", help=u"Bind to interface IF")
1624
parser.add_option("-a", u"--address", type=u"string",
1625
help=u"Address to listen for requests on")
1626
parser.add_option("-p", u"--port", type=u"int",
1627
help=u"Port number to receive requests on")
1628
parser.add_option("--check", action=u"store_true",
1629
help=u"Run self-test")
1630
parser.add_option("--debug", action=u"store_true",
1631
help=u"Debug mode; run in foreground and log to"
1632
u" terminal")
1633
parser.add_option("--debuglevel", type=u"string", metavar="Level",
1634
help=u"Debug level for stdout output")
1635
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1636
u" priority string (see GnuTLS documentation)")
1637
parser.add_option("--servicename", type=u"string",
1638
metavar=u"NAME", help=u"Zeroconf service name")
1639
parser.add_option("--configdir", type=u"string",
1640
default=u"/etc/mandos", metavar=u"DIR",
1641
help=u"Directory to search for configuration"
1642
u" files")
1643
parser.add_option("--no-dbus", action=u"store_false",
1644
dest=u"use_dbus", help=u"Do not provide D-Bus"
1645
u" system bus interface")
1646
parser.add_option("--no-ipv6", action=u"store_false",
1647
dest=u"use_ipv6", help=u"Do not use IPv6")
1648
options = parser.parse_args()[0]
1786
1649
1787
1650
if options.check:
1788
1651
import doctest
1790
1653
sys.exit()
1791
1654
1792
1655
# Default values for config file for server-global settings
1793
server_defaults = { "interface": "",
1794
"address": "",
1795
"port": "",
1796
"debug": "False",
1797
"priority":
1798
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1799
"servicename": "Mandos",
1800
"use_dbus": "True",
1801
"use_ipv6": "True",
1802
"debuglevel": "",
1656
server_defaults = { u"interface": u"",
1657
u"address": u"",
1658
u"port": u"",
1659
u"debug": u"False",
1660
u"priority":
1661
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1662
u"servicename": u"Mandos",
1663
u"use_dbus": u"True",
1664
u"use_ipv6": u"True",
1665
u"debuglevel": u"",
1803
1666
}
1804
1667
1805
1668
# Parse config file for server-global settings
1806
1669
server_config = configparser.SafeConfigParser(server_defaults)
1807
1670
del server_defaults
1808
1671
server_config.read(os.path.join(options.configdir,
1809
"mandos.conf"))
1672
u"mandos.conf"))
1810
1673
# Convert the SafeConfigParser object to a dict
1811
1674
server_settings = server_config.defaults()
1812
1675
# 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",
1676
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1677
server_settings[option] = server_config.getboolean(u"DEFAULT",
1815
1678
option)
1816
1679
if server_settings["port"]:
1817
server_settings["port"] = server_config.getint("DEFAULT",
1818
"port")
1680
server_settings["port"] = server_config.getint(u"DEFAULT",
1681
u"port")
1819
1682
del server_config
1820
1683
1821
1684
# Override the settings from the config file with command line
1822
1685
# options, if set.
1823
for option in ("interface", "address", "port", "debug",
1824
"priority", "servicename", "configdir",
1825
"use_dbus", "use_ipv6", "debuglevel"):
1686
for option in (u"interface", u"address", u"port", u"debug",
1687
u"priority", u"servicename", u"configdir",
1688
u"use_dbus", u"use_ipv6", u"debuglevel"):
1826
1689
value = getattr(options, option)
1827
1690
if value is not None:
1828
1691
server_settings[option] = value
1836
1699
##################################################################
1837
1700
1838
1701
# For convenience
1839
debug = server_settings["debug"]
1840
debuglevel = server_settings["debuglevel"]
1841
use_dbus = server_settings["use_dbus"]
1842
use_ipv6 = server_settings["use_ipv6"]
1702
debug = server_settings[u"debug"]
1703
debuglevel = server_settings[u"debuglevel"]
1704
use_dbus = server_settings[u"use_dbus"]
1705
use_ipv6 = server_settings[u"use_ipv6"]
1843
1706
1844
if server_settings["servicename"] != "Mandos":
1707
if server_settings[u"servicename"] != u"Mandos":
1845
1708
syslogger.setFormatter(logging.Formatter
1846
('Mandos (%s) [%%(process)d]:'
1847
' %%(levelname)s: %%(message)s'
1848
% server_settings["servicename"]))
1709
(u'Mandos (%s) [%%(process)d]:'
1710
u' %%(levelname)s: %%(message)s'
1711
% server_settings[u"servicename"]))
1849
1712
1850
1713
# Parse config file with clients
1851
client_defaults = { "timeout": "5m",
1852
"extended_timeout": "15m",
1853
"interval": "2m",
1854
"checker": "fping -q -- %%(host)s",
1855
"host": "",
1856
"approval_delay": "0s",
1857
"approval_duration": "1s",
1714
client_defaults = { u"timeout": u"1h",
1715
u"interval": u"5m",
1716
u"checker": u"fping -q -- %%(host)s",
1717
u"host": u"",
1718
u"approved_delay": u"0s",
1719
u"approved_duration": u"1s",
1858
1720
}
1859
1721
client_config = configparser.SafeConfigParser(client_defaults)
1860
client_config.read(os.path.join(server_settings["configdir"],
1861
"clients.conf"))
1722
client_config.read(os.path.join(server_settings[u"configdir"],
1723
u"clients.conf"))
1862
1724
1863
1725
global mandos_dbus_service
1864
1726
mandos_dbus_service = None
1865
1727
1866
tcp_server = MandosServer((server_settings["address"],
1867
server_settings["port"]),
1728
tcp_server = MandosServer((server_settings[u"address"],
1729
server_settings[u"port"]),
1868
1730
ClientHandler,
1869
interface=(server_settings["interface"]
1870
or None),
1731
interface=server_settings[u"interface"],
1871
1732
use_ipv6=use_ipv6,
1872
1733
gnutls_priority=
1873
server_settings["priority"],
1734
server_settings[u"priority"],
1874
1735
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)
1736
pidfilename = u"/var/run/mandos.pid"
1737
try:
1738
pidfile = open(pidfilename, u"w")
1739
except IOError:
1740
logger.error(u"Could not open file %r", pidfilename)
1881
1741
1882
1742
try:
1883
uid = pwd.getpwnam("_mandos").pw_uid
1884
gid = pwd.getpwnam("_mandos").pw_gid
1743
uid = pwd.getpwnam(u"_mandos").pw_uid
1744
gid = pwd.getpwnam(u"_mandos").pw_gid
1885
1745
except KeyError:
1886
1746
try:
1887
uid = pwd.getpwnam("mandos").pw_uid
1888
gid = pwd.getpwnam("mandos").pw_gid
1747
uid = pwd.getpwnam(u"mandos").pw_uid
1748
gid = pwd.getpwnam(u"mandos").pw_gid
1889
1749
except KeyError:
1890
1750
try:
1891
uid = pwd.getpwnam("nobody").pw_uid
1892
gid = pwd.getpwnam("nobody").pw_gid
1751
uid = pwd.getpwnam(u"nobody").pw_uid
1752
gid = pwd.getpwnam(u"nobody").pw_gid
1893
1753
except KeyError:
1894
1754
uid = 65534
1895
1755
gid = 65534
1896
1756
try:
1897
1757
os.setgid(gid)
1898
1758
os.setuid(uid)
1899
except OSError as error:
1759
except OSError, error:
1900
1760
if error[0] != errno.EPERM:
1901
1761
raise error
1902
1762
1763
# Enable all possible GnuTLS debugging
1764
1765
1903
1766
if not debug and not debuglevel:
1904
1767
syslogger.setLevel(logging.WARNING)
1905
1768
console.setLevel(logging.WARNING)
1909
1772
console.setLevel(level)
1910
1773
1911
1774
if debug:
1912
# Enable all possible GnuTLS debugging
1913
1914
1775
# "Use a log level over 10 to enable all debugging options."
1915
1776
# - GnuTLS manual
1916
1777
gnutls.library.functions.gnutls_global_set_log_level(11)
1917
1778
1918
1779
@gnutls.library.types.gnutls_log_func
1919
1780
def debug_gnutls(level, string):
1920
logger.debug("GnuTLS: %s", string[:-1])
1781
logger.debug(u"GnuTLS: %s", string[:-1])
1921
1782
1922
1783
(gnutls.library.functions
1923
1784
.gnutls_global_set_log_function(debug_gnutls))
1924
1785
1925
1786
# Redirect stdin so all checkers get /dev/null
1926
1787
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1927
1788
os.dup2(null, sys.stdin.fileno())
1930
1791
else:
1931
1792
# No console logging
1932
1793
logger.removeHandler(console)
1933
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()
1794
1938
1795
1939
1796
global main_loop
1940
1797
# From the Avahi example code
1944
1801
# End of Avahi example code
1945
1802
if use_dbus:
1946
1803
try:
1947
bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",
1804
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
1948
1805
bus, do_not_queue=True)
1949
except dbus.exceptions.NameExistsException as e:
1950
logger.error(unicode(e) + ", disabling D-Bus")
1806
except dbus.exceptions.NameExistsException, e:
1807
logger.error(unicode(e) + u", disabling D-Bus")
1951
1808
use_dbus = False
1952
server_settings["use_dbus"] = False
1809
server_settings[u"use_dbus"] = False
1953
1810
tcp_server.use_dbus = False
1954
1811
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1955
service = AvahiService(name = server_settings["servicename"],
1956
servicetype = "_mandos._tcp",
1812
service = AvahiService(name = server_settings[u"servicename"],
1813
servicetype = u"_mandos._tcp",
1957
1814
protocol = protocol, bus = bus)
1958
1815
if server_settings["interface"]:
1959
1816
service.interface = (if_nametoindex
1960
(str(server_settings["interface"])))
1961
1817
(str(server_settings[u"interface"])))
1818
1819
if not debug:
1820
# Close all input and output, do double fork, etc.
1821
daemon()
1822
1962
1823
global multiprocessing_manager
1963
1824
multiprocessing_manager = multiprocessing.Manager()
1964
1825
1983
1844
client_config, section)))
1984
1845
for section in client_config.sections()))
1985
1846
if not tcp_server.clients:
1986
logger.warning("No clients defined")
1847
logger.warning(u"No clients defined")
1987
1848
1849
try:
1850
with pidfile:
1851
pid = os.getpid()
1852
pidfile.write(str(pid) + "\n")
1853
del pidfile
1854
except IOError:
1855
logger.error(u"Could not write to file %r with PID %d",
1856
pidfilename, pid)
1857
except NameError:
1858
# "pidfile" was never created
1859
pass
1860
del pidfilename
1861
1988
1862
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
1863
signal.signal(signal.SIGINT, signal.SIG_IGN)
2003
2004
1864
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2005
1865
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2006
1866
2008
1868
class MandosDBusService(dbus.service.Object):
2009
1869
"""A D-Bus proxy object"""
2010
1870
def __init__(self):
2011
dbus.service.Object.__init__(self, bus, "/")
2012
_interface = "se.bsnet.fukt.Mandos"
1871
dbus.service.Object.__init__(self, bus, u"/")
1872
_interface = u"se.bsnet.fukt.Mandos"
2013
1873
2014
@dbus.service.signal(_interface, signature="o")
1874
@dbus.service.signal(_interface, signature=u"o")
2015
1875
def ClientAdded(self, objpath):
2016
1876
"D-Bus signal"
2017
1877
pass
2018
1878
2019
@dbus.service.signal(_interface, signature="ss")
1879
@dbus.service.signal(_interface, signature=u"ss")
2020
1880
def ClientNotFound(self, fingerprint, address):
2021
1881
"D-Bus signal"
2022
1882
pass
2023
1883
2024
@dbus.service.signal(_interface, signature="os")
1884
@dbus.service.signal(_interface, signature=u"os")
2025
1885
def ClientRemoved(self, objpath, name):
2026
1886
"D-Bus signal"
2027
1887
pass
2028
1888
2029
@dbus.service.method(_interface, out_signature="ao")
1889
@dbus.service.method(_interface, out_signature=u"ao")
2030
1890
def GetAllClients(self):
2031
1891
"D-Bus method"
2032
1892
return dbus.Array(c.dbus_object_path
2033
1893
for c in tcp_server.clients)
2034
1894
2035
1895
@dbus.service.method(_interface,
2036
out_signature="a{oa{sv}}")
1896
out_signature=u"a{oa{sv}}")
2037
1897
def GetAllClientsWithProperties(self):
2038
1898
"D-Bus method"
2039
1899
return dbus.Dictionary(
2040
((c.dbus_object_path, c.GetAll(""))
1900
((c.dbus_object_path, c.GetAll(u""))
2041
1901
for c in tcp_server.clients),
2042
signature="oa{sv}")
1902
signature=u"oa{sv}")
2043
1903
2044
@dbus.service.method(_interface, in_signature="o")
1904
@dbus.service.method(_interface, in_signature=u"o")
2045
1905
def RemoveClient(self, object_path):
2046
1906
"D-Bus method"
2047
1907
for c in tcp_server.clients:
2089
1949
# Find out what port we got
2090
1950
service.port = tcp_server.socket.getsockname()[1]
2091
1951
if use_ipv6:
2092
logger.info("Now listening on address %r, port %d,"
1952
logger.info(u"Now listening on address %r, port %d,"
2093
1953
" flowinfo %d, scope_id %d"
2094
1954
% tcp_server.socket.getsockname())
2095
1955
else: # IPv4
2096
logger.info("Now listening on address %r, port %d"
1956
logger.info(u"Now listening on address %r, port %d"
2097
1957
% tcp_server.socket.getsockname())
2098
1958
2099
1959
#service.interface = tcp_server.socket.getsockname()[3]
2102
1962
# From the Avahi example code
2103
1963
try:
2104
1964
service.activate()
2105
except dbus.exceptions.DBusException as error:
2106
logger.critical("DBusException: %s", error)
1965
except dbus.exceptions.DBusException, error:
1966
logger.critical(u"DBusException: %s", error)
2107
1967
cleanup()
2108
1968
sys.exit(1)
2109
1969
# End of Avahi example code
2113
1973
(tcp_server.handle_request
2114
1974
(*args[2:], **kwargs) or True))
2115
1975
2116
logger.debug("Starting main loop")
1976
logger.debug(u"Starting main loop")
2117
1977
main_loop.run()
2118
except AvahiError as error:
2119
logger.critical("AvahiError: %s", error)
1978
except AvahiError, error:
1979
logger.critical(u"AvahiError: %s", error)
2120
1980
cleanup()
2121
1981
sys.exit(1)
2122
1982
except KeyboardInterrupt:
2123
1983
if debug:
2124
print("", file=sys.stderr)
2125
logger.debug("Server received KeyboardInterrupt")
2126
logger.debug("Server exiting")
1984
print >> sys.stderr
1985
logger.debug(u"Server received KeyboardInterrupt")
1986
logger.debug(u"Server exiting")
2127
1987
# Must run before the D-Bus bus name gets deregistered
2128
1988
cleanup()
2129
1989
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0