/mandos/trunk : revision 237.4.28

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

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

from future_builtins import *

38

39

37

import SocketServer as socketserver

40

38

import socket

41

39

import argparse

67

65

import types

68

66

import binascii

69

67

import tempfile

70

import itertools

71

import collections

72

68

73

69

import dbus

74

70

import dbus.service

79

75

import ctypes.util

80

76

import xml.dom.minidom

81

77

import inspect

78

import GnuPGInterface

82

79

83

80

try:

84

81

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

88

85

except ImportError:

89

86

SO_BINDTODEVICE = None

90

87

91

version = "1.6.7"

88

version = "1.5.3"

92

89

stored_state_file = "clients.pickle"

93

90

94

91

logger = logging.getLogger()

95

syslogger = None

92

syslogger = (logging.handlers.SysLogHandler

93

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

94

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

96

95

97

96

try:

98

97

if_nametoindex = (ctypes.cdll.LoadLibrary

114

113

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

115

114

"""init logger and add loglevel"""

116

115

117

global syslogger

118

syslogger = (logging.handlers.SysLogHandler

119

(facility =

120

logging.handlers.SysLogHandler.LOG_DAEMON,

121

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

122

116

syslogger.setFormatter(logging.Formatter

123

117

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

124

118

' %(message)s'))

142

136

class PGPEngine(object):

143

137

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

144

138

def __init__(self):

139

self.gnupg = GnuPGInterface.GnuPG()

145

140

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

146

self.gnupgargs = ['--batch',

147

'--home', self.tempdir,

148

'--force-mdc',

149

'--quiet',

150

'--no-use-agent']

141

self.gnupg = GnuPGInterface.GnuPG()

142

self.gnupg.options.meta_interactive = False

143

self.gnupg.options.homedir = self.tempdir

144

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

145

'--quiet',

146

'--no-use-agent'])

151

147

152

148

def __enter__(self):

153

149

return self

154

150

155

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

151

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

156

152

self._cleanup()

157

153

return False

158

154

175

171

def password_encode(self, password):

176

172

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

177

173

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

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

174

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

185

175

186

176

def encrypt(self, data, password):

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)

177

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

178

with open(os.devnull) as devnull:

179

try:

180

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

181

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

182

attach_fhs={'stderr': devnull})

183

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

184

f.write(data)

185

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

186

ciphertext = f.read()

187

proc.wait()

188

except IOError as e:

189

raise PGPError(e)

190

self.gnupg.passphrase = None

202

191

return ciphertext

203

192

204

193

def decrypt(self, data, password):

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)

194

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

195

with open(os.devnull) as devnull:

196

try:

197

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

198

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

199

attach_fhs={'stderr': devnull})

200

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

201

f.write(data)

202

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

203

decrypted_plaintext = f.read()

204

proc.wait()

205

except IOError as e:

206

raise PGPError(e)

207

self.gnupg.passphrase = None

221

208

return decrypted_plaintext

222

209

223

210

211

224

212

class AvahiError(Exception):

225

213

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

226

214

self.value = value

243

231

Used to optionally bind to the specified interface.

244

232

name: string; Example: 'Mandos'

245

233

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

246

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

234

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

247

235

port: integer; what port to announce

248

236

TXT: list of strings; TXT record for the service

249

237

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

255

243

server: D-Bus Server

256

244

bus: dbus.SystemBus()

257

245

"""

258

259

246

def __init__(self, interface = avahi.IF_UNSPEC, name = None,

260

247

servicetype = None, port = None, TXT = None,

261

248

domain = "", host = "", max_renames = 32768,

274

261

self.server = None

275

262

self.bus = bus

276

263

self.entry_group_state_changed_match = None

277

278

264

def rename(self):

279

265

"""Derived from the Avahi example code"""

280

266

if self.rename_count >= self.max_renames:

290

276

try:

291

277

self.add()

292

278

except dbus.exceptions.DBusException as error:

293

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

279

logger.critical("DBusException: %s", error)

294

280

self.cleanup()

295

281

os._exit(1)

296

282

self.rename_count += 1

297

298

283

def remove(self):

299

284

"""Derived from the Avahi example code"""

300

285

if self.entry_group_state_changed_match is not None:

302

287

self.entry_group_state_changed_match = None

303

288

if self.group is not None:

304

289

self.group.Reset()

305

306

290

def add(self):

307

291

"""Derived from the Avahi example code"""

308

292

self.remove()

325

309

dbus.UInt16(self.port),

326

310

avahi.string_array_to_txt_array(self.TXT))

327

311

self.group.Commit()

328

329

312

def entry_group_state_changed(self, state, error):

330

313

"""Derived from the Avahi example code"""

331

314

logger.debug("Avahi entry group state change: %i", state)

338

321

elif state == avahi.ENTRY_GROUP_FAILURE:

339

322

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

340

323

unicode(error))

341

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

342

.format(error))

343

324

raise AvahiGroupError("State changed: %s"

325

% unicode(error))

344

326

def cleanup(self):

345

327

"""Derived from the Avahi example code"""

346

328

if self.group is not None:

351

333

pass

352

334

self.group = None

353

335

self.remove()

354

355

336

def server_state_changed(self, state, error=None):

356

337

"""Derived from the Avahi example code"""

357

338

logger.debug("Avahi server state change: %i", state)

376

357

logger.debug("Unknown state: %r", state)

377

358

else:

378

359

logger.debug("Unknown state: %r: %r", state, error)

379

380

360

def activate(self):

381

361

"""Derived from the Avahi example code"""

382

362

if self.server is None:

389

369

self.server_state_changed)

390

370

self.server_state_changed(self.server.GetState())

391

371

392

393

372

class AvahiServiceToSyslog(AvahiService):

394

373

def rename(self):

395

374

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

396

375

ret = AvahiService.rename(self)

397

376

syslogger.setFormatter(logging.Formatter

398

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

399

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

400

.format(self.name)))

377

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

378

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

379

% self.name))

401

380

return ret

402

381

403

382

def timedelta_to_milliseconds(td):

383

"Convert a datetime.timedelta() to milliseconds"

384

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

385

+ (td.seconds * 1000)

386

+ (td.microseconds // 1000))

387

404

388

class Client(object):

405

389

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

406

390

442

426

runtime_expansions: Allowed attributes for runtime expansion.

443

427

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

444

428

disabled, or None

445

server_settings: The server_settings dict from main()

446

429

"""

447

430

448

431

runtime_expansions = ("approval_delay", "approval_duration",

449

"created", "enabled", "expires",

450

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

451

"last_approval_request", "last_checked_ok",

432

"created", "enabled", "fingerprint",

433

"host", "interval", "last_checked_ok",

452

434

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

453

client_defaults = { "timeout": "PT5M",

454

"extended_timeout": "PT15M",

455

"interval": "PT2M",

435

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

436

"extended_timeout": "15m",

437

"interval": "2m",

456

438

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

457

439

"host": "",

458

"approval_delay": "PT0S",

459

"approval_duration": "PT1S",

440

"approval_delay": "0s",

441

"approval_duration": "1s",

460

442

"approved_by_default": "True",

461

443

"enabled": "True",

462

444

}

463

445

446

def timeout_milliseconds(self):

447

"Return the 'timeout' attribute in milliseconds"

448

return timedelta_to_milliseconds(self.timeout)

449

450

def extended_timeout_milliseconds(self):

451

"Return the 'extended_timeout' attribute in milliseconds"

452

return timedelta_to_milliseconds(self.extended_timeout)

453

454

def interval_milliseconds(self):

455

"Return the 'interval' attribute in milliseconds"

456

return timedelta_to_milliseconds(self.interval)

457

458

def approval_delay_milliseconds(self):

459

return timedelta_to_milliseconds(self.approval_delay)

460

464

461

@staticmethod

465

462

def config_parser(config):

466

463

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

491

488

"rb") as secfile:

492

489

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

493

490

else:

494

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

495

.format(section))

491

raise TypeError("No secret or secfile for section %s"

492

% section)

496

493

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

497

494

client["extended_timeout"] = string_to_delta(

498

495

section["extended_timeout"])

507

504

client["last_checker_status"] = -2

508

505

509

506

return settings

510

511

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

507

508

509

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

510

"""Note: the 'checker' key in 'config' sets the

511

'checker_command' attribute and *not* the 'checker'

512

attribute."""

512

513

self.name = name

513

if server_settings is None:

514

server_settings = {}

515

self.server_settings = server_settings

516

514

# adding all client settings

517

for setting, value in settings.items():

515

for setting, value in settings.iteritems():

518

516

setattr(self, setting, value)

519

517

520

518

if self.enabled:

526

524

else:

527

525

self.last_enabled = None

528

526

self.expires = None

529

527

530

528

logger.debug("Creating client %r", self.name)

531

529

# Uppercase and remove spaces from fingerprint for later

532

530

# comparison purposes with return value from the fingerprint()

534

532

logger.debug(" Fingerprint: %s", self.fingerprint)

535

533

self.created = settings.get("created",

536

534

datetime.datetime.utcnow())

537

535

538

536

# attributes specific for this server instance

539

537

self.checker = None

540

538

self.checker_initiator_tag = None

568

566

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

569

567

# Already enabled

570

568

return

569

self.send_changedstate()

571

570

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

572

571

self.enabled = True

573

572

self.last_enabled = datetime.datetime.utcnow()

574

573

self.init_checker()

575

self.send_changedstate()

576

574

577

575

def disable(self, quiet=True):

578

576

"""Disable this client."""

579

577

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

580

578

return False

581

579

if not quiet:

580

self.send_changedstate()

581

if not quiet:

582

logger.info("Disabling client %s", self.name)

583

if getattr(self, "disable_initiator_tag", None) is not None:

583

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

584

gobject.source_remove(self.disable_initiator_tag)

585

self.disable_initiator_tag = None

586

self.expires = None

587

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

587

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

588

gobject.source_remove(self.checker_initiator_tag)

589

self.checker_initiator_tag = None

590

self.stop_checker()

591

self.enabled = False

592

if not quiet:

593

self.send_changedstate()

594

592

# Do not run this again if called by a gobject.timeout_add

595

593

return False

596

594

600

598

def init_checker(self):

601

599

# Schedule a new checker to be started an 'interval' from now,

602

600

# and every interval from then on.

603

if self.checker_initiator_tag is not None:

604

gobject.source_remove(self.checker_initiator_tag)

605

601

self.checker_initiator_tag = (gobject.timeout_add

606

(int(self.interval

607

.total_seconds() * 1000),

602

(self.interval_milliseconds(),

608

603

self.start_checker))

609

604

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

610

if self.disable_initiator_tag is not None:

611

gobject.source_remove(self.disable_initiator_tag)

612

605

self.disable_initiator_tag = (gobject.timeout_add

613

(int(self.timeout

614

.total_seconds() * 1000),

615

self.disable))

606

(self.timeout_milliseconds(),

607

self.disable))

616

608

# Also start a new checker *right now*.

617

609

self.start_checker()

618

610

646

638

timeout = self.timeout

647

639

if self.disable_initiator_tag is not None:

648

640

gobject.source_remove(self.disable_initiator_tag)

649

self.disable_initiator_tag = None

650

641

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

651

642

self.disable_initiator_tag = (gobject.timeout_add

652

(int(timeout.total_seconds()

653

* 1000), self.disable))

643

(timedelta_to_milliseconds

644

(timeout), self.disable))

654

645

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

655

646

656

647

def need_approval(self):

662

653

If a checker already exists, leave it running and do

663

654

nothing."""

664

655

# The reason for not killing a running checker is that if we

665

# did that, and if a checker (for some reason) started running

666

# slowly and taking more than 'interval' time, then the client

667

# would inevitably timeout, since no checker would get a

668

# chance to run to completion. If we instead leave running

656

# did that, then if a checker (for some reason) started

657

# running slowly and taking more than 'interval' time, the

658

# client would inevitably timeout, since no checker would get

659

# a chance to run to completion. If we instead leave running

669

660

# checkers alone, the checker would have to take more time

670

661

# than 'timeout' for the client to be disabled, which is as it

671

662

# should be.

673

664

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

674

665

try:

675

666

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

667

except (AttributeError, OSError) as error:

668

if (isinstance(error, OSError)

669

and error.errno != errno.ECHILD):

670

raise error

681

671

else:

682

672

if pid:

683

673

logger.warning("Checker was a zombie")

686

676

self.current_checker_command)

687

677

# Start a new checker if needed

688

678

if self.checker is None:

689

# Escape attributes for the shell

690

escaped_attrs = { attr:

691

re.escape(unicode(getattr(self,

692

attr)))

693

for attr in self.runtime_expansions }

694

679

try:

695

command = self.checker_command % escaped_attrs

696

except TypeError as error:

697

logger.error('Could not format string "%s"',

698

self.checker_command, exc_info=error)

699

return True # Try again later

680

# In case checker_command has exactly one % operator

681

command = self.checker_command % self.host

682

except TypeError:

683

# Escape attributes for the shell

684

escaped_attrs = dict(

685

(attr,

686

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

687

errors=

688

'replace')))

689

for attr in

690

self.runtime_expansions)

691

692

try:

693

command = self.checker_command % escaped_attrs

694

except TypeError as error:

695

logger.error('Could not format string "%s":'

696

' %s', self.checker_command, error)

697

return True # Try again later

700

698

self.current_checker_command = command

701

699

try:

702

700

logger.info("Starting checker %r for %s",

705

703

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

706

704

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

707

705

# always replaced by /dev/null.)

708

# The exception is when not debugging but nevertheless

709

# running in the foreground; use the previously

710

# created wnull.

711

popen_args = {}

712

if (not self.server_settings["debug"]

713

and self.server_settings["foreground"]):

714

popen_args.update({"stdout": wnull,

715

"stderr": wnull })

716

706

self.checker = subprocess.Popen(command,

717

707

close_fds=True,

718

shell=True, cwd="/",

719

**popen_args)

720

except OSError as error:

721

logger.error("Failed to start subprocess",

722

exc_info=error)

723

return True

724

self.checker_callback_tag = (gobject.child_watch_add

725

(self.checker.pid,

726

self.checker_callback,

727

data=command))

728

# The checker may have completed before the gobject

729

# watch was added. Check for this.

730

try:

708

shell=True, cwd="/")

709

self.checker_callback_tag = (gobject.child_watch_add

710

(self.checker.pid,

711

self.checker_callback,

712

data=command))

713

# The checker may have completed before the gobject

714

# watch was added. Check for this.

731

715

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

716

if pid:

717

gobject.source_remove(self.checker_callback_tag)

718

self.checker_callback(pid, status, command)

732

719

except OSError as error:

733

if error.errno == errno.ECHILD:

734

# This should never happen

735

logger.error("Child process vanished",

736

exc_info=error)

737

return True

738

raise

739

if pid:

740

gobject.source_remove(self.checker_callback_tag)

741

self.checker_callback(pid, status, command)

720

logger.error("Failed to start subprocess: %s",

721

error)

742

722

# Re-run this periodically if run by gobject.timeout_add

743

723

return True

744

724

751

731

return

752

732

logger.debug("Stopping checker for %(name)s", vars(self))

753

733

try:

754

self.checker.terminate()

734

os.kill(self.checker.pid, signal.SIGTERM)

755

735

#time.sleep(0.5)

756

736

#if self.checker.poll() is None:

757

# self.checker.kill()

737

# os.kill(self.checker.pid, signal.SIGKILL)

758

738

except OSError as error:

759

739

if error.errno != errno.ESRCH: # No such process

760

740

raise

777

757

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

778

758

if byte_arrays and signature != "ay":

779

759

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

780

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

760

" signature %r" % signature)

781

761

def decorator(func):

782

762

func._dbus_is_property = True

783

763

func._dbus_interface = dbus_interface

791

771

return decorator

792

772

793

773

794

def dbus_interface_annotations(dbus_interface):

795

"""Decorator for marking functions returning interface annotations

796

797

Usage:

798

799

@dbus_interface_annotations("org.example.Interface")

800

def _foo(self): # Function name does not matter

801

return {"org.freedesktop.DBus.Deprecated": "true",

802

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

803

"false"}

804

"""

805

def decorator(func):

806

func._dbus_is_interface = True

807

func._dbus_interface = dbus_interface

808

func._dbus_name = dbus_interface

809

return func

810

return decorator

811

812

813

def dbus_annotations(annotations):

814

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

815

Usage:

816

817

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

818

access="r")

819

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

820

"org.freedesktop.DBus.Property."

821

"EmitsChangedSignal": "false"})

822

def Property_dbus_property(self):

823

return dbus.Boolean(False)

824

"""

825

def decorator(func):

826

func._dbus_annotations = annotations

827

return func

828

return decorator

829

830

831

774

class DBusPropertyException(dbus.exceptions.DBusException):

832

775

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

833

776

"""

856

799

"""

857

800

858

801

@staticmethod

859

def _is_dbus_thing(thing):

860

"""Returns a function testing if an attribute is a D-Bus thing

861

862

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

863

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

864

"""

865

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

866

False)

802

def _is_dbus_property(obj):

803

return getattr(obj, "_dbus_is_property", False)

867

804

868

def _get_all_dbus_things(self, thing):

805

def _get_all_dbus_properties(self):

869

806

"""Returns a generator of (name, attribute) pairs

870

807

"""

871

return ((getattr(athing.__get__(self), "_dbus_name",

872

name),

873

athing.__get__(self))

808

return ((prop.__get__(self)._dbus_name, prop.__get__(self))

874

809

for cls in self.__class__.__mro__

875

for name, athing in

876

inspect.getmembers(cls,

877

self._is_dbus_thing(thing)))

810

for name, prop in

811

inspect.getmembers(cls, self._is_dbus_property))

878

812

879

813

def _get_dbus_property(self, interface_name, property_name):

880

814

"""Returns a bound method if one exists which is a D-Bus

882

816

"""

883

817

for cls in self.__class__.__mro__:

884

818

for name, value in (inspect.getmembers

885

(cls,

886

self._is_dbus_thing("property"))):

819

(cls, self._is_dbus_property)):

887

820

if (value._dbus_name == property_name

888

821

and value._dbus_interface == interface_name):

889

822

return value.__get__(self)

917

850

# The byte_arrays option is not supported yet on

918

851

# signatures other than "ay".

919

852

if prop._dbus_signature != "ay":

920

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

921

"'ay' signature {!r}"

922

.format(prop._dbus_signature))

853

raise ValueError

923

854

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

924

855

for byte in value))

925

856

prop(value)

933

864

Note: Will not include properties with access="write".

934

865

"""

935

866

properties = {}

936

for name, prop in self._get_all_dbus_things("property"):

867

for name, prop in self._get_all_dbus_properties():

937

868

if (interface_name

938

869

and interface_name != prop._dbus_interface):

939

870

# Interface non-empty but did not match

954

885

path_keyword='object_path',

955

886

connection_keyword='connection')

956

887

def Introspect(self, object_path, connection):

957

"""Overloading of standard D-Bus method.

958

959

Inserts property tags and interface annotation tags.

888

"""Standard D-Bus method, overloaded to insert property tags.

960

889

"""

961

890

xmlstring = dbus.service.Object.Introspect(self, object_path,

962

891

connection)

969

898

e.setAttribute("access", prop._dbus_access)

970

899

return e

971

900

for if_tag in document.getElementsByTagName("interface"):

972

# Add property tags

973

901

for tag in (make_tag(document, name, prop)

974

902

for name, prop

975

in self._get_all_dbus_things("property")

903

in self._get_all_dbus_properties()

976

904

if prop._dbus_interface

977

905

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

978

906

if_tag.appendChild(tag)

979

# Add annotation tags

980

for typ in ("method", "signal", "property"):

981

for tag in if_tag.getElementsByTagName(typ):

982

annots = dict()

983

for name, prop in (self.

984

_get_all_dbus_things(typ)):

985

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

986

and prop._dbus_interface

987

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

988

annots.update(getattr

989

(prop,

990

"_dbus_annotations",

991

{}))

992

for name, value in annots.items():

993

ann_tag = document.createElement(

994

"annotation")

995

ann_tag.setAttribute("name", name)

996

ann_tag.setAttribute("value", value)

997

tag.appendChild(ann_tag)

998

# Add interface annotation tags

999

for annotation, value in dict(

1000

itertools.chain.from_iterable(

1001

annotations().items()

1002

for name, annotations in

1003

self._get_all_dbus_things("interface")

1004

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

1005

)).items():

1006

ann_tag = document.createElement("annotation")

1007

ann_tag.setAttribute("name", annotation)

1008

ann_tag.setAttribute("value", value)

1009

if_tag.appendChild(ann_tag)

1010

907

# Add the names to the return values for the

1011

908

# "org.freedesktop.DBus.Properties" methods

1012

909

if (if_tag.getAttribute("name")

1027

924

except (AttributeError, xml.dom.DOMException,

1028

925

xml.parsers.expat.ExpatError) as error:

1029

926

logger.error("Failed to override Introspection method",

1030

exc_info=error)

927

error)

1031

928

return xmlstring

1032

929

1033

930

1034

def datetime_to_dbus(dt, variant_level=0):

931

def datetime_to_dbus (dt, variant_level=0):

1035

932

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

1036

933

if dt is None:

1037

934

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

1039

936

variant_level=variant_level)

1040

937

1041

938

1042

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1043

"""A class decorator; applied to a subclass of

1044

dbus.service.Object, it will add alternate D-Bus attributes with

1045

interface names according to the "alt_interface_names" mapping.

1046

Usage:

1047

1048

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

1049

"net.example.AlternateInterface"})

1050

class SampleDBusObject(dbus.service.Object):

1051

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

1052

def SampleDBusMethod():

1053

pass

1054

1055

The above "SampleDBusMethod" on "SampleDBusObject" will be

1056

reachable via two interfaces: "org.example.Interface" and

1057

"net.example.AlternateInterface", the latter of which will have

1058

its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to

1059

"true", unless "deprecate" is passed with a False value.

1060

1061

This works for methods and signals, and also for D-Bus properties

1062

(from DBusObjectWithProperties) and interfaces (from the

1063

dbus_interface_annotations decorator).

939

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

940

.__metaclass__):

941

"""Applied to an empty subclass of a D-Bus object, this metaclass

942

will add additional D-Bus attributes matching a certain pattern.

1064

943

"""

1065

def wrapper(cls):

1066

for orig_interface_name, alt_interface_name in (

1067

alt_interface_names.items()):

1068

attr = {}

1069

interface_names = set()

1070

# Go though all attributes of the class

1071

for attrname, attribute in inspect.getmembers(cls):

944

def __new__(mcs, name, bases, attr):

945

# Go through all the base classes which could have D-Bus

946

# methods, signals, or properties in them

947

for base in (b for b in bases

948

if issubclass(b, dbus.service.Object)):

949

# Go though all attributes of the base class

950

for attrname, attribute in inspect.getmembers(base):

1072

951

# Ignore non-D-Bus attributes, and D-Bus attributes

1073

952

# with the wrong interface name

1074

953

if (not hasattr(attribute, "_dbus_interface")

1075

954

or not attribute._dbus_interface

1076

.startswith(orig_interface_name)):

955

.startswith("se.recompile.Mandos")):

1077

956

continue

1078

957

# Create an alternate D-Bus interface name based on

1079

958

# the current name

1080

959

alt_interface = (attribute._dbus_interface

1081

.replace(orig_interface_name,

1082

alt_interface_name))

1083

interface_names.add(alt_interface)

960

.replace("se.recompile.Mandos",

961

"se.bsnet.fukt.Mandos"))

1084

962

# Is this a D-Bus signal?

1085

963

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

1086

# Extract the original non-method undecorated

1087

# function by black magic

964

# Extract the original non-method function by

965

# black magic

1088

966

nonmethod_func = (dict(

1089

967

zip(attribute.func_code.co_freevars,

1090

968

attribute.__closure__))["func"]

1101

979

nonmethod_func.func_name,

1102

980

nonmethod_func.func_defaults,

1103

981

nonmethod_func.func_closure)))

1104

# Copy annotations, if any

1105

try:

1106

new_function._dbus_annotations = (

1107

dict(attribute._dbus_annotations))

1108

except AttributeError:

1109

pass

1110

982

# Define a creator of a function to call both the

1111

# original and alternate functions, so both the

1112

# original and alternate signals gets sent when

1113

# the function is called

983

# old and new functions, so both the old and new

984

# signals gets sent when the function is called

1114

985

def fixscope(func1, func2):

1115

986

"""This function is a scope container to pass

1116

987

func1 and func2 to the "call_both" function

1123

994

return call_both

1124

995

# Create the "call_both" function and add it to

1125

996

# the class

1126

attr[attrname] = fixscope(attribute, new_function)

997

attr[attrname] = fixscope(attribute,

998

new_function)

1127

999

# Is this a D-Bus method?

1128

1000

elif getattr(attribute, "_dbus_is_method", False):

1129

1001

# Create a new, but exactly alike, function

1140

1012

attribute.func_name,

1141

1013

attribute.func_defaults,

1142

1014

attribute.func_closure)))

1143

# Copy annotations, if any

1144

try:

1145

attr[attrname]._dbus_annotations = (

1146

dict(attribute._dbus_annotations))

1147

except AttributeError:

1148

pass

1149

1015

# Is this a D-Bus property?

1150

1016

elif getattr(attribute, "_dbus_is_property", False):

1151

1017

# Create a new, but exactly alike, function

1165

1031

attribute.func_name,

1166

1032

attribute.func_defaults,

1167

1033

attribute.func_closure)))

1168

# Copy annotations, if any

1169

try:

1170

attr[attrname]._dbus_annotations = (

1171

dict(attribute._dbus_annotations))

1172

except AttributeError:

1173

pass

1174

# Is this a D-Bus interface?

1175

elif getattr(attribute, "_dbus_is_interface", False):

1176

# Create a new, but exactly alike, function

1177

# object. Decorate it to be a new D-Bus interface

1178

# with the alternate D-Bus interface name. Add it

1179

# to the class.

1180

attr[attrname] = (dbus_interface_annotations

1181

(alt_interface)

1182

(types.FunctionType

1183

(attribute.func_code,

1184

attribute.func_globals,

1185

attribute.func_name,

1186

attribute.func_defaults,

1187

attribute.func_closure)))

1188

if deprecate:

1189

# Deprecate all alternate interfaces

1190

iname="_AlternateDBusNames_interface_annotation{}"

1191

for interface_name in interface_names:

1192

@dbus_interface_annotations(interface_name)

1193

def func(self):

1194

return { "org.freedesktop.DBus.Deprecated":

1195

"true" }

1196

# Find an unused name

1197

for aname in (iname.format(i)

1198

for i in itertools.count()):

1199

if aname not in attr:

1200

attr[aname] = func

1201

break

1202

if interface_names:

1203

# Replace the class with a new subclass of it with

1204

# methods, signals, etc. as created above.

1205

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

1206

(cls,), attr)

1207

return cls

1208

return wrapper

1209

1210

1211

@alternate_dbus_interfaces({"se.recompile.Mandos":

1212

"se.bsnet.fukt.Mandos"})

1034

return type.__new__(mcs, name, bases, attr)

1035

1036

1213

1037

class ClientDBus(Client, DBusObjectWithProperties):

1214

1038

"""A Client class using D-Bus

1215

1039

1235

1059

("/clients/" + client_object_name))

1236

1060

DBusObjectWithProperties.__init__(self, self.bus,

1237

1061

self.dbus_object_path)

1238

1062

1239

1063

def notifychangeproperty(transform_func,

1240

1064

dbus_name, type_func=lambda x: x,

1241

1065

variant_level=1):

1249

1073

to the D-Bus. Default: no transform

1250

1074

variant_level: D-Bus variant level. Default: 1

1251

1075

"""

1252

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

1076

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

1253

1077

def setter(self, value):

1254

1078

if hasattr(self, "dbus_object_path"):

1255

1079

if (not hasattr(self, attrname) or

1264

1088

1265

1089

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

1266

1090

1091

1267

1092

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1268

1093

approvals_pending = notifychangeproperty(dbus.Boolean,

1269

1094

"ApprovalPending",

1285

1110

approval_delay = notifychangeproperty(dbus.UInt64,

1286

1111

"ApprovalDelay",

1287

1112

type_func =

1288

lambda td: td.total_seconds()

1289

* 1000)

1113

timedelta_to_milliseconds)

1290

1114

approval_duration = notifychangeproperty(

1291

1115

dbus.UInt64, "ApprovalDuration",

1292

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

1116

type_func = timedelta_to_milliseconds)

1293

1117

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

1294

1118

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

1295

type_func = lambda td:

1296

td.total_seconds() * 1000)

1119

type_func =

1120

timedelta_to_milliseconds)

1297

1121

extended_timeout = notifychangeproperty(

1298

1122

dbus.UInt64, "ExtendedTimeout",

1299

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

1123

type_func = timedelta_to_milliseconds)

1300

1124

interval = notifychangeproperty(dbus.UInt64,

1301

1125

"Interval",

1302

1126

type_func =

1303

lambda td: td.total_seconds()

1304

* 1000)

1127

timedelta_to_milliseconds)

1305

1128

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

1306

1129

1307

1130

del notifychangeproperty

1335

1158

*args, **kwargs)

1336

1159

1337

1160

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

1338

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

1161

old_checker = self.checker

1162

if self.checker is not None:

1163

old_checker_pid = self.checker.pid

1164

else:

1165

old_checker_pid = None

1339

1166

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

1340

1167

# Only if new checker process was started

1341

1168

if (self.checker is not None

1349

1176

return False

1350

1177

1351

1178

def approve(self, value=True):

1179

self.send_changedstate()

1352

1180

self.approved = value

1353

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

1354

* 1000), self._reset_approved)

1355

self.send_changedstate()

1181

gobject.timeout_add(timedelta_to_milliseconds

1182

(self.approval_duration),

1183

self._reset_approved)

1184

1356

1185

1357

1186

## D-Bus methods, signals & properties

1358

1187

_interface = "se.recompile.Mandos.Client"

1359

1188

1360

## Interfaces

1361

1362

@dbus_interface_annotations(_interface)

1363

def _foo(self):

1364

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

1365

"false"}

1366

1367

1189

## Signals

1368

1190

1369

1191

# CheckerCompleted - signal

1460

1282

access="readwrite")

1461

1283

def ApprovalDelay_dbus_property(self, value=None):

1462

1284

if value is None: # get

1463

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

1464

* 1000)

1285

return dbus.UInt64(self.approval_delay_milliseconds())

1465

1286

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

1466

1287

1467

1288

# ApprovalDuration - property

1469

1290

access="readwrite")

1470

1291

def ApprovalDuration_dbus_property(self, value=None):

1471

1292

if value is None: # get

1472

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

1473

* 1000)

1293

return dbus.UInt64(timedelta_to_milliseconds(

1294

self.approval_duration))

1474

1295

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

1475

1296

1476

1297

# Name - property

1542

1363

access="readwrite")

1543

1364

def Timeout_dbus_property(self, value=None):

1544

1365

if value is None: # get

1545

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

1546

old_timeout = self.timeout

1366

return dbus.UInt64(self.timeout_milliseconds())

1547

1367

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

1548

# Reschedule disabling

1368

# Reschedule timeout

1549

1369

if self.enabled:

1550

1370

now = datetime.datetime.utcnow()

1551

self.expires += self.timeout - old_timeout

1552

if self.expires <= now:

1371

time_to_die = timedelta_to_milliseconds(

1372

(self.last_checked_ok + self.timeout) - now)

1373

if time_to_die <= 0:

1553

1374

# The timeout has passed

1554

1375

self.disable()

1555

1376

else:

1377

self.expires = (now +

1378

datetime.timedelta(milliseconds =

1379

time_to_die))

1556

1380

if (getattr(self, "disable_initiator_tag", None)

1557

1381

is None):

1558

1382

return

1559

1383

gobject.source_remove(self.disable_initiator_tag)

1560

self.disable_initiator_tag = (

1561

gobject.timeout_add(

1562

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

1563

* 1000), self.disable))

1384

self.disable_initiator_tag = (gobject.timeout_add

1385

(time_to_die,

1386

self.disable))

1564

1387

1565

1388

# ExtendedTimeout - property

1566

1389

@dbus_service_property(_interface, signature="t",

1567

1390

access="readwrite")

1568

1391

def ExtendedTimeout_dbus_property(self, value=None):

1569

1392

if value is None: # get

1570

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

1571

* 1000)

1393

return dbus.UInt64(self.extended_timeout_milliseconds())

1572

1394

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

1573

1395

1574

1396

# Interval - property

1576

1398

access="readwrite")

1577

1399

def Interval_dbus_property(self, value=None):

1578

1400

if value is None: # get

1579

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

1401

return dbus.UInt64(self.interval_milliseconds())

1580

1402

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

1581

1403

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

1582

1404

return

1646

1468

self._pipe.send(('setattr', name, value))

1647

1469

1648

1470

1471

class ClientDBusTransitional(ClientDBus):

1472

__metaclass__ = AlternateDBusNamesMetaclass

1473

1474

1649

1475

class ClientHandler(socketserver.BaseRequestHandler, object):

1650

1476

"""A class to handle client connections.

1651

1477

1687

1513

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

1688

1514

try:

1689

1515

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

1690

raise RuntimeError(line)

1516

raise RuntimeError

1691

1517

except (ValueError, IndexError, RuntimeError) as error:

1692

1518

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

1693

1519

return

1742

1568

if self.server.use_dbus:

1743

1569

# Emit D-Bus signal

1744

1570

client.NeedApproval(

1745

client.approval_delay.total_seconds()

1746

* 1000, client.approved_by_default)

1571

client.approval_delay_milliseconds(),

1572

client.approved_by_default)

1747

1573

else:

1748

1574

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

1749

1575

client.name)

1755

1581

#wait until timeout or approved

1756

1582

time = datetime.datetime.now()

1757

1583

client.changedstate.acquire()

1758

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

1584

(client.changedstate.wait

1585

(float(client.timedelta_to_milliseconds(delay)

1586

/ 1000)))

1759

1587

client.changedstate.release()

1760

1588

time2 = datetime.datetime.now()

1761

1589

if (time2 - time) >= delay:

1777

1605

try:

1778

1606

sent = session.send(client.secret[sent_size:])

1779

1607

except gnutls.errors.GNUTLSError as error:

1780

logger.warning("gnutls send failed",

1781

exc_info=error)

1608

logger.warning("gnutls send failed")

1782

1609

return

1783

1610

logger.debug("Sent: %d, remaining: %d",

1784

1611

sent, len(client.secret)

1798

1625

try:

1799

1626

session.bye()

1800

1627

except gnutls.errors.GNUTLSError as error:

1801

logger.warning("GnuTLS bye failed",

1802

exc_info=error)

1628

logger.warning("GnuTLS bye failed")

1803

1629

1804

1630

@staticmethod

1805

1631

def peer_certificate(session):

1877

1703

def process_request(self, request, address):

1878

1704

"""Start a new process to process the request."""

1879

1705

proc = multiprocessing.Process(target = self.sub_process_main,

1880

args = (request, address))

1706

args = (request,

1707

address))

1881

1708

proc.start()

1882

1709

return proc

1883

1710

1898

1725

1899

1726

def add_pipe(self, parent_pipe, proc):

1900

1727

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

1901

raise NotImplementedError()

1728

raise NotImplementedError

1902

1729

1903

1730

1904

1731

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1911

1738

use_ipv6: Boolean; to use IPv6 or not

1912

1739

"""

1913

1740

def __init__(self, server_address, RequestHandlerClass,

1914

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

1915

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

1916

creating a new one with socket.socket().

1917

"""

1741

interface=None, use_ipv6=True):

1918

1742

self.interface = interface

1919

1743

if use_ipv6:

1920

1744

self.address_family = socket.AF_INET6

1921

if socketfd is not None:

1922

# Save the file descriptor

1923

self.socketfd = socketfd

1924

# Save the original socket.socket() function

1925

self.socket_socket = socket.socket

1926

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

1927

#

1928

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

1929

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

1930

# patching socket.socket.)

1931

#

1932

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

1933

@functools.wraps(socket.socket)

1934

def socket_wrapper(*args, **kwargs):

1935

# Restore original function so subsequent calls are

1936

# not affected.

1937

socket.socket = self.socket_socket

1938

del self.socket_socket

1939

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

1940

# saved file descriptor.

1941

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

1942

# Replace socket.socket() function with wrapper

1943

socket.socket = socket_wrapper

1944

# The socketserver.TCPServer.__init__ will call

1945

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

1946

# socket_wrapper(), if socketfd was set.

1947

1745

socketserver.TCPServer.__init__(self, server_address,

1948

1746

RequestHandlerClass)

1949

1950

1747

def server_bind(self):

1951

1748

"""This overrides the normal server_bind() function

1952

1749

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

1960

1757

try:

1961

1758

self.socket.setsockopt(socket.SOL_SOCKET,

1962

1759

SO_BINDTODEVICE,

1963

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

1760

str(self.interface

1761

+ '\0'))

1964

1762

except socket.error as error:

1965

if error.errno == errno.EPERM:

1966

logger.error("No permission to bind to"

1967

" interface %s", self.interface)

1968

elif error.errno == errno.ENOPROTOOPT:

1763

if error[0] == errno.EPERM:

1764

logger.error("No permission to"

1765

" bind to interface %s",

1766

self.interface)

1767

elif error[0] == errno.ENOPROTOOPT:

1969

1768

logger.error("SO_BINDTODEVICE not available;"

1970

1769

" cannot bind to interface %s",

1971

1770

self.interface)

1972

elif error.errno == errno.ENODEV:

1973

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

1974

" cannot bind", self.interface)

1975

1771

else:

1976

1772

raise

1977

1773

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

1980

1776

if self.address_family == socket.AF_INET6:

1981

1777

any_address = "::" # in6addr_any

1982

1778

else:

1983

any_address = "0.0.0.0" # INADDR_ANY

1779

any_address = socket.INADDR_ANY

1984

1780

self.server_address = (any_address,

1985

1781

self.server_address[1])

1986

1782

elif not self.server_address[1]:

2007

1803

"""

2008

1804

def __init__(self, server_address, RequestHandlerClass,

2009

1805

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

2010

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

1806

gnutls_priority=None, use_dbus=True):

2011

1807

self.enabled = False

2012

1808

self.clients = clients

2013

1809

if self.clients is None:

2017

1813

IPv6_TCPServer.__init__(self, server_address,

2018

1814

RequestHandlerClass,

2019

1815

interface = interface,

2020

use_ipv6 = use_ipv6,

2021

socketfd = socketfd)

1816

use_ipv6 = use_ipv6)

2022

1817

def server_activate(self):

2023

1818

if self.enabled:

2024

1819

return socketserver.TCPServer.server_activate(self)

2037

1832

2038

1833

def handle_ipc(self, source, condition, parent_pipe=None,

2039

1834

proc = None, client_object=None):

1835

condition_names = {

1836

gobject.IO_IN: "IN", # There is data to read.

1837

gobject.IO_OUT: "OUT", # Data can be written (without

1838

# blocking).

1839

gobject.IO_PRI: "PRI", # There is urgent data to read.

1840

gobject.IO_ERR: "ERR", # Error condition.

1841

gobject.IO_HUP: "HUP" # Hung up (the connection has been

1842

# broken, usually for pipes and

1843

# sockets).

1844

}

1845

conditions_string = ' | '.join(name

1846

for cond, name in

1847

condition_names.iteritems()

1848

if cond & condition)

2040

1849

# error, or the other end of multiprocessing.Pipe has closed

2041

if condition & (gobject.IO_ERR | gobject.IO_HUP):

1850

if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):

2042

1851

# Wait for other process to exit

2043

1852

proc.join()

2044

1853

return False

2102

1911

return True

2103

1912

2104

1913

2105

def rfc3339_duration_to_delta(duration):

2106

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

2107

2108

>>> rfc3339_duration_to_delta("P7D")

2109

datetime.timedelta(7)

2110

>>> rfc3339_duration_to_delta("PT60S")

2111

datetime.timedelta(0, 60)

2112

>>> rfc3339_duration_to_delta("PT60M")

2113

datetime.timedelta(0, 3600)

2114

>>> rfc3339_duration_to_delta("PT24H")

2115

datetime.timedelta(1)

2116

>>> rfc3339_duration_to_delta("P1W")

2117

datetime.timedelta(7)

2118

>>> rfc3339_duration_to_delta("PT5M30S")

2119

datetime.timedelta(0, 330)

2120

>>> rfc3339_duration_to_delta("P1DT3M20S")

2121

datetime.timedelta(1, 200)

2122

"""

2123

2124

# Parsing an RFC 3339 duration with regular expressions is not

2125

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

2126

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

2127

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

2128

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

2129

# avoid excessive use of external libraries.

2130

2131

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

2132

Token = collections.namedtuple("Token",

2133

("regexp", # To match token; if

2134

# "value" is not None,

2135

# must have a "group"

2136

# containing digits

2137

"value", # datetime.timedelta or

2138

# None

2139

"followers")) # Tokens valid after

2140

# this token

2141

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

2142

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

2143

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

2144

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

2145

datetime.timedelta(seconds=1),

2146

frozenset((token_end,)))

2147

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

2148

datetime.timedelta(minutes=1),

2149

frozenset((token_second, token_end)))

2150

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

2151

datetime.timedelta(hours=1),

2152

frozenset((token_minute, token_end)))

2153

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

2154

None,

2155

frozenset((token_hour, token_minute,

2156

token_second)))

2157

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

2158

datetime.timedelta(days=1),

2159

frozenset((token_time, token_end)))

2160

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

2161

datetime.timedelta(weeks=4),

2162

frozenset((token_day, token_end)))

2163

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

2164

datetime.timedelta(weeks=52),

2165

frozenset((token_month, token_end)))

2166

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

2167

datetime.timedelta(weeks=1),

2168

frozenset((token_end,)))

2169

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

2170

frozenset((token_year, token_month,

2171

token_day, token_time,

2172

token_week)))

2173

# Define starting values

2174

value = datetime.timedelta() # Value so far

2175

found_token = None

2176

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

2177

s = duration # String left to parse

2178

# Loop until end token is found

2179

while found_token is not token_end:

2180

# Search for any currently valid tokens

2181

for token in followers:

2182

match = token.regexp.match(s)

2183

if match is not None:

2184

# Token found

2185

if token.value is not None:

2186

# Value found, parse digits

2187

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

2188

# Add to value so far

2189

value += factor * token.value

2190

# Strip token from string

2191

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

2192

# Go to found token

2193

found_token = token

2194

# Set valid next tokens

2195

followers = found_token.followers

2196

break

2197

else:

2198

# No currently valid tokens were found

2199

raise ValueError("Invalid RFC 3339 duration")

2200

# End token found

2201

return value

2202

2203

2204

1914

def string_to_delta(interval):

2205

1915

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

2206

1916

2217

1927

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

2218

1928

datetime.timedelta(0, 330)

2219

1929

"""

2220

2221

try:

2222

return rfc3339_duration_to_delta(interval)

2223

except ValueError:

2224

pass

2225

2226

1930

timevalue = datetime.timedelta(0)

2227

1931

for s in interval.split():

2228

1932

try:

2239

1943

elif suffix == "w":

2240

1944

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

2241

1945

else:

2242

raise ValueError("Unknown suffix {!r}"

2243

.format(suffix))

2244

except IndexError as e:

1946

raise ValueError("Unknown suffix %r" % suffix)

1947

except (ValueError, IndexError) as e:

2245

1948

raise ValueError(*(e.args))

2246

1949

timevalue += delta

2247

1950

return timevalue

2260

1963

sys.exit()

2261

1964

if not noclose:

2262

1965

# Close all standard open file descriptors

2263

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

1966

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

2264

1967

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

2265

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

2266

.format(os.devnull))

1968

raise OSError(errno.ENODEV,

1969

"%s not a character device"

1970

% os.path.devnull)

2267

1971

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

2268

1972

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

2269

1973

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

2278

1982

2279

1983

parser = argparse.ArgumentParser()

2280

1984

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

2281

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

1985

version = "%%(prog)s %s" % version,

2282

1986

help="show version number and exit")

2283

1987

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

2284

1988

help="Bind to interface IF")

2290

1994

help="Run self-test")

2291

1995

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

2292

1996

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

2293

" to terminal", default=None)

1997

" to terminal")

2294

1998

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

2295

1999

help="Debug level for stdout output")

2296

2000

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

2303

2007

" files")

2304

2008

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

2305

2009

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

2306

" system bus interface", default=None)

2010

" system bus interface")

2307

2011

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

2308

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

2309

default=None)

2012

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

2310

2013

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

2311

2014

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

2312

" state", default=None)

2313

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

2314

help="Specify a file descriptor to a network"

2315

" socket to use instead of creating one")

2015

" state")

2316

2016

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

2317

2017

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

2318

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

2319

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

2320

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

2321

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

2322

default=None)

2323

2018

2324

2019

options = parser.parse_args()

2325

2020

2326

2021

if options.check:

2327

2022

import doctest

2328

fail_count, test_count = doctest.testmod()

2329

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

2023

doctest.testmod()

2024

sys.exit()

2330

2025

2331

2026

# Default values for config file for server-global settings

2332

2027

server_defaults = { "interface": "",

2334

2029

"port": "",

2335

2030

"debug": "False",

2336

2031

"priority":

2337

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

2032

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

2338

2033

"servicename": "Mandos",

2339

2034

"use_dbus": "True",

2340

2035

"use_ipv6": "True",

2341

2036

"debuglevel": "",

2342

2037

"restore": "True",

2343

"socket": "",

2344

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

2345

"foreground": "False",

2346

"zeroconf": "True",

2038

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

2347

2039

}

2348

2040

2349

2041

# Parse config file for server-global settings

2354

2046

# Convert the SafeConfigParser object to a dict

2355

2047

server_settings = server_config.defaults()

2356

2048

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

2357

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

2049

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

2358

2050

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

2359

2051

option)

2360

2052

if server_settings["port"]:

2361

2053

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

2362

2054

"port")

2363

if server_settings["socket"]:

2364

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

2365

"socket")

2366

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

2367

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

2368

# happen with a supplied network socket.

2369

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

2370

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

2371

["socket"])

2372

2055

del server_config

2373

2056

2374

2057

# Override the settings from the config file with command line

2376

2059

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

2377

2060

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

2378

2061

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

2379

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

2062

"statedir"):

2380

2063

value = getattr(options, option)

2381

2064

if value is not None:

2382

2065

server_settings[option] = value

2385

2068

for option in server_settings.keys():

2386

2069

if type(server_settings[option]) is str:

2387

2070

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

2388

# Force all boolean options to be boolean

2389

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

2390

"foreground", "zeroconf"):

2391

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

2392

# Debug implies foreground

2393

if server_settings["debug"]:

2394

server_settings["foreground"] = True

2395

2071

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

2396

2072

2397

2073

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

2398

2074

2399

if (not server_settings["zeroconf"] and

2400

not (server_settings["port"]

2401

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

2402

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

2403

" Zeroconf")

2404

2405

2075

# For convenience

2406

2076

debug = server_settings["debug"]

2407

2077

debuglevel = server_settings["debuglevel"]

2409

2079

use_ipv6 = server_settings["use_ipv6"]

2410

2080

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

2411

2081

stored_state_file)

2412

foreground = server_settings["foreground"]

2413

zeroconf = server_settings["zeroconf"]

2414

2082

2415

2083

if debug:

2416

2084

initlogger(debug, logging.DEBUG)

2423

2091

2424

2092

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

2425

2093

syslogger.setFormatter(logging.Formatter

2426

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

2427

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

2428

.format(server_settings

2429

["servicename"])))

2094

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

2095

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

2096

% server_settings["servicename"]))

2430

2097

2431

2098

# Parse config file with clients

2432

2099

client_config = configparser.SafeConfigParser(Client

2437

2104

global mandos_dbus_service

2438

2105

mandos_dbus_service = None

2439

2106

2440

socketfd = None

2441

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

2442

socketfd = server_settings["socket"]

2443

2107

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

2444

2108

server_settings["port"]),

2445

2109

ClientHandler,

2448

2112

use_ipv6=use_ipv6,

2449

2113

gnutls_priority=

2450

2114

server_settings["priority"],

2451

use_dbus=use_dbus,

2452

socketfd=socketfd)

2453

if not foreground:

2454

pidfilename = "/run/mandos.pid"

2455

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

2456

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

2457

pidfile = None

2115

use_dbus=use_dbus)

2116

if not debug:

2117

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

2458

2118

try:

2459

2119

pidfile = open(pidfilename, "w")

2460

except IOError as e:

2461

logger.error("Could not open file %r", pidfilename,

2462

exc_info=e)

2120

except IOError:

2121

logger.error("Could not open file %r", pidfilename)

2463

2122

2464

for name in ("_mandos", "mandos", "nobody"):

2123

try:

2124

uid = pwd.getpwnam("_mandos").pw_uid

2125

gid = pwd.getpwnam("_mandos").pw_gid

2126

except KeyError:

2465

2127

try:

2466

uid = pwd.getpwnam(name).pw_uid

2467

gid = pwd.getpwnam(name).pw_gid

2468

break

2128

uid = pwd.getpwnam("mandos").pw_uid

2129

gid = pwd.getpwnam("mandos").pw_gid

2469

2130

except KeyError:

2470

continue

2471

else:

2472

uid = 65534

2473

gid = 65534

2131

try:

2132

uid = pwd.getpwnam("nobody").pw_uid

2133

gid = pwd.getpwnam("nobody").pw_gid

2134

except KeyError:

2135

uid = 65534

2136

gid = 65534

2474

2137

try:

2475

2138

os.setgid(gid)

2476

2139

os.setuid(uid)

2477

2140

except OSError as error:

2478

if error.errno != errno.EPERM:

2479

raise

2141

if error[0] != errno.EPERM:

2142

raise error

2480

2143

2481

2144

if debug:

2482

2145

# Enable all possible GnuTLS debugging

2493

2156

.gnutls_global_set_log_function(debug_gnutls))

2494

2157

2495

2158

# Redirect stdin so all checkers get /dev/null

2496

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

2159

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

2497

2160

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

2498

2161

if null > 2:

2499

2162

os.close(null)

2500

2163

2501

2164

# Need to fork before connecting to D-Bus

2502

if not foreground:

2165

if not debug:

2503

2166

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

2504

2167

daemon()

2505

2168

2506

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

2507

# need to inform gobject that threads will be used.

2508

2169

gobject.threads_init()

2509

2170

2510

2171

global main_loop

2511

2172

# From the Avahi example code

2512

DBusGMainLoop(set_as_default=True)

2173

DBusGMainLoop(set_as_default=True )

2513

2174

main_loop = gobject.MainLoop()

2514

2175

bus = dbus.SystemBus()

2515

2176

# End of Avahi example code

2521

2182

("se.bsnet.fukt.Mandos", bus,

2522

2183

do_not_queue=True))

2523

2184

except dbus.exceptions.NameExistsException as e:

2524

logger.error("Disabling D-Bus:", exc_info=e)

2185

logger.error(unicode(e) + ", disabling D-Bus")

2525

2186

use_dbus = False

2526

2187

server_settings["use_dbus"] = False

2527

2188

tcp_server.use_dbus = False

2528

if zeroconf:

2529

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2530

service = AvahiServiceToSyslog(name =

2531

server_settings["servicename"],

2532

servicetype = "_mandos._tcp",

2533

protocol = protocol, bus = bus)

2534

if server_settings["interface"]:

2535

service.interface = (if_nametoindex

2536

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

2189

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2190

service = AvahiServiceToSyslog(name =

2191

server_settings["servicename"],

2192

servicetype = "_mandos._tcp",

2193

protocol = protocol, bus = bus)

2194

if server_settings["interface"]:

2195

service.interface = (if_nametoindex

2196

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

2537

2197

2538

2198

global multiprocessing_manager

2539

2199

multiprocessing_manager = multiprocessing.Manager()

2540

2200

2541

2201

client_class = Client

2542

2202

if use_dbus:

2543

client_class = functools.partial(ClientDBus, bus = bus)

2203

client_class = functools.partial(ClientDBusTransitional,

2204

bus = bus)

2544

2205

2545

2206

client_settings = Client.config_parser(client_config)

2546

2207

old_client_settings = {}

2547

2208

clients_data = {}

2548

2209

2549

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

2550

global wnull

2551

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

2552

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

2553

# mode

2554

if debug or not foreground:

2555

wnull.close()

2556

2557

2210

# Get client data and settings from last running state.

2558

2211

if server_settings["restore"]:

2559

2212

try:

2562

2215

(stored_state))

2563

2216

os.remove(stored_state_path)

2564

2217

except IOError as e:

2565

if e.errno == errno.ENOENT:

2566

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

2567

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

2568

else:

2569

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

2570

exc_info=e)

2218

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

2219

.format(e))

2220

if e.errno != errno.ENOENT:

2571

2221

raise

2572

2222

except EOFError as e:

2573

2223

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

2574

"EOFError:", exc_info=e)

2224

"EOFError: {0}".format(e))

2575

2225

2576

2226

with PGPEngine() as pgp:

2577

for client_name, client in clients_data.items():

2578

# Skip removed clients

2579

if client_name not in client_settings:

2580

continue

2581

2227

for client_name, client in clients_data.iteritems():

2582

2228

# Decide which value to use after restoring saved state.

2583

2229

# We have three different values: Old config file,

2584

2230

# new config file, and saved state.

2605

2251

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

2606

2252

if not client["last_checked_ok"]:

2607

2253

logger.warning(

2608

"disabling client {} - Client never "

2254

"disabling client {0} - Client never "

2609

2255

"performed a successful checker"

2610

2256

.format(client_name))

2611

2257

client["enabled"] = False

2612

2258

elif client["last_checker_status"] != 0:

2613

2259

logger.warning(

2614

"disabling client {} - Client last"

2615

" checker failed with error code {}"

2260

"disabling client {0} - Client "

2261

"last checker failed with error code {1}"

2616

2262

.format(client_name,

2617

2263

client["last_checker_status"]))

2618

2264

client["enabled"] = False

2621

2267

.utcnow()

2622

2268

+ client["timeout"])

2623

2269

logger.debug("Last checker succeeded,"

2624

" keeping {} enabled"

2270

" keeping {0} enabled"

2625

2271

.format(client_name))

2626

2272

try:

2627

2273

client["secret"] = (

2630

2276

["secret"]))

2631

2277

except PGPError:

2632

2278

# If decryption fails, we use secret from new settings

2633

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

2279

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

2634

2280

.format(client_name))

2635

2281

client["secret"] = (

2636

2282

client_settings[client_name]["secret"])

2283

2637

2284

2638

2285

# Add/remove clients based on new changes made to config

2639

2286

for client_name in (set(old_client_settings)

2642

2289

for client_name in (set(client_settings)

2643

2290

- set(old_client_settings)):

2644

2291

clients_data[client_name] = client_settings[client_name]

2645

2292

2646

2293

# Create all client objects

2647

for client_name, client in clients_data.items():

2294

for client_name, client in clients_data.iteritems():

2648

2295

tcp_server.clients[client_name] = client_class(

2649

name = client_name, settings = client,

2650

server_settings = server_settings)

2296

name = client_name, settings = client)

2651

2297

2652

2298

if not tcp_server.clients:

2653

2299

logger.warning("No clients defined")

2654

2655

if not foreground:

2656

if pidfile is not None:

2657

try:

2658

with pidfile:

2659

pid = os.getpid()

2660

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

2661

except IOError:

2662

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

2663

pidfilename, pid)

2664

del pidfile

2300

2301

if not debug:

2302

try:

2303

with pidfile:

2304

pid = os.getpid()

2305

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

2306

del pidfile

2307

except IOError:

2308

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

2309

pidfilename, pid)

2310

except NameError:

2311

# "pidfile" was never created

2312

pass

2665

2313

del pidfilename

2314

signal.signal(signal.SIGINT, signal.SIG_IGN)

2666

2315

2667

2316

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

2668

2317

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

2669

2318

2670

2319

if use_dbus:

2671

@alternate_dbus_interfaces({"se.recompile.Mandos":

2672

"se.bsnet.fukt.Mandos"})

2673

class MandosDBusService(DBusObjectWithProperties):

2320

class MandosDBusService(dbus.service.Object):

2674

2321

"""A D-Bus proxy object"""

2675

2322

def __init__(self):

2676

2323

dbus.service.Object.__init__(self, bus, "/")

2677

2324

_interface = "se.recompile.Mandos"

2678

2325

2679

@dbus_interface_annotations(_interface)

2680

def _foo(self):

2681

return { "org.freedesktop.DBus.Property"

2682

".EmitsChangedSignal":

2683

"false"}

2684

2685

2326

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

2686

2327

def ClientAdded(self, objpath):

2687

2328

"D-Bus signal"

2729

2370

2730

2371

del _interface

2731

2372

2732

mandos_dbus_service = MandosDBusService()

2373

class MandosDBusServiceTransitional(MandosDBusService):

2374

__metaclass__ = AlternateDBusNamesMetaclass

2375

mandos_dbus_service = MandosDBusServiceTransitional()

2733

2376

2734

2377

def cleanup():

2735

2378

"Cleanup function; run on exit"

2736

if zeroconf:

2737

service.cleanup()

2379

service.cleanup()

2738

2380

2739

2381

multiprocessing.active_children()

2740

wnull.close()

2741

2382

if not (tcp_server.clients or client_settings):

2742

2383

return

2743

2384

2754

2395

2755

2396

# A list of attributes that can not be pickled

2756

2397

# + secret.

2757

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

2758

"checker", "server_settings" }

2398

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

2399

"checker"))

2759

2400

for name, typ in (inspect.getmembers

2760

2401

(dbus.service.Object)):

2761

2402

exclude.add(name)

2770

2411

del client_settings[client.name]["secret"]

2771

2412

2772

2413

try:

2773

with (tempfile.NamedTemporaryFile

2774

(mode='wb', suffix=".pickle", prefix='clients-',

2775

dir=os.path.dirname(stored_state_path),

2776

delete=False)) as stored_state:

2414

tempfd, tempname = tempfile.mkstemp(suffix=".pickle",

2415

prefix="clients-",

2416

dir=os.path.dirname

2417

(stored_state_path))

2418

with os.fdopen(tempfd, "wb") as stored_state:

2777

2419

pickle.dump((clients, client_settings), stored_state)

2778

tempname=stored_state.name

2779

2420

os.rename(tempname, stored_state_path)

2780

2421

except (IOError, OSError) as e:

2422

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

2423

.format(e))

2781

2424

if not debug:

2782

2425

try:

2783

2426

os.remove(tempname)

2784

2427

except NameError:

2785

2428

pass

2786

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

2787

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

2788

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

2789

else:

2790

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

2791

exc_info=e)

2792

raise

2429

if e.errno not in set((errno.ENOENT, errno.EACCES,

2430

errno.EEXIST)):

2431

raise e

2793

2432

2794

2433

# Delete all clients, and settings from config

2795

2434

while tcp_server.clients:

2819

2458

tcp_server.server_activate()

2820

2459

2821

2460

# Find out what port we got

2822

if zeroconf:

2823

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

2461

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

2824

2462

if use_ipv6:

2825

2463

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

2826

" flowinfo %d, scope_id %d",

2827

*tcp_server.socket.getsockname())

2464

" flowinfo %d, scope_id %d"

2465

% tcp_server.socket.getsockname())

2828

2466

else: # IPv4

2829

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

2830

*tcp_server.socket.getsockname())

2467

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

2468

% tcp_server.socket.getsockname())

2831

2469

2832

2470

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

2833

2471

2834

2472

try:

2835

if zeroconf:

2836

# From the Avahi example code

2837

try:

2838

service.activate()

2839

except dbus.exceptions.DBusException as error:

2840

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

2841

cleanup()

2842

sys.exit(1)

2843

# End of Avahi example code

2473

# From the Avahi example code

2474

try:

2475

service.activate()

2476

except dbus.exceptions.DBusException as error:

2477

logger.critical("DBusException: %s", error)

2478

cleanup()

2479

sys.exit(1)

2480

# End of Avahi example code

2844

2481

2845

2482

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

2846

2483

lambda *args, **kwargs:

2850

2487

logger.debug("Starting main loop")

2851

2488

main_loop.run()

2852

2489

except AvahiError as error:

2853

logger.critical("Avahi Error", exc_info=error)

2490

logger.critical("AvahiError: %s", error)

2854

2491

cleanup()

2855

2492

sys.exit(1)

2856

2493

except KeyboardInterrupt: