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