To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 237.7.332
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.332
- Committer: Teddy Hogeborn
- Date: 2015-08-10 08:25:01 UTC
- mto: (237.7.594 trunk)
- mto: This revision was merged to the branch mainline in revision 325.
- Revision ID: teddy@recompile.se-20150810082501-rb7w2dre1flqiqe2
Refactor D-Bus annotation class out from D-Bus properties class.
* mandos (DBusObjectWithAnnotations): New; factored out D-Bus
annotations code from
DBusObjectWithProperties class.
(DBusObjectWithProperties): Inherit from DBusObjectWithAnnotations.
(main/MandosDBusService): - '' -
(main/MandosDBusService._foo): Removed interface annotation for
"o.f.D.Property.EmitsChangedSignal";
this object has no properties.
* mandos (DBusObjectWithAnnotations): New; factored out D-Bus
annotations code from
DBusObjectWithProperties class.
(DBusObjectWithProperties): Inherit from DBusObjectWithAnnotations.
(main/MandosDBusService): - '' -
(main/MandosDBusService._foo): Removed interface annotation for
"o.f.D.Property.EmitsChangedSignal";
this object has no properties.
- files added:
- debian/mandos-client.examples
- debian/upstream
- network-hooks.d
- plugin-helpers
- files modified:
- .bzrignore
added
removed
mandos
1
#!/usr/bin/python
1
#!/usr/bin/python2.7
2
2
# -*- mode: python; coding: utf-8 -*-
3
3
#
4
4
# Mandos server - give out binary blobs to connecting clients.
11
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2008-2011 Teddy Hogeborn
15
# Copyright © 2008-2011 Björn Påhlsson
14
# Copyright © 2008-2015 Teddy Hogeborn
15
# Copyright © 2008-2015 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
34
34
from __future__ import (division, absolute_import, print_function,
35
35
unicode_literals)
36
36
37
import SocketServer as socketserver
37
from future_builtins import *
38
39
try:
40
import SocketServer as socketserver
41
except ImportError:
42
import socketserver
38
43
import socket
39
44
import argparse
40
45
import datetime
45
50
import gnutls.library.functions
46
51
import gnutls.library.constants
47
52
import gnutls.library.types
48
import ConfigParser as configparser
53
try:
54
import ConfigParser as configparser
55
except ImportError:
56
import configparser
49
57
import sys
50
58
import re
51
59
import os
60
68
import struct
61
69
import fcntl
62
70
import functools
63
import cPickle as pickle
71
try:
72
import cPickle as pickle
73
except ImportError:
74
import pickle
64
75
import multiprocessing
65
76
import types
66
77
import binascii
67
78
import tempfile
79
import itertools
80
import collections
81
import codecs
68
82
69
83
import dbus
70
84
import dbus.service
71
import gobject
85
try:
86
import gobject
87
except ImportError:
88
from gi.repository import GObject as gobject
72
89
import avahi
73
90
from dbus.mainloop.glib import DBusGMainLoop
74
91
import ctypes
75
92
import ctypes.util
76
93
import xml.dom.minidom
77
94
import inspect
78
import GnuPGInterface
79
95
80
96
try:
81
97
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
85
101
except ImportError:
86
102
SO_BINDTODEVICE = None
87
103
88
version = "1.4.1"
104
if sys.version_info.major == 2:
105
str = unicode
106
107
version = "1.6.9"
89
108
stored_state_file = "clients.pickle"
90
109
91
110
logger = logging.getLogger()
92
syslogger = (logging.handlers.SysLogHandler
93
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
94
address = str("/dev/log")))
111
syslogger = None
95
112
96
113
try:
97
if_nametoindex = (ctypes.cdll.LoadLibrary
98
(ctypes.util.find_library("c"))
99
.if_nametoindex)
114
if_nametoindex = ctypes.cdll.LoadLibrary(
115
ctypes.util.find_library("c")).if_nametoindex
100
116
except (OSError, AttributeError):
117
101
118
def if_nametoindex(interface):
102
119
"Get an interface index the hard way, i.e. using fcntl()"
103
120
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
104
121
with contextlib.closing(socket.socket()) as s:
105
122
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
106
struct.pack(str("16s16x"),
107
interface))
108
interface_index = struct.unpack(str("I"),
109
ifreq[16:20])[0]
123
struct.pack(b"16s16x", interface))
124
interface_index = struct.unpack("I", ifreq[16:20])[0]
110
125
return interface_index
111
126
112
127
113
def initlogger(level=logging.WARNING):
128
def initlogger(debug, level=logging.WARNING):
114
129
"""init logger and add loglevel"""
115
130
131
global syslogger
132
syslogger = (logging.handlers.SysLogHandler(
133
facility = logging.handlers.SysLogHandler.LOG_DAEMON,
134
address = "/dev/log"))
116
135
syslogger.setFormatter(logging.Formatter
117
136
('Mandos [%(process)d]: %(levelname)s:'
118
137
' %(message)s'))
119
138
logger.addHandler(syslogger)
120
139
121
console = logging.StreamHandler()
122
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
123
' [%(process)d]:'
124
' %(levelname)s:'
125
' %(message)s'))
126
logger.addHandler(console)
140
if debug:
141
console = logging.StreamHandler()
142
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
143
' [%(process)d]:'
144
' %(levelname)s:'
145
' %(message)s'))
146
logger.addHandler(console)
127
147
logger.setLevel(level)
128
148
129
149
134
154
135
155
class PGPEngine(object):
136
156
"""A simple class for OpenPGP symmetric encryption & decryption"""
157
137
158
def __init__(self):
138
self.gnupg = GnuPGInterface.GnuPG()
139
159
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
140
self.gnupg = GnuPGInterface.GnuPG()
141
self.gnupg.options.meta_interactive = False
142
self.gnupg.options.homedir = self.tempdir
143
self.gnupg.options.extra_args.extend(['--force-mdc',
144
'--quiet'])
160
self.gnupgargs = ['--batch',
161
'--home', self.tempdir,
162
'--force-mdc',
163
'--quiet',
164
'--no-use-agent']
145
165
146
166
def __enter__(self):
147
167
return self
148
168
149
def __exit__ (self, exc_type, exc_value, traceback):
169
def __exit__(self, exc_type, exc_value, traceback):
150
170
self._cleanup()
151
171
return False
152
172
169
189
def password_encode(self, password):
170
190
# Passphrase can not be empty and can not contain newlines or
171
191
# NUL bytes. So we prefix it and hex encode it.
172
return b"mandos" + binascii.hexlify(password)
192
encoded = b"mandos" + binascii.hexlify(password)
193
if len(encoded) > 2048:
194
# GnuPG can't handle long passwords, so encode differently
195
encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
196
.replace(b"\n", b"\\n")
197
.replace(b"\0", b"\\x00"))
198
return encoded
173
199
174
200
def encrypt(self, data, password):
175
self.gnupg.passphrase = self.password_encode(password)
176
with open(os.devnull) as devnull:
177
try:
178
proc = self.gnupg.run(['--symmetric'],
179
create_fhs=['stdin', 'stdout'],
180
attach_fhs={'stderr': devnull})
181
with contextlib.closing(proc.handles['stdin']) as f:
182
f.write(data)
183
with contextlib.closing(proc.handles['stdout']) as f:
184
ciphertext = f.read()
185
proc.wait()
186
except IOError as e:
187
raise PGPError(e)
188
self.gnupg.passphrase = None
201
passphrase = self.password_encode(password)
202
with tempfile.NamedTemporaryFile(
203
dir=self.tempdir) as passfile:
204
passfile.write(passphrase)
205
passfile.flush()
206
proc = subprocess.Popen(['gpg', '--symmetric',
207
'--passphrase-file',
208
passfile.name]
209
+ self.gnupgargs,
210
stdin = subprocess.PIPE,
211
stdout = subprocess.PIPE,
212
stderr = subprocess.PIPE)
213
ciphertext, err = proc.communicate(input = data)
214
if proc.returncode != 0:
215
raise PGPError(err)
189
216
return ciphertext
190
217
191
218
def decrypt(self, data, password):
192
self.gnupg.passphrase = self.password_encode(password)
193
with open(os.devnull) as devnull:
194
try:
195
proc = self.gnupg.run(['--decrypt'],
196
create_fhs=['stdin', 'stdout'],
197
attach_fhs={'stderr': devnull})
198
with contextlib.closing(proc.handles['stdin'] ) as f:
199
f.write(data)
200
with contextlib.closing(proc.handles['stdout']) as f:
201
decrypted_plaintext = f.read()
202
proc.wait()
203
except IOError as e:
204
raise PGPError(e)
205
self.gnupg.passphrase = None
219
passphrase = self.password_encode(password)
220
with tempfile.NamedTemporaryFile(
221
dir = self.tempdir) as passfile:
222
passfile.write(passphrase)
223
passfile.flush()
224
proc = subprocess.Popen(['gpg', '--decrypt',
225
'--passphrase-file',
226
passfile.name]
227
+ self.gnupgargs,
228
stdin = subprocess.PIPE,
229
stdout = subprocess.PIPE,
230
stderr = subprocess.PIPE)
231
decrypted_plaintext, err = proc.communicate(input = data)
232
if proc.returncode != 0:
233
raise PGPError(err)
206
234
return decrypted_plaintext
207
235
208
236
209
210
237
class AvahiError(Exception):
211
238
def __init__(self, value, *args, **kwargs):
212
239
self.value = value
213
super(AvahiError, self).__init__(value, *args, **kwargs)
214
def __unicode__(self):
215
return unicode(repr(self.value))
240
return super(AvahiError, self).__init__(value, *args,
241
**kwargs)
242
216
243
217
244
class AvahiServiceError(AvahiError):
218
245
pass
219
246
247
220
248
class AvahiGroupError(AvahiError):
221
249
pass
222
250
229
257
Used to optionally bind to the specified interface.
230
258
name: string; Example: 'Mandos'
231
259
type: string; Example: '_mandos._tcp'.
232
See <http://www.dns-sd.org/ServiceTypes.html>
260
See <https://www.iana.org/assignments/service-names-port-numbers>
233
261
port: integer; what port to announce
234
262
TXT: list of strings; TXT record for the service
235
263
domain: string; Domain to publish on, default to .local if empty.
241
269
server: D-Bus Server
242
270
bus: dbus.SystemBus()
243
271
"""
244
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
245
servicetype = None, port = None, TXT = None,
246
domain = "", host = "", max_renames = 32768,
247
protocol = avahi.PROTO_UNSPEC, bus = None):
272
273
def __init__(self,
274
interface = avahi.IF_UNSPEC,
275
name = None,
276
servicetype = None,
277
port = None,
278
TXT = None,
279
domain = "",
280
host = "",
281
max_renames = 32768,
282
protocol = avahi.PROTO_UNSPEC,
283
bus = None):
248
284
self.interface = interface
249
285
self.name = name
250
286
self.type = servicetype
259
295
self.server = None
260
296
self.bus = bus
261
297
self.entry_group_state_changed_match = None
262
def rename(self):
298
299
def rename(self, remove=True):
263
300
"""Derived from the Avahi example code"""
264
301
if self.rename_count >= self.max_renames:
265
302
logger.critical("No suitable Zeroconf service name found"
266
303
" after %i retries, exiting.",
267
304
self.rename_count)
268
305
raise AvahiServiceError("Too many renames")
269
self.name = unicode(self.server
270
.GetAlternativeServiceName(self.name))
306
self.name = str(
307
self.server.GetAlternativeServiceName(self.name))
308
self.rename_count += 1
271
309
logger.info("Changing Zeroconf service name to %r ...",
272
310
self.name)
273
self.remove()
311
if remove:
312
self.remove()
274
313
try:
275
314
self.add()
276
315
except dbus.exceptions.DBusException as error:
277
logger.critical("DBusException: %s", error)
278
self.cleanup()
279
os._exit(1)
280
self.rename_count += 1
316
if (error.get_dbus_name()
317
== "org.freedesktop.Avahi.CollisionError"):
318
logger.info("Local Zeroconf service name collision.")
319
return self.rename(remove=False)
320
else:
321
logger.critical("D-Bus Exception", exc_info=error)
322
self.cleanup()
323
os._exit(1)
324
281
325
def remove(self):
282
326
"""Derived from the Avahi example code"""
283
327
if self.entry_group_state_changed_match is not None:
285
329
self.entry_group_state_changed_match = None
286
330
if self.group is not None:
287
331
self.group.Reset()
332
288
333
def add(self):
289
334
"""Derived from the Avahi example code"""
290
335
self.remove()
307
352
dbus.UInt16(self.port),
308
353
avahi.string_array_to_txt_array(self.TXT))
309
354
self.group.Commit()
355
310
356
def entry_group_state_changed(self, state, error):
311
357
"""Derived from the Avahi example code"""
312
358
logger.debug("Avahi entry group state change: %i", state)
318
364
self.rename()
319
365
elif state == avahi.ENTRY_GROUP_FAILURE:
320
366
logger.critical("Avahi: Error in group state changed %s",
321
unicode(error))
322
raise AvahiGroupError("State changed: %s"
323
% unicode(error))
367
str(error))
368
raise AvahiGroupError("State changed: {!s}".format(error))
369
324
370
def cleanup(self):
325
371
"""Derived from the Avahi example code"""
326
372
if self.group is not None:
331
377
pass
332
378
self.group = None
333
379
self.remove()
380
334
381
def server_state_changed(self, state, error=None):
335
382
"""Derived from the Avahi example code"""
336
383
logger.debug("Avahi server state change: %i", state)
337
bad_states = { avahi.SERVER_INVALID:
338
"Zeroconf server invalid",
339
avahi.SERVER_REGISTERING: None,
340
avahi.SERVER_COLLISION:
341
"Zeroconf server name collision",
342
avahi.SERVER_FAILURE:
343
"Zeroconf server failure" }
384
bad_states = {
385
avahi.SERVER_INVALID: "Zeroconf server invalid",
386
avahi.SERVER_REGISTERING: None,
387
avahi.SERVER_COLLISION: "Zeroconf server name collision",
388
avahi.SERVER_FAILURE: "Zeroconf server failure",
389
}
344
390
if state in bad_states:
345
391
if bad_states[state] is not None:
346
392
if error is None:
349
395
logger.error(bad_states[state] + ": %r", error)
350
396
self.cleanup()
351
397
elif state == avahi.SERVER_RUNNING:
352
self.add()
398
try:
399
self.add()
400
except dbus.exceptions.DBusException as error:
401
if (error.get_dbus_name()
402
== "org.freedesktop.Avahi.CollisionError"):
403
logger.info("Local Zeroconf service name"
404
" collision.")
405
return self.rename(remove=False)
406
else:
407
logger.critical("D-Bus Exception", exc_info=error)
408
self.cleanup()
409
os._exit(1)
353
410
else:
354
411
if error is None:
355
412
logger.debug("Unknown state: %r", state)
356
413
else:
357
414
logger.debug("Unknown state: %r: %r", state, error)
415
358
416
def activate(self):
359
417
"""Derived from the Avahi example code"""
360
418
if self.server is None:
364
422
follow_name_owner_changes=True),
365
423
avahi.DBUS_INTERFACE_SERVER)
366
424
self.server.connect_to_signal("StateChanged",
367
self.server_state_changed)
425
self.server_state_changed)
368
426
self.server_state_changed(self.server.GetState())
369
427
428
370
429
class AvahiServiceToSyslog(AvahiService):
371
def rename(self):
430
def rename(self, *args, **kwargs):
372
431
"""Add the new name to the syslog messages"""
373
ret = AvahiService.rename(self)
374
syslogger.setFormatter(logging.Formatter
375
('Mandos (%s) [%%(process)d]:'
376
' %%(levelname)s: %%(message)s'
377
% self.name))
432
ret = AvahiService.rename(self, *args, **kwargs)
433
syslogger.setFormatter(logging.Formatter(
434
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
435
.format(self.name)))
378
436
return ret
379
437
380
def timedelta_to_milliseconds(td):
381
"Convert a datetime.timedelta() to milliseconds"
382
return ((td.days * 24 * 60 * 60 * 1000)
383
+ (td.seconds * 1000)
384
+ (td.microseconds // 1000))
385
438
def call_pipe(connection, # : multiprocessing.Connection
439
func, *args, **kwargs):
440
"""This function is meant to be called by multiprocessing.Process
441
442
This function runs func(*args, **kwargs), and writes the resulting
443
return value on the provided multiprocessing.Connection.
444
"""
445
connection.send(func(*args, **kwargs))
446
connection.close()
447
386
448
class Client(object):
387
449
"""A representation of a client host served by this server.
388
450
413
475
last_checked_ok: datetime.datetime(); (UTC) or None
414
476
last_checker_status: integer between 0 and 255 reflecting exit
415
477
status of last checker. -1 reflects crashed
416
checker, or None.
478
checker, -2 means no checker completed yet.
479
last_checker_signal: The signal which killed the last checker, if
480
last_checker_status is -1
417
481
last_enabled: datetime.datetime(); (UTC) or None
418
482
name: string; from the config file, used in log messages and
419
483
D-Bus identifiers
420
484
secret: bytestring; sent verbatim (over TLS) to client
421
485
timeout: datetime.timedelta(); How long from last_checked_ok
422
486
until this client is disabled
423
extended_timeout: extra long timeout when password has been sent
487
extended_timeout: extra long timeout when secret has been sent
424
488
runtime_expansions: Allowed attributes for runtime expansion.
425
489
expires: datetime.datetime(); time (UTC) when a client will be
426
490
disabled, or None
491
server_settings: The server_settings dict from main()
427
492
"""
428
493
429
494
runtime_expansions = ("approval_delay", "approval_duration",
430
"created", "enabled", "fingerprint",
431
"host", "interval", "last_checked_ok",
495
"created", "enabled", "expires",
496
"fingerprint", "host", "interval",
497
"last_approval_request", "last_checked_ok",
432
498
"last_enabled", "name", "timeout")
433
client_defaults = { "timeout": "5m",
434
"extended_timeout": "15m",
435
"interval": "2m",
436
"checker": "fping -q -- %%(host)s",
437
"host": "",
438
"approval_delay": "0s",
439
"approval_duration": "1s",
440
"approved_by_default": "True",
441
"enabled": "True",
442
}
443
444
def timeout_milliseconds(self):
445
"Return the 'timeout' attribute in milliseconds"
446
return timedelta_to_milliseconds(self.timeout)
447
448
def extended_timeout_milliseconds(self):
449
"Return the 'extended_timeout' attribute in milliseconds"
450
return timedelta_to_milliseconds(self.extended_timeout)
451
452
def interval_milliseconds(self):
453
"Return the 'interval' attribute in milliseconds"
454
return timedelta_to_milliseconds(self.interval)
455
456
def approval_delay_milliseconds(self):
457
return timedelta_to_milliseconds(self.approval_delay)
458
499
client_defaults = {
500
"timeout": "PT5M",
501
"extended_timeout": "PT15M",
502
"interval": "PT2M",
503
"checker": "fping -q -- %%(host)s",
504
"host": "",
505
"approval_delay": "PT0S",
506
"approval_duration": "PT1S",
507
"approved_by_default": "True",
508
"enabled": "True",
509
}
510
459
511
@staticmethod
460
512
def config_parser(config):
461
""" Construct a new dict of client settings of this form:
513
"""Construct a new dict of client settings of this form:
462
514
{ client_name: {setting_name: value, ...}, ...}
463
with exceptions for any special settings as defined above"""
515
with exceptions for any special settings as defined above.
516
NOTE: Must be a pure function. Must return the same result
517
value given the same arguments.
518
"""
464
519
settings = {}
465
520
for client_name in config.sections():
466
521
section = dict(config.items(client_name))
470
525
# Reformat values from string types to Python types
471
526
client["approved_by_default"] = config.getboolean(
472
527
client_name, "approved_by_default")
473
client["enabled"] = config.getboolean(client_name, "enabled")
528
client["enabled"] = config.getboolean(client_name,
529
"enabled")
474
530
531
# Uppercase and remove spaces from fingerprint for later
532
# comparison purposes with return value from the
533
# fingerprint() function
475
534
client["fingerprint"] = (section["fingerprint"].upper()
476
535
.replace(" ", ""))
477
536
if "secret" in section:
482
541
"rb") as secfile:
483
542
client["secret"] = secfile.read()
484
543
else:
485
raise TypeError("No secret or secfile for section %s"
486
% section)
544
raise TypeError("No secret or secfile for section {}"
545
.format(section))
487
546
client["timeout"] = string_to_delta(section["timeout"])
488
547
client["extended_timeout"] = string_to_delta(
489
548
section["extended_timeout"])
495
554
client["checker_command"] = section["checker"]
496
555
client["last_approval_request"] = None
497
556
client["last_checked_ok"] = None
498
client["last_checker_status"] = None
499
if client["enabled"]:
500
client["last_enabled"] = datetime.datetime.utcnow()
501
client["expires"] = (datetime.datetime.utcnow()
502
+ client["timeout"])
503
else:
504
client["last_enabled"] = None
505
client["expires"] = None
506
557
client["last_checker_status"] = -2
558
507
559
return settings
508
509
510
def __init__(self, settings, name = None):
511
"""Note: the 'checker' key in 'config' sets the
512
'checker_command' attribute and *not* the 'checker'
513
attribute."""
560
561
def __init__(self, settings, name = None, server_settings=None):
514
562
self.name = name
563
if server_settings is None:
564
server_settings = {}
565
self.server_settings = server_settings
515
566
# adding all client settings
516
for setting, value in settings.iteritems():
567
for setting, value in settings.items():
517
568
setattr(self, setting, value)
518
569
570
if self.enabled:
571
if not hasattr(self, "last_enabled"):
572
self.last_enabled = datetime.datetime.utcnow()
573
if not hasattr(self, "expires"):
574
self.expires = (datetime.datetime.utcnow()
575
+ self.timeout)
576
else:
577
self.last_enabled = None
578
self.expires = None
579
519
580
logger.debug("Creating client %r", self.name)
520
# Uppercase and remove spaces from fingerprint for later
521
# comparison purposes with return value from the fingerprint()
522
# function
523
581
logger.debug(" Fingerprint: %s", self.fingerprint)
524
self.created = settings.get("created", datetime.datetime.utcnow())
525
582
self.created = settings.get("created",
583
datetime.datetime.utcnow())
584
526
585
# attributes specific for this server instance
527
586
self.checker = None
528
587
self.checker_initiator_tag = None
531
590
self.current_checker_command = None
532
591
self.approved = None
533
592
self.approvals_pending = 0
534
self.changedstate = (multiprocessing_manager
535
.Condition(multiprocessing_manager
536
.Lock()))
537
self.client_structure = [attr for attr in
538
self.__dict__.iterkeys()
593
self.changedstate = multiprocessing_manager.Condition(
594
multiprocessing_manager.Lock())
595
self.client_structure = [attr
596
for attr in self.__dict__.iterkeys()
539
597
if not attr.startswith("_")]
540
598
self.client_structure.append("client_structure")
541
599
542
for name, t in inspect.getmembers(type(self),
543
lambda obj:
544
isinstance(obj,
545
property)):
600
for name, t in inspect.getmembers(
601
type(self), lambda obj: isinstance(obj, property)):
546
602
if not name.startswith("_"):
547
603
self.client_structure.append(name)
548
604
556
612
if getattr(self, "enabled", False):
557
613
# Already enabled
558
614
return
559
self.send_changedstate()
560
615
self.expires = datetime.datetime.utcnow() + self.timeout
561
616
self.enabled = True
562
617
self.last_enabled = datetime.datetime.utcnow()
563
618
self.init_checker()
619
self.send_changedstate()
564
620
565
621
def disable(self, quiet=True):
566
622
"""Disable this client."""
567
623
if not getattr(self, "enabled", False):
568
624
return False
569
625
if not quiet:
570
self.send_changedstate()
571
if not quiet:
572
626
logger.info("Disabling client %s", self.name)
573
if getattr(self, "disable_initiator_tag", False):
627
if getattr(self, "disable_initiator_tag", None) is not None:
574
628
gobject.source_remove(self.disable_initiator_tag)
575
629
self.disable_initiator_tag = None
576
630
self.expires = None
577
if getattr(self, "checker_initiator_tag", False):
631
if getattr(self, "checker_initiator_tag", None) is not None:
578
632
gobject.source_remove(self.checker_initiator_tag)
579
633
self.checker_initiator_tag = None
580
634
self.stop_checker()
581
635
self.enabled = False
636
if not quiet:
637
self.send_changedstate()
582
638
# Do not run this again if called by a gobject.timeout_add
583
639
return False
584
640
588
644
def init_checker(self):
589
645
# Schedule a new checker to be started an 'interval' from now,
590
646
# and every interval from then on.
591
self.checker_initiator_tag = (gobject.timeout_add
592
(self.interval_milliseconds(),
593
self.start_checker))
647
if self.checker_initiator_tag is not None:
648
gobject.source_remove(self.checker_initiator_tag)
649
self.checker_initiator_tag = gobject.timeout_add(
650
int(self.interval.total_seconds() * 1000),
651
self.start_checker)
594
652
# Schedule a disable() when 'timeout' has passed
595
self.disable_initiator_tag = (gobject.timeout_add
596
(self.timeout_milliseconds(),
597
self.disable))
653
if self.disable_initiator_tag is not None:
654
gobject.source_remove(self.disable_initiator_tag)
655
self.disable_initiator_tag = gobject.timeout_add(
656
int(self.timeout.total_seconds() * 1000), self.disable)
598
657
# Also start a new checker *right now*.
599
658
self.start_checker()
600
659
601
def checker_callback(self, pid, condition, command):
660
def checker_callback(self, source, condition, connection,
661
command):
602
662
"""The checker has completed, so take appropriate actions."""
603
663
self.checker_callback_tag = None
604
664
self.checker = None
605
if os.WIFEXITED(condition):
606
self.last_checker_status = os.WEXITSTATUS(condition)
665
# Read return code from connection (see call_pipe)
666
returncode = connection.recv()
667
connection.close()
668
669
if returncode >= 0:
670
self.last_checker_status = returncode
671
self.last_checker_signal = None
607
672
if self.last_checker_status == 0:
608
673
logger.info("Checker for %(name)s succeeded",
609
674
vars(self))
610
675
self.checked_ok()
611
676
else:
612
logger.info("Checker for %(name)s failed",
613
vars(self))
677
logger.info("Checker for %(name)s failed", vars(self))
614
678
else:
615
679
self.last_checker_status = -1
680
self.last_checker_signal = -returncode
616
681
logger.warning("Checker for %(name)s crashed?",
617
682
vars(self))
618
619
def checked_ok(self, timeout=None):
620
"""Bump up the timeout for this client.
621
622
This should only be called when the client has been seen,
623
alive and well.
624
"""
683
return False
684
685
def checked_ok(self):
686
"""Assert that the client has been seen, alive and well."""
687
self.last_checked_ok = datetime.datetime.utcnow()
688
self.last_checker_status = 0
689
self.last_checker_signal = None
690
self.bump_timeout()
691
692
def bump_timeout(self, timeout=None):
693
"""Bump up the timeout for this client."""
625
694
if timeout is None:
626
695
timeout = self.timeout
627
self.last_checked_ok = datetime.datetime.utcnow()
628
696
if self.disable_initiator_tag is not None:
629
697
gobject.source_remove(self.disable_initiator_tag)
698
self.disable_initiator_tag = None
630
699
if getattr(self, "enabled", False):
631
self.disable_initiator_tag = (gobject.timeout_add
632
(timedelta_to_milliseconds
633
(timeout), self.disable))
700
self.disable_initiator_tag = gobject.timeout_add(
701
int(timeout.total_seconds() * 1000), self.disable)
634
702
self.expires = datetime.datetime.utcnow() + timeout
635
703
636
704
def need_approval(self):
642
710
If a checker already exists, leave it running and do
643
711
nothing."""
644
712
# The reason for not killing a running checker is that if we
645
# did that, then if a checker (for some reason) started
646
# running slowly and taking more than 'interval' time, the
647
# client would inevitably timeout, since no checker would get
648
# a chance to run to completion. If we instead leave running
713
# did that, and if a checker (for some reason) started running
714
# slowly and taking more than 'interval' time, then the client
715
# would inevitably timeout, since no checker would get a
716
# chance to run to completion. If we instead leave running
649
717
# checkers alone, the checker would have to take more time
650
718
# than 'timeout' for the client to be disabled, which is as it
651
719
# should be.
652
720
653
# If a checker exists, make sure it is not a zombie
654
try:
655
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
656
except (AttributeError, OSError) as error:
657
if (isinstance(error, OSError)
658
and error.errno != errno.ECHILD):
659
raise error
660
else:
661
if pid:
662
logger.warning("Checker was a zombie")
663
gobject.source_remove(self.checker_callback_tag)
664
self.checker_callback(pid, status,
665
self.current_checker_command)
721
if self.checker is not None and not self.checker.is_alive():
722
logger.warning("Checker was not alive; joining")
723
self.checker.join()
724
self.checker = None
666
725
# Start a new checker if needed
667
726
if self.checker is None:
727
# Escape attributes for the shell
728
escaped_attrs = {
729
attr: re.escape(str(getattr(self, attr)))
730
for attr in self.runtime_expansions }
668
731
try:
669
# In case checker_command has exactly one % operator
670
command = self.checker_command % self.host
671
except TypeError:
672
# Escape attributes for the shell
673
escaped_attrs = dict(
674
(attr,
675
re.escape(unicode(str(getattr(self, attr, "")),
676
errors=
677
'replace')))
678
for attr in
679
self.runtime_expansions)
680
681
try:
682
command = self.checker_command % escaped_attrs
683
except TypeError as error:
684
logger.error('Could not format string "%s":'
685
' %s', self.checker_command, error)
686
return True # Try again later
732
command = self.checker_command % escaped_attrs
733
except TypeError as error:
734
logger.error('Could not format string "%s"',
735
self.checker_command,
736
exc_info=error)
737
return True # Try again later
687
738
self.current_checker_command = command
688
try:
689
logger.info("Starting checker %r for %s",
690
command, self.name)
691
# We don't need to redirect stdout and stderr, since
692
# in normal mode, that is already done by daemon(),
693
# and in debug mode we don't want to. (Stdin is
694
# always replaced by /dev/null.)
695
self.checker = subprocess.Popen(command,
696
close_fds=True,
697
shell=True, cwd="/")
698
self.checker_callback_tag = (gobject.child_watch_add
699
(self.checker.pid,
700
self.checker_callback,
701
data=command))
702
# The checker may have completed before the gobject
703
# watch was added. Check for this.
704
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
705
if pid:
706
gobject.source_remove(self.checker_callback_tag)
707
self.checker_callback(pid, status, command)
708
except OSError as error:
709
logger.error("Failed to start subprocess: %s",
710
error)
739
logger.info("Starting checker %r for %s", command,
740
self.name)
741
# We don't need to redirect stdout and stderr, since
742
# in normal mode, that is already done by daemon(),
743
# and in debug mode we don't want to. (Stdin is
744
# always replaced by /dev/null.)
745
# The exception is when not debugging but nevertheless
746
# running in the foreground; use the previously
747
# created wnull.
748
popen_args = { "close_fds": True,
749
"shell": True,
750
"cwd": "/" }
751
if (not self.server_settings["debug"]
752
and self.server_settings["foreground"]):
753
popen_args.update({"stdout": wnull,
754
"stderr": wnull })
755
pipe = multiprocessing.Pipe(duplex = False)
756
self.checker = multiprocessing.Process(
757
target = call_pipe,
758
args = (pipe[1], subprocess.call, command),
759
kwargs = popen_args)
760
self.checker.start()
761
self.checker_callback_tag = gobject.io_add_watch(
762
pipe[0].fileno(), gobject.IO_IN,
763
self.checker_callback, pipe[0], command)
711
764
# Re-run this periodically if run by gobject.timeout_add
712
765
return True
713
766
719
772
if getattr(self, "checker", None) is None:
720
773
return
721
774
logger.debug("Stopping checker for %(name)s", vars(self))
722
try:
723
os.kill(self.checker.pid, signal.SIGTERM)
724
#time.sleep(0.5)
725
#if self.checker.poll() is None:
726
# os.kill(self.checker.pid, signal.SIGKILL)
727
except OSError as error:
728
if error.errno != errno.ESRCH: # No such process
729
raise
775
self.checker.terminate()
730
776
self.checker = None
731
777
732
778
733
def dbus_service_property(dbus_interface, signature="v",
734
access="readwrite", byte_arrays=False):
779
def dbus_service_property(dbus_interface,
780
signature="v",
781
access="readwrite",
782
byte_arrays=False):
735
783
"""Decorators for marking methods of a DBusObjectWithProperties to
736
784
become properties on the D-Bus.
737
785
746
794
# "Set" method, so we fail early here:
747
795
if byte_arrays and signature != "ay":
748
796
raise ValueError("Byte arrays not supported for non-'ay'"
749
" signature %r" % signature)
797
" signature {!r}".format(signature))
798
750
799
def decorator(func):
751
800
func._dbus_is_property = True
752
801
func._dbus_interface = dbus_interface
757
806
func._dbus_name = func._dbus_name[:-14]
758
807
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
759
808
return func
809
810
return decorator
811
812
813
def dbus_interface_annotations(dbus_interface):
814
"""Decorator for marking functions returning interface annotations
815
816
Usage:
817
818
@dbus_interface_annotations("org.example.Interface")
819
def _foo(self): # Function name does not matter
820
return {"org.freedesktop.DBus.Deprecated": "true",
821
"org.freedesktop.DBus.Property.EmitsChangedSignal":
822
"false"}
823
"""
824
825
def decorator(func):
826
func._dbus_is_interface = True
827
func._dbus_interface = dbus_interface
828
func._dbus_name = dbus_interface
829
return func
830
831
return decorator
832
833
834
def dbus_annotations(annotations):
835
"""Decorator to annotate D-Bus methods, signals or properties
836
Usage:
837
838
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
839
"org.freedesktop.DBus.Property."
840
"EmitsChangedSignal": "false"})
841
@dbus_service_property("org.example.Interface", signature="b",
842
access="r")
843
def Property_dbus_property(self):
844
return dbus.Boolean(False)
845
846
See also the DBusObjectWithAnnotations class.
847
"""
848
849
def decorator(func):
850
func._dbus_annotations = annotations
851
return func
852
760
853
return decorator
761
854
762
855
763
856
class DBusPropertyException(dbus.exceptions.DBusException):
764
857
"""A base class for D-Bus property-related exceptions
765
858
"""
766
def __unicode__(self):
767
return unicode(str(self))
859
pass
768
860
769
861
770
862
class DBusPropertyAccessException(DBusPropertyException):
779
871
pass
780
872
781
873
782
class DBusObjectWithProperties(dbus.service.Object):
874
class DBusObjectWithAnnotations(dbus.service.Object):
875
"""A D-Bus object with annotations.
876
877
Classes inheriting from this can use the dbus_annotations
878
decorator to add annotations to methods or signals.
879
"""
880
881
@staticmethod
882
def _is_dbus_thing(thing):
883
"""Returns a function testing if an attribute is a D-Bus thing
884
885
If called like _is_dbus_thing("method") it returns a function
886
suitable for use as predicate to inspect.getmembers().
887
"""
888
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
889
False)
890
891
def _get_all_dbus_things(self, thing):
892
"""Returns a generator of (name, attribute) pairs
893
"""
894
return ((getattr(athing.__get__(self), "_dbus_name", name),
895
athing.__get__(self))
896
for cls in self.__class__.__mro__
897
for name, athing in
898
inspect.getmembers(cls, self._is_dbus_thing(thing)))
899
900
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
901
out_signature = "s",
902
path_keyword = 'object_path',
903
connection_keyword = 'connection')
904
def Introspect(self, object_path, connection):
905
"""Overloading of standard D-Bus method.
906
907
Inserts annotation tags on methods and signals.
908
"""
909
xmlstring = dbus.service.Object.Introspect(self, object_path,
910
connection)
911
try:
912
document = xml.dom.minidom.parseString(xmlstring)
913
914
for if_tag in document.getElementsByTagName("interface"):
915
# Add annotation tags
916
for typ in ("method", "signal"):
917
for tag in if_tag.getElementsByTagName(typ):
918
annots = dict()
919
for name, prop in (self.
920
_get_all_dbus_things(typ)):
921
if (name == tag.getAttribute("name")
922
and prop._dbus_interface
923
== if_tag.getAttribute("name")):
924
annots.update(getattr(
925
prop, "_dbus_annotations", {}))
926
for name, value in annots.items():
927
ann_tag = document.createElement(
928
"annotation")
929
ann_tag.setAttribute("name", name)
930
ann_tag.setAttribute("value", value)
931
tag.appendChild(ann_tag)
932
# Add interface annotation tags
933
for annotation, value in dict(
934
itertools.chain.from_iterable(
935
annotations().items()
936
for name, annotations
937
in self._get_all_dbus_things("interface")
938
if name == if_tag.getAttribute("name")
939
)).items():
940
ann_tag = document.createElement("annotation")
941
ann_tag.setAttribute("name", annotation)
942
ann_tag.setAttribute("value", value)
943
if_tag.appendChild(ann_tag)
944
# Fix argument name for the Introspect method itself
945
if (if_tag.getAttribute("name")
946
== dbus.INTROSPECTABLE_IFACE):
947
for cn in if_tag.getElementsByTagName("method"):
948
if cn.getAttribute("name") == "Introspect":
949
for arg in cn.getElementsByTagName("arg"):
950
if (arg.getAttribute("direction")
951
== "out"):
952
arg.setAttribute("name",
953
"xml_data")
954
xmlstring = document.toxml("utf-8")
955
document.unlink()
956
except (AttributeError, xml.dom.DOMException,
957
xml.parsers.expat.ExpatError) as error:
958
logger.error("Failed to override Introspection method",
959
exc_info=error)
960
return xmlstring
961
962
963
class DBusObjectWithProperties(DBusObjectWithAnnotations):
783
964
"""A D-Bus object with properties.
784
965
785
966
Classes inheriting from this can use the dbus_service_property
787
968
standard Get(), Set(), and GetAll() methods on the D-Bus.
788
969
"""
789
970
790
@staticmethod
791
def _is_dbus_property(obj):
792
return getattr(obj, "_dbus_is_property", False)
793
794
def _get_all_dbus_properties(self):
795
"""Returns a generator of (name, attribute) pairs
796
"""
797
return ((prop.__get__(self)._dbus_name, prop.__get__(self))
798
for cls in self.__class__.__mro__
799
for name, prop in
800
inspect.getmembers(cls, self._is_dbus_property))
801
802
971
def _get_dbus_property(self, interface_name, property_name):
803
972
"""Returns a bound method if one exists which is a D-Bus
804
973
property with the specified name and interface.
805
974
"""
806
for cls in self.__class__.__mro__:
807
for name, value in (inspect.getmembers
808
(cls, self._is_dbus_property)):
975
for cls in self.__class__.__mro__:
976
for name, value in inspect.getmembers(
977
cls, self._is_dbus_thing("property")):
809
978
if (value._dbus_name == property_name
810
979
and value._dbus_interface == interface_name):
811
980
return value.__get__(self)
812
981
813
982
# No such property
814
raise DBusPropertyNotFound(self.dbus_object_path + ":"
815
+ interface_name + "."
816
+ property_name)
983
raise DBusPropertyNotFound("{}:{}.{}".format(
984
self.dbus_object_path, interface_name, property_name))
817
985
818
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
986
@dbus.service.method(dbus.PROPERTIES_IFACE,
987
in_signature="ss",
819
988
out_signature="v")
820
989
def Get(self, interface_name, property_name):
821
990
"""Standard D-Bus property Get() method, see D-Bus standard.
839
1008
# The byte_arrays option is not supported yet on
840
1009
# signatures other than "ay".
841
1010
if prop._dbus_signature != "ay":
842
raise ValueError
843
value = dbus.ByteArray(''.join(unichr(byte)
844
for byte in value))
1011
raise ValueError("Byte arrays not supported for non-"
1012
"'ay' signature {!r}"
1013
.format(prop._dbus_signature))
1014
value = dbus.ByteArray(b''.join(chr(byte)
1015
for byte in value))
845
1016
prop(value)
846
1017
847
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
1018
@dbus.service.method(dbus.PROPERTIES_IFACE,
1019
in_signature="s",
848
1020
out_signature="a{sv}")
849
1021
def GetAll(self, interface_name):
850
1022
"""Standard D-Bus property GetAll() method, see D-Bus
853
1025
Note: Will not include properties with access="write".
854
1026
"""
855
1027
properties = {}
856
for name, prop in self._get_all_dbus_properties():
1028
for name, prop in self._get_all_dbus_things("property"):
857
1029
if (interface_name
858
1030
and interface_name != prop._dbus_interface):
859
1031
# Interface non-empty but did not match
865
1037
if not hasattr(value, "variant_level"):
866
1038
properties[name] = value
867
1039
continue
868
properties[name] = type(value)(value, variant_level=
869
value.variant_level+1)
1040
properties[name] = type(value)(
1041
value, variant_level = value.variant_level + 1)
870
1042
return dbus.Dictionary(properties, signature="sv")
871
1043
1044
@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
1045
def PropertiesChanged(self, interface_name, changed_properties,
1046
invalidated_properties):
1047
"""Standard D-Bus PropertiesChanged() signal, see D-Bus
1048
standard.
1049
"""
1050
pass
1051
872
1052
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
873
1053
out_signature="s",
874
1054
path_keyword='object_path',
875
1055
connection_keyword='connection')
876
1056
def Introspect(self, object_path, connection):
877
"""Standard D-Bus method, overloaded to insert property tags.
1057
"""Overloading of standard D-Bus method.
1058
1059
Inserts property tags and interface annotation tags.
878
1060
"""
879
xmlstring = dbus.service.Object.Introspect(self, object_path,
880
connection)
1061
xmlstring = DBusObjectWithAnnotations.Introspect(self,
1062
object_path,
1063
connection)
881
1064
try:
882
1065
document = xml.dom.minidom.parseString(xmlstring)
1066
883
1067
def make_tag(document, name, prop):
884
1068
e = document.createElement("property")
885
1069
e.setAttribute("name", name)
886
1070
e.setAttribute("type", prop._dbus_signature)
887
1071
e.setAttribute("access", prop._dbus_access)
888
1072
return e
1073
889
1074
for if_tag in document.getElementsByTagName("interface"):
1075
# Add property tags
890
1076
for tag in (make_tag(document, name, prop)
891
1077
for name, prop
892
in self._get_all_dbus_properties()
1078
in self._get_all_dbus_things("property")
893
1079
if prop._dbus_interface
894
1080
== if_tag.getAttribute("name")):
895
1081
if_tag.appendChild(tag)
1082
# Add annotation tags for properties
1083
for tag in if_tag.getElementsByTagName("property"):
1084
annots = dict()
1085
for name, prop in self._get_all_dbus_things(
1086
"property"):
1087
if (name == tag.getAttribute("name")
1088
and prop._dbus_interface
1089
== if_tag.getAttribute("name")):
1090
annots.update(getattr(
1091
prop, "_dbus_annotations", {}))
1092
for name, value in annots.items():
1093
ann_tag = document.createElement(
1094
"annotation")
1095
ann_tag.setAttribute("name", name)
1096
ann_tag.setAttribute("value", value)
1097
tag.appendChild(ann_tag)
896
1098
# Add the names to the return values for the
897
1099
# "org.freedesktop.DBus.Properties" methods
898
1100
if (if_tag.getAttribute("name")
913
1115
except (AttributeError, xml.dom.DOMException,
914
1116
xml.parsers.expat.ExpatError) as error:
915
1117
logger.error("Failed to override Introspection method",
916
error)
1118
exc_info=error)
917
1119
return xmlstring
918
1120
919
1121
920
def datetime_to_dbus (dt, variant_level=0):
1122
def datetime_to_dbus(dt, variant_level=0):
921
1123
"""Convert a UTC datetime.datetime() to a D-Bus type."""
922
1124
if dt is None:
923
1125
return dbus.String("", variant_level = variant_level)
924
return dbus.String(dt.isoformat(),
925
variant_level=variant_level)
926
927
928
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
929
.__metaclass__):
930
"""Applied to an empty subclass of a D-Bus object, this metaclass
931
will add additional D-Bus attributes matching a certain pattern.
1126
return dbus.String(dt.isoformat(), variant_level=variant_level)
1127
1128
1129
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1130
"""A class decorator; applied to a subclass of
1131
dbus.service.Object, it will add alternate D-Bus attributes with
1132
interface names according to the "alt_interface_names" mapping.
1133
Usage:
1134
1135
@alternate_dbus_interfaces({"org.example.Interface":
1136
"net.example.AlternateInterface"})
1137
class SampleDBusObject(dbus.service.Object):
1138
@dbus.service.method("org.example.Interface")
1139
def SampleDBusMethod():
1140
pass
1141
1142
The above "SampleDBusMethod" on "SampleDBusObject" will be
1143
reachable via two interfaces: "org.example.Interface" and
1144
"net.example.AlternateInterface", the latter of which will have
1145
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1146
"true", unless "deprecate" is passed with a False value.
1147
1148
This works for methods and signals, and also for D-Bus properties
1149
(from DBusObjectWithProperties) and interfaces (from the
1150
dbus_interface_annotations decorator).
932
1151
"""
933
def __new__(mcs, name, bases, attr):
934
# Go through all the base classes which could have D-Bus
935
# methods, signals, or properties in them
936
for base in (b for b in bases
937
if issubclass(b, dbus.service.Object)):
938
# Go though all attributes of the base class
939
for attrname, attribute in inspect.getmembers(base):
1152
1153
def wrapper(cls):
1154
for orig_interface_name, alt_interface_name in (
1155
alt_interface_names.items()):
1156
attr = {}
1157
interface_names = set()
1158
# Go though all attributes of the class
1159
for attrname, attribute in inspect.getmembers(cls):
940
1160
# Ignore non-D-Bus attributes, and D-Bus attributes
941
1161
# with the wrong interface name
942
1162
if (not hasattr(attribute, "_dbus_interface")
943
or not attribute._dbus_interface
944
.startswith("se.recompile.Mandos")):
1163
or not attribute._dbus_interface.startswith(
1164
orig_interface_name)):
945
1165
continue
946
1166
# Create an alternate D-Bus interface name based on
947
1167
# the current name
948
alt_interface = (attribute._dbus_interface
949
.replace("se.recompile.Mandos",
950
"se.bsnet.fukt.Mandos"))
1168
alt_interface = attribute._dbus_interface.replace(
1169
orig_interface_name, alt_interface_name)
1170
interface_names.add(alt_interface)
951
1171
# Is this a D-Bus signal?
952
1172
if getattr(attribute, "_dbus_is_signal", False):
953
# Extract the original non-method function by
954
# black magic
955
nonmethod_func = (dict(
1173
if sys.version_info.major == 2:
1174
# Extract the original non-method undecorated
1175
# function by black magic
1176
nonmethod_func = (dict(
956
1177
zip(attribute.func_code.co_freevars,
957
attribute.__closure__))["func"]
958
.cell_contents)
1178
attribute.__closure__))
1179
["func"].cell_contents)
1180
else:
1181
nonmethod_func = attribute
959
1182
# Create a new, but exactly alike, function
960
1183
# object, and decorate it to be a new D-Bus signal
961
1184
# with the alternate D-Bus interface name
962
new_function = (dbus.service.signal
963
(alt_interface,
964
attribute._dbus_signature)
965
(types.FunctionType(
966
nonmethod_func.func_code,
967
nonmethod_func.func_globals,
968
nonmethod_func.func_name,
969
nonmethod_func.func_defaults,
970
nonmethod_func.func_closure)))
1185
if sys.version_info.major == 2:
1186
new_function = types.FunctionType(
1187
nonmethod_func.func_code,
1188
nonmethod_func.func_globals,
1189
nonmethod_func.func_name,
1190
nonmethod_func.func_defaults,
1191
nonmethod_func.func_closure)
1192
else:
1193
new_function = types.FunctionType(
1194
nonmethod_func.__code__,
1195
nonmethod_func.__globals__,
1196
nonmethod_func.__name__,
1197
nonmethod_func.__defaults__,
1198
nonmethod_func.__closure__)
1199
new_function = (dbus.service.signal(
1200
alt_interface,
1201
attribute._dbus_signature)(new_function))
1202
# Copy annotations, if any
1203
try:
1204
new_function._dbus_annotations = dict(
1205
attribute._dbus_annotations)
1206
except AttributeError:
1207
pass
971
1208
# Define a creator of a function to call both the
972
# old and new functions, so both the old and new
973
# signals gets sent when the function is called
1209
# original and alternate functions, so both the
1210
# original and alternate signals gets sent when
1211
# the function is called
974
1212
def fixscope(func1, func2):
975
1213
"""This function is a scope container to pass
976
1214
func1 and func2 to the "call_both" function
977
1215
outside of its arguments"""
1216
978
1217
def call_both(*args, **kwargs):
979
1218
"""This function will emit two D-Bus
980
1219
signals by calling func1 and func2"""
981
1220
func1(*args, **kwargs)
982
1221
func2(*args, **kwargs)
1222
983
1223
return call_both
984
1224
# Create the "call_both" function and add it to
985
1225
# the class
986
attr[attrname] = fixscope(attribute,
987
new_function)
1226
attr[attrname] = fixscope(attribute, new_function)
988
1227
# Is this a D-Bus method?
989
1228
elif getattr(attribute, "_dbus_is_method", False):
990
1229
# Create a new, but exactly alike, function
991
1230
# object. Decorate it to be a new D-Bus method
992
1231
# with the alternate D-Bus interface name. Add it
993
1232
# to the class.
994
attr[attrname] = (dbus.service.method
995
(alt_interface,
996
attribute._dbus_in_signature,
997
attribute._dbus_out_signature)
998
(types.FunctionType
999
(attribute.func_code,
1000
attribute.func_globals,
1001
attribute.func_name,
1002
attribute.func_defaults,
1003
attribute.func_closure)))
1233
attr[attrname] = (
1234
dbus.service.method(
1235
alt_interface,
1236
attribute._dbus_in_signature,
1237
attribute._dbus_out_signature)
1238
(types.FunctionType(attribute.func_code,
1239
attribute.func_globals,
1240
attribute.func_name,
1241
attribute.func_defaults,
1242
attribute.func_closure)))
1243
# Copy annotations, if any
1244
try:
1245
attr[attrname]._dbus_annotations = dict(
1246
attribute._dbus_annotations)
1247
except AttributeError:
1248
pass
1004
1249
# Is this a D-Bus property?
1005
1250
elif getattr(attribute, "_dbus_is_property", False):
1006
1251
# Create a new, but exactly alike, function
1007
1252
# object, and decorate it to be a new D-Bus
1008
1253
# property with the alternate D-Bus interface
1009
1254
# name. Add it to the class.
1010
attr[attrname] = (dbus_service_property
1011
(alt_interface,
1012
attribute._dbus_signature,
1013
attribute._dbus_access,
1014
attribute
1015
._dbus_get_args_options
1016
["byte_arrays"])
1017
(types.FunctionType
1018
(attribute.func_code,
1019
attribute.func_globals,
1020
attribute.func_name,
1021
attribute.func_defaults,
1022
attribute.func_closure)))
1023
return type.__new__(mcs, name, bases, attr)
1024
1025
1255
attr[attrname] = (dbus_service_property(
1256
alt_interface, attribute._dbus_signature,
1257
attribute._dbus_access,
1258
attribute._dbus_get_args_options
1259
["byte_arrays"])
1260
(types.FunctionType(
1261
attribute.func_code,
1262
attribute.func_globals,
1263
attribute.func_name,
1264
attribute.func_defaults,
1265
attribute.func_closure)))
1266
# Copy annotations, if any
1267
try:
1268
attr[attrname]._dbus_annotations = dict(
1269
attribute._dbus_annotations)
1270
except AttributeError:
1271
pass
1272
# Is this a D-Bus interface?
1273
elif getattr(attribute, "_dbus_is_interface", False):
1274
# Create a new, but exactly alike, function
1275
# object. Decorate it to be a new D-Bus interface
1276
# with the alternate D-Bus interface name. Add it
1277
# to the class.
1278
attr[attrname] = (
1279
dbus_interface_annotations(alt_interface)
1280
(types.FunctionType(attribute.func_code,
1281
attribute.func_globals,
1282
attribute.func_name,
1283
attribute.func_defaults,
1284
attribute.func_closure)))
1285
if deprecate:
1286
# Deprecate all alternate interfaces
1287
iname="_AlternateDBusNames_interface_annotation{}"
1288
for interface_name in interface_names:
1289
1290
@dbus_interface_annotations(interface_name)
1291
def func(self):
1292
return { "org.freedesktop.DBus.Deprecated":
1293
"true" }
1294
# Find an unused name
1295
for aname in (iname.format(i)
1296
for i in itertools.count()):
1297
if aname not in attr:
1298
attr[aname] = func
1299
break
1300
if interface_names:
1301
# Replace the class with a new subclass of it with
1302
# methods, signals, etc. as created above.
1303
cls = type(b"{}Alternate".format(cls.__name__),
1304
(cls, ), attr)
1305
return cls
1306
1307
return wrapper
1308
1309
1310
@alternate_dbus_interfaces({"se.recompile.Mandos":
1311
"se.bsnet.fukt.Mandos"})
1026
1312
class ClientDBus(Client, DBusObjectWithProperties):
1027
1313
"""A Client class using D-Bus
1028
1314
1032
1318
"""
1033
1319
1034
1320
runtime_expansions = (Client.runtime_expansions
1035
+ ("dbus_object_path",))
1321
+ ("dbus_object_path", ))
1322
1323
_interface = "se.recompile.Mandos.Client"
1036
1324
1037
1325
# dbus.service.Object doesn't use super(), so we can't either.
1038
1326
1039
1327
def __init__(self, bus = None, *args, **kwargs):
1040
1328
self.bus = bus
1041
1329
Client.__init__(self, *args, **kwargs)
1042
self._approvals_pending = 0
1043
1044
self._approvals_pending = 0
1045
1330
# Only now, when this client is initialized, can it show up on
1046
1331
# the D-Bus
1047
client_object_name = unicode(self.name).translate(
1332
client_object_name = str(self.name).translate(
1048
1333
{ord("."): ord("_"),
1049
1334
ord("-"): ord("_")})
1050
self.dbus_object_path = (dbus.ObjectPath
1051
("/clients/" + client_object_name))
1335
self.dbus_object_path = dbus.ObjectPath(
1336
"/clients/" + client_object_name)
1052
1337
DBusObjectWithProperties.__init__(self, self.bus,
1053
1338
self.dbus_object_path)
1054
1055
def notifychangeproperty(transform_func,
1056
dbus_name, type_func=lambda x: x,
1057
variant_level=1):
1339
1340
def notifychangeproperty(transform_func, dbus_name,
1341
type_func=lambda x: x,
1342
variant_level=1,
1343
invalidate_only=False,
1344
_interface=_interface):
1058
1345
""" Modify a variable so that it's a property which announces
1059
1346
its changes to DBus.
1060
1347
1065
1352
to the D-Bus. Default: no transform
1066
1353
variant_level: D-Bus variant level. Default: 1
1067
1354
"""
1068
attrname = "_{0}".format(dbus_name)
1355
attrname = "_{}".format(dbus_name)
1356
1069
1357
def setter(self, value):
1070
1358
if hasattr(self, "dbus_object_path"):
1071
1359
if (not hasattr(self, attrname) or
1072
1360
type_func(getattr(self, attrname, None))
1073
1361
!= type_func(value)):
1074
dbus_value = transform_func(type_func(value),
1075
variant_level
1076
=variant_level)
1077
self.PropertyChanged(dbus.String(dbus_name),
1078
dbus_value)
1362
if invalidate_only:
1363
self.PropertiesChanged(
1364
_interface, dbus.Dictionary(),
1365
dbus.Array((dbus_name, )))
1366
else:
1367
dbus_value = transform_func(
1368
type_func(value),
1369
variant_level = variant_level)
1370
self.PropertyChanged(dbus.String(dbus_name),
1371
dbus_value)
1372
self.PropertiesChanged(
1373
_interface,
1374
dbus.Dictionary({ dbus.String(dbus_name):
1375
dbus_value }),
1376
dbus.Array())
1079
1377
setattr(self, attrname, value)
1080
1378
1081
1379
return property(lambda self: getattr(self, attrname), setter)
1082
1380
1083
1084
1381
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1085
1382
approvals_pending = notifychangeproperty(dbus.Boolean,
1086
1383
"ApprovalPending",
1088
1385
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1089
1386
last_enabled = notifychangeproperty(datetime_to_dbus,
1090
1387
"LastEnabled")
1091
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
1092
type_func = lambda checker:
1093
checker is not None)
1388
checker = notifychangeproperty(
1389
dbus.Boolean, "CheckerRunning",
1390
type_func = lambda checker: checker is not None)
1094
1391
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1095
1392
"LastCheckedOK")
1393
last_checker_status = notifychangeproperty(dbus.Int16,
1394
"LastCheckerStatus")
1096
1395
last_approval_request = notifychangeproperty(
1097
1396
datetime_to_dbus, "LastApprovalRequest")
1098
1397
approved_by_default = notifychangeproperty(dbus.Boolean,
1099
1398
"ApprovedByDefault")
1100
approval_delay = notifychangeproperty(dbus.UInt64,
1101
"ApprovalDelay",
1102
type_func =
1103
timedelta_to_milliseconds)
1399
approval_delay = notifychangeproperty(
1400
dbus.UInt64, "ApprovalDelay",
1401
type_func = lambda td: td.total_seconds() * 1000)
1104
1402
approval_duration = notifychangeproperty(
1105
1403
dbus.UInt64, "ApprovalDuration",
1106
type_func = timedelta_to_milliseconds)
1404
type_func = lambda td: td.total_seconds() * 1000)
1107
1405
host = notifychangeproperty(dbus.String, "Host")
1108
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1109
type_func =
1110
timedelta_to_milliseconds)
1406
timeout = notifychangeproperty(
1407
dbus.UInt64, "Timeout",
1408
type_func = lambda td: td.total_seconds() * 1000)
1111
1409
extended_timeout = notifychangeproperty(
1112
1410
dbus.UInt64, "ExtendedTimeout",
1113
type_func = timedelta_to_milliseconds)
1114
interval = notifychangeproperty(dbus.UInt64,
1115
"Interval",
1116
type_func =
1117
timedelta_to_milliseconds)
1411
type_func = lambda td: td.total_seconds() * 1000)
1412
interval = notifychangeproperty(
1413
dbus.UInt64, "Interval",
1414
type_func = lambda td: td.total_seconds() * 1000)
1118
1415
checker_command = notifychangeproperty(dbus.String, "Checker")
1416
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1417
invalidate_only=True)
1119
1418
1120
1419
del notifychangeproperty
1121
1420
1128
1427
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1129
1428
Client.__del__(self, *args, **kwargs)
1130
1429
1131
def checker_callback(self, pid, condition, command,
1132
*args, **kwargs):
1133
self.checker_callback_tag = None
1134
self.checker = None
1135
if os.WIFEXITED(condition):
1136
exitstatus = os.WEXITSTATUS(condition)
1430
def checker_callback(self, source, condition,
1431
connection, command, *args, **kwargs):
1432
ret = Client.checker_callback(self, source, condition,
1433
connection, command, *args,
1434
**kwargs)
1435
exitstatus = self.last_checker_status
1436
if exitstatus >= 0:
1137
1437
# Emit D-Bus signal
1138
1438
self.CheckerCompleted(dbus.Int16(exitstatus),
1139
dbus.Int64(condition),
1439
# This is specific to GNU libC
1440
dbus.Int64(exitstatus << 8),
1140
1441
dbus.String(command))
1141
1442
else:
1142
1443
# Emit D-Bus signal
1143
1444
self.CheckerCompleted(dbus.Int16(-1),
1144
dbus.Int64(condition),
1445
dbus.Int64(
1446
# This is specific to GNU libC
1447
(exitstatus << 8)
1448
| self.last_checker_signal),
1145
1449
dbus.String(command))
1146
1147
return Client.checker_callback(self, pid, condition, command,
1148
*args, **kwargs)
1450
return ret
1149
1451
1150
1452
def start_checker(self, *args, **kwargs):
1151
old_checker = self.checker
1152
if self.checker is not None:
1153
old_checker_pid = self.checker.pid
1154
else:
1155
old_checker_pid = None
1453
old_checker_pid = getattr(self.checker, "pid", None)
1156
1454
r = Client.start_checker(self, *args, **kwargs)
1157
1455
# Only if new checker process was started
1158
1456
if (self.checker is not None
1166
1464
return False
1167
1465
1168
1466
def approve(self, value=True):
1169
self.send_changedstate()
1170
1467
self.approved = value
1171
gobject.timeout_add(timedelta_to_milliseconds
1172
(self.approval_duration),
1173
self._reset_approved)
1174
1468
gobject.timeout_add(int(self.approval_duration.total_seconds()
1469
* 1000), self._reset_approved)
1470
self.send_changedstate()
1175
1471
1176
1472
## D-Bus methods, signals & properties
1177
_interface = "se.recompile.Mandos.Client"
1473
1474
## Interfaces
1178
1475
1179
1476
## Signals
1180
1477
1191
1488
pass
1192
1489
1193
1490
# PropertyChanged - signal
1491
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1194
1492
@dbus.service.signal(_interface, signature="sv")
1195
1493
def PropertyChanged(self, property, value):
1196
1494
"D-Bus signal"
1217
1515
"D-Bus signal"
1218
1516
return self.need_approval()
1219
1517
1220
# NeRwequest - signal
1221
@dbus.service.signal(_interface, signature="s")
1222
def NewRequest(self, ip):
1223
"""D-Bus signal
1224
Is sent after a client request a password.
1225
"""
1226
pass
1227
1228
1518
## Methods
1229
1519
1230
1520
# Approve - method
1238
1528
self.checked_ok()
1239
1529
1240
1530
# Enable - method
1531
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1241
1532
@dbus.service.method(_interface)
1242
1533
def Enable(self):
1243
1534
"D-Bus method"
1244
1535
self.enable()
1245
1536
1246
1537
# StartChecker - method
1538
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1247
1539
@dbus.service.method(_interface)
1248
1540
def StartChecker(self):
1249
1541
"D-Bus method"
1250
1542
self.start_checker()
1251
1543
1252
1544
# Disable - method
1545
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1253
1546
@dbus.service.method(_interface)
1254
1547
def Disable(self):
1255
1548
"D-Bus method"
1256
1549
self.disable()
1257
1550
1258
1551
# StopChecker - method
1552
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1259
1553
@dbus.service.method(_interface)
1260
1554
def StopChecker(self):
1261
1555
self.stop_checker()
1268
1562
return dbus.Boolean(bool(self.approvals_pending))
1269
1563
1270
1564
# ApprovedByDefault - property
1271
@dbus_service_property(_interface, signature="b",
1565
@dbus_service_property(_interface,
1566
signature="b",
1272
1567
access="readwrite")
1273
1568
def ApprovedByDefault_dbus_property(self, value=None):
1274
1569
if value is None: # get
1276
1571
self.approved_by_default = bool(value)
1277
1572
1278
1573
# ApprovalDelay - property
1279
@dbus_service_property(_interface, signature="t",
1574
@dbus_service_property(_interface,
1575
signature="t",
1280
1576
access="readwrite")
1281
1577
def ApprovalDelay_dbus_property(self, value=None):
1282
1578
if value is None: # get
1283
return dbus.UInt64(self.approval_delay_milliseconds())
1579
return dbus.UInt64(self.approval_delay.total_seconds()
1580
* 1000)
1284
1581
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1285
1582
1286
1583
# ApprovalDuration - property
1287
@dbus_service_property(_interface, signature="t",
1584
@dbus_service_property(_interface,
1585
signature="t",
1288
1586
access="readwrite")
1289
1587
def ApprovalDuration_dbus_property(self, value=None):
1290
1588
if value is None: # get
1291
return dbus.UInt64(timedelta_to_milliseconds(
1292
self.approval_duration))
1589
return dbus.UInt64(self.approval_duration.total_seconds()
1590
* 1000)
1293
1591
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1294
1592
1295
1593
# Name - property
1594
@dbus_annotations(
1595
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1296
1596
@dbus_service_property(_interface, signature="s", access="read")
1297
1597
def Name_dbus_property(self):
1298
1598
return dbus.String(self.name)
1299
1599
1300
1600
# Fingerprint - property
1601
@dbus_annotations(
1602
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1301
1603
@dbus_service_property(_interface, signature="s", access="read")
1302
1604
def Fingerprint_dbus_property(self):
1303
1605
return dbus.String(self.fingerprint)
1304
1606
1305
1607
# Host - property
1306
@dbus_service_property(_interface, signature="s",
1608
@dbus_service_property(_interface,
1609
signature="s",
1307
1610
access="readwrite")
1308
1611
def Host_dbus_property(self, value=None):
1309
1612
if value is None: # get
1310
1613
return dbus.String(self.host)
1311
self.host = unicode(value)
1614
self.host = str(value)
1312
1615
1313
1616
# Created - property
1617
@dbus_annotations(
1618
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1314
1619
@dbus_service_property(_interface, signature="s", access="read")
1315
1620
def Created_dbus_property(self):
1316
1621
return datetime_to_dbus(self.created)
1321
1626
return datetime_to_dbus(self.last_enabled)
1322
1627
1323
1628
# Enabled - property
1324
@dbus_service_property(_interface, signature="b",
1629
@dbus_service_property(_interface,
1630
signature="b",
1325
1631
access="readwrite")
1326
1632
def Enabled_dbus_property(self, value=None):
1327
1633
if value is None: # get
1332
1638
self.disable()
1333
1639
1334
1640
# LastCheckedOK - property
1335
@dbus_service_property(_interface, signature="s",
1641
@dbus_service_property(_interface,
1642
signature="s",
1336
1643
access="readwrite")
1337
1644
def LastCheckedOK_dbus_property(self, value=None):
1338
1645
if value is not None:
1340
1647
return
1341
1648
return datetime_to_dbus(self.last_checked_ok)
1342
1649
1650
# LastCheckerStatus - property
1651
@dbus_service_property(_interface, signature="n", access="read")
1652
def LastCheckerStatus_dbus_property(self):
1653
return dbus.Int16(self.last_checker_status)
1654
1343
1655
# Expires - property
1344
1656
@dbus_service_property(_interface, signature="s", access="read")
1345
1657
def Expires_dbus_property(self):
1351
1663
return datetime_to_dbus(self.last_approval_request)
1352
1664
1353
1665
# Timeout - property
1354
@dbus_service_property(_interface, signature="t",
1666
@dbus_service_property(_interface,
1667
signature="t",
1355
1668
access="readwrite")
1356
1669
def Timeout_dbus_property(self, value=None):
1357
1670
if value is None: # get
1358
return dbus.UInt64(self.timeout_milliseconds())
1671
return dbus.UInt64(self.timeout.total_seconds() * 1000)
1672
old_timeout = self.timeout
1359
1673
self.timeout = datetime.timedelta(0, 0, 0, value)
1360
if getattr(self, "disable_initiator_tag", None) is None:
1361
return
1362
# Reschedule timeout
1363
gobject.source_remove(self.disable_initiator_tag)
1364
self.disable_initiator_tag = None
1365
self.expires = None
1366
time_to_die = timedelta_to_milliseconds((self
1367
.last_checked_ok
1368
+ self.timeout)
1369
- datetime.datetime
1370
.utcnow())
1371
if time_to_die <= 0:
1372
# The timeout has passed
1373
self.disable()
1374
else:
1375
self.expires = (datetime.datetime.utcnow()
1376
+ datetime.timedelta(milliseconds =
1377
time_to_die))
1378
self.disable_initiator_tag = (gobject.timeout_add
1379
(time_to_die, self.disable))
1674
# Reschedule disabling
1675
if self.enabled:
1676
now = datetime.datetime.utcnow()
1677
self.expires += self.timeout - old_timeout
1678
if self.expires <= now:
1679
# The timeout has passed
1680
self.disable()
1681
else:
1682
if (getattr(self, "disable_initiator_tag", None)
1683
is None):
1684
return
1685
gobject.source_remove(self.disable_initiator_tag)
1686
self.disable_initiator_tag = gobject.timeout_add(
1687
int((self.expires - now).total_seconds() * 1000),
1688
self.disable)
1380
1689
1381
1690
# ExtendedTimeout - property
1382
@dbus_service_property(_interface, signature="t",
1691
@dbus_service_property(_interface,
1692
signature="t",
1383
1693
access="readwrite")
1384
1694
def ExtendedTimeout_dbus_property(self, value=None):
1385
1695
if value is None: # get
1386
return dbus.UInt64(self.extended_timeout_milliseconds())
1696
return dbus.UInt64(self.extended_timeout.total_seconds()
1697
* 1000)
1387
1698
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1388
1699
1389
1700
# Interval - property
1390
@dbus_service_property(_interface, signature="t",
1701
@dbus_service_property(_interface,
1702
signature="t",
1391
1703
access="readwrite")
1392
1704
def Interval_dbus_property(self, value=None):
1393
1705
if value is None: # get
1394
return dbus.UInt64(self.interval_milliseconds())
1706
return dbus.UInt64(self.interval.total_seconds() * 1000)
1395
1707
self.interval = datetime.timedelta(0, 0, 0, value)
1396
1708
if getattr(self, "checker_initiator_tag", None) is None:
1397
1709
return
1398
1710
if self.enabled:
1399
1711
# Reschedule checker run
1400
1712
gobject.source_remove(self.checker_initiator_tag)
1401
self.checker_initiator_tag = (gobject.timeout_add
1402
(value, self.start_checker))
1403
self.start_checker() # Start one now, too
1713
self.checker_initiator_tag = gobject.timeout_add(
1714
value, self.start_checker)
1715
self.start_checker() # Start one now, too
1404
1716
1405
1717
# Checker - property
1406
@dbus_service_property(_interface, signature="s",
1718
@dbus_service_property(_interface,
1719
signature="s",
1407
1720
access="readwrite")
1408
1721
def Checker_dbus_property(self, value=None):
1409
1722
if value is None: # get
1410
1723
return dbus.String(self.checker_command)
1411
self.checker_command = unicode(value)
1724
self.checker_command = str(value)
1412
1725
1413
1726
# CheckerRunning - property
1414
@dbus_service_property(_interface, signature="b",
1727
@dbus_service_property(_interface,
1728
signature="b",
1415
1729
access="readwrite")
1416
1730
def CheckerRunning_dbus_property(self, value=None):
1417
1731
if value is None: # get
1422
1736
self.stop_checker()
1423
1737
1424
1738
# ObjectPath - property
1739
@dbus_annotations(
1740
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",
1741
"org.freedesktop.DBus.Deprecated": "true"})
1425
1742
@dbus_service_property(_interface, signature="o", access="read")
1426
1743
def ObjectPath_dbus_property(self):
1427
1744
return self.dbus_object_path # is already a dbus.ObjectPath
1428
1745
1429
1746
# Secret = property
1430
@dbus_service_property(_interface, signature="ay",
1431
access="write", byte_arrays=True)
1747
@dbus_annotations(
1748
{"org.freedesktop.DBus.Property.EmitsChangedSignal":
1749
"invalidates"})
1750
@dbus_service_property(_interface,
1751
signature="ay",
1752
access="write",
1753
byte_arrays=True)
1432
1754
def Secret_dbus_property(self, value):
1433
self.secret = str(value)
1755
self.secret = bytes(value)
1434
1756
1435
1757
del _interface
1436
1758
1440
1762
self._pipe = child_pipe
1441
1763
self._pipe.send(('init', fpr, address))
1442
1764
if not self._pipe.recv():
1443
raise KeyError()
1765
raise KeyError(fpr)
1444
1766
1445
1767
def __getattribute__(self, name):
1446
1768
if name == '_pipe':
1450
1772
if data[0] == 'data':
1451
1773
return data[1]
1452
1774
if data[0] == 'function':
1775
1453
1776
def func(*args, **kwargs):
1454
1777
self._pipe.send(('funcall', name, args, kwargs))
1455
1778
return self._pipe.recv()[1]
1779
1456
1780
return func
1457
1781
1458
1782
def __setattr__(self, name, value):
1461
1785
self._pipe.send(('setattr', name, value))
1462
1786
1463
1787
1464
class ClientDBusTransitional(ClientDBus):
1465
__metaclass__ = AlternateDBusNamesMetaclass
1466
1467
1468
1788
class ClientHandler(socketserver.BaseRequestHandler, object):
1469
1789
"""A class to handle client connections.
1470
1790
1474
1794
def handle(self):
1475
1795
with contextlib.closing(self.server.child_pipe) as child_pipe:
1476
1796
logger.info("TCP connection from: %s",
1477
unicode(self.client_address))
1797
str(self.client_address))
1478
1798
logger.debug("Pipe FD: %d",
1479
1799
self.server.child_pipe.fileno())
1480
1800
1481
session = (gnutls.connection
1482
.ClientSession(self.request,
1483
gnutls.connection
1484
.X509Credentials()))
1801
session = gnutls.connection.ClientSession(
1802
self.request, gnutls.connection .X509Credentials())
1485
1803
1486
1804
# Note: gnutls.connection.X509Credentials is really a
1487
1805
# generic GnuTLS certificate credentials object so long as
1496
1814
priority = self.server.gnutls_priority
1497
1815
if priority is None:
1498
1816
priority = "NORMAL"
1499
(gnutls.library.functions
1500
.gnutls_priority_set_direct(session._c_object,
1501
priority, None))
1817
gnutls.library.functions.gnutls_priority_set_direct(
1818
session._c_object, priority, None)
1502
1819
1503
1820
# Start communication using the Mandos protocol
1504
1821
# Get protocol number
1506
1823
logger.debug("Protocol version: %r", line)
1507
1824
try:
1508
1825
if int(line.strip().split()[0]) > 1:
1509
raise RuntimeError
1826
raise RuntimeError(line)
1510
1827
except (ValueError, IndexError, RuntimeError) as error:
1511
1828
logger.error("Unknown protocol version: %s", error)
1512
1829
return
1524
1841
approval_required = False
1525
1842
try:
1526
1843
try:
1527
fpr = self.fingerprint(self.peer_certificate
1528
(session))
1844
fpr = self.fingerprint(
1845
self.peer_certificate(session))
1529
1846
except (TypeError,
1530
1847
gnutls.errors.GNUTLSError) as error:
1531
1848
logger.warning("Bad certificate: %s", error)
1538
1855
except KeyError:
1539
1856
return
1540
1857
1541
if self.server.use_dbus:
1542
# Emit D-Bus signal
1543
client.NewRequest(str(self.client_address))
1544
1545
1858
if client.approval_delay:
1546
1859
delay = client.approval_delay
1547
1860
client.approvals_pending += 1
1550
1863
while True:
1551
1864
if not client.enabled:
1552
1865
logger.info("Client %s is disabled",
1553
client.name)
1866
client.name)
1554
1867
if self.server.use_dbus:
1555
1868
# Emit D-Bus signal
1556
1869
client.Rejected("Disabled")
1565
1878
if self.server.use_dbus:
1566
1879
# Emit D-Bus signal
1567
1880
client.NeedApproval(
1568
client.approval_delay_milliseconds(),
1569
client.approved_by_default)
1881
client.approval_delay.total_seconds()
1882
* 1000, client.approved_by_default)
1570
1883
else:
1571
1884
logger.warning("Client %s was not approved",
1572
1885
client.name)
1578
1891
#wait until timeout or approved
1579
1892
time = datetime.datetime.now()
1580
1893
client.changedstate.acquire()
1581
(client.changedstate.wait
1582
(float(client.timedelta_to_milliseconds(delay)
1583
/ 1000)))
1894
client.changedstate.wait(delay.total_seconds())
1584
1895
client.changedstate.release()
1585
1896
time2 = datetime.datetime.now()
1586
1897
if (time2 - time) >= delay:
1602
1913
try:
1603
1914
sent = session.send(client.secret[sent_size:])
1604
1915
except gnutls.errors.GNUTLSError as error:
1605
logger.warning("gnutls send failed")
1916
logger.warning("gnutls send failed",
1917
exc_info=error)
1606
1918
return
1607
logger.debug("Sent: %d, remaining: %d",
1608
sent, len(client.secret)
1609
- (sent_size + sent))
1919
logger.debug("Sent: %d, remaining: %d", sent,
1920
len(client.secret) - (sent_size
1921
+ sent))
1610
1922
sent_size += sent
1611
1923
1612
1924
logger.info("Sending secret to %s", client.name)
1613
1925
# bump the timeout using extended_timeout
1614
client.checked_ok(client.extended_timeout)
1926
client.bump_timeout(client.extended_timeout)
1615
1927
if self.server.use_dbus:
1616
1928
# Emit D-Bus signal
1617
1929
client.GotSecret()
1622
1934
try:
1623
1935
session.bye()
1624
1936
except gnutls.errors.GNUTLSError as error:
1625
logger.warning("GnuTLS bye failed")
1937
logger.warning("GnuTLS bye failed",
1938
exc_info=error)
1626
1939
1627
1940
@staticmethod
1628
1941
def peer_certificate(session):
1629
1942
"Return the peer's OpenPGP certificate as a bytestring"
1630
1943
# If not an OpenPGP certificate...
1631
if (gnutls.library.functions
1632
.gnutls_certificate_type_get(session._c_object)
1944
if (gnutls.library.functions.gnutls_certificate_type_get(
1945
session._c_object)
1633
1946
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1634
1947
# ...do the normal thing
1635
1948
return session.peer_certificate
1649
1962
def fingerprint(openpgp):
1650
1963
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1651
1964
# New GnuTLS "datum" with the OpenPGP public key
1652
datum = (gnutls.library.types
1653
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1654
ctypes.POINTER
1655
(ctypes.c_ubyte)),
1656
ctypes.c_uint(len(openpgp))))
1965
datum = gnutls.library.types.gnutls_datum_t(
1966
ctypes.cast(ctypes.c_char_p(openpgp),
1967
ctypes.POINTER(ctypes.c_ubyte)),
1968
ctypes.c_uint(len(openpgp)))
1657
1969
# New empty GnuTLS certificate
1658
1970
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1659
(gnutls.library.functions
1660
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1971
gnutls.library.functions.gnutls_openpgp_crt_init(
1972
ctypes.byref(crt))
1661
1973
# Import the OpenPGP public key into the certificate
1662
(gnutls.library.functions
1663
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1664
gnutls.library.constants
1665
.GNUTLS_OPENPGP_FMT_RAW))
1974
gnutls.library.functions.gnutls_openpgp_crt_import(
1975
crt, ctypes.byref(datum),
1976
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
1666
1977
# Verify the self signature in the key
1667
1978
crtverify = ctypes.c_uint()
1668
(gnutls.library.functions
1669
.gnutls_openpgp_crt_verify_self(crt, 0,
1670
ctypes.byref(crtverify)))
1979
gnutls.library.functions.gnutls_openpgp_crt_verify_self(
1980
crt, 0, ctypes.byref(crtverify))
1671
1981
if crtverify.value != 0:
1672
1982
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1673
raise (gnutls.errors.CertificateSecurityError
1674
("Verify failed"))
1983
raise gnutls.errors.CertificateSecurityError(
1984
"Verify failed")
1675
1985
# New buffer for the fingerprint
1676
1986
buf = ctypes.create_string_buffer(20)
1677
1987
buf_len = ctypes.c_size_t()
1678
1988
# Get the fingerprint from the certificate into the buffer
1679
(gnutls.library.functions
1680
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1681
ctypes.byref(buf_len)))
1989
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint(
1990
crt, ctypes.byref(buf), ctypes.byref(buf_len))
1682
1991
# Deinit the certificate
1683
1992
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1684
1993
# Convert the buffer to a Python bytestring
1690
1999
1691
2000
class MultiprocessingMixIn(object):
1692
2001
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
2002
1693
2003
def sub_process_main(self, request, address):
1694
2004
try:
1695
2005
self.finish_request(request, address)
1700
2010
def process_request(self, request, address):
1701
2011
"""Start a new process to process the request."""
1702
2012
proc = multiprocessing.Process(target = self.sub_process_main,
1703
args = (request,
1704
address))
2013
args = (request, address))
1705
2014
proc.start()
1706
2015
return proc
1707
2016
1708
2017
1709
2018
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1710
2019
""" adds a pipe to the MixIn """
2020
1711
2021
def process_request(self, request, client_address):
1712
2022
"""Overrides and wraps the original process_request().
1713
2023
1722
2032
1723
2033
def add_pipe(self, parent_pipe, proc):
1724
2034
"""Dummy function; override as necessary"""
1725
raise NotImplementedError
2035
raise NotImplementedError()
1726
2036
1727
2037
1728
2038
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1734
2044
interface: None or a network interface name (string)
1735
2045
use_ipv6: Boolean; to use IPv6 or not
1736
2046
"""
2047
1737
2048
def __init__(self, server_address, RequestHandlerClass,
1738
interface=None, use_ipv6=True):
2049
interface=None,
2050
use_ipv6=True,
2051
socketfd=None):
2052
"""If socketfd is set, use that file descriptor instead of
2053
creating a new one with socket.socket().
2054
"""
1739
2055
self.interface = interface
1740
2056
if use_ipv6:
1741
2057
self.address_family = socket.AF_INET6
2058
if socketfd is not None:
2059
# Save the file descriptor
2060
self.socketfd = socketfd
2061
# Save the original socket.socket() function
2062
self.socket_socket = socket.socket
2063
# To implement --socket, we monkey patch socket.socket.
2064
#
2065
# (When socketserver.TCPServer is a new-style class, we
2066
# could make self.socket into a property instead of monkey
2067
# patching socket.socket.)
2068
#
2069
# Create a one-time-only replacement for socket.socket()
2070
@functools.wraps(socket.socket)
2071
def socket_wrapper(*args, **kwargs):
2072
# Restore original function so subsequent calls are
2073
# not affected.
2074
socket.socket = self.socket_socket
2075
del self.socket_socket
2076
# This time only, return a new socket object from the
2077
# saved file descriptor.
2078
return socket.fromfd(self.socketfd, *args, **kwargs)
2079
# Replace socket.socket() function with wrapper
2080
socket.socket = socket_wrapper
2081
# The socketserver.TCPServer.__init__ will call
2082
# socket.socket(), which might be our replacement,
2083
# socket_wrapper(), if socketfd was set.
1742
2084
socketserver.TCPServer.__init__(self, server_address,
1743
2085
RequestHandlerClass)
2086
1744
2087
def server_bind(self):
1745
2088
"""This overrides the normal server_bind() function
1746
2089
to bind to an interface if one was specified, and also NOT to
1752
2095
self.interface)
1753
2096
else:
1754
2097
try:
1755
self.socket.setsockopt(socket.SOL_SOCKET,
1756
SO_BINDTODEVICE,
1757
str(self.interface
1758
+ '\0'))
2098
self.socket.setsockopt(
2099
socket.SOL_SOCKET, SO_BINDTODEVICE,
2100
(self.interface + "\0").encode("utf-8"))
1759
2101
except socket.error as error:
1760
if error[0] == errno.EPERM:
1761
logger.error("No permission to"
1762
" bind to interface %s",
1763
self.interface)
1764
elif error[0] == errno.ENOPROTOOPT:
2102
if error.errno == errno.EPERM:
2103
logger.error("No permission to bind to"
2104
" interface %s", self.interface)
2105
elif error.errno == errno.ENOPROTOOPT:
1765
2106
logger.error("SO_BINDTODEVICE not available;"
1766
2107
" cannot bind to interface %s",
1767
2108
self.interface)
2109
elif error.errno == errno.ENODEV:
2110
logger.error("Interface %s does not exist,"
2111
" cannot bind", self.interface)
1768
2112
else:
1769
2113
raise
1770
2114
# Only bind(2) the socket if we really need to.
1773
2117
if self.address_family == socket.AF_INET6:
1774
2118
any_address = "::" # in6addr_any
1775
2119
else:
1776
any_address = socket.INADDR_ANY
2120
any_address = "0.0.0.0" # INADDR_ANY
1777
2121
self.server_address = (any_address,
1778
2122
self.server_address[1])
1779
2123
elif not self.server_address[1]:
1780
self.server_address = (self.server_address[0],
1781
0)
2124
self.server_address = (self.server_address[0], 0)
1782
2125
# if self.interface:
1783
2126
# self.server_address = (self.server_address[0],
1784
2127
# 0, # port
1798
2141
1799
2142
Assumes a gobject.MainLoop event loop.
1800
2143
"""
2144
1801
2145
def __init__(self, server_address, RequestHandlerClass,
1802
interface=None, use_ipv6=True, clients=None,
1803
gnutls_priority=None, use_dbus=True):
2146
interface=None,
2147
use_ipv6=True,
2148
clients=None,
2149
gnutls_priority=None,
2150
use_dbus=True,
2151
socketfd=None):
1804
2152
self.enabled = False
1805
2153
self.clients = clients
1806
2154
if self.clients is None:
1810
2158
IPv6_TCPServer.__init__(self, server_address,
1811
2159
RequestHandlerClass,
1812
2160
interface = interface,
1813
use_ipv6 = use_ipv6)
2161
use_ipv6 = use_ipv6,
2162
socketfd = socketfd)
2163
1814
2164
def server_activate(self):
1815
2165
if self.enabled:
1816
2166
return socketserver.TCPServer.server_activate(self)
1820
2170
1821
2171
def add_pipe(self, parent_pipe, proc):
1822
2172
# Call "handle_ipc" for both data and EOF events
1823
gobject.io_add_watch(parent_pipe.fileno(),
1824
gobject.IO_IN | gobject.IO_HUP,
1825
functools.partial(self.handle_ipc,
1826
parent_pipe =
1827
parent_pipe,
1828
proc = proc))
2173
gobject.io_add_watch(
2174
parent_pipe.fileno(),
2175
gobject.IO_IN | gobject.IO_HUP,
2176
functools.partial(self.handle_ipc,
2177
parent_pipe = parent_pipe,
2178
proc = proc))
1829
2179
1830
def handle_ipc(self, source, condition, parent_pipe=None,
1831
proc = None, client_object=None):
1832
condition_names = {
1833
gobject.IO_IN: "IN", # There is data to read.
1834
gobject.IO_OUT: "OUT", # Data can be written (without
1835
# blocking).
1836
gobject.IO_PRI: "PRI", # There is urgent data to read.
1837
gobject.IO_ERR: "ERR", # Error condition.
1838
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1839
# broken, usually for pipes and
1840
# sockets).
1841
}
1842
conditions_string = ' | '.join(name
1843
for cond, name in
1844
condition_names.iteritems()
1845
if cond & condition)
2180
def handle_ipc(self, source, condition,
2181
parent_pipe=None,
2182
proc = None,
2183
client_object=None):
1846
2184
# error, or the other end of multiprocessing.Pipe has closed
1847
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
2185
if condition & (gobject.IO_ERR | gobject.IO_HUP):
1848
2186
# Wait for other process to exit
1849
2187
proc.join()
1850
2188
return False
1871
2209
parent_pipe.send(False)
1872
2210
return False
1873
2211
1874
gobject.io_add_watch(parent_pipe.fileno(),
1875
gobject.IO_IN | gobject.IO_HUP,
1876
functools.partial(self.handle_ipc,
1877
parent_pipe =
1878
parent_pipe,
1879
proc = proc,
1880
client_object =
1881
client))
2212
gobject.io_add_watch(
2213
parent_pipe.fileno(),
2214
gobject.IO_IN | gobject.IO_HUP,
2215
functools.partial(self.handle_ipc,
2216
parent_pipe = parent_pipe,
2217
proc = proc,
2218
client_object = client))
1882
2219
parent_pipe.send(True)
1883
2220
# remove the old hook in favor of the new above hook on
1884
2221
# same fileno
1890
2227
1891
2228
parent_pipe.send(('data', getattr(client_object,
1892
2229
funcname)(*args,
1893
**kwargs)))
2230
**kwargs)))
1894
2231
1895
2232
if command == 'getattr':
1896
2233
attrname = request[1]
1897
if callable(client_object.__getattribute__(attrname)):
1898
parent_pipe.send(('function',))
2234
if isinstance(client_object.__getattribute__(attrname),
2235
collections.Callable):
2236
parent_pipe.send(('function', ))
1899
2237
else:
1900
parent_pipe.send(('data', client_object
1901
.__getattribute__(attrname)))
2238
parent_pipe.send((
2239
'data', client_object.__getattribute__(attrname)))
1902
2240
1903
2241
if command == 'setattr':
1904
2242
attrname = request[1]
1908
2246
return True
1909
2247
1910
2248
2249
def rfc3339_duration_to_delta(duration):
2250
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2251
2252
>>> rfc3339_duration_to_delta("P7D")
2253
datetime.timedelta(7)
2254
>>> rfc3339_duration_to_delta("PT60S")
2255
datetime.timedelta(0, 60)
2256
>>> rfc3339_duration_to_delta("PT60M")
2257
datetime.timedelta(0, 3600)
2258
>>> rfc3339_duration_to_delta("PT24H")
2259
datetime.timedelta(1)
2260
>>> rfc3339_duration_to_delta("P1W")
2261
datetime.timedelta(7)
2262
>>> rfc3339_duration_to_delta("PT5M30S")
2263
datetime.timedelta(0, 330)
2264
>>> rfc3339_duration_to_delta("P1DT3M20S")
2265
datetime.timedelta(1, 200)
2266
"""
2267
2268
# Parsing an RFC 3339 duration with regular expressions is not
2269
# possible - there would have to be multiple places for the same
2270
# values, like seconds. The current code, while more esoteric, is
2271
# cleaner without depending on a parsing library. If Python had a
2272
# built-in library for parsing we would use it, but we'd like to
2273
# avoid excessive use of external libraries.
2274
2275
# New type for defining tokens, syntax, and semantics all-in-one
2276
Token = collections.namedtuple("Token", (
2277
"regexp", # To match token; if "value" is not None, must have
2278
# a "group" containing digits
2279
"value", # datetime.timedelta or None
2280
"followers")) # Tokens valid after this token
2281
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2282
# the "duration" ABNF definition in RFC 3339, Appendix A.
2283
token_end = Token(re.compile(r"$"), None, frozenset())
2284
token_second = Token(re.compile(r"(\d+)S"),
2285
datetime.timedelta(seconds=1),
2286
frozenset((token_end, )))
2287
token_minute = Token(re.compile(r"(\d+)M"),
2288
datetime.timedelta(minutes=1),
2289
frozenset((token_second, token_end)))
2290
token_hour = Token(re.compile(r"(\d+)H"),
2291
datetime.timedelta(hours=1),
2292
frozenset((token_minute, token_end)))
2293
token_time = Token(re.compile(r"T"),
2294
None,
2295
frozenset((token_hour, token_minute,
2296
token_second)))
2297
token_day = Token(re.compile(r"(\d+)D"),
2298
datetime.timedelta(days=1),
2299
frozenset((token_time, token_end)))
2300
token_month = Token(re.compile(r"(\d+)M"),
2301
datetime.timedelta(weeks=4),
2302
frozenset((token_day, token_end)))
2303
token_year = Token(re.compile(r"(\d+)Y"),
2304
datetime.timedelta(weeks=52),
2305
frozenset((token_month, token_end)))
2306
token_week = Token(re.compile(r"(\d+)W"),
2307
datetime.timedelta(weeks=1),
2308
frozenset((token_end, )))
2309
token_duration = Token(re.compile(r"P"), None,
2310
frozenset((token_year, token_month,
2311
token_day, token_time,
2312
token_week)))
2313
# Define starting values
2314
value = datetime.timedelta() # Value so far
2315
found_token = None
2316
followers = frozenset((token_duration, )) # Following valid tokens
2317
s = duration # String left to parse
2318
# Loop until end token is found
2319
while found_token is not token_end:
2320
# Search for any currently valid tokens
2321
for token in followers:
2322
match = token.regexp.match(s)
2323
if match is not None:
2324
# Token found
2325
if token.value is not None:
2326
# Value found, parse digits
2327
factor = int(match.group(1), 10)
2328
# Add to value so far
2329
value += factor * token.value
2330
# Strip token from string
2331
s = token.regexp.sub("", s, 1)
2332
# Go to found token
2333
found_token = token
2334
# Set valid next tokens
2335
followers = found_token.followers
2336
break
2337
else:
2338
# No currently valid tokens were found
2339
raise ValueError("Invalid RFC 3339 duration: {!r}"
2340
.format(duration))
2341
# End token found
2342
return value
2343
2344
1911
2345
def string_to_delta(interval):
1912
2346
"""Parse a string and return a datetime.timedelta
1913
2347
1924
2358
>>> string_to_delta('5m 30s')
1925
2359
datetime.timedelta(0, 330)
1926
2360
"""
2361
2362
try:
2363
return rfc3339_duration_to_delta(interval)
2364
except ValueError:
2365
pass
2366
1927
2367
timevalue = datetime.timedelta(0)
1928
2368
for s in interval.split():
1929
2369
try:
1930
suffix = unicode(s[-1])
2370
suffix = s[-1]
1931
2371
value = int(s[:-1])
1932
2372
if suffix == "d":
1933
2373
delta = datetime.timedelta(value)
1940
2380
elif suffix == "w":
1941
2381
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1942
2382
else:
1943
raise ValueError("Unknown suffix %r" % suffix)
1944
except (ValueError, IndexError) as e:
2383
raise ValueError("Unknown suffix {!r}".format(suffix))
2384
except IndexError as e:
1945
2385
raise ValueError(*(e.args))
1946
2386
timevalue += delta
1947
2387
return timevalue
1960
2400
sys.exit()
1961
2401
if not noclose:
1962
2402
# Close all standard open file descriptors
1963
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2403
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1964
2404
if not stat.S_ISCHR(os.fstat(null).st_mode):
1965
2405
raise OSError(errno.ENODEV,
1966
"%s not a character device"
1967
% os.path.devnull)
2406
"{} not a character device"
2407
.format(os.devnull))
1968
2408
os.dup2(null, sys.stdin.fileno())
1969
2409
os.dup2(null, sys.stdout.fileno())
1970
2410
os.dup2(null, sys.stderr.fileno())
1979
2419
1980
2420
parser = argparse.ArgumentParser()
1981
2421
parser.add_argument("-v", "--version", action="version",
1982
version = "%%(prog)s %s" % version,
2422
version = "%(prog)s {}".format(version),
1983
2423
help="show version number and exit")
1984
2424
parser.add_argument("-i", "--interface", metavar="IF",
1985
2425
help="Bind to interface IF")
1991
2431
help="Run self-test")
1992
2432
parser.add_argument("--debug", action="store_true",
1993
2433
help="Debug mode; run in foreground and log"
1994
" to terminal")
2434
" to terminal", default=None)
1995
2435
parser.add_argument("--debuglevel", metavar="LEVEL",
1996
2436
help="Debug level for stdout output")
1997
2437
parser.add_argument("--priority", help="GnuTLS"
2004
2444
" files")
2005
2445
parser.add_argument("--no-dbus", action="store_false",
2006
2446
dest="use_dbus", help="Do not provide D-Bus"
2007
" system bus interface")
2447
" system bus interface", default=None)
2008
2448
parser.add_argument("--no-ipv6", action="store_false",
2009
dest="use_ipv6", help="Do not use IPv6")
2449
dest="use_ipv6", help="Do not use IPv6",
2450
default=None)
2010
2451
parser.add_argument("--no-restore", action="store_false",
2011
2452
dest="restore", help="Do not restore stored"
2012
" state")
2453
" state", default=None)
2454
parser.add_argument("--socket", type=int,
2455
help="Specify a file descriptor to a network"
2456
" socket to use instead of creating one")
2013
2457
parser.add_argument("--statedir", metavar="DIR",
2014
2458
help="Directory to save/restore state in")
2459
parser.add_argument("--foreground", action="store_true",
2460
help="Run in foreground", default=None)
2461
parser.add_argument("--no-zeroconf", action="store_false",
2462
dest="zeroconf", help="Do not use Zeroconf",
2463
default=None)
2015
2464
2016
2465
options = parser.parse_args()
2017
2466
2018
2467
if options.check:
2019
2468
import doctest
2020
doctest.testmod()
2021
sys.exit()
2469
fail_count, test_count = doctest.testmod()
2470
sys.exit(os.EX_OK if fail_count == 0 else 1)
2022
2471
2023
2472
# Default values for config file for server-global settings
2024
2473
server_defaults = { "interface": "",
2026
2475
"port": "",
2027
2476
"debug": "False",
2028
2477
"priority":
2029
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2478
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2479
":+SIGN-DSA-SHA256",
2030
2480
"servicename": "Mandos",
2031
2481
"use_dbus": "True",
2032
2482
"use_ipv6": "True",
2033
2483
"debuglevel": "",
2034
2484
"restore": "True",
2035
"statedir": "/var/lib/mandos"
2036
}
2485
"socket": "",
2486
"statedir": "/var/lib/mandos",
2487
"foreground": "False",
2488
"zeroconf": "True",
2489
}
2037
2490
2038
2491
# Parse config file for server-global settings
2039
2492
server_config = configparser.SafeConfigParser(server_defaults)
2040
2493
del server_defaults
2041
server_config.read(os.path.join(options.configdir,
2042
"mandos.conf"))
2494
server_config.read(os.path.join(options.configdir, "mandos.conf"))
2043
2495
# Convert the SafeConfigParser object to a dict
2044
2496
server_settings = server_config.defaults()
2045
2497
# Use the appropriate methods on the non-string config options
2046
for option in ("debug", "use_dbus", "use_ipv6"):
2498
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2047
2499
server_settings[option] = server_config.getboolean("DEFAULT",
2048
2500
option)
2049
2501
if server_settings["port"]:
2050
2502
server_settings["port"] = server_config.getint("DEFAULT",
2051
2503
"port")
2504
if server_settings["socket"]:
2505
server_settings["socket"] = server_config.getint("DEFAULT",
2506
"socket")
2507
# Later, stdin will, and stdout and stderr might, be dup'ed
2508
# over with an opened os.devnull. But we don't want this to
2509
# happen with a supplied network socket.
2510
if 0 <= server_settings["socket"] <= 2:
2511
server_settings["socket"] = os.dup(server_settings
2512
["socket"])
2052
2513
del server_config
2053
2514
2054
2515
# Override the settings from the config file with command line
2055
2516
# options, if set.
2056
2517
for option in ("interface", "address", "port", "debug",
2057
"priority", "servicename", "configdir",
2058
"use_dbus", "use_ipv6", "debuglevel", "restore",
2059
"statedir"):
2518
"priority", "servicename", "configdir", "use_dbus",
2519
"use_ipv6", "debuglevel", "restore", "statedir",
2520
"socket", "foreground", "zeroconf"):
2060
2521
value = getattr(options, option)
2061
2522
if value is not None:
2062
2523
server_settings[option] = value
2063
2524
del options
2064
2525
# Force all strings to be unicode
2065
2526
for option in server_settings.keys():
2066
if type(server_settings[option]) is str:
2067
server_settings[option] = unicode(server_settings[option])
2527
if isinstance(server_settings[option], bytes):
2528
server_settings[option] = (server_settings[option]
2529
.decode("utf-8"))
2530
# Force all boolean options to be boolean
2531
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2532
"foreground", "zeroconf"):
2533
server_settings[option] = bool(server_settings[option])
2534
# Debug implies foreground
2535
if server_settings["debug"]:
2536
server_settings["foreground"] = True
2068
2537
# Now we have our good server settings in "server_settings"
2069
2538
2070
2539
##################################################################
2071
2540
2541
if (not server_settings["zeroconf"]
2542
and not (server_settings["port"]
2543
or server_settings["socket"] != "")):
2544
parser.error("Needs port or socket to work without Zeroconf")
2545
2072
2546
# For convenience
2073
2547
debug = server_settings["debug"]
2074
2548
debuglevel = server_settings["debuglevel"]
2076
2550
use_ipv6 = server_settings["use_ipv6"]
2077
2551
stored_state_path = os.path.join(server_settings["statedir"],
2078
2552
stored_state_file)
2553
foreground = server_settings["foreground"]
2554
zeroconf = server_settings["zeroconf"]
2079
2555
2080
2556
if debug:
2081
initlogger(logging.DEBUG)
2557
initlogger(debug, logging.DEBUG)
2082
2558
else:
2083
2559
if not debuglevel:
2084
initlogger()
2560
initlogger(debug)
2085
2561
else:
2086
2562
level = getattr(logging, debuglevel.upper())
2087
initlogger(level)
2563
initlogger(debug, level)
2088
2564
2089
2565
if server_settings["servicename"] != "Mandos":
2090
syslogger.setFormatter(logging.Formatter
2091
('Mandos (%s) [%%(process)d]:'
2092
' %%(levelname)s: %%(message)s'
2093
% server_settings["servicename"]))
2566
syslogger.setFormatter(
2567
logging.Formatter('Mandos ({}) [%(process)d]:'
2568
' %(levelname)s: %(message)s'.format(
2569
server_settings["servicename"])))
2094
2570
2095
2571
# Parse config file with clients
2096
client_config = configparser.SafeConfigParser(Client.client_defaults)
2572
client_config = configparser.SafeConfigParser(Client
2573
.client_defaults)
2097
2574
client_config.read(os.path.join(server_settings["configdir"],
2098
2575
"clients.conf"))
2099
2576
2100
2577
global mandos_dbus_service
2101
2578
mandos_dbus_service = None
2102
2579
2103
tcp_server = MandosServer((server_settings["address"],
2104
server_settings["port"]),
2105
ClientHandler,
2106
interface=(server_settings["interface"]
2107
or None),
2108
use_ipv6=use_ipv6,
2109
gnutls_priority=
2110
server_settings["priority"],
2111
use_dbus=use_dbus)
2112
if not debug:
2113
pidfilename = "/var/run/mandos.pid"
2580
socketfd = None
2581
if server_settings["socket"] != "":
2582
socketfd = server_settings["socket"]
2583
tcp_server = MandosServer(
2584
(server_settings["address"], server_settings["port"]),
2585
ClientHandler,
2586
interface=(server_settings["interface"] or None),
2587
use_ipv6=use_ipv6,
2588
gnutls_priority=server_settings["priority"],
2589
use_dbus=use_dbus,
2590
socketfd=socketfd)
2591
if not foreground:
2592
pidfilename = "/run/mandos.pid"
2593
if not os.path.isdir("/run/."):
2594
pidfilename = "/var/run/mandos.pid"
2595
pidfile = None
2114
2596
try:
2115
pidfile = open(pidfilename, "w")
2116
except IOError:
2117
logger.error("Could not open file %r", pidfilename)
2597
pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
2598
except IOError as e:
2599
logger.error("Could not open file %r", pidfilename,
2600
exc_info=e)
2118
2601
2119
try:
2120
uid = pwd.getpwnam("_mandos").pw_uid
2121
gid = pwd.getpwnam("_mandos").pw_gid
2122
except KeyError:
2602
for name in ("_mandos", "mandos", "nobody"):
2123
2603
try:
2124
uid = pwd.getpwnam("mandos").pw_uid
2125
gid = pwd.getpwnam("mandos").pw_gid
2604
uid = pwd.getpwnam(name).pw_uid
2605
gid = pwd.getpwnam(name).pw_gid
2606
break
2126
2607
except KeyError:
2127
try:
2128
uid = pwd.getpwnam("nobody").pw_uid
2129
gid = pwd.getpwnam("nobody").pw_gid
2130
except KeyError:
2131
uid = 65534
2132
gid = 65534
2608
continue
2609
else:
2610
uid = 65534
2611
gid = 65534
2133
2612
try:
2134
2613
os.setgid(gid)
2135
2614
os.setuid(uid)
2136
2615
except OSError as error:
2137
if error[0] != errno.EPERM:
2138
raise error
2616
if error.errno != errno.EPERM:
2617
raise
2139
2618
2140
2619
if debug:
2141
2620
# Enable all possible GnuTLS debugging
2148
2627
def debug_gnutls(level, string):
2149
2628
logger.debug("GnuTLS: %s", string[:-1])
2150
2629
2151
(gnutls.library.functions
2152
.gnutls_global_set_log_function(debug_gnutls))
2630
gnutls.library.functions.gnutls_global_set_log_function(
2631
debug_gnutls)
2153
2632
2154
2633
# Redirect stdin so all checkers get /dev/null
2155
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2634
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2156
2635
os.dup2(null, sys.stdin.fileno())
2157
2636
if null > 2:
2158
2637
os.close(null)
2159
else:
2160
# No console logging
2161
logger.removeHandler(console)
2162
2638
2163
2639
# Need to fork before connecting to D-Bus
2164
if not debug:
2640
if not foreground:
2165
2641
# Close all input and output, do double fork, etc.
2166
2642
daemon()
2167
2643
2644
# multiprocessing will use threads, so before we use gobject we
2645
# need to inform gobject that threads will be used.
2646
gobject.threads_init()
2647
2168
2648
global main_loop
2169
2649
# From the Avahi example code
2170
DBusGMainLoop(set_as_default=True )
2650
DBusGMainLoop(set_as_default=True)
2171
2651
main_loop = gobject.MainLoop()
2172
2652
bus = dbus.SystemBus()
2173
2653
# End of Avahi example code
2174
2654
if use_dbus:
2175
2655
try:
2176
2656
bus_name = dbus.service.BusName("se.recompile.Mandos",
2177
bus, do_not_queue=True)
2178
old_bus_name = (dbus.service.BusName
2179
("se.bsnet.fukt.Mandos", bus,
2180
do_not_queue=True))
2181
except dbus.exceptions.NameExistsException as e:
2182
logger.error(unicode(e) + ", disabling D-Bus")
2657
bus,
2658
do_not_queue=True)
2659
old_bus_name = dbus.service.BusName(
2660
"se.bsnet.fukt.Mandos", bus,
2661
do_not_queue=True)
2662
except dbus.exceptions.DBusException as e:
2663
logger.error("Disabling D-Bus:", exc_info=e)
2183
2664
use_dbus = False
2184
2665
server_settings["use_dbus"] = False
2185
2666
tcp_server.use_dbus = False
2186
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2187
service = AvahiServiceToSyslog(name =
2188
server_settings["servicename"],
2189
servicetype = "_mandos._tcp",
2190
protocol = protocol, bus = bus)
2191
if server_settings["interface"]:
2192
service.interface = (if_nametoindex
2193
(str(server_settings["interface"])))
2667
if zeroconf:
2668
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2669
service = AvahiServiceToSyslog(
2670
name = server_settings["servicename"],
2671
servicetype = "_mandos._tcp",
2672
protocol = protocol,
2673
bus = bus)
2674
if server_settings["interface"]:
2675
service.interface = if_nametoindex(
2676
server_settings["interface"].encode("utf-8"))
2194
2677
2195
2678
global multiprocessing_manager
2196
2679
multiprocessing_manager = multiprocessing.Manager()
2197
2680
2198
2681
client_class = Client
2199
2682
if use_dbus:
2200
client_class = functools.partial(ClientDBusTransitional,
2201
bus = bus)
2683
client_class = functools.partial(ClientDBus, bus = bus)
2202
2684
2203
2685
client_settings = Client.config_parser(client_config)
2204
2686
old_client_settings = {}
2205
2687
clients_data = {}
2206
2688
2689
# This is used to redirect stdout and stderr for checker processes
2690
global wnull
2691
wnull = open(os.devnull, "w") # A writable /dev/null
2692
# Only used if server is running in foreground but not in debug
2693
# mode
2694
if debug or not foreground:
2695
wnull.close()
2696
2207
2697
# Get client data and settings from last running state.
2208
2698
if server_settings["restore"]:
2209
2699
try:
2210
2700
with open(stored_state_path, "rb") as stored_state:
2211
clients_data, old_client_settings = (pickle.load
2212
(stored_state))
2701
clients_data, old_client_settings = pickle.load(
2702
stored_state)
2213
2703
os.remove(stored_state_path)
2214
2704
except IOError as e:
2215
logger.warning("Could not load persistent state: {0}"
2216
.format(e))
2217
if e.errno != errno.ENOENT:
2705
if e.errno == errno.ENOENT:
2706
logger.warning("Could not load persistent state:"
2707
" {}".format(os.strerror(e.errno)))
2708
else:
2709
logger.critical("Could not load persistent state:",
2710
exc_info=e)
2218
2711
raise
2712
except EOFError as e:
2713
logger.warning("Could not load persistent state: "
2714
"EOFError:",
2715
exc_info=e)
2219
2716
2220
2717
with PGPEngine() as pgp:
2221
for client_name, client in clients_data.iteritems():
2718
for client_name, client in clients_data.items():
2719
# Skip removed clients
2720
if client_name not in client_settings:
2721
continue
2722
2222
2723
# Decide which value to use after restoring saved state.
2223
2724
# We have three different values: Old config file,
2224
2725
# new config file, and saved state.
2229
2730
# For each value in new config, check if it
2230
2731
# differs from the old config value (Except for
2231
2732
# the "secret" attribute)
2232
if (name != "secret" and
2233
value != old_client_settings[client_name]
2234
[name]):
2733
if (name != "secret"
2734
and (value !=
2735
old_client_settings[client_name][name])):
2235
2736
client[name] = value
2236
2737
except KeyError:
2237
2738
pass
2238
2739
2239
2740
# Clients who has passed its expire date can still be
2240
# enabled if its last checker was successful. Clients
2241
# whose checker failed before we stored its state is
2242
# assumed to have failed all checkers during downtime.
2741
# enabled if its last checker was successful. A Client
2742
# whose checker succeeded before we stored its state is
2743
# assumed to have successfully run all checkers during
2744
# downtime.
2243
2745
if client["enabled"]:
2244
2746
if datetime.datetime.utcnow() >= client["expires"]:
2245
2747
if not client["last_checked_ok"]:
2246
2748
logger.warning(
2247
"disabling client {0} - Client never "
2248
"performed a successfull checker"
2249
.format(client["name"]))
2749
"disabling client {} - Client never "
2750
"performed a successful checker".format(
2751
client_name))
2250
2752
client["enabled"] = False
2251
2753
elif client["last_checker_status"] != 0:
2252
2754
logger.warning(
2253
"disabling client {0} - Client "
2254
"last checker failed with error code {1}"
2255
.format(client["name"],
2256
client["last_checker_status"]))
2755
"disabling client {} - Client last"
2756
" checker failed with error code"
2757
" {}".format(
2758
client_name,
2759
client["last_checker_status"]))
2257
2760
client["enabled"] = False
2258
2761
else:
2259
client["expires"] = (datetime.datetime
2260
.utcnow()
2261
+ client["timeout"])
2262
2762
client["expires"] = (
2763
datetime.datetime.utcnow()
2764
+ client["timeout"])
2765
logger.debug("Last checker succeeded,"
2766
" keeping {} enabled".format(
2767
client_name))
2263
2768
try:
2264
client["secret"] = (
2265
pgp.decrypt(client["encrypted_secret"],
2266
client_settings[client_name]
2267
["secret"]))
2769
client["secret"] = pgp.decrypt(
2770
client["encrypted_secret"],
2771
client_settings[client_name]["secret"])
2268
2772
except PGPError:
2269
2773
# If decryption fails, we use secret from new settings
2270
logger.debug("Failed to decrypt {0} old secret"
2271
.format(client_name))
2272
client["secret"] = (
2273
client_settings[client_name]["secret"])
2274
2774
logger.debug("Failed to decrypt {} old secret".format(
2775
client_name))
2776
client["secret"] = (client_settings[client_name]
2777
["secret"])
2275
2778
2276
2779
# Add/remove clients based on new changes made to config
2277
for client_name in set(old_client_settings) - set(client_settings):
2780
for client_name in (set(old_client_settings)
2781
- set(client_settings)):
2278
2782
del clients_data[client_name]
2279
for client_name in set(client_settings) - set(old_client_settings):
2783
for client_name in (set(client_settings)
2784
- set(old_client_settings)):
2280
2785
clients_data[client_name] = client_settings[client_name]
2281
2282
# Create clients all clients
2283
for client_name, client in clients_data.iteritems():
2786
2787
# Create all client objects
2788
for client_name, client in clients_data.items():
2284
2789
tcp_server.clients[client_name] = client_class(
2285
name = client_name, settings = client)
2790
name = client_name,
2791
settings = client,
2792
server_settings = server_settings)
2286
2793
2287
2794
if not tcp_server.clients:
2288
2795
logger.warning("No clients defined")
2289
2290
if not debug:
2291
try:
2292
with pidfile:
2293
pid = os.getpid()
2294
pidfile.write(str(pid) + "\n".encode("utf-8"))
2295
del pidfile
2296
except IOError:
2297
logger.error("Could not write to file %r with PID %d",
2298
pidfilename, pid)
2299
except NameError:
2300
# "pidfile" was never created
2301
pass
2796
2797
if not foreground:
2798
if pidfile is not None:
2799
pid = os.getpid()
2800
try:
2801
with pidfile:
2802
print(pid, file=pidfile)
2803
except IOError:
2804
logger.error("Could not write to file %r with PID %d",
2805
pidfilename, pid)
2806
del pidfile
2302
2807
del pidfilename
2303
signal.signal(signal.SIGINT, signal.SIG_IGN)
2304
2808
2305
2809
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2306
2810
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2307
2811
2308
2812
if use_dbus:
2309
class MandosDBusService(dbus.service.Object):
2813
2814
@alternate_dbus_interfaces(
2815
{ "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })
2816
class MandosDBusService(DBusObjectWithAnnotations):
2310
2817
"""A D-Bus proxy object"""
2818
2311
2819
def __init__(self):
2312
2820
dbus.service.Object.__init__(self, bus, "/")
2821
2313
2822
_interface = "se.recompile.Mandos"
2314
2823
2315
2824
@dbus.service.signal(_interface, signature="o")
2330
2839
@dbus.service.method(_interface, out_signature="ao")
2331
2840
def GetAllClients(self):
2332
2841
"D-Bus method"
2333
return dbus.Array(c.dbus_object_path
2334
for c in
2842
return dbus.Array(c.dbus_object_path for c in
2335
2843
tcp_server.clients.itervalues())
2336
2844
2337
2845
@dbus.service.method(_interface,
2339
2847
def GetAllClientsWithProperties(self):
2340
2848
"D-Bus method"
2341
2849
return dbus.Dictionary(
2342
((c.dbus_object_path, c.GetAll(""))
2343
for c in tcp_server.clients.itervalues()),
2850
{ c.dbus_object_path: c.GetAll("")
2851
for c in tcp_server.clients.itervalues() },
2344
2852
signature="oa{sv}")
2345
2853
2346
2854
@dbus.service.method(_interface, in_signature="o")
2359
2867
2360
2868
del _interface
2361
2869
2362
class MandosDBusServiceTransitional(MandosDBusService):
2363
__metaclass__ = AlternateDBusNamesMetaclass
2364
mandos_dbus_service = MandosDBusServiceTransitional()
2870
mandos_dbus_service = MandosDBusService()
2365
2871
2366
2872
def cleanup():
2367
2873
"Cleanup function; run on exit"
2368
service.cleanup()
2874
if zeroconf:
2875
service.cleanup()
2369
2876
2370
2877
multiprocessing.active_children()
2878
wnull.close()
2371
2879
if not (tcp_server.clients or client_settings):
2372
2880
return
2373
2881
2384
2892
2385
2893
# A list of attributes that can not be pickled
2386
2894
# + secret.
2387
exclude = set(("bus", "changedstate", "secret",
2388
"checker"))
2389
for name, typ in (inspect.getmembers
2390
(dbus.service.Object)):
2895
exclude = { "bus", "changedstate", "secret",
2896
"checker", "server_settings" }
2897
for name, typ in inspect.getmembers(dbus.service
2898
.Object):
2391
2899
exclude.add(name)
2392
2900
2393
2901
client_dict["encrypted_secret"] = (client
2400
2908
del client_settings[client.name]["secret"]
2401
2909
2402
2910
try:
2403
with os.fdopen(os.open(stored_state_path,
2404
os.O_CREAT|os.O_WRONLY|os.O_TRUNC,
2405
0600), "wb") as stored_state:
2911
with tempfile.NamedTemporaryFile(
2912
mode='wb',
2913
suffix=".pickle",
2914
prefix='clients-',
2915
dir=os.path.dirname(stored_state_path),
2916
delete=False) as stored_state:
2406
2917
pickle.dump((clients, client_settings), stored_state)
2918
tempname = stored_state.name
2919
os.rename(tempname, stored_state_path)
2407
2920
except (IOError, OSError) as e:
2408
logger.warning("Could not save persistent state: {0}"
2409
.format(e))
2410
if e.errno not in (errno.ENOENT, errno.EACCES):
2921
if not debug:
2922
try:
2923
os.remove(tempname)
2924
except NameError:
2925
pass
2926
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2927
logger.warning("Could not save persistent state: {}"
2928
.format(os.strerror(e.errno)))
2929
else:
2930
logger.warning("Could not save persistent state:",
2931
exc_info=e)
2411
2932
raise
2412
2933
2413
2934
# Delete all clients, and settings from config
2419
2940
client.disable(quiet=True)
2420
2941
if use_dbus:
2421
2942
# Emit D-Bus signal
2422
mandos_dbus_service.ClientRemoved(client
2423
.dbus_object_path,
2424
client.name)
2943
mandos_dbus_service.ClientRemoved(
2944
client.dbus_object_path, client.name)
2425
2945
client_settings.clear()
2426
2946
2427
2947
atexit.register(cleanup)
2438
2958
tcp_server.server_activate()
2439
2959
2440
2960
# Find out what port we got
2441
service.port = tcp_server.socket.getsockname()[1]
2961
if zeroconf:
2962
service.port = tcp_server.socket.getsockname()[1]
2442
2963
if use_ipv6:
2443
2964
logger.info("Now listening on address %r, port %d,"
2444
" flowinfo %d, scope_id %d"
2445
% tcp_server.socket.getsockname())
2965
" flowinfo %d, scope_id %d",
2966
*tcp_server.socket.getsockname())
2446
2967
else: # IPv4
2447
logger.info("Now listening on address %r, port %d"
2448
% tcp_server.socket.getsockname())
2968
logger.info("Now listening on address %r, port %d",
2969
*tcp_server.socket.getsockname())
2449
2970
2450
2971
#service.interface = tcp_server.socket.getsockname()[3]
2451
2972
2452
2973
try:
2453
# From the Avahi example code
2454
try:
2455
service.activate()
2456
except dbus.exceptions.DBusException as error:
2457
logger.critical("DBusException: %s", error)
2458
cleanup()
2459
sys.exit(1)
2460
# End of Avahi example code
2974
if zeroconf:
2975
# From the Avahi example code
2976
try:
2977
service.activate()
2978
except dbus.exceptions.DBusException as error:
2979
logger.critical("D-Bus Exception", exc_info=error)
2980
cleanup()
2981
sys.exit(1)
2982
# End of Avahi example code
2461
2983
2462
2984
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2463
2985
lambda *args, **kwargs:
2467
2989
logger.debug("Starting main loop")
2468
2990
main_loop.run()
2469
2991
except AvahiError as error:
2470
logger.critical("AvahiError: %s", error)
2992
logger.critical("Avahi Error", exc_info=error)
2471
2993
cleanup()
2472
2994
sys.exit(1)
2473
2995
except KeyboardInterrupt:
2478
3000
# Must run before the D-Bus bus name gets deregistered
2479
3001
cleanup()
2480
3002
3003
2481
3004
if __name__ == '__main__':
2482
3005
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0