/mandos/trunk : revision 608

1

#!/usr/bin/python2.7

1

#!/usr/bin/python

2

# -*- mode: python; coding: utf-8 -*-

3

#

4

# Mandos server - give out binary blobs to connecting clients.

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

if sys.version_info.major == 2:

92

str = unicode

93

94

version = "1.6.9"

91

version = "1.6.0"

95

92

stored_state_file = "clients.pickle"

96

93

97

94

logger = logging.getLogger()

98

syslogger = None

95

syslogger = (logging.handlers.SysLogHandler

96

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

97

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

99

98

100

99

try:

101

100

if_nametoindex = (ctypes.cdll.LoadLibrary

107

106

SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h

108

107

with contextlib.closing(socket.socket()) as s:

109

108

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

110

struct.pack(b"16s16x", interface))

111

interface_index = struct.unpack("I", ifreq[16:20])[0]

109

struct.pack(str("16s16x"),

110

interface))

111

interface_index = struct.unpack(str("I"),

112

ifreq[16:20])[0]

112

113

return interface_index

113

114

115

116

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

116

117

"""init logger and add loglevel"""

117

118

global syslogger

119

syslogger = (logging.handlers.SysLogHandler

120

(facility =

121

logging.handlers.SysLogHandler.LOG_DAEMON,

122

address = "/dev/log"))

123

119

syslogger.setFormatter(logging.Formatter

124

120

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

125

121

' %(message)s'))

143

139

class PGPEngine(object):

144

140

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

145

141

def __init__(self):

142

self.gnupg = GnuPGInterface.GnuPG()

146

143

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

147

self.gnupgargs = ['--batch',

148

'--home', self.tempdir,

149

'--force-mdc',

150

'--quiet',

151

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

152

150

153

151

def __enter__(self):

154

152

return self

176

174

def password_encode(self, password):

177

175

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

178

176

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

179

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

180

if len(encoded) > 2048:

181

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

182

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

183

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

184

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

185

return encoded

177

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

186

178

187

179

def encrypt(self, data, password):

188

passphrase = self.password_encode(password)

189

with tempfile.NamedTemporaryFile(dir=self.tempdir

190

) as passfile:

191

passfile.write(passphrase)

192

passfile.flush()

193

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

194

'--passphrase-file',

195

passfile.name]

196

+ self.gnupgargs,

197

stdin = subprocess.PIPE,

198

stdout = subprocess.PIPE,

199

stderr = subprocess.PIPE)

200

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

201

if proc.returncode != 0:

202

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

203

194

return ciphertext

204

195

205

196

def decrypt(self, data, password):

206

passphrase = self.password_encode(password)

207

with tempfile.NamedTemporaryFile(dir = self.tempdir

208

) as passfile:

209

passfile.write(passphrase)

210

passfile.flush()

211

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

212

'--passphrase-file',

213

passfile.name]

214

+ self.gnupgargs,

215

stdin = subprocess.PIPE,

216

stdout = subprocess.PIPE,

217

stderr = subprocess.PIPE)

218

decrypted_plaintext, err = proc.communicate(input

219

= data)

220

if proc.returncode != 0:

221

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

222

211

return decrypted_plaintext

223

212

224

213

225

214

class AvahiError(Exception):

226

215

def __init__(self, value, *args, **kwargs):

227

216

self.value = value

228

return super(AvahiError, self).__init__(value, *args,

229

**kwargs)

217

super(AvahiError, self).__init__(value, *args, **kwargs)

218

def __unicode__(self):

219

return unicode(repr(self.value))

230

220

231

221

class AvahiServiceError(AvahiError):

232

222

pass

243

233

Used to optionally bind to the specified interface.

244

234

name: string; Example: 'Mandos'

245

235

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

246

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

236

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

247

237

port: integer; what port to announce

248

238

TXT: list of strings; TXT record for the service

249

239

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

282

272

" after %i retries, exiting.",

283

273

self.rename_count)

284

274

raise AvahiServiceError("Too many renames")

285

self.name = str(self.server

286

.GetAlternativeServiceName(self.name))

275

self.name = unicode(self.server

276

.GetAlternativeServiceName(self.name))

287

277

logger.info("Changing Zeroconf service name to %r ...",

288

278

self.name)

289

279

self.remove()

337

327

self.rename()

338

328

elif state == avahi.ENTRY_GROUP_FAILURE:

339

329

logger.critical("Avahi: Error in group state changed %s",

340

str(error))

341

raise AvahiGroupError("State changed: {!s}"

330

unicode(error))

331

raise AvahiGroupError("State changed: {0!s}"

342

332

.format(error))

343

333

344

334

def cleanup(self):

395

385

"""Add the new name to the syslog messages"""

396

386

ret = AvahiService.rename(self)

397

387

syslogger.setFormatter(logging.Formatter

398

('Mandos ({}) [%(process)d]:'

388

('Mandos ({0}) [%(process)d]:'

399

389

' %(levelname)s: %(message)s'

400

390

.format(self.name)))

401

391

return ret

402

392

403

393

394

def timedelta_to_milliseconds(td):

395

"Convert a datetime.timedelta() to milliseconds"

396

return ((td.days * 24 * 60 * 60 * 1000)

397

+ (td.seconds * 1000)

398

+ (td.microseconds // 1000))

399

400

404

401

class Client(object):

405

402

"""A representation of a client host served by this server.

406

403

442

439

runtime_expansions: Allowed attributes for runtime expansion.

443

440

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

444

441

disabled, or None

445

server_settings: The server_settings dict from main()

446

442

"""

447

443

448

444

runtime_expansions = ("approval_delay", "approval_duration",

450

446

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

451

447

"last_approval_request", "last_checked_ok",

452

448

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

453

client_defaults = { "timeout": "PT5M",

454

"extended_timeout": "PT15M",

455

"interval": "PT2M",

449

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

450

"extended_timeout": "15m",

451

"interval": "2m",

456

452

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

457

453

"host": "",

458

"approval_delay": "PT0S",

459

"approval_duration": "PT1S",

454

"approval_delay": "0s",

455

"approval_duration": "1s",

460

456

"approved_by_default": "True",

461

457

"enabled": "True",

462

458

}

463

459

460

def timeout_milliseconds(self):

461

"Return the 'timeout' attribute in milliseconds"

462

return timedelta_to_milliseconds(self.timeout)

463

464

def extended_timeout_milliseconds(self):

465

"Return the 'extended_timeout' attribute in milliseconds"

466

return timedelta_to_milliseconds(self.extended_timeout)

467

468

def interval_milliseconds(self):

469

"Return the 'interval' attribute in milliseconds"

470

return timedelta_to_milliseconds(self.interval)

471

472

def approval_delay_milliseconds(self):

473

return timedelta_to_milliseconds(self.approval_delay)

474

464

475

@staticmethod

465

476

def config_parser(config):

466

477

"""Construct a new dict of client settings of this form:

491

502

"rb") as secfile:

492

503

client["secret"] = secfile.read()

493

504

else:

494

raise TypeError("No secret or secfile for section {}"

505

raise TypeError("No secret or secfile for section {0}"

495

506

.format(section))

496

507

client["timeout"] = string_to_delta(section["timeout"])

497

508

client["extended_timeout"] = string_to_delta(

508

519

509

520

return settings

510

521

511

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

522

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

512

523

self.name = name

513

if server_settings is None:

514

server_settings = {}

515

self.server_settings = server_settings

516

524

# adding all client settings

517

for setting, value in settings.items():

525

for setting, value in settings.iteritems():

518

526

setattr(self, setting, value)

519

527

520

528

if self.enabled:

603

611

if self.checker_initiator_tag is not None:

604

612

gobject.source_remove(self.checker_initiator_tag)

605

613

self.checker_initiator_tag = (gobject.timeout_add

606

(int(self.interval

607

.total_seconds() * 1000),

614

(self.interval_milliseconds(),

608

615

self.start_checker))

609

616

# Schedule a disable() when 'timeout' has passed

610

617

if self.disable_initiator_tag is not None:

611

618

gobject.source_remove(self.disable_initiator_tag)

612

619

self.disable_initiator_tag = (gobject.timeout_add

613

(int(self.timeout

614

.total_seconds() * 1000),

615

self.disable))

620

(self.timeout_milliseconds(),

621

self.disable))

616

622

# Also start a new checker *right now*.

617

623

self.start_checker()

618

624

649

655

self.disable_initiator_tag = None

650

656

if getattr(self, "enabled", False):

651

657

self.disable_initiator_tag = (gobject.timeout_add

652

(int(timeout.total_seconds()

653

* 1000), self.disable))

658

(timedelta_to_milliseconds

659

(timeout), self.disable))

654

660

self.expires = datetime.datetime.utcnow() + timeout

655

661

656

662

def need_approval(self):

673

679

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

674

680

try:

675

681

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

676

except AttributeError:

677

pass

678

except OSError as error:

679

if error.errno != errno.ECHILD:

680

raise

682

except (AttributeError, OSError) as error:

683

if (isinstance(error, OSError)

684

and error.errno != errno.ECHILD):

685

raise error

681

686

else:

682

687

if pid:

683

688

logger.warning("Checker was a zombie")

687

692

# Start a new checker if needed

688

693

if self.checker is None:

689

694

# Escape attributes for the shell

690

escaped_attrs = { attr:

691

re.escape(str(getattr(self, attr)))

692

for attr in self.runtime_expansions }

695

escaped_attrs = dict(

696

(attr, re.escape(unicode(getattr(self, attr))))

697

for attr in

698

self.runtime_expansions)

693

699

try:

694

700

command = self.checker_command % escaped_attrs

695

701

except TypeError as error:

704

710

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

705

711

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

706

712

# always replaced by /dev/null.)

707

# The exception is when not debugging but nevertheless

708

# running in the foreground; use the previously

709

# created wnull.

710

popen_args = {}

711

if (not self.server_settings["debug"]

712

and self.server_settings["foreground"]):

713

popen_args.update({"stdout": wnull,

714

"stderr": wnull })

715

713

self.checker = subprocess.Popen(command,

716

714

close_fds=True,

717

shell=True, cwd="/",

718

**popen_args)

715

shell=True, cwd="/")

719

716

except OSError as error:

720

717

logger.error("Failed to start subprocess",

721

718

exc_info=error)

722

return True

723

719

self.checker_callback_tag = (gobject.child_watch_add

724

720

(self.checker.pid,

725

721

self.checker_callback,

726

722

data=command))

727

723

# The checker may have completed before the gobject

728

724

# watch was added. Check for this.

729

try:

730

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

731

except OSError as error:

732

if error.errno == errno.ECHILD:

733

# This should never happen

734

logger.error("Child process vanished",

735

exc_info=error)

736

return True

737

raise

725

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

738

726

if pid:

739

727

gobject.source_remove(self.checker_callback_tag)

740

728

self.checker_callback(pid, status, command)

776

764

# "Set" method, so we fail early here:

777

765

if byte_arrays and signature != "ay":

778

766

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

779

" signature {!r}".format(signature))

767

" signature {0!r}".format(signature))

780

768

def decorator(func):

781

769

func._dbus_is_property = True

782

770

func._dbus_interface = dbus_interface

813

801

"""Decorator to annotate D-Bus methods, signals or properties

814

802

Usage:

815

803

816

@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",

817

"org.freedesktop.DBus.Property."

818

"EmitsChangedSignal": "false"})

819

804

@dbus_service_property("org.example.Interface", signature="b",

820

805

access="r")

806

@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",

807

"org.freedesktop.DBus.Property."

808

"EmitsChangedSignal": "false"})

821

809

def Property_dbus_property(self):

822

810

return dbus.Boolean(False)

823

811

"""

830

818

class DBusPropertyException(dbus.exceptions.DBusException):

831

819

"""A base class for D-Bus property-related exceptions

832

820

"""

833

pass

821

def __unicode__(self):

822

return unicode(str(self))

823

834

824

835

825

class DBusPropertyAccessException(DBusPropertyException):

836

826

"""A property's access permissions disallows an operation.

859

849

If called like _is_dbus_thing("method") it returns a function

860

850

suitable for use as predicate to inspect.getmembers().

861

851

"""

862

return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),

852

return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),

863

853

False)

864

854

865

855

def _get_all_dbus_things(self, thing):

914

904

# The byte_arrays option is not supported yet on

915

905

# signatures other than "ay".

916

906

if prop._dbus_signature != "ay":

917

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

918

"'ay' signature {!r}"

919

.format(prop._dbus_signature))

907

raise ValueError

920

908

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

921

909

for byte in value))

922

910

prop(value)

946

934

value.variant_level+1)

947

935

return dbus.Dictionary(properties, signature="sv")

948

936

949

@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")

950

def PropertiesChanged(self, interface_name, changed_properties,

951

invalidated_properties):

952

"""Standard D-Bus PropertiesChanged() signal, see D-Bus

953

standard.

954

"""

955

pass

956

957

937

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

958

938

out_signature="s",

959

939

path_keyword='object_path',

994

974

(prop,

995

975

"_dbus_annotations",

996

976

{}))

997

for name, value in annots.items():

977

for name, value in annots.iteritems():

998

978

ann_tag = document.createElement(

999

979

"annotation")

1000

980

ann_tag.setAttribute("name", name)

1003

983

# Add interface annotation tags

1004

984

for annotation, value in dict(

1005

985

itertools.chain.from_iterable(

1006

annotations().items()

986

annotations().iteritems()

1007

987

for name, annotations in

1008

988

self._get_all_dbus_things("interface")

1009

989

if name == if_tag.getAttribute("name")

1010

)).items():

990

)).iteritems():

1011

991

ann_tag = document.createElement("annotation")

1012

992

ann_tag.setAttribute("name", annotation)

1013

993

ann_tag.setAttribute("value", value)

1069

1049

"""

1070

1050

def wrapper(cls):

1071

1051

for orig_interface_name, alt_interface_name in (

1072

alt_interface_names.items()):

1052

alt_interface_names.iteritems()):

1073

1053

attr = {}

1074

1054

interface_names = set()

1075

1055

# Go though all attributes of the class

1088

1068

interface_names.add(alt_interface)

1089

1069

# Is this a D-Bus signal?

1090

1070

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

1091

# Extract the original non-method undecorated

1092

# function by black magic

1071

# Extract the original non-method function by

1072

# black magic

1093

1073

nonmethod_func = (dict(

1094

1074

zip(attribute.func_code.co_freevars,

1095

1075

attribute.__closure__))["func"]

1192

1172

attribute.func_closure)))

1193

1173

if deprecate:

1194

1174

# Deprecate all alternate interfaces

1195

iname="_AlternateDBusNames_interface_annotation{}"

1175

iname="_AlternateDBusNames_interface_annotation{0}"

1196

1176

for interface_name in interface_names:

1197

1177

@dbus_interface_annotations(interface_name)

1198

1178

def func(self):

1207

1187

if interface_names:

1208

1188

# Replace the class with a new subclass of it with

1209

1189

# methods, signals, etc. as created above.

1210

cls = type(b"{}Alternate".format(cls.__name__),

1190

cls = type(b"{0}Alternate".format(cls.__name__),

1211

1191

(cls,), attr)

1212

1192

return cls

1213

1193

return wrapper

1226

1206

runtime_expansions = (Client.runtime_expansions

1227

1207

+ ("dbus_object_path",))

1228

1208

1229

_interface = "se.recompile.Mandos.Client"

1230

1231

1209

# dbus.service.Object doesn't use super(), so we can't either.

1232

1210

1233

1211

def __init__(self, bus = None, *args, **kwargs):

1235

1213

Client.__init__(self, *args, **kwargs)

1236

1214

# Only now, when this client is initialized, can it show up on

1237

1215

# the D-Bus

1238

client_object_name = str(self.name).translate(

1216

client_object_name = unicode(self.name).translate(

1239

1217

{ord("."): ord("_"),

1240

1218

ord("-"): ord("_")})

1241

1219

self.dbus_object_path = (dbus.ObjectPath

1245

1223

1246

1224

def notifychangeproperty(transform_func,

1247

1225

dbus_name, type_func=lambda x: x,

1248

variant_level=1, invalidate_only=False,

1249

_interface=_interface):

1226

variant_level=1):

1250

1227

""" Modify a variable so that it's a property which announces

1251

1228

its changes to DBus.

1252

1229

1257

1234

to the D-Bus. Default: no transform

1258

1235

variant_level: D-Bus variant level. Default: 1

1259

1236

"""

1260

attrname = "_{}".format(dbus_name)

1237

attrname = "_{0}".format(dbus_name)

1261

1238

def setter(self, value):

1262

1239

if hasattr(self, "dbus_object_path"):

1263

1240

if (not hasattr(self, attrname) or

1264

1241

type_func(getattr(self, attrname, None))

1265

1242

!= type_func(value)):

1266

if invalidate_only:

1267

self.PropertiesChanged(_interface,

1268

dbus.Dictionary(),

1269

dbus.Array

1270

((dbus_name,)))

1271

else:

1272

dbus_value = transform_func(type_func(value),

1273

variant_level

1274

=variant_level)

1275

self.PropertyChanged(dbus.String(dbus_name),

1276

dbus_value)

1277

self.PropertiesChanged(_interface,

1278

dbus.Dictionary({

1279

dbus.String(dbus_name):

1280

dbus_value }), dbus.Array())

1243

dbus_value = transform_func(type_func(value),

1244

variant_level

1245

=variant_level)

1246

self.PropertyChanged(dbus.String(dbus_name),

1247

dbus_value)

1281

1248

setattr(self, attrname, value)

1282

1249

1283

1250

return property(lambda self: getattr(self, attrname), setter)

1303

1270

approval_delay = notifychangeproperty(dbus.UInt64,

1304

1271

"ApprovalDelay",

1305

1272

type_func =

1306

lambda td: td.total_seconds()

1307

* 1000)

1273

timedelta_to_milliseconds)

1308

1274

approval_duration = notifychangeproperty(

1309

1275

dbus.UInt64, "ApprovalDuration",

1310

type_func = lambda td: td.total_seconds() * 1000)

1276

type_func = timedelta_to_milliseconds)

1311

1277

host = notifychangeproperty(dbus.String, "Host")

1312

1278

timeout = notifychangeproperty(dbus.UInt64, "Timeout",

1313

type_func = lambda td:

1314

td.total_seconds() * 1000)

1279

type_func =

1280

timedelta_to_milliseconds)

1315

1281

extended_timeout = notifychangeproperty(

1316

1282

dbus.UInt64, "ExtendedTimeout",

1317

type_func = lambda td: td.total_seconds() * 1000)

1283

type_func = timedelta_to_milliseconds)

1318

1284

interval = notifychangeproperty(dbus.UInt64,

1319

1285

"Interval",

1320

1286

type_func =

1321

lambda td: td.total_seconds()

1322

* 1000)

1287

timedelta_to_milliseconds)

1323

1288

checker_command = notifychangeproperty(dbus.String, "Checker")

1324

secret = notifychangeproperty(dbus.ByteArray, "Secret",

1325

invalidate_only=True)

1326

1289

1327

1290

del notifychangeproperty

1328

1291

1355

1318

*args, **kwargs)

1356

1319

1357

1320

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

1358

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

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

1359

1326

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

1360

1327

# Only if new checker process was started

1361

1328

if (self.checker is not None

1370

1337

1371

1338

def approve(self, value=True):

1372

1339

self.approved = value

1373

gobject.timeout_add(int(self.approval_duration.total_seconds()

1374

* 1000), self._reset_approved)

1340

gobject.timeout_add(timedelta_to_milliseconds

1341

(self.approval_duration),

1342

self._reset_approved)

1375

1343

self.send_changedstate()

1376

1344

1377

1345

## D-Bus methods, signals & properties

1346

_interface = "se.recompile.Mandos.Client"

1378

1347

1379

1348

## Interfaces

1380

1349

1350

@dbus_interface_annotations(_interface)

1351

def _foo(self):

1352

return { "org.freedesktop.DBus.Property.EmitsChangedSignal":

1353

"false"}

1354

1381

1355

## Signals

1382

1356

1383

1357

# CheckerCompleted - signal

1393

1367

pass

1394

1368

1395

1369

# PropertyChanged - signal

1396

@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})

1397

1370

@dbus.service.signal(_interface, signature="sv")

1398

1371

def PropertyChanged(self, property, value):

1399

1372

"D-Bus signal"

1475

1448

access="readwrite")

1476

1449

def ApprovalDelay_dbus_property(self, value=None):

1477

1450

if value is None: # get

1478

return dbus.UInt64(self.approval_delay.total_seconds()

1479

* 1000)

1451

return dbus.UInt64(self.approval_delay_milliseconds())

1480

1452

self.approval_delay = datetime.timedelta(0, 0, 0, value)

1481

1453

1482

1454

# ApprovalDuration - property

1484

1456

access="readwrite")

1485

1457

def ApprovalDuration_dbus_property(self, value=None):

1486

1458

if value is None: # get

1487

return dbus.UInt64(self.approval_duration.total_seconds()

1488

* 1000)

1459

return dbus.UInt64(timedelta_to_milliseconds(

1460

self.approval_duration))

1489

1461

self.approval_duration = datetime.timedelta(0, 0, 0, value)

1490

1462

1491

1463

# Name - property

1504

1476

def Host_dbus_property(self, value=None):

1505

1477

if value is None: # get

1506

1478

return dbus.String(self.host)

1507

self.host = str(value)

1479

self.host = unicode(value)

1508

1480

1509

1481

# Created - property

1510

1482

@dbus_service_property(_interface, signature="s", access="read")

1557

1529

access="readwrite")

1558

1530

def Timeout_dbus_property(self, value=None):

1559

1531

if value is None: # get

1560

return dbus.UInt64(self.timeout.total_seconds() * 1000)

1532

return dbus.UInt64(self.timeout_milliseconds())

1561

1533

old_timeout = self.timeout

1562

1534

self.timeout = datetime.timedelta(0, 0, 0, value)

1563

1535

# Reschedule disabling

1574

1546

gobject.source_remove(self.disable_initiator_tag)

1575

1547

self.disable_initiator_tag = (

1576

1548

gobject.timeout_add(

1577

int((self.expires - now).total_seconds()

1578

* 1000), self.disable))

1549

timedelta_to_milliseconds(self.expires - now),

1550

self.disable))

1579

1551

1580

1552

# ExtendedTimeout - property

1581

1553

@dbus_service_property(_interface, signature="t",

1582

1554

access="readwrite")

1583

1555

def ExtendedTimeout_dbus_property(self, value=None):

1584

1556

if value is None: # get

1585

return dbus.UInt64(self.extended_timeout.total_seconds()

1586

* 1000)

1557

return dbus.UInt64(self.extended_timeout_milliseconds())

1587

1558

self.extended_timeout = datetime.timedelta(0, 0, 0, value)

1588

1559

1589

1560

# Interval - property

1591

1562

access="readwrite")

1592

1563

def Interval_dbus_property(self, value=None):

1593

1564

if value is None: # get

1594

return dbus.UInt64(self.interval.total_seconds() * 1000)

1565

return dbus.UInt64(self.interval_milliseconds())

1595

1566

self.interval = datetime.timedelta(0, 0, 0, value)

1596

1567

if getattr(self, "checker_initiator_tag", None) is None:

1597

1568

return

1608

1579

def Checker_dbus_property(self, value=None):

1609

1580

if value is None: # get

1610

1581

return dbus.String(self.checker_command)

1611

self.checker_command = str(value)

1582

self.checker_command = unicode(value)

1612

1583

1613

1584

# CheckerRunning - property

1614

1585

@dbus_service_property(_interface, signature="b",

1630

1601

@dbus_service_property(_interface, signature="ay",

1631

1602

access="write", byte_arrays=True)

1632

1603

def Secret_dbus_property(self, value):

1633

self.secret = bytes(value)

1604

self.secret = str(value)

1634

1605

1635

1606

del _interface

1636

1607

1670

1641

def handle(self):

1671

1642

with contextlib.closing(self.server.child_pipe) as child_pipe:

1672

1643

logger.info("TCP connection from: %s",

1673

str(self.client_address))

1644

unicode(self.client_address))

1674

1645

logger.debug("Pipe FD: %d",

1675

1646

self.server.child_pipe.fileno())

1676

1647

1702

1673

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

1703

1674

try:

1704

1675

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

1705

raise RuntimeError(line)

1676

raise RuntimeError

1706

1677

except (ValueError, IndexError, RuntimeError) as error:

1707

1678

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

1708

1679

return

1757

1728

if self.server.use_dbus:

1758

1729

# Emit D-Bus signal

1759

1730

client.NeedApproval(

1760

client.approval_delay.total_seconds()

1761

* 1000, client.approved_by_default)

1731

client.approval_delay_milliseconds(),

1732

client.approved_by_default)

1762

1733

else:

1763

1734

logger.warning("Client %s was not approved",

1764

1735

client.name)

1770

1741

#wait until timeout or approved

1771

1742

time = datetime.datetime.now()

1772

1743

client.changedstate.acquire()

1773

client.changedstate.wait(delay.total_seconds())

1744

client.changedstate.wait(

1745

float(timedelta_to_milliseconds(delay)

1746

/ 1000))

1774

1747

client.changedstate.release()

1775

1748

time2 = datetime.datetime.now()

1776

1749

if (time2 - time) >= delay:

1913

1886

1914

1887

def add_pipe(self, parent_pipe, proc):

1915

1888

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

1916

raise NotImplementedError()

1889

raise NotImplementedError

1917

1890

1918

1891

1919

1892

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1975

1948

try:

1976

1949

self.socket.setsockopt(socket.SOL_SOCKET,

1977

1950

SO_BINDTODEVICE,

1978

(self.interface + "\0")

1979

.encode("utf-8"))

1951

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

1980

1952

except socket.error as error:

1981

1953

if error.errno == errno.EPERM:

1982

1954

logger.error("No permission to bind to"

1996

1968

if self.address_family == socket.AF_INET6:

1997

1969

any_address = "::" # in6addr_any

1998

1970

else:

1999

any_address = "0.0.0.0" # INADDR_ANY

1971

any_address = socket.INADDR_ANY

2000

1972

self.server_address = (any_address,

2001

1973

self.server_address[1])

2002

1974

elif not self.server_address[1]:

2118

2090

return True

2119

2091

2120

2092

2121

def rfc3339_duration_to_delta(duration):

2122

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

2123

2124

>>> rfc3339_duration_to_delta("P7D")

2125

datetime.timedelta(7)

2126

>>> rfc3339_duration_to_delta("PT60S")

2127

datetime.timedelta(0, 60)

2128

>>> rfc3339_duration_to_delta("PT60M")

2129

datetime.timedelta(0, 3600)

2130

>>> rfc3339_duration_to_delta("PT24H")

2131

datetime.timedelta(1)

2132

>>> rfc3339_duration_to_delta("P1W")

2133

datetime.timedelta(7)

2134

>>> rfc3339_duration_to_delta("PT5M30S")

2135

datetime.timedelta(0, 330)

2136

>>> rfc3339_duration_to_delta("P1DT3M20S")

2137

datetime.timedelta(1, 200)

2138

"""

2139

2140

# Parsing an RFC 3339 duration with regular expressions is not

2141

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

2142

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

2143

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

2144

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

2145

# avoid excessive use of external libraries.

2146

2147

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

2148

Token = collections.namedtuple("Token",

2149

("regexp", # To match token; if

2150

# "value" is not None,

2151

# must have a "group"

2152

# containing digits

2153

"value", # datetime.timedelta or

2154

# None

2155

"followers")) # Tokens valid after

2156

# this token

2157

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

2158

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

2159

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

2160

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

2161

datetime.timedelta(seconds=1),

2162

frozenset((token_end,)))

2163

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

2164

datetime.timedelta(minutes=1),

2165

frozenset((token_second, token_end)))

2166

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

2167

datetime.timedelta(hours=1),

2168

frozenset((token_minute, token_end)))

2169

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

2170

None,

2171

frozenset((token_hour, token_minute,

2172

token_second)))

2173

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

2174

datetime.timedelta(days=1),

2175

frozenset((token_time, token_end)))

2176

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

2177

datetime.timedelta(weeks=4),

2178

frozenset((token_day, token_end)))

2179

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

2180

datetime.timedelta(weeks=52),

2181

frozenset((token_month, token_end)))

2182

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

2183

datetime.timedelta(weeks=1),

2184

frozenset((token_end,)))

2185

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

2186

frozenset((token_year, token_month,

2187

token_day, token_time,

2188

token_week)))

2189

# Define starting values

2190

value = datetime.timedelta() # Value so far

2191

found_token = None

2192

followers = frozenset((token_duration,)) # Following valid tokens

2193

s = duration # String left to parse

2194

# Loop until end token is found

2195

while found_token is not token_end:

2196

# Search for any currently valid tokens

2197

for token in followers:

2198

match = token.regexp.match(s)

2199

if match is not None:

2200

# Token found

2201

if token.value is not None:

2202

# Value found, parse digits

2203

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

2204

# Add to value so far

2205

value += factor * token.value

2206

# Strip token from string

2207

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

2208

# Go to found token

2209

found_token = token

2210

# Set valid next tokens

2211

followers = found_token.followers

2212

break

2213

else:

2214

# No currently valid tokens were found

2215

raise ValueError("Invalid RFC 3339 duration")

2216

# End token found

2217

return value

2218

2219

2220

2093

def string_to_delta(interval):

2221

2094

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

2222

2095

2233

2106

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

2234

2107

datetime.timedelta(0, 330)

2235

2108

"""

2236

2237

try:

2238

return rfc3339_duration_to_delta(interval)

2239

except ValueError:

2240

pass

2241

2242

2109

timevalue = datetime.timedelta(0)

2243

2110

for s in interval.split():

2244

2111

try:

2245

suffix = s[-1]

2112

suffix = unicode(s[-1])

2246

2113

value = int(s[:-1])

2247

2114

if suffix == "d":

2248

2115

delta = datetime.timedelta(value)

2255

2122

elif suffix == "w":

2256

2123

delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)

2257

2124

else:

2258

raise ValueError("Unknown suffix {!r}"

2125

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

2259

2126

.format(suffix))

2260

except IndexError as e:

2127

except (ValueError, IndexError) as e:

2261

2128

raise ValueError(*(e.args))

2262

2129

timevalue += delta

2263

2130

return timevalue

2278

2145

# Close all standard open file descriptors

2279

2146

null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)

2280

2147

if not stat.S_ISCHR(os.fstat(null).st_mode):

2281

raise OSError(errno.ENODEV, "{} not a character device"

2148

raise OSError(errno.ENODEV,

2149

"{0} not a character device"

2282

2150

.format(os.devnull))

2283

2151

os.dup2(null, sys.stdin.fileno())

2284

2152

os.dup2(null, sys.stdout.fileno())

2294

2162

2295

2163

parser = argparse.ArgumentParser()

2296

2164

parser.add_argument("-v", "--version", action="version",

2297

version = "%(prog)s {}".format(version),

2165

version = "%(prog)s {0}".format(version),

2298

2166

help="show version number and exit")

2299

2167

parser.add_argument("-i", "--interface", metavar="IF",

2300

2168

help="Bind to interface IF")

2306

2174

help="Run self-test")

2307

2175

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

2308

2176

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

2309

" to terminal", default=None)

2177

" to terminal")

2310

2178

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

2311

2179

help="Debug level for stdout output")

2312

2180

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

2319

2187

" files")

2320

2188

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

2321

2189

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

2322

" system bus interface", default=None)

2190

" system bus interface")

2323

2191

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

2324

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

2325

default=None)

2192

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

2326

2193

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

2327

2194

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

2328

" state", default=None)

2195

" state")

2329

2196

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

2330

2197

help="Specify a file descriptor to a network"

2331

2198

" socket to use instead of creating one")

2332

2199

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

2333

2200

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

2334

2201

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

2335

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

2336

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

2337

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

2338

default=None)

2202

help="Run in foreground")

2339

2203

2340

2204

options = parser.parse_args()

2341

2205

2342

2206

if options.check:

2343

2207

import doctest

2344

fail_count, test_count = doctest.testmod()

2345

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

2208

doctest.testmod()

2209

sys.exit()

2346

2210

2347

2211

# Default values for config file for server-global settings

2348

2212

server_defaults = { "interface": "",

2350

2214

"port": "",

2351

2215

"debug": "False",

2352

2216

"priority":

2353

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

2217

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

2354

2218

"servicename": "Mandos",

2355

2219

"use_dbus": "True",

2356

2220

"use_ipv6": "True",

2359

2223

"socket": "",

2360

2224

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

2361

2225

"foreground": "False",

2362

"zeroconf": "True",

2363

2226

}

2364

2227

2365

2228

# Parse config file for server-global settings

2392

2255

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

2393

2256

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

2394

2257

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

2395

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

2258

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

2396

2259

value = getattr(options, option)

2397

2260

if value is not None:

2398

2261

server_settings[option] = value

2399

2262

del options

2400

2263

# Force all strings to be unicode

2401

2264

for option in server_settings.keys():

2402

if isinstance(server_settings[option], bytes):

2403

server_settings[option] = (server_settings[option]

2404

.decode("utf-8"))

2405

# Force all boolean options to be boolean

2406

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

2407

"foreground", "zeroconf"):

2408

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

2265

if type(server_settings[option]) is str:

2266

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

2409

2267

# Debug implies foreground

2410

2268

if server_settings["debug"]:

2411

2269

server_settings["foreground"] = True

2413

2271

2414

2272

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

2415

2273

2416

if (not server_settings["zeroconf"] and

2417

not (server_settings["port"]

2418

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

2419

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

2420

" Zeroconf")

2421

2422

2274

# For convenience

2423

2275

debug = server_settings["debug"]

2424

2276

debuglevel = server_settings["debuglevel"]

2427

2279

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

2428

2280

stored_state_file)

2429

2281

foreground = server_settings["foreground"]

2430

zeroconf = server_settings["zeroconf"]

2431

2282

2432

2283

if debug:

2433

2284

initlogger(debug, logging.DEBUG)

2440

2291

2441

2292

if server_settings["servicename"] != "Mandos":

2442

2293

syslogger.setFormatter(logging.Formatter

2443

('Mandos ({}) [%(process)d]:'

2294

('Mandos ({0}) [%(process)d]:'

2444

2295

' %(levelname)s: %(message)s'

2445

2296

.format(server_settings

2446

2297

["servicename"])))

2454

2305

global mandos_dbus_service

2455

2306

mandos_dbus_service = None

2456

2307

2457

socketfd = None

2458

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

2459

socketfd = server_settings["socket"]

2460

2308

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

2461

2309

server_settings["port"]),

2462

2310

ClientHandler,

2466

2314

gnutls_priority=

2467

2315

server_settings["priority"],

2468

2316

use_dbus=use_dbus,

2469

socketfd=socketfd)

2317

socketfd=(server_settings["socket"]

2318

or None))

2470

2319

if not foreground:

2471

pidfilename = "/run/mandos.pid"

2472

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

2473

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

2320

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

2474

2321

pidfile = None

2475

2322

try:

2476

2323

pidfile = open(pidfilename, "w")

2493

2340

os.setuid(uid)

2494

2341

except OSError as error:

2495

2342

if error.errno != errno.EPERM:

2496

raise

2343

raise error

2497

2344

2498

2345

if debug:

2499

2346

# Enable all possible GnuTLS debugging

2542

2389

use_dbus = False

2543

2390

server_settings["use_dbus"] = False

2544

2391

tcp_server.use_dbus = False

2545

if zeroconf:

2546

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2547

service = AvahiServiceToSyslog(name =

2548

server_settings["servicename"],

2549

servicetype = "_mandos._tcp",

2550

protocol = protocol, bus = bus)

2551

if server_settings["interface"]:

2552

service.interface = (if_nametoindex

2553

(server_settings["interface"]

2554

.encode("utf-8")))

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

2555

2400

2556

2401

global multiprocessing_manager

2557

2402

multiprocessing_manager = multiprocessing.Manager()

2564

2409

old_client_settings = {}

2565

2410

clients_data = {}

2566

2411

2567

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

2568

global wnull

2569

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

2570

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

2571

# mode

2572

if debug or not foreground:

2573

wnull.close()

2574

2575

2412

# Get client data and settings from last running state.

2576

2413

if server_settings["restore"]:

2577

2414

try:

2581

2418

os.remove(stored_state_path)

2582

2419

except IOError as e:

2583

2420

if e.errno == errno.ENOENT:

2584

logger.warning("Could not load persistent state: {}"

2421

logger.warning("Could not load persistent state: {0}"

2585

2422

.format(os.strerror(e.errno)))

2586

2423

else:

2587

2424

logger.critical("Could not load persistent state:",

2592

2429

"EOFError:", exc_info=e)

2593

2430

2594

2431

with PGPEngine() as pgp:

2595

for client_name, client in clients_data.items():

2596

# Skip removed clients

2597

if client_name not in client_settings:

2598

continue

2599

2432

for client_name, client in clients_data.iteritems():

2600

2433

# Decide which value to use after restoring saved state.

2601

2434

# We have three different values: Old config file,

2602

2435

# new config file, and saved state.

2623

2456

if datetime.datetime.utcnow() >= client["expires"]:

2624

2457

if not client["last_checked_ok"]:

2625

2458

logger.warning(

2626

"disabling client {} - Client never "

2459

"disabling client {0} - Client never "

2627

2460

"performed a successful checker"

2628

2461

.format(client_name))

2629

2462

client["enabled"] = False

2630

2463

elif client["last_checker_status"] != 0:

2631

2464

logger.warning(

2632

"disabling client {} - Client last"

2633

" checker failed with error code {}"

2465

"disabling client {0} - Client "

2466

"last checker failed with error code {1}"

2634

2467

.format(client_name,

2635

2468

client["last_checker_status"]))

2636

2469

client["enabled"] = False

2639

2472

.utcnow()

2640

2473

+ client["timeout"])

2641

2474

logger.debug("Last checker succeeded,"

2642

" keeping {} enabled"

2475

" keeping {0} enabled"

2643

2476

.format(client_name))

2644

2477

try:

2645

2478

client["secret"] = (

2648

2481

["secret"]))

2649

2482

except PGPError:

2650

2483

# If decryption fails, we use secret from new settings

2651

logger.debug("Failed to decrypt {} old secret"

2484

logger.debug("Failed to decrypt {0} old secret"

2652

2485

.format(client_name))

2653

2486

client["secret"] = (

2654

2487

client_settings[client_name]["secret"])

2662

2495

clients_data[client_name] = client_settings[client_name]

2663

2496

2664

2497

# Create all client objects

2665

for client_name, client in clients_data.items():

2498

for client_name, client in clients_data.iteritems():

2666

2499

tcp_server.clients[client_name] = client_class(

2667

name = client_name, settings = client,

2668

server_settings = server_settings)

2500

name = client_name, settings = client)

2669

2501

2670

2502

if not tcp_server.clients:

2671

2503

logger.warning("No clients defined")

2675

2507

try:

2676

2508

with pidfile:

2677

2509

pid = os.getpid()

2678

pidfile.write("{}\n".format(pid).encode("utf-8"))

2510

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

2679

2511

except IOError:

2680

2512

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

2681

2513

pidfilename, pid)

2727

2559

def GetAllClientsWithProperties(self):

2728

2560

"D-Bus method"

2729

2561

return dbus.Dictionary(

2730

{ c.dbus_object_path: c.GetAll("")

2731

for c in tcp_server.clients.itervalues() },

2562

((c.dbus_object_path, c.GetAll(""))

2563

for c in tcp_server.clients.itervalues()),

2732

2564

signature="oa{sv}")

2733

2565

2734

2566

@dbus.service.method(_interface, in_signature="o")

2751

2583

2752

2584

def cleanup():

2753

2585

"Cleanup function; run on exit"

2754

if zeroconf:

2755

service.cleanup()

2586

service.cleanup()

2756

2587

2757

2588

multiprocessing.active_children()

2758

wnull.close()

2759

2589

if not (tcp_server.clients or client_settings):

2760

2590

return

2761

2591

2772

2602

2773

2603

# A list of attributes that can not be pickled

2774

2604

# + secret.

2775

exclude = { "bus", "changedstate", "secret",

2776

"checker", "server_settings" }

2605

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

2606

"checker"))

2777

2607

for name, typ in (inspect.getmembers

2778

2608

(dbus.service.Object)):

2779

2609

exclude.add(name)

2802

2632

except NameError:

2803

2633

pass

2804

2634

if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):

2805

logger.warning("Could not save persistent state: {}"

2635

logger.warning("Could not save persistent state: {0}"

2806

2636

.format(os.strerror(e.errno)))

2807

2637

else:

2808

2638

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

2809

2639

exc_info=e)

2810

raise

2640

raise e

2811

2641

2812

2642

# Delete all clients, and settings from config

2813

2643

while tcp_server.clients:

2837

2667

tcp_server.server_activate()

2838

2668

2839

2669

# Find out what port we got

2840

if zeroconf:

2841

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

2670

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

2842

2671

if use_ipv6:

2843

2672

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

2844

2673

" flowinfo %d, scope_id %d",

2850

2679

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

2851

2680

2852

2681

try:

2853

if zeroconf:

2854

# From the Avahi example code

2855

try:

2856

service.activate()

2857

except dbus.exceptions.DBusException as error:

2858

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

2859

cleanup()

2860

sys.exit(1)

2861

# End of Avahi example code

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

2862

2690

2863

2691

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

2864

2692

lambda *args, **kwargs: