/mandos/trunk : revision 237.7.1

11

# "AvahiService" class, and some lines in "main".

12

#

13

# Everything else is

14

15

14

15

16

#

17

# This program is free software: you can redistribute it and/or modify

18

# it under the terms of the GNU General Public License as published by

68

import binascii

69

import tempfile

70

import itertools

71

import collections

72

71

73

72

import dbus

74

73

import dbus.service

79

78

import ctypes.util

80

79

import xml.dom.minidom

81

80

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.6.1"

91

version = "1.5.3"

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()

142

143

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

143

self.gnupgargs = ['--batch',

144

'--home', self.tempdir,

145

'--force-mdc',

146

'--quiet',

147

'--no-use-agent']

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'])

148

150

149

151

def __enter__(self):

150

152

return self

151

153

152

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

154

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

153

155

self._cleanup()

154

156

return False

155

157

172

174

def password_encode(self, password):

173

175

# Passphrase can not be empty and can not contain newlines or

174

176

# NUL bytes. So we prefix it and hex encode it.

175

encoded = b"mandos" + binascii.hexlify(password)

176

if len(encoded) > 2048:

177

# GnuPG can't handle long passwords, so encode differently

178

encoded = (b"mandos" + password.replace(b"\\", b"\\\\")

179

.replace(b"\n", b"\\n")

180

.replace(b"\0", b"\\x00"))

181

return encoded

177

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

182

178

183

179

def encrypt(self, data, password):

184

passphrase = self.password_encode(password)

185

with tempfile.NamedTemporaryFile(dir=self.tempdir

186

) as passfile:

187

passfile.write(passphrase)

188

passfile.flush()

189

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

190

'--passphrase-file',

191

passfile.name]

192

+ self.gnupgargs,

193

stdin = subprocess.PIPE,

194

stdout = subprocess.PIPE,

195

stderr = subprocess.PIPE)

196

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

197

if proc.returncode != 0:

198

raise PGPError(err)

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

199

194

return ciphertext

200

195

201

196

def decrypt(self, data, password):

202

passphrase = self.password_encode(password)

203

with tempfile.NamedTemporaryFile(dir = self.tempdir

204

) as passfile:

205

passfile.write(passphrase)

206

passfile.flush()

207

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

208

'--passphrase-file',

209

passfile.name]

210

+ self.gnupgargs,

211

stdin = subprocess.PIPE,

212

stdout = subprocess.PIPE,

213

stderr = subprocess.PIPE)

214

decrypted_plaintext, err = proc.communicate(input

215

= data)

216

if proc.returncode != 0:

217

raise PGPError(err)

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

218

211

return decrypted_plaintext

219

212

220

213

240

233

Used to optionally bind to the specified interface.

241

234

name: string; Example: 'Mandos'

242

235

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

243

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

236

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

244

237

port: integer; what port to announce

245

238

TXT: list of strings; TXT record for the service

246

239

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

446

439

runtime_expansions: Allowed attributes for runtime expansion.

447

440

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

448

441

disabled, or None

449

server_settings: The server_settings dict from main()

450

442

"""

451

443

452

444

runtime_expansions = ("approval_delay", "approval_duration",

454

446

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

455

447

"last_approval_request", "last_checked_ok",

456

448

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

457

client_defaults = { "timeout": "PT5M",

458

"extended_timeout": "PT15M",

459

"interval": "PT2M",

449

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

450

"extended_timeout": "15m",

451

"interval": "2m",

460

452

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

461

453

"host": "",

462

"approval_delay": "PT0S",

463

"approval_duration": "PT1S",

454

"approval_delay": "0s",

455

"approval_duration": "1s",

464

456

"approved_by_default": "True",

465

457

"enabled": "True",

466

458

}

527

519

528

520

return settings

529

521

530

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

522

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

531

523

self.name = name

532

if server_settings is None:

533

server_settings = {}

534

self.server_settings = server_settings

535

524

# adding all client settings

536

525

for setting, value in settings.iteritems():

537

526

setattr(self, setting, value)

721

710

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

722

711

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

723

712

# always replaced by /dev/null.)

724

# The exception is when not debugging but nevertheless

725

# running in the foreground; use the previously

726

# created wnull.

727

popen_args = {}

728

if (not self.server_settings["debug"]

729

and self.server_settings["foreground"]):

730

popen_args.update({"stdout": wnull,

731

"stderr": wnull })

732

713

self.checker = subprocess.Popen(command,

733

714

close_fds=True,

734

shell=True, cwd="/",

735

**popen_args)

715

shell=True, cwd="/")

736

716

except OSError as error:

737

717

logger.error("Failed to start subprocess",

738

718

exc_info=error)

739

return True

740

719

self.checker_callback_tag = (gobject.child_watch_add

741

720

(self.checker.pid,

742

721

self.checker_callback,

743

722

data=command))

744

723

# The checker may have completed before the gobject

745

724

# watch was added. Check for this.

746

try:

747

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

748

except OSError as error:

749

if error.errno == errno.ECHILD:

750

# This should never happen

751

logger.error("Child process vanished",

752

exc_info=error)

753

return True

754

raise

725

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

755

726

if pid:

756

727

gobject.source_remove(self.checker_callback_tag)

757

728

self.checker_callback(pid, status, command)

1045

1016

return xmlstring

1046

1017

1047

1018

1048

def datetime_to_dbus(dt, variant_level=0):

1019

def datetime_to_dbus (dt, variant_level=0):

1049

1020

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

1050

1021

if dt is None:

1051

1022

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

1059

1030

interface names according to the "alt_interface_names" mapping.

1060

1031

Usage:

1061

1032

1062

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

1063

"net.example.AlternateInterface"})

1033

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

1034

"net.example.AlternateInterface"})

1064

1035

class SampleDBusObject(dbus.service.Object):

1065

1036

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

1066

1037

def SampleDBusMethod():

1097

1068

interface_names.add(alt_interface)

1098

1069

# Is this a D-Bus signal?

1099

1070

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

1100

# Extract the original non-method undecorated

1101

# function by black magic

1071

# Extract the original non-method function by

1072

# black magic

1102

1073

nonmethod_func = (dict(

1103

1074

zip(attribute.func_code.co_freevars,

1104

1075

attribute.__closure__))["func"]

1928

1899

use_ipv6: Boolean; to use IPv6 or not

1929

1900

"""

1930

1901

def __init__(self, server_address, RequestHandlerClass,

1931

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

1932

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

1933

creating a new one with socket.socket().

1934

"""

1902

interface=None, use_ipv6=True):

1935

1903

self.interface = interface

1936

1904

if use_ipv6:

1937

1905

self.address_family = socket.AF_INET6

1938

if socketfd is not None:

1939

# Save the file descriptor

1940

self.socketfd = socketfd

1941

# Save the original socket.socket() function

1942

self.socket_socket = socket.socket

1943

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

1944

#

1945

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

1946

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

1947

# patching socket.socket.)

1948

#

1949

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

1950

@functools.wraps(socket.socket)

1951

def socket_wrapper(*args, **kwargs):

1952

# Restore original function so subsequent calls are

1953

# not affected.

1954

socket.socket = self.socket_socket

1955

del self.socket_socket

1956

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

1957

# saved file descriptor.

1958

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

1959

# Replace socket.socket() function with wrapper

1960

socket.socket = socket_wrapper

1961

# The socketserver.TCPServer.__init__ will call

1962

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

1963

# socket_wrapper(), if socketfd was set.

1964

1906

socketserver.TCPServer.__init__(self, server_address,

1965

1907

RequestHandlerClass)

1966

1967

1908

def server_bind(self):

1968

1909

"""This overrides the normal server_bind() function

1969

1910

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

1977

1918

try:

1978

1919

self.socket.setsockopt(socket.SOL_SOCKET,

1979

1920

SO_BINDTODEVICE,

1980

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

1921

str(self.interface

1922

+ '\0'))

1981

1923

except socket.error as error:

1982

1924

if error.errno == errno.EPERM:

1983

logger.error("No permission to bind to"

1984

" interface %s", self.interface)

1925

logger.error("No permission to"

1926

" bind to interface %s",

1927

self.interface)

1985

1928

elif error.errno == errno.ENOPROTOOPT:

1986

1929

logger.error("SO_BINDTODEVICE not available;"

1987

1930

" cannot bind to interface %s",

1988

1931

self.interface)

1989

1932

elif error.errno == errno.ENODEV:

1990

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

1991

" cannot bind", self.interface)

1933

logger.error("Interface %s does not"

1934

" exist, cannot bind",

1935

self.interface)

1992

1936

else:

1993

1937

raise

1994

1938

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

1997

1941

if self.address_family == socket.AF_INET6:

1998

1942

any_address = "::" # in6addr_any

1999

1943

else:

2000

any_address = "0.0.0.0" # INADDR_ANY

1944

any_address = socket.INADDR_ANY

2001

1945

self.server_address = (any_address,

2002

1946

self.server_address[1])

2003

1947

elif not self.server_address[1]:

2024

1968

"""

2025

1969

def __init__(self, server_address, RequestHandlerClass,

2026

1970

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

2027

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

1971

gnutls_priority=None, use_dbus=True):

2028

1972

self.enabled = False

2029

1973

self.clients = clients

2030

1974

if self.clients is None:

2034

1978

IPv6_TCPServer.__init__(self, server_address,

2035

1979

RequestHandlerClass,

2036

1980

interface = interface,

2037

use_ipv6 = use_ipv6,

2038

socketfd = socketfd)

1981

use_ipv6 = use_ipv6)

2039

1982

def server_activate(self):

2040

1983

if self.enabled:

2041

1984

return socketserver.TCPServer.server_activate(self)

2119

2062

return True

2120

2063

2121

2064

2122

def rfc3339_duration_to_delta(duration):

2123

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

2124

2125

>>> rfc3339_duration_to_delta("P7D")

2126

datetime.timedelta(7)

2127

>>> rfc3339_duration_to_delta("PT60S")

2128

datetime.timedelta(0, 60)

2129

>>> rfc3339_duration_to_delta("PT60M")

2130

datetime.timedelta(0, 3600)

2131

>>> rfc3339_duration_to_delta("PT24H")

2132

datetime.timedelta(1)

2133

>>> rfc3339_duration_to_delta("P1W")

2134

datetime.timedelta(7)

2135

>>> rfc3339_duration_to_delta("PT5M30S")

2136

datetime.timedelta(0, 330)

2137

>>> rfc3339_duration_to_delta("P1DT3M20S")

2138

datetime.timedelta(1, 200)

2139

"""

2140

2141

# Parsing an RFC 3339 duration with regular expressions is not

2142

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

2143

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

2144

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

2145

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

2146

# avoid excessive use of external libraries.

2147

2148

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

2149

Token = collections.namedtuple("Token",

2150

("regexp", # To match token; if

2151

# "value" is not None,

2152

# must have a "group"

2153

# containing digits

2154

"value", # datetime.timedelta or

2155

# None

2156

"followers")) # Tokens valid after

2157

# this token

2158

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

2159

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

2160

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

2161

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

2162

datetime.timedelta(seconds=1),

2163

frozenset((token_end,)))

2164

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

2165

datetime.timedelta(minutes=1),

2166

frozenset((token_second, token_end)))

2167

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

2168

datetime.timedelta(hours=1),

2169

frozenset((token_minute, token_end)))

2170

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

2171

None,

2172

frozenset((token_hour, token_minute,

2173

token_second)))

2174

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

2175

datetime.timedelta(days=1),

2176

frozenset((token_time, token_end)))

2177

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

2178

datetime.timedelta(weeks=4),

2179

frozenset((token_day, token_end)))

2180

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

2181

datetime.timedelta(weeks=52),

2182

frozenset((token_month, token_end)))

2183

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

2184

datetime.timedelta(weeks=1),

2185

frozenset((token_end,)))

2186

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

2187

frozenset((token_year, token_month,

2188

token_day, token_time,

2189

token_week))),

2190

# Define starting values

2191

value = datetime.timedelta() # Value so far

2192

found_token = None

2193

followers = frozenset(token_duration,) # Following valid tokens

2194

s = duration # String left to parse

2195

# Loop until end token is found

2196

while found_token is not token_end:

2197

# Search for any currently valid tokens

2198

for token in followers:

2199

match = token.regexp.match(s)

2200

if match is not None:

2201

# Token found

2202

if token.value is not None:

2203

# Value found, parse digits

2204

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

2205

# Add to value so far

2206

value += factor * token.value

2207

# Strip token from string

2208

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

2209

# Go to found token

2210

found_token = token

2211

# Set valid next tokens

2212

followers = found_token.followers

2213

break

2214

else:

2215

# No currently valid tokens were found

2216

raise ValueError("Invalid RFC 3339 duration")

2217

# End token found

2218

return value

2219

2220

2221

2065

def string_to_delta(interval):

2222

2066

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

2223

2067

2234

2078

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

2235

2079

datetime.timedelta(0, 330)

2236

2080

"""

2237

2238

try:

2239

return rfc3339_duration_to_delta(interval)

2240

except ValueError:

2241

pass

2242

2243

2081

timevalue = datetime.timedelta(0)

2244

2082

for s in interval.split():

2245

2083

try:

2308

2146

help="Run self-test")

2309

2147

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

2310

2148

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

2311

" to terminal", default=None)

2149

" to terminal")

2312

2150

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

2313

2151

help="Debug level for stdout output")

2314

2152

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

2321

2159

" files")

2322

2160

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

2323

2161

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

2324

" system bus interface", default=None)

2162

" system bus interface")

2325

2163

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

2326

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

2327

default=None)

2164

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

2328

2165

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

2329

2166

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

2330

" state", default=None)

2331

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

2332

help="Specify a file descriptor to a network"

2333

" socket to use instead of creating one")

2167

" state")

2334

2168

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

2335

2169

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

2336

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

2337

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

2338

2170

2339

2171

options = parser.parse_args()

2340

2172

2349

2181

"port": "",

2350

2182

"debug": "False",

2351

2183

"priority":

2352

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

2184

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

2353

2185

"servicename": "Mandos",

2354

2186

"use_dbus": "True",

2355

2187

"use_ipv6": "True",

2356

2188

"debuglevel": "",

2357

2189

"restore": "True",

2358

"socket": "",

2359

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

2360

"foreground": "False",

2190

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

2361

2191

}

2362

2192

2363

2193

# Parse config file for server-global settings

2368

2198

# Convert the SafeConfigParser object to a dict

2369

2199

server_settings = server_config.defaults()

2370

2200

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

2371

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

2201

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

2372

2202

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

2373

2203

option)

2374

2204

if server_settings["port"]:

2375

2205

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

2376

2206

"port")

2377

if server_settings["socket"]:

2378

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

2379

"socket")

2380

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

2381

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

2382

# happen with a supplied network socket.

2383

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

2384

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

2385

["socket"])

2386

2207

del server_config

2387

2208

2388

2209

# Override the settings from the config file with command line

2390

2211

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

2391

2212

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

2392

2213

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

2393

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

2214

"statedir"):

2394

2215

value = getattr(options, option)

2395

2216

if value is not None:

2396

2217

server_settings[option] = value

2399

2220

for option in server_settings.keys():

2400

2221

if type(server_settings[option]) is str:

2401

2222

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

2402

# Force all boolean options to be boolean

2403

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

2404

"foreground"):

2405

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

2406

# Debug implies foreground

2407

if server_settings["debug"]:

2408

server_settings["foreground"] = True

2409

2223

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

2410

2224

2411

2225

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

2417

2231

use_ipv6 = server_settings["use_ipv6"]

2418

2232

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

2419

2233

stored_state_file)

2420

foreground = server_settings["foreground"]

2421

2234

2422

2235

if debug:

2423

2236

initlogger(debug, logging.DEBUG)

2452

2265

use_ipv6=use_ipv6,

2453

2266

gnutls_priority=

2454

2267

server_settings["priority"],

2455

use_dbus=use_dbus,

2456

socketfd=(server_settings["socket"]

2457

or None))

2458

if not foreground:

2459

pidfilename = "/run/mandos.pid"

2460

pidfile = None

2268

use_dbus=use_dbus)

2269

if not debug:

2270

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

2461

2271

try:

2462

2272

pidfile = open(pidfilename, "w")

2463

2273

except IOError as e:

2502

2312

os.close(null)

2503

2313

2504

2314

# Need to fork before connecting to D-Bus

2505

if not foreground:

2315

if not debug:

2506

2316

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

2507

2317

daemon()

2508

2318

2509

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

2510

# need to inform gobject that threads will be used.

2511

2319

gobject.threads_init()

2512

2320

2513

2321

global main_loop

2548

2356

old_client_settings = {}

2549

2357

clients_data = {}

2550

2358

2551

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

2552

global wnull

2553

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

2554

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

2555

# mode

2556

if debug or not foreground:

2557

wnull.close()

2558

2559

2359

# Get client data and settings from last running state.

2560

2360

if server_settings["restore"]:

2561

2361

try:

2577

2377

2578

2378

with PGPEngine() as pgp:

2579

2379

for client_name, client in clients_data.iteritems():

2580

# Skip removed clients

2581

if client_name not in client_settings:

2582

continue

2583

2584

2380

# Decide which value to use after restoring saved state.

2585

2381

# We have three different values: Old config file,

2586

2382

# new config file, and saved state.

2648

2444

# Create all client objects

2649

2445

for client_name, client in clients_data.iteritems():

2650

2446

tcp_server.clients[client_name] = client_class(

2651

name = client_name, settings = client,

2652

server_settings = server_settings)

2447

name = client_name, settings = client)

2653

2448

2654

2449

if not tcp_server.clients:

2655

2450

logger.warning("No clients defined")

2656

2451

2657

if not foreground:

2658

if pidfile is not None:

2659

try:

2660

with pidfile:

2661

pid = os.getpid()

2662

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

2663

except IOError:

2664

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

2665

pidfilename, pid)

2666

del pidfile

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

2667

2464

del pidfilename

2668

2465

2669

2466

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

2738

2535

service.cleanup()

2739

2536

2740

2537

multiprocessing.active_children()

2741

wnull.close()

2742

2538

if not (tcp_server.clients or client_settings):

2743

2539

return

2744

2540

2756

2552

# A list of attributes that can not be pickled

2757

2553

# + secret.

2758

2554

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

2759

"checker", "server_settings"))

2555

"checker"))

2760

2556

for name, typ in (inspect.getmembers

2761

2557

(dbus.service.Object)):

2762

2558

exclude.add(name)