/mandos/release : revision 237.7.120

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

68

66

import binascii

69

67

import tempfile

70

68

import itertools

71

import collections

72

69

73

70

import dbus

74

71

import dbus.service

79

76

import ctypes.util

80

77

import xml.dom.minidom

81

78

import inspect

79

import GnuPGInterface

82

80

83

81

try:

84

82

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

88

86

except ImportError:

89

87

SO_BINDTODEVICE = None

90

88

91

version = "1.6.7"

89

version = "1.5.3"

92

90

stored_state_file = "clients.pickle"

93

91

94

92

logger = logging.getLogger()

95

syslogger = None

93

syslogger = (logging.handlers.SysLogHandler

94

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

95

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

96

97

try:

98

if_nametoindex = (ctypes.cdll.LoadLibrary

114

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

115

"""init logger and add loglevel"""

116

117

global syslogger

118

syslogger = (logging.handlers.SysLogHandler

119

(facility =

120

logging.handlers.SysLogHandler.LOG_DAEMON,

121

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

122

117

syslogger.setFormatter(logging.Formatter

123

118

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

124

119

' %(message)s'))

142

137

class PGPEngine(object):

143

138

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

144

139

def __init__(self):

140

self.gnupg = GnuPGInterface.GnuPG()

145

141

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

146

self.gnupgargs = ['--batch',

147

'--home', self.tempdir,

148

'--force-mdc',

149

'--quiet',

150

'--no-use-agent']

142

self.gnupg = GnuPGInterface.GnuPG()

143

self.gnupg.options.meta_interactive = False

144

self.gnupg.options.homedir = self.tempdir

145

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

146

'--quiet',

147

'--no-use-agent'])

151

148

152

149

def __enter__(self):

153

150

return self

154

151

155

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

152

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

156

153

self._cleanup()

157

154

return False

158

155

175

172

def password_encode(self, password):

176

173

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

177

174

# 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

175

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

185

176

186

177

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)

178

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

179

with open(os.devnull, "w") as devnull:

180

try:

181

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

182

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

183

attach_fhs={'stderr': devnull})

184

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

185

f.write(data)

186

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

187

ciphertext = f.read()

188

proc.wait()

189

except IOError as e:

190

raise PGPError(e)

191

self.gnupg.passphrase = None

202

192

return ciphertext

203

193

204

194

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)

195

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

196

with open(os.devnull, "w") as devnull:

197

try:

198

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

199

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

200

attach_fhs={'stderr': devnull})

201

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

202

f.write(data)

203

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

204

decrypted_plaintext = f.read()

205

proc.wait()

206

except IOError as e:

207

raise PGPError(e)

208

self.gnupg.passphrase = None

221

209

return decrypted_plaintext

222

210

223

211

212

224

213

class AvahiError(Exception):

225

214

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

226

215

self.value = value

243

232

Used to optionally bind to the specified interface.

244

233

name: string; Example: 'Mandos'

245

234

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

246

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

235

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

247

236

port: integer; what port to announce

248

237

TXT: list of strings; TXT record for the service

249

238

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

255

244

server: D-Bus Server

256

245

bus: dbus.SystemBus()

257

246

"""

258

259

247

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

260

248

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

261

249

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

274

262

self.server = None

275

263

self.bus = bus

276

264

self.entry_group_state_changed_match = None

277

278

265

def rename(self):

279

266

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

280

267

if self.rename_count >= self.max_renames:

294

281

self.cleanup()

295

282

os._exit(1)

296

283

self.rename_count += 1

297

298

284

def remove(self):

299

285

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

300

286

if self.entry_group_state_changed_match is not None:

302

288

self.entry_group_state_changed_match = None

303

289

if self.group is not None:

304

290

self.group.Reset()

305

306

291

def add(self):

307

292

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

308

293

self.remove()

325

310

dbus.UInt16(self.port),

326

311

avahi.string_array_to_txt_array(self.TXT))

327

312

self.group.Commit()

328

329

313

def entry_group_state_changed(self, state, error):

330

314

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

331

315

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

340

324

unicode(error))

341

325

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

342

326

.format(error))

343

344

327

def cleanup(self):

345

328

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

346

329

if self.group is not None:

351

334

pass

352

335

self.group = None

353

336

self.remove()

354

355

337

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

356

338

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

357

339

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

376

358

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

377

359

else:

378

360

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

379

380

361

def activate(self):

381

362

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

382

363

if self.server is None:

389

370

self.server_state_changed)

390

371

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

391

372

392

393

373

class AvahiServiceToSyslog(AvahiService):

394

374

def rename(self):

395

375

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

400

380

.format(self.name)))

401

381

return ret

402

382

403

404

383

def timedelta_to_milliseconds(td):

405

384

"Convert a datetime.timedelta() to milliseconds"

406

385

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

407

386

+ (td.seconds * 1000)

408

387

+ (td.microseconds // 1000))

409

410

388

411

389

class Client(object):

412

390

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

413

391

449

427

runtime_expansions: Allowed attributes for runtime expansion.

450

428

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

451

429

disabled, or None

452

server_settings: The server_settings dict from main()

453

430

"""

454

431

455

432

runtime_expansions = ("approval_delay", "approval_duration",

456

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

457

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

458

"last_approval_request", "last_checked_ok",

433

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

434

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

459

435

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

460

client_defaults = { "timeout": "PT5M",

461

"extended_timeout": "PT15M",

462

"interval": "PT2M",

436

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

437

"extended_timeout": "15m",

438

"interval": "2m",

463

439

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

464

440

"host": "",

465

"approval_delay": "PT0S",

466

"approval_duration": "PT1S",

441

"approval_delay": "0s",

442

"approval_duration": "1s",

467

443

"approved_by_default": "True",

468

444

"enabled": "True",

469

445

}

482

458

483

459

def approval_delay_milliseconds(self):

484

460

return timedelta_to_milliseconds(self.approval_delay)

485

461

486

462

@staticmethod

487

463

def config_parser(config):

488

464

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

529

505

client["last_checker_status"] = -2

530

506

531

507

return settings

532

533

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

508

509

510

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

511

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

512

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

513

attribute."""

534

514

self.name = name

535

if server_settings is None:

536

server_settings = {}

537

self.server_settings = server_settings

538

515

# adding all client settings

539

516

for setting, value in settings.iteritems():

540

517

setattr(self, setting, value)

548

525

else:

549

526

self.last_enabled = None

550

527

self.expires = None

551

528

552

529

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

553

530

# Uppercase and remove spaces from fingerprint for later

554

531

# comparison purposes with return value from the fingerprint()

556

533

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

557

534

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

558

535

datetime.datetime.utcnow())

559

536

560

537

# attributes specific for this server instance

561

538

self.checker = None

562

539

self.checker_initiator_tag = None

590

567

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

591

568

# Already enabled

592

569

return

570

self.send_changedstate()

593

571

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

594

572

self.enabled = True

595

573

self.last_enabled = datetime.datetime.utcnow()

596

574

self.init_checker()

597

self.send_changedstate()

598

575

599

576

def disable(self, quiet=True):

600

577

"""Disable this client."""

601

578

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

602

579

return False

603

580

if not quiet:

581

self.send_changedstate()

582

if not quiet:

604

583

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

605

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

584

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

606

585

gobject.source_remove(self.disable_initiator_tag)

607

586

self.disable_initiator_tag = None

608

587

self.expires = None

609

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

588

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

610

589

gobject.source_remove(self.checker_initiator_tag)

611

590

self.checker_initiator_tag = None

612

591

self.stop_checker()

613

592

self.enabled = False

614

if not quiet:

615

self.send_changedstate()

616

593

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

617

594

return False

618

595

622

599

def init_checker(self):

623

600

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

624

601

# and every interval from then on.

625

if self.checker_initiator_tag is not None:

626

gobject.source_remove(self.checker_initiator_tag)

627

602

self.checker_initiator_tag = (gobject.timeout_add

628

603

(self.interval_milliseconds(),

629

604

self.start_checker))

630

605

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

631

if self.disable_initiator_tag is not None:

632

gobject.source_remove(self.disable_initiator_tag)

633

606

self.disable_initiator_tag = (gobject.timeout_add

634

607

(self.timeout_milliseconds(),

635

608

self.disable))

666

639

timeout = self.timeout

667

640

if self.disable_initiator_tag is not None:

668

641

gobject.source_remove(self.disable_initiator_tag)

669

self.disable_initiator_tag = None

670

642

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

671

643

self.disable_initiator_tag = (gobject.timeout_add

672

644

(timedelta_to_milliseconds

682

654

If a checker already exists, leave it running and do

683

655

nothing."""

684

656

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

685

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

686

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

687

# would inevitably timeout, since no checker would get a

688

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

657

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

658

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

659

# client would inevitably timeout, since no checker would get

660

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

689

661

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

690

662

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

691

663

# should be.

693

665

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

694

666

try:

695

667

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

696

except AttributeError:

697

pass

698

except OSError as error:

699

if error.errno != errno.ECHILD:

700

raise

668

except (AttributeError, OSError) as error:

669

if (isinstance(error, OSError)

670

and error.errno != errno.ECHILD):

671

raise error

701

672

else:

702

673

if pid:

703

674

logger.warning("Checker was a zombie")

706

677

self.current_checker_command)

707

678

# Start a new checker if needed

708

679

if self.checker is None:

709

# Escape attributes for the shell

710

escaped_attrs = dict(

711

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

712

for attr in

713

self.runtime_expansions)

714

680

try:

715

command = self.checker_command % escaped_attrs

716

except TypeError as error:

717

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

718

self.checker_command, exc_info=error)

719

return True # Try again later

681

# In case checker_command has exactly one % operator

682

command = self.checker_command % self.host

683

except TypeError:

684

# Escape attributes for the shell

685

escaped_attrs = dict(

686

(attr,

687

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

688

errors=

689

'replace')))

690

for attr in

691

self.runtime_expansions)

692

693

try:

694

command = self.checker_command % escaped_attrs

695

except TypeError as error:

696

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

697

self.checker_command, exc_info=error)

698

return True # Try again later

720

699

self.current_checker_command = command

721

700

try:

722

701

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

725

704

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

726

705

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

727

706

# always replaced by /dev/null.)

728

# The exception is when not debugging but nevertheless

729

# running in the foreground; use the previously

730

# created wnull.

731

popen_args = {}

732

if (not self.server_settings["debug"]

733

and self.server_settings["foreground"]):

734

popen_args.update({"stdout": wnull,

735

"stderr": wnull })

736

707

self.checker = subprocess.Popen(command,

737

708

close_fds=True,

738

shell=True, cwd="/",

739

**popen_args)

709

shell=True, cwd="/")

710

self.checker_callback_tag = (gobject.child_watch_add

711

(self.checker.pid,

712

self.checker_callback,

713

data=command))

714

# The checker may have completed before the gobject

715

# watch was added. Check for this.

716

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

717

if pid:

718

gobject.source_remove(self.checker_callback_tag)

719

self.checker_callback(pid, status, command)

740

720

except OSError as error:

741

721

logger.error("Failed to start subprocess",

742

722

exc_info=error)

743

return True

744

self.checker_callback_tag = (gobject.child_watch_add

745

(self.checker.pid,

746

self.checker_callback,

747

data=command))

748

# The checker may have completed before the gobject

749

# watch was added. Check for this.

750

try:

751

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

752

except OSError as error:

753

if error.errno == errno.ECHILD:

754

# This should never happen

755

logger.error("Child process vanished",

756

exc_info=error)

757

return True

758

raise

759

if pid:

760

gobject.source_remove(self.checker_callback_tag)

761

self.checker_callback(pid, status, command)

762

723

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

763

724

return True

764

725

812

773

813

774

814

775

def dbus_interface_annotations(dbus_interface):

815

"""Decorator for marking functions returning interface annotations

776

"""Decorator for marking functions returning interface annotations.

816

777

817

778

Usage:

818

779

937

898

# The byte_arrays option is not supported yet on

938

899

# signatures other than "ay".

939

900

if prop._dbus_signature != "ay":

940

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

941

"'ay' signature {0!r}"

942

.format(prop._dbus_signature))

901

raise ValueError

943

902

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

944

903

for byte in value))

945

904

prop(value)

1017

976

tag.appendChild(ann_tag)

1018

977

# Add interface annotation tags

1019

978

for annotation, value in dict(

1020

itertools.chain.from_iterable(

1021

annotations().iteritems()

1022

for name, annotations in

1023

self._get_all_dbus_things("interface")

1024

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

1025

)).iteritems():

979

itertools.chain(

980

*(annotations().iteritems()

981

for name, annotations in

982

self._get_all_dbus_things("interface")

983

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

984

))).iteritems():

1026

985

ann_tag = document.createElement("annotation")

1027

986

ann_tag.setAttribute("name", annotation)

1028

987

ann_tag.setAttribute("value", value)

1051

1010

return xmlstring

1052

1011

1053

1012

1054

def datetime_to_dbus(dt, variant_level=0):

1013

def datetime_to_dbus (dt, variant_level=0):

1055

1014

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

1056

1015

if dt is None:

1057

1016

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

1059

1018

variant_level=variant_level)

1060

1019

1061

1020

1062

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1063

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

1064

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

1065

interface names according to the "alt_interface_names" mapping.

1066

Usage:

1067

1068

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

1069

"net.example.AlternateInterface"})

1070

class SampleDBusObject(dbus.service.Object):

1071

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

1072

def SampleDBusMethod():

1073

pass

1074

1075

The above "SampleDBusMethod" on "SampleDBusObject" will be

1076

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

1077

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

1078

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

1079

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

1080

1081

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

1082

(from DBusObjectWithProperties) and interfaces (from the

1083

dbus_interface_annotations decorator).

1021

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

1022

.__metaclass__):

1023

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

1024

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

1084

1025

"""

1085

def wrapper(cls):

1086

for orig_interface_name, alt_interface_name in (

1087

alt_interface_names.iteritems()):

1088

attr = {}

1089

interface_names = set()

1090

# Go though all attributes of the class

1091

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

1026

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

1027

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

1028

# methods, signals, or properties in them

1029

old_interface_names = []

1030

for base in (b for b in bases

1031

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

1032

# Go though all attributes of the base class

1033

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

1092

1034

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

1093

1035

# with the wrong interface name

1094

1036

if (not hasattr(attribute, "_dbus_interface")

1095

1037

or not attribute._dbus_interface

1096

.startswith(orig_interface_name)):

1038

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

1097

1039

continue

1098

1040

# Create an alternate D-Bus interface name based on

1099

1041

# the current name

1100

1042

alt_interface = (attribute._dbus_interface

1101

.replace(orig_interface_name,

1102

alt_interface_name))

1103

interface_names.add(alt_interface)

1043

.replace("se.recompile.Mandos",

1044

"se.bsnet.fukt.Mandos"))

1045

if alt_interface != attribute._dbus_interface:

1046

old_interface_names.append(alt_interface)

1104

1047

# Is this a D-Bus signal?

1105

1048

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

1106

# Extract the original non-method undecorated

1107

# function by black magic

1049

# Extract the original non-method function by

1050

# black magic

1108

1051

nonmethod_func = (dict(

1109

1052

zip(attribute.func_code.co_freevars,

1110

1053

attribute.__closure__))["func"]

1128

1071

except AttributeError:

1129

1072

pass

1130

1073

# Define a creator of a function to call both the

1131

# original and alternate functions, so both the

1132

# original and alternate signals gets sent when

1133

# the function is called

1074

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

1075

# signals gets sent when the function is called

1134

1076

def fixscope(func1, func2):

1135

1077

"""This function is a scope container to pass

1136

1078

func1 and func2 to the "call_both" function

1143

1085

return call_both

1144

1086

# Create the "call_both" function and add it to

1145

1087

# the class

1146

attr[attrname] = fixscope(attribute, new_function)

1088

attr[attrname] = fixscope(attribute,

1089

new_function)

1147

1090

# Is this a D-Bus method?

1148

1091

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

1149

1092

# Create a new, but exactly alike, function

1205

1148

attribute.func_name,

1206

1149

attribute.func_defaults,

1207

1150

attribute.func_closure)))

1208

if deprecate:

1209

# Deprecate all alternate interfaces

1210

iname="_AlternateDBusNames_interface_annotation{0}"

1211

for interface_name in interface_names:

1212

@dbus_interface_annotations(interface_name)

1213

def func(self):

1214

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

1215

"true" }

1216

# Find an unused name

1217

for aname in (iname.format(i)

1218

for i in itertools.count()):

1219

if aname not in attr:

1220

attr[aname] = func

1221

break

1222

if interface_names:

1223

# Replace the class with a new subclass of it with

1224

# methods, signals, etc. as created above.

1225

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

1226

(cls,), attr)

1227

return cls

1228

return wrapper

1229

1230

1231

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

1232

"se.bsnet.fukt.Mandos"})

1151

# Deprecate all old interfaces

1152

basename="_AlternateDBusNamesMetaclass_interface_annotation{0}"

1153

for old_interface_name in old_interface_names:

1154

@dbus_interface_annotations(old_interface_name)

1155

def func(self):

1156

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

1157

# Find an unused name

1158

for aname in (basename.format(i) for i in

1159

itertools.count()):

1160

if aname not in attr:

1161

attr[aname] = func

1162

break

1163

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

1164

1165

1233

1166

class ClientDBus(Client, DBusObjectWithProperties):

1234

1167

"""A Client class using D-Bus

1235

1168

1255

1188

("/clients/" + client_object_name))

1256

1189

DBusObjectWithProperties.__init__(self, self.bus,

1257

1190

self.dbus_object_path)

1258

1191

1259

1192

def notifychangeproperty(transform_func,

1260

1193

dbus_name, type_func=lambda x: x,

1261

1194

variant_level=1):

1284

1217

1285

1218

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

1286

1219

1220

1287

1221

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1288

1222

approvals_pending = notifychangeproperty(dbus.Boolean,

1289

1223

"ApprovalPending",

1353

1287

*args, **kwargs)

1354

1288

1355

1289

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

1356

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

1290

old_checker = self.checker

1291

if self.checker is not None:

1292

old_checker_pid = self.checker.pid

1293

else:

1294

old_checker_pid = None

1357

1295

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

1358

1296

# Only if new checker process was started

1359

1297

if (self.checker is not None

1367

1305

return False

1368

1306

1369

1307

def approve(self, value=True):

1308

self.send_changedstate()

1370

1309

self.approved = value

1371

1310

gobject.timeout_add(timedelta_to_milliseconds

1372

1311

(self.approval_duration),

1373

1312

self._reset_approved)

1374

self.send_changedstate()

1313

1375

1314

1376

1315

## D-Bus methods, signals & properties

1377

1316

_interface = "se.recompile.Mandos.Client"

1561

1500

def Timeout_dbus_property(self, value=None):

1562

1501

if value is None: # get

1563

1502

return dbus.UInt64(self.timeout_milliseconds())

1564

old_timeout = self.timeout

1565

1503

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

1566

# Reschedule disabling

1504

# Reschedule timeout

1567

1505

if self.enabled:

1568

1506

now = datetime.datetime.utcnow()

1569

self.expires += self.timeout - old_timeout

1570

if self.expires <= now:

1507

time_to_die = timedelta_to_milliseconds(

1508

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

1509

if time_to_die <= 0:

1571

1510

# The timeout has passed

1572

1511

self.disable()

1573

1512

else:

1513

self.expires = (now +

1514

datetime.timedelta(milliseconds =

1515

time_to_die))

1574

1516

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

1575

1517

is None):

1576

1518

return

1577

1519

gobject.source_remove(self.disable_initiator_tag)

1578

self.disable_initiator_tag = (

1579

gobject.timeout_add(

1580

timedelta_to_milliseconds(self.expires - now),

1581

self.disable))

1520

self.disable_initiator_tag = (gobject.timeout_add

1521

(time_to_die,

1522

self.disable))

1582

1523

1583

1524

# ExtendedTimeout - property

1584

1525

@dbus_service_property(_interface, signature="t",

1663

1604

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

1664

1605

1665

1606

1607

class ClientDBusTransitional(ClientDBus):

1608

__metaclass__ = AlternateDBusNamesMetaclass

1609

1610

1666

1611

class ClientHandler(socketserver.BaseRequestHandler, object):

1667

1612

"""A class to handle client connections.

1668

1613

1704

1649

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

1705

1650

try:

1706

1651

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

1707

raise RuntimeError(line)

1652

raise RuntimeError

1708

1653

except (ValueError, IndexError, RuntimeError) as error:

1709

1654

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

1710

1655

return

1772

1717

#wait until timeout or approved

1773

1718

time = datetime.datetime.now()

1774

1719

client.changedstate.acquire()

1775

client.changedstate.wait(

1776

float(timedelta_to_milliseconds(delay)

1777

/ 1000))

1720

(client.changedstate.wait

1721

(float(client.timedelta_to_milliseconds(delay)

1722

/ 1000)))

1778

1723

client.changedstate.release()

1779

1724

time2 = datetime.datetime.now()

1780

1725

if (time2 - time) >= delay:

1796

1741

try:

1797

1742

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

1798

1743

except gnutls.errors.GNUTLSError as error:

1799

logger.warning("gnutls send failed",

1800

exc_info=error)

1744

logger.warning("gnutls send failed")

1801

1745

return

1802

1746

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

1803

1747

sent, len(client.secret)

1817

1761

try:

1818

1762

session.bye()

1819

1763

except gnutls.errors.GNUTLSError as error:

1820

logger.warning("GnuTLS bye failed",

1821

exc_info=error)

1764

logger.warning("GnuTLS bye failed")

1822

1765

1823

1766

@staticmethod

1824

1767

def peer_certificate(session):

1896

1839

def process_request(self, request, address):

1897

1840

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

1898

1841

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

1899

args = (request, address))

1842

args = (request,

1843

address))

1900

1844

proc.start()

1901

1845

return proc

1902

1846

1917

1861

1918

1862

def add_pipe(self, parent_pipe, proc):

1919

1863

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

1920

raise NotImplementedError()

1864

raise NotImplementedError

1921

1865

1922

1866

1923

1867

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1930

1874

use_ipv6: Boolean; to use IPv6 or not

1931

1875

"""

1932

1876

def __init__(self, server_address, RequestHandlerClass,

1933

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

1934

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

1935

creating a new one with socket.socket().

1936

"""

1877

interface=None, use_ipv6=True):

1937

1878

self.interface = interface

1938

1879

if use_ipv6:

1939

1880

self.address_family = socket.AF_INET6

1940

if socketfd is not None:

1941

# Save the file descriptor

1942

self.socketfd = socketfd

1943

# Save the original socket.socket() function

1944

self.socket_socket = socket.socket

1945

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

1946

#

1947

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

1948

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

1949

# patching socket.socket.)

1950

#

1951

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

1952

@functools.wraps(socket.socket)

1953

def socket_wrapper(*args, **kwargs):

1954

# Restore original function so subsequent calls are

1955

# not affected.

1956

socket.socket = self.socket_socket

1957

del self.socket_socket

1958

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

1959

# saved file descriptor.

1960

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

1961

# Replace socket.socket() function with wrapper

1962

socket.socket = socket_wrapper

1963

# The socketserver.TCPServer.__init__ will call

1964

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

1965

# socket_wrapper(), if socketfd was set.

1966

1881

socketserver.TCPServer.__init__(self, server_address,

1967

1882

RequestHandlerClass)

1968

1969

1883

def server_bind(self):

1970

1884

"""This overrides the normal server_bind() function

1971

1885

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

1979

1893

try:

1980

1894

self.socket.setsockopt(socket.SOL_SOCKET,

1981

1895

SO_BINDTODEVICE,

1982

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

1896

str(self.interface

1897

+ '\0'))

1983

1898

except socket.error as error:

1984

if error.errno == errno.EPERM:

1985

logger.error("No permission to bind to"

1986

" interface %s", self.interface)

1987

elif error.errno == errno.ENOPROTOOPT:

1899

if error[0] == errno.EPERM:

1900

logger.error("No permission to"

1901

" bind to interface %s",

1902

self.interface)

1903

elif error[0] == errno.ENOPROTOOPT:

1988

1904

logger.error("SO_BINDTODEVICE not available;"

1989

1905

" cannot bind to interface %s",

1990

1906

self.interface)

1991

elif error.errno == errno.ENODEV:

1992

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

1993

" cannot bind", self.interface)

1994

1907

else:

1995

1908

raise

1996

1909

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

1999

1912

if self.address_family == socket.AF_INET6:

2000

1913

any_address = "::" # in6addr_any

2001

1914

else:

2002

any_address = "0.0.0.0" # INADDR_ANY

1915

any_address = socket.INADDR_ANY

2003

1916

self.server_address = (any_address,

2004

1917

self.server_address[1])

2005

1918

elif not self.server_address[1]:

2026

1939

"""

2027

1940

def __init__(self, server_address, RequestHandlerClass,

2028

1941

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

2029

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

1942

gnutls_priority=None, use_dbus=True):

2030

1943

self.enabled = False

2031

1944

self.clients = clients

2032

1945

if self.clients is None:

2036

1949

IPv6_TCPServer.__init__(self, server_address,

2037

1950

RequestHandlerClass,

2038

1951

interface = interface,

2039

use_ipv6 = use_ipv6,

2040

socketfd = socketfd)

1952

use_ipv6 = use_ipv6)

2041

1953

def server_activate(self):

2042

1954

if self.enabled:

2043

1955

return socketserver.TCPServer.server_activate(self)

2056

1968

2057

1969

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

2058

1970

proc = None, client_object=None):

1971

condition_names = {

1972

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

1973

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

1974

# blocking).

1975

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

1976

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

1977

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

1978

# broken, usually for pipes and

1979

# sockets).

1980

}

1981

conditions_string = ' | '.join(name

1982

for cond, name in

1983

condition_names.iteritems()

1984

if cond & condition)

2059

1985

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

2060

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

1986

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

2061

1987

# Wait for other process to exit

2062

1988

proc.join()

2063

1989

return False

2121

2047

return True

2122

2048

2123

2049

2124

def rfc3339_duration_to_delta(duration):

2125

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

2126

2127

>>> rfc3339_duration_to_delta("P7D")

2128

datetime.timedelta(7)

2129

>>> rfc3339_duration_to_delta("PT60S")

2130

datetime.timedelta(0, 60)

2131

>>> rfc3339_duration_to_delta("PT60M")

2132

datetime.timedelta(0, 3600)

2133

>>> rfc3339_duration_to_delta("PT24H")

2134

datetime.timedelta(1)

2135

>>> rfc3339_duration_to_delta("P1W")

2136

datetime.timedelta(7)

2137

>>> rfc3339_duration_to_delta("PT5M30S")

2138

datetime.timedelta(0, 330)

2139

>>> rfc3339_duration_to_delta("P1DT3M20S")

2140

datetime.timedelta(1, 200)

2141

"""

2142

2143

# Parsing an RFC 3339 duration with regular expressions is not

2144

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

2145

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

2146

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

2147

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

2148

# avoid excessive use of external libraries.

2149

2150

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

2151

Token = collections.namedtuple("Token",

2152

("regexp", # To match token; if

2153

# "value" is not None,

2154

# must have a "group"

2155

# containing digits

2156

"value", # datetime.timedelta or

2157

# None

2158

"followers")) # Tokens valid after

2159

# this token

2160

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

2161

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

2162

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

2163

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

2164

datetime.timedelta(seconds=1),

2165

frozenset((token_end,)))

2166

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

2167

datetime.timedelta(minutes=1),

2168

frozenset((token_second, token_end)))

2169

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

2170

datetime.timedelta(hours=1),

2171

frozenset((token_minute, token_end)))

2172

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

2173

None,

2174

frozenset((token_hour, token_minute,

2175

token_second)))

2176

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

2177

datetime.timedelta(days=1),

2178

frozenset((token_time, token_end)))

2179

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

2180

datetime.timedelta(weeks=4),

2181

frozenset((token_day, token_end)))

2182

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

2183

datetime.timedelta(weeks=52),

2184

frozenset((token_month, token_end)))

2185

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

2186

datetime.timedelta(weeks=1),

2187

frozenset((token_end,)))

2188

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

2189

frozenset((token_year, token_month,

2190

token_day, token_time,

2191

token_week))),

2192

# Define starting values

2193

value = datetime.timedelta() # Value so far

2194

found_token = None

2195

followers = frozenset(token_duration,) # Following valid tokens

2196

s = duration # String left to parse

2197

# Loop until end token is found

2198

while found_token is not token_end:

2199

# Search for any currently valid tokens

2200

for token in followers:

2201

match = token.regexp.match(s)

2202

if match is not None:

2203

# Token found

2204

if token.value is not None:

2205

# Value found, parse digits

2206

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

2207

# Add to value so far

2208

value += factor * token.value

2209

# Strip token from string

2210

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

2211

# Go to found token

2212

found_token = token

2213

# Set valid next tokens

2214

followers = found_token.followers

2215

break

2216

else:

2217

# No currently valid tokens were found

2218

raise ValueError("Invalid RFC 3339 duration")

2219

# End token found

2220

return value

2221

2222

2223

2050

def string_to_delta(interval):

2224

2051

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

2225

2052

2236

2063

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

2237

2064

datetime.timedelta(0, 330)

2238

2065

"""

2239

2240

try:

2241

return rfc3339_duration_to_delta(interval)

2242

except ValueError:

2243

pass

2244

2245

2066

timevalue = datetime.timedelta(0)

2246

2067

for s in interval.split():

2247

2068

try:

2260

2081

else:

2261

2082

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

2262

2083

.format(suffix))

2263

except IndexError as e:

2084

except (ValueError, IndexError) as e:

2264

2085

raise ValueError(*(e.args))

2265

2086

timevalue += delta

2266

2087

return timevalue

2310

2131

help="Run self-test")

2311

2132

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

2312

2133

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

2313

" to terminal", default=None)

2134

" to terminal")

2314

2135

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

2315

2136

help="Debug level for stdout output")

2316

2137

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

2323

2144

" files")

2324

2145

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

2325

2146

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

2326

" system bus interface", default=None)

2147

" system bus interface")

2327

2148

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

2328

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

2329

default=None)

2149

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

2330

2150

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

2331

2151

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

2332

" state", default=None)

2333

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

2334

help="Specify a file descriptor to a network"

2335

" socket to use instead of creating one")

2152

" state")

2336

2153

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

2337

2154

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

2338

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

2339

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

2340

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

2341

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

2342

default=None)

2343

2155

2344

2156

options = parser.parse_args()

2345

2157

2346

2158

if options.check:

2347

2159

import doctest

2348

fail_count, test_count = doctest.testmod()

2349

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

2160

doctest.testmod()

2161

sys.exit()

2350

2162

2351

2163

# Default values for config file for server-global settings

2352

2164

server_defaults = { "interface": "",

2354

2166

"port": "",

2355

2167

"debug": "False",

2356

2168

"priority":

2357

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

2169

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

2358

2170

"servicename": "Mandos",

2359

2171

"use_dbus": "True",

2360

2172

"use_ipv6": "True",

2361

2173

"debuglevel": "",

2362

2174

"restore": "True",

2363

"socket": "",

2364

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

2365

"foreground": "False",

2366

"zeroconf": "True",

2175

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

2367

2176

}

2368

2177

2369

2178

# Parse config file for server-global settings

2374

2183

# Convert the SafeConfigParser object to a dict

2375

2184

server_settings = server_config.defaults()

2376

2185

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

2377

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

2186

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

2378

2187

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

2379

2188

option)

2380

2189

if server_settings["port"]:

2381

2190

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

2382

2191

"port")

2383

if server_settings["socket"]:

2384

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

2385

"socket")

2386

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

2387

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

2388

# happen with a supplied network socket.

2389

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

2390

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

2391

["socket"])

2392

2192

del server_config

2393

2193

2394

2194

# Override the settings from the config file with command line

2396

2196

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

2397

2197

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

2398

2198

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

2399

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

2199

"statedir"):

2400

2200

value = getattr(options, option)

2401

2201

if value is not None:

2402

2202

server_settings[option] = value

2405

2205

for option in server_settings.keys():

2406

2206

if type(server_settings[option]) is str:

2407

2207

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

2408

# Force all boolean options to be boolean

2409

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

2410

"foreground", "zeroconf"):

2411

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

2412

# Debug implies foreground

2413

if server_settings["debug"]:

2414

server_settings["foreground"] = True

2415

2208

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

2416

2209

2417

2210

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

2418

2211

2419

if (not server_settings["zeroconf"] and

2420

not (server_settings["port"]

2421

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

2422

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

2423

" Zeroconf")

2424

2425

2212

# For convenience

2426

2213

debug = server_settings["debug"]

2427

2214

debuglevel = server_settings["debuglevel"]

2429

2216

use_ipv6 = server_settings["use_ipv6"]

2430

2217

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

2431

2218

stored_state_file)

2432

foreground = server_settings["foreground"]

2433

zeroconf = server_settings["zeroconf"]

2434

2219

2435

2220

if debug:

2436

2221

initlogger(debug, logging.DEBUG)

2457

2242

global mandos_dbus_service

2458

2243

mandos_dbus_service = None

2459

2244

2460

socketfd = None

2461

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

2462

socketfd = server_settings["socket"]

2463

2245

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

2464

2246

server_settings["port"]),

2465

2247

ClientHandler,

2468

2250

use_ipv6=use_ipv6,

2469

2251

gnutls_priority=

2470

2252

server_settings["priority"],

2471

use_dbus=use_dbus,

2472

socketfd=socketfd)

2473

if not foreground:

2474

pidfilename = "/run/mandos.pid"

2475

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

2476

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

2477

pidfile = None

2253

use_dbus=use_dbus)

2254

if not debug:

2255

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

2478

2256

try:

2479

2257

pidfile = open(pidfilename, "w")

2480

except IOError as e:

2481

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

2482

exc_info=e)

2258

except IOError:

2259

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

2483

2260

2484

2261

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

2485

2262

try:

2495

2272

os.setgid(gid)

2496

2273

os.setuid(uid)

2497

2274

except OSError as error:

2498

if error.errno != errno.EPERM:

2499

raise

2275

if error[0] != errno.EPERM:

2276

raise error

2500

2277

2501

2278

if debug:

2502

2279

# Enable all possible GnuTLS debugging

2519

2296

os.close(null)

2520

2297

2521

2298

# Need to fork before connecting to D-Bus

2522

if not foreground:

2299

if not debug:

2523

2300

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

2524

2301

daemon()

2525

2302

2526

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

2527

# need to inform gobject that threads will be used.

2528

2303

gobject.threads_init()

2529

2304

2530

2305

global main_loop

2541

2316

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

2542

2317

do_not_queue=True))

2543

2318

except dbus.exceptions.NameExistsException as e:

2544

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

2319

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

2545

2320

use_dbus = False

2546

2321

server_settings["use_dbus"] = False

2547

2322

tcp_server.use_dbus = False

2548

if zeroconf:

2549

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2550

service = AvahiServiceToSyslog(name =

2551

server_settings["servicename"],

2552

servicetype = "_mandos._tcp",

2553

protocol = protocol, bus = bus)

2554

if server_settings["interface"]:

2555

service.interface = (if_nametoindex

2556

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

2323

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2324

service = AvahiServiceToSyslog(name =

2325

server_settings["servicename"],

2326

servicetype = "_mandos._tcp",

2327

protocol = protocol, bus = bus)

2328

if server_settings["interface"]:

2329

service.interface = (if_nametoindex

2330

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

2557

2331

2558

2332

global multiprocessing_manager

2559

2333

multiprocessing_manager = multiprocessing.Manager()

2560

2334

2561

2335

client_class = Client

2562

2336

if use_dbus:

2563

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

2337

client_class = functools.partial(ClientDBusTransitional,

2338

bus = bus)

2564

2339

2565

2340

client_settings = Client.config_parser(client_config)

2566

2341

old_client_settings = {}

2567

2342

clients_data = {}

2568

2343

2569

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

2570

global wnull

2571

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

2572

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

2573

# mode

2574

if debug or not foreground:

2575

wnull.close()

2576

2577

2344

# Get client data and settings from last running state.

2578

2345

if server_settings["restore"]:

2579

2346

try:

2582

2349

(stored_state))

2583

2350

os.remove(stored_state_path)

2584

2351

except IOError as e:

2585

if e.errno == errno.ENOENT:

2586

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

2587

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

2588

else:

2589

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

2590

exc_info=e)

2352

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

2353

.format(e))

2354

if e.errno != errno.ENOENT:

2591

2355

raise

2592

2356

except EOFError as e:

2593

2357

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

2594

"EOFError:", exc_info=e)

2358

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

2595

2359

2596

2360

with PGPEngine() as pgp:

2597

2361

for client_name, client in clients_data.iteritems():

2598

# Skip removed clients

2599

if client_name not in client_settings:

2600

continue

2601

2602

2362

# Decide which value to use after restoring saved state.

2603

2363

# We have three different values: Old config file,

2604

2364

# new config file, and saved state.

2654

2414

.format(client_name))

2655

2415

client["secret"] = (

2656

2416

client_settings[client_name]["secret"])

2417

2657

2418

2658

2419

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

2659

2420

for client_name in (set(old_client_settings)

2662

2423

for client_name in (set(client_settings)

2663

2424

- set(old_client_settings)):

2664

2425

clients_data[client_name] = client_settings[client_name]

2665

2426

2666

2427

# Create all client objects

2667

2428

for client_name, client in clients_data.iteritems():

2668

2429

tcp_server.clients[client_name] = client_class(

2669

name = client_name, settings = client,

2670

server_settings = server_settings)

2430

name = client_name, settings = client)

2671

2431

2672

2432

if not tcp_server.clients:

2673

2433

logger.warning("No clients defined")

2674

2675

if not foreground:

2676

if pidfile is not None:

2677

try:

2678

with pidfile:

2679

pid = os.getpid()

2680

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

2681

except IOError:

2682

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

2683

pidfilename, pid)

2684

del pidfile

2434

2435

if not debug:

2436

try:

2437

with pidfile:

2438

pid = os.getpid()

2439

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

2440

del pidfile

2441

except IOError:

2442

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

2443

pidfilename, pid)

2444

except NameError:

2445

# "pidfile" was never created

2446

pass

2685

2447

del pidfilename

2448

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

2686

2449

2687

2450

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

2688

2451

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

2689

2452

2690

2453

if use_dbus:

2691

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

2692

"se.bsnet.fukt.Mandos"})

2693

2454

class MandosDBusService(DBusObjectWithProperties):

2694

2455

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

2695

2456

def __init__(self):

2749

2510

2750

2511

del _interface

2751

2512

2752

mandos_dbus_service = MandosDBusService()

2513

class MandosDBusServiceTransitional(MandosDBusService):

2514

__metaclass__ = AlternateDBusNamesMetaclass

2515

mandos_dbus_service = MandosDBusServiceTransitional()

2753

2516

2754

2517

def cleanup():

2755

2518

"Cleanup function; run on exit"

2756

if zeroconf:

2757

service.cleanup()

2519

service.cleanup()

2758

2520

2759

2521

multiprocessing.active_children()

2760

wnull.close()

2761

2522

if not (tcp_server.clients or client_settings):

2762

2523

return

2763

2524

2775

2536

# A list of attributes that can not be pickled

2776

2537

# + secret.

2777

2538

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

2778

"checker", "server_settings"))

2539

"checker"))

2779

2540

for name, typ in (inspect.getmembers

2780

2541

(dbus.service.Object)):

2781

2542

exclude.add(name)

2790

2551

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

2791

2552

2792

2553

try:

2793

with (tempfile.NamedTemporaryFile

2794

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

2795

dir=os.path.dirname(stored_state_path),

2796

delete=False)) as stored_state:

2554

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

2555

prefix="clients-",

2556

dir=os.path.dirname

2557

(stored_state_path))

2558

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

2797

2559

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

2798

tempname=stored_state.name

2799

2560

os.rename(tempname, stored_state_path)

2800

2561

except (IOError, OSError) as e:

2562

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

2563

.format(e))

2801

2564

if not debug:

2802

2565

try:

2803

2566

os.remove(tempname)

2804

2567

except NameError:

2805

2568

pass

2806

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

2807

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

2808

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

2809

else:

2810

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

2811

exc_info=e)

2812

raise

2569

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

2570

errno.EEXIST)):

2571

raise e

2813

2572

2814

2573

# Delete all clients, and settings from config

2815

2574

while tcp_server.clients:

2839

2598

tcp_server.server_activate()

2840

2599

2841

2600

# Find out what port we got

2842

if zeroconf:

2843

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

2601

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

2844

2602

if use_ipv6:

2845

2603

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

2846

2604

" flowinfo %d, scope_id %d",

2852

2610

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

2853

2611

2854

2612

try:

2855

if zeroconf:

2856

# From the Avahi example code

2857

try:

2858

service.activate()

2859

except dbus.exceptions.DBusException as error:

2860

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

2861

cleanup()

2862

sys.exit(1)

2863

# End of Avahi example code

2613

# From the Avahi example code

2614

try:

2615

service.activate()

2616

except dbus.exceptions.DBusException as error:

2617

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

2618

cleanup()

2619

sys.exit(1)

2620

# End of Avahi example code

2864

2621

2865

2622

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

2866

2623

lambda *args, **kwargs: