189
207
self.group.Commit()
190
208
def entry_group_state_changed(self, state, error):
191
209
"""Derived from the Avahi example code"""
192
logger.debug(u"Avahi state change: %i", state)
210
logger.debug("Avahi entry group state change: %i", state)
194
212
if state == avahi.ENTRY_GROUP_ESTABLISHED:
195
logger.debug(u"Zeroconf service established.")
213
logger.debug("Zeroconf service established.")
196
214
elif state == avahi.ENTRY_GROUP_COLLISION:
197
logger.warning(u"Zeroconf service name collision.")
215
logger.info("Zeroconf service name collision.")
199
217
elif state == avahi.ENTRY_GROUP_FAILURE:
200
logger.critical(u"Avahi: Error in group state changed %s",
218
logger.critical("Avahi: Error in group state changed %s",
202
raise AvahiGroupError(u"State changed: %s"
220
raise AvahiGroupError("State changed: %s"
203
221
% unicode(error))
204
222
def cleanup(self):
205
223
"""Derived from the Avahi example code"""
206
224
if self.group is not None:
227
except (dbus.exceptions.UnknownMethodException,
228
dbus.exceptions.DBusException) as e:
208
230
self.group = None
209
def server_state_changed(self, state):
232
def server_state_changed(self, state, error=None):
210
233
"""Derived from the Avahi example code"""
211
if state == avahi.SERVER_COLLISION:
212
logger.error(u"Zeroconf server name collision")
234
logger.debug("Avahi server state change: %i", state)
235
bad_states = { avahi.SERVER_INVALID:
236
"Zeroconf server invalid",
237
avahi.SERVER_REGISTERING: None,
238
avahi.SERVER_COLLISION:
239
"Zeroconf server name collision",
240
avahi.SERVER_FAILURE:
241
"Zeroconf server failure" }
242
if state in bad_states:
243
if bad_states[state] is not None:
245
logger.error(bad_states[state])
247
logger.error(bad_states[state] + ": %r", error)
214
249
elif state == avahi.SERVER_RUNNING:
253
logger.debug("Unknown state: %r", state)
255
logger.debug("Unknown state: %r: %r", state, error)
216
256
def activate(self):
217
257
"""Derived from the Avahi example code"""
218
258
if self.server is None:
219
259
self.server = dbus.Interface(
220
260
self.bus.get_object(avahi.DBUS_NAME,
221
avahi.DBUS_PATH_SERVER),
261
avahi.DBUS_PATH_SERVER,
262
follow_name_owner_changes=True),
222
263
avahi.DBUS_INTERFACE_SERVER)
223
self.server.connect_to_signal(u"StateChanged",
264
self.server.connect_to_signal("StateChanged",
224
265
self.server_state_changed)
225
266
self.server_state_changed(self.server.GetState())
269
def _timedelta_to_milliseconds(td):
270
"Convert a datetime.timedelta() to milliseconds"
271
return ((td.days * 24 * 60 * 60 * 1000)
272
+ (td.seconds * 1000)
273
+ (td.microseconds // 1000))
228
275
class Client(object):
229
276
"""A representation of a client host served by this server.
232
name: string; from the config file, used in log messages and
234
fingerprint: string (40 or 32 hexadecimal digits); used to
235
uniquely identify the client
236
secret: bytestring; sent verbatim (over TLS) to client
237
host: string; available for use by the checker command
238
created: datetime.datetime(); (UTC) object creation
239
last_enabled: datetime.datetime(); (UTC)
241
last_checked_ok: datetime.datetime(); (UTC) or None
242
timeout: datetime.timedelta(); How long from last_checked_ok
243
until this client is invalid
244
interval: datetime.timedelta(); How often to start a new checker
245
disable_hook: If set, called by disable() as disable_hook(self)
279
_approved: bool(); 'None' if not yet approved/disapproved
280
approval_delay: datetime.timedelta(); Time to wait for approval
281
approval_duration: datetime.timedelta(); Duration of one approval
246
282
checker: subprocess.Popen(); a running checker process used
247
283
to see if the client lives.
248
284
'None' if no process is running.
249
checker_initiator_tag: a gobject event source tag, or None
250
disable_initiator_tag: - '' -
251
checker_callback_tag: - '' -
252
checker_command: string; External command which is run to check if
253
client lives. %() expansions are done at
285
checker_callback_tag: a gobject event source tag, or None
286
checker_command: string; External command which is run to check
287
if client lives. %() expansions are done at
254
288
runtime with vars(self) as dict, so that for
255
289
instance %(name)s can be used in the command.
290
checker_initiator_tag: a gobject event source tag, or None
291
created: datetime.datetime(); (UTC) object creation
256
292
current_checker_command: string; current running checker_command
293
disable_hook: If set, called by disable() as disable_hook(self)
294
disable_initiator_tag: a gobject event source tag, or None
296
fingerprint: string (40 or 32 hexadecimal digits); used to
297
uniquely identify the client
298
host: string; available for use by the checker command
299
interval: datetime.timedelta(); How often to start a new checker
300
last_approval_request: datetime.datetime(); (UTC) or None
301
last_checked_ok: datetime.datetime(); (UTC) or None
302
last_enabled: datetime.datetime(); (UTC)
303
name: string; from the config file, used in log messages and
305
secret: bytestring; sent verbatim (over TLS) to client
306
timeout: datetime.timedelta(); How long from last_checked_ok
307
until this client is disabled
308
extended_timeout: extra long timeout when password has been sent
309
runtime_expansions: Allowed attributes for runtime expansion.
310
expires: datetime.datetime(); time (UTC) when a client will be
260
def _datetime_to_milliseconds(dt):
261
"Convert a datetime.datetime() to milliseconds"
262
return ((dt.days * 24 * 60 * 60 * 1000)
263
+ (dt.seconds * 1000)
264
+ (dt.microseconds // 1000))
314
runtime_expansions = ("approval_delay", "approval_duration",
315
"created", "enabled", "fingerprint",
316
"host", "interval", "last_checked_ok",
317
"last_enabled", "name", "timeout")
266
319
def timeout_milliseconds(self):
267
320
"Return the 'timeout' attribute in milliseconds"
268
return self._datetime_to_milliseconds(self.timeout)
321
return _timedelta_to_milliseconds(self.timeout)
323
def extended_timeout_milliseconds(self):
324
"Return the 'extended_timeout' attribute in milliseconds"
325
return _timedelta_to_milliseconds(self.extended_timeout)
270
327
def interval_milliseconds(self):
271
328
"Return the 'interval' attribute in milliseconds"
272
return self._datetime_to_milliseconds(self.interval)
329
return _timedelta_to_milliseconds(self.interval)
331
def approval_delay_milliseconds(self):
332
return _timedelta_to_milliseconds(self.approval_delay)
274
334
def __init__(self, name = None, disable_hook=None, config=None):
275
335
"""Note: the 'checker' key in 'config' sets the
279
339
if config is None:
281
logger.debug(u"Creating client %r", self.name)
341
logger.debug("Creating client %r", self.name)
282
342
# Uppercase and remove spaces from fingerprint for later
283
343
# comparison purposes with return value from the fingerprint()
285
self.fingerprint = (config[u"fingerprint"].upper()
287
logger.debug(u" Fingerprint: %s", self.fingerprint)
288
if u"secret" in config:
289
self.secret = config[u"secret"].decode(u"base64")
290
elif u"secfile" in config:
291
with closing(open(os.path.expanduser
293
(config[u"secfile"])))) as secfile:
345
self.fingerprint = (config["fingerprint"].upper()
347
logger.debug(" Fingerprint: %s", self.fingerprint)
348
if "secret" in config:
349
self.secret = config["secret"].decode("base64")
350
elif "secfile" in config:
351
with open(os.path.expanduser(os.path.expandvars
352
(config["secfile"])),
294
354
self.secret = secfile.read()
296
raise TypeError(u"No secret or secfile for client %s"
356
raise TypeError("No secret or secfile for client %s"
298
self.host = config.get(u"host", u"")
358
self.host = config.get("host", "")
299
359
self.created = datetime.datetime.utcnow()
300
360
self.enabled = False
361
self.last_approval_request = None
301
362
self.last_enabled = None
302
363
self.last_checked_ok = None
303
self.timeout = string_to_delta(config[u"timeout"])
304
self.interval = string_to_delta(config[u"interval"])
364
self.timeout = string_to_delta(config["timeout"])
365
self.extended_timeout = string_to_delta(config
366
["extended_timeout"])
367
self.interval = string_to_delta(config["interval"])
305
368
self.disable_hook = disable_hook
306
369
self.checker = None
307
370
self.checker_initiator_tag = None
308
371
self.disable_initiator_tag = None
309
373
self.checker_callback_tag = None
310
self.checker_command = config[u"checker"]
374
self.checker_command = config["checker"]
311
375
self.current_checker_command = None
312
376
self.last_connect = None
377
self._approved = None
378
self.approved_by_default = config.get("approved_by_default",
380
self.approvals_pending = 0
381
self.approval_delay = string_to_delta(
382
config["approval_delay"])
383
self.approval_duration = string_to_delta(
384
config["approval_duration"])
385
self.changedstate = (multiprocessing_manager
386
.Condition(multiprocessing_manager
389
def send_changedstate(self):
390
self.changedstate.acquire()
391
self.changedstate.notify_all()
392
self.changedstate.release()
314
394
def enable(self):
315
395
"""Start this client's checker and timeout hooks"""
316
if getattr(self, u"enabled", False):
396
if getattr(self, "enabled", False):
317
397
# Already enabled
319
self.last_enabled = datetime.datetime.utcnow()
399
self.send_changedstate()
320
400
# Schedule a new checker to be started an 'interval' from now,
321
401
# and every interval from then on.
322
402
self.checker_initiator_tag = (gobject.timeout_add
323
403
(self.interval_milliseconds(),
324
404
self.start_checker))
325
# Also start a new checker *right now*.
327
405
# Schedule a disable() when 'timeout' has passed
406
self.expires = datetime.datetime.utcnow() + self.timeout
328
407
self.disable_initiator_tag = (gobject.timeout_add
329
408
(self.timeout_milliseconds(),
331
410
self.enabled = True
411
self.last_enabled = datetime.datetime.utcnow()
412
# Also start a new checker *right now*.
415
def disable(self, quiet=True):
334
416
"""Disable this client."""
335
417
if not getattr(self, "enabled", False):
337
logger.info(u"Disabling client %s", self.name)
338
if getattr(self, u"disable_initiator_tag", False):
420
self.send_changedstate()
422
logger.info("Disabling client %s", self.name)
423
if getattr(self, "disable_initiator_tag", False):
339
424
gobject.source_remove(self.disable_initiator_tag)
340
425
self.disable_initiator_tag = None
341
if getattr(self, u"checker_initiator_tag", False):
427
if getattr(self, "checker_initiator_tag", False):
342
428
gobject.source_remove(self.checker_initiator_tag)
343
429
self.checker_initiator_tag = None
344
430
self.stop_checker()
454
555
if self.checker_callback_tag:
455
556
gobject.source_remove(self.checker_callback_tag)
456
557
self.checker_callback_tag = None
457
if getattr(self, u"checker", None) is None:
558
if getattr(self, "checker", None) is None:
459
logger.debug(u"Stopping checker for %(name)s", vars(self))
560
logger.debug("Stopping checker for %(name)s", vars(self))
461
562
os.kill(self.checker.pid, signal.SIGTERM)
463
564
#if self.checker.poll() is None:
464
565
# os.kill(self.checker.pid, signal.SIGKILL)
465
except OSError, error:
566
except OSError as error:
466
567
if error.errno != errno.ESRCH: # No such process
468
569
self.checker = None
470
def still_valid(self):
471
"""Has the timeout not yet passed for this client?"""
472
if not getattr(self, u"enabled", False):
474
now = datetime.datetime.utcnow()
475
if self.last_checked_ok is None:
476
return now < (self.created + self.timeout)
478
return now < (self.last_checked_ok + self.timeout)
481
class ClientDBus(Client, dbus.service.Object):
572
def dbus_service_property(dbus_interface, signature="v",
573
access="readwrite", byte_arrays=False):
574
"""Decorators for marking methods of a DBusObjectWithProperties to
575
become properties on the D-Bus.
577
The decorated method will be called with no arguments by "Get"
578
and with one argument by "Set".
580
The parameters, where they are supported, are the same as
581
dbus.service.method, except there is only "signature", since the
582
type from Get() and the type sent to Set() is the same.
584
# Encoding deeply encoded byte arrays is not supported yet by the
585
# "Set" method, so we fail early here:
586
if byte_arrays and signature != "ay":
587
raise ValueError("Byte arrays not supported for non-'ay'"
588
" signature %r" % signature)
590
func._dbus_is_property = True
591
func._dbus_interface = dbus_interface
592
func._dbus_signature = signature
593
func._dbus_access = access
594
func._dbus_name = func.__name__
595
if func._dbus_name.endswith("_dbus_property"):
596
func._dbus_name = func._dbus_name[:-14]
597
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
602
class DBusPropertyException(dbus.exceptions.DBusException):
603
"""A base class for D-Bus property-related exceptions
605
def __unicode__(self):
606
return unicode(str(self))
609
class DBusPropertyAccessException(DBusPropertyException):
610
"""A property's access permissions disallows an operation.
615
class DBusPropertyNotFound(DBusPropertyException):
616
"""An attempt was made to access a non-existing property.
621
class DBusObjectWithProperties(dbus.service.Object):
622
"""A D-Bus object with properties.
624
Classes inheriting from this can use the dbus_service_property
625
decorator to expose methods as D-Bus properties. It exposes the
626
standard Get(), Set(), and GetAll() methods on the D-Bus.
630
def _is_dbus_property(obj):
631
return getattr(obj, "_dbus_is_property", False)
633
def _get_all_dbus_properties(self):
634
"""Returns a generator of (name, attribute) pairs
636
return ((prop.__get__(self)._dbus_name, prop.__get__(self))
637
for cls in self.__class__.__mro__
639
inspect.getmembers(cls, self._is_dbus_property))
641
def _get_dbus_property(self, interface_name, property_name):
642
"""Returns a bound method if one exists which is a D-Bus
643
property with the specified name and interface.
645
for cls in self.__class__.__mro__:
646
for name, value in (inspect.getmembers
647
(cls, self._is_dbus_property)):
648
if (value._dbus_name == property_name
649
and value._dbus_interface == interface_name):
650
return value.__get__(self)
653
raise DBusPropertyNotFound(self.dbus_object_path + ":"
654
+ interface_name + "."
657
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
659
def Get(self, interface_name, property_name):
660
"""Standard D-Bus property Get() method, see D-Bus standard.
662
prop = self._get_dbus_property(interface_name, property_name)
663
if prop._dbus_access == "write":
664
raise DBusPropertyAccessException(property_name)
666
if not hasattr(value, "variant_level"):
668
return type(value)(value, variant_level=value.variant_level+1)
670
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
671
def Set(self, interface_name, property_name, value):
672
"""Standard D-Bus property Set() method, see D-Bus standard.
674
prop = self._get_dbus_property(interface_name, property_name)
675
if prop._dbus_access == "read":
676
raise DBusPropertyAccessException(property_name)
677
if prop._dbus_get_args_options["byte_arrays"]:
678
# The byte_arrays option is not supported yet on
679
# signatures other than "ay".
680
if prop._dbus_signature != "ay":
682
value = dbus.ByteArray(''.join(unichr(byte)
686
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
687
out_signature="a{sv}")
688
def GetAll(self, interface_name):
689
"""Standard D-Bus property GetAll() method, see D-Bus
692
Note: Will not include properties with access="write".
695
for name, prop in self._get_all_dbus_properties():
697
and interface_name != prop._dbus_interface):
698
# Interface non-empty but did not match
700
# Ignore write-only properties
701
if prop._dbus_access == "write":
704
if not hasattr(value, "variant_level"):
707
all[name] = type(value)(value, variant_level=
708
value.variant_level+1)
709
return dbus.Dictionary(all, signature="sv")
711
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
713
path_keyword='object_path',
714
connection_keyword='connection')
715
def Introspect(self, object_path, connection):
716
"""Standard D-Bus method, overloaded to insert property tags.
718
xmlstring = dbus.service.Object.Introspect(self, object_path,
721
document = xml.dom.minidom.parseString(xmlstring)
722
def make_tag(document, name, prop):
723
e = document.createElement("property")
724
e.setAttribute("name", name)
725
e.setAttribute("type", prop._dbus_signature)
726
e.setAttribute("access", prop._dbus_access)
728
for if_tag in document.getElementsByTagName("interface"):
729
for tag in (make_tag(document, name, prop)
731
in self._get_all_dbus_properties()
732
if prop._dbus_interface
733
== if_tag.getAttribute("name")):
734
if_tag.appendChild(tag)
735
# Add the names to the return values for the
736
# "org.freedesktop.DBus.Properties" methods
737
if (if_tag.getAttribute("name")
738
== "org.freedesktop.DBus.Properties"):
739
for cn in if_tag.getElementsByTagName("method"):
740
if cn.getAttribute("name") == "Get":
741
for arg in cn.getElementsByTagName("arg"):
742
if (arg.getAttribute("direction")
744
arg.setAttribute("name", "value")
745
elif cn.getAttribute("name") == "GetAll":
746
for arg in cn.getElementsByTagName("arg"):
747
if (arg.getAttribute("direction")
749
arg.setAttribute("name", "props")
750
xmlstring = document.toxml("utf-8")
752
except (AttributeError, xml.dom.DOMException,
753
xml.parsers.expat.ExpatError) as error:
754
logger.error("Failed to override Introspection method",
759
def datetime_to_dbus (dt, variant_level=0):
760
"""Convert a UTC datetime.datetime() to a D-Bus type."""
762
return dbus.String("", variant_level = variant_level)
763
return dbus.String(dt.isoformat(),
764
variant_level=variant_level)
766
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
768
"""Applied to an empty subclass of a D-Bus object, this metaclass
769
will add additional D-Bus attributes matching a certain pattern.
771
def __new__(mcs, name, bases, attr):
772
# Go through all the base classes which could have D-Bus
773
# methods, signals, or properties in them
774
for base in (b for b in bases
775
if issubclass(b, dbus.service.Object)):
776
# Go though all attributes of the base class
777
for attrname, attribute in inspect.getmembers(base):
778
# Ignore non-D-Bus attributes, and D-Bus attributes
779
# with the wrong interface name
780
if (not hasattr(attribute, "_dbus_interface")
781
or not attribute._dbus_interface
782
.startswith("se.recompile.Mandos")):
784
# Create an alternate D-Bus interface name based on
786
alt_interface = (attribute._dbus_interface
787
.replace("se.recompile.Mandos",
788
"se.bsnet.fukt.Mandos"))
789
# Is this a D-Bus signal?
790
if getattr(attribute, "_dbus_is_signal", False):
791
# Extract the original non-method function by
793
nonmethod_func = (dict(
794
zip(attribute.func_code.co_freevars,
795
attribute.__closure__))["func"]
797
# Create a new, but exactly alike, function
798
# object, and decorate it to be a new D-Bus signal
799
# with the alternate D-Bus interface name
800
new_function = (dbus.service.signal
802
attribute._dbus_signature)
804
nonmethod_func.func_code,
805
nonmethod_func.func_globals,
806
nonmethod_func.func_name,
807
nonmethod_func.func_defaults,
808
nonmethod_func.func_closure)))
809
# Define a creator of a function to call both the
810
# old and new functions, so both the old and new
811
# signals gets sent when the function is called
812
def fixscope(func1, func2):
813
"""This function is a scope container to pass
814
func1 and func2 to the "call_both" function
815
outside of its arguments"""
816
def call_both(*args, **kwargs):
817
"""This function will emit two D-Bus
818
signals by calling func1 and func2"""
819
func1(*args, **kwargs)
820
func2(*args, **kwargs)
822
# Create the "call_both" function and add it to
824
attr[attrname] = fixscope(attribute,
826
# Is this a D-Bus method?
827
elif getattr(attribute, "_dbus_is_method", False):
828
# Create a new, but exactly alike, function
829
# object. Decorate it to be a new D-Bus method
830
# with the alternate D-Bus interface name. Add it
832
attr[attrname] = (dbus.service.method
834
attribute._dbus_in_signature,
835
attribute._dbus_out_signature)
837
(attribute.func_code,
838
attribute.func_globals,
840
attribute.func_defaults,
841
attribute.func_closure)))
842
# Is this a D-Bus property?
843
elif getattr(attribute, "_dbus_is_property", False):
844
# Create a new, but exactly alike, function
845
# object, and decorate it to be a new D-Bus
846
# property with the alternate D-Bus interface
847
# name. Add it to the class.
848
attr[attrname] = (dbus_service_property
850
attribute._dbus_signature,
851
attribute._dbus_access,
853
._dbus_get_args_options
856
(attribute.func_code,
857
attribute.func_globals,
859
attribute.func_defaults,
860
attribute.func_closure)))
861
return type.__new__(mcs, name, bases, attr)
863
class ClientDBus(Client, DBusObjectWithProperties):
482
864
"""A Client class using D-Bus
485
867
dbus_object_path: dbus.ObjectPath
486
868
bus: dbus.SystemBus()
871
runtime_expansions = (Client.runtime_expansions
872
+ ("dbus_object_path",))
488
874
# dbus.service.Object doesn't use super(), so we can't either.
490
876
def __init__(self, bus = None, *args, **kwargs):
877
self._approvals_pending = 0
492
879
Client.__init__(self, *args, **kwargs)
493
880
# Only now, when this client is initialized, can it show up on
882
client_object_name = unicode(self.name).translate(
495
885
self.dbus_object_path = (dbus.ObjectPath
497
+ self.name.replace(u".", u"_")))
498
dbus.service.Object.__init__(self, self.bus,
499
self.dbus_object_path)
502
def _datetime_to_dbus(dt, variant_level=0):
503
"""Convert a UTC datetime.datetime() to a D-Bus type."""
504
return dbus.String(dt.isoformat(),
505
variant_level=variant_level)
508
oldstate = getattr(self, u"enabled", False)
509
r = Client.enable(self)
510
if oldstate != self.enabled:
512
self.PropertyChanged(dbus.String(u"enabled"),
513
dbus.Boolean(True, variant_level=1))
514
self.PropertyChanged(
515
dbus.String(u"last_enabled"),
516
self._datetime_to_dbus(self.last_enabled,
520
def disable(self, signal = True):
521
oldstate = getattr(self, u"enabled", False)
522
r = Client.disable(self)
523
if signal and oldstate != self.enabled:
525
self.PropertyChanged(dbus.String(u"enabled"),
526
dbus.Boolean(False, variant_level=1))
886
("/clients/" + client_object_name))
887
DBusObjectWithProperties.__init__(self, self.bus,
888
self.dbus_object_path)
890
def notifychangeproperty(transform_func,
891
dbus_name, type_func=lambda x: x,
893
""" Modify a variable so that it's a property which announces
896
transform_fun: Function that takes a value and a variant_level
897
and transforms it to a D-Bus type.
898
dbus_name: D-Bus name of the variable
899
type_func: Function that transform the value before sending it
900
to the D-Bus. Default: no transform
901
variant_level: D-Bus variant level. Default: 1
903
attrname = "_{0}".format(dbus_name)
904
def setter(self, value):
905
if hasattr(self, "dbus_object_path"):
906
if (not hasattr(self, attrname) or
907
type_func(getattr(self, attrname, None))
908
!= type_func(value)):
909
dbus_value = transform_func(type_func(value),
912
self.PropertyChanged(dbus.String(dbus_name),
914
setattr(self, attrname, value)
916
return property(lambda self: getattr(self, attrname), setter)
919
expires = notifychangeproperty(datetime_to_dbus, "Expires")
920
approvals_pending = notifychangeproperty(dbus.Boolean,
923
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
924
last_enabled = notifychangeproperty(datetime_to_dbus,
926
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
927
type_func = lambda checker:
929
last_checked_ok = notifychangeproperty(datetime_to_dbus,
931
last_approval_request = notifychangeproperty(
932
datetime_to_dbus, "LastApprovalRequest")
933
approved_by_default = notifychangeproperty(dbus.Boolean,
935
approval_delay = notifychangeproperty(dbus.UInt16,
938
_timedelta_to_milliseconds)
939
approval_duration = notifychangeproperty(
940
dbus.UInt16, "ApprovalDuration",
941
type_func = _timedelta_to_milliseconds)
942
host = notifychangeproperty(dbus.String, "Host")
943
timeout = notifychangeproperty(dbus.UInt16, "Timeout",
945
_timedelta_to_milliseconds)
946
extended_timeout = notifychangeproperty(
947
dbus.UInt16, "ExtendedTimeout",
948
type_func = _timedelta_to_milliseconds)
949
interval = notifychangeproperty(dbus.UInt16,
952
_timedelta_to_milliseconds)
953
checker_command = notifychangeproperty(dbus.String, "Checker")
955
del notifychangeproperty
529
957
def __del__(self, *args, **kwargs):
531
959
self.remove_from_connection()
532
960
except LookupError:
534
if hasattr(dbus.service.Object, u"__del__"):
535
dbus.service.Object.__del__(self, *args, **kwargs)
962
if hasattr(DBusObjectWithProperties, "__del__"):
963
DBusObjectWithProperties.__del__(self, *args, **kwargs)
536
964
Client.__del__(self, *args, **kwargs)
538
966
def checker_callback(self, pid, condition, command,
539
967
*args, **kwargs):
540
968
self.checker_callback_tag = None
541
969
self.checker = None
543
self.PropertyChanged(dbus.String(u"checker_running"),
544
dbus.Boolean(False, variant_level=1))
545
970
if os.WIFEXITED(condition):
546
971
exitstatus = os.WEXITSTATUS(condition)
547
972
# Emit D-Bus signal
578
994
and old_checker_pid != self.checker.pid):
579
995
# Emit D-Bus signal
580
996
self.CheckerStarted(self.current_checker_command)
581
self.PropertyChanged(
582
dbus.String(u"checker_running"),
583
dbus.Boolean(True, variant_level=1))
586
def stop_checker(self, *args, **kwargs):
587
old_checker = getattr(self, u"checker", None)
588
r = Client.stop_checker(self, *args, **kwargs)
589
if (old_checker is not None
590
and getattr(self, u"checker", None) is None):
591
self.PropertyChanged(dbus.String(u"checker_running"),
592
dbus.Boolean(False, variant_level=1))
595
## D-Bus methods & signals
596
_interface = u"se.bsnet.fukt.Mandos.Client"
599
@dbus.service.method(_interface)
601
return self.checked_ok()
999
def _reset_approved(self):
1000
self._approved = None
1003
def approve(self, value=True):
1004
self.send_changedstate()
1005
self._approved = value
1006
gobject.timeout_add(_timedelta_to_milliseconds
1007
(self.approval_duration),
1008
self._reset_approved)
1011
## D-Bus methods, signals & properties
1012
_interface = "se.recompile.Mandos.Client"
603
1016
# CheckerCompleted - signal
604
@dbus.service.signal(_interface, signature=u"nxs")
1017
@dbus.service.signal(_interface, signature="nxs")
605
1018
def CheckerCompleted(self, exitcode, waitstatus, command):
609
1022
# CheckerStarted - signal
610
@dbus.service.signal(_interface, signature=u"s")
1023
@dbus.service.signal(_interface, signature="s")
611
1024
def CheckerStarted(self, command):
615
# GetAllProperties - method
616
@dbus.service.method(_interface, out_signature=u"a{sv}")
617
def GetAllProperties(self):
619
return dbus.Dictionary({
620
dbus.String(u"name"):
621
dbus.String(self.name, variant_level=1),
622
dbus.String(u"fingerprint"):
623
dbus.String(self.fingerprint, variant_level=1),
624
dbus.String(u"host"):
625
dbus.String(self.host, variant_level=1),
626
dbus.String(u"created"):
627
self._datetime_to_dbus(self.created,
629
dbus.String(u"last_enabled"):
630
(self._datetime_to_dbus(self.last_enabled,
632
if self.last_enabled is not None
633
else dbus.Boolean(False, variant_level=1)),
634
dbus.String(u"enabled"):
635
dbus.Boolean(self.enabled, variant_level=1),
636
dbus.String(u"last_checked_ok"):
637
(self._datetime_to_dbus(self.last_checked_ok,
639
if self.last_checked_ok is not None
640
else dbus.Boolean (False, variant_level=1)),
641
dbus.String(u"timeout"):
642
dbus.UInt64(self.timeout_milliseconds(),
644
dbus.String(u"interval"):
645
dbus.UInt64(self.interval_milliseconds(),
647
dbus.String(u"checker"):
648
dbus.String(self.checker_command,
650
dbus.String(u"checker_running"):
651
dbus.Boolean(self.checker is not None,
653
dbus.String(u"object_path"):
654
dbus.ObjectPath(self.dbus_object_path,
658
# IsStillValid - method
659
@dbus.service.method(_interface, out_signature=u"b")
660
def IsStillValid(self):
661
return self.still_valid()
663
1028
# PropertyChanged - signal
664
@dbus.service.signal(_interface, signature=u"sv")
1029
@dbus.service.signal(_interface, signature="sv")
665
1030
def PropertyChanged(self, property, value):
669
# ReceivedSecret - signal
1034
# GotSecret - signal
670
1035
@dbus.service.signal(_interface)
671
def ReceivedSecret(self):
1036
def GotSecret(self):
1038
Is sent after a successful transfer of secret from the Mandos
1039
server to mandos-client
675
1043
# Rejected - signal
676
@dbus.service.signal(_interface)
1044
@dbus.service.signal(_interface, signature="s")
1045
def Rejected(self, reason):
681
# SetChecker - method
682
@dbus.service.method(_interface, in_signature=u"s")
683
def SetChecker(self, checker):
684
"D-Bus setter method"
685
self.checker_command = checker
687
self.PropertyChanged(dbus.String(u"checker"),
688
dbus.String(self.checker_command,
692
@dbus.service.method(_interface, in_signature=u"s")
693
def SetHost(self, host):
694
"D-Bus setter method"
697
self.PropertyChanged(dbus.String(u"host"),
698
dbus.String(self.host, variant_level=1))
700
# SetInterval - method
701
@dbus.service.method(_interface, in_signature=u"t")
702
def SetInterval(self, milliseconds):
703
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
705
self.PropertyChanged(dbus.String(u"interval"),
707
.interval_milliseconds(),
711
@dbus.service.method(_interface, in_signature=u"ay",
713
def SetSecret(self, secret):
714
"D-Bus setter method"
715
self.secret = str(secret)
717
# SetTimeout - method
718
@dbus.service.method(_interface, in_signature=u"t")
719
def SetTimeout(self, milliseconds):
720
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
722
self.PropertyChanged(dbus.String(u"timeout"),
723
(dbus.UInt64(self.timeout_milliseconds(),
1049
# NeedApproval - signal
1050
@dbus.service.signal(_interface, signature="tb")
1051
def NeedApproval(self, timeout, default):
1053
return self.need_approval()
1058
@dbus.service.method(_interface, in_signature="b")
1059
def Approve(self, value):
1062
# CheckedOK - method
1063
@dbus.service.method(_interface)
1064
def CheckedOK(self):
726
1067
# Enable - method
727
1068
@dbus.service.method(_interface)
746
1087
def StopChecker(self):
747
1088
self.stop_checker()
1092
# ApprovalPending - property
1093
@dbus_service_property(_interface, signature="b", access="read")
1094
def ApprovalPending_dbus_property(self):
1095
return dbus.Boolean(bool(self.approvals_pending))
1097
# ApprovedByDefault - property
1098
@dbus_service_property(_interface, signature="b",
1100
def ApprovedByDefault_dbus_property(self, value=None):
1101
if value is None: # get
1102
return dbus.Boolean(self.approved_by_default)
1103
self.approved_by_default = bool(value)
1105
# ApprovalDelay - property
1106
@dbus_service_property(_interface, signature="t",
1108
def ApprovalDelay_dbus_property(self, value=None):
1109
if value is None: # get
1110
return dbus.UInt64(self.approval_delay_milliseconds())
1111
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1113
# ApprovalDuration - property
1114
@dbus_service_property(_interface, signature="t",
1116
def ApprovalDuration_dbus_property(self, value=None):
1117
if value is None: # get
1118
return dbus.UInt64(_timedelta_to_milliseconds(
1119
self.approval_duration))
1120
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1123
@dbus_service_property(_interface, signature="s", access="read")
1124
def Name_dbus_property(self):
1125
return dbus.String(self.name)
1127
# Fingerprint - property
1128
@dbus_service_property(_interface, signature="s", access="read")
1129
def Fingerprint_dbus_property(self):
1130
return dbus.String(self.fingerprint)
1133
@dbus_service_property(_interface, signature="s",
1135
def Host_dbus_property(self, value=None):
1136
if value is None: # get
1137
return dbus.String(self.host)
1140
# Created - property
1141
@dbus_service_property(_interface, signature="s", access="read")
1142
def Created_dbus_property(self):
1143
return dbus.String(datetime_to_dbus(self.created))
1145
# LastEnabled - property
1146
@dbus_service_property(_interface, signature="s", access="read")
1147
def LastEnabled_dbus_property(self):
1148
return datetime_to_dbus(self.last_enabled)
1150
# Enabled - property
1151
@dbus_service_property(_interface, signature="b",
1153
def Enabled_dbus_property(self, value=None):
1154
if value is None: # get
1155
return dbus.Boolean(self.enabled)
1161
# LastCheckedOK - property
1162
@dbus_service_property(_interface, signature="s",
1164
def LastCheckedOK_dbus_property(self, value=None):
1165
if value is not None:
1168
return datetime_to_dbus(self.last_checked_ok)
1170
# Expires - property
1171
@dbus_service_property(_interface, signature="s", access="read")
1172
def Expires_dbus_property(self):
1173
return datetime_to_dbus(self.expires)
1175
# LastApprovalRequest - property
1176
@dbus_service_property(_interface, signature="s", access="read")
1177
def LastApprovalRequest_dbus_property(self):
1178
return datetime_to_dbus(self.last_approval_request)
1180
# Timeout - property
1181
@dbus_service_property(_interface, signature="t",
1183
def Timeout_dbus_property(self, value=None):
1184
if value is None: # get
1185
return dbus.UInt64(self.timeout_milliseconds())
1186
self.timeout = datetime.timedelta(0, 0, 0, value)
1187
if getattr(self, "disable_initiator_tag", None) is None:
1189
# Reschedule timeout
1190
gobject.source_remove(self.disable_initiator_tag)
1191
self.disable_initiator_tag = None
1193
time_to_die = _timedelta_to_milliseconds((self
1198
if time_to_die <= 0:
1199
# The timeout has passed
1202
self.expires = (datetime.datetime.utcnow()
1203
+ datetime.timedelta(milliseconds =
1205
self.disable_initiator_tag = (gobject.timeout_add
1206
(time_to_die, self.disable))
1208
# ExtendedTimeout - property
1209
@dbus_service_property(_interface, signature="t",
1211
def ExtendedTimeout_dbus_property(self, value=None):
1212
if value is None: # get
1213
return dbus.UInt64(self.extended_timeout_milliseconds())
1214
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1216
# Interval - property
1217
@dbus_service_property(_interface, signature="t",
1219
def Interval_dbus_property(self, value=None):
1220
if value is None: # get
1221
return dbus.UInt64(self.interval_milliseconds())
1222
self.interval = datetime.timedelta(0, 0, 0, value)
1223
if getattr(self, "checker_initiator_tag", None) is None:
1225
# Reschedule checker run
1226
gobject.source_remove(self.checker_initiator_tag)
1227
self.checker_initiator_tag = (gobject.timeout_add
1228
(value, self.start_checker))
1229
self.start_checker() # Start one now, too
1231
# Checker - property
1232
@dbus_service_property(_interface, signature="s",
1234
def Checker_dbus_property(self, value=None):
1235
if value is None: # get
1236
return dbus.String(self.checker_command)
1237
self.checker_command = value
1239
# CheckerRunning - property
1240
@dbus_service_property(_interface, signature="b",
1242
def CheckerRunning_dbus_property(self, value=None):
1243
if value is None: # get
1244
return dbus.Boolean(self.checker is not None)
1246
self.start_checker()
1250
# ObjectPath - property
1251
@dbus_service_property(_interface, signature="o", access="read")
1252
def ObjectPath_dbus_property(self):
1253
return self.dbus_object_path # is already a dbus.ObjectPath
1256
@dbus_service_property(_interface, signature="ay",
1257
access="write", byte_arrays=True)
1258
def Secret_dbus_property(self, value):
1259
self.secret = str(value)
1264
class ProxyClient(object):
1265
def __init__(self, child_pipe, fpr, address):
1266
self._pipe = child_pipe
1267
self._pipe.send(('init', fpr, address))
1268
if not self._pipe.recv():
1271
def __getattribute__(self, name):
1272
if(name == '_pipe'):
1273
return super(ProxyClient, self).__getattribute__(name)
1274
self._pipe.send(('getattr', name))
1275
data = self._pipe.recv()
1276
if data[0] == 'data':
1278
if data[0] == 'function':
1279
def func(*args, **kwargs):
1280
self._pipe.send(('funcall', name, args, kwargs))
1281
return self._pipe.recv()[1]
1284
def __setattr__(self, name, value):
1285
if(name == '_pipe'):
1286
return super(ProxyClient, self).__setattr__(name, value)
1287
self._pipe.send(('setattr', name, value))
1289
class ClientDBusTransitional(ClientDBus):
1290
__metaclass__ = AlternateDBusNamesMetaclass
752
1292
class ClientHandler(socketserver.BaseRequestHandler, object):
753
1293
"""A class to handle client connections.
756
1296
Note: This will run in its own forked process."""
758
1298
def handle(self):
759
logger.info(u"TCP connection from: %s",
760
unicode(self.client_address))
761
logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])
762
# Open IPC pipe to parent process
763
with closing(os.fdopen(self.server.pipe[1], u"w", 1)) as ipc:
1299
with contextlib.closing(self.server.child_pipe) as child_pipe:
1300
logger.info("TCP connection from: %s",
1301
unicode(self.client_address))
1302
logger.debug("Pipe FD: %d",
1303
self.server.child_pipe.fileno())
764
1305
session = (gnutls.connection
765
1306
.ClientSession(self.request,
766
1307
gnutls.connection
767
1308
.X509Credentials()))
769
line = self.request.makefile().readline()
770
logger.debug(u"Protocol version: %r", line)
772
if int(line.strip().split()[0]) > 1:
774
except (ValueError, IndexError, RuntimeError), error:
775
logger.error(u"Unknown protocol version: %s", error)
778
1310
# Note: gnutls.connection.X509Credentials is really a
779
1311
# generic GnuTLS certificate credentials object so long as
780
1312
# no X.509 keys are added to it. Therefore, we can use it
781
1313
# here despite using OpenPGP certificates.
783
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
784
# u"+AES-256-CBC", u"+SHA1",
785
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
1315
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1316
# "+AES-256-CBC", "+SHA1",
1317
# "+COMP-NULL", "+CTYPE-OPENPGP",
787
1319
# Use a fallback default, since this MUST be set.
788
1320
priority = self.server.gnutls_priority
789
1321
if priority is None:
791
1323
(gnutls.library.functions
792
1324
.gnutls_priority_set_direct(session._c_object,
793
1325
priority, None))
1327
# Start communication using the Mandos protocol
1328
# Get protocol number
1329
line = self.request.makefile().readline()
1330
logger.debug("Protocol version: %r", line)
1332
if int(line.strip().split()[0]) > 1:
1334
except (ValueError, IndexError, RuntimeError) as error:
1335
logger.error("Unknown protocol version: %s", error)
1338
# Start GnuTLS connection
796
1340
session.handshake()
797
except gnutls.errors.GNUTLSError, error:
798
logger.warning(u"Handshake failed: %s", error)
1341
except gnutls.errors.GNUTLSError as error:
1342
logger.warning("Handshake failed: %s", error)
799
1343
# Do not run session.bye() here: the session is not
800
1344
# established. Just abandon the request.
802
logger.debug(u"Handshake succeeded")
1346
logger.debug("Handshake succeeded")
1348
approval_required = False
804
fpr = self.fingerprint(self.peer_certificate(session))
805
except (TypeError, gnutls.errors.GNUTLSError), error:
806
logger.warning(u"Bad certificate: %s", error)
809
logger.debug(u"Fingerprint: %s", fpr)
1351
fpr = self.fingerprint(self.peer_certificate
1354
gnutls.errors.GNUTLSError) as error:
1355
logger.warning("Bad certificate: %s", error)
1357
logger.debug("Fingerprint: %s", fpr)
1360
client = ProxyClient(child_pipe, fpr,
1361
self.client_address)
1365
if client.approval_delay:
1366
delay = client.approval_delay
1367
client.approvals_pending += 1
1368
approval_required = True
1371
if not client.enabled:
1372
logger.info("Client %s is disabled",
1374
if self.server.use_dbus:
1376
client.Rejected("Disabled")
1379
if client._approved or not client.approval_delay:
1380
#We are approved or approval is disabled
1382
elif client._approved is None:
1383
logger.info("Client %s needs approval",
1385
if self.server.use_dbus:
1387
client.NeedApproval(
1388
client.approval_delay_milliseconds(),
1389
client.approved_by_default)
1391
logger.warning("Client %s was not approved",
1393
if self.server.use_dbus:
1395
client.Rejected("Denied")
1398
#wait until timeout or approved
1399
time = datetime.datetime.now()
1400
client.changedstate.acquire()
1401
(client.changedstate.wait
1402
(float(client._timedelta_to_milliseconds(delay)
1404
client.changedstate.release()
1405
time2 = datetime.datetime.now()
1406
if (time2 - time) >= delay:
1407
if not client.approved_by_default:
1408
logger.warning("Client %s timed out while"
1409
" waiting for approval",
1411
if self.server.use_dbus:
1413
client.Rejected("Approval timed out")
1418
delay -= time2 - time
1421
while sent_size < len(client.secret):
1423
sent = session.send(client.secret[sent_size:])
1424
except gnutls.errors.GNUTLSError as error:
1425
logger.warning("gnutls send failed")
1427
logger.debug("Sent: %d, remaining: %d",
1428
sent, len(client.secret)
1429
- (sent_size + sent))
1432
logger.info("Sending secret to %s", client.name)
1433
# bump the timeout using extended_timeout
1434
client.checked_ok(client.extended_timeout)
1435
if self.server.use_dbus:
811
for c in self.server.clients:
812
if c.fingerprint == fpr:
816
ipc.write(u"NOTFOUND %s %s\n"
817
% (fpr, unicode(self.client_address)))
820
# Have to check if client.still_valid(), since it is
821
# possible that the client timed out while establishing
822
# the GnuTLS session.
823
if not client.still_valid():
824
ipc.write(u"INVALID %s\n" % client.name)
827
ipc.write(u"SENDING %s\n" % client.name)
829
while sent_size < len(client.secret):
830
sent = session.send(client.secret[sent_size:])
831
logger.debug(u"Sent: %d, remaining: %d",
832
sent, len(client.secret)
833
- (sent_size + sent))
1440
if approval_required:
1441
client.approvals_pending -= 1
1444
except gnutls.errors.GNUTLSError as error:
1445
logger.warning("GnuTLS bye failed")
838
1448
def peer_certificate(session):
1025
1663
for cond, name in
1026
1664
condition_names.iteritems()
1027
1665
if cond & condition)
1028
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1031
# Turn the pipe file descriptor into a Python file object
1032
if source not in file_objects:
1033
file_objects[source] = os.fdopen(source, u"r", 1)
1035
# Read a line from the file object
1036
cmdline = file_objects[source].readline()
1037
if not cmdline: # Empty line means end of file
1038
# close the IPC pipe
1039
file_objects[source].close()
1040
del file_objects[source]
1042
# Stop calling this function
1045
logger.debug(u"IPC command: %r", cmdline)
1047
# Parse and act on command
1048
cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)
1050
if cmd == u"NOTFOUND":
1051
logger.warning(u"Client not found for fingerprint: %s",
1055
mandos_dbus_service.ClientNotFound(args)
1056
elif cmd == u"INVALID":
1057
for client in self.clients:
1058
if client.name == args:
1059
logger.warning(u"Client %s is invalid", args)
1065
logger.error(u"Unknown client %s is invalid", args)
1066
elif cmd == u"SENDING":
1067
for client in self.clients:
1068
if client.name == args:
1069
logger.info(u"Sending secret to %s", client.name)
1073
client.ReceivedSecret()
1076
logger.error(u"Sending secret to unknown client %s",
1079
logger.error(u"Unknown IPC command: %r", cmdline)
1081
# Keep calling this function
1666
# error, or the other end of multiprocessing.Pipe has closed
1667
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1668
# Wait for other process to exit
1672
# Read a request from the child
1673
request = parent_pipe.recv()
1674
command = request[0]
1676
if command == 'init':
1678
address = request[2]
1680
for c in self.clients:
1681
if c.fingerprint == fpr:
1685
logger.info("Client not found for fingerprint: %s, ad"
1686
"dress: %s", fpr, address)
1689
mandos_dbus_service.ClientNotFound(fpr,
1691
parent_pipe.send(False)
1694
gobject.io_add_watch(parent_pipe.fileno(),
1695
gobject.IO_IN | gobject.IO_HUP,
1696
functools.partial(self.handle_ipc,
1702
parent_pipe.send(True)
1703
# remove the old hook in favor of the new above hook on
1706
if command == 'funcall':
1707
funcname = request[1]
1711
parent_pipe.send(('data', getattr(client_object,
1715
if command == 'getattr':
1716
attrname = request[1]
1717
if callable(client_object.__getattribute__(attrname)):
1718
parent_pipe.send(('function',))
1720
parent_pipe.send(('data', client_object
1721
.__getattribute__(attrname)))
1723
if command == 'setattr':
1724
attrname = request[1]
1726
setattr(client_object, attrname, value)
1085
1731
def string_to_delta(interval):
1086
1732
"""Parse a string and return a datetime.timedelta
1088
>>> string_to_delta(u'7d')
1734
>>> string_to_delta('7d')
1089
1735
datetime.timedelta(7)
1090
>>> string_to_delta(u'60s')
1736
>>> string_to_delta('60s')
1091
1737
datetime.timedelta(0, 60)
1092
>>> string_to_delta(u'60m')
1738
>>> string_to_delta('60m')
1093
1739
datetime.timedelta(0, 3600)
1094
>>> string_to_delta(u'24h')
1740
>>> string_to_delta('24h')
1095
1741
datetime.timedelta(1)
1096
>>> string_to_delta(u'1w')
1742
>>> string_to_delta('1w')
1097
1743
datetime.timedelta(7)
1098
>>> string_to_delta(u'5m 30s')
1744
>>> string_to_delta('5m 30s')
1099
1745
datetime.timedelta(0, 330)
1101
1747
timevalue = datetime.timedelta(0)
1174
1821
##################################################################
1175
1822
# Parsing of options, both command line and config file
1177
parser = optparse.OptionParser(version = "%%prog %s" % version)
1178
parser.add_option("-i", u"--interface", type=u"string",
1179
metavar="IF", help=u"Bind to interface IF")
1180
parser.add_option("-a", u"--address", type=u"string",
1181
help=u"Address to listen for requests on")
1182
parser.add_option("-p", u"--port", type=u"int",
1183
help=u"Port number to receive requests on")
1184
parser.add_option("--check", action=u"store_true",
1185
help=u"Run self-test")
1186
parser.add_option("--debug", action=u"store_true",
1187
help=u"Debug mode; run in foreground and log to"
1189
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1190
u" priority string (see GnuTLS documentation)")
1191
parser.add_option("--servicename", type=u"string",
1192
metavar=u"NAME", help=u"Zeroconf service name")
1193
parser.add_option("--configdir", type=u"string",
1194
default=u"/etc/mandos", metavar=u"DIR",
1195
help=u"Directory to search for configuration"
1197
parser.add_option("--no-dbus", action=u"store_false",
1198
dest=u"use_dbus", help=u"Do not provide D-Bus"
1199
u" system bus interface")
1200
parser.add_option("--no-ipv6", action=u"store_false",
1201
dest=u"use_ipv6", help=u"Do not use IPv6")
1202
options = parser.parse_args()[0]
1824
parser = argparse.ArgumentParser()
1825
parser.add_argument("-v", "--version", action="version",
1826
version = "%%(prog)s %s" % version,
1827
help="show version number and exit")
1828
parser.add_argument("-i", "--interface", metavar="IF",
1829
help="Bind to interface IF")
1830
parser.add_argument("-a", "--address",
1831
help="Address to listen for requests on")
1832
parser.add_argument("-p", "--port", type=int,
1833
help="Port number to receive requests on")
1834
parser.add_argument("--check", action="store_true",
1835
help="Run self-test")
1836
parser.add_argument("--debug", action="store_true",
1837
help="Debug mode; run in foreground and log"
1839
parser.add_argument("--debuglevel", metavar="LEVEL",
1840
help="Debug level for stdout output")
1841
parser.add_argument("--priority", help="GnuTLS"
1842
" priority string (see GnuTLS documentation)")
1843
parser.add_argument("--servicename",
1844
metavar="NAME", help="Zeroconf service name")
1845
parser.add_argument("--configdir",
1846
default="/etc/mandos", metavar="DIR",
1847
help="Directory to search for configuration"
1849
parser.add_argument("--no-dbus", action="store_false",
1850
dest="use_dbus", help="Do not provide D-Bus"
1851
" system bus interface")
1852
parser.add_argument("--no-ipv6", action="store_false",
1853
dest="use_ipv6", help="Do not use IPv6")
1854
options = parser.parse_args()
1204
1856
if options.check:
1252
1905
##################################################################
1254
1907
# For convenience
1255
debug = server_settings[u"debug"]
1256
use_dbus = server_settings[u"use_dbus"]
1257
use_ipv6 = server_settings[u"use_ipv6"]
1260
syslogger.setLevel(logging.WARNING)
1261
console.setLevel(logging.WARNING)
1263
if server_settings[u"servicename"] != u"Mandos":
1908
debug = server_settings["debug"]
1909
debuglevel = server_settings["debuglevel"]
1910
use_dbus = server_settings["use_dbus"]
1911
use_ipv6 = server_settings["use_ipv6"]
1913
if server_settings["servicename"] != "Mandos":
1264
1914
syslogger.setFormatter(logging.Formatter
1265
(u'Mandos (%s) [%%(process)d]:'
1266
u' %%(levelname)s: %%(message)s'
1267
% server_settings[u"servicename"]))
1915
('Mandos (%s) [%%(process)d]:'
1916
' %%(levelname)s: %%(message)s'
1917
% server_settings["servicename"]))
1269
1919
# Parse config file with clients
1270
client_defaults = { u"timeout": u"1h",
1272
u"checker": u"fping -q -- %%(host)s",
1920
client_defaults = { "timeout": "5m",
1921
"extended_timeout": "15m",
1923
"checker": "fping -q -- %%(host)s",
1925
"approval_delay": "0s",
1926
"approval_duration": "1s",
1275
1928
client_config = configparser.SafeConfigParser(client_defaults)
1276
client_config.read(os.path.join(server_settings[u"configdir"],
1929
client_config.read(os.path.join(server_settings["configdir"],
1279
1932
global mandos_dbus_service
1280
1933
mandos_dbus_service = None
1282
tcp_server = MandosServer((server_settings[u"address"],
1283
server_settings[u"port"]),
1935
tcp_server = MandosServer((server_settings["address"],
1936
server_settings["port"]),
1285
interface=server_settings[u"interface"],
1938
interface=(server_settings["interface"]
1286
1940
use_ipv6=use_ipv6,
1287
1941
gnutls_priority=
1288
server_settings[u"priority"],
1942
server_settings["priority"],
1289
1943
use_dbus=use_dbus)
1290
pidfilename = u"/var/run/mandos.pid"
1292
pidfile = open(pidfilename, u"w")
1294
logger.error(u"Could not open file %r", pidfilename)
1945
pidfilename = "/var/run/mandos.pid"
1947
pidfile = open(pidfilename, "w")
1949
logger.error("Could not open file %r", pidfilename)
1297
uid = pwd.getpwnam(u"_mandos").pw_uid
1298
gid = pwd.getpwnam(u"_mandos").pw_gid
1952
uid = pwd.getpwnam("_mandos").pw_uid
1953
gid = pwd.getpwnam("_mandos").pw_gid
1299
1954
except KeyError:
1301
uid = pwd.getpwnam(u"mandos").pw_uid
1302
gid = pwd.getpwnam(u"mandos").pw_gid
1956
uid = pwd.getpwnam("mandos").pw_uid
1957
gid = pwd.getpwnam("mandos").pw_gid
1303
1958
except KeyError:
1305
uid = pwd.getpwnam(u"nobody").pw_uid
1306
gid = pwd.getpwnam(u"nobody").pw_gid
1960
uid = pwd.getpwnam("nobody").pw_uid
1961
gid = pwd.getpwnam("nobody").pw_gid
1307
1962
except KeyError:
1313
except OSError, error:
1968
except OSError as error:
1314
1969
if error[0] != errno.EPERM:
1317
# Enable all possible GnuTLS debugging
1972
if not debug and not debuglevel:
1973
syslogger.setLevel(logging.WARNING)
1974
console.setLevel(logging.WARNING)
1976
level = getattr(logging, debuglevel.upper())
1977
syslogger.setLevel(level)
1978
console.setLevel(level)
1981
# Enable all possible GnuTLS debugging
1319
1983
# "Use a log level over 10 to enable all debugging options."
1320
1984
# - GnuTLS manual
1321
1985
gnutls.library.functions.gnutls_global_set_log_level(11)
1323
1987
@gnutls.library.types.gnutls_log_func
1324
1988
def debug_gnutls(level, string):
1325
logger.debug(u"GnuTLS: %s", string[:-1])
1989
logger.debug("GnuTLS: %s", string[:-1])
1327
1991
(gnutls.library.functions
1328
1992
.gnutls_global_set_log_function(debug_gnutls))
1994
# Redirect stdin so all checkers get /dev/null
1995
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1996
os.dup2(null, sys.stdin.fileno())
2000
# No console logging
2001
logger.removeHandler(console)
2003
# Need to fork before connecting to D-Bus
2005
# Close all input and output, do double fork, etc.
1330
2008
global main_loop
1331
2009
# From the Avahi example code