88
78
except ImportError:
89
79
SO_BINDTODEVICE = None
92
stored_state_file = "clients.pickle"
94
logger = logging.getLogger()
98
if_nametoindex = (ctypes.cdll.LoadLibrary
99
(ctypes.util.find_library("c"))
101
except (OSError, AttributeError):
102
def if_nametoindex(interface):
103
"Get an interface index the hard way, i.e. using fcntl()"
104
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
105
with contextlib.closing(socket.socket()) as s:
106
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
107
struct.pack(str("16s16x"),
109
interface_index = struct.unpack(str("I"),
111
return interface_index
114
def initlogger(debug, level=logging.WARNING):
115
"""init logger and add loglevel"""
117
syslogger = (logging.handlers.SysLogHandler
119
logging.handlers.SysLogHandler.LOG_DAEMON,
120
address = str("/dev/log")))
121
syslogger.setFormatter(logging.Formatter
122
('Mandos [%(process)d]: %(levelname)s:'
124
logger.addHandler(syslogger)
127
console = logging.StreamHandler()
128
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
132
logger.addHandler(console)
133
logger.setLevel(level)
136
class PGPError(Exception):
137
"""Exception if encryption/decryption fails"""
141
class PGPEngine(object):
142
"""A simple class for OpenPGP symmetric encryption & decryption"""
144
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
145
self.gnupgargs = ['--batch',
146
'--home', self.tempdir,
154
def __exit__(self, exc_type, exc_value, traceback):
162
if self.tempdir is not None:
163
# Delete contents of tempdir
164
for root, dirs, files in os.walk(self.tempdir,
166
for filename in files:
167
os.remove(os.path.join(root, filename))
169
os.rmdir(os.path.join(root, dirname))
171
os.rmdir(self.tempdir)
174
def password_encode(self, password):
175
# Passphrase can not be empty and can not contain newlines or
176
# NUL bytes. So we prefix it and hex encode it.
177
encoded = b"mandos" + binascii.hexlify(password)
178
if len(encoded) > 2048:
179
# GnuPG can't handle long passwords, so encode differently
180
encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
181
.replace(b"\n", b"\\n")
182
.replace(b"\0", b"\\x00"))
185
def encrypt(self, data, password):
186
passphrase = self.password_encode(password)
187
with tempfile.NamedTemporaryFile(dir=self.tempdir
189
passfile.write(passphrase)
191
proc = subprocess.Popen(['gpg', '--symmetric',
195
stdin = subprocess.PIPE,
196
stdout = subprocess.PIPE,
197
stderr = subprocess.PIPE)
198
ciphertext, err = proc.communicate(input = data)
199
if proc.returncode != 0:
203
def decrypt(self, data, password):
204
passphrase = self.password_encode(password)
205
with tempfile.NamedTemporaryFile(dir = self.tempdir
207
passfile.write(passphrase)
209
proc = subprocess.Popen(['gpg', '--decrypt',
213
stdin = subprocess.PIPE,
214
stdout = subprocess.PIPE,
215
stderr = subprocess.PIPE)
216
decrypted_plaintext, err = proc.communicate(input
218
if proc.returncode != 0:
220
return decrypted_plaintext
84
logger = logging.Logger(u'mandos')
85
syslogger = (logging.handlers.SysLogHandler
86
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
87
address = "/dev/log"))
88
syslogger.setFormatter(logging.Formatter
89
(u'Mandos [%(process)d]: %(levelname)s:'
91
logger.addHandler(syslogger)
93
console = logging.StreamHandler()
94
console.setFormatter(logging.Formatter(u'%(name)s [%(process)d]:'
97
logger.addHandler(console)
223
99
class AvahiError(Exception):
224
100
def __init__(self, value, *args, **kwargs):
324
189
dbus.UInt16(self.port),
325
190
avahi.string_array_to_txt_array(self.TXT))
326
191
self.group.Commit()
328
192
def entry_group_state_changed(self, state, error):
329
193
"""Derived from the Avahi example code"""
330
logger.debug("Avahi entry group state change: %i", state)
194
logger.debug(u"Avahi state change: %i", state)
332
196
if state == avahi.ENTRY_GROUP_ESTABLISHED:
333
logger.debug("Zeroconf service established.")
197
logger.debug(u"Zeroconf service established.")
334
198
elif state == avahi.ENTRY_GROUP_COLLISION:
335
logger.info("Zeroconf service name collision.")
199
logger.warning(u"Zeroconf service name collision.")
337
201
elif state == avahi.ENTRY_GROUP_FAILURE:
338
logger.critical("Avahi: Error in group state changed %s",
202
logger.critical(u"Avahi: Error in group state changed %s",
340
raise AvahiGroupError("State changed: {0!s}"
204
raise AvahiGroupError(u"State changed: %s"
343
206
def cleanup(self):
344
207
"""Derived from the Avahi example code"""
345
208
if self.group is not None:
348
except (dbus.exceptions.UnknownMethodException,
349
dbus.exceptions.DBusException):
351
210
self.group = None
354
def server_state_changed(self, state, error=None):
211
def server_state_changed(self, state):
355
212
"""Derived from the Avahi example code"""
356
logger.debug("Avahi server state change: %i", state)
357
bad_states = { avahi.SERVER_INVALID:
358
"Zeroconf server invalid",
359
avahi.SERVER_REGISTERING: None,
360
avahi.SERVER_COLLISION:
361
"Zeroconf server name collision",
362
avahi.SERVER_FAILURE:
363
"Zeroconf server failure" }
364
if state in bad_states:
365
if bad_states[state] is not None:
367
logger.error(bad_states[state])
369
logger.error(bad_states[state] + ": %r", error)
213
if state == avahi.SERVER_COLLISION:
214
logger.error(u"Zeroconf server name collision")
371
216
elif state == avahi.SERVER_RUNNING:
375
logger.debug("Unknown state: %r", state)
377
logger.debug("Unknown state: %r: %r", state, error)
379
218
def activate(self):
380
219
"""Derived from the Avahi example code"""
381
220
if self.server is None:
382
221
self.server = dbus.Interface(
383
222
self.bus.get_object(avahi.DBUS_NAME,
384
avahi.DBUS_PATH_SERVER,
385
follow_name_owner_changes=True),
223
avahi.DBUS_PATH_SERVER),
386
224
avahi.DBUS_INTERFACE_SERVER)
387
self.server.connect_to_signal("StateChanged",
225
self.server.connect_to_signal(u"StateChanged",
388
226
self.server_state_changed)
389
227
self.server_state_changed(self.server.GetState())
392
class AvahiServiceToSyslog(AvahiService):
394
"""Add the new name to the syslog messages"""
395
ret = AvahiService.rename(self)
396
syslogger.setFormatter(logging.Formatter
397
('Mandos ({0}) [%(process)d]:'
398
' %(levelname)s: %(message)s'
403
def timedelta_to_milliseconds(td):
404
"Convert a datetime.timedelta() to milliseconds"
405
return ((td.days * 24 * 60 * 60 * 1000)
406
+ (td.seconds * 1000)
407
+ (td.microseconds // 1000))
410
230
class Client(object):
411
231
"""A representation of a client host served by this server.
414
approved: bool(); 'None' if not yet approved/disapproved
415
approval_delay: datetime.timedelta(); Time to wait for approval
416
approval_duration: datetime.timedelta(); Duration of one approval
234
name: string; from the config file, used in log messages and
236
fingerprint: string (40 or 32 hexadecimal digits); used to
237
uniquely identify the client
238
secret: bytestring; sent verbatim (over TLS) to client
239
host: string; available for use by the checker command
240
created: datetime.datetime(); (UTC) object creation
241
last_enabled: datetime.datetime(); (UTC)
243
last_checked_ok: datetime.datetime(); (UTC) or None
244
timeout: datetime.timedelta(); How long from last_checked_ok
245
until this client is invalid
246
interval: datetime.timedelta(); How often to start a new checker
247
disable_hook: If set, called by disable() as disable_hook(self)
417
248
checker: subprocess.Popen(); a running checker process used
418
249
to see if the client lives.
419
250
'None' if no process is running.
420
checker_callback_tag: a gobject event source tag, or None
421
checker_command: string; External command which is run to check
422
if client lives. %() expansions are done at
251
checker_initiator_tag: a gobject event source tag, or None
252
disable_initiator_tag: - '' -
253
checker_callback_tag: - '' -
254
checker_command: string; External command which is run to check if
255
client lives. %() expansions are done at
423
256
runtime with vars(self) as dict, so that for
424
257
instance %(name)s can be used in the command.
425
checker_initiator_tag: a gobject event source tag, or None
426
created: datetime.datetime(); (UTC) object creation
427
client_structure: Object describing what attributes a client has
428
and is used for storing the client at exit
429
258
current_checker_command: string; current running checker_command
430
disable_initiator_tag: a gobject event source tag, or None
432
fingerprint: string (40 or 32 hexadecimal digits); used to
433
uniquely identify the client
434
host: string; available for use by the checker command
435
interval: datetime.timedelta(); How often to start a new checker
436
last_approval_request: datetime.datetime(); (UTC) or None
437
last_checked_ok: datetime.datetime(); (UTC) or None
438
last_checker_status: integer between 0 and 255 reflecting exit
439
status of last checker. -1 reflects crashed
440
checker, -2 means no checker completed yet.
441
last_enabled: datetime.datetime(); (UTC) or None
442
name: string; from the config file, used in log messages and
444
secret: bytestring; sent verbatim (over TLS) to client
445
timeout: datetime.timedelta(); How long from last_checked_ok
446
until this client is disabled
447
extended_timeout: extra long timeout when secret has been sent
448
runtime_expansions: Allowed attributes for runtime expansion.
449
expires: datetime.datetime(); time (UTC) when a client will be
451
server_settings: The server_settings dict from main()
454
runtime_expansions = ("approval_delay", "approval_duration",
455
"created", "enabled", "expires",
456
"fingerprint", "host", "interval",
457
"last_approval_request", "last_checked_ok",
458
"last_enabled", "name", "timeout")
459
client_defaults = { "timeout": "PT5M",
460
"extended_timeout": "PT15M",
462
"checker": "fping -q -- %%(host)s",
464
"approval_delay": "PT0S",
465
"approval_duration": "PT1S",
466
"approved_by_default": "True",
262
def _timedelta_to_milliseconds(td):
263
"Convert a datetime.timedelta() to milliseconds"
264
return ((td.days * 24 * 60 * 60 * 1000)
265
+ (td.seconds * 1000)
266
+ (td.microseconds // 1000))
470
268
def timeout_milliseconds(self):
471
269
"Return the 'timeout' attribute in milliseconds"
472
return timedelta_to_milliseconds(self.timeout)
474
def extended_timeout_milliseconds(self):
475
"Return the 'extended_timeout' attribute in milliseconds"
476
return timedelta_to_milliseconds(self.extended_timeout)
270
return self._timedelta_to_milliseconds(self.timeout)
478
272
def interval_milliseconds(self):
479
273
"Return the 'interval' attribute in milliseconds"
480
return timedelta_to_milliseconds(self.interval)
482
def approval_delay_milliseconds(self):
483
return timedelta_to_milliseconds(self.approval_delay)
486
def config_parser(config):
487
"""Construct a new dict of client settings of this form:
488
{ client_name: {setting_name: value, ...}, ...}
489
with exceptions for any special settings as defined above.
490
NOTE: Must be a pure function. Must return the same result
491
value given the same arguments.
494
for client_name in config.sections():
495
section = dict(config.items(client_name))
496
client = settings[client_name] = {}
498
client["host"] = section["host"]
499
# Reformat values from string types to Python types
500
client["approved_by_default"] = config.getboolean(
501
client_name, "approved_by_default")
502
client["enabled"] = config.getboolean(client_name,
505
client["fingerprint"] = (section["fingerprint"].upper()
507
if "secret" in section:
508
client["secret"] = section["secret"].decode("base64")
509
elif "secfile" in section:
510
with open(os.path.expanduser(os.path.expandvars
511
(section["secfile"])),
513
client["secret"] = secfile.read()
515
raise TypeError("No secret or secfile for section {0}"
517
client["timeout"] = string_to_delta(section["timeout"])
518
client["extended_timeout"] = string_to_delta(
519
section["extended_timeout"])
520
client["interval"] = string_to_delta(section["interval"])
521
client["approval_delay"] = string_to_delta(
522
section["approval_delay"])
523
client["approval_duration"] = string_to_delta(
524
section["approval_duration"])
525
client["checker_command"] = section["checker"]
526
client["last_approval_request"] = None
527
client["last_checked_ok"] = None
528
client["last_checker_status"] = -2
532
def __init__(self, settings, name = None, server_settings=None):
274
return self._timedelta_to_milliseconds(self.interval)
276
def __init__(self, name = None, disable_hook=None, config=None):
277
"""Note: the 'checker' key in 'config' sets the
278
'checker_command' attribute and *not* the 'checker'
534
if server_settings is None:
536
self.server_settings = server_settings
537
# adding all client settings
538
for setting, value in settings.iteritems():
539
setattr(self, setting, value)
542
if not hasattr(self, "last_enabled"):
543
self.last_enabled = datetime.datetime.utcnow()
544
if not hasattr(self, "expires"):
545
self.expires = (datetime.datetime.utcnow()
548
self.last_enabled = None
551
logger.debug("Creating client %r", self.name)
283
logger.debug(u"Creating client %r", self.name)
552
284
# Uppercase and remove spaces from fingerprint for later
553
285
# comparison purposes with return value from the fingerprint()
555
logger.debug(" Fingerprint: %s", self.fingerprint)
556
self.created = settings.get("created",
557
datetime.datetime.utcnow())
559
# attributes specific for this server instance
287
self.fingerprint = (config[u"fingerprint"].upper()
289
logger.debug(u" Fingerprint: %s", self.fingerprint)
290
if u"secret" in config:
291
self.secret = config[u"secret"].decode(u"base64")
292
elif u"secfile" in config:
293
with closing(open(os.path.expanduser
295
(config[u"secfile"])),
297
self.secret = secfile.read()
299
raise TypeError(u"No secret or secfile for client %s"
301
self.host = config.get(u"host", u"")
302
self.created = datetime.datetime.utcnow()
304
self.last_enabled = None
305
self.last_checked_ok = None
306
self.timeout = string_to_delta(config[u"timeout"])
307
self.interval = string_to_delta(config[u"interval"])
308
self.disable_hook = disable_hook
560
309
self.checker = None
561
310
self.checker_initiator_tag = None
562
311
self.disable_initiator_tag = None
563
312
self.checker_callback_tag = None
313
self.checker_command = config[u"checker"]
564
314
self.current_checker_command = None
566
self.approvals_pending = 0
567
self.changedstate = (multiprocessing_manager
568
.Condition(multiprocessing_manager
570
self.client_structure = [attr for attr in
571
self.__dict__.iterkeys()
572
if not attr.startswith("_")]
573
self.client_structure.append("client_structure")
575
for name, t in inspect.getmembers(type(self),
579
if not name.startswith("_"):
580
self.client_structure.append(name)
582
# Send notice to process children that client state has changed
583
def send_changedstate(self):
584
with self.changedstate:
585
self.changedstate.notify_all()
315
self.last_connect = None
587
317
def enable(self):
588
318
"""Start this client's checker and timeout hooks"""
589
if getattr(self, "enabled", False):
319
if getattr(self, u"enabled", False):
590
320
# Already enabled
592
self.expires = datetime.datetime.utcnow() + self.timeout
594
322
self.last_enabled = datetime.datetime.utcnow()
596
self.send_changedstate()
598
def disable(self, quiet=True):
599
"""Disable this client."""
600
if not getattr(self, "enabled", False):
603
logger.info("Disabling client %s", self.name)
604
if getattr(self, "disable_initiator_tag", None) is not None:
605
gobject.source_remove(self.disable_initiator_tag)
606
self.disable_initiator_tag = None
608
if getattr(self, "checker_initiator_tag", None) is not None:
609
gobject.source_remove(self.checker_initiator_tag)
610
self.checker_initiator_tag = None
614
self.send_changedstate()
615
# Do not run this again if called by a gobject.timeout_add
621
def init_checker(self):
622
323
# Schedule a new checker to be started an 'interval' from now,
623
324
# and every interval from then on.
624
if self.checker_initiator_tag is not None:
625
gobject.source_remove(self.checker_initiator_tag)
626
325
self.checker_initiator_tag = (gobject.timeout_add
627
326
(self.interval_milliseconds(),
628
327
self.start_checker))
328
# Also start a new checker *right now*.
629
330
# Schedule a disable() when 'timeout' has passed
630
if self.disable_initiator_tag is not None:
631
gobject.source_remove(self.disable_initiator_tag)
632
331
self.disable_initiator_tag = (gobject.timeout_add
633
332
(self.timeout_milliseconds(),
635
# Also start a new checker *right now*.
337
"""Disable this client."""
338
if not getattr(self, "enabled", False):
340
logger.info(u"Disabling client %s", self.name)
341
if getattr(self, u"disable_initiator_tag", False):
342
gobject.source_remove(self.disable_initiator_tag)
343
self.disable_initiator_tag = None
344
if getattr(self, u"checker_initiator_tag", False):
345
gobject.source_remove(self.checker_initiator_tag)
346
self.checker_initiator_tag = None
348
if self.disable_hook:
349
self.disable_hook(self)
351
# Do not run this again if called by a gobject.timeout_add
355
self.disable_hook = None
638
358
def checker_callback(self, pid, condition, command):
639
359
"""The checker has completed, so take appropriate actions."""
640
360
self.checker_callback_tag = None
641
361
self.checker = None
642
362
if os.WIFEXITED(condition):
643
self.last_checker_status = os.WEXITSTATUS(condition)
644
if self.last_checker_status == 0:
645
logger.info("Checker for %(name)s succeeded",
363
exitstatus = os.WEXITSTATUS(condition)
365
logger.info(u"Checker for %(name)s succeeded",
647
367
self.checked_ok()
649
logger.info("Checker for %(name)s failed",
369
logger.info(u"Checker for %(name)s failed",
652
self.last_checker_status = -1
653
logger.warning("Checker for %(name)s crashed?",
372
logger.warning(u"Checker for %(name)s crashed?",
656
375
def checked_ok(self):
657
"""Assert that the client has been seen, alive and well."""
376
"""Bump up the timeout for this client.
378
This should only be called when the client has been seen,
658
381
self.last_checked_ok = datetime.datetime.utcnow()
659
self.last_checker_status = 0
662
def bump_timeout(self, timeout=None):
663
"""Bump up the timeout for this client."""
665
timeout = self.timeout
666
if self.disable_initiator_tag is not None:
667
gobject.source_remove(self.disable_initiator_tag)
668
self.disable_initiator_tag = None
669
if getattr(self, "enabled", False):
670
self.disable_initiator_tag = (gobject.timeout_add
671
(timedelta_to_milliseconds
672
(timeout), self.disable))
673
self.expires = datetime.datetime.utcnow() + timeout
675
def need_approval(self):
676
self.last_approval_request = datetime.datetime.utcnow()
382
gobject.source_remove(self.disable_initiator_tag)
383
self.disable_initiator_tag = (gobject.timeout_add
384
(self.timeout_milliseconds(),
678
387
def start_checker(self):
679
388
"""Start a new checker subprocess if one is not running.
681
390
If a checker already exists, leave it running and do
683
392
# The reason for not killing a running checker is that if we
684
# did that, and if a checker (for some reason) started running
685
# slowly and taking more than 'interval' time, then the client
686
# would inevitably timeout, since no checker would get a
687
# chance to run to completion. If we instead leave running
393
# did that, then if a checker (for some reason) started
394
# running slowly and taking more than 'interval' time, the
395
# client would inevitably timeout, since no checker would get
396
# a chance to run to completion. If we instead leave running
688
397
# checkers alone, the checker would have to take more time
689
# than 'timeout' for the client to be disabled, which is as it
398
# than 'timeout' for the client to be declared invalid, which
399
# is as it should be.
692
401
# If a checker exists, make sure it is not a zombie
694
403
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
695
except AttributeError:
697
except OSError as error:
698
if error.errno != errno.ECHILD:
404
except (AttributeError, OSError), error:
405
if (isinstance(error, OSError)
406
and error.errno != errno.ECHILD):
702
logger.warning("Checker was a zombie")
410
logger.warning(u"Checker was a zombie")
703
411
gobject.source_remove(self.checker_callback_tag)
704
412
self.checker_callback(pid, status,
705
413
self.current_checker_command)
706
414
# Start a new checker if needed
707
415
if self.checker is None:
708
# Escape attributes for the shell
709
escaped_attrs = dict(
710
(attr, re.escape(unicode(getattr(self, attr))))
712
self.runtime_expansions)
714
command = self.checker_command % escaped_attrs
715
except TypeError as error:
716
logger.error('Could not format string "%s"',
717
self.checker_command, exc_info=error)
718
return True # Try again later
417
# In case checker_command has exactly one % operator
418
command = self.checker_command % self.host
420
# Escape attributes for the shell
421
escaped_attrs = dict((key,
422
re.escape(unicode(str(val),
426
vars(self).iteritems())
428
command = self.checker_command % escaped_attrs
429
except TypeError, error:
430
logger.error(u'Could not format string "%s":'
431
u' %s', self.checker_command, error)
432
return True # Try again later
719
433
self.current_checker_command = command
721
logger.info("Starting checker %r for %s",
435
logger.info(u"Starting checker %r for %s",
722
436
command, self.name)
723
437
# We don't need to redirect stdout and stderr, since
724
438
# in normal mode, that is already done by daemon(),
725
439
# and in debug mode we don't want to. (Stdin is
726
440
# always replaced by /dev/null.)
727
# The exception is when not debugging but nevertheless
728
# running in the foreground; use the previously
731
if (not self.server_settings["debug"]
732
and self.server_settings["foreground"]):
733
popen_args.update({"stdout": wnull,
735
441
self.checker = subprocess.Popen(command,
739
except OSError as error:
740
logger.error("Failed to start subprocess",
743
self.checker_callback_tag = (gobject.child_watch_add
745
self.checker_callback,
747
# The checker may have completed before the gobject
748
# watch was added. Check for this.
443
shell=True, cwd=u"/")
444
self.checker_callback_tag = (gobject.child_watch_add
446
self.checker_callback,
448
# The checker may have completed before the gobject
449
# watch was added. Check for this.
750
450
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
751
except OSError as error:
752
if error.errno == errno.ECHILD:
753
# This should never happen
754
logger.error("Child process vanished",
759
gobject.source_remove(self.checker_callback_tag)
760
self.checker_callback(pid, status, command)
452
gobject.source_remove(self.checker_callback_tag)
453
self.checker_callback(pid, status, command)
454
except OSError, error:
455
logger.error(u"Failed to start subprocess: %s",
761
457
# Re-run this periodically if run by gobject.timeout_add
869
533
class DBusObjectWithProperties(dbus.service.Object):
870
534
"""A D-Bus object with properties.
872
536
Classes inheriting from this can use the dbus_service_property
873
537
decorator to expose methods as D-Bus properties. It exposes the
874
538
standard Get(), Set(), and GetAll() methods on the D-Bus.
878
def _is_dbus_thing(thing):
879
"""Returns a function testing if an attribute is a D-Bus thing
881
If called like _is_dbus_thing("method") it returns a function
882
suitable for use as predicate to inspect.getmembers().
884
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
542
def _is_dbus_property(obj):
543
return getattr(obj, u"_dbus_is_property", False)
887
def _get_all_dbus_things(self, thing):
545
def _get_all_dbus_properties(self):
888
546
"""Returns a generator of (name, attribute) pairs
890
return ((getattr(athing.__get__(self), "_dbus_name",
892
athing.__get__(self))
893
for cls in self.__class__.__mro__
895
inspect.getmembers(cls,
896
self._is_dbus_thing(thing)))
548
return ((prop._dbus_name, prop)
550
inspect.getmembers(self, self._is_dbus_property))
898
552
def _get_dbus_property(self, interface_name, property_name):
899
553
"""Returns a bound method if one exists which is a D-Bus
900
554
property with the specified name and interface.
902
for cls in self.__class__.__mro__:
903
for name, value in (inspect.getmembers
905
self._is_dbus_thing("property"))):
906
if (value._dbus_name == property_name
907
and value._dbus_interface == interface_name):
908
return value.__get__(self)
556
for name in (property_name,
557
property_name + u"_dbus_property"):
558
prop = getattr(self, name, None)
560
or not self._is_dbus_property(prop)
561
or prop._dbus_name != property_name
562
or (interface_name and prop._dbus_interface
563
and interface_name != prop._dbus_interface)):
910
566
# No such property
911
raise DBusPropertyNotFound(self.dbus_object_path + ":"
912
+ interface_name + "."
567
raise DBusPropertyNotFound(self.dbus_object_path + u":"
568
+ interface_name + u"."
915
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
571
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
917
573
def Get(self, interface_name, property_name):
918
574
"""Standard D-Bus property Get() method, see D-Bus standard.
920
576
prop = self._get_dbus_property(interface_name, property_name)
921
if prop._dbus_access == "write":
577
if prop._dbus_access == u"write":
922
578
raise DBusPropertyAccessException(property_name)
924
if not hasattr(value, "variant_level"):
580
if not hasattr(value, u"variant_level"):
926
582
return type(value)(value, variant_level=value.variant_level+1)
928
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
584
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
929
585
def Set(self, interface_name, property_name, value):
930
586
"""Standard D-Bus property Set() method, see D-Bus standard.
932
588
prop = self._get_dbus_property(interface_name, property_name)
933
if prop._dbus_access == "read":
589
if prop._dbus_access == u"read":
934
590
raise DBusPropertyAccessException(property_name)
935
if prop._dbus_get_args_options["byte_arrays"]:
936
# The byte_arrays option is not supported yet on
937
# signatures other than "ay".
938
if prop._dbus_signature != "ay":
939
raise ValueError("Byte arrays not supported for non-"
940
"'ay' signature {0!r}"
941
.format(prop._dbus_signature))
942
value = dbus.ByteArray(b''.join(chr(byte)
591
if prop._dbus_get_args_options[u"byte_arrays"]:
592
value = dbus.ByteArray(''.join(unichr(byte)
946
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
947
out_signature="a{sv}")
596
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
597
out_signature=u"a{sv}")
948
598
def GetAll(self, interface_name):
949
599
"""Standard D-Bus property GetAll() method, see D-Bus
952
602
Note: Will not include properties with access="write".
955
for name, prop in self._get_all_dbus_things("property"):
605
for name, prop in self._get_all_dbus_properties():
956
606
if (interface_name
957
607
and interface_name != prop._dbus_interface):
958
608
# Interface non-empty but did not match
960
610
# Ignore write-only properties
961
if prop._dbus_access == "write":
611
if prop._dbus_access == u"write":
964
if not hasattr(value, "variant_level"):
965
properties[name] = value
614
if not hasattr(value, u"variant_level"):
967
properties[name] = type(value)(value, variant_level=
968
value.variant_level+1)
969
return dbus.Dictionary(properties, signature="sv")
617
all[name] = type(value)(value, variant_level=
618
value.variant_level+1)
619
return dbus.Dictionary(all, signature=u"sv")
971
621
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
973
623
path_keyword='object_path',
974
624
connection_keyword='connection')
975
625
def Introspect(self, object_path, connection):
976
"""Overloading of standard D-Bus method.
978
Inserts property tags and interface annotation tags.
626
"""Standard D-Bus method, overloaded to insert property tags.
980
628
xmlstring = dbus.service.Object.Introspect(self, object_path,
983
631
document = xml.dom.minidom.parseString(xmlstring)
984
632
def make_tag(document, name, prop):
985
e = document.createElement("property")
986
e.setAttribute("name", name)
987
e.setAttribute("type", prop._dbus_signature)
988
e.setAttribute("access", prop._dbus_access)
633
e = document.createElement(u"property")
634
e.setAttribute(u"name", name)
635
e.setAttribute(u"type", prop._dbus_signature)
636
e.setAttribute(u"access", prop._dbus_access)
990
for if_tag in document.getElementsByTagName("interface"):
638
for if_tag in document.getElementsByTagName(u"interface"):
992
639
for tag in (make_tag(document, name, prop)
994
in self._get_all_dbus_things("property")
641
in self._get_all_dbus_properties()
995
642
if prop._dbus_interface
996
== if_tag.getAttribute("name")):
643
== if_tag.getAttribute(u"name")):
997
644
if_tag.appendChild(tag)
998
# Add annotation tags
999
for typ in ("method", "signal", "property"):
1000
for tag in if_tag.getElementsByTagName(typ):
1002
for name, prop in (self.
1003
_get_all_dbus_things(typ)):
1004
if (name == tag.getAttribute("name")
1005
and prop._dbus_interface
1006
== if_tag.getAttribute("name")):
1007
annots.update(getattr
1009
"_dbus_annotations",
1011
for name, value in annots.iteritems():
1012
ann_tag = document.createElement(
1014
ann_tag.setAttribute("name", name)
1015
ann_tag.setAttribute("value", value)
1016
tag.appendChild(ann_tag)
1017
# Add interface annotation tags
1018
for annotation, value in dict(
1019
itertools.chain.from_iterable(
1020
annotations().iteritems()
1021
for name, annotations in
1022
self._get_all_dbus_things("interface")
1023
if name == if_tag.getAttribute("name")
1025
ann_tag = document.createElement("annotation")
1026
ann_tag.setAttribute("name", annotation)
1027
ann_tag.setAttribute("value", value)
1028
if_tag.appendChild(ann_tag)
1029
645
# Add the names to the return values for the
1030
646
# "org.freedesktop.DBus.Properties" methods
1031
if (if_tag.getAttribute("name")
1032
== "org.freedesktop.DBus.Properties"):
1033
for cn in if_tag.getElementsByTagName("method"):
1034
if cn.getAttribute("name") == "Get":
1035
for arg in cn.getElementsByTagName("arg"):
1036
if (arg.getAttribute("direction")
1038
arg.setAttribute("name", "value")
1039
elif cn.getAttribute("name") == "GetAll":
1040
for arg in cn.getElementsByTagName("arg"):
1041
if (arg.getAttribute("direction")
1043
arg.setAttribute("name", "props")
1044
xmlstring = document.toxml("utf-8")
647
if (if_tag.getAttribute(u"name")
648
== u"org.freedesktop.DBus.Properties"):
649
for cn in if_tag.getElementsByTagName(u"method"):
650
if cn.getAttribute(u"name") == u"Get":
651
for arg in cn.getElementsByTagName(u"arg"):
652
if (arg.getAttribute(u"direction")
654
arg.setAttribute(u"name", u"value")
655
elif cn.getAttribute(u"name") == u"GetAll":
656
for arg in cn.getElementsByTagName(u"arg"):
657
if (arg.getAttribute(u"direction")
659
arg.setAttribute(u"name", u"props")
660
xmlstring = document.toxml(u"utf-8")
1045
661
document.unlink()
1046
662
except (AttributeError, xml.dom.DOMException,
1047
xml.parsers.expat.ExpatError) as error:
1048
logger.error("Failed to override Introspection method",
663
xml.parsers.expat.ExpatError), error:
664
logger.error(u"Failed to override Introspection method",
1050
666
return xmlstring
1053
def datetime_to_dbus(dt, variant_level=0):
1054
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1056
return dbus.String("", variant_level = variant_level)
1057
return dbus.String(dt.isoformat(),
1058
variant_level=variant_level)
1061
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1062
"""A class decorator; applied to a subclass of
1063
dbus.service.Object, it will add alternate D-Bus attributes with
1064
interface names according to the "alt_interface_names" mapping.
1067
@alternate_dbus_interfaces({"org.example.Interface":
1068
"net.example.AlternateInterface"})
1069
class SampleDBusObject(dbus.service.Object):
1070
@dbus.service.method("org.example.Interface")
1071
def SampleDBusMethod():
1074
The above "SampleDBusMethod" on "SampleDBusObject" will be
1075
reachable via two interfaces: "org.example.Interface" and
1076
"net.example.AlternateInterface", the latter of which will have
1077
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1078
"true", unless "deprecate" is passed with a False value.
1080
This works for methods and signals, and also for D-Bus properties
1081
(from DBusObjectWithProperties) and interfaces (from the
1082
dbus_interface_annotations decorator).
1085
for orig_interface_name, alt_interface_name in (
1086
alt_interface_names.iteritems()):
1088
interface_names = set()
1089
# Go though all attributes of the class
1090
for attrname, attribute in inspect.getmembers(cls):
1091
# Ignore non-D-Bus attributes, and D-Bus attributes
1092
# with the wrong interface name
1093
if (not hasattr(attribute, "_dbus_interface")
1094
or not attribute._dbus_interface
1095
.startswith(orig_interface_name)):
1097
# Create an alternate D-Bus interface name based on
1099
alt_interface = (attribute._dbus_interface
1100
.replace(orig_interface_name,
1101
alt_interface_name))
1102
interface_names.add(alt_interface)
1103
# Is this a D-Bus signal?
1104
if getattr(attribute, "_dbus_is_signal", False):
1105
# Extract the original non-method undecorated
1106
# function by black magic
1107
nonmethod_func = (dict(
1108
zip(attribute.func_code.co_freevars,
1109
attribute.__closure__))["func"]
1111
# Create a new, but exactly alike, function
1112
# object, and decorate it to be a new D-Bus signal
1113
# with the alternate D-Bus interface name
1114
new_function = (dbus.service.signal
1116
attribute._dbus_signature)
1117
(types.FunctionType(
1118
nonmethod_func.func_code,
1119
nonmethod_func.func_globals,
1120
nonmethod_func.func_name,
1121
nonmethod_func.func_defaults,
1122
nonmethod_func.func_closure)))
1123
# Copy annotations, if any
1125
new_function._dbus_annotations = (
1126
dict(attribute._dbus_annotations))
1127
except AttributeError:
1129
# Define a creator of a function to call both the
1130
# original and alternate functions, so both the
1131
# original and alternate signals gets sent when
1132
# the function is called
1133
def fixscope(func1, func2):
1134
"""This function is a scope container to pass
1135
func1 and func2 to the "call_both" function
1136
outside of its arguments"""
1137
def call_both(*args, **kwargs):
1138
"""This function will emit two D-Bus
1139
signals by calling func1 and func2"""
1140
func1(*args, **kwargs)
1141
func2(*args, **kwargs)
1143
# Create the "call_both" function and add it to
1145
attr[attrname] = fixscope(attribute, new_function)
1146
# Is this a D-Bus method?
1147
elif getattr(attribute, "_dbus_is_method", False):
1148
# Create a new, but exactly alike, function
1149
# object. Decorate it to be a new D-Bus method
1150
# with the alternate D-Bus interface name. Add it
1152
attr[attrname] = (dbus.service.method
1154
attribute._dbus_in_signature,
1155
attribute._dbus_out_signature)
1157
(attribute.func_code,
1158
attribute.func_globals,
1159
attribute.func_name,
1160
attribute.func_defaults,
1161
attribute.func_closure)))
1162
# Copy annotations, if any
1164
attr[attrname]._dbus_annotations = (
1165
dict(attribute._dbus_annotations))
1166
except AttributeError:
1168
# Is this a D-Bus property?
1169
elif getattr(attribute, "_dbus_is_property", False):
1170
# Create a new, but exactly alike, function
1171
# object, and decorate it to be a new D-Bus
1172
# property with the alternate D-Bus interface
1173
# name. Add it to the class.
1174
attr[attrname] = (dbus_service_property
1176
attribute._dbus_signature,
1177
attribute._dbus_access,
1179
._dbus_get_args_options
1182
(attribute.func_code,
1183
attribute.func_globals,
1184
attribute.func_name,
1185
attribute.func_defaults,
1186
attribute.func_closure)))
1187
# Copy annotations, if any
1189
attr[attrname]._dbus_annotations = (
1190
dict(attribute._dbus_annotations))
1191
except AttributeError:
1193
# Is this a D-Bus interface?
1194
elif getattr(attribute, "_dbus_is_interface", False):
1195
# Create a new, but exactly alike, function
1196
# object. Decorate it to be a new D-Bus interface
1197
# with the alternate D-Bus interface name. Add it
1199
attr[attrname] = (dbus_interface_annotations
1202
(attribute.func_code,
1203
attribute.func_globals,
1204
attribute.func_name,
1205
attribute.func_defaults,
1206
attribute.func_closure)))
1208
# Deprecate all alternate interfaces
1209
iname="_AlternateDBusNames_interface_annotation{0}"
1210
for interface_name in interface_names:
1211
@dbus_interface_annotations(interface_name)
1213
return { "org.freedesktop.DBus.Deprecated":
1215
# Find an unused name
1216
for aname in (iname.format(i)
1217
for i in itertools.count()):
1218
if aname not in attr:
1222
# Replace the class with a new subclass of it with
1223
# methods, signals, etc. as created above.
1224
cls = type(b"{0}Alternate".format(cls.__name__),
1230
@alternate_dbus_interfaces({"se.recompile.Mandos":
1231
"se.bsnet.fukt.Mandos"})
1232
669
class ClientDBus(Client, DBusObjectWithProperties):
1233
670
"""A Client class using D-Bus
1247
680
Client.__init__(self, *args, **kwargs)
1248
681
# Only now, when this client is initialized, can it show up on
1250
client_object_name = unicode(self.name).translate(
1251
{ord("."): ord("_"),
1252
ord("-"): ord("_")})
1253
683
self.dbus_object_path = (dbus.ObjectPath
1254
("/clients/" + client_object_name))
685
+ self.name.replace(u".", u"_")))
1255
686
DBusObjectWithProperties.__init__(self, self.bus,
1256
687
self.dbus_object_path)
1258
def notifychangeproperty(transform_func,
1259
dbus_name, type_func=lambda x: x,
1261
""" Modify a variable so that it's a property which announces
1262
its changes to DBus.
1264
transform_fun: Function that takes a value and a variant_level
1265
and transforms it to a D-Bus type.
1266
dbus_name: D-Bus name of the variable
1267
type_func: Function that transform the value before sending it
1268
to the D-Bus. Default: no transform
1269
variant_level: D-Bus variant level. Default: 1
1271
attrname = "_{0}".format(dbus_name)
1272
def setter(self, value):
1273
if hasattr(self, "dbus_object_path"):
1274
if (not hasattr(self, attrname) or
1275
type_func(getattr(self, attrname, None))
1276
!= type_func(value)):
1277
dbus_value = transform_func(type_func(value),
1280
self.PropertyChanged(dbus.String(dbus_name),
1282
setattr(self, attrname, value)
1284
return property(lambda self: getattr(self, attrname), setter)
1286
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1287
approvals_pending = notifychangeproperty(dbus.Boolean,
1290
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1291
last_enabled = notifychangeproperty(datetime_to_dbus,
1293
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
1294
type_func = lambda checker:
1295
checker is not None)
1296
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1298
last_checker_status = notifychangeproperty(dbus.Int16,
1299
"LastCheckerStatus")
1300
last_approval_request = notifychangeproperty(
1301
datetime_to_dbus, "LastApprovalRequest")
1302
approved_by_default = notifychangeproperty(dbus.Boolean,
1303
"ApprovedByDefault")
1304
approval_delay = notifychangeproperty(dbus.UInt64,
1307
timedelta_to_milliseconds)
1308
approval_duration = notifychangeproperty(
1309
dbus.UInt64, "ApprovalDuration",
1310
type_func = timedelta_to_milliseconds)
1311
host = notifychangeproperty(dbus.String, "Host")
1312
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1314
timedelta_to_milliseconds)
1315
extended_timeout = notifychangeproperty(
1316
dbus.UInt64, "ExtendedTimeout",
1317
type_func = timedelta_to_milliseconds)
1318
interval = notifychangeproperty(dbus.UInt64,
1321
timedelta_to_milliseconds)
1322
checker_command = notifychangeproperty(dbus.String, "Checker")
1324
del notifychangeproperty
690
def _datetime_to_dbus(dt, variant_level=0):
691
"""Convert a UTC datetime.datetime() to a D-Bus type."""
692
return dbus.String(dt.isoformat(),
693
variant_level=variant_level)
696
oldstate = getattr(self, u"enabled", False)
697
r = Client.enable(self)
698
if oldstate != self.enabled:
700
self.PropertyChanged(dbus.String(u"enabled"),
701
dbus.Boolean(True, variant_level=1))
702
self.PropertyChanged(
703
dbus.String(u"last_enabled"),
704
self._datetime_to_dbus(self.last_enabled,
708
def disable(self, signal = True):
709
oldstate = getattr(self, u"enabled", False)
710
r = Client.disable(self)
711
if signal and oldstate != self.enabled:
713
self.PropertyChanged(dbus.String(u"enabled"),
714
dbus.Boolean(False, variant_level=1))
1326
717
def __del__(self, *args, **kwargs):
1328
719
self.remove_from_connection()
1329
720
except LookupError:
1331
if hasattr(DBusObjectWithProperties, "__del__"):
722
if hasattr(DBusObjectWithProperties, u"__del__"):
1332
723
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1333
724
Client.__del__(self, *args, **kwargs)
1462
841
def StopChecker(self):
1463
842
self.stop_checker()
1467
# ApprovalPending - property
1468
@dbus_service_property(_interface, signature="b", access="read")
1469
def ApprovalPending_dbus_property(self):
1470
return dbus.Boolean(bool(self.approvals_pending))
1472
# ApprovedByDefault - property
1473
@dbus_service_property(_interface, signature="b",
1475
def ApprovedByDefault_dbus_property(self, value=None):
1476
if value is None: # get
1477
return dbus.Boolean(self.approved_by_default)
1478
self.approved_by_default = bool(value)
1480
# ApprovalDelay - property
1481
@dbus_service_property(_interface, signature="t",
1483
def ApprovalDelay_dbus_property(self, value=None):
1484
if value is None: # get
1485
return dbus.UInt64(self.approval_delay_milliseconds())
1486
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1488
# ApprovalDuration - property
1489
@dbus_service_property(_interface, signature="t",
1491
def ApprovalDuration_dbus_property(self, value=None):
1492
if value is None: # get
1493
return dbus.UInt64(timedelta_to_milliseconds(
1494
self.approval_duration))
1495
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1498
@dbus_service_property(_interface, signature="s", access="read")
1499
def Name_dbus_property(self):
845
@dbus_service_property(_interface, signature=u"s", access=u"read")
846
def name_dbus_property(self):
1500
847
return dbus.String(self.name)
1502
# Fingerprint - property
1503
@dbus_service_property(_interface, signature="s", access="read")
1504
def Fingerprint_dbus_property(self):
849
# fingerprint - property
850
@dbus_service_property(_interface, signature=u"s", access=u"read")
851
def fingerprint_dbus_property(self):
1505
852
return dbus.String(self.fingerprint)
1508
@dbus_service_property(_interface, signature="s",
1510
def Host_dbus_property(self, value=None):
855
@dbus_service_property(_interface, signature=u"s",
857
def host_dbus_property(self, value=None):
1511
858
if value is None: # get
1512
859
return dbus.String(self.host)
1513
self.host = unicode(value)
1515
# Created - property
1516
@dbus_service_property(_interface, signature="s", access="read")
1517
def Created_dbus_property(self):
1518
return datetime_to_dbus(self.created)
1520
# LastEnabled - property
1521
@dbus_service_property(_interface, signature="s", access="read")
1522
def LastEnabled_dbus_property(self):
1523
return datetime_to_dbus(self.last_enabled)
1525
# Enabled - property
1526
@dbus_service_property(_interface, signature="b",
1528
def Enabled_dbus_property(self, value=None):
862
self.PropertyChanged(dbus.String(u"host"),
863
dbus.String(value, variant_level=1))
866
@dbus_service_property(_interface, signature=u"s", access=u"read")
867
def created_dbus_property(self):
868
return dbus.String(self._datetime_to_dbus(self.created))
870
# last_enabled - property
871
@dbus_service_property(_interface, signature=u"s", access=u"read")
872
def last_enabled_dbus_property(self):
873
if self.last_enabled is None:
874
return dbus.String(u"")
875
return dbus.String(self._datetime_to_dbus(self.last_enabled))
878
@dbus_service_property(_interface, signature=u"b",
880
def enabled_dbus_property(self, value=None):
1529
881
if value is None: # get
1530
882
return dbus.Boolean(self.enabled)
1536
# LastCheckedOK - property
1537
@dbus_service_property(_interface, signature="s",
1539
def LastCheckedOK_dbus_property(self, value=None):
888
# last_checked_ok - property
889
@dbus_service_property(_interface, signature=u"s",
891
def last_checked_ok_dbus_property(self, value=None):
1540
892
if value is not None:
1541
893
self.checked_ok()
1543
return datetime_to_dbus(self.last_checked_ok)
1545
# LastCheckerStatus - property
1546
@dbus_service_property(_interface, signature="n",
1548
def LastCheckerStatus_dbus_property(self):
1549
return dbus.Int16(self.last_checker_status)
1551
# Expires - property
1552
@dbus_service_property(_interface, signature="s", access="read")
1553
def Expires_dbus_property(self):
1554
return datetime_to_dbus(self.expires)
1556
# LastApprovalRequest - property
1557
@dbus_service_property(_interface, signature="s", access="read")
1558
def LastApprovalRequest_dbus_property(self):
1559
return datetime_to_dbus(self.last_approval_request)
1561
# Timeout - property
1562
@dbus_service_property(_interface, signature="t",
1564
def Timeout_dbus_property(self, value=None):
895
if self.last_checked_ok is None:
896
return dbus.String(u"")
897
return dbus.String(self._datetime_to_dbus(self
901
@dbus_service_property(_interface, signature=u"t",
903
def timeout_dbus_property(self, value=None):
1565
904
if value is None: # get
1566
905
return dbus.UInt64(self.timeout_milliseconds())
1567
old_timeout = self.timeout
1568
906
self.timeout = datetime.timedelta(0, 0, 0, value)
1569
# Reschedule disabling
1571
now = datetime.datetime.utcnow()
1572
self.expires += self.timeout - old_timeout
1573
if self.expires <= now:
1574
# The timeout has passed
1577
if (getattr(self, "disable_initiator_tag", None)
1580
gobject.source_remove(self.disable_initiator_tag)
1581
self.disable_initiator_tag = (
1582
gobject.timeout_add(
1583
timedelta_to_milliseconds(self.expires - now),
1586
# ExtendedTimeout - property
1587
@dbus_service_property(_interface, signature="t",
1589
def ExtendedTimeout_dbus_property(self, value=None):
1590
if value is None: # get
1591
return dbus.UInt64(self.extended_timeout_milliseconds())
1592
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1594
# Interval - property
1595
@dbus_service_property(_interface, signature="t",
1597
def Interval_dbus_property(self, value=None):
908
self.PropertyChanged(dbus.String(u"timeout"),
909
dbus.UInt64(value, variant_level=1))
910
if getattr(self, u"disable_initiator_tag", None) is None:
913
gobject.source_remove(self.disable_initiator_tag)
914
self.disable_initiator_tag = None
916
_timedelta_to_milliseconds((self
922
# The timeout has passed
925
self.disable_initiator_tag = (gobject.timeout_add
926
(time_to_die, self.disable))
928
# interval - property
929
@dbus_service_property(_interface, signature=u"t",
931
def interval_dbus_property(self, value=None):
1598
932
if value is None: # get
1599
933
return dbus.UInt64(self.interval_milliseconds())
1600
934
self.interval = datetime.timedelta(0, 0, 0, value)
1601
if getattr(self, "checker_initiator_tag", None) is None:
936
self.PropertyChanged(dbus.String(u"interval"),
937
dbus.UInt64(value, variant_level=1))
938
if getattr(self, u"checker_initiator_tag", None) is None:
1604
# Reschedule checker run
1605
gobject.source_remove(self.checker_initiator_tag)
1606
self.checker_initiator_tag = (gobject.timeout_add
1607
(value, self.start_checker))
1608
self.start_checker() # Start one now, too
1610
# Checker - property
1611
@dbus_service_property(_interface, signature="s",
1613
def Checker_dbus_property(self, value=None):
940
# Reschedule checker run
941
gobject.source_remove(self.checker_initiator_tag)
942
self.checker_initiator_tag = (gobject.timeout_add
943
(value, self.start_checker))
944
self.start_checker() # Start one now, too
947
@dbus_service_property(_interface, signature=u"s",
949
def checker_dbus_property(self, value=None):
1614
950
if value is None: # get
1615
951
return dbus.String(self.checker_command)
1616
self.checker_command = unicode(value)
952
self.checker_command = value
954
self.PropertyChanged(dbus.String(u"checker"),
955
dbus.String(self.checker_command,
1618
# CheckerRunning - property
1619
@dbus_service_property(_interface, signature="b",
1621
def CheckerRunning_dbus_property(self, value=None):
958
# checker_running - property
959
@dbus_service_property(_interface, signature=u"b",
961
def checker_running_dbus_property(self, value=None):
1622
962
if value is None: # get
1623
963
return dbus.Boolean(self.checker is not None)
1673
987
Note: This will run in its own forked process."""
1675
989
def handle(self):
1676
with contextlib.closing(self.server.child_pipe) as child_pipe:
1677
logger.info("TCP connection from: %s",
1678
unicode(self.client_address))
1679
logger.debug("Pipe FD: %d",
1680
self.server.child_pipe.fileno())
990
logger.info(u"TCP connection from: %s",
991
unicode(self.client_address))
992
logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])
993
# Open IPC pipe to parent process
994
with closing(os.fdopen(self.server.pipe[1], u"w", 1)) as ipc:
1682
995
session = (gnutls.connection
1683
996
.ClientSession(self.request,
1684
997
gnutls.connection
1685
998
.X509Credentials()))
1000
line = self.request.makefile().readline()
1001
logger.debug(u"Protocol version: %r", line)
1003
if int(line.strip().split()[0]) > 1:
1005
except (ValueError, IndexError, RuntimeError), error:
1006
logger.error(u"Unknown protocol version: %s", error)
1687
1009
# Note: gnutls.connection.X509Credentials is really a
1688
1010
# generic GnuTLS certificate credentials object so long as
1689
1011
# no X.509 keys are added to it. Therefore, we can use it
1690
1012
# here despite using OpenPGP certificates.
1692
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1693
# "+AES-256-CBC", "+SHA1",
1694
# "+COMP-NULL", "+CTYPE-OPENPGP",
1014
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
1015
# u"+AES-256-CBC", u"+SHA1",
1016
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
1696
1018
# Use a fallback default, since this MUST be set.
1697
1019
priority = self.server.gnutls_priority
1698
1020
if priority is None:
1021
priority = u"NORMAL"
1700
1022
(gnutls.library.functions
1701
1023
.gnutls_priority_set_direct(session._c_object,
1702
1024
priority, None))
1704
# Start communication using the Mandos protocol
1705
# Get protocol number
1706
line = self.request.makefile().readline()
1707
logger.debug("Protocol version: %r", line)
1709
if int(line.strip().split()[0]) > 1:
1710
raise RuntimeError(line)
1711
except (ValueError, IndexError, RuntimeError) as error:
1712
logger.error("Unknown protocol version: %s", error)
1715
# Start GnuTLS connection
1717
1027
session.handshake()
1718
except gnutls.errors.GNUTLSError as error:
1719
logger.warning("Handshake failed: %s", error)
1028
except gnutls.errors.GNUTLSError, error:
1029
logger.warning(u"Handshake failed: %s", error)
1720
1030
# Do not run session.bye() here: the session is not
1721
1031
# established. Just abandon the request.
1723
logger.debug("Handshake succeeded")
1725
approval_required = False
1033
logger.debug(u"Handshake succeeded")
1728
fpr = self.fingerprint(self.peer_certificate
1731
gnutls.errors.GNUTLSError) as error:
1732
logger.warning("Bad certificate: %s", error)
1734
logger.debug("Fingerprint: %s", fpr)
1737
client = ProxyClient(child_pipe, fpr,
1738
self.client_address)
1742
if client.approval_delay:
1743
delay = client.approval_delay
1744
client.approvals_pending += 1
1745
approval_required = True
1748
if not client.enabled:
1749
logger.info("Client %s is disabled",
1751
if self.server.use_dbus:
1753
client.Rejected("Disabled")
1756
if client.approved or not client.approval_delay:
1757
#We are approved or approval is disabled
1759
elif client.approved is None:
1760
logger.info("Client %s needs approval",
1762
if self.server.use_dbus:
1764
client.NeedApproval(
1765
client.approval_delay_milliseconds(),
1766
client.approved_by_default)
1768
logger.warning("Client %s was not approved",
1770
if self.server.use_dbus:
1772
client.Rejected("Denied")
1775
#wait until timeout or approved
1776
time = datetime.datetime.now()
1777
client.changedstate.acquire()
1778
client.changedstate.wait(
1779
float(timedelta_to_milliseconds(delay)
1781
client.changedstate.release()
1782
time2 = datetime.datetime.now()
1783
if (time2 - time) >= delay:
1784
if not client.approved_by_default:
1785
logger.warning("Client %s timed out while"
1786
" waiting for approval",
1788
if self.server.use_dbus:
1790
client.Rejected("Approval timed out")
1795
delay -= time2 - time
1798
while sent_size < len(client.secret):
1800
sent = session.send(client.secret[sent_size:])
1801
except gnutls.errors.GNUTLSError as error:
1802
logger.warning("gnutls send failed",
1805
logger.debug("Sent: %d, remaining: %d",
1806
sent, len(client.secret)
1807
- (sent_size + sent))
1810
logger.info("Sending secret to %s", client.name)
1811
# bump the timeout using extended_timeout
1812
client.bump_timeout(client.extended_timeout)
1813
if self.server.use_dbus:
1035
fpr = self.fingerprint(self.peer_certificate(session))
1036
except (TypeError, gnutls.errors.GNUTLSError), error:
1037
logger.warning(u"Bad certificate: %s", error)
1040
logger.debug(u"Fingerprint: %s", fpr)
1818
if approval_required:
1819
client.approvals_pending -= 1
1822
except gnutls.errors.GNUTLSError as error:
1823
logger.warning("GnuTLS bye failed",
1042
for c in self.server.clients:
1043
if c.fingerprint == fpr:
1047
ipc.write(u"NOTFOUND %s %s\n"
1048
% (fpr, unicode(self.client_address)))
1051
# Have to check if client.still_valid(), since it is
1052
# possible that the client timed out while establishing
1053
# the GnuTLS session.
1054
if not client.still_valid():
1055
ipc.write(u"INVALID %s\n" % client.name)
1058
ipc.write(u"SENDING %s\n" % client.name)
1060
while sent_size < len(client.secret):
1061
sent = session.send(client.secret[sent_size:])
1062
logger.debug(u"Sent: %d, remaining: %d",
1063
sent, len(client.secret)
1064
- (sent_size + sent))
1827
1069
def peer_certificate(session):
1933
1156
use_ipv6: Boolean; to use IPv6 or not
1935
1158
def __init__(self, server_address, RequestHandlerClass,
1936
interface=None, use_ipv6=True, socketfd=None):
1937
"""If socketfd is set, use that file descriptor instead of
1938
creating a new one with socket.socket().
1159
interface=None, use_ipv6=True):
1940
1160
self.interface = interface
1942
1162
self.address_family = socket.AF_INET6
1943
if socketfd is not None:
1944
# Save the file descriptor
1945
self.socketfd = socketfd
1946
# Save the original socket.socket() function
1947
self.socket_socket = socket.socket
1948
# To implement --socket, we monkey patch socket.socket.
1950
# (When socketserver.TCPServer is a new-style class, we
1951
# could make self.socket into a property instead of monkey
1952
# patching socket.socket.)
1954
# Create a one-time-only replacement for socket.socket()
1955
@functools.wraps(socket.socket)
1956
def socket_wrapper(*args, **kwargs):
1957
# Restore original function so subsequent calls are
1959
socket.socket = self.socket_socket
1960
del self.socket_socket
1961
# This time only, return a new socket object from the
1962
# saved file descriptor.
1963
return socket.fromfd(self.socketfd, *args, **kwargs)
1964
# Replace socket.socket() function with wrapper
1965
socket.socket = socket_wrapper
1966
# The socketserver.TCPServer.__init__ will call
1967
# socket.socket(), which might be our replacement,
1968
# socket_wrapper(), if socketfd was set.
1969
1163
socketserver.TCPServer.__init__(self, server_address,
1970
1164
RequestHandlerClass)
1972
1165
def server_bind(self):
1973
1166
"""This overrides the normal server_bind() function
1974
1167
to bind to an interface if one was specified, and also NOT to
1975
1168
bind to an address or port if they were not specified."""
1976
1169
if self.interface is not None:
1977
1170
if SO_BINDTODEVICE is None:
1978
logger.error("SO_BINDTODEVICE does not exist;"
1979
" cannot bind to interface %s",
1171
logger.error(u"SO_BINDTODEVICE does not exist;"
1172
u" cannot bind to interface %s",
1980
1173
self.interface)
1983
1176
self.socket.setsockopt(socket.SOL_SOCKET,
1984
1177
SO_BINDTODEVICE,
1985
str(self.interface + '\0'))
1986
except socket.error as error:
1987
if error.errno == errno.EPERM:
1988
logger.error("No permission to bind to"
1989
" interface %s", self.interface)
1990
elif error.errno == errno.ENOPROTOOPT:
1991
logger.error("SO_BINDTODEVICE not available;"
1992
" cannot bind to interface %s",
1994
elif error.errno == errno.ENODEV:
1995
logger.error("Interface %s does not exist,"
1996
" cannot bind", self.interface)
1180
except socket.error, error:
1181
if error[0] == errno.EPERM:
1182
logger.error(u"No permission to"
1183
u" bind to interface %s",
1185
elif error[0] == errno.ENOPROTOOPT:
1186
logger.error(u"SO_BINDTODEVICE not available;"
1187
u" cannot bind to interface %s",
1999
1191
# Only bind(2) the socket if we really need to.
2000
1192
if self.server_address[0] or self.server_address[1]:
2001
1193
if not self.server_address[0]:
2002
1194
if self.address_family == socket.AF_INET6:
2003
any_address = "::" # in6addr_any
1195
any_address = u"::" # in6addr_any
2005
any_address = "0.0.0.0" # INADDR_ANY
1197
any_address = socket.INADDR_ANY
2006
1198
self.server_address = (any_address,
2007
1199
self.server_address[1])
2008
1200
elif not self.server_address[1]:
2030
1222
def __init__(self, server_address, RequestHandlerClass,
2031
1223
interface=None, use_ipv6=True, clients=None,
2032
gnutls_priority=None, use_dbus=True, socketfd=None):
1224
gnutls_priority=None, use_dbus=True):
2033
1225
self.enabled = False
2034
1226
self.clients = clients
2035
1227
if self.clients is None:
1228
self.clients = set()
2037
1229
self.use_dbus = use_dbus
2038
1230
self.gnutls_priority = gnutls_priority
2039
1231
IPv6_TCPServer.__init__(self, server_address,
2040
1232
RequestHandlerClass,
2041
1233
interface = interface,
2042
use_ipv6 = use_ipv6,
2043
socketfd = socketfd)
1234
use_ipv6 = use_ipv6)
2044
1235
def server_activate(self):
2045
1236
if self.enabled:
2046
1237
return socketserver.TCPServer.server_activate(self)
2048
1238
def enable(self):
2049
1239
self.enabled = True
2051
def add_pipe(self, parent_pipe, proc):
1240
def add_pipe(self, pipe):
2052
1241
# Call "handle_ipc" for both data and EOF events
2053
gobject.io_add_watch(parent_pipe.fileno(),
2054
gobject.IO_IN | gobject.IO_HUP,
2055
functools.partial(self.handle_ipc,
2060
def handle_ipc(self, source, condition, parent_pipe=None,
2061
proc = None, client_object=None):
2062
# error, or the other end of multiprocessing.Pipe has closed
2063
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2064
# Wait for other process to exit
2068
# Read a request from the child
2069
request = parent_pipe.recv()
2070
command = request[0]
2072
if command == 'init':
2074
address = request[2]
2076
for c in self.clients.itervalues():
2077
if c.fingerprint == fpr:
2081
logger.info("Client not found for fingerprint: %s, ad"
2082
"dress: %s", fpr, address)
2085
mandos_dbus_service.ClientNotFound(fpr,
2087
parent_pipe.send(False)
2090
gobject.io_add_watch(parent_pipe.fileno(),
2091
gobject.IO_IN | gobject.IO_HUP,
2092
functools.partial(self.handle_ipc,
2098
parent_pipe.send(True)
2099
# remove the old hook in favor of the new above hook on
2102
if command == 'funcall':
2103
funcname = request[1]
2107
parent_pipe.send(('data', getattr(client_object,
2111
if command == 'getattr':
2112
attrname = request[1]
2113
if callable(client_object.__getattribute__(attrname)):
2114
parent_pipe.send(('function',))
2116
parent_pipe.send(('data', client_object
2117
.__getattribute__(attrname)))
2119
if command == 'setattr':
2120
attrname = request[1]
2122
setattr(client_object, attrname, value)
1242
gobject.io_add_watch(pipe, gobject.IO_IN | gobject.IO_HUP,
1244
def handle_ipc(self, source, condition, file_objects={}):
1246
gobject.IO_IN: u"IN", # There is data to read.
1247
gobject.IO_OUT: u"OUT", # Data can be written (without
1249
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1250
gobject.IO_ERR: u"ERR", # Error condition.
1251
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1252
# broken, usually for pipes and
1255
conditions_string = ' | '.join(name
1257
condition_names.iteritems()
1258
if cond & condition)
1259
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1262
# Turn the pipe file descriptor into a Python file object
1263
if source not in file_objects:
1264
file_objects[source] = os.fdopen(source, u"r", 1)
1266
# Read a line from the file object
1267
cmdline = file_objects[source].readline()
1268
if not cmdline: # Empty line means end of file
1269
# close the IPC pipe
1270
file_objects[source].close()
1271
del file_objects[source]
1273
# Stop calling this function
1276
logger.debug(u"IPC command: %r", cmdline)
1278
# Parse and act on command
1279
cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)
1281
if cmd == u"NOTFOUND":
1282
logger.warning(u"Client not found for fingerprint: %s",
1286
mandos_dbus_service.ClientNotFound(args)
1287
elif cmd == u"INVALID":
1288
for client in self.clients:
1289
if client.name == args:
1290
logger.warning(u"Client %s is invalid", args)
1296
logger.error(u"Unknown client %s is invalid", args)
1297
elif cmd == u"SENDING":
1298
for client in self.clients:
1299
if client.name == args:
1300
logger.info(u"Sending secret to %s", client.name)
1307
logger.error(u"Sending secret to unknown client %s",
1310
logger.error(u"Unknown IPC command: %r", cmdline)
1312
# Keep calling this function
2127
def rfc3339_duration_to_delta(duration):
2128
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2130
>>> rfc3339_duration_to_delta("P7D")
2131
datetime.timedelta(7)
2132
>>> rfc3339_duration_to_delta("PT60S")
2133
datetime.timedelta(0, 60)
2134
>>> rfc3339_duration_to_delta("PT60M")
2135
datetime.timedelta(0, 3600)
2136
>>> rfc3339_duration_to_delta("PT24H")
2137
datetime.timedelta(1)
2138
>>> rfc3339_duration_to_delta("P1W")
2139
datetime.timedelta(7)
2140
>>> rfc3339_duration_to_delta("PT5M30S")
2141
datetime.timedelta(0, 330)
2142
>>> rfc3339_duration_to_delta("P1DT3M20S")
2143
datetime.timedelta(1, 200)
2146
# Parsing an RFC 3339 duration with regular expressions is not
2147
# possible - there would have to be multiple places for the same
2148
# values, like seconds. The current code, while more esoteric, is
2149
# cleaner without depending on a parsing library. If Python had a
2150
# built-in library for parsing we would use it, but we'd like to
2151
# avoid excessive use of external libraries.
2153
# New type for defining tokens, syntax, and semantics all-in-one
2154
Token = collections.namedtuple("Token",
2155
("regexp", # To match token; if
2156
# "value" is not None,
2157
# must have a "group"
2159
"value", # datetime.timedelta or
2161
"followers")) # Tokens valid after
2163
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2164
# the "duration" ABNF definition in RFC 3339, Appendix A.
2165
token_end = Token(re.compile(r"$"), None, frozenset())
2166
token_second = Token(re.compile(r"(\d+)S"),
2167
datetime.timedelta(seconds=1),
2168
frozenset((token_end,)))
2169
token_minute = Token(re.compile(r"(\d+)M"),
2170
datetime.timedelta(minutes=1),
2171
frozenset((token_second, token_end)))
2172
token_hour = Token(re.compile(r"(\d+)H"),
2173
datetime.timedelta(hours=1),
2174
frozenset((token_minute, token_end)))
2175
token_time = Token(re.compile(r"T"),
2177
frozenset((token_hour, token_minute,
2179
token_day = Token(re.compile(r"(\d+)D"),
2180
datetime.timedelta(days=1),
2181
frozenset((token_time, token_end)))
2182
token_month = Token(re.compile(r"(\d+)M"),
2183
datetime.timedelta(weeks=4),
2184
frozenset((token_day, token_end)))
2185
token_year = Token(re.compile(r"(\d+)Y"),
2186
datetime.timedelta(weeks=52),
2187
frozenset((token_month, token_end)))
2188
token_week = Token(re.compile(r"(\d+)W"),
2189
datetime.timedelta(weeks=1),
2190
frozenset((token_end,)))
2191
token_duration = Token(re.compile(r"P"), None,
2192
frozenset((token_year, token_month,
2193
token_day, token_time,
2195
# Define starting values
2196
value = datetime.timedelta() # Value so far
2198
followers = frozenset(token_duration,) # Following valid tokens
2199
s = duration # String left to parse
2200
# Loop until end token is found
2201
while found_token is not token_end:
2202
# Search for any currently valid tokens
2203
for token in followers:
2204
match = token.regexp.match(s)
2205
if match is not None:
2207
if token.value is not None:
2208
# Value found, parse digits
2209
factor = int(match.group(1), 10)
2210
# Add to value so far
2211
value += factor * token.value
2212
# Strip token from string
2213
s = token.regexp.sub("", s, 1)
2216
# Set valid next tokens
2217
followers = found_token.followers
2220
# No currently valid tokens were found
2221
raise ValueError("Invalid RFC 3339 duration")
2226
1316
def string_to_delta(interval):
2227
1317
"""Parse a string and return a datetime.timedelta
2229
>>> string_to_delta('7d')
1319
>>> string_to_delta(u'7d')
2230
1320
datetime.timedelta(7)
2231
>>> string_to_delta('60s')
1321
>>> string_to_delta(u'60s')
2232
1322
datetime.timedelta(0, 60)
2233
>>> string_to_delta('60m')
1323
>>> string_to_delta(u'60m')
2234
1324
datetime.timedelta(0, 3600)
2235
>>> string_to_delta('24h')
1325
>>> string_to_delta(u'24h')
2236
1326
datetime.timedelta(1)
2237
>>> string_to_delta('1w')
1327
>>> string_to_delta(u'1w')
2238
1328
datetime.timedelta(7)
2239
>>> string_to_delta('5m 30s')
1329
>>> string_to_delta(u'5m 30s')
2240
1330
datetime.timedelta(0, 330)
2244
return rfc3339_duration_to_delta(interval)
2248
1332
timevalue = datetime.timedelta(0)
2249
1333
for s in interval.split():
2251
1335
suffix = unicode(s[-1])
2252
1336
value = int(s[:-1])
2254
1338
delta = datetime.timedelta(value)
1339
elif suffix == u"s":
2256
1340
delta = datetime.timedelta(0, value)
1341
elif suffix == u"m":
2258
1342
delta = datetime.timedelta(0, 0, 0, 0, value)
1343
elif suffix == u"h":
2260
1344
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1345
elif suffix == u"w":
2262
1346
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2264
raise ValueError("Unknown suffix {0!r}"
2266
except IndexError as e:
2267
raise ValueError(*(e.args))
1349
except (ValueError, IndexError):
2268
1351
timevalue += delta
2269
1352
return timevalue
1355
def if_nametoindex(interface):
1356
"""Call the C function if_nametoindex(), or equivalent
1358
Note: This function cannot accept a unicode string."""
1359
global if_nametoindex
1361
if_nametoindex = (ctypes.cdll.LoadLibrary
1362
(ctypes.util.find_library(u"c"))
1364
except (OSError, AttributeError):
1365
logger.warning(u"Doing if_nametoindex the hard way")
1366
def if_nametoindex(interface):
1367
"Get an interface index the hard way, i.e. using fcntl()"
1368
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1369
with closing(socket.socket()) as s:
1370
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1371
struct.pack(str(u"16s16x"),
1373
interface_index = struct.unpack(str(u"I"),
1375
return interface_index
1376
return if_nametoindex(interface)
2272
1379
def daemon(nochdir = False, noclose = False):
2273
1380
"""See daemon(3). Standard BSD Unix function.
2299
1406
##################################################################
2300
1407
# Parsing of options, both command line and config file
2302
parser = argparse.ArgumentParser()
2303
parser.add_argument("-v", "--version", action="version",
2304
version = "%(prog)s {0}".format(version),
2305
help="show version number and exit")
2306
parser.add_argument("-i", "--interface", metavar="IF",
2307
help="Bind to interface IF")
2308
parser.add_argument("-a", "--address",
2309
help="Address to listen for requests on")
2310
parser.add_argument("-p", "--port", type=int,
2311
help="Port number to receive requests on")
2312
parser.add_argument("--check", action="store_true",
2313
help="Run self-test")
2314
parser.add_argument("--debug", action="store_true",
2315
help="Debug mode; run in foreground and log"
2316
" to terminal", default=None)
2317
parser.add_argument("--debuglevel", metavar="LEVEL",
2318
help="Debug level for stdout output")
2319
parser.add_argument("--priority", help="GnuTLS"
2320
" priority string (see GnuTLS documentation)")
2321
parser.add_argument("--servicename",
2322
metavar="NAME", help="Zeroconf service name")
2323
parser.add_argument("--configdir",
2324
default="/etc/mandos", metavar="DIR",
2325
help="Directory to search for configuration"
2327
parser.add_argument("--no-dbus", action="store_false",
2328
dest="use_dbus", help="Do not provide D-Bus"
2329
" system bus interface", default=None)
2330
parser.add_argument("--no-ipv6", action="store_false",
2331
dest="use_ipv6", help="Do not use IPv6",
2333
parser.add_argument("--no-restore", action="store_false",
2334
dest="restore", help="Do not restore stored"
2335
" state", default=None)
2336
parser.add_argument("--socket", type=int,
2337
help="Specify a file descriptor to a network"
2338
" socket to use instead of creating one")
2339
parser.add_argument("--statedir", metavar="DIR",
2340
help="Directory to save/restore state in")
2341
parser.add_argument("--foreground", action="store_true",
2342
help="Run in foreground", default=None)
2344
options = parser.parse_args()
1409
parser = optparse.OptionParser(version = "%%prog %s" % version)
1410
parser.add_option("-i", u"--interface", type=u"string",
1411
metavar="IF", help=u"Bind to interface IF")
1412
parser.add_option("-a", u"--address", type=u"string",
1413
help=u"Address to listen for requests on")
1414
parser.add_option("-p", u"--port", type=u"int",
1415
help=u"Port number to receive requests on")
1416
parser.add_option("--check", action=u"store_true",
1417
help=u"Run self-test")
1418
parser.add_option("--debug", action=u"store_true",
1419
help=u"Debug mode; run in foreground and log to"
1421
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1422
u" priority string (see GnuTLS documentation)")
1423
parser.add_option("--servicename", type=u"string",
1424
metavar=u"NAME", help=u"Zeroconf service name")
1425
parser.add_option("--configdir", type=u"string",
1426
default=u"/etc/mandos", metavar=u"DIR",
1427
help=u"Directory to search for configuration"
1429
parser.add_option("--no-dbus", action=u"store_false",
1430
dest=u"use_dbus", help=u"Do not provide D-Bus"
1431
u" system bus interface")
1432
parser.add_option("--no-ipv6", action=u"store_false",
1433
dest=u"use_ipv6", help=u"Do not use IPv6")
1434
options = parser.parse_args()[0]
2346
1436
if options.check:
2348
fail_count, test_count = doctest.testmod()
2349
sys.exit(os.EX_OK if fail_count == 0 else 1)
2351
1441
# Default values for config file for server-global settings
2352
server_defaults = { "interface": "",
2357
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2358
"servicename": "Mandos",
2364
"statedir": "/var/lib/mandos",
2365
"foreground": "False",
1442
server_defaults = { u"interface": u"",
1447
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1448
u"servicename": u"Mandos",
1449
u"use_dbus": u"True",
1450
u"use_ipv6": u"True",
2368
1453
# Parse config file for server-global settings
2369
1454
server_config = configparser.SafeConfigParser(server_defaults)
2370
1455
del server_defaults
2371
1456
server_config.read(os.path.join(options.configdir,
2373
1458
# Convert the SafeConfigParser object to a dict
2374
1459
server_settings = server_config.defaults()
2375
1460
# Use the appropriate methods on the non-string config options
2376
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2377
server_settings[option] = server_config.getboolean("DEFAULT",
1461
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1462
server_settings[option] = server_config.getboolean(u"DEFAULT",
2379
1464
if server_settings["port"]:
2380
server_settings["port"] = server_config.getint("DEFAULT",
2382
if server_settings["socket"]:
2383
server_settings["socket"] = server_config.getint("DEFAULT",
2385
# Later, stdin will, and stdout and stderr might, be dup'ed
2386
# over with an opened os.devnull. But we don't want this to
2387
# happen with a supplied network socket.
2388
if 0 <= server_settings["socket"] <= 2:
2389
server_settings["socket"] = os.dup(server_settings
1465
server_settings["port"] = server_config.getint(u"DEFAULT",
2391
1467
del server_config
2393
1469
# Override the settings from the config file with command line
2394
1470
# options, if set.
2395
for option in ("interface", "address", "port", "debug",
2396
"priority", "servicename", "configdir",
2397
"use_dbus", "use_ipv6", "debuglevel", "restore",
2398
"statedir", "socket", "foreground"):
1471
for option in (u"interface", u"address", u"port", u"debug",
1472
u"priority", u"servicename", u"configdir",
1473
u"use_dbus", u"use_ipv6"):
2399
1474
value = getattr(options, option)
2400
1475
if value is not None:
2401
1476
server_settings[option] = value
2404
1479
for option in server_settings.keys():
2405
1480
if type(server_settings[option]) is str:
2406
1481
server_settings[option] = unicode(server_settings[option])
2407
# Force all boolean options to be boolean
2408
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2410
server_settings[option] = bool(server_settings[option])
2411
# Debug implies foreground
2412
if server_settings["debug"]:
2413
server_settings["foreground"] = True
2414
1482
# Now we have our good server settings in "server_settings"
2416
1484
##################################################################
2418
1486
# For convenience
2419
debug = server_settings["debug"]
2420
debuglevel = server_settings["debuglevel"]
2421
use_dbus = server_settings["use_dbus"]
2422
use_ipv6 = server_settings["use_ipv6"]
2423
stored_state_path = os.path.join(server_settings["statedir"],
2425
foreground = server_settings["foreground"]
2428
initlogger(debug, logging.DEBUG)
2433
level = getattr(logging, debuglevel.upper())
2434
initlogger(debug, level)
2436
if server_settings["servicename"] != "Mandos":
1487
debug = server_settings[u"debug"]
1488
use_dbus = server_settings[u"use_dbus"]
1489
use_ipv6 = server_settings[u"use_ipv6"]
1492
syslogger.setLevel(logging.WARNING)
1493
console.setLevel(logging.WARNING)
1495
if server_settings[u"servicename"] != u"Mandos":
2437
1496
syslogger.setFormatter(logging.Formatter
2438
('Mandos ({0}) [%(process)d]:'
2439
' %(levelname)s: %(message)s'
2440
.format(server_settings
1497
(u'Mandos (%s) [%%(process)d]:'
1498
u' %%(levelname)s: %%(message)s'
1499
% server_settings[u"servicename"]))
2443
1501
# Parse config file with clients
2444
client_config = configparser.SafeConfigParser(Client
2446
client_config.read(os.path.join(server_settings["configdir"],
1502
client_defaults = { u"timeout": u"1h",
1504
u"checker": u"fping -q -- %%(host)s",
1507
client_config = configparser.SafeConfigParser(client_defaults)
1508
client_config.read(os.path.join(server_settings[u"configdir"],
2449
1511
global mandos_dbus_service
2450
1512
mandos_dbus_service = None
2452
tcp_server = MandosServer((server_settings["address"],
2453
server_settings["port"]),
1514
tcp_server = MandosServer((server_settings[u"address"],
1515
server_settings[u"port"]),
2455
interface=(server_settings["interface"]
1517
interface=server_settings[u"interface"],
2457
1518
use_ipv6=use_ipv6,
2458
1519
gnutls_priority=
2459
server_settings["priority"],
2461
socketfd=(server_settings["socket"]
2464
pidfilename = "/run/mandos.pid"
2465
if not os.path.isdir("/run/."):
2466
pidfilename = "/var/run/mandos.pid"
2469
pidfile = open(pidfilename, "w")
2470
except IOError as e:
2471
logger.error("Could not open file %r", pidfilename,
1520
server_settings[u"priority"],
1522
pidfilename = u"/var/run/mandos.pid"
1524
pidfile = open(pidfilename, u"w")
1526
logger.error(u"Could not open file %r", pidfilename)
2474
for name in ("_mandos", "mandos", "nobody"):
1529
uid = pwd.getpwnam(u"_mandos").pw_uid
1530
gid = pwd.getpwnam(u"_mandos").pw_gid
2476
uid = pwd.getpwnam(name).pw_uid
2477
gid = pwd.getpwnam(name).pw_gid
1533
uid = pwd.getpwnam(u"mandos").pw_uid
1534
gid = pwd.getpwnam(u"mandos").pw_gid
2479
1535
except KeyError:
1537
uid = pwd.getpwnam(u"nobody").pw_uid
1538
gid = pwd.getpwnam(u"nobody").pw_gid
2487
except OSError as error:
2488
if error.errno != errno.EPERM:
1545
except OSError, error:
1546
if error[0] != errno.EPERM:
1549
# Enable all possible GnuTLS debugging
2492
# Enable all possible GnuTLS debugging
2494
1551
# "Use a log level over 10 to enable all debugging options."
2495
1552
# - GnuTLS manual
2496
1553
gnutls.library.functions.gnutls_global_set_log_level(11)
2498
1555
@gnutls.library.types.gnutls_log_func
2499
1556
def debug_gnutls(level, string):
2500
logger.debug("GnuTLS: %s", string[:-1])
1557
logger.debug(u"GnuTLS: %s", string[:-1])
2502
1559
(gnutls.library.functions
2503
1560
.gnutls_global_set_log_function(debug_gnutls))
2505
# Redirect stdin so all checkers get /dev/null
2506
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2507
os.dup2(null, sys.stdin.fileno())
2511
# Need to fork before connecting to D-Bus
2513
# Close all input and output, do double fork, etc.
2516
# multiprocessing will use threads, so before we use gobject we
2517
# need to inform gobject that threads will be used.
2518
gobject.threads_init()
2520
1562
global main_loop
2521
1563
# From the Avahi example code
2522
DBusGMainLoop(set_as_default=True)
1564
DBusGMainLoop(set_as_default=True )
2523
1565
main_loop = gobject.MainLoop()
2524
1566
bus = dbus.SystemBus()
2525
1567
# End of Avahi example code
2528
bus_name = dbus.service.BusName("se.recompile.Mandos",
2529
bus, do_not_queue=True)
2530
old_bus_name = (dbus.service.BusName
2531
("se.bsnet.fukt.Mandos", bus,
2533
except dbus.exceptions.NameExistsException as e:
2534
logger.error("Disabling D-Bus:", exc_info=e)
2536
server_settings["use_dbus"] = False
2537
tcp_server.use_dbus = False
1569
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
2538
1570
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2539
service = AvahiServiceToSyslog(name =
2540
server_settings["servicename"],
2541
servicetype = "_mandos._tcp",
2542
protocol = protocol, bus = bus)
1571
service = AvahiService(name = server_settings[u"servicename"],
1572
servicetype = u"_mandos._tcp",
1573
protocol = protocol, bus = bus)
2543
1574
if server_settings["interface"]:
2544
1575
service.interface = (if_nametoindex
2545
(str(server_settings["interface"])))
2547
global multiprocessing_manager
2548
multiprocessing_manager = multiprocessing.Manager()
1576
(str(server_settings[u"interface"])))
2550
1578
client_class = Client
2552
1580
client_class = functools.partial(ClientDBus, bus = bus)
2554
client_settings = Client.config_parser(client_config)
2555
old_client_settings = {}
2558
# This is used to redirect stdout and stderr for checker processes
2560
wnull = open(os.devnull, "w") # A writable /dev/null
2561
# Only used if server is running in foreground but not in debug
2563
if debug or not foreground:
2566
# Get client data and settings from last running state.
2567
if server_settings["restore"]:
2569
with open(stored_state_path, "rb") as stored_state:
2570
clients_data, old_client_settings = (pickle.load
2572
os.remove(stored_state_path)
2573
except IOError as e:
2574
if e.errno == errno.ENOENT:
2575
logger.warning("Could not load persistent state: {0}"
2576
.format(os.strerror(e.errno)))
2578
logger.critical("Could not load persistent state:",
2581
except EOFError as e:
2582
logger.warning("Could not load persistent state: "
2583
"EOFError:", exc_info=e)
2585
with PGPEngine() as pgp:
2586
for client_name, client in clients_data.iteritems():
2587
# Skip removed clients
2588
if client_name not in client_settings:
2591
# Decide which value to use after restoring saved state.
2592
# We have three different values: Old config file,
2593
# new config file, and saved state.
2594
# New config value takes precedence if it differs from old
2595
# config value, otherwise use saved state.
2596
for name, value in client_settings[client_name].items():
2598
# For each value in new config, check if it
2599
# differs from the old config value (Except for
2600
# the "secret" attribute)
2601
if (name != "secret" and
2602
value != old_client_settings[client_name]
2604
client[name] = value
2608
# Clients who has passed its expire date can still be
2609
# enabled if its last checker was successful. Clients
2610
# whose checker succeeded before we stored its state is
2611
# assumed to have successfully run all checkers during
2613
if client["enabled"]:
2614
if datetime.datetime.utcnow() >= client["expires"]:
2615
if not client["last_checked_ok"]:
2617
"disabling client {0} - Client never "
2618
"performed a successful checker"
2619
.format(client_name))
2620
client["enabled"] = False
2621
elif client["last_checker_status"] != 0:
2623
"disabling client {0} - Client "
2624
"last checker failed with error code {1}"
2625
.format(client_name,
2626
client["last_checker_status"]))
2627
client["enabled"] = False
2629
client["expires"] = (datetime.datetime
2631
+ client["timeout"])
2632
logger.debug("Last checker succeeded,"
2633
" keeping {0} enabled"
2634
.format(client_name))
2636
client["secret"] = (
2637
pgp.decrypt(client["encrypted_secret"],
2638
client_settings[client_name]
2641
# If decryption fails, we use secret from new settings
2642
logger.debug("Failed to decrypt {0} old secret"
2643
.format(client_name))
2644
client["secret"] = (
2645
client_settings[client_name]["secret"])
2647
# Add/remove clients based on new changes made to config
2648
for client_name in (set(old_client_settings)
2649
- set(client_settings)):
2650
del clients_data[client_name]
2651
for client_name in (set(client_settings)
2652
- set(old_client_settings)):
2653
clients_data[client_name] = client_settings[client_name]
2655
# Create all client objects
2656
for client_name, client in clients_data.iteritems():
2657
tcp_server.clients[client_name] = client_class(
2658
name = client_name, settings = client,
2659
server_settings = server_settings)
1581
tcp_server.clients.update(set(
1582
client_class(name = section,
1583
config= dict(client_config.items(section)))
1584
for section in client_config.sections()))
2661
1585
if not tcp_server.clients:
2662
logger.warning("No clients defined")
2665
if pidfile is not None:
2669
pidfile.write(str(pid) + "\n".encode("utf-8"))
2671
logger.error("Could not write to file %r with PID %d",
1586
logger.warning(u"No clients defined")
1589
# Redirect stdin so all checkers get /dev/null
1590
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1591
os.dup2(null, sys.stdin.fileno())
1595
# No console logging
1596
logger.removeHandler(console)
1597
# Close all input and output, do double fork, etc.
1601
with closing(pidfile):
1603
pidfile.write(str(pid) + "\n")
1606
logger.error(u"Could not write to file %r with PID %d",
1609
# "pidfile" was never created
1614
"Cleanup function; run on exit"
1617
while tcp_server.clients:
1618
client = tcp_server.clients.pop()
1619
client.disable_hook = None
1622
atexit.register(cleanup)
1625
signal.signal(signal.SIGINT, signal.SIG_IGN)
2676
1626
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2677
1627
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2680
@alternate_dbus_interfaces({"se.recompile.Mandos":
2681
"se.bsnet.fukt.Mandos"})
2682
class MandosDBusService(DBusObjectWithProperties):
1630
class MandosDBusService(dbus.service.Object):
2683
1631
"""A D-Bus proxy object"""
2684
1632
def __init__(self):
2685
dbus.service.Object.__init__(self, bus, "/")
2686
_interface = "se.recompile.Mandos"
2688
@dbus_interface_annotations(_interface)
2690
return { "org.freedesktop.DBus.Property"
2691
".EmitsChangedSignal":
2694
@dbus.service.signal(_interface, signature="o")
2695
def ClientAdded(self, objpath):
2699
@dbus.service.signal(_interface, signature="ss")
2700
def ClientNotFound(self, fingerprint, address):
2704
@dbus.service.signal(_interface, signature="os")
1633
dbus.service.Object.__init__(self, bus, u"/")
1634
_interface = u"se.bsnet.fukt.Mandos"
1636
@dbus.service.signal(_interface, signature=u"oa{sv}")
1637
def ClientAdded(self, objpath, properties):
1641
@dbus.service.signal(_interface, signature=u"s")
1642
def ClientNotFound(self, fingerprint):
1646
@dbus.service.signal(_interface, signature=u"os")
2705
1647
def ClientRemoved(self, objpath, name):
2709
@dbus.service.method(_interface, out_signature="ao")
1651
@dbus.service.method(_interface, out_signature=u"ao")
2710
1652
def GetAllClients(self):
2712
1654
return dbus.Array(c.dbus_object_path
2714
tcp_server.clients.itervalues())
1655
for c in tcp_server.clients)
2716
1657
@dbus.service.method(_interface,
2717
out_signature="a{oa{sv}}")
1658
out_signature=u"a{oa{sv}}")
2718
1659
def GetAllClientsWithProperties(self):
2720
1661
return dbus.Dictionary(
2721
((c.dbus_object_path, c.GetAll(""))
2722
for c in tcp_server.clients.itervalues()),
1662
((c.dbus_object_path, c.GetAll(u""))
1663
for c in tcp_server.clients),
1664
signature=u"oa{sv}")
2725
@dbus.service.method(_interface, in_signature="o")
1666
@dbus.service.method(_interface, in_signature=u"o")
2726
1667
def RemoveClient(self, object_path):
2728
for c in tcp_server.clients.itervalues():
1669
for c in tcp_server.clients:
2729
1670
if c.dbus_object_path == object_path:
2730
del tcp_server.clients[c.name]
1671
tcp_server.clients.remove(c)
2731
1672
c.remove_from_connection()
2732
1673
# Don't signal anything except ClientRemoved
2733
c.disable(quiet=True)
1674
c.disable(signal=False)
2734
1675
# Emit D-Bus signal
2735
1676
self.ClientRemoved(object_path, c.name)
2737
raise KeyError(object_path)
2741
1682
mandos_dbus_service = MandosDBusService()
2744
"Cleanup function; run on exit"
2747
multiprocessing.active_children()
2749
if not (tcp_server.clients or client_settings):
2752
# Store client before exiting. Secrets are encrypted with key
2753
# based on what config file has. If config file is
2754
# removed/edited, old secret will thus be unrecovable.
2756
with PGPEngine() as pgp:
2757
for client in tcp_server.clients.itervalues():
2758
key = client_settings[client.name]["secret"]
2759
client.encrypted_secret = pgp.encrypt(client.secret,
2763
# A list of attributes that can not be pickled
2765
exclude = set(("bus", "changedstate", "secret",
2766
"checker", "server_settings"))
2767
for name, typ in (inspect.getmembers
2768
(dbus.service.Object)):
2771
client_dict["encrypted_secret"] = (client
2773
for attr in client.client_structure:
2774
if attr not in exclude:
2775
client_dict[attr] = getattr(client, attr)
2777
clients[client.name] = client_dict
2778
del client_settings[client.name]["secret"]
2781
with (tempfile.NamedTemporaryFile
2782
(mode='wb', suffix=".pickle", prefix='clients-',
2783
dir=os.path.dirname(stored_state_path),
2784
delete=False)) as stored_state:
2785
pickle.dump((clients, client_settings), stored_state)
2786
tempname=stored_state.name
2787
os.rename(tempname, stored_state_path)
2788
except (IOError, OSError) as e:
2794
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2795
logger.warning("Could not save persistent state: {0}"
2796
.format(os.strerror(e.errno)))
2798
logger.warning("Could not save persistent state:",
2802
# Delete all clients, and settings from config
2803
while tcp_server.clients:
2804
name, client = tcp_server.clients.popitem()
2806
client.remove_from_connection()
2807
# Don't signal anything except ClientRemoved
2808
client.disable(quiet=True)
2811
mandos_dbus_service.ClientRemoved(client
2814
client_settings.clear()
2816
atexit.register(cleanup)
2818
for client in tcp_server.clients.itervalues():
1684
for client in tcp_server.clients:
2820
1686
# Emit D-Bus signal
2821
mandos_dbus_service.ClientAdded(client.dbus_object_path)
2822
# Need to initiate checking of clients
2824
client.init_checker()
1687
mandos_dbus_service.ClientAdded(client.dbus_object_path,
2826
1691
tcp_server.enable()
2827
1692
tcp_server.server_activate()