/mandos/release : revision 317

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

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

91

version = "1.6.5"

92

stored_state_file = "clients.pickle"

93

94

logger = logging.getLogger()

95

syslogger = (logging.handlers.SysLogHandler

96

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

97

address = str("/dev/log")))

95

syslogger = None

98

96

99

97

try:

100

98

if_nametoindex = (ctypes.cdll.LoadLibrary

116

114

def initlogger(debug, level=logging.WARNING):

117

115

"""init logger and add loglevel"""

118

116

117

global syslogger

118

syslogger = (logging.handlers.SysLogHandler

119

(facility =

120

logging.handlers.SysLogHandler.LOG_DAEMON,

121

address = str("/dev/log")))

119

122

syslogger.setFormatter(logging.Formatter

120

123

('Mandos [%(process)d]: %(levelname)s:'

121

124

' %(message)s'))

139

142

class PGPEngine(object):

140

143

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

141

144

def __init__(self):

142

self.gnupg = GnuPGInterface.GnuPG()

143

145

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

146

self.gnupgargs = ['--batch',

147

'--home', self.tempdir,

148

'--force-mdc',

149

'--quiet',

150

'--no-use-agent']

150

151

152

def __enter__(self):

152

153

return self

174

175

def password_encode(self, password):

175

176

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

176

177

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

177

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

178

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

179

if len(encoded) > 2048:

180

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

181

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

182

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

183

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

184

return encoded

178

185

179

186

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

187

passphrase = self.password_encode(password)

188

with tempfile.NamedTemporaryFile(dir=self.tempdir

189

) as passfile:

190

passfile.write(passphrase)

191

passfile.flush()

192

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

193

'--passphrase-file',

194

passfile.name]

195

+ self.gnupgargs,

196

stdin = subprocess.PIPE,

197

stdout = subprocess.PIPE,

198

stderr = subprocess.PIPE)

199

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

200

if proc.returncode != 0:

201

raise PGPError(err)

194

202

return ciphertext

195

203

196

204

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

205

passphrase = self.password_encode(password)

206

with tempfile.NamedTemporaryFile(dir = self.tempdir

207

) as passfile:

208

passfile.write(passphrase)

209

passfile.flush()

210

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

211

'--passphrase-file',

212

passfile.name]

213

+ self.gnupgargs,

214

stdin = subprocess.PIPE,

215

stdout = subprocess.PIPE,

216

stderr = subprocess.PIPE)

217

decrypted_plaintext, err = proc.communicate(input

218

= data)

219

if proc.returncode != 0:

220

raise PGPError(err)

211

221

return decrypted_plaintext

212

222

213

223

233

243

Used to optionally bind to the specified interface.

234

244

name: string; Example: 'Mandos'

235

245

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

236

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

246

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

237

247

port: integer; what port to announce

238

248

TXT: list of strings; TXT record for the service

239

249

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

439

449

runtime_expansions: Allowed attributes for runtime expansion.

440

450

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

441

451

disabled, or None

452

server_settings: The server_settings dict from main()

442

453

"""

443

454

444

455

runtime_expansions = ("approval_delay", "approval_duration",

446

457

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

447

458

"last_approval_request", "last_checked_ok",

448

459

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

449

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

450

"extended_timeout": "15m",

451

"interval": "2m",

460

client_defaults = { "timeout": "PT5M",

461

"extended_timeout": "PT15M",

462

"interval": "PT2M",

452

463

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

453

464

"host": "",

454

"approval_delay": "0s",

455

"approval_duration": "1s",

465

"approval_delay": "PT0S",

466

"approval_duration": "PT1S",

456

467

"approved_by_default": "True",

457

468

"enabled": "True",

458

469

}

519

530

520

531

return settings

521

532

522

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

533

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

523

534

self.name = name

535

if server_settings is None:

536

server_settings = {}

537

self.server_settings = server_settings

524

538

# adding all client settings

525

539

for setting, value in settings.iteritems():

526

540

setattr(self, setting, value)

679

693

# If a checker exists, make sure it is not a zombie

680

694

try:

681

695

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

682

except (AttributeError, OSError) as error:

683

if (isinstance(error, OSError)

684

and error.errno != errno.ECHILD):

685

raise error

696

except AttributeError:

697

pass

698

except OSError as error:

699

if error.errno != errno.ECHILD:

700

raise

686

701

else:

687

702

if pid:

688

703

logger.warning("Checker was a zombie")

710

725

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

711

726

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

712

727

# always replaced by /dev/null.)

728

# The exception is when not debugging but nevertheless

729

# running in the foreground; use the previously

730

# created wnull.

731

popen_args = {}

732

if (not self.server_settings["debug"]

733

and self.server_settings["foreground"]):

734

popen_args.update({"stdout": wnull,

735

"stderr": wnull })

713

736

self.checker = subprocess.Popen(command,

714

737

close_fds=True,

715

shell=True, cwd="/")

738

shell=True, cwd="/",

739

**popen_args)

716

740

except OSError as error:

717

741

logger.error("Failed to start subprocess",

718

742

exc_info=error)

743

return True

719

744

self.checker_callback_tag = (gobject.child_watch_add

720

745

(self.checker.pid,

721

746

self.checker_callback,

722

747

data=command))

723

748

# The checker may have completed before the gobject

724

749

# watch was added. Check for this.

725

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

750

try:

751

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

752

except OSError as error:

753

if error.errno == errno.ECHILD:

754

# This should never happen

755

logger.error("Child process vanished",

756

exc_info=error)

757

return True

758

raise

726

759

if pid:

727

760

gobject.source_remove(self.checker_callback_tag)

728

761

self.checker_callback(pid, status, command)

904

937

# The byte_arrays option is not supported yet on

905

938

# signatures other than "ay".

906

939

if prop._dbus_signature != "ay":

907

raise ValueError

940

raise ValueError("Byte arrays not supported for non-"

941

"'ay' signature {0!r}"

942

.format(prop._dbus_signature))

908

943

value = dbus.ByteArray(b''.join(chr(byte)

909

944

for byte in value))

910

945

prop(value)

1068

1103

interface_names.add(alt_interface)

1069

1104

# Is this a D-Bus signal?

1070

1105

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

1071

# Extract the original non-method function by

1072

# black magic

1106

# Extract the original non-method undecorated

1107

# function by black magic

1073

1108

nonmethod_func = (dict(

1074

1109

zip(attribute.func_code.co_freevars,

1075

1110

attribute.__closure__))["func"]

1318

1353

*args, **kwargs)

1319

1354

1320

1355

def start_checker(self, *args, **kwargs):

1321

old_checker = self.checker

1322

if self.checker is not None:

1323

old_checker_pid = self.checker.pid

1324

else:

1325

old_checker_pid = None

1356

old_checker_pid = getattr(self.checker, "pid", None)

1326

1357

r = Client.start_checker(self, *args, **kwargs)

1327

1358

# Only if new checker process was started

1328

1359

if (self.checker is not None

1673

1704

logger.debug("Protocol version: %r", line)

1674

1705

try:

1675

1706

if int(line.strip().split()[0]) > 1:

1676

raise RuntimeError

1707

raise RuntimeError(line)

1677

1708

except (ValueError, IndexError, RuntimeError) as error:

1678

1709

logger.error("Unknown protocol version: %s", error)

1679

1710

return

1886

1917

1887

1918

def add_pipe(self, parent_pipe, proc):

1888

1919

"""Dummy function; override as necessary"""

1889

raise NotImplementedError

1920

raise NotImplementedError()

1890

1921

1891

1922

1892

1923

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1968

1999

if self.address_family == socket.AF_INET6:

1969

2000

any_address = "::" # in6addr_any

1970

2001

else:

1971

any_address = socket.INADDR_ANY

2002

any_address = "0.0.0.0" # INADDR_ANY

1972

2003

self.server_address = (any_address,

1973

2004

self.server_address[1])

1974

2005

elif not self.server_address[1]:

2090

2121

return True

2091

2122

2092

2123

2124

def rfc3339_duration_to_delta(duration):

2125

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

2126

2127

>>> rfc3339_duration_to_delta("P7D")

2128

datetime.timedelta(7)

2129

>>> rfc3339_duration_to_delta("PT60S")

2130

datetime.timedelta(0, 60)

2131

>>> rfc3339_duration_to_delta("PT60M")

2132

datetime.timedelta(0, 3600)

2133

>>> rfc3339_duration_to_delta("PT24H")

2134

datetime.timedelta(1)

2135

>>> rfc3339_duration_to_delta("P1W")

2136

datetime.timedelta(7)

2137

>>> rfc3339_duration_to_delta("PT5M30S")

2138

datetime.timedelta(0, 330)

2139

>>> rfc3339_duration_to_delta("P1DT3M20S")

2140

datetime.timedelta(1, 200)

2141

"""

2142

2143

# Parsing an RFC 3339 duration with regular expressions is not

2144

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

2145

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

2146

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

2147

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

2148

# avoid excessive use of external libraries.

2149

2150

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

2151

Token = collections.namedtuple("Token",

2152

("regexp", # To match token; if

2153

# "value" is not None,

2154

# must have a "group"

2155

# containing digits

2156

"value", # datetime.timedelta or

2157

# None

2158

"followers")) # Tokens valid after

2159

# this token

2160

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

2161

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

2162

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

2163

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

2164

datetime.timedelta(seconds=1),

2165

frozenset((token_end,)))

2166

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

2167

datetime.timedelta(minutes=1),

2168

frozenset((token_second, token_end)))

2169

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

2170

datetime.timedelta(hours=1),

2171

frozenset((token_minute, token_end)))

2172

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

2173

None,

2174

frozenset((token_hour, token_minute,

2175

token_second)))

2176

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

2177

datetime.timedelta(days=1),

2178

frozenset((token_time, token_end)))

2179

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

2180

datetime.timedelta(weeks=4),

2181

frozenset((token_day, token_end)))

2182

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

2183

datetime.timedelta(weeks=52),

2184

frozenset((token_month, token_end)))

2185

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

2186

datetime.timedelta(weeks=1),

2187

frozenset((token_end,)))

2188

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

2189

frozenset((token_year, token_month,

2190

token_day, token_time,

2191

token_week))),

2192

# Define starting values

2193

value = datetime.timedelta() # Value so far

2194

found_token = None

2195

followers = frozenset(token_duration,) # Following valid tokens

2196

s = duration # String left to parse

2197

# Loop until end token is found

2198

while found_token is not token_end:

2199

# Search for any currently valid tokens

2200

for token in followers:

2201

match = token.regexp.match(s)

2202

if match is not None:

2203

# Token found

2204

if token.value is not None:

2205

# Value found, parse digits

2206

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

2207

# Add to value so far

2208

value += factor * token.value

2209

# Strip token from string

2210

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

2211

# Go to found token

2212

found_token = token

2213

# Set valid next tokens

2214

followers = found_token.followers

2215

break

2216

else:

2217

# No currently valid tokens were found

2218

raise ValueError("Invalid RFC 3339 duration")

2219

# End token found

2220

return value

2221

2222

2093

2223

def string_to_delta(interval):

2094

2224

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

2095

2225

2106

2236

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

2107

2237

datetime.timedelta(0, 330)

2108

2238

"""

2239

2240

try:

2241

return rfc3339_duration_to_delta(interval)

2242

except ValueError:

2243

pass

2244

2109

2245

timevalue = datetime.timedelta(0)

2110

2246

for s in interval.split():

2111

2247

try:

2124

2260

else:

2125

2261

raise ValueError("Unknown suffix {0!r}"

2126

2262

.format(suffix))

2127

except (ValueError, IndexError) as e:

2263

except IndexError as e:

2128

2264

raise ValueError(*(e.args))

2129

2265

timevalue += delta

2130

2266

return timevalue

2174

2310

help="Run self-test")

2175

2311

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

2176

2312

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

2177

" to terminal")

2313

" to terminal", default=None)

2178

2314

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

2179

2315

help="Debug level for stdout output")

2180

2316

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

2187

2323

" files")

2188

2324

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

2189

2325

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

2190

" system bus interface")

2326

" system bus interface", default=None)

2191

2327

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

2192

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

2328

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

2329

default=None)

2193

2330

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

2194

2331

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

2195

" state")

2332

" state", default=None)

2196

2333

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

2197

2334

help="Specify a file descriptor to a network"

2198

2335

" socket to use instead of creating one")

2199

2336

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

2200

2337

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

2201

2338

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

2202

help="Run in foreground")

2339

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

2340

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

2341

dest="zeroconf", help="Do not use Zeroconf",

2342

default=None)

2203

2343

2204

2344

options = parser.parse_args()

2205

2345

2206

2346

if options.check:

2207

2347

import doctest

2208

doctest.testmod()

2209

sys.exit()

2348

fail_count, test_count = doctest.testmod()

2349

sys.exit(os.EX_OK if fail_count == 0 else 1)

2210

2350

2211

2351

# Default values for config file for server-global settings

2212

2352

server_defaults = { "interface": "",

2214

2354

"port": "",

2215

2355

"debug": "False",

2216

2356

"priority":

2217

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

2357

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

2218

2358

"servicename": "Mandos",

2219

2359

"use_dbus": "True",

2220

2360

"use_ipv6": "True",

2223

2363

"socket": "",

2224

2364

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

2225

2365

"foreground": "False",

2366

"zeroconf": "True",

2226

2367

}

2227

2368

2228

2369

# Parse config file for server-global settings

2255

2396

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

2256

2397

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

2257

2398

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

2258

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

2399

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

2259

2400

value = getattr(options, option)

2260

2401

if value is not None:

2261

2402

server_settings[option] = value

2264

2405

for option in server_settings.keys():

2265

2406

if type(server_settings[option]) is str:

2266

2407

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

2408

# Force all boolean options to be boolean

2409

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

2410

"foreground", "zeroconf"):

2411

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

2267

2412

# Debug implies foreground

2268

2413

if server_settings["debug"]:

2269

2414

server_settings["foreground"] = True

2271

2416

2272

2417

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

2273

2418

2419

if (not server_settings["zeroconf"] and

2420

not (server_settings["port"]

2421

or server_settings["socket"] != "")):

2422

parser.error("Needs port or socket to work without"

2423

" Zeroconf")

2424

2274

2425

# For convenience

2275

2426

debug = server_settings["debug"]

2276

2427

debuglevel = server_settings["debuglevel"]

2279

2430

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

2280

2431

stored_state_file)

2281

2432

foreground = server_settings["foreground"]

2433

zeroconf = server_settings["zeroconf"]

2282

2434

2283

2435

if debug:

2284

2436

initlogger(debug, logging.DEBUG)

2305

2457

global mandos_dbus_service

2306

2458

mandos_dbus_service = None

2307

2459

2460

socketfd = None

2461

if server_settings["socket"] != "":

2462

socketfd = server_settings["socket"]

2308

2463

tcp_server = MandosServer((server_settings["address"],

2309

2464

server_settings["port"]),

2310

2465

ClientHandler,

2314

2469

gnutls_priority=

2315

2470

server_settings["priority"],

2316

2471

use_dbus=use_dbus,

2317

socketfd=(server_settings["socket"]

2318

or None))

2472

socketfd=socketfd)

2319

2473

if not foreground:

2320

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

2474

pidfilename = "/run/mandos.pid"

2475

if not os.path.isdir("/run/."):

2476

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

2321

2477

pidfile = None

2322

2478

try:

2323

2479

pidfile = open(pidfilename, "w")

2340

2496

os.setuid(uid)

2341

2497

except OSError as error:

2342

2498

if error.errno != errno.EPERM:

2343

raise error

2499

raise

2344

2500

2345

2501

if debug:

2346

2502

# Enable all possible GnuTLS debugging

2389

2545

use_dbus = False

2390

2546

server_settings["use_dbus"] = False

2391

2547

tcp_server.use_dbus = False

2392

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2393

service = AvahiServiceToSyslog(name =

2394

server_settings["servicename"],

2395

servicetype = "_mandos._tcp",

2396

protocol = protocol, bus = bus)

2397

if server_settings["interface"]:

2398

service.interface = (if_nametoindex

2399

(str(server_settings["interface"])))

2548

if zeroconf:

2549

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2550

service = AvahiServiceToSyslog(name =

2551

server_settings["servicename"],

2552

servicetype = "_mandos._tcp",

2553

protocol = protocol, bus = bus)

2554

if server_settings["interface"]:

2555

service.interface = (if_nametoindex

2556

(str(server_settings["interface"])))

2400

2557

2401

2558

global multiprocessing_manager

2402

2559

multiprocessing_manager = multiprocessing.Manager()

2409

2566

old_client_settings = {}

2410

2567

clients_data = {}

2411

2568

2569

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

2570

global wnull

2571

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

2572

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

2573

# mode

2574

if debug or not foreground:

2575

wnull.close()

2576

2412

2577

# Get client data and settings from last running state.

2413

2578

if server_settings["restore"]:

2414

2579

try:

2430

2595

2431

2596

with PGPEngine() as pgp:

2432

2597

for client_name, client in clients_data.iteritems():

2598

# Skip removed clients

2599

if client_name not in client_settings:

2600

continue

2601

2433

2602

# Decide which value to use after restoring saved state.

2434

2603

# We have three different values: Old config file,

2435

2604

# new config file, and saved state.

2497

2666

# Create all client objects

2498

2667

for client_name, client in clients_data.iteritems():

2499

2668

tcp_server.clients[client_name] = client_class(

2500

name = client_name, settings = client)

2669

name = client_name, settings = client,

2670

server_settings = server_settings)

2501

2671

2502

2672

if not tcp_server.clients:

2503

2673

logger.warning("No clients defined")

2583

2753

2584

2754

def cleanup():

2585

2755

"Cleanup function; run on exit"

2586

service.cleanup()

2756

if zeroconf:

2757

service.cleanup()

2587

2758

2588

2759

multiprocessing.active_children()

2760

wnull.close()

2589

2761

if not (tcp_server.clients or client_settings):

2590

2762

return

2591

2763

2603

2775

# A list of attributes that can not be pickled

2604

2776

# + secret.

2605

2777

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

2606

"checker"))

2778

"checker", "server_settings"))

2607

2779

for name, typ in (inspect.getmembers

2608

2780

(dbus.service.Object)):

2609

2781

exclude.add(name)

2637

2809

else:

2638

2810

logger.warning("Could not save persistent state:",

2639

2811

exc_info=e)

2640

raise e

2812

raise

2641

2813

2642

2814

# Delete all clients, and settings from config

2643

2815

while tcp_server.clients:

2667

2839

tcp_server.server_activate()

2668

2840

2669

2841

# Find out what port we got

2670

service.port = tcp_server.socket.getsockname()[1]

2842

if zeroconf:

2843

service.port = tcp_server.socket.getsockname()[1]

2671

2844

if use_ipv6:

2672

2845

logger.info("Now listening on address %r, port %d,"

2673

2846

" flowinfo %d, scope_id %d",

2679

2852

#service.interface = tcp_server.socket.getsockname()[3]

2680

2853

2681

2854

try:

2682

# From the Avahi example code

2683

try:

2684

service.activate()

2685

except dbus.exceptions.DBusException as error:

2686

logger.critical("D-Bus Exception", exc_info=error)

2687

cleanup()

2688

sys.exit(1)

2689

# End of Avahi example code

2855

if zeroconf:

2856

# From the Avahi example code

2857

try:

2858

service.activate()

2859

except dbus.exceptions.DBusException as error:

2860

logger.critical("D-Bus Exception", exc_info=error)

2861

cleanup()

2862

sys.exit(1)

2863

# End of Avahi example code

2690

2864

2691

2865

gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,

2692

2866

lambda *args, **kwargs: