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