156
171
# End of Avahi example code
159
class Client(object):
174
def _datetime_to_dbus(dt, variant_level=0):
175
"""Convert a UTC datetime.datetime() to a D-Bus type."""
176
return dbus.String(dt.isoformat(), variant_level=variant_level)
179
class Client(dbus.service.Object):
160
180
"""A representation of a client host served by this server.
162
name: string; from the config file, used in log messages
182
name: string; from the config file, used in log messages and
163
184
fingerprint: string (40 or 32 hexadecimal digits); used to
164
185
uniquely identify the client
165
secret: bytestring; sent verbatim (over TLS) to client
166
host: string; available for use by the checker command
167
created: datetime.datetime(); object creation, not client host
168
last_checked_ok: datetime.datetime() or None if not yet checked OK
169
timeout: datetime.timedelta(); How long from last_checked_ok
170
until this client is invalid
171
interval: datetime.timedelta(); How often to start a new checker
172
stop_hook: If set, called by stop() as stop_hook(self)
173
checker: subprocess.Popen(); a running checker process used
174
to see if the client lives.
175
'None' if no process is running.
186
secret: bytestring; sent verbatim (over TLS) to client
187
host: string; available for use by the checker command
188
created: datetime.datetime(); (UTC) object creation
189
last_enabled: datetime.datetime(); (UTC)
191
last_checked_ok: datetime.datetime(); (UTC) or None
192
timeout: datetime.timedelta(); How long from last_checked_ok
193
until this client is invalid
194
interval: datetime.timedelta(); How often to start a new checker
195
disable_hook: If set, called by disable() as disable_hook(self)
196
checker: subprocess.Popen(); a running checker process used
197
to see if the client lives.
198
'None' if no process is running.
176
199
checker_initiator_tag: a gobject event source tag, or None
177
stop_initiator_tag: - '' -
200
disable_initiator_tag: - '' -
178
201
checker_callback_tag: - '' -
179
202
checker_command: string; External command which is run to check if
180
203
client lives. %() expansions are done at
181
204
runtime with vars(self) as dict, so that for
182
205
instance %(name)s can be used in the command.
184
_timeout: Real variable for 'timeout'
185
_interval: Real variable for 'interval'
186
_timeout_milliseconds: Used when calling gobject.timeout_add()
187
_interval_milliseconds: - '' -
206
use_dbus: bool(); Whether to provide D-Bus interface and signals
207
dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus
189
def _set_timeout(self, timeout):
190
"Setter function for 'timeout' attribute"
191
self._timeout = timeout
192
self._timeout_milliseconds = ((self.timeout.days
193
* 24 * 60 * 60 * 1000)
194
+ (self.timeout.seconds * 1000)
195
+ (self.timeout.microseconds
197
timeout = property(lambda self: self._timeout,
200
def _set_interval(self, interval):
201
"Setter function for 'interval' attribute"
202
self._interval = interval
203
self._interval_milliseconds = ((self.interval.days
204
* 24 * 60 * 60 * 1000)
205
+ (self.interval.seconds
207
+ (self.interval.microseconds
209
interval = property(lambda self: self._interval,
212
def __init__(self, name = None, stop_hook=None, config={}):
209
def timeout_milliseconds(self):
210
"Return the 'timeout' attribute in milliseconds"
211
return ((self.timeout.days * 24 * 60 * 60 * 1000)
212
+ (self.timeout.seconds * 1000)
213
+ (self.timeout.microseconds // 1000))
215
def interval_milliseconds(self):
216
"Return the 'interval' attribute in milliseconds"
217
return ((self.interval.days * 24 * 60 * 60 * 1000)
218
+ (self.interval.seconds * 1000)
219
+ (self.interval.microseconds // 1000))
221
def __init__(self, name = None, disable_hook=None, config=None,
213
223
"""Note: the 'checker' key in 'config' sets the
214
224
'checker_command' attribute and *not* the 'checker'
217
229
logger.debug(u"Creating client %r", self.name)
230
self.use_dbus = False # During __init__
218
231
# Uppercase and remove spaces from fingerprint for later
219
232
# comparison purposes with return value from the fingerprint()
221
self.fingerprint = config["fingerprint"].upper()\
234
self.fingerprint = (config["fingerprint"].upper()
223
236
logger.debug(u" Fingerprint: %s", self.fingerprint)
224
237
if "secret" in config:
225
238
self.secret = config["secret"].decode(u"base64")
226
239
elif "secfile" in config:
227
sf = open(config["secfile"])
228
self.secret = sf.read()
240
with closing(open(os.path.expanduser
242
(config["secfile"])))) as secfile:
243
self.secret = secfile.read()
231
245
raise TypeError(u"No secret or secfile for client %s"
233
247
self.host = config.get("host", "")
234
self.created = datetime.datetime.now()
248
self.created = datetime.datetime.utcnow()
250
self.last_enabled = None
235
251
self.last_checked_ok = None
236
252
self.timeout = string_to_delta(config["timeout"])
237
253
self.interval = string_to_delta(config["interval"])
238
self.stop_hook = stop_hook
254
self.disable_hook = disable_hook
239
255
self.checker = None
240
256
self.checker_initiator_tag = None
241
self.stop_initiator_tag = None
257
self.disable_initiator_tag = None
242
258
self.checker_callback_tag = None
243
self.check_command = config["checker"]
259
self.checker_command = config["checker"]
260
self.last_connect = None
261
# Only now, when this client is initialized, can it show up on
263
self.use_dbus = use_dbus
265
self.dbus_object_path = (dbus.ObjectPath
267
+ self.name.replace(".", "_")))
268
dbus.service.Object.__init__(self, bus,
269
self.dbus_object_path)
245
272
"""Start this client's checker and timeout hooks"""
273
self.last_enabled = datetime.datetime.utcnow()
246
274
# Schedule a new checker to be started an 'interval' from now,
247
275
# and every interval from then on.
248
self.checker_initiator_tag = gobject.timeout_add\
249
(self._interval_milliseconds,
276
self.checker_initiator_tag = (gobject.timeout_add
277
(self.interval_milliseconds(),
251
279
# Also start a new checker *right now*.
252
280
self.start_checker()
253
# Schedule a stop() when 'timeout' has passed
254
self.stop_initiator_tag = gobject.timeout_add\
255
(self._timeout_milliseconds,
259
The possibility that a client might be restarted is left open,
260
but not currently used."""
261
# If this client doesn't have a secret, it is already stopped.
262
if hasattr(self, "secret") and self.secret:
263
logger.info(u"Stopping client %s", self.name)
281
# Schedule a disable() when 'timeout' has passed
282
self.disable_initiator_tag = (gobject.timeout_add
283
(self.timeout_milliseconds(),
288
self.PropertyChanged(dbus.String(u"enabled"),
289
dbus.Boolean(True, variant_level=1))
290
self.PropertyChanged(dbus.String(u"last_enabled"),
291
(_datetime_to_dbus(self.last_enabled,
295
"""Disable this client."""
296
if not getattr(self, "enabled", False):
267
if getattr(self, "stop_initiator_tag", False):
268
gobject.source_remove(self.stop_initiator_tag)
269
self.stop_initiator_tag = None
298
logger.info(u"Disabling client %s", self.name)
299
if getattr(self, "disable_initiator_tag", False):
300
gobject.source_remove(self.disable_initiator_tag)
301
self.disable_initiator_tag = None
270
302
if getattr(self, "checker_initiator_tag", False):
271
303
gobject.source_remove(self.checker_initiator_tag)
272
304
self.checker_initiator_tag = None
273
305
self.stop_checker()
306
if self.disable_hook:
307
self.disable_hook(self)
311
self.PropertyChanged(dbus.String(u"enabled"),
312
dbus.Boolean(False, variant_level=1))
276
313
# Do not run this again if called by a gobject.timeout_add
278
316
def __del__(self):
279
self.stop_hook = None
281
def checker_callback(self, pid, condition):
317
self.disable_hook = None
320
def checker_callback(self, pid, condition, command):
282
321
"""The checker has completed, so take appropriate actions."""
283
now = datetime.datetime.now()
284
322
self.checker_callback_tag = None
285
323
self.checker = None
286
if os.WIFEXITED(condition) \
287
and (os.WEXITSTATUS(condition) == 0):
288
logger.info(u"Checker for %(name)s succeeded",
290
self.last_checked_ok = now
291
gobject.source_remove(self.stop_initiator_tag)
292
self.stop_initiator_tag = gobject.timeout_add\
293
(self._timeout_milliseconds,
295
elif not os.WIFEXITED(condition):
326
self.PropertyChanged(dbus.String(u"checker_running"),
327
dbus.Boolean(False, variant_level=1))
328
if os.WIFEXITED(condition):
329
exitstatus = os.WEXITSTATUS(condition)
331
logger.info(u"Checker for %(name)s succeeded",
335
logger.info(u"Checker for %(name)s failed",
339
self.CheckerCompleted(dbus.Int16(exitstatus),
340
dbus.Int64(condition),
341
dbus.String(command))
296
343
logger.warning(u"Checker for %(name)s crashed?",
299
logger.info(u"Checker for %(name)s failed",
347
self.CheckerCompleted(dbus.Int16(-1),
348
dbus.Int64(condition),
349
dbus.String(command))
351
def checked_ok(self):
352
"""Bump up the timeout for this client.
353
This should only be called when the client has been seen,
356
self.last_checked_ok = datetime.datetime.utcnow()
357
gobject.source_remove(self.disable_initiator_tag)
358
self.disable_initiator_tag = (gobject.timeout_add
359
(self.timeout_milliseconds(),
363
self.PropertyChanged(
364
dbus.String(u"last_checked_ok"),
365
(_datetime_to_dbus(self.last_checked_ok,
301
368
def start_checker(self):
302
369
"""Start a new checker subprocess if one is not running.
303
370
If a checker already exists, leave it running and do
312
379
# is as it should be.
313
380
if self.checker is None:
315
# In case check_command has exactly one % operator
316
command = self.check_command % self.host
382
# In case checker_command has exactly one % operator
383
command = self.checker_command % self.host
317
384
except TypeError:
318
385
# Escape attributes for the shell
319
386
escaped_attrs = dict((key, re.escape(str(val)))
321
388
vars(self).iteritems())
323
command = self.check_command % escaped_attrs
390
command = self.checker_command % escaped_attrs
324
391
except TypeError, error:
325
392
logger.error(u'Could not format string "%s":'
326
u' %s', self.check_command, error)
393
u' %s', self.checker_command, error)
327
394
return True # Try again later
329
396
logger.info(u"Starting checker %r for %s",
330
397
command, self.name)
398
# We don't need to redirect stdout and stderr, since
399
# in normal mode, that is already done by daemon(),
400
# and in debug mode we don't want to. (Stdin is
401
# always replaced by /dev/null.)
331
402
self.checker = subprocess.Popen(command,
333
404
shell=True, cwd="/")
334
self.checker_callback_tag = gobject.child_watch_add\
336
self.checker_callback)
337
except subprocess.OSError, error:
407
self.CheckerStarted(command)
408
self.PropertyChanged(
409
dbus.String("checker_running"),
410
dbus.Boolean(True, variant_level=1))
411
self.checker_callback_tag = (gobject.child_watch_add
413
self.checker_callback,
415
# The checker may have completed before the gobject
416
# watch was added. Check for this.
417
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
419
gobject.source_remove(self.checker_callback_tag)
420
self.checker_callback(pid, status, command)
421
except OSError, error:
338
422
logger.error(u"Failed to start subprocess: %s",
340
424
# Re-run this periodically if run by gobject.timeout_add
342
427
def stop_checker(self):
343
428
"""Force the checker process, if any, to stop."""
344
429
if self.checker_callback_tag:
356
441
if error.errno != errno.ESRCH: # No such process
358
443
self.checker = None
445
self.PropertyChanged(dbus.String(u"checker_running"),
446
dbus.Boolean(False, variant_level=1))
359
448
def still_valid(self):
360
449
"""Has the timeout not yet passed for this client?"""
361
now = datetime.datetime.now()
450
if not getattr(self, "enabled", False):
452
now = datetime.datetime.utcnow()
362
453
if self.last_checked_ok is None:
363
454
return now < (self.created + self.timeout)
365
456
return now < (self.last_checked_ok + self.timeout)
458
## D-Bus methods & signals
459
_interface = u"se.bsnet.fukt.Mandos.Client"
462
CheckedOK = dbus.service.method(_interface)(checked_ok)
463
CheckedOK.__name__ = "CheckedOK"
465
# CheckerCompleted - signal
466
@dbus.service.signal(_interface, signature="nxs")
467
def CheckerCompleted(self, exitcode, waitstatus, 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,
514
dbus.String("object_path"):
515
dbus.ObjectPath(self.dbus_object_path,
519
# IsStillValid - method
520
IsStillValid = (dbus.service.method(_interface, out_signature="b")
522
IsStillValid.__name__ = "IsStillValid"
524
# PropertyChanged - signal
525
@dbus.service.signal(_interface, signature="sv")
526
def PropertyChanged(self, property, value):
530
# SetChecker - method
531
@dbus.service.method(_interface, in_signature="s")
532
def SetChecker(self, checker):
533
"D-Bus setter method"
534
self.checker_command = checker
536
self.PropertyChanged(dbus.String(u"checker"),
537
dbus.String(self.checker_command,
541
@dbus.service.method(_interface, in_signature="s")
542
def SetHost(self, host):
543
"D-Bus setter method"
546
self.PropertyChanged(dbus.String(u"host"),
547
dbus.String(self.host, variant_level=1))
549
# SetInterval - method
550
@dbus.service.method(_interface, in_signature="t")
551
def SetInterval(self, milliseconds):
552
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
554
self.PropertyChanged(dbus.String(u"interval"),
555
(dbus.UInt64(self.interval_milliseconds(),
559
@dbus.service.method(_interface, in_signature="ay",
561
def SetSecret(self, secret):
562
"D-Bus setter method"
563
self.secret = str(secret)
565
# SetTimeout - method
566
@dbus.service.method(_interface, in_signature="t")
567
def SetTimeout(self, milliseconds):
568
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
570
self.PropertyChanged(dbus.String(u"timeout"),
571
(dbus.UInt64(self.timeout_milliseconds(),
575
Enable = dbus.service.method(_interface)(enable)
576
Enable.__name__ = "Enable"
578
# StartChecker - method
579
@dbus.service.method(_interface)
580
def StartChecker(self):
585
@dbus.service.method(_interface)
590
# StopChecker - method
591
StopChecker = dbus.service.method(_interface)(stop_checker)
592
StopChecker.__name__ = "StopChecker"
368
597
def peer_certificate(session):
369
598
"Return the peer's OpenPGP certificate as a bytestring"
370
599
# If not an OpenPGP certificate...
371
if gnutls.library.functions.gnutls_certificate_type_get\
372
(session._c_object) \
373
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
600
if (gnutls.library.functions
601
.gnutls_certificate_type_get(session._c_object)
602
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
374
603
# ...do the normal thing
375
604
return session.peer_certificate
376
list_size = ctypes.c_uint()
377
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
378
(session._c_object, ctypes.byref(list_size))
605
list_size = ctypes.c_uint(1)
606
cert_list = (gnutls.library.functions
607
.gnutls_certificate_get_peers
608
(session._c_object, ctypes.byref(list_size)))
609
if not bool(cert_list) and list_size.value != 0:
610
raise gnutls.errors.GNUTLSError("error getting peer"
379
612
if list_size.value == 0:
381
614
cert = cert_list[0]
385
618
def fingerprint(openpgp):
386
619
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
387
620
# New GnuTLS "datum" with the OpenPGP public key
388
datum = gnutls.library.types.gnutls_datum_t\
389
(ctypes.cast(ctypes.c_char_p(openpgp),
390
ctypes.POINTER(ctypes.c_ubyte)),
391
ctypes.c_uint(len(openpgp)))
621
datum = (gnutls.library.types
622
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
625
ctypes.c_uint(len(openpgp))))
392
626
# New empty GnuTLS certificate
393
627
crt = gnutls.library.types.gnutls_openpgp_crt_t()
394
gnutls.library.functions.gnutls_openpgp_crt_init\
628
(gnutls.library.functions
629
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
396
630
# Import the OpenPGP public key into the certificate
397
gnutls.library.functions.gnutls_openpgp_crt_import\
398
(crt, ctypes.byref(datum),
399
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
631
(gnutls.library.functions
632
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
633
gnutls.library.constants
634
.GNUTLS_OPENPGP_FMT_RAW))
635
# Verify the self signature in the key
636
crtverify = ctypes.c_uint()
637
(gnutls.library.functions
638
.gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
639
if crtverify.value != 0:
640
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
641
raise gnutls.errors.CertificateSecurityError("Verify failed")
400
642
# New buffer for the fingerprint
401
buffer = ctypes.create_string_buffer(20)
402
buffer_length = ctypes.c_size_t()
643
buf = ctypes.create_string_buffer(20)
644
buf_len = ctypes.c_size_t()
403
645
# Get the fingerprint from the certificate into the buffer
404
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
405
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
646
(gnutls.library.functions
647
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
648
ctypes.byref(buf_len)))
406
649
# Deinit the certificate
407
650
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
408
651
# Convert the buffer to a Python bytestring
409
fpr = ctypes.string_at(buffer, buffer_length.value)
652
fpr = ctypes.string_at(buf, buf_len.value)
410
653
# Convert the bytestring to hexadecimal notation
411
654
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
415
class tcp_handler(SocketServer.BaseRequestHandler, object):
658
class TCP_handler(SocketServer.BaseRequestHandler, object):
416
659
"""A TCP request handler class.
417
660
Instantiated by IPv6_TCPServer for each request to handle it.
418
661
Note: This will run in its own forked process."""
420
663
def handle(self):
421
664
logger.info(u"TCP connection from: %s",
422
unicode(self.client_address))
423
session = gnutls.connection.ClientSession\
424
(self.request, gnutls.connection.X509Credentials())
665
unicode(self.client_address))
666
session = (gnutls.connection
667
.ClientSession(self.request,
426
671
line = self.request.makefile().readline()
427
672
logger.debug(u"Protocol version: %r", line)
686
945
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
687
946
"servicename": "Mandos",
690
950
# Parse config file for server-global settings
691
951
server_config = ConfigParser.SafeConfigParser(server_defaults)
692
952
del server_defaults
693
953
server_config.read(os.path.join(options.configdir, "mandos.conf"))
694
server_section = "server"
695
954
# Convert the SafeConfigParser object to a dict
696
server_settings = dict(server_config.items(server_section))
697
# Use getboolean on the boolean config option
698
server_settings["debug"] = server_config.getboolean\
699
(server_section, "debug")
955
server_settings = server_config.defaults()
956
# Use the appropriate methods on the non-string config options
957
server_settings["debug"] = server_config.getboolean("DEFAULT",
959
server_settings["use_dbus"] = server_config.getboolean("DEFAULT",
961
if server_settings["port"]:
962
server_settings["port"] = server_config.getint("DEFAULT",
700
964
del server_config
702
966
# Override the settings from the config file with command line
703
967
# options, if set.
704
968
for option in ("interface", "address", "port", "debug",
705
"priority", "servicename", "configdir"):
969
"priority", "servicename", "configdir",
706
971
value = getattr(options, option)
707
972
if value is not None:
708
973
server_settings[option] = value
710
975
# Now we have our good server settings in "server_settings"
978
debug = server_settings["debug"]
979
use_dbus = server_settings["use_dbus"]
982
syslogger.setLevel(logging.WARNING)
983
console.setLevel(logging.WARNING)
985
if server_settings["servicename"] != "Mandos":
986
syslogger.setFormatter(logging.Formatter
987
('Mandos (%s): %%(levelname)s:'
989
% server_settings["servicename"]))
712
991
# Parse config file with clients
713
992
client_defaults = { "timeout": "1h",
714
993
"interval": "5m",
715
994
"checker": "fping -q -- %%(host)s",
717
997
client_config = ConfigParser.SafeConfigParser(client_defaults)
718
998
client_config.read(os.path.join(server_settings["configdir"],
1002
tcp_server = IPv6_TCPServer((server_settings["address"],
1003
server_settings["port"]),
1005
settings=server_settings,
1007
pidfilename = "/var/run/mandos.pid"
1009
pidfile = open(pidfilename, "w")
1011
logger.error("Could not open file %r", pidfilename)
1014
uid = pwd.getpwnam("_mandos").pw_uid
1015
gid = pwd.getpwnam("_mandos").pw_gid
1018
uid = pwd.getpwnam("mandos").pw_uid
1019
gid = pwd.getpwnam("mandos").pw_gid
1022
uid = pwd.getpwnam("nobody").pw_uid
1023
gid = pwd.getpwnam("nogroup").pw_gid
1030
except OSError, error:
1031
if error[0] != errno.EPERM:
1034
# Enable all possible GnuTLS debugging
1036
# "Use a log level over 10 to enable all debugging options."
1038
gnutls.library.functions.gnutls_global_set_log_level(11)
1040
@gnutls.library.types.gnutls_log_func
1041
def debug_gnutls(level, string):
1042
logger.debug("GnuTLS: %s", string[:-1])
1044
(gnutls.library.functions
1045
.gnutls_global_set_log_function(debug_gnutls))
722
1048
service = AvahiService(name = server_settings["servicename"],
723
type = "_mandos._tcp", );
1049
servicetype = "_mandos._tcp", )
724
1050
if server_settings["interface"]:
725
service.interface = if_nametoindex(server_settings["interface"])
1051
service.interface = (if_nametoindex
1052
(server_settings["interface"]))
727
1054
global main_loop
731
1058
DBusGMainLoop(set_as_default=True )
732
1059
main_loop = gobject.MainLoop()
733
1060
bus = dbus.SystemBus()
734
server = dbus.Interface(
735
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
736
avahi.DBUS_INTERFACE_SERVER )
1061
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1062
avahi.DBUS_PATH_SERVER),
1063
avahi.DBUS_INTERFACE_SERVER)
737
1064
# End of Avahi example code
739
debug = server_settings["debug"]
742
console = logging.StreamHandler()
743
# console.setLevel(logging.DEBUG)
744
console.setFormatter(logging.Formatter\
745
('%(levelname)s: %(message)s'))
746
logger.addHandler(console)
750
def remove_from_clients(client):
751
clients.remove(client)
753
logger.critical(u"No clients left, exiting")
1066
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
756
1068
clients.update(Set(Client(name = section,
757
stop_hook = remove_from_clients,
759
= dict(client_config.items(section)))
1070
= dict(client_config.items(section)),
1071
use_dbus = use_dbus)
760
1072
for section in client_config.sections()))
762
logger.critical(u"No clients defined")
1074
logger.warning(u"No clients defined")
1077
# Redirect stdin so all checkers get /dev/null
1078
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1079
os.dup2(null, sys.stdin.fileno())
1083
# No console logging
1084
logger.removeHandler(console)
1085
# Close all input and output, do double fork, etc.
768
pidfilename = "/var/run/mandos/mandos.pid"
771
pidfile = open(pidfilename, "w")
772
1090
pidfile.write(str(pid) + "\n")
776
logger.error(u"Could not write %s file with PID %d",
777
pidfilename, os.getpid())
1094
logger.error(u"Could not write to file %r with PID %d",
1097
# "pidfile" was never created
780
1102
"Cleanup function; run on exit"
797
1119
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
798
1120
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1123
class MandosServer(dbus.service.Object):
1124
"""A D-Bus proxy object"""
1126
dbus.service.Object.__init__(self, bus, "/")
1127
_interface = u"se.bsnet.fukt.Mandos"
1129
@dbus.service.signal(_interface, signature="oa{sv}")
1130
def ClientAdded(self, objpath, properties):
1134
@dbus.service.signal(_interface, signature="os")
1135
def ClientRemoved(self, objpath, name):
1139
@dbus.service.method(_interface, out_signature="ao")
1140
def GetAllClients(self):
1142
return dbus.Array(c.dbus_object_path for c in clients)
1144
@dbus.service.method(_interface, out_signature="a{oa{sv}}")
1145
def GetAllClientsWithProperties(self):
1147
return dbus.Dictionary(
1148
((c.dbus_object_path, c.GetAllProperties())
1152
@dbus.service.method(_interface, in_signature="o")
1153
def RemoveClient(self, object_path):
1156
if c.dbus_object_path == object_path:
1158
# Don't signal anything except ClientRemoved
1162
self.ClientRemoved(object_path, c.name)
1168
mandos_server = MandosServer()
800
1170
for client in clients:
803
tcp_server = IPv6_TCPServer((server_settings["address"],
804
server_settings["port"]),
806
settings=server_settings,
1173
mandos_server.ClientAdded(client.dbus_object_path,
1174
client.GetAllProperties())
1178
tcp_server.server_activate()
808
1180
# Find out what port we got
809
1181
service.port = tcp_server.socket.getsockname()[1]
810
1182
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"