/mandos/release : revision 237.7.172

68

import binascii

69

import tempfile

70

import itertools

71

import collections

71

72

73

import dbus

73

74

import dbus.service

78

79

import ctypes.util

79

80

import xml.dom.minidom

80

81

import inspect

81

import GnuPGInterface

82

83

try:

84

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

88

except ImportError:

89

SO_BINDTODEVICE = None

90

91

version = "1.5.4"

91

version = "1.6.0"

92

stored_state_file = "clients.pickle"

93

94

logger = logging.getLogger()

139

class PGPEngine(object):

140

"""A simple class for OpenPGP symmetric encryption & decryption"""

141

def __init__(self):

142

self.gnupg = GnuPGInterface.GnuPG()

143

142

self.tempdir = tempfile.mkdtemp(prefix="mandos-")

144

self.gnupg = GnuPGInterface.GnuPG()

145

self.gnupg.options.meta_interactive = False

146

self.gnupg.options.homedir = self.tempdir

147

self.gnupg.options.extra_args.extend(['--force-mdc',

148

'--quiet',

149

'--no-use-agent'])

143

self.gnupgargs = ['--batch',

144

'--home', self.tempdir,

145

'--force-mdc',

146

'--quiet',

147

'--no-use-agent']

150

148

151

149

def __enter__(self):

152

150

return self

153

151

154

def __exit__ (self, exc_type, exc_value, traceback):

152

def __exit__(self, exc_type, exc_value, traceback):

155

153

self._cleanup()

156

154

return False

157

155

177

175

return b"mandos" + binascii.hexlify(password)

178

176

179

177

def encrypt(self, data, password):

180

self.gnupg.passphrase = self.password_encode(password)

181

with open(os.devnull, "w") as devnull:

182

try:

183

proc = self.gnupg.run(['--symmetric'],

184

create_fhs=['stdin', 'stdout'],

185

attach_fhs={'stderr': devnull})

186

with contextlib.closing(proc.handles['stdin']) as f:

187

f.write(data)

188

with contextlib.closing(proc.handles['stdout']) as f:

189

ciphertext = f.read()

190

proc.wait()

191

except IOError as e:

192

raise PGPError(e)

193

self.gnupg.passphrase = None

178

passphrase = self.password_encode(password)

179

with tempfile.NamedTemporaryFile(dir=self.tempdir

180

) as passfile:

181

passfile.write(passphrase)

182

passfile.flush()

183

proc = subprocess.Popen(['gpg', '--symmetric',

184

'--passphrase-file',

185

passfile.name]

186

+ self.gnupgargs,

187

stdin = subprocess.PIPE,

188

stdout = subprocess.PIPE,

189

stderr = subprocess.PIPE)

190

ciphertext, err = proc.communicate(input = data)

191

if proc.returncode != 0:

192

raise PGPError(err)

194

193

return ciphertext

195

194

196

195

def decrypt(self, data, password):

197

self.gnupg.passphrase = self.password_encode(password)

198

with open(os.devnull, "w") as devnull:

199

try:

200

proc = self.gnupg.run(['--decrypt'],

201

create_fhs=['stdin', 'stdout'],

202

attach_fhs={'stderr': devnull})

203

with contextlib.closing(proc.handles['stdin']) as f:

204

f.write(data)

205

with contextlib.closing(proc.handles['stdout']) as f:

206

decrypted_plaintext = f.read()

207

proc.wait()

208

except IOError as e:

209

raise PGPError(e)

210

self.gnupg.passphrase = None

196

passphrase = self.password_encode(password)

197

with tempfile.NamedTemporaryFile(dir = self.tempdir

198

) as passfile:

199

passfile.write(passphrase)

200

passfile.flush()

201

proc = subprocess.Popen(['gpg', '--decrypt',

202

'--passphrase-file',

203

passfile.name]

204

+ self.gnupgargs,

205

stdin = subprocess.PIPE,

206

stdout = subprocess.PIPE,

207

stderr = subprocess.PIPE)

208

decrypted_plaintext, err = proc.communicate(input

209

= data)

210

if proc.returncode != 0:

211

raise PGPError(err)

211

212

return decrypted_plaintext

212

213

214

233

234

Used to optionally bind to the specified interface.

234

235

name: string; Example: 'Mandos'

235

236

type: string; Example: '_mandos._tcp'.

236

See <http://www.dns-sd.org/ServiceTypes.html>

237

See <https://www.iana.org/assignments/service-names-port-numbers>

237

238

port: integer; what port to announce

238

239

TXT: list of strings; TXT record for the service

239

240

domain: string; Domain to publish on, default to .local if empty.

439

440

runtime_expansions: Allowed attributes for runtime expansion.

440

441

expires: datetime.datetime(); time (UTC) when a client will be

441

442

disabled, or None

443

server_settings: The server_settings dict from main()

442

444

"""

443

445

444

446

runtime_expansions = ("approval_delay", "approval_duration",

446

448

"fingerprint", "host", "interval",

447

449

"last_approval_request", "last_checked_ok",

448

450

"last_enabled", "name", "timeout")

449

client_defaults = { "timeout": "5m",

450

"extended_timeout": "15m",

451

"interval": "2m",

451

client_defaults = { "timeout": "PT5M",

452

"extended_timeout": "PT15M",

453

"interval": "PT2M",

452

454

"checker": "fping -q -- %%(host)s",

453

455

"host": "",

454

"approval_delay": "0s",

455

"approval_duration": "1s",

456

"approval_delay": "PT0S",

457

"approval_duration": "PT1S",

456

458

"approved_by_default": "True",

457

459

"enabled": "True",

458

460

}

519

521

520

522

return settings

521

523

522

def __init__(self, settings, name = None):

524

def __init__(self, settings, name = None, server_settings=None):

523

525

self.name = name

526

if server_settings is None:

527

server_settings = {}

528

self.server_settings = server_settings

524

529

# adding all client settings

525

530

for setting, value in settings.iteritems():

526

531

setattr(self, setting, value)

710

715

# in normal mode, that is already done by daemon(),

711

716

# and in debug mode we don't want to. (Stdin is

712

717

# always replaced by /dev/null.)

718

# The exception is when not debugging but nevertheless

719

# running in the foreground; use the previously

720

# created wnull.

721

popen_args = {}

722

if (not self.server_settings["debug"]

723

and self.server_settings["foreground"]):

724

popen_args.update({"stdout": wnull,

725

"stderr": wnull })

713

726

self.checker = subprocess.Popen(command,

714

727

close_fds=True,

715

shell=True, cwd="/")

728

shell=True, cwd="/",

729

**popen_args)

716

730

except OSError as error:

717

731

logger.error("Failed to start subprocess",

718

732

exc_info=error)

733

return True

719

734

self.checker_callback_tag = (gobject.child_watch_add

720

735

(self.checker.pid,

721

736

self.checker_callback,

722

737

data=command))

723

738

# The checker may have completed before the gobject

724

739

# watch was added. Check for this.

725

pid, status = os.waitpid(self.checker.pid, os.WNOHANG)

740

try:

741

pid, status = os.waitpid(self.checker.pid, os.WNOHANG)

742

except OSError as error:

743

if error.errno == errno.ECHILD:

744

# This should never happen

745

logger.error("Child process vanished",

746

exc_info=error)

747

return True

748

raise

726

749

if pid:

727

750

gobject.source_remove(self.checker_callback_tag)

728

751

self.checker_callback(pid, status, command)

1016

1039

return xmlstring

1017

1040

1018

1041

1019

def datetime_to_dbus (dt, variant_level=0):

1042

def datetime_to_dbus(dt, variant_level=0):

1020

1043

"""Convert a UTC datetime.datetime() to a D-Bus type."""

1021

1044

if dt is None:

1022

1045

return dbus.String("", variant_level = variant_level)

1030

1053

interface names according to the "alt_interface_names" mapping.

1031

1054

Usage:

1032

1055

1033

@alternate_dbus_names({"org.example.Interface":

1034

"net.example.AlternateInterface"})

1056

@alternate_dbus_interfaces({"org.example.Interface":

1057

"net.example.AlternateInterface"})

1035

1058

class SampleDBusObject(dbus.service.Object):

1036

1059

@dbus.service.method("org.example.Interface")

1037

1060

def SampleDBusMethod():

1068

1091

interface_names.add(alt_interface)

1069

1092

# Is this a D-Bus signal?

1070

1093

if getattr(attribute, "_dbus_is_signal", False):

1071

# Extract the original non-method function by

1072

# black magic

1094

# Extract the original non-method undecorated

1095

# function by black magic

1073

1096

nonmethod_func = (dict(

1074

1097

zip(attribute.func_code.co_freevars,

1075

1098

attribute.__closure__))["func"]

1899

1922

use_ipv6: Boolean; to use IPv6 or not

1900

1923

"""

1901

1924

def __init__(self, server_address, RequestHandlerClass,

1902

interface=None, use_ipv6=True):

1925

interface=None, use_ipv6=True, socketfd=None):

1926

"""If socketfd is set, use that file descriptor instead of

1927

creating a new one with socket.socket().

1928

"""

1903

1929

self.interface = interface

1904

1930

if use_ipv6:

1905

1931

self.address_family = socket.AF_INET6

1932

if socketfd is not None:

1933

# Save the file descriptor

1934

self.socketfd = socketfd

1935

# Save the original socket.socket() function

1936

self.socket_socket = socket.socket

1937

# To implement --socket, we monkey patch socket.socket.

1938

#

1939

# (When socketserver.TCPServer is a new-style class, we

1940

# could make self.socket into a property instead of monkey

1941

# patching socket.socket.)

1942

#

1943

# Create a one-time-only replacement for socket.socket()

1944

@functools.wraps(socket.socket)

1945

def socket_wrapper(*args, **kwargs):

1946

# Restore original function so subsequent calls are

1947

# not affected.

1948

socket.socket = self.socket_socket

1949

del self.socket_socket

1950

# This time only, return a new socket object from the

1951

# saved file descriptor.

1952

return socket.fromfd(self.socketfd, *args, **kwargs)

1953

# Replace socket.socket() function with wrapper

1954

socket.socket = socket_wrapper

1955

# The socketserver.TCPServer.__init__ will call

1956

# socket.socket(), which might be our replacement,

1957

# socket_wrapper(), if socketfd was set.

1906

1958

socketserver.TCPServer.__init__(self, server_address,

1907

1959

RequestHandlerClass)

1960

1908

1961

def server_bind(self):

1909

1962

"""This overrides the normal server_bind() function

1910

1963

to bind to an interface if one was specified, and also NOT to

1918

1971

try:

1919

1972

self.socket.setsockopt(socket.SOL_SOCKET,

1920

1973

SO_BINDTODEVICE,

1921

str(self.interface

1922

+ '\0'))

1974

str(self.interface + '\0'))

1923

1975

except socket.error as error:

1924

1976

if error.errno == errno.EPERM:

1925

logger.error("No permission to"

1926

" bind to interface %s",

1927

self.interface)

1977

logger.error("No permission to bind to"

1978

" interface %s", self.interface)

1928

1979

elif error.errno == errno.ENOPROTOOPT:

1929

1980

logger.error("SO_BINDTODEVICE not available;"

1930

1981

" cannot bind to interface %s",

1931

1982

self.interface)

1932

1983

elif error.errno == errno.ENODEV:

1933

logger.error("Interface %s does not"

1934

" exist, cannot bind",

1935

self.interface)

1984

logger.error("Interface %s does not exist,"

1985

" cannot bind", self.interface)

1936

1986

else:

1937

1987

raise

1938

1988

# Only bind(2) the socket if we really need to.

1941

1991

if self.address_family == socket.AF_INET6:

1942

1992

any_address = "::" # in6addr_any

1943

1993

else:

1944

any_address = socket.INADDR_ANY

1994

any_address = "0.0.0.0" # INADDR_ANY

1945

1995

self.server_address = (any_address,

1946

1996

self.server_address[1])

1947

1997

elif not self.server_address[1]:

1968

2018

"""

1969

2019

def __init__(self, server_address, RequestHandlerClass,

1970

2020

interface=None, use_ipv6=True, clients=None,

1971

gnutls_priority=None, use_dbus=True):

2021

gnutls_priority=None, use_dbus=True, socketfd=None):

1972

2022

self.enabled = False

1973

2023

self.clients = clients

1974

2024

if self.clients is None:

1978

2028

IPv6_TCPServer.__init__(self, server_address,

1979

2029

RequestHandlerClass,

1980

2030

interface = interface,

1981

use_ipv6 = use_ipv6)

2031

use_ipv6 = use_ipv6,

2032

socketfd = socketfd)

1982

2033

def server_activate(self):

1983

2034

if self.enabled:

1984

2035

return socketserver.TCPServer.server_activate(self)

2062

2113

return True

2063

2114

2064

2115

2116

def rfc3339_duration_to_delta(duration):

2117

"""Parse an RFC 3339 "duration" and return a datetime.timedelta

2118

2119

>>> rfc3339_duration_to_delta("P7D")

2120

datetime.timedelta(7)

2121

>>> rfc3339_duration_to_delta("PT60S")

2122

datetime.timedelta(0, 60)

2123

>>> rfc3339_duration_to_delta("PT60M")

2124

datetime.timedelta(0, 3600)

2125

>>> rfc3339_duration_to_delta("PT24H")

2126

datetime.timedelta(1)

2127

>>> rfc3339_duration_to_delta("P1W")

2128

datetime.timedelta(7)

2129

>>> rfc3339_duration_to_delta("PT5M30S")

2130

datetime.timedelta(0, 330)

2131

>>> rfc3339_duration_to_delta("P1DT3M20S")

2132

datetime.timedelta(1, 200)

2133

"""

2134

2135

# Parsing an RFC 3339 duration with regular expressions is not

2136

# possible - there would have to be multiple places for the same

2137

# values, like seconds. The current code, while more esoteric, is

2138

# cleaner without depending on a parsing library. If Python had a

2139

# built-in library for parsing we would use it, but we'd like to

2140

# avoid excessive use of external libraries.

2141

2142

# New type for defining tokens, syntax, and semantics all-in-one

2143

Token = collections.namedtuple("Token",

2144

("regexp", # To match token; if

2145

# "value" is not None,

2146

# must have a "group"

2147

# containing digits

2148

"value", # datetime.timedelta or

2149

# None

2150

"followers")) # Tokens valid after

2151

# this token

2152

# RFC 3339 "duration" tokens, syntax, and semantics; taken from

2153

# the "duration" ABNF definition in RFC 3339, Appendix A.

2154

token_end = Token(re.compile(r"$"), None, frozenset())

2155

token_second = Token(re.compile(r"(\d+)S"),

2156

datetime.timedelta(seconds=1),

2157

frozenset((token_end,)))

2158

token_minute = Token(re.compile(r"(\d+)M"),

2159

datetime.timedelta(minutes=1),

2160

frozenset((token_second, token_end)))

2161

token_hour = Token(re.compile(r"(\d+)H"),

2162

datetime.timedelta(hours=1),

2163

frozenset((token_minute, token_end)))

2164

token_time = Token(re.compile(r"T"),

2165

None,

2166

frozenset((token_hour, token_minute,

2167

token_second)))

2168

token_day = Token(re.compile(r"(\d+)D"),

2169

datetime.timedelta(days=1),

2170

frozenset((token_time, token_end)))

2171

token_month = Token(re.compile(r"(\d+)M"),

2172

datetime.timedelta(weeks=4),

2173

frozenset((token_day, token_end)))

2174

token_year = Token(re.compile(r"(\d+)Y"),

2175

datetime.timedelta(weeks=52),

2176

frozenset((token_month, token_end)))

2177

token_week = Token(re.compile(r"(\d+)W"),

2178

datetime.timedelta(weeks=1),

2179

frozenset((token_end,)))

2180

token_duration = Token(re.compile(r"P"), None,

2181

frozenset((token_year, token_month,

2182

token_day, token_time,

2183

token_week))),

2184

# Define starting values

2185

value = datetime.timedelta() # Value so far

2186

found_token = None

2187

followers = frozenset(token_duration,) # Following valid tokens

2188

s = duration # String left to parse

2189

# Loop until end token is found

2190

while found_token is not token_end:

2191

# Search for any currently valid tokens

2192

for token in followers:

2193

match = token.regexp.match(s)

2194

if match is not None:

2195

# Token found

2196

if token.value is not None:

2197

# Value found, parse digits

2198

factor = int(match.group(1), 10)

2199

# Add to value so far

2200

value += factor * token.value

2201

# Strip token from string

2202

s = token.regexp.sub("", s, 1)

2203

# Go to found token

2204

found_token = token

2205

# Set valid next tokens

2206

followers = found_token.followers

2207

break

2208

else:

2209

# No currently valid tokens were found

2210

raise ValueError("Invalid RFC 3339 duration")

2211

# End token found

2212

return value

2213

2214

2065

2215

def string_to_delta(interval):

2066

2216

"""Parse a string and return a datetime.timedelta

2067

2217

2078

2228

>>> string_to_delta('5m 30s')

2079

2229

datetime.timedelta(0, 330)

2080

2230

"""

2231

2232

try:

2233

return rfc3339_duration_to_delta(interval)

2234

except ValueError:

2235

pass

2236

2081

2237

timevalue = datetime.timedelta(0)

2082

2238

for s in interval.split():

2083

2239

try:

2146

2302

help="Run self-test")

2147

2303

parser.add_argument("--debug", action="store_true",

2148

2304

help="Debug mode; run in foreground and log"

2149

" to terminal")

2305

" to terminal", default=None)

2150

2306

parser.add_argument("--debuglevel", metavar="LEVEL",

2151

2307

help="Debug level for stdout output")

2152

2308

parser.add_argument("--priority", help="GnuTLS"

2159

2315

" files")

2160

2316

parser.add_argument("--no-dbus", action="store_false",

2161

2317

dest="use_dbus", help="Do not provide D-Bus"

2162

" system bus interface")

2318

" system bus interface", default=None)

2163

2319

parser.add_argument("--no-ipv6", action="store_false",

2164

dest="use_ipv6", help="Do not use IPv6")

2320

dest="use_ipv6", help="Do not use IPv6",

2321

default=None)

2165

2322

parser.add_argument("--no-restore", action="store_false",

2166

2323

dest="restore", help="Do not restore stored"

2167

" state")

2324

" state", default=None)

2325

parser.add_argument("--socket", type=int,

2326

help="Specify a file descriptor to a network"

2327

" socket to use instead of creating one")

2168

2328

parser.add_argument("--statedir", metavar="DIR",

2169

2329

help="Directory to save/restore state in")

2330

parser.add_argument("--foreground", action="store_true",

2331

help="Run in foreground", default=None)

2170

2332

2171

2333

options = parser.parse_args()

2172

2334

2181

2343

"port": "",

2182

2344

"debug": "False",

2183

2345

"priority":

2184

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",

2346

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224",

2185

2347

"servicename": "Mandos",

2186

2348

"use_dbus": "True",

2187

2349

"use_ipv6": "True",

2188

2350

"debuglevel": "",

2189

2351

"restore": "True",

2190

"statedir": "/var/lib/mandos"

2352

"socket": "",

2353

"statedir": "/var/lib/mandos",

2354

"foreground": "False",

2191

2355

}

2192

2356

2193

2357

# Parse config file for server-global settings

2198

2362

# Convert the SafeConfigParser object to a dict

2199

2363

server_settings = server_config.defaults()

2200

2364

# Use the appropriate methods on the non-string config options

2201

for option in ("debug", "use_dbus", "use_ipv6"):

2365

for option in ("debug", "use_dbus", "use_ipv6", "foreground"):

2202

2366

server_settings[option] = server_config.getboolean("DEFAULT",

2203

2367

option)

2204

2368

if server_settings["port"]:

2205

2369

server_settings["port"] = server_config.getint("DEFAULT",

2206

2370

"port")

2371

if server_settings["socket"]:

2372

server_settings["socket"] = server_config.getint("DEFAULT",

2373

"socket")

2374

# Later, stdin will, and stdout and stderr might, be dup'ed

2375

# over with an opened os.devnull. But we don't want this to

2376

# happen with a supplied network socket.

2377

if 0 <= server_settings["socket"] <= 2:

2378

server_settings["socket"] = os.dup(server_settings

2379

["socket"])

2207

2380

del server_config

2208

2381

2209

2382

# Override the settings from the config file with command line

2211

2384

for option in ("interface", "address", "port", "debug",

2212

2385

"priority", "servicename", "configdir",

2213

2386

"use_dbus", "use_ipv6", "debuglevel", "restore",

2214

"statedir"):

2387

"statedir", "socket", "foreground"):

2215

2388

value = getattr(options, option)

2216

2389

if value is not None:

2217

2390

server_settings[option] = value

2220

2393

for option in server_settings.keys():

2221

2394

if type(server_settings[option]) is str:

2222

2395

server_settings[option] = unicode(server_settings[option])

2396

# Force all boolean options to be boolean

2397

for option in ("debug", "use_dbus", "use_ipv6", "restore",

2398

"foreground"):

2399

server_settings[option] = bool(server_settings[option])

2400

# Debug implies foreground

2401

if server_settings["debug"]:

2402

server_settings["foreground"] = True

2223

2403

# Now we have our good server settings in "server_settings"

2224

2404

2225

2405

##################################################################

2231

2411

use_ipv6 = server_settings["use_ipv6"]

2232

2412

stored_state_path = os.path.join(server_settings["statedir"],

2233

2413

stored_state_file)

2414

foreground = server_settings["foreground"]

2234

2415

2235

2416

if debug:

2236

2417

initlogger(debug, logging.DEBUG)

2265

2446

use_ipv6=use_ipv6,

2266

2447

gnutls_priority=

2267

2448

server_settings["priority"],

2268

use_dbus=use_dbus)

2269

if not debug:

2449

use_dbus=use_dbus,

2450

socketfd=(server_settings["socket"]

2451

or None))

2452

if not foreground:

2270

2453

pidfilename = "/var/run/mandos.pid"

2454

pidfile = None

2271

2455

try:

2272

2456

pidfile = open(pidfilename, "w")

2273

2457

except IOError as e:

2312

2496

os.close(null)

2313

2497

2314

2498

# Need to fork before connecting to D-Bus

2315

if not debug:

2499

if not foreground:

2316

2500

# Close all input and output, do double fork, etc.

2317

2501

daemon()

2318

2502

2503

# multiprocessing will use threads, so before we use gobject we

2504

# need to inform gobject that threads will be used.

2319

2505

gobject.threads_init()

2320

2506

2321

2507

global main_loop

2356

2542

old_client_settings = {}

2357

2543

clients_data = {}

2358

2544

2545

# This is used to redirect stdout and stderr for checker processes

2546

global wnull

2547

wnull = open(os.devnull, "w") # A writable /dev/null

2548

# Only used if server is running in foreground but not in debug

2549

# mode

2550

if debug or not foreground:

2551

wnull.close()

2552

2359

2553

# Get client data and settings from last running state.

2360

2554

if server_settings["restore"]:

2361

2555

try:

2377

2571

2378

2572

with PGPEngine() as pgp:

2379

2573

for client_name, client in clients_data.iteritems():

2574

# Skip removed clients

2575

if client_name not in client_settings:

2576

continue

2577

2380

2578

# Decide which value to use after restoring saved state.

2381

2579

# We have three different values: Old config file,

2382

2580

# new config file, and saved state.

2444

2642

# Create all client objects

2445

2643

for client_name, client in clients_data.iteritems():

2446

2644

tcp_server.clients[client_name] = client_class(

2447

name = client_name, settings = client)

2645

name = client_name, settings = client,

2646

server_settings = server_settings)

2448

2647

2449

2648

if not tcp_server.clients:

2450

2649

logger.warning("No clients defined")

2451

2650

2452

if not debug:

2453

try:

2454

with pidfile:

2455

pid = os.getpid()

2456

pidfile.write(str(pid) + "\n".encode("utf-8"))

2457

del pidfile

2458

except IOError:

2459

logger.error("Could not write to file %r with PID %d",

2460

pidfilename, pid)

2461

except NameError:

2462

# "pidfile" was never created

2463

pass

2651

if not foreground:

2652

if pidfile is not None:

2653

try:

2654

with pidfile:

2655

pid = os.getpid()

2656

pidfile.write(str(pid) + "\n".encode("utf-8"))

2657

except IOError:

2658

logger.error("Could not write to file %r with PID %d",

2659

pidfilename, pid)

2660

del pidfile

2464

2661

del pidfilename

2465

2662

2466

2663

signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())

2535

2732

service.cleanup()

2536

2733

2537

2734

multiprocessing.active_children()

2735

wnull.close()

2538

2736

if not (tcp_server.clients or client_settings):

2539

2737

return

2540

2738

2552

2750

# A list of attributes that can not be pickled

2553

2751

# + secret.

2554

2752

exclude = set(("bus", "changedstate", "secret",

2555

"checker"))

2753

"checker", "server_settings"))

2556

2754

for name, typ in (inspect.getmembers

2557

2755

(dbus.service.Object)):

2558

2756

exclude.add(name)