106
112
a sensible number of times
108
114
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
109
type = None, port = None, TXT = None, domain = "",
110
host = "", max_renames = 32768):
115
servicetype = None, port = None, TXT = None,
116
domain = "", host = "", max_renames = 32768):
111
117
self.interface = interface
119
self.type = servicetype
121
self.TXT = TXT if TXT is not None else []
119
122
self.domain = domain
121
124
self.rename_count = 0
125
self.max_renames = max_renames
122
126
def rename(self):
123
127
"""Derived from the Avahi example code"""
124
128
if self.rename_count >= self.max_renames:
125
logger.critical(u"No suitable service name found after %i"
126
u" retries, exiting.", rename_count)
127
raise AvahiServiceError("Too many renames")
128
name = server.GetAlternativeServiceName(name)
129
logger.error(u"Changing name to %r ...", name)
130
syslogger.setFormatter(logging.Formatter\
129
logger.critical(u"No suitable Zeroconf service name found"
130
u" after %i retries, exiting.",
132
raise AvahiServiceError(u"Too many renames")
133
self.name = server.GetAlternativeServiceName(self.name)
134
logger.info(u"Changing Zeroconf service name to %r ...",
136
syslogger.setFormatter(logging.Formatter
131
137
('Mandos (%s): %%(levelname)s:'
132
' %%(message)s' % name))
138
' %%(message)s' % self.name))
135
141
self.rename_count += 1
164
170
# End of Avahi example code
167
class Client(object):
173
def _datetime_to_dbus(dt, variant_level=0):
174
"""Convert a UTC datetime.datetime() to a D-Bus type."""
175
return dbus.String(dt.isoformat(), variant_level=variant_level)
178
class Client(dbus.service.Object):
168
179
"""A representation of a client host served by this server.
170
name: string; from the config file, used in log messages
181
name: string; from the config file, used in log messages
171
182
fingerprint: string (40 or 32 hexadecimal digits); used to
172
183
uniquely identify the client
173
secret: bytestring; sent verbatim (over TLS) to client
174
host: string; available for use by the checker command
175
created: datetime.datetime(); object creation, not client host
176
last_checked_ok: datetime.datetime() or None if not yet checked OK
177
timeout: datetime.timedelta(); How long from last_checked_ok
178
until this client is invalid
179
interval: datetime.timedelta(); How often to start a new checker
180
stop_hook: If set, called by stop() as stop_hook(self)
181
checker: subprocess.Popen(); a running checker process used
182
to see if the client lives.
183
'None' if no process is running.
184
secret: bytestring; sent verbatim (over TLS) to client
185
host: string; available for use by the checker command
186
created: datetime.datetime(); (UTC) object creation
187
last_enabled: datetime.datetime(); (UTC)
189
last_checked_ok: datetime.datetime(); (UTC) or None
190
timeout: datetime.timedelta(); How long from last_checked_ok
191
until this client is invalid
192
interval: datetime.timedelta(); How often to start a new checker
193
disable_hook: If set, called by disable() as disable_hook(self)
194
checker: subprocess.Popen(); a running checker process used
195
to see if the client lives.
196
'None' if no process is running.
184
197
checker_initiator_tag: a gobject event source tag, or None
185
stop_initiator_tag: - '' -
198
disable_initiator_tag: - '' -
186
199
checker_callback_tag: - '' -
187
200
checker_command: string; External command which is run to check if
188
201
client lives. %() expansions are done at
189
202
runtime with vars(self) as dict, so that for
190
203
instance %(name)s can be used in the command.
204
dbus_object_path: dbus.ObjectPath
191
205
Private attibutes:
192
206
_timeout: Real variable for 'timeout'
193
207
_interval: Real variable for 'interval'
215
233
+ (self.interval.microseconds
217
interval = property(lambda self: self._interval,
236
self.PropertyChanged(dbus.String(u"interval"),
237
(dbus.UInt64(self._interval_milliseconds,
239
interval = property(lambda self: self._interval, _set_interval)
219
240
del _set_interval
220
def __init__(self, name = None, stop_hook=None, config={}):
242
def __init__(self, name = None, disable_hook=None, config=None):
221
243
"""Note: the 'checker' key in 'config' sets the
222
244
'checker_command' attribute and *not* the 'checker'
246
self.dbus_object_path = (dbus.ObjectPath
248
+ name.replace(".", "_")))
249
dbus.service.Object.__init__(self, bus,
250
self.dbus_object_path)
225
254
logger.debug(u"Creating client %r", self.name)
226
255
# Uppercase and remove spaces from fingerprint for later
227
256
# comparison purposes with return value from the fingerprint()
229
self.fingerprint = config["fingerprint"].upper()\
258
self.fingerprint = (config["fingerprint"].upper()
231
260
logger.debug(u" Fingerprint: %s", self.fingerprint)
232
261
if "secret" in config:
233
262
self.secret = config["secret"].decode(u"base64")
234
263
elif "secfile" in config:
235
sf = open(config["secfile"])
236
self.secret = sf.read()
264
with closing(open(os.path.expanduser
266
(config["secfile"])))) as secfile:
267
self.secret = secfile.read()
239
269
raise TypeError(u"No secret or secfile for client %s"
241
271
self.host = config.get("host", "")
242
self.created = datetime.datetime.now()
272
self.created = datetime.datetime.utcnow()
274
self.last_enabled = None
243
275
self.last_checked_ok = None
244
276
self.timeout = string_to_delta(config["timeout"])
245
277
self.interval = string_to_delta(config["interval"])
246
self.stop_hook = stop_hook
278
self.disable_hook = disable_hook
247
279
self.checker = None
248
280
self.checker_initiator_tag = None
249
self.stop_initiator_tag = None
281
self.disable_initiator_tag = None
250
282
self.checker_callback_tag = None
251
self.check_command = config["checker"]
283
self.checker_command = config["checker"]
253
286
"""Start this client's checker and timeout hooks"""
287
self.last_enabled = datetime.datetime.utcnow()
254
288
# Schedule a new checker to be started an 'interval' from now,
255
289
# and every interval from then on.
256
self.checker_initiator_tag = gobject.timeout_add\
257
(self._interval_milliseconds,
290
self.checker_initiator_tag = (gobject.timeout_add
291
(self._interval_milliseconds,
259
293
# Also start a new checker *right now*.
260
294
self.start_checker()
261
# Schedule a stop() when 'timeout' has passed
262
self.stop_initiator_tag = gobject.timeout_add\
263
(self._timeout_milliseconds,
267
The possibility that a client might be restarted is left open,
268
but not currently used."""
269
# If this client doesn't have a secret, it is already stopped.
270
if hasattr(self, "secret") and self.secret:
271
logger.info(u"Stopping client %s", self.name)
295
# Schedule a disable() when 'timeout' has passed
296
self.disable_initiator_tag = (gobject.timeout_add
297
(self._timeout_milliseconds,
301
self.PropertyChanged(dbus.String(u"enabled"),
302
dbus.Boolean(True, variant_level=1))
303
self.PropertyChanged(dbus.String(u"last_enabled"),
304
(_datetime_to_dbus(self.last_enabled,
308
"""Disable this client."""
309
if not getattr(self, "enabled", False):
275
if getattr(self, "stop_initiator_tag", False):
276
gobject.source_remove(self.stop_initiator_tag)
277
self.stop_initiator_tag = None
311
logger.info(u"Disabling client %s", self.name)
312
if getattr(self, "disable_initiator_tag", False):
313
gobject.source_remove(self.disable_initiator_tag)
314
self.disable_initiator_tag = None
278
315
if getattr(self, "checker_initiator_tag", False):
279
316
gobject.source_remove(self.checker_initiator_tag)
280
317
self.checker_initiator_tag = None
281
318
self.stop_checker()
319
if self.disable_hook:
320
self.disable_hook(self)
323
self.PropertyChanged(dbus.String(u"enabled"),
324
dbus.Boolean(False, variant_level=1))
284
325
# Do not run this again if called by a gobject.timeout_add
286
328
def __del__(self):
287
self.stop_hook = None
289
def checker_callback(self, pid, condition):
329
self.disable_hook = None
332
def checker_callback(self, pid, condition, command):
290
333
"""The checker has completed, so take appropriate actions."""
291
now = datetime.datetime.now()
292
334
self.checker_callback_tag = None
293
335
self.checker = None
294
if os.WIFEXITED(condition) \
295
and (os.WEXITSTATUS(condition) == 0):
337
self.PropertyChanged(dbus.String(u"checker_running"),
338
dbus.Boolean(False, variant_level=1))
339
if (os.WIFEXITED(condition)
340
and (os.WEXITSTATUS(condition) == 0)):
296
341
logger.info(u"Checker for %(name)s succeeded",
298
self.last_checked_ok = now
299
gobject.source_remove(self.stop_initiator_tag)
300
self.stop_initiator_tag = gobject.timeout_add\
301
(self._timeout_milliseconds,
344
self.CheckerCompleted(dbus.Boolean(True),
345
dbus.UInt16(condition),
346
dbus.String(command))
303
348
elif not os.WIFEXITED(condition):
304
349
logger.warning(u"Checker for %(name)s crashed?",
352
self.CheckerCompleted(dbus.Boolean(False),
353
dbus.UInt16(condition),
354
dbus.String(command))
307
356
logger.info(u"Checker for %(name)s failed",
359
self.CheckerCompleted(dbus.Boolean(False),
360
dbus.UInt16(condition),
361
dbus.String(command))
363
def bump_timeout(self):
364
"""Bump up the timeout for this client.
365
This should only be called when the client has been seen,
368
self.last_checked_ok = datetime.datetime.utcnow()
369
gobject.source_remove(self.disable_initiator_tag)
370
self.disable_initiator_tag = (gobject.timeout_add
371
(self._timeout_milliseconds,
373
self.PropertyChanged(dbus.String(u"last_checked_ok"),
374
(_datetime_to_dbus(self.last_checked_ok,
309
377
def start_checker(self):
310
378
"""Start a new checker subprocess if one is not running.
311
379
If a checker already exists, leave it running and do
320
388
# is as it should be.
321
389
if self.checker is None:
323
# In case check_command has exactly one % operator
324
command = self.check_command % self.host
391
# In case checker_command has exactly one % operator
392
command = self.checker_command % self.host
325
393
except TypeError:
326
394
# Escape attributes for the shell
327
395
escaped_attrs = dict((key, re.escape(str(val)))
329
397
vars(self).iteritems())
331
command = self.check_command % escaped_attrs
399
command = self.checker_command % escaped_attrs
332
400
except TypeError, error:
333
401
logger.error(u'Could not format string "%s":'
334
u' %s', self.check_command, error)
402
u' %s', self.checker_command, error)
335
403
return True # Try again later
337
405
logger.info(u"Starting checker %r for %s",
338
406
command, self.name)
407
# We don't need to redirect stdout and stderr, since
408
# in normal mode, that is already done by daemon(),
409
# and in debug mode we don't want to. (Stdin is
410
# always replaced by /dev/null.)
339
411
self.checker = subprocess.Popen(command,
341
413
shell=True, cwd="/")
342
self.checker_callback_tag = gobject.child_watch_add\
344
self.checker_callback)
345
except subprocess.OSError, error:
415
self.CheckerStarted(command)
416
self.PropertyChanged(dbus.String("checker_running"),
417
dbus.Boolean(True, variant_level=1))
418
self.checker_callback_tag = (gobject.child_watch_add
420
self.checker_callback,
422
except OSError, error:
346
423
logger.error(u"Failed to start subprocess: %s",
348
425
# Re-run this periodically if run by gobject.timeout_add
350
428
def stop_checker(self):
351
429
"""Force the checker process, if any, to stop."""
352
430
if self.checker_callback_tag:
364
442
if error.errno != errno.ESRCH: # No such process
366
444
self.checker = None
445
self.PropertyChanged(dbus.String(u"checker_running"),
446
dbus.Boolean(False, variant_level=1))
367
448
def still_valid(self):
368
449
"""Has the timeout not yet passed for this client?"""
369
now = datetime.datetime.now()
450
if not getattr(self, "enabled", False):
452
now = datetime.datetime.utcnow()
370
453
if self.last_checked_ok is None:
371
454
return now < (self.created + self.timeout)
373
456
return now < (self.last_checked_ok + self.timeout)
458
## D-Bus methods & signals
459
_interface = u"org.mandos_system.Mandos.Client"
461
# BumpTimeout - method
462
BumpTimeout = dbus.service.method(_interface)(bump_timeout)
463
BumpTimeout.__name__ = "BumpTimeout"
465
# CheckerCompleted - signal
466
@dbus.service.signal(_interface, signature="bqs")
467
def CheckerCompleted(self, success, condition, command):
471
# CheckerStarted - signal
472
@dbus.service.signal(_interface, signature="s")
473
def CheckerStarted(self, command):
477
# GetAllProperties - method
478
@dbus.service.method(_interface, out_signature="a{sv}")
479
def GetAllProperties(self):
481
return dbus.Dictionary({
483
dbus.String(self.name, variant_level=1),
484
dbus.String("fingerprint"):
485
dbus.String(self.fingerprint, variant_level=1),
487
dbus.String(self.host, variant_level=1),
488
dbus.String("created"):
489
_datetime_to_dbus(self.created, variant_level=1),
490
dbus.String("last_enabled"):
491
(_datetime_to_dbus(self.last_enabled,
493
if self.last_enabled is not None
494
else dbus.Boolean(False, variant_level=1)),
495
dbus.String("enabled"):
496
dbus.Boolean(self.enabled, variant_level=1),
497
dbus.String("last_checked_ok"):
498
(_datetime_to_dbus(self.last_checked_ok,
500
if self.last_checked_ok is not None
501
else dbus.Boolean (False, variant_level=1)),
502
dbus.String("timeout"):
503
dbus.UInt64(self._timeout_milliseconds,
505
dbus.String("interval"):
506
dbus.UInt64(self._interval_milliseconds,
508
dbus.String("checker"):
509
dbus.String(self.checker_command,
511
dbus.String("checker_running"):
512
dbus.Boolean(self.checker is not None,
516
# IsStillValid - method
517
IsStillValid = (dbus.service.method(_interface, out_signature="b")
519
IsStillValid.__name__ = "IsStillValid"
521
# PropertyChanged - signal
522
@dbus.service.signal(_interface, signature="sv")
523
def PropertyChanged(self, property, value):
527
# SetChecker - method
528
@dbus.service.method(_interface, in_signature="s")
529
def SetChecker(self, checker):
530
"D-Bus setter method"
531
self.checker_command = checker
534
@dbus.service.method(_interface, in_signature="s")
535
def SetHost(self, host):
536
"D-Bus setter method"
539
# SetInterval - method
540
@dbus.service.method(_interface, in_signature="t")
541
def SetInterval(self, milliseconds):
542
self.interval = datetime.timdeelta(0, 0, 0, milliseconds)
545
@dbus.service.method(_interface, in_signature="ay",
547
def SetSecret(self, secret):
548
"D-Bus setter method"
549
self.secret = str(secret)
551
# SetTimeout - method
552
@dbus.service.method(_interface, in_signature="t")
553
def SetTimeout(self, milliseconds):
554
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
557
Enable = dbus.service.method(_interface)(enable)
558
Enable.__name__ = "Enable"
560
# StartChecker - method
561
@dbus.service.method(_interface)
562
def StartChecker(self):
567
@dbus.service.method(_interface)
572
# StopChecker - method
573
StopChecker = dbus.service.method(_interface)(stop_checker)
574
StopChecker.__name__ = "StopChecker"
376
579
def peer_certificate(session):
377
580
"Return the peer's OpenPGP certificate as a bytestring"
378
581
# If not an OpenPGP certificate...
379
if gnutls.library.functions.gnutls_certificate_type_get\
380
(session._c_object) \
381
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
582
if (gnutls.library.functions
583
.gnutls_certificate_type_get(session._c_object)
584
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
382
585
# ...do the normal thing
383
586
return session.peer_certificate
384
587
list_size = ctypes.c_uint()
385
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
386
(session._c_object, ctypes.byref(list_size))
588
cert_list = (gnutls.library.functions
589
.gnutls_certificate_get_peers
590
(session._c_object, ctypes.byref(list_size)))
387
591
if list_size.value == 0:
389
593
cert = cert_list[0]
393
597
def fingerprint(openpgp):
394
598
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
395
599
# New GnuTLS "datum" with the OpenPGP public key
396
datum = gnutls.library.types.gnutls_datum_t\
397
(ctypes.cast(ctypes.c_char_p(openpgp),
398
ctypes.POINTER(ctypes.c_ubyte)),
399
ctypes.c_uint(len(openpgp)))
600
datum = (gnutls.library.types
601
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
604
ctypes.c_uint(len(openpgp))))
400
605
# New empty GnuTLS certificate
401
606
crt = gnutls.library.types.gnutls_openpgp_crt_t()
402
gnutls.library.functions.gnutls_openpgp_crt_init\
607
(gnutls.library.functions
608
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
404
609
# Import the OpenPGP public key into the certificate
405
gnutls.library.functions.gnutls_openpgp_crt_import\
406
(crt, ctypes.byref(datum),
407
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
610
(gnutls.library.functions
611
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
612
gnutls.library.constants
613
.GNUTLS_OPENPGP_FMT_RAW))
614
# Verify the self signature in the key
615
crtverify = ctypes.c_uint()
616
(gnutls.library.functions
617
.gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
618
if crtverify.value != 0:
619
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
620
raise gnutls.errors.CertificateSecurityError("Verify failed")
408
621
# New buffer for the fingerprint
409
buffer = ctypes.create_string_buffer(20)
410
buffer_length = ctypes.c_size_t()
622
buf = ctypes.create_string_buffer(20)
623
buf_len = ctypes.c_size_t()
411
624
# Get the fingerprint from the certificate into the buffer
412
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
413
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
625
(gnutls.library.functions
626
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
627
ctypes.byref(buf_len)))
414
628
# Deinit the certificate
415
629
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
416
630
# Convert the buffer to a Python bytestring
417
fpr = ctypes.string_at(buffer, buffer_length.value)
631
fpr = ctypes.string_at(buf, buf_len.value)
418
632
# Convert the bytestring to hexadecimal notation
419
633
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
423
class tcp_handler(SocketServer.BaseRequestHandler, object):
637
class TCP_handler(SocketServer.BaseRequestHandler, object):
424
638
"""A TCP request handler class.
425
639
Instantiated by IPv6_TCPServer for each request to handle it.
426
640
Note: This will run in its own forked process."""
428
642
def handle(self):
429
643
logger.info(u"TCP connection from: %s",
430
unicode(self.client_address))
431
session = gnutls.connection.ClientSession\
432
(self.request, gnutls.connection.X509Credentials())
644
unicode(self.client_address))
645
session = (gnutls.connection
646
.ClientSession(self.request,
434
650
line = self.request.makefile().readline()
435
651
logger.debug(u"Protocol version: %r", line)
562
786
datetime.timedelta(1)
563
787
>>> string_to_delta(u'1w')
564
788
datetime.timedelta(7)
789
>>> string_to_delta('5m 30s')
790
datetime.timedelta(0, 330)
567
suffix=unicode(interval[-1])
568
value=int(interval[:-1])
570
delta = datetime.timedelta(value)
572
delta = datetime.timedelta(0, value)
574
delta = datetime.timedelta(0, 0, 0, 0, value)
576
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
578
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
792
timevalue = datetime.timedelta(0)
793
for s in interval.split():
795
suffix = unicode(s[-1])
798
delta = datetime.timedelta(value)
800
delta = datetime.timedelta(0, value)
802
delta = datetime.timedelta(0, 0, 0, 0, value)
804
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
806
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
809
except (ValueError, IndexError):
581
except (ValueError, IndexError):
586
815
def server_state_changed(state):
587
816
"""Derived from the Avahi example code"""
588
817
if state == avahi.SERVER_COLLISION:
589
logger.error(u"Server name collision")
818
logger.error(u"Zeroconf server name collision")
591
820
elif state == avahi.SERVER_RUNNING:
595
824
def entry_group_state_changed(state, error):
596
825
"""Derived from the Avahi example code"""
597
logger.debug(u"state change: %i", state)
826
logger.debug(u"Avahi state change: %i", state)
599
828
if state == avahi.ENTRY_GROUP_ESTABLISHED:
600
logger.debug(u"Service established.")
829
logger.debug(u"Zeroconf service established.")
601
830
elif state == avahi.ENTRY_GROUP_COLLISION:
602
logger.warning(u"Service name collision.")
831
logger.warning(u"Zeroconf service name collision.")
604
833
elif state == avahi.ENTRY_GROUP_FAILURE:
605
logger.critical(u"Error in group state changed %s",
834
logger.critical(u"Avahi: Error in group state changed %s",
607
raise AvahiGroupError("State changed: %s", str(error))
836
raise AvahiGroupError(u"State changed: %s" % unicode(error))
609
838
def if_nametoindex(interface):
610
839
"""Call the C function if_nametoindex(), or equivalent"""
611
840
global if_nametoindex
613
if "ctypes.util" not in sys.modules:
615
if_nametoindex = ctypes.cdll.LoadLibrary\
616
(ctypes.util.find_library("c")).if_nametoindex
842
if_nametoindex = (ctypes.cdll.LoadLibrary
843
(ctypes.util.find_library("c"))
617
845
except (OSError, AttributeError):
618
846
if "struct" not in sys.modules:
732
955
# Parse config file with clients
733
956
client_defaults = { "timeout": "1h",
734
957
"interval": "5m",
735
"checker": "fping -q -- %%(host)s",
958
"checker": "fping -q -- %(host)s",
737
961
client_config = ConfigParser.SafeConfigParser(client_defaults)
738
962
client_config.read(os.path.join(server_settings["configdir"],
966
tcp_server = IPv6_TCPServer((server_settings["address"],
967
server_settings["port"]),
969
settings=server_settings,
971
pidfilename = "/var/run/mandos.pid"
973
pidfile = open(pidfilename, "w")
974
except IOError, error:
975
logger.error("Could not open file %r", pidfilename)
978
uid = pwd.getpwnam("_mandos").pw_uid
981
uid = pwd.getpwnam("mandos").pw_uid
984
uid = pwd.getpwnam("nobody").pw_uid
988
gid = pwd.getpwnam("_mandos").pw_gid
991
gid = pwd.getpwnam("mandos").pw_gid
994
gid = pwd.getpwnam("nogroup").pw_gid
1000
except OSError, error:
1001
if error[0] != errno.EPERM:
742
1005
service = AvahiService(name = server_settings["servicename"],
743
type = "_mandos._tcp", );
1006
servicetype = "_mandos._tcp", )
744
1007
if server_settings["interface"]:
745
service.interface = if_nametoindex(server_settings["interface"])
1008
service.interface = (if_nametoindex
1009
(server_settings["interface"]))
747
1011
global main_loop
808
1075
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
809
1076
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1078
class MandosServer(dbus.service.Object):
1079
"""A D-Bus proxy object"""
1081
dbus.service.Object.__init__(self, bus,
1083
_interface = u"org.mandos_system.Mandos"
1085
@dbus.service.signal(_interface, signature="oa{sv}")
1086
def ClientAdded(self, objpath, properties):
1090
@dbus.service.signal(_interface, signature="o")
1091
def ClientRemoved(self, objpath):
1095
@dbus.service.method(_interface, out_signature="ao")
1096
def GetAllClients(self):
1097
return dbus.Array(c.dbus_object_path for c in clients)
1099
@dbus.service.method(_interface, out_signature="a{oa{sv}}")
1100
def GetAllClientsWithProperties(self):
1101
return dbus.Dictionary(
1102
((c.dbus_object_path, c.GetAllProperties())
1106
@dbus.service.method(_interface, in_signature="o")
1107
def RemoveClient(self, object_path):
1109
if c.dbus_object_path == object_path:
1117
mandos_server = MandosServer()
811
1119
for client in clients:
814
tcp_server = IPv6_TCPServer((server_settings["address"],
815
server_settings["port"]),
817
settings=server_settings,
1121
mandos_server.ClientAdded(client.dbus_object_path,
1122
client.GetAllProperties())
1126
tcp_server.server_activate()
819
1128
# Find out what port we got
820
1129
service.port = tcp_server.socket.getsockname()[1]
821
1130
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"