/mandos/trunk : revision 237.4.53

1

#!/usr/bin/python

1

#!/usr/bin/python2.7

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

37

39

import SocketServer as socketserver

38

40

import socket

39

41

import argparse

65

67

import types

66

68

import binascii

67

69

import tempfile

70

import itertools

71

import collections

68

72

69

73

import dbus

70

74

import dbus.service

75

79

import ctypes.util

76

80

import xml.dom.minidom

77

81

import inspect

78

import GnuPGInterface

79

82

80

83

try:

81

84

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

85

88

except ImportError:

86

89

SO_BINDTODEVICE = None

87

90

88

version = "1.5.2"

91

version = "1.6.8"

89

92

stored_state_file = "clients.pickle"

90

93

91

94

logger = logging.getLogger()

92

syslogger = (logging.handlers.SysLogHandler

93

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

94

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

95

syslogger = None

95

96

97

try:

97

98

if_nametoindex = (ctypes.cdll.LoadLibrary

113

114

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

114

115

"""init logger and add loglevel"""

115

116

117

global syslogger

118

syslogger = (logging.handlers.SysLogHandler

119

(facility =

120

logging.handlers.SysLogHandler.LOG_DAEMON,

121

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

116

122

syslogger.setFormatter(logging.Formatter

117

123

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

118

124

' %(message)s'))

136

142

class PGPEngine(object):

137

143

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

138

144

def __init__(self):

139

self.gnupg = GnuPGInterface.GnuPG()

140

145

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

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

146

self.gnupgargs = ['--batch',

147

'--home', self.tempdir,

148

'--force-mdc',

149

'--quiet',

150

'--no-use-agent']

147

151

148

152

def __enter__(self):

149

153

return self

150

154

151

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

155

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

152

156

self._cleanup()

153

157

return False

154

158

171

175

def password_encode(self, password):

172

176

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

173

177

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

174

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

178

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

179

if len(encoded) > 2048:

180

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

181

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

182

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

183

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

184

return encoded

175

185

176

186

def encrypt(self, data, password):

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

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)

191

202

return ciphertext

192

203

193

204

def decrypt(self, data, password):

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

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)

208

221

return decrypted_plaintext

209

222

210

223

211

212

224

class AvahiError(Exception):

213

225

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

214

226

self.value = value

231

243

Used to optionally bind to the specified interface.

232

244

name: string; Example: 'Mandos'

233

245

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

234

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

246

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

235

247

port: integer; what port to announce

236

248

TXT: list of strings; TXT record for the service

237

249

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

243

255

server: D-Bus Server

244

256

bus: dbus.SystemBus()

245

257

"""

258

246

259

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

247

260

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

248

261

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

261

274

self.server = None

262

275

self.bus = bus

263

276

self.entry_group_state_changed_match = None

277

264

278

def rename(self):

265

279

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

266

280

if self.rename_count >= self.max_renames:

276

290

try:

277

291

self.add()

278

292

except dbus.exceptions.DBusException as error:

279

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

293

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

280

294

self.cleanup()

281

295

os._exit(1)

282

296

self.rename_count += 1

297

283

298

def remove(self):

284

299

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

285

300

if self.entry_group_state_changed_match is not None:

287

302

self.entry_group_state_changed_match = None

288

303

if self.group is not None:

289

304

self.group.Reset()

305

290

306

def add(self):

291

307

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

292

308

self.remove()

309

325

dbus.UInt16(self.port),

310

326

avahi.string_array_to_txt_array(self.TXT))

311

327

self.group.Commit()

328

312

329

def entry_group_state_changed(self, state, error):

313

330

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

314

331

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

321

338

elif state == avahi.ENTRY_GROUP_FAILURE:

322

339

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

323

340

unicode(error))

324

raise AvahiGroupError("State changed: %s"

325

% unicode(error))

341

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

342

.format(error))

343

326

344

def cleanup(self):

327

345

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

328

346

if self.group is not None:

333

351

pass

334

352

self.group = None

335

353

self.remove()

354

336

355

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

337

356

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

338

357

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

357

376

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

358

377

else:

359

378

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

379

360

380

def activate(self):

361

381

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

362

382

if self.server is None:

369

389

self.server_state_changed)

370

390

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

371

391

392

372

393

class AvahiServiceToSyslog(AvahiService):

373

394

def rename(self):

374

395

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

375

396

ret = AvahiService.rename(self)

376

397

syslogger.setFormatter(logging.Formatter

377

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

378

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

379

% self.name))

398

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

399

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

400

.format(self.name)))

380

401

return ret

381

402

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

403

388

404

class Client(object):

389

405

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

390

406

415

431

last_checked_ok: datetime.datetime(); (UTC) or None

416

432

last_checker_status: integer between 0 and 255 reflecting exit

417

433

status of last checker. -1 reflects crashed

418

checker, or None.

434

checker, -2 means no checker completed yet.

419

435

last_enabled: datetime.datetime(); (UTC) or None

420

436

name: string; from the config file, used in log messages and

421

437

D-Bus identifiers

426

442

runtime_expansions: Allowed attributes for runtime expansion.

427

443

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

428

444

disabled, or None

445

server_settings: The server_settings dict from main()

429

446

"""

430

447

431

448

runtime_expansions = ("approval_delay", "approval_duration",

432

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

433

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

449

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

450

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

451

"last_approval_request", "last_checked_ok",

434

452

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

435

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

436

"extended_timeout": "15m",

437

"interval": "2m",

453

client_defaults = { "timeout": "PT5M",

454

"extended_timeout": "PT15M",

455

"interval": "PT2M",

438

456

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

439

457

"host": "",

440

"approval_delay": "0s",

441

"approval_duration": "1s",

458

"approval_delay": "PT0S",

459

"approval_duration": "PT1S",

442

460

"approved_by_default": "True",

443

461

"enabled": "True",

444

462

}

445

463

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

461

464

@staticmethod

462

465

def config_parser(config):

463

466

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

488

491

"rb") as secfile:

489

492

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

490

493

else:

491

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

492

% section)

494

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

495

.format(section))

493

496

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

494

497

client["extended_timeout"] = string_to_delta(

495

498

section["extended_timeout"])

501

504

client["checker_command"] = section["checker"]

502

505

client["last_approval_request"] = None

503

506

client["last_checked_ok"] = None

504

client["last_checker_status"] = None

507

client["last_checker_status"] = -2

505

508

506

509

return settings

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

510

511

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

513

512

self.name = name

513

if server_settings is None:

514

server_settings = {}

515

self.server_settings = server_settings

514

516

# adding all client settings

515

for setting, value in settings.iteritems():

517

for setting, value in settings.items():

516

518

setattr(self, setting, value)

517

519

518

520

if self.enabled:

524

526

else:

525

527

self.last_enabled = None

526

528

self.expires = None

527

529

528

530

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

529

531

# Uppercase and remove spaces from fingerprint for later

530

532

# comparison purposes with return value from the fingerprint()

532

534

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

533

535

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

534

536

datetime.datetime.utcnow())

535

537

536

538

# attributes specific for this server instance

537

539

self.checker = None

538

540

self.checker_initiator_tag = None

566

568

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

567

569

# Already enabled

568

570

return

569

self.send_changedstate()

570

571

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

571

572

self.enabled = True

572

573

self.last_enabled = datetime.datetime.utcnow()

573

574

self.init_checker()

575

self.send_changedstate()

574

576

575

577

def disable(self, quiet=True):

576

578

"""Disable this client."""

577

579

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

578

580

return False

579

581

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", False):

583

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

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", False):

587

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

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

592

594

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

593

595

return False

594

596

598

600

def init_checker(self):

599

601

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

600

602

# and every interval from then on.

603

if self.checker_initiator_tag is not None:

604

gobject.source_remove(self.checker_initiator_tag)

601

605

self.checker_initiator_tag = (gobject.timeout_add

602

(self.interval_milliseconds(),

606

(int(self.interval

607

.total_seconds() * 1000),

603

608

self.start_checker))

604

609

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

610

if self.disable_initiator_tag is not None:

611

gobject.source_remove(self.disable_initiator_tag)

605

612

self.disable_initiator_tag = (gobject.timeout_add

606

(self.timeout_milliseconds(),

607

self.disable))

613

(int(self.timeout

614

.total_seconds() * 1000),

615

self.disable))

608

616

# Also start a new checker *right now*.

609

617

self.start_checker()

610

618

626

634

logger.warning("Checker for %(name)s crashed?",

627

635

vars(self))

628

636

629

def checked_ok(self, timeout=None):

630

"""Bump up the timeout for this client.

631

632

This should only be called when the client has been seen,

633

alive and well.

634

"""

637

def checked_ok(self):

638

"""Assert that the client has been seen, alive and well."""

639

self.last_checked_ok = datetime.datetime.utcnow()

640

self.last_checker_status = 0

641

self.bump_timeout()

642

643

def bump_timeout(self, timeout=None):

644

"""Bump up the timeout for this client."""

635

645

if timeout is None:

636

646

timeout = self.timeout

637

self.last_checked_ok = datetime.datetime.utcnow()

638

647

if self.disable_initiator_tag is not None:

639

648

gobject.source_remove(self.disable_initiator_tag)

649

self.disable_initiator_tag = None

640

650

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

641

651

self.disable_initiator_tag = (gobject.timeout_add

642

(timedelta_to_milliseconds

643

(timeout), self.disable))

652

(int(timeout.total_seconds()

653

* 1000), self.disable))

644

654

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

645

655

646

656

def need_approval(self):

652

662

If a checker already exists, leave it running and do

653

663

nothing."""

654

664

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

655

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

656

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

657

# client would inevitably timeout, since no checker would get

658

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

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

659

669

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

660

670

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

661

671

# should be.

663

673

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

664

674

try:

665

675

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

666

except (AttributeError, OSError) as error:

667

if (isinstance(error, OSError)

668

and error.errno != errno.ECHILD):

669

raise error

676

except AttributeError:

677

pass

678

except OSError as error:

679

if error.errno != errno.ECHILD:

680

raise

670

681

else:

671

682

if pid:

672

683

logger.warning("Checker was a zombie")

675

686

self.current_checker_command)

676

687

# Start a new checker if needed

677

688

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 }

678

694

try:

679

# In case checker_command has exactly one % operator

680

command = self.checker_command % self.host

681

except TypeError:

682

# Escape attributes for the shell

683

escaped_attrs = dict(

684

(attr,

685

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

686

errors=

687

'replace')))

688

for attr in

689

self.runtime_expansions)

690

691

try:

692

command = self.checker_command % escaped_attrs

693

except TypeError as error:

694

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

695

' %s', self.checker_command, error)

696

return True # Try again later

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

697

700

self.current_checker_command = command

698

701

try:

699

702

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

702

705

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

703

706

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

704

707

# 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 })

705

716

self.checker = subprocess.Popen(command,

706

717

close_fds=True,

707

shell=True, cwd="/")

708

self.checker_callback_tag = (gobject.child_watch_add

709

(self.checker.pid,

710

self.checker_callback,

711

data=command))

712

# The checker may have completed before the gobject

713

# watch was added. Check for this.

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:

714

731

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

715

if pid:

716

gobject.source_remove(self.checker_callback_tag)

717

self.checker_callback(pid, status, command)

718

732

except OSError as error:

719

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

720

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)

721

742

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

722

743

return True

723

744

730

751

return

731

752

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

732

753

try:

733

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

754

self.checker.terminate()

734

755

#time.sleep(0.5)

735

756

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

736

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

757

# self.checker.kill()

737

758

except OSError as error:

738

759

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

739

760

raise

756

777

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

757

778

if byte_arrays and signature != "ay":

758

779

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

759

" signature %r" % signature)

780

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

760

781

def decorator(func):

761

782

func._dbus_is_property = True

762

783

func._dbus_interface = dbus_interface

770

791

return decorator

771

792

772

793

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

773

831

class DBusPropertyException(dbus.exceptions.DBusException):

774

832

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

775

833

"""

798

856

"""

799

857

800

858

@staticmethod

801

def _is_dbus_property(obj):

802

return getattr(obj, "_dbus_is_property", False)

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)

803

867

804

def _get_all_dbus_properties(self):

868

def _get_all_dbus_things(self, thing):

805

869

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

806

870

"""

807

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

871

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

872

name),

873

athing.__get__(self))

808

874

for cls in self.__class__.__mro__

809

for name, prop in

810

inspect.getmembers(cls, self._is_dbus_property))

875

for name, athing in

876

inspect.getmembers(cls,

877

self._is_dbus_thing(thing)))

811

878

812

879

def _get_dbus_property(self, interface_name, property_name):

813

880

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

815

882

"""

816

883

for cls in self.__class__.__mro__:

817

884

for name, value in (inspect.getmembers

818

(cls, self._is_dbus_property)):

885

(cls,

886

self._is_dbus_thing("property"))):

819

887

if (value._dbus_name == property_name

820

888

and value._dbus_interface == interface_name):

821

889

return value.__get__(self)

849

917

# The byte_arrays option is not supported yet on

850

918

# signatures other than "ay".

851

919

if prop._dbus_signature != "ay":

852

raise ValueError

920

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

921

"'ay' signature {!r}"

922

.format(prop._dbus_signature))

853

923

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

854

924

for byte in value))

855

925

prop(value)

863

933

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

864

934

"""

865

935

properties = {}

866

for name, prop in self._get_all_dbus_properties():

936

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

867

937

if (interface_name

868

938

and interface_name != prop._dbus_interface):

869

939

# Interface non-empty but did not match

884

954

path_keyword='object_path',

885

955

connection_keyword='connection')

886

956

def Introspect(self, object_path, connection):

887

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

957

"""Overloading of standard D-Bus method.

958

959

Inserts property tags and interface annotation tags.

888

960

"""

889

961

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

890

962

connection)

897

969

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

898

970

return e

899

971

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

972

# Add property tags

900

973

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

901

974

for name, prop

902

in self._get_all_dbus_properties()

975

in self._get_all_dbus_things("property")

903

976

if prop._dbus_interface

904

977

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

905

978

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)

906

1010

# Add the names to the return values for the

907

1011

# "org.freedesktop.DBus.Properties" methods

908

1012

if (if_tag.getAttribute("name")

923

1027

except (AttributeError, xml.dom.DOMException,

924

1028

xml.parsers.expat.ExpatError) as error:

925

1029

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

926

error)

1030

exc_info=error)

927

1031

return xmlstring

928

1032

929

1033

930

def datetime_to_dbus (dt, variant_level=0):

1034

def datetime_to_dbus(dt, variant_level=0):

931

1035

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

932

1036

if dt is None:

933

1037

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

935

1039

variant_level=variant_level)

936

1040

937

1041

938

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

939

.__metaclass__):

940

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

941

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

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

942

1064

"""

943

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

944

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

945

# methods, signals, or properties in them

946

for base in (b for b in bases

947

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

948

# Go though all attributes of the base class

949

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

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

950

1072

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

951

1073

# with the wrong interface name

952

1074

if (not hasattr(attribute, "_dbus_interface")

953

1075

or not attribute._dbus_interface

954

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

1076

.startswith(orig_interface_name)):

955

1077

continue

956

1078

# Create an alternate D-Bus interface name based on

957

1079

# the current name

958

1080

alt_interface = (attribute._dbus_interface

959

.replace("se.recompile.Mandos",

960

"se.bsnet.fukt.Mandos"))

1081

.replace(orig_interface_name,

1082

alt_interface_name))

1083

interface_names.add(alt_interface)

961

1084

# Is this a D-Bus signal?

962

1085

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

963

# Extract the original non-method function by

964

# black magic

1086

# Extract the original non-method undecorated

1087

# function by black magic

965

1088

nonmethod_func = (dict(

966

1089

zip(attribute.func_code.co_freevars,

967

1090

attribute.__closure__))["func"]

978

1101

nonmethod_func.func_name,

979

1102

nonmethod_func.func_defaults,

980

1103

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

981

1110

# Define a creator of a function to call both the

982

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

983

# signals gets sent when the function is called

1111

# original and alternate functions, so both the

1112

# original and alternate signals gets sent when

1113

# the function is called

984

1114

def fixscope(func1, func2):

985

1115

"""This function is a scope container to pass

986

1116

func1 and func2 to the "call_both" function

993

1123

return call_both

994

1124

# Create the "call_both" function and add it to

995

1125

# the class

996

attr[attrname] = fixscope(attribute,

997

new_function)

1126

attr[attrname] = fixscope(attribute, new_function)

998

1127

# Is this a D-Bus method?

999

1128

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

1000

1129

# Create a new, but exactly alike, function

1011

1140

attribute.func_name,

1012

1141

attribute.func_defaults,

1013

1142

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

1014

1149

# Is this a D-Bus property?

1015

1150

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

1016

1151

# Create a new, but exactly alike, function

1030

1165

attribute.func_name,

1031

1166

attribute.func_defaults,

1032

1167

attribute.func_closure)))

1033

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

1034

1035

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

1036

1213

class ClientDBus(Client, DBusObjectWithProperties):

1037

1214

"""A Client class using D-Bus

1038

1215

1058

1235

("/clients/" + client_object_name))

1059

1236

DBusObjectWithProperties.__init__(self, self.bus,

1060

1237

self.dbus_object_path)

1061

1238

1062

1239

def notifychangeproperty(transform_func,

1063

1240

dbus_name, type_func=lambda x: x,

1064

1241

variant_level=1):

1072

1249

to the D-Bus. Default: no transform

1073

1250

variant_level: D-Bus variant level. Default: 1

1074

1251

"""

1075

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

1252

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

1076

1253

def setter(self, value):

1077

1254

if hasattr(self, "dbus_object_path"):

1078

1255

if (not hasattr(self, attrname) or

1087

1264

1088

1265

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

1089

1266

1090

1091

1267

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1092

1268

approvals_pending = notifychangeproperty(dbus.Boolean,

1093

1269

"ApprovalPending",

1100

1276

checker is not None)

1101

1277

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1102

1278

"LastCheckedOK")

1279

last_checker_status = notifychangeproperty(dbus.Int16,

1280

"LastCheckerStatus")

1103

1281

last_approval_request = notifychangeproperty(

1104

1282

datetime_to_dbus, "LastApprovalRequest")

1105

1283

approved_by_default = notifychangeproperty(dbus.Boolean,

1107

1285

approval_delay = notifychangeproperty(dbus.UInt64,

1108

1286

"ApprovalDelay",

1109

1287

type_func =

1110

timedelta_to_milliseconds)

1288

lambda td: td.total_seconds()

1289

* 1000)

1111

1290

approval_duration = notifychangeproperty(

1112

1291

dbus.UInt64, "ApprovalDuration",

1113

type_func = timedelta_to_milliseconds)

1292

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

1114

1293

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

1115

1294

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

1116

type_func =

1117

timedelta_to_milliseconds)

1295

type_func = lambda td:

1296

td.total_seconds() * 1000)

1118

1297

extended_timeout = notifychangeproperty(

1119

1298

dbus.UInt64, "ExtendedTimeout",

1120

type_func = timedelta_to_milliseconds)

1299

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

1121

1300

interval = notifychangeproperty(dbus.UInt64,

1122

1301

"Interval",

1123

1302

type_func =

1124

timedelta_to_milliseconds)

1303

lambda td: td.total_seconds()

1304

* 1000)

1125

1305

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

1126

1306

1127

1307

del notifychangeproperty

1155

1335

*args, **kwargs)

1156

1336

1157

1337

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

1158

old_checker = self.checker

1159

if self.checker is not None:

1160

old_checker_pid = self.checker.pid

1161

else:

1162

old_checker_pid = None

1338

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

1163

1339

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

1164

1340

# Only if new checker process was started

1165

1341

if (self.checker is not None

1173

1349

return False

1174

1350

1175

1351

def approve(self, value=True):

1176

self.send_changedstate()

1177

1352

self.approved = value

1178

gobject.timeout_add(timedelta_to_milliseconds

1179

(self.approval_duration),

1180

self._reset_approved)

1181

1353

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

1354

* 1000), self._reset_approved)

1355

self.send_changedstate()

1182

1356

1183

1357

## D-Bus methods, signals & properties

1184

1358

_interface = "se.recompile.Mandos.Client"

1185

1359

1360

## Interfaces

1361

1362

@dbus_interface_annotations(_interface)

1363

def _foo(self):

1364

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

1365

"false"}

1366

1186

1367

## Signals

1187

1368

1188

1369

# CheckerCompleted - signal

1279

1460

access="readwrite")

1280

1461

def ApprovalDelay_dbus_property(self, value=None):

1281

1462

if value is None: # get

1282

return dbus.UInt64(self.approval_delay_milliseconds())

1463

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

1464

* 1000)

1283

1465

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

1284

1466

1285

1467

# ApprovalDuration - property

1287

1469

access="readwrite")

1288

1470

def ApprovalDuration_dbus_property(self, value=None):

1289

1471

if value is None: # get

1290

return dbus.UInt64(timedelta_to_milliseconds(

1291

self.approval_duration))

1472

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

1473

* 1000)

1292

1474

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

1293

1475

1294

1476

# Name - property

1339

1521

return

1340

1522

return datetime_to_dbus(self.last_checked_ok)

1341

1523

1524

# LastCheckerStatus - property

1525

@dbus_service_property(_interface, signature="n",

1526

access="read")

1527

def LastCheckerStatus_dbus_property(self):

1528

return dbus.Int16(self.last_checker_status)

1529

1342

1530

# Expires - property

1343

1531

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

1344

1532

def Expires_dbus_property(self):

1354

1542

access="readwrite")

1355

1543

def Timeout_dbus_property(self, value=None):

1356

1544

if value is None: # get

1357

return dbus.UInt64(self.timeout_milliseconds())

1545

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

1546

old_timeout = self.timeout

1358

1547

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

1359

# Reschedule timeout

1548

# Reschedule disabling

1360

1549

if self.enabled:

1361

1550

now = datetime.datetime.utcnow()

1362

time_to_die = timedelta_to_milliseconds(

1363

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

1364

if time_to_die <= 0:

1551

self.expires += self.timeout - old_timeout

1552

if self.expires <= now:

1365

1553

# The timeout has passed

1366

1554

self.disable()

1367

1555

else:

1368

self.expires = (now +

1369

datetime.timedelta(milliseconds =

1370

time_to_die))

1371

1556

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

1372

1557

is None):

1373

1558

return

1374

1559

gobject.source_remove(self.disable_initiator_tag)

1375

self.disable_initiator_tag = (gobject.timeout_add

1376

(time_to_die,

1377

self.disable))

1560

self.disable_initiator_tag = (

1561

gobject.timeout_add(

1562

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

1563

* 1000), self.disable))

1378

1564

1379

1565

# ExtendedTimeout - property

1380

1566

@dbus_service_property(_interface, signature="t",

1381

1567

access="readwrite")

1382

1568

def ExtendedTimeout_dbus_property(self, value=None):

1383

1569

if value is None: # get

1384

return dbus.UInt64(self.extended_timeout_milliseconds())

1570

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

1571

* 1000)

1385

1572

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

1386

1573

1387

1574

# Interval - property

1389

1576

access="readwrite")

1390

1577

def Interval_dbus_property(self, value=None):

1391

1578

if value is None: # get

1392

return dbus.UInt64(self.interval_milliseconds())

1579

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

1393

1580

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

1394

1581

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

1395

1582

return

1459

1646

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

1460

1647

1461

1648

1462

class ClientDBusTransitional(ClientDBus):

1463

__metaclass__ = AlternateDBusNamesMetaclass

1464

1465

1466

1649

class ClientHandler(socketserver.BaseRequestHandler, object):

1467

1650

"""A class to handle client connections.

1468

1651

1504

1687

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

1505

1688

try:

1506

1689

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

1507

raise RuntimeError

1690

raise RuntimeError(line)

1508

1691

except (ValueError, IndexError, RuntimeError) as error:

1509

1692

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

1510

1693

return

1559

1742

if self.server.use_dbus:

1560

1743

# Emit D-Bus signal

1561

1744

client.NeedApproval(

1562

client.approval_delay_milliseconds(),

1563

client.approved_by_default)

1745

client.approval_delay.total_seconds()

1746

* 1000, client.approved_by_default)

1564

1747

else:

1565

1748

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

1566

1749

client.name)

1572

1755

#wait until timeout or approved

1573

1756

time = datetime.datetime.now()

1574

1757

client.changedstate.acquire()

1575

(client.changedstate.wait

1576

(float(client.timedelta_to_milliseconds(delay)

1577

/ 1000)))

1758

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

1578

1759

client.changedstate.release()

1579

1760

time2 = datetime.datetime.now()

1580

1761

if (time2 - time) >= delay:

1596

1777

try:

1597

1778

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

1598

1779

except gnutls.errors.GNUTLSError as error:

1599

logger.warning("gnutls send failed")

1780

logger.warning("gnutls send failed",

1781

exc_info=error)

1600

1782

return

1601

1783

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

1602

1784

sent, len(client.secret)

1605

1787

1606

1788

logger.info("Sending secret to %s", client.name)

1607

1789

# bump the timeout using extended_timeout

1608

client.checked_ok(client.extended_timeout)

1790

client.bump_timeout(client.extended_timeout)

1609

1791

if self.server.use_dbus:

1610

1792

# Emit D-Bus signal

1611

1793

client.GotSecret()

1616

1798

try:

1617

1799

session.bye()

1618

1800

except gnutls.errors.GNUTLSError as error:

1619

logger.warning("GnuTLS bye failed")

1801

logger.warning("GnuTLS bye failed",

1802

exc_info=error)

1620

1803

1621

1804

@staticmethod

1622

1805

def peer_certificate(session):

1694

1877

def process_request(self, request, address):

1695

1878

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

1696

1879

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

1697

args = (request,

1698

address))

1880

args = (request, address))

1699

1881

proc.start()

1700

1882

return proc

1701

1883

1716

1898

1717

1899

def add_pipe(self, parent_pipe, proc):

1718

1900

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

1719

raise NotImplementedError

1901

raise NotImplementedError()

1720

1902

1721

1903

1722

1904

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1729

1911

use_ipv6: Boolean; to use IPv6 or not

1730

1912

"""

1731

1913

def __init__(self, server_address, RequestHandlerClass,

1732

interface=None, use_ipv6=True):

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

"""

1733

1918

self.interface = interface

1734

1919

if use_ipv6:

1735

1920

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.

1736

1947

socketserver.TCPServer.__init__(self, server_address,

1737

1948

RequestHandlerClass)

1949

1738

1950

def server_bind(self):

1739

1951

"""This overrides the normal server_bind() function

1740

1952

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

1748

1960

try:

1749

1961

self.socket.setsockopt(socket.SOL_SOCKET,

1750

1962

SO_BINDTODEVICE,

1751

str(self.interface

1752

+ '\0'))

1963

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

1753

1964

except socket.error as error:

1754

if error[0] == errno.EPERM:

1755

logger.error("No permission to"

1756

" bind to interface %s",

1757

self.interface)

1758

elif error[0] == errno.ENOPROTOOPT:

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:

1759

1969

logger.error("SO_BINDTODEVICE not available;"

1760

1970

" cannot bind to interface %s",

1761

1971

self.interface)

1972

elif error.errno == errno.ENODEV:

1973

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

1974

" cannot bind", self.interface)

1762

1975

else:

1763

1976

raise

1764

1977

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

1767

1980

if self.address_family == socket.AF_INET6:

1768

1981

any_address = "::" # in6addr_any

1769

1982

else:

1770

any_address = socket.INADDR_ANY

1983

any_address = "0.0.0.0" # INADDR_ANY

1771

1984

self.server_address = (any_address,

1772

1985

self.server_address[1])

1773

1986

elif not self.server_address[1]:

1794

2007

"""

1795

2008

def __init__(self, server_address, RequestHandlerClass,

1796

2009

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

1797

gnutls_priority=None, use_dbus=True):

2010

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

1798

2011

self.enabled = False

1799

2012

self.clients = clients

1800

2013

if self.clients is None:

1804

2017

IPv6_TCPServer.__init__(self, server_address,

1805

2018

RequestHandlerClass,

1806

2019

interface = interface,

1807

use_ipv6 = use_ipv6)

2020

use_ipv6 = use_ipv6,

2021

socketfd = socketfd)

1808

2022

def server_activate(self):

1809

2023

if self.enabled:

1810

2024

return socketserver.TCPServer.server_activate(self)

1823

2037

1824

2038

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

1825

2039

proc = None, client_object=None):

1826

condition_names = {

1827

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

1828

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

1829

# blocking).

1830

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

1831

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

1832

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

1833

# broken, usually for pipes and

1834

# sockets).

1835

}

1836

conditions_string = ' | '.join(name

1837

for cond, name in

1838

condition_names.iteritems()

1839

if cond & condition)

1840

2040

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

1841

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

2041

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

1842

2042

# Wait for other process to exit

1843

2043

proc.join()

1844

2044

return False

1902

2102

return True

1903

2103

1904

2104

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

1905

2204

def string_to_delta(interval):

1906

2205

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

1907

2206

1918

2217

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

1919

2218

datetime.timedelta(0, 330)

1920

2219

"""

2220

2221

try:

2222

return rfc3339_duration_to_delta(interval)

2223

except ValueError:

2224

pass

2225

1921

2226

timevalue = datetime.timedelta(0)

1922

2227

for s in interval.split():

1923

2228

try:

1934

2239

elif suffix == "w":

1935

2240

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

1936

2241

else:

1937

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

1938

except (ValueError, IndexError) as e:

2242

raise ValueError("Unknown suffix {!r}"

2243

.format(suffix))

2244

except IndexError as e:

1939

2245

raise ValueError(*(e.args))

1940

2246

timevalue += delta

1941

2247

return timevalue

1954

2260

sys.exit()

1955

2261

if not noclose:

1956

2262

# Close all standard open file descriptors

1957

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

2263

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

1958

2264

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

1959

raise OSError(errno.ENODEV,

1960

"%s not a character device"

1961

% os.path.devnull)

2265

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

2266

.format(os.devnull))

1962

2267

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

1963

2268

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

1964

2269

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

1973

2278

1974

2279

parser = argparse.ArgumentParser()

1975

2280

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

1976

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

2281

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

1977

2282

help="show version number and exit")

1978

2283

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

1979

2284

help="Bind to interface IF")

1985

2290

help="Run self-test")

1986

2291

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

1987

2292

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

1988

" to terminal")

2293

" to terminal", default=None)

1989

2294

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

1990

2295

help="Debug level for stdout output")

1991

2296

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

1998

2303

" files")

1999

2304

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

2000

2305

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

2001

" system bus interface")

2306

" system bus interface", default=None)

2002

2307

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

2003

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

2308

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

2309

default=None)

2004

2310

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

2005

2311

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

2006

" state")

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

2007

2316

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

2008

2317

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)

2009

2323

2010

2324

options = parser.parse_args()

2011

2325

2012

2326

if options.check:

2013

2327

import doctest

2014

doctest.testmod()

2015

sys.exit()

2328

fail_count, test_count = doctest.testmod()

2329

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

2016

2330

2017

2331

# Default values for config file for server-global settings

2018

2332

server_defaults = { "interface": "",

2020

2334

"port": "",

2021

2335

"debug": "False",

2022

2336

"priority":

2023

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

2337

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

2024

2338

"servicename": "Mandos",

2025

2339

"use_dbus": "True",

2026

2340

"use_ipv6": "True",

2027

2341

"debuglevel": "",

2028

2342

"restore": "True",

2029

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

2343

"socket": "",

2344

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

2345

"foreground": "False",

2346

"zeroconf": "True",

2030

2347

}

2031

2348

2032

2349

# Parse config file for server-global settings

2037

2354

# Convert the SafeConfigParser object to a dict

2038

2355

server_settings = server_config.defaults()

2039

2356

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

2040

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

2357

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

2041

2358

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

2042

2359

option)

2043

2360

if server_settings["port"]:

2044

2361

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

2045

2362

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

2046

2372

del server_config

2047

2373

2048

2374

# Override the settings from the config file with command line

2050

2376

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

2051

2377

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

2052

2378

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

2053

"statedir"):

2379

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

2054

2380

value = getattr(options, option)

2055

2381

if value is not None:

2056

2382

server_settings[option] = value

2059

2385

for option in server_settings.keys():

2060

2386

if type(server_settings[option]) is str:

2061

2387

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

2062

2395

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

2063

2396

2064

2397

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

2065

2398

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

2066

2405

# For convenience

2067

2406

debug = server_settings["debug"]

2068

2407

debuglevel = server_settings["debuglevel"]

2070

2409

use_ipv6 = server_settings["use_ipv6"]

2071

2410

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

2072

2411

stored_state_file)

2412

foreground = server_settings["foreground"]

2413

zeroconf = server_settings["zeroconf"]

2073

2414

2074

2415

if debug:

2075

2416

initlogger(debug, logging.DEBUG)

2082

2423

2083

2424

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

2084

2425

syslogger.setFormatter(logging.Formatter

2085

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

2086

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

2087

% server_settings["servicename"]))

2426

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

2427

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

2428

.format(server_settings

2429

["servicename"])))

2088

2430

2089

2431

# Parse config file with clients

2090

2432

client_config = configparser.SafeConfigParser(Client

2095

2437

global mandos_dbus_service

2096

2438

mandos_dbus_service = None

2097

2439

2440

socketfd = None

2441

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

2442

socketfd = server_settings["socket"]

2098

2443

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

2099

2444

server_settings["port"]),

2100

2445

ClientHandler,

2103

2448

use_ipv6=use_ipv6,

2104

2449

gnutls_priority=

2105

2450

server_settings["priority"],

2106

use_dbus=use_dbus)

2107

if not debug:

2108

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

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

2109

2458

try:

2110

2459

pidfile = open(pidfilename, "w")

2111

except IOError:

2112

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

2460

except IOError as e:

2461

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

2462

exc_info=e)

2113

2463

2114

try:

2115

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

2116

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

2117

except KeyError:

2464

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

2118

2465

try:

2119

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

2120

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

2466

uid = pwd.getpwnam(name).pw_uid

2467

gid = pwd.getpwnam(name).pw_gid

2468

break

2121

2469

except KeyError:

2122

try:

2123

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

2124

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

2125

except KeyError:

2126

uid = 65534

2127

gid = 65534

2470

continue

2471

else:

2472

uid = 65534

2473

gid = 65534

2128

2474

try:

2129

2475

os.setgid(gid)

2130

2476

os.setuid(uid)

2131

2477

except OSError as error:

2132

if error[0] != errno.EPERM:

2133

raise error

2478

if error.errno != errno.EPERM:

2479

raise

2134

2480

2135

2481

if debug:

2136

2482

# Enable all possible GnuTLS debugging

2147

2493

.gnutls_global_set_log_function(debug_gnutls))

2148

2494

2149

2495

# Redirect stdin so all checkers get /dev/null

2150

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

2496

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

2151

2497

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

2152

2498

if null > 2:

2153

2499

os.close(null)

2154

2500

2155

2501

# Need to fork before connecting to D-Bus

2156

if not debug:

2502

if not foreground:

2157

2503

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

2158

2504

daemon()

2159

2505

2506

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

2507

# need to inform gobject that threads will be used.

2160

2508

gobject.threads_init()

2161

2509

2162

2510

global main_loop

2163

2511

# From the Avahi example code

2164

DBusGMainLoop(set_as_default=True )

2512

DBusGMainLoop(set_as_default=True)

2165

2513

main_loop = gobject.MainLoop()

2166

2514

bus = dbus.SystemBus()

2167

2515

# End of Avahi example code

2173

2521

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

2174

2522

do_not_queue=True))

2175

2523

except dbus.exceptions.NameExistsException as e:

2176

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

2524

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

2177

2525

use_dbus = False

2178

2526

server_settings["use_dbus"] = False

2179

2527

tcp_server.use_dbus = False

2180

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2181

service = AvahiServiceToSyslog(name =

2182

server_settings["servicename"],

2183

servicetype = "_mandos._tcp",

2184

protocol = protocol, bus = bus)

2185

if server_settings["interface"]:

2186

service.interface = (if_nametoindex

2187

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

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

2188

2537

2189

2538

global multiprocessing_manager

2190

2539

multiprocessing_manager = multiprocessing.Manager()

2191

2540

2192

2541

client_class = Client

2193

2542

if use_dbus:

2194

client_class = functools.partial(ClientDBusTransitional,

2195

bus = bus)

2543

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

2196

2544

2197

2545

client_settings = Client.config_parser(client_config)

2198

2546

old_client_settings = {}

2199

2547

clients_data = {}

2200

2548

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

2201

2557

# Get client data and settings from last running state.

2202

2558

if server_settings["restore"]:

2203

2559

try:

2206

2562

(stored_state))

2207

2563

os.remove(stored_state_path)

2208

2564

except IOError as e:

2209

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

2210

.format(e))

2211

if e.errno != errno.ENOENT:

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)

2212

2571

raise

2213

2572

except EOFError as e:

2214

2573

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

2215

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

2574

"EOFError:", exc_info=e)

2216

2575

2217

2576

with PGPEngine() as pgp:

2218

for client_name, client in clients_data.iteritems():

2577

for client_name, client in clients_data.items():

2578

# Skip removed clients

2579

if client_name not in client_settings:

2580

continue

2581

2219

2582

# Decide which value to use after restoring saved state.

2220

2583

# We have three different values: Old config file,

2221

2584

# new config file, and saved state.

2242

2605

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

2243

2606

if not client["last_checked_ok"]:

2244

2607

logger.warning(

2245

"disabling client {0} - Client never "

2608

"disabling client {} - Client never "

2246

2609

"performed a successful checker"

2247

2610

.format(client_name))

2248

2611

client["enabled"] = False

2249

2612

elif client["last_checker_status"] != 0:

2250

2613

logger.warning(

2251

"disabling client {0} - Client "

2252

"last checker failed with error code {1}"

2614

"disabling client {} - Client last"

2615

" checker failed with error code {}"

2253

2616

.format(client_name,

2254

2617

client["last_checker_status"]))

2255

2618

client["enabled"] = False

2258

2621

.utcnow()

2259

2622

+ client["timeout"])

2260

2623

logger.debug("Last checker succeeded,"

2261

" keeping {0} enabled"

2624

" keeping {} enabled"

2262

2625

.format(client_name))

2263

2626

try:

2264

2627

client["secret"] = (

2267

2630

["secret"]))

2268

2631

except PGPError:

2269

2632

# If decryption fails, we use secret from new settings

2270

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

2633

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

2271

2634

.format(client_name))

2272

2635

client["secret"] = (

2273

2636

client_settings[client_name]["secret"])

2274

2275

2637

2276

2638

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

2277

2639

for client_name in (set(old_client_settings)

2280

2642

for client_name in (set(client_settings)

2281

2643

- set(old_client_settings)):

2282

2644

clients_data[client_name] = client_settings[client_name]

2283

2645

2284

2646

# Create all client objects

2285

for client_name, client in clients_data.iteritems():

2647

for client_name, client in clients_data.items():

2286

2648

tcp_server.clients[client_name] = client_class(

2287

name = client_name, settings = client)

2649

name = client_name, settings = client,

2650

server_settings = server_settings)

2288

2651

2289

2652

if not tcp_server.clients:

2290

2653

logger.warning("No clients defined")

2291

2292

if not debug:

2293

try:

2294

with pidfile:

2295

pid = os.getpid()

2296

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

2297

del pidfile

2298

except IOError:

2299

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

2300

pidfilename, pid)

2301

except NameError:

2302

# "pidfile" was never created

2303

pass

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

2304

2665

del pidfilename

2305

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

2306

2666

2307

2667

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

2308

2668

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

2309

2669

2310

2670

if use_dbus:

2311

class MandosDBusService(dbus.service.Object):

2671

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

2672

"se.bsnet.fukt.Mandos"})

2673

class MandosDBusService(DBusObjectWithProperties):

2312

2674

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

2313

2675

def __init__(self):

2314

2676

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

2315

2677

_interface = "se.recompile.Mandos"

2316

2678

2679

@dbus_interface_annotations(_interface)

2680

def _foo(self):

2681

return { "org.freedesktop.DBus.Property"

2682

".EmitsChangedSignal":

2683

"false"}

2684

2317

2685

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

2318

2686

def ClientAdded(self, objpath):

2319

2687

"D-Bus signal"

2361

2729

2362

2730

del _interface

2363

2731

2364

class MandosDBusServiceTransitional(MandosDBusService):

2365

__metaclass__ = AlternateDBusNamesMetaclass

2366

mandos_dbus_service = MandosDBusServiceTransitional()

2732

mandos_dbus_service = MandosDBusService()

2367

2733

2368

2734

def cleanup():

2369

2735

"Cleanup function; run on exit"

2370

service.cleanup()

2736

if zeroconf:

2737

service.cleanup()

2371

2738

2372

2739

multiprocessing.active_children()

2740

wnull.close()

2373

2741

if not (tcp_server.clients or client_settings):

2374

2742

return

2375

2743

2386

2754

2387

2755

# A list of attributes that can not be pickled

2388

2756

# + secret.

2389

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

2390

"checker"))

2757

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

2758

"checker", "server_settings" }

2391

2759

for name, typ in (inspect.getmembers

2392

2760

(dbus.service.Object)):

2393

2761

exclude.add(name)

2402

2770

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

2403

2771

2404

2772

try:

2405

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

2406

prefix="clients-",

2407

dir=os.path.dirname

2408

(stored_state_path))

2409

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

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:

2410

2777

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

2778

tempname=stored_state.name

2411

2779

os.rename(tempname, stored_state_path)

2412

2780

except (IOError, OSError) as e:

2413

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

2414

.format(e))

2415

2781

if not debug:

2416

2782

try:

2417

2783

os.remove(tempname)

2418

2784

except NameError:

2419

2785

pass

2420

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

2421

errno.EEXIST)):

2422

raise e

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

2423

2793

2424

2794

# Delete all clients, and settings from config

2425

2795

while tcp_server.clients:

2449

2819

tcp_server.server_activate()

2450

2820

2451

2821

# Find out what port we got

2452

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

2822

if zeroconf:

2823

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

2453

2824

if use_ipv6:

2454

2825

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

2455

" flowinfo %d, scope_id %d"

2456

% tcp_server.socket.getsockname())

2826

" flowinfo %d, scope_id %d",

2827

*tcp_server.socket.getsockname())

2457

2828

else: # IPv4

2458

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

2459

% tcp_server.socket.getsockname())

2829

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

2830

*tcp_server.socket.getsockname())

2460

2831

2461

2832

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

2462

2833

2463

2834

try:

2464

# From the Avahi example code

2465

try:

2466

service.activate()

2467

except dbus.exceptions.DBusException as error:

2468

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

2469

cleanup()

2470

sys.exit(1)

2471

# End of Avahi example code

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

2472

2844

2473

2845

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

2474

2846

lambda *args, **kwargs:

2478

2850

logger.debug("Starting main loop")

2479

2851

main_loop.run()

2480

2852

except AvahiError as error:

2481

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

2853

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

2482

2854

cleanup()

2483

2855

sys.exit(1)

2484

2856

except KeyboardInterrupt: