/mandos/trunk : revision 24.1.186

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

28

# along with this program. If not, see

29

# <http://www.gnu.org/licenses/>.

30

#

31

# Contact the authors at <mandos@recompile.se>.

31

# Contact the authors at <mandos@fukt.bsnet.se>.

32

#

33

34

from __future__ import (division, absolute_import, print_function,

63

import cPickle as pickle

64

import multiprocessing

65

import types

66

import binascii

67

import tempfile

68

import itertools

69

66

70

67

import dbus

71

68

import dbus.service

76

73

import ctypes.util

77

74

import xml.dom.minidom

78

75

import inspect

79

import GnuPGInterface

80

76

81

77

try:

82

78

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

86

82

except ImportError:

87

83

SO_BINDTODEVICE = None

88

84

89

version = "1.5.3"

90

stored_state_file = "clients.pickle"

91

92

logger = logging.getLogger()

85

86

version = "1.3.1"

87

88

#logger = logging.getLogger('mandos')

89

logger = logging.Logger('mandos')

93

90

syslogger = (logging.handlers.SysLogHandler

94

91

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

95

92

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

96

97

try:

98

if_nametoindex = (ctypes.cdll.LoadLibrary

99

(ctypes.util.find_library("c"))

100

.if_nametoindex)

101

except (OSError, AttributeError):

102

def if_nametoindex(interface):

103

"Get an interface index the hard way, i.e. using fcntl()"

104

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

105

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

106

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

107

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

108

interface))

109

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

110

ifreq[16:20])[0]

111

return interface_index

112

113

114

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

115

"""init logger and add loglevel"""

116

117

syslogger.setFormatter(logging.Formatter

118

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

119

' %(message)s'))

120

logger.addHandler(syslogger)

121

122

if debug:

123

console = logging.StreamHandler()

124

console.setFormatter(logging.Formatter('%(asctime)s %(name)s'

125

' [%(process)d]:'

126

' %(levelname)s:'

127

' %(message)s'))

128

logger.addHandler(console)

129

logger.setLevel(level)

130

131

132

class PGPError(Exception):

133

"""Exception if encryption/decryption fails"""

134

pass

135

136

137

class PGPEngine(object):

138

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

139

def __init__(self):

140

self.gnupg = GnuPGInterface.GnuPG()

141

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

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

148

149

def __enter__(self):

150

return self

151

152

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

153

self._cleanup()

154

return False

155

156

def __del__(self):

157

self._cleanup()

158

159

def _cleanup(self):

160

if self.tempdir is not None:

161

# Delete contents of tempdir

162

for root, dirs, files in os.walk(self.tempdir,

163

topdown = False):

164

for filename in files:

165

os.remove(os.path.join(root, filename))

166

for dirname in dirs:

167

os.rmdir(os.path.join(root, dirname))

168

# Remove tempdir

169

os.rmdir(self.tempdir)

170

self.tempdir = None

171

172

def password_encode(self, password):

173

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

174

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

175

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

176

177

def encrypt(self, data, password):

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

192

return ciphertext

193

194

def decrypt(self, data, password):

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

209

return decrypted_plaintext

210

211

93

syslogger.setFormatter(logging.Formatter

94

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

95

' %(message)s'))

96

logger.addHandler(syslogger)

97

98

console = logging.StreamHandler()

99

console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'

100

' %(levelname)s:'

101

' %(message)s'))

102

logger.addHandler(console)

212

103

213

104

class AvahiError(Exception):

214

105

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

269

160

" after %i retries, exiting.",

270

161

self.rename_count)

271

162

raise AvahiServiceError("Too many renames")

272

self.name = unicode(self.server

273

.GetAlternativeServiceName(self.name))

163

self.name = unicode(self.server.GetAlternativeServiceName(self.name))

274

164

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

275

165

self.name)

166

syslogger.setFormatter(logging.Formatter

167

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

168

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

169

% self.name))

276

170

self.remove()

277

171

try:

278

172

self.add()

279

173

except dbus.exceptions.DBusException as error:

280

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

174

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

281

175

self.cleanup()

282

176

os._exit(1)

283

177

self.rename_count += 1

298

192

avahi.DBUS_INTERFACE_ENTRY_GROUP)

299

193

self.entry_group_state_changed_match = (

300

194

self.group.connect_to_signal(

301

'StateChanged', self.entry_group_state_changed))

195

'StateChanged', self .entry_group_state_changed))

302

196

logger.debug("Adding Zeroconf service '%s' of type '%s' ...",

303

197

self.name, self.type)

304

198

self.group.AddService(

322

216

elif state == avahi.ENTRY_GROUP_FAILURE:

323

217

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

324

218

unicode(error))

325

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

326

.format(error))

219

raise AvahiGroupError("State changed: %s"

220

% unicode(error))

327

221

def cleanup(self):

328

222

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

329

223

if self.group is not None:

330

224

try:

331

225

self.group.Free()

332

226

except (dbus.exceptions.UnknownMethodException,

333

dbus.exceptions.DBusException):

227

dbus.exceptions.DBusException) as e:

334

228

pass

335

229

self.group = None

336

230

self.remove()

370

264

self.server_state_changed)

371

265

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

372

266

373

class AvahiServiceToSyslog(AvahiService):

374

def rename(self):

375

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

376

ret = AvahiService.rename(self)

377

syslogger.setFormatter(logging.Formatter

378

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

379

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

380

.format(self.name)))

381

return ret

382

267

383

def timedelta_to_milliseconds(td):

268

def _timedelta_to_milliseconds(td):

384

269

"Convert a datetime.timedelta() to milliseconds"

385

270

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

386

271

+ (td.seconds * 1000)

390

275

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

391

276

392

277

Attributes:

393

approved: bool(); 'None' if not yet approved/disapproved

278

_approved: bool(); 'None' if not yet approved/disapproved

394

279

approval_delay: datetime.timedelta(); Time to wait for approval

395

280

approval_duration: datetime.timedelta(); Duration of one approval

396

281

checker: subprocess.Popen(); a running checker process used

403

288

instance %(name)s can be used in the command.

404

289

checker_initiator_tag: a gobject event source tag, or None

405

290

created: datetime.datetime(); (UTC) object creation

406

client_structure: Object describing what attributes a client has

407

and is used for storing the client at exit

408

291

current_checker_command: string; current running checker_command

292

disable_hook: If set, called by disable() as disable_hook(self)

409

293

disable_initiator_tag: a gobject event source tag, or None

410

294

enabled: bool()

411

295

fingerprint: string (40 or 32 hexadecimal digits); used to

414

298

interval: datetime.timedelta(); How often to start a new checker

415

299

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

416

300

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

417

last_checker_status: integer between 0 and 255 reflecting exit

418

status of last checker. -1 reflects crashed

419

checker, -2 means no checker completed yet.

420

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

301

last_enabled: datetime.datetime(); (UTC)

421

302

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

422

303

D-Bus identifiers

423

304

secret: bytestring; sent verbatim (over TLS) to client

424

305

timeout: datetime.timedelta(); How long from last_checked_ok

425

306

until this client is disabled

426

extended_timeout: extra long timeout when secret has been sent

307

extended_timeout: extra long timeout when password has been sent

427

308

runtime_expansions: Allowed attributes for runtime expansion.

428

309

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

429

310

disabled, or None

433

314

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

434

315

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

435

316

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

436

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

437

"extended_timeout": "15m",

438

"interval": "2m",

439

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

440

"host": "",

441

"approval_delay": "0s",

442

"approval_duration": "1s",

443

"approved_by_default": "True",

444

"enabled": "True",

445

}

446

317

447

318

def timeout_milliseconds(self):

448

319

"Return the 'timeout' attribute in milliseconds"

449

return timedelta_to_milliseconds(self.timeout)

320

return _timedelta_to_milliseconds(self.timeout)

450

321

451

322

def extended_timeout_milliseconds(self):

452

323

"Return the 'extended_timeout' attribute in milliseconds"

453

return timedelta_to_milliseconds(self.extended_timeout)

324

return _timedelta_to_milliseconds(self.extended_timeout)

454

325

455

326

def interval_milliseconds(self):

456

327

"Return the 'interval' attribute in milliseconds"

457

return timedelta_to_milliseconds(self.interval)

328

return _timedelta_to_milliseconds(self.interval)

458

329

459

330

def approval_delay_milliseconds(self):

460

return timedelta_to_milliseconds(self.approval_delay)

461

462

@staticmethod

463

def config_parser(config):

464

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

465

{ client_name: {setting_name: value, ...}, ...}

466

with exceptions for any special settings as defined above.

467

NOTE: Must be a pure function. Must return the same result

468

value given the same arguments.

469

"""

470

settings = {}

471

for client_name in config.sections():

472

section = dict(config.items(client_name))

473

client = settings[client_name] = {}

474

475

client["host"] = section["host"]

476

# Reformat values from string types to Python types

477

client["approved_by_default"] = config.getboolean(

478

client_name, "approved_by_default")

479

client["enabled"] = config.getboolean(client_name,

480

"enabled")

481

482

client["fingerprint"] = (section["fingerprint"].upper()

483

.replace(" ", ""))

484

if "secret" in section:

485

client["secret"] = section["secret"].decode("base64")

486

elif "secfile" in section:

487

with open(os.path.expanduser(os.path.expandvars

488

(section["secfile"])),

489

"rb") as secfile:

490

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

491

else:

492

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

493

.format(section))

494

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

495

client["extended_timeout"] = string_to_delta(

496

section["extended_timeout"])

497

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

498

client["approval_delay"] = string_to_delta(

499

section["approval_delay"])

500

client["approval_duration"] = string_to_delta(

501

section["approval_duration"])

502

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

503

client["last_approval_request"] = None

504

client["last_checked_ok"] = None

505

client["last_checker_status"] = -2

506

507

return settings

508

509

510

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

331

return _timedelta_to_milliseconds(self.approval_delay)

332

333

def __init__(self, name = None, disable_hook=None, config=None):

511

334

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

512

335

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

513

336

attribute."""

514

337

self.name = name

515

# adding all client settings

516

for setting, value in settings.iteritems():

517

setattr(self, setting, value)

518

519

if self.enabled:

520

if not hasattr(self, "last_enabled"):

521

self.last_enabled = datetime.datetime.utcnow()

522

if not hasattr(self, "expires"):

523

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

524

+ self.timeout)

525

else:

526

self.last_enabled = None

527

self.expires = None

528

338

if config is None:

339

config = {}

529

340

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

530

341

# Uppercase and remove spaces from fingerprint for later

531

342

# comparison purposes with return value from the fingerprint()

532

343

# function

344

self.fingerprint = (config["fingerprint"].upper()

345

.replace(" ", ""))

533

346

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

534

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

535

datetime.datetime.utcnow())

536

537

# attributes specific for this server instance

347

if "secret" in config:

348

self.secret = config["secret"].decode("base64")

349

elif "secfile" in config:

350

with open(os.path.expanduser(os.path.expandvars

351

(config["secfile"])),

352

"rb") as secfile:

353

self.secret = secfile.read()

354

else:

355

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

356

% self.name)

357

self.host = config.get("host", "")

358

self.created = datetime.datetime.utcnow()

359

self.enabled = False

360

self.last_approval_request = None

361

self.last_enabled = None

362

self.last_checked_ok = None

363

self.timeout = string_to_delta(config["timeout"])

364

self.extended_timeout = string_to_delta(config["extended_timeout"])

365

self.interval = string_to_delta(config["interval"])

366

self.disable_hook = disable_hook

538

367

self.checker = None

539

368

self.checker_initiator_tag = None

540

369

self.disable_initiator_tag = None

370

self.expires = None

541

371

self.checker_callback_tag = None

372

self.checker_command = config["checker"]

542

373

self.current_checker_command = None

543

self.approved = None

374

self.last_connect = None

375

self._approved = None

376

self.approved_by_default = config.get("approved_by_default",

377

True)

544

378

self.approvals_pending = 0

545

self.changedstate = (multiprocessing_manager

546

.Condition(multiprocessing_manager

547

.Lock()))

548

self.client_structure = [attr for attr in

549

self.__dict__.iterkeys()

550

if not attr.startswith("_")]

551

self.client_structure.append("client_structure")

552

553

for name, t in inspect.getmembers(type(self),

554

lambda obj:

555

isinstance(obj,

556

property)):

557

if not name.startswith("_"):

558

self.client_structure.append(name)

379

self.approval_delay = string_to_delta(

380

config["approval_delay"])

381

self.approval_duration = string_to_delta(

382

config["approval_duration"])

383

self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())

559

384

560

# Send notice to process children that client state has changed

561

385

def send_changedstate(self):

562

with self.changedstate:

563

self.changedstate.notify_all()

564

386

self.changedstate.acquire()

387

self.changedstate.notify_all()

388

self.changedstate.release()

389

565

390

def enable(self):

566

391

"""Start this client's checker and timeout hooks"""

567

392

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

568

393

# Already enabled

569

394

return

570

395

self.send_changedstate()

396

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

397

# and every interval from then on.

398

self.checker_initiator_tag = (gobject.timeout_add

399

(self.interval_milliseconds(),

400

self.start_checker))

401

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

571

402

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

403

self.disable_initiator_tag = (gobject.timeout_add

404

(self.timeout_milliseconds(),

405

self.disable))

572

406

self.enabled = True

573

407

self.last_enabled = datetime.datetime.utcnow()

574

self.init_checker()

408

# Also start a new checker *right now*.

409

self.start_checker()

575

410

576

411

def disable(self, quiet=True):

577

412

"""Disable this client."""

589

424

gobject.source_remove(self.checker_initiator_tag)

590

425

self.checker_initiator_tag = None

591

426

self.stop_checker()

427

if self.disable_hook:

428

self.disable_hook(self)

592

429

self.enabled = False

593

430

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

594

431

return False

595

432

596

433

def __del__(self):

434

self.disable_hook = None

597

435

self.disable()

598

436

599

def init_checker(self):

600

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

601

# and every interval from then on.

602

self.checker_initiator_tag = (gobject.timeout_add

603

(self.interval_milliseconds(),

604

self.start_checker))

605

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

606

self.disable_initiator_tag = (gobject.timeout_add

607

(self.timeout_milliseconds(),

608

self.disable))

609

# Also start a new checker *right now*.

610

self.start_checker()

611

612

437

def checker_callback(self, pid, condition, command):

613

438

"""The checker has completed, so take appropriate actions."""

614

439

self.checker_callback_tag = None

615

440

self.checker = None

616

441

if os.WIFEXITED(condition):

617

self.last_checker_status = os.WEXITSTATUS(condition)

618

if self.last_checker_status == 0:

442

exitstatus = os.WEXITSTATUS(condition)

443

if exitstatus == 0:

619

444

logger.info("Checker for %(name)s succeeded",

620

445

vars(self))

621

446

self.checked_ok()

623

448

logger.info("Checker for %(name)s failed",

624

449

vars(self))

625

450

else:

626

self.last_checker_status = -1

627

451

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

628

452

vars(self))

629

453

630

def checked_ok(self):

631

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

632

self.last_checked_ok = datetime.datetime.utcnow()

633

self.last_checker_status = 0

634

self.bump_timeout()

635

636

def bump_timeout(self, timeout=None):

637

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

454

def checked_ok(self, timeout=None):

455

"""Bump up the timeout for this client.

456

457

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

458

alive and well.

459

"""

638

460

if timeout is None:

639

461

timeout = self.timeout

640

if self.disable_initiator_tag is not None:

641

gobject.source_remove(self.disable_initiator_tag)

642

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

643

self.disable_initiator_tag = (gobject.timeout_add

644

(timedelta_to_milliseconds

645

(timeout), self.disable))

646

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

462

self.last_checked_ok = datetime.datetime.utcnow()

463

gobject.source_remove(self.disable_initiator_tag)

464

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

465

self.disable_initiator_tag = (gobject.timeout_add

466

(_timedelta_to_milliseconds(timeout),

467

self.disable))

647

468

648

469

def need_approval(self):

649

470

self.last_approval_request = datetime.datetime.utcnow()

693

514

try:

694

515

command = self.checker_command % escaped_attrs

695

516

except TypeError as error:

696

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

697

self.checker_command, exc_info=error)

517

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

518

' %s', self.checker_command, error)

698

519

return True # Try again later

699

520

self.current_checker_command = command

700

521

try:

718

539

gobject.source_remove(self.checker_callback_tag)

719

540

self.checker_callback(pid, status, command)

720

541

except OSError as error:

721

logger.error("Failed to start subprocess",

722

exc_info=error)

542

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

543

error)

723

544

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

724

545

return True

725

546

732

553

return

733

554

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

734

555

try:

735

self.checker.terminate()

556

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

736

557

#time.sleep(0.5)

737

558

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

738

# self.checker.kill()

559

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

739

560

except OSError as error:

740

561

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

741

562

raise

758

579

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

759

580

if byte_arrays and signature != "ay":

760

581

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

761

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

582

" signature %r" % signature)

762

583

def decorator(func):

763

584

func._dbus_is_property = True

764

585

func._dbus_interface = dbus_interface

772

593

return decorator

773

594

774

595

775

def dbus_interface_annotations(dbus_interface):

776

"""Decorator for marking functions returning interface annotations.

777

778

Usage:

779

780

@dbus_interface_annotations("org.example.Interface")

781

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

782

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

783

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

784

"false"}

785

"""

786

def decorator(func):

787

func._dbus_is_interface = True

788

func._dbus_interface = dbus_interface

789

func._dbus_name = dbus_interface

790

return func

791

return decorator

792

793

794

def dbus_annotations(annotations):

795

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

796

Usage:

797

798

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

799

access="r")

800

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

801

"org.freedesktop.DBus.Property."

802

"EmitsChangedSignal": "false"})

803

def Property_dbus_property(self):

804

return dbus.Boolean(False)

805

"""

806

def decorator(func):

807

func._dbus_annotations = annotations

808

return func

809

return decorator

810

811

812

596

class DBusPropertyException(dbus.exceptions.DBusException):

813

597

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

814

598

"""

837

621

"""

838

622

839

623

@staticmethod

840

def _is_dbus_thing(thing):

841

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

842

843

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

844

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

845

"""

846

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

847

False)

624

def _is_dbus_property(obj):

625

return getattr(obj, "_dbus_is_property", False)

848

626

849

def _get_all_dbus_things(self, thing):

627

def _get_all_dbus_properties(self):

850

628

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

851

629

"""

852

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

853

name),

854

athing.__get__(self))

630

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

855

631

for cls in self.__class__.__mro__

856

for name, athing in

857

inspect.getmembers(cls,

858

self._is_dbus_thing(thing)))

632

for name, prop in inspect.getmembers(cls, self._is_dbus_property))

859

633

860

634

def _get_dbus_property(self, interface_name, property_name):

861

635

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

862

636

property with the specified name and interface.

863

637

"""

864

638

for cls in self.__class__.__mro__:

865

for name, value in (inspect.getmembers

866

(cls,

867

self._is_dbus_thing("property"))):

868

if (value._dbus_name == property_name

869

and value._dbus_interface == interface_name):

639

for name, value in inspect.getmembers(cls, self._is_dbus_property):

640

if value._dbus_name == property_name and value._dbus_interface == interface_name:

870

641

return value.__get__(self)

871

642

872

643

# No such property

873

644

raise DBusPropertyNotFound(self.dbus_object_path + ":"

874

645

+ interface_name + "."

875

646

+ property_name)

647

876

648

877

649

@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",

878

650

out_signature="v")

899

671

# signatures other than "ay".

900

672

if prop._dbus_signature != "ay":

901

673

raise ValueError

902

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

903

for byte in value))

674

value = dbus.ByteArray(''.join(unichr(byte)

675

for byte in value))

904

676

prop(value)

905

677

906

678

@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",

911

683

912

684

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

913

685

"""

914

properties = {}

915

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

686

all = {}

687

for name, prop in self._get_all_dbus_properties():

916

688

if (interface_name

917

689

and interface_name != prop._dbus_interface):

918

690

# Interface non-empty but did not match

922

694

continue

923

695

value = prop()

924

696

if not hasattr(value, "variant_level"):

925

properties[name] = value

697

all[name] = value

926

698

continue

927

properties[name] = type(value)(value, variant_level=

928

value.variant_level+1)

929

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

699

all[name] = type(value)(value, variant_level=

700

value.variant_level+1)

701

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

930

702

931

703

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

932

704

out_signature="s",

933

705

path_keyword='object_path',

934

706

connection_keyword='connection')

935

707

def Introspect(self, object_path, connection):

936

"""Overloading of standard D-Bus method.

937

938

Inserts property tags and interface annotation tags.

708

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

939

709

"""

940

710

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

941

711

connection)

948

718

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

949

719

return e

950

720

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

951

# Add property tags

952

721

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

953

722

for name, prop

954

in self._get_all_dbus_things("property")

723

in self._get_all_dbus_properties()

955

724

if prop._dbus_interface

956

725

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

957

726

if_tag.appendChild(tag)

958

# Add annotation tags

959

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

960

for tag in if_tag.getElementsByTagName(typ):

961

annots = dict()

962

for name, prop in (self.

963

_get_all_dbus_things(typ)):

964

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

965

and prop._dbus_interface

966

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

967

annots.update(getattr

968

(prop,

969

"_dbus_annotations",

970

{}))

971

for name, value in annots.iteritems():

972

ann_tag = document.createElement(

973

"annotation")

974

ann_tag.setAttribute("name", name)

975

ann_tag.setAttribute("value", value)

976

tag.appendChild(ann_tag)

977

# Add interface annotation tags

978

for annotation, value in dict(

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

985

ann_tag = document.createElement("annotation")

986

ann_tag.setAttribute("name", annotation)

987

ann_tag.setAttribute("value", value)

988

if_tag.appendChild(ann_tag)

989

727

# Add the names to the return values for the

990

728

# "org.freedesktop.DBus.Properties" methods

991

729

if (if_tag.getAttribute("name")

1006

744

except (AttributeError, xml.dom.DOMException,

1007

745

xml.parsers.expat.ExpatError) as error:

1008

746

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

1009

exc_info=error)

747

error)

1010

748

return xmlstring

1011

749

1012

750

1017

755

return dbus.String(dt.isoformat(),

1018

756

variant_level=variant_level)

1019

757

1020

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.

1025

"""

758

class transitional_dbus_metaclass(DBusObjectWithProperties.__metaclass__):

1026

759

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

1034

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

1035

# with the wrong interface name

1036

if (not hasattr(attribute, "_dbus_interface")

1037

or not attribute._dbus_interface

1038

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

1039

continue

1040

# Create an alternate D-Bus interface name based on

1041

# the current name

1042

alt_interface = (attribute._dbus_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)

1047

# Is this a D-Bus signal?

1048

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

1049

# Extract the original non-method function by

1050

# black magic

1051

nonmethod_func = (dict(

1052

zip(attribute.func_code.co_freevars,

1053

attribute.__closure__))["func"]

1054

.cell_contents)

1055

# Create a new, but exactly alike, function

1056

# object, and decorate it to be a new D-Bus signal

1057

# with the alternate D-Bus interface name

1058

new_function = (dbus.service.signal

1059

(alt_interface,

1060

attribute._dbus_signature)

1061

(types.FunctionType(

1062

nonmethod_func.func_code,

1063

nonmethod_func.func_globals,

1064

nonmethod_func.func_name,

1065

nonmethod_func.func_defaults,

1066

nonmethod_func.func_closure)))

1067

# Copy annotations, if any

1068

try:

1069

new_function._dbus_annotations = (

1070

dict(attribute._dbus_annotations))

1071

except AttributeError:

1072

pass

1073

# Define a creator of a function to call both the

1074

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

1075

# signals gets sent when the function is called

1076

def fixscope(func1, func2):

1077

"""This function is a scope container to pass

1078

func1 and func2 to the "call_both" function

1079

outside of its arguments"""

1080

def call_both(*args, **kwargs):

1081

"""This function will emit two D-Bus

1082

signals by calling func1 and func2"""

1083

func1(*args, **kwargs)

1084

func2(*args, **kwargs)

1085

return call_both

1086

# Create the "call_both" function and add it to

1087

# the class

1088

attr[attrname] = fixscope(attribute,

1089

new_function)

1090

# Is this a D-Bus method?

1091

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

1092

# Create a new, but exactly alike, function

1093

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

1094

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

1095

# to the class.

1096

attr[attrname] = (dbus.service.method

1097

(alt_interface,

1098

attribute._dbus_in_signature,

1099

attribute._dbus_out_signature)

1100

(types.FunctionType

1101

(attribute.func_code,

1102

attribute.func_globals,

1103

attribute.func_name,

1104

attribute.func_defaults,

1105

attribute.func_closure)))

1106

# Copy annotations, if any

1107

try:

1108

attr[attrname]._dbus_annotations = (

1109

dict(attribute._dbus_annotations))

1110

except AttributeError:

1111

pass

1112

# Is this a D-Bus property?

1113

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

1114

# Create a new, but exactly alike, function

1115

# object, and decorate it to be a new D-Bus

1116

# property with the alternate D-Bus interface

1117

# name. Add it to the class.

1118

attr[attrname] = (dbus_service_property

1119

(alt_interface,

1120

attribute._dbus_signature,

1121

attribute._dbus_access,

1122

attribute

1123

._dbus_get_args_options

1124

["byte_arrays"])

1125

(types.FunctionType

1126

(attribute.func_code,

1127

attribute.func_globals,

1128

attribute.func_name,

1129

attribute.func_defaults,

1130

attribute.func_closure)))

1131

# Copy annotations, if any

1132

try:

1133

attr[attrname]._dbus_annotations = (

1134

dict(attribute._dbus_annotations))

1135

except AttributeError:

1136

pass

1137

# Is this a D-Bus interface?

1138

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

1139

# Create a new, but exactly alike, function

1140

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

1141

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

1142

# to the class.

1143

attr[attrname] = (dbus_interface_annotations

1144

(alt_interface)

1145

(types.FunctionType

1146

(attribute.func_code,

1147

attribute.func_globals,

1148

attribute.func_name,

1149

attribute.func_defaults,

1150

attribute.func_closure)))

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

760

for attrname, old_dbusobj in inspect.getmembers(bases[0]):

761

new_interface = getattr(old_dbusobj, "_dbus_interface", "").replace("se.bsnet.fukt.", "se.recompile.")

762

if (getattr(old_dbusobj, "_dbus_is_signal", False)

763

and old_dbusobj._dbus_interface.startswith("se.bsnet.fukt.Mandos")):

764

unwrappedfunc = dict(zip(old_dbusobj.func_code.co_freevars,

765

old_dbusobj.__closure__))["func"].cell_contents

766

newfunc = types.FunctionType(unwrappedfunc.func_code,

767

unwrappedfunc.func_globals,

768

unwrappedfunc.func_name,

769

unwrappedfunc.func_defaults,

770

unwrappedfunc.func_closure)

771

new_dbusfunc = dbus.service.signal(

772

new_interface, old_dbusobj._dbus_signature)(newfunc)

773

attr["_transitional_" + attrname] = new_dbusfunc

774

775

def fixscope(func1, func2):

776

def newcall(*args, **kwargs):

777

func1(*args, **kwargs)

778

func2(*args, **kwargs)

779

return newcall

780

781

attr[attrname] = fixscope(old_dbusobj, new_dbusfunc)

782

783

elif (getattr(old_dbusobj, "_dbus_is_method", False)

784

and old_dbusobj._dbus_interface.startswith("se.bsnet.fukt.Mandos")):

785

new_dbusfunc = (dbus.service.method

786

(new_interface,

787

old_dbusobj._dbus_in_signature,

788

old_dbusobj._dbus_out_signature)

789

(types.FunctionType

790

(old_dbusobj.func_code,

791

old_dbusobj.func_globals,

792

old_dbusobj.func_name,

793

old_dbusobj.func_defaults,

794

old_dbusobj.func_closure)))

795

796

attr[attrname] = new_dbusfunc

797

elif (getattr(old_dbusobj, "_dbus_is_property", False)

798

and old_dbusobj._dbus_interface.startswith("se.bsnet.fukt.Mandos")):

799

new_dbusfunc = (dbus_service_property

800

(new_interface,

801

old_dbusobj._dbus_signature,

802

old_dbusobj._dbus_access,

803

old_dbusobj._dbus_get_args_options["byte_arrays"])

804

(types.FunctionType

805

(old_dbusobj.func_code,

806

old_dbusobj.func_globals,

807

old_dbusobj.func_name,

808

old_dbusobj.func_defaults,

809

old_dbusobj.func_closure)))

810

811

attr[attrname] = new_dbusfunc

1163

812

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

1164

813

1165

1166

814

class ClientDBus(Client, DBusObjectWithProperties):

1167

815

"""A Client class using D-Bus

1168

816

1177

825

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

1178

826

1179

827

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

828

self._approvals_pending = 0

1180

829

self.bus = bus

1181

830

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

1182

831

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

1192

841

def notifychangeproperty(transform_func,

1193

842

dbus_name, type_func=lambda x: x,

1194

843

variant_level=1):

1195

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

1196

its changes to DBus.

1197

1198

transform_fun: Function that takes a value and a variant_level

1199

and transforms it to a D-Bus type.

1200

dbus_name: D-Bus name of the variable

844

""" Modify a variable so that its a property that announce its

845

changes to DBus.

846

transform_fun: Function that takes a value and transform it to

847

DBus type.

848

dbus_name: DBus name of the variable

1201

849

type_func: Function that transform the value before sending it

1202

to the D-Bus. Default: no transform

1203

variant_level: D-Bus variant level. Default: 1

850

to DBus

851

variant_level: DBus variant level. default: 1

1204

852

"""

1205

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

853

real_value = [None,]

1206

854

def setter(self, value):

855

old_value = real_value[0]

856

real_value[0] = value

1207

857

if hasattr(self, "dbus_object_path"):

1208

if (not hasattr(self, attrname) or

1209

type_func(getattr(self, attrname, None))

1210

!= type_func(value)):

1211

dbus_value = transform_func(type_func(value),

1212

variant_level

1213

=variant_level)

858

if type_func(old_value) != type_func(real_value[0]):

859

dbus_value = transform_func(type_func(real_value[0]),

860

variant_level)

1214

861

self.PropertyChanged(dbus.String(dbus_name),

1215

862

dbus_value)

1216

setattr(self, attrname, value)

1217

863

1218

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

864

return property(lambda self: real_value[0], setter)

1219

865

1220

866

1221

867

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1226

872

last_enabled = notifychangeproperty(datetime_to_dbus,

1227

873

"LastEnabled")

1228

874

checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",

1229

type_func = lambda checker:

1230

checker is not None)

875

type_func = lambda checker: checker is not None)

1231

876

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1232

877

"LastCheckedOK")

1233

last_checker_status = notifychangeproperty(dbus.Int16,

1234

"LastCheckerStatus")

1235

last_approval_request = notifychangeproperty(

1236

datetime_to_dbus, "LastApprovalRequest")

878

last_approval_request = notifychangeproperty(datetime_to_dbus,

879

"LastApprovalRequest")

1237

880

approved_by_default = notifychangeproperty(dbus.Boolean,

1238

881

"ApprovedByDefault")

1239

approval_delay = notifychangeproperty(dbus.UInt64,

1240

"ApprovalDelay",

1241

type_func =

1242

timedelta_to_milliseconds)

1243

approval_duration = notifychangeproperty(

1244

dbus.UInt64, "ApprovalDuration",

1245

type_func = timedelta_to_milliseconds)

882

approval_delay = notifychangeproperty(dbus.UInt16, "ApprovalDelay",

883

type_func = _timedelta_to_milliseconds)

884

approval_duration = notifychangeproperty(dbus.UInt16, "ApprovalDuration",

885

type_func = _timedelta_to_milliseconds)

1246

886

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

1247

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

1248

type_func =

1249

timedelta_to_milliseconds)

1250

extended_timeout = notifychangeproperty(

1251

dbus.UInt64, "ExtendedTimeout",

1252

type_func = timedelta_to_milliseconds)

1253

interval = notifychangeproperty(dbus.UInt64,

1254

"Interval",

1255

type_func =

1256

timedelta_to_milliseconds)

887

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

888

type_func = _timedelta_to_milliseconds)

889

extended_timeout = notifychangeproperty(dbus.UInt16, "ExtendedTimeout",

890

type_func = _timedelta_to_milliseconds)

891

interval = notifychangeproperty(dbus.UInt16, "Interval",

892

type_func = _timedelta_to_milliseconds)

1257

893

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

1258

894

1259

895

del notifychangeproperty

1301

937

return r

1302

938

1303

939

def _reset_approved(self):

1304

self.approved = None

940

self._approved = None

1305

941

return False

1306

942

1307

943

def approve(self, value=True):

1308

944

self.send_changedstate()

1309

self.approved = value

1310

gobject.timeout_add(timedelta_to_milliseconds

945

self._approved = value

946

gobject.timeout_add(_timedelta_to_milliseconds

1311

947

(self.approval_duration),

1312

948

self._reset_approved)

1313

949

1314

950

1315

951

## D-Bus methods, signals & properties

1316

_interface = "se.recompile.Mandos.Client"

1317

1318

## Interfaces

1319

1320

@dbus_interface_annotations(_interface)

1321

def _foo(self):

1322

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

1323

"false"}

1324

952

_interface = "se.bsnet.fukt.Mandos.Client"

953

1325

954

## Signals

1326

955

1327

956

# CheckerCompleted - signal

1426

1055

access="readwrite")

1427

1056

def ApprovalDuration_dbus_property(self, value=None):

1428

1057

if value is None: # get

1429

return dbus.UInt64(timedelta_to_milliseconds(

1058

return dbus.UInt64(_timedelta_to_milliseconds(

1430

1059

self.approval_duration))

1431

1060

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

1432

1061

1446

1075

def Host_dbus_property(self, value=None):

1447

1076

if value is None: # get

1448

1077

return dbus.String(self.host)

1449

self.host = unicode(value)

1078

self.host = value

1450

1079

1451

1080

# Created - property

1452

1081

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

1453

1082

def Created_dbus_property(self):

1454

return datetime_to_dbus(self.created)

1083

return dbus.String(datetime_to_dbus(self.created))

1455

1084

1456

1085

# LastEnabled - property

1457

1086

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

1478

1107

return

1479

1108

return datetime_to_dbus(self.last_checked_ok)

1480

1109

1481

# LastCheckerStatus - property

1482

@dbus_service_property(_interface, signature="n",

1483

access="read")

1484

def LastCheckerStatus_dbus_property(self):

1485

return dbus.Int16(self.last_checker_status)

1486

1487

1110

# Expires - property

1488

1111

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

1489

1112

def Expires_dbus_property(self):

1501

1124

if value is None: # get

1502

1125

return dbus.UInt64(self.timeout_milliseconds())

1503

1126

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

1127

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

1128

return

1504

1129

# Reschedule timeout

1505

if self.enabled:

1506

now = datetime.datetime.utcnow()

1507

time_to_die = timedelta_to_milliseconds(

1508

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

1509

if time_to_die <= 0:

1510

# The timeout has passed

1511

self.disable()

1512

else:

1513

self.expires = (now +

1514

datetime.timedelta(milliseconds =

1515

time_to_die))

1516

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

1517

is None):

1518

return

1519

gobject.source_remove(self.disable_initiator_tag)

1520

self.disable_initiator_tag = (gobject.timeout_add

1521

(time_to_die,

1522

self.disable))

1130

gobject.source_remove(self.disable_initiator_tag)

1131

self.disable_initiator_tag = None

1132

self.expires = None

1133

time_to_die = (self.

1134

_timedelta_to_milliseconds((self

1135

.last_checked_ok

1136

+ self.timeout)

1137

- datetime.datetime

1138

.utcnow()))

1139

if time_to_die <= 0:

1140

# The timeout has passed

1141

self.disable()

1142

else:

1143

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

1144

+ datetime.timedelta(milliseconds = time_to_die))

1145

self.disable_initiator_tag = (gobject.timeout_add

1146

(time_to_die, self.disable))

1523

1147

1524

1148

# ExtendedTimeout - property

1525

1149

@dbus_service_property(_interface, signature="t",

1538

1162

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

1539

1163

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

1540

1164

return

1541

if self.enabled:

1542

# Reschedule checker run

1543

gobject.source_remove(self.checker_initiator_tag)

1544

self.checker_initiator_tag = (gobject.timeout_add

1545

(value, self.start_checker))

1546

self.start_checker() # Start one now, too

1165

# Reschedule checker run

1166

gobject.source_remove(self.checker_initiator_tag)

1167

self.checker_initiator_tag = (gobject.timeout_add

1168

(value, self.start_checker))

1169

self.start_checker() # Start one now, too

1547

1170

1548

1171

# Checker - property

1549

1172

@dbus_service_property(_interface, signature="s",

1551

1174

def Checker_dbus_property(self, value=None):

1552

1175

if value is None: # get

1553

1176

return dbus.String(self.checker_command)

1554

self.checker_command = unicode(value)

1177

self.checker_command = value

1555

1178

1556

1179

# CheckerRunning - property

1557

1180

@dbus_service_property(_interface, signature="b",

1586

1209

raise KeyError()

1587

1210

1588

1211

def __getattribute__(self, name):

1589

if name == '_pipe':

1212

if(name == '_pipe'):

1590

1213

return super(ProxyClient, self).__getattribute__(name)

1591

1214

self._pipe.send(('getattr', name))

1592

1215

data = self._pipe.recv()

1599

1222

return func

1600

1223

1601

1224

def __setattr__(self, name, value):

1602

if name == '_pipe':

1225

if(name == '_pipe'):

1603

1226

return super(ProxyClient, self).__setattr__(name, value)

1604

1227

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

1605

1228

1606

1607

1229

class ClientDBusTransitional(ClientDBus):

1608

__metaclass__ = AlternateDBusNamesMetaclass

1609

1230

__metaclass__ = transitional_dbus_metaclass

1610

1231

1611

1232

class ClientHandler(socketserver.BaseRequestHandler, object):

1612

1233

"""A class to handle client connections.

1692

1313

client.name)

1693

1314

if self.server.use_dbus:

1694

1315

# Emit D-Bus signal

1695

client.Rejected("Disabled")

1316

client.Rejected("Disabled")

1696

1317

return

1697

1318

1698

if client.approved or not client.approval_delay:

1319

if client._approved or not client.approval_delay:

1699

1320

#We are approved or approval is disabled

1700

1321

break

1701

elif client.approved is None:

1322

elif client._approved is None:

1702

1323

logger.info("Client %s needs approval",

1703

1324

client.name)

1704

1325

if self.server.use_dbus:

1715

1336

return

1716

1337

1717

1338

#wait until timeout or approved

1339

#x = float(client._timedelta_to_milliseconds(delay))

1718

1340

time = datetime.datetime.now()

1719

1341

client.changedstate.acquire()

1720

(client.changedstate.wait

1721

(float(client.timedelta_to_milliseconds(delay)

1722

/ 1000)))

1342

client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))

1723

1343

client.changedstate.release()

1724

1344

time2 = datetime.datetime.now()

1725

1345

if (time2 - time) >= delay:

1749

1369

sent_size += sent

1750

1370

1751

1371

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

1752

# bump the timeout using extended_timeout

1753

client.bump_timeout(client.extended_timeout)

1372

# bump the timeout as if seen

1373

client.checked_ok(client.extended_timeout)

1754

1374

if self.server.use_dbus:

1755

1375

# Emit D-Bus signal

1756

1376

client.GotSecret()

1823

1443

# Convert the buffer to a Python bytestring

1824

1444

fpr = ctypes.string_at(buf, buf_len.value)

1825

1445

# Convert the bytestring to hexadecimal notation

1826

hex_fpr = binascii.hexlify(fpr).upper()

1446

hex_fpr = ''.join("%02X" % ord(char) for char in fpr)

1827

1447

return hex_fpr

1828

1448

1829

1449

1832

1452

def sub_process_main(self, request, address):

1833

1453

try:

1834

1454

self.finish_request(request, address)

1835

except Exception:

1455

except:

1836

1456

self.handle_error(request, address)

1837

1457

self.close_request(request)

1838

1458

1839

1459

def process_request(self, request, address):

1840

1460

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

1841

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

1842

args = (request,

1843

address))

1844

proc.start()

1845

return proc

1461

multiprocessing.Process(target = self.sub_process_main,

1462

args = (request, address)).start()

1846

1463

1847

1464

1848

1465

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1854

1471

"""

1855

1472

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1856

1473

1857

proc = MultiprocessingMixIn.process_request(self, request,

1858

client_address)

1474

super(MultiprocessingMixInWithPipe,

1475

self).process_request(request, client_address)

1859

1476

self.child_pipe.close()

1860

self.add_pipe(parent_pipe, proc)

1477

self.add_pipe(parent_pipe)

1861

1478

1862

def add_pipe(self, parent_pipe, proc):

1479

def add_pipe(self, parent_pipe):

1863

1480

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

1864

1481

raise NotImplementedError

1865

1482

1943

1560

self.enabled = False

1944

1561

self.clients = clients

1945

1562

if self.clients is None:

1946

self.clients = {}

1563

self.clients = set()

1947

1564

self.use_dbus = use_dbus

1948

1565

self.gnutls_priority = gnutls_priority

1949

1566

IPv6_TCPServer.__init__(self, server_address,

1953

1570

def server_activate(self):

1954

1571

if self.enabled:

1955

1572

return socketserver.TCPServer.server_activate(self)

1956

1957

1573

def enable(self):

1958

1574

self.enabled = True

1959

1960

def add_pipe(self, parent_pipe, proc):

1575

def add_pipe(self, parent_pipe):

1961

1576

# Call "handle_ipc" for both data and EOF events

1962

1577

gobject.io_add_watch(parent_pipe.fileno(),

1963

1578

gobject.IO_IN | gobject.IO_HUP,

1964

1579

functools.partial(self.handle_ipc,

1965

parent_pipe =

1966

parent_pipe,

1967

proc = proc))

1968

1580

parent_pipe = parent_pipe))

1581

1969

1582

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

1970

proc = None, client_object=None):

1583

client_object=None):

1971

1584

condition_names = {

1972

1585

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

1973

1586

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

1982

1595

for cond, name in

1983

1596

condition_names.iteritems()

1984

1597

if cond & condition)

1985

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

1598

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

1986

1599

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

1987

# Wait for other process to exit

1988

proc.join()

1989

1600

return False

1990

1601

1991

1602

# Read a request from the child

1996

1607

fpr = request[1]

1997

1608

address = request[2]

1998

1609

1999

for c in self.clients.itervalues():

1610

for c in self.clients:

2000

1611

if c.fingerprint == fpr:

2001

1612

client = c

2002

1613

break

2005

1616

"dress: %s", fpr, address)

2006

1617

if self.use_dbus:

2007

1618

# Emit D-Bus signal

2008

mandos_dbus_service.ClientNotFound(fpr,

2009

address[0])

1619

mandos_dbus_service.ClientNotFound(fpr, address[0])

2010

1620

parent_pipe.send(False)

2011

1621

return False

2012

1622

2013

1623

gobject.io_add_watch(parent_pipe.fileno(),

2014

1624

gobject.IO_IN | gobject.IO_HUP,

2015

1625

functools.partial(self.handle_ipc,

2016

parent_pipe =

2017

parent_pipe,

2018

proc = proc,

2019

client_object =

2020

client))

1626

parent_pipe = parent_pipe,

1627

client_object = client))

2021

1628

parent_pipe.send(True)

2022

# remove the old hook in favor of the new above hook on

2023

# same fileno

1629

# remove the old hook in favor of the new above hook on same fileno

2024

1630

return False

2025

1631

if command == 'funcall':

2026

1632

funcname = request[1]

2027

1633

args = request[2]

2028

1634

kwargs = request[3]

2029

1635

2030

parent_pipe.send(('data', getattr(client_object,

2031

funcname)(*args,

2032

**kwargs)))

1636

parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))

2033

1637

2034

1638

if command == 'getattr':

2035

1639

attrname = request[1]

2036

1640

if callable(client_object.__getattribute__(attrname)):

2037

1641

parent_pipe.send(('function',))

2038

1642

else:

2039

parent_pipe.send(('data', client_object

2040

.__getattribute__(attrname)))

1643

parent_pipe.send(('data', client_object.__getattribute__(attrname)))

2041

1644

2042

1645

if command == 'setattr':

2043

1646

attrname = request[1]

2079

1682

elif suffix == "w":

2080

1683

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

2081

1684

else:

2082

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

2083

.format(suffix))

1685

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

2084

1686

except (ValueError, IndexError) as e:

2085

1687

raise ValueError(*(e.args))

2086

1688

timevalue += delta

2087

1689

return timevalue

2088

1690

2089

1691

1692

def if_nametoindex(interface):

1693

"""Call the C function if_nametoindex(), or equivalent

1694

1695

Note: This function cannot accept a unicode string."""

1696

global if_nametoindex

1697

try:

1698

if_nametoindex = (ctypes.cdll.LoadLibrary

1699

(ctypes.util.find_library("c"))

1700

.if_nametoindex)

1701

except (OSError, AttributeError):

1702

logger.warning("Doing if_nametoindex the hard way")

1703

def if_nametoindex(interface):

1704

"Get an interface index the hard way, i.e. using fcntl()"

1705

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

1706

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

1707

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1708

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

1709

interface))

1710

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

1711

ifreq[16:20])[0]

1712

return interface_index

1713

return if_nametoindex(interface)

1714

1715

2090

1716

def daemon(nochdir = False, noclose = False):

2091

1717

"""See daemon(3). Standard BSD Unix function.

2092

1718

2100

1726

sys.exit()

2101

1727

if not noclose:

2102

1728

# Close all standard open file descriptors

2103

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

1729

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

2104

1730

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

2105

1731

raise OSError(errno.ENODEV,

2106

"{0} not a character device"

2107

.format(os.devnull))

1732

"%s not a character device"

1733

% os.path.devnull)

2108

1734

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

2109

1735

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

2110

1736

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

2119

1745

2120

1746

parser = argparse.ArgumentParser()

2121

1747

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

2122

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

1748

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

2123

1749

help="show version number and exit")

2124

1750

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

2125

1751

help="Bind to interface IF")

2147

1773

" system bus interface")

2148

1774

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

2149

1775

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

2150

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

2151

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

2152

" state")

2153

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

2154

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

2155

2156

1776

options = parser.parse_args()

2157

1777

2158

1778

if options.check:

2171

1791

"use_dbus": "True",

2172

1792

"use_ipv6": "True",

2173

1793

"debuglevel": "",

2174

"restore": "True",

2175

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

2176

1794

}

2177

1795

2178

1796

# Parse config file for server-global settings

2195

1813

# options, if set.

2196

1814

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

2197

1815

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

2198

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

2199

"statedir"):

1816

"use_dbus", "use_ipv6", "debuglevel"):

2200

1817

value = getattr(options, option)

2201

1818

if value is not None:

2202

1819

server_settings[option] = value

2214

1831

debuglevel = server_settings["debuglevel"]

2215

1832

use_dbus = server_settings["use_dbus"]

2216

1833

use_ipv6 = server_settings["use_ipv6"]

2217

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

2218

stored_state_file)

2219

2220

if debug:

2221

initlogger(debug, logging.DEBUG)

2222

else:

2223

if not debuglevel:

2224

initlogger(debug)

2225

else:

2226

level = getattr(logging, debuglevel.upper())

2227

initlogger(debug, level)

2228

1834

2229

1835

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

2230

1836

syslogger.setFormatter(logging.Formatter

2231

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

2232

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

2233

.format(server_settings

2234

["servicename"])))

1837

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

1838

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

1839

% server_settings["servicename"]))

2235

1840

2236

1841

# Parse config file with clients

2237

client_config = configparser.SafeConfigParser(Client

2238

.client_defaults)

1842

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

1843

"extended_timeout": "15m",

1844

"interval": "2m",

1845

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

1846

"host": "",

1847

"approval_delay": "0s",

1848

"approval_duration": "1s",

1849

}

1850

client_config = configparser.SafeConfigParser(client_defaults)

2239

1851

client_config.read(os.path.join(server_settings["configdir"],

2240

1852

"clients.conf"))

2241

1853

2258

1870

except IOError:

2259

1871

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

2260

1872

2261

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

1873

try:

1874

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

1875

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

1876

except KeyError:

2262

1877

try:

2263

uid = pwd.getpwnam(name).pw_uid

2264

gid = pwd.getpwnam(name).pw_gid

2265

break

1878

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

1879

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

2266

1880

except KeyError:

2267

continue

2268

else:

2269

uid = 65534

2270

gid = 65534

1881

try:

1882

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

1883

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

1884

except KeyError:

1885

uid = 65534

1886

gid = 65534

2271

1887

try:

2272

1888

os.setgid(gid)

2273

1889

os.setuid(uid)

2275

1891

if error[0] != errno.EPERM:

2276

1892

raise error

2277

1893

1894

if not debug and not debuglevel:

1895

syslogger.setLevel(logging.WARNING)

1896

console.setLevel(logging.WARNING)

1897

if debuglevel:

1898

level = getattr(logging, debuglevel.upper())

1899

syslogger.setLevel(level)

1900

console.setLevel(level)

1901

2278

1902

if debug:

2279

1903

# Enable all possible GnuTLS debugging

2280

1904

2290

1914

.gnutls_global_set_log_function(debug_gnutls))

2291

1915

2292

1916

# Redirect stdin so all checkers get /dev/null

2293

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

1917

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

2294

1918

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

2295

1919

if null > 2:

2296

1920

os.close(null)

1921

else:

1922

# No console logging

1923

logger.removeHandler(console)

2297

1924

2298

1925

# Need to fork before connecting to D-Bus

2299

1926

if not debug:

2300

1927

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

2301

1928

daemon()

2302

1929

2303

gobject.threads_init()

2304

2305

1930

global main_loop

2306

1931

# From the Avahi example code

2307

DBusGMainLoop(set_as_default=True)

1932

DBusGMainLoop(set_as_default=True )

2308

1933

main_loop = gobject.MainLoop()

2309

1934

bus = dbus.SystemBus()

2310

1935

# End of Avahi example code

2311

1936

if use_dbus:

2312

1937

try:

2313

bus_name = dbus.service.BusName("se.recompile.Mandos",

2314

bus, do_not_queue=True)

2315

old_bus_name = (dbus.service.BusName

2316

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

2317

do_not_queue=True))

1938

bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",

1939

bus, do_not_queue=True)

1940

bus_name2 = dbus.service.BusName("se.recompile.Mandos",

1941

bus, do_not_queue=True)

2318

1942

except dbus.exceptions.NameExistsException as e:

2319

1943

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

2320

1944

use_dbus = False

2321

1945

server_settings["use_dbus"] = False

2322

1946

tcp_server.use_dbus = False

2323

1947

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)

1948

service = AvahiService(name = server_settings["servicename"],

1949

servicetype = "_mandos._tcp",

1950

protocol = protocol, bus = bus)

2328

1951

if server_settings["interface"]:

2329

1952

service.interface = (if_nametoindex

2330

1953

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

2334

1957

2335

1958

client_class = Client

2336

1959

if use_dbus:

2337

client_class = functools.partial(ClientDBusTransitional,

2338

bus = bus)

2339

2340

client_settings = Client.config_parser(client_config)

2341

old_client_settings = {}

2342

clients_data = {}

2343

2344

# Get client data and settings from last running state.

2345

if server_settings["restore"]:

2346

try:

2347

with open(stored_state_path, "rb") as stored_state:

2348

clients_data, old_client_settings = (pickle.load

2349

(stored_state))

2350

os.remove(stored_state_path)

2351

except IOError as e:

2352

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

2353

.format(e))

2354

if e.errno != errno.ENOENT:

2355

raise

2356

except EOFError as e:

2357

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

2358

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

2359

2360

with PGPEngine() as pgp:

2361

for client_name, client in clients_data.iteritems():

2362

# Decide which value to use after restoring saved state.

2363

# We have three different values: Old config file,

2364

# new config file, and saved state.

2365

# New config value takes precedence if it differs from old

2366

# config value, otherwise use saved state.

2367

for name, value in client_settings[client_name].items():

2368

try:

2369

# For each value in new config, check if it

2370

# differs from the old config value (Except for

2371

# the "secret" attribute)

2372

if (name != "secret" and

2373

value != old_client_settings[client_name]

2374

[name]):

2375

client[name] = value

2376

except KeyError:

2377

pass

2378

2379

# Clients who has passed its expire date can still be

2380

# enabled if its last checker was successful. Clients

2381

# whose checker succeeded before we stored its state is

2382

# assumed to have successfully run all checkers during

2383

# downtime.

2384

if client["enabled"]:

2385

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

2386

if not client["last_checked_ok"]:

2387

logger.warning(

2388

"disabling client {0} - Client never "

2389

"performed a successful checker"

2390

.format(client_name))

2391

client["enabled"] = False

2392

elif client["last_checker_status"] != 0:

2393

logger.warning(

2394

"disabling client {0} - Client "

2395

"last checker failed with error code {1}"

2396

.format(client_name,

2397

client["last_checker_status"]))

2398

client["enabled"] = False

2399

else:

2400

client["expires"] = (datetime.datetime

2401

.utcnow()

2402

+ client["timeout"])

2403

logger.debug("Last checker succeeded,"

2404

" keeping {0} enabled"

2405

.format(client_name))

1960

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

1961

def client_config_items(config, section):

1962

special_settings = {

1963

"approved_by_default":

1964

lambda: config.getboolean(section,

1965

"approved_by_default"),

1966

}

1967

for name, value in config.items(section):

2406

1968

try:

2407

client["secret"] = (

2408

pgp.decrypt(client["encrypted_secret"],

2409

client_settings[client_name]

2410

["secret"]))

2411

except PGPError:

2412

# If decryption fails, we use secret from new settings

2413

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

2414

.format(client_name))

2415

client["secret"] = (

2416

client_settings[client_name]["secret"])

2417

2418

2419

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

2420

for client_name in (set(old_client_settings)

2421

- set(client_settings)):

2422

del clients_data[client_name]

2423

for client_name in (set(client_settings)

2424

- set(old_client_settings)):

2425

clients_data[client_name] = client_settings[client_name]

2426

2427

# Create all client objects

2428

for client_name, client in clients_data.iteritems():

2429

tcp_server.clients[client_name] = client_class(

2430

name = client_name, settings = client)

2431

1969

yield (name, special_settings[name]())

1970

except KeyError:

1971

yield (name, value)

1972

1973

tcp_server.clients.update(set(

1974

client_class(name = section,

1975

config= dict(client_config_items(

1976

client_config, section)))

1977

for section in client_config.sections()))

2432

1978

if not tcp_server.clients:

2433

1979

logger.warning("No clients defined")

2434

1980

2445

1991

# "pidfile" was never created

2446

1992

pass

2447

1993

del pidfilename

1994

2448

1995

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

2449

1996

2450

1997

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

2451

1998

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

2452

1999

2453

2000

if use_dbus:

2454

class MandosDBusService(DBusObjectWithProperties):

2001

class MandosDBusService(dbus.service.Object):

2455

2002

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

2456

2003

def __init__(self):

2457

2004

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

2458

_interface = "se.recompile.Mandos"

2459

2460

@dbus_interface_annotations(_interface)

2461

def _foo(self):

2462

return { "org.freedesktop.DBus.Property"

2463

".EmitsChangedSignal":

2464

"false"}

2005

_interface = "se.bsnet.fukt.Mandos"

2465

2006

2466

2007

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

2467

2008

def ClientAdded(self, objpath):

2482

2023

def GetAllClients(self):

2483

2024

"D-Bus method"

2484

2025

return dbus.Array(c.dbus_object_path

2485

for c in

2486

tcp_server.clients.itervalues())

2026

for c in tcp_server.clients)

2487

2027

2488

2028

@dbus.service.method(_interface,

2489

2029

out_signature="a{oa{sv}}")

2491

2031

"D-Bus method"

2492

2032

return dbus.Dictionary(

2493

2033

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

2494

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

2034

for c in tcp_server.clients),

2495

2035

signature="oa{sv}")

2496

2036

2497

2037

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

2498

2038

def RemoveClient(self, object_path):

2499

2039

"D-Bus method"

2500

for c in tcp_server.clients.itervalues():

2040

for c in tcp_server.clients:

2501

2041

if c.dbus_object_path == object_path:

2502

del tcp_server.clients[c.name]

2042

tcp_server.clients.remove(c)

2503

2043

c.remove_from_connection()

2504

2044

# Don't signal anything except ClientRemoved

2505

2045

c.disable(quiet=True)

2511

2051

del _interface

2512

2052

2513

2053

class MandosDBusServiceTransitional(MandosDBusService):

2514

__metaclass__ = AlternateDBusNamesMetaclass

2054

__metaclass__ = transitional_dbus_metaclass

2515

2055

mandos_dbus_service = MandosDBusServiceTransitional()

2516

2056

2517

2057

def cleanup():

2518

2058

"Cleanup function; run on exit"

2519

2059

service.cleanup()

2520

2060

2521

multiprocessing.active_children()

2522

if not (tcp_server.clients or client_settings):

2523

return

2524

2525

# Store client before exiting. Secrets are encrypted with key

2526

# based on what config file has. If config file is

2527

# removed/edited, old secret will thus be unrecovable.

2528

clients = {}

2529

with PGPEngine() as pgp:

2530

for client in tcp_server.clients.itervalues():

2531

key = client_settings[client.name]["secret"]

2532

client.encrypted_secret = pgp.encrypt(client.secret,

2533

key)

2534

client_dict = {}

2535

2536

# A list of attributes that can not be pickled

2537

# + secret.

2538

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

2539

"checker"))

2540

for name, typ in (inspect.getmembers

2541

(dbus.service.Object)):

2542

exclude.add(name)

2543

2544

client_dict["encrypted_secret"] = (client

2545

.encrypted_secret)

2546

for attr in client.client_structure:

2547

if attr not in exclude:

2548

client_dict[attr] = getattr(client, attr)

2549

2550

clients[client.name] = client_dict

2551

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

2552

2553

try:

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:

2559

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

2560

os.rename(tempname, stored_state_path)

2561

except (IOError, OSError) as e:

2562

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

2563

.format(e))

2564

if not debug:

2565

try:

2566

os.remove(tempname)

2567

except NameError:

2568

pass

2569

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

2570

errno.EEXIST)):

2571

raise e

2572

2573

# Delete all clients, and settings from config

2574

2061

while tcp_server.clients:

2575

name, client = tcp_server.clients.popitem()

2062

client = tcp_server.clients.pop()

2576

2063

if use_dbus:

2577

2064

client.remove_from_connection()

2065

client.disable_hook = None

2578

2066

# Don't signal anything except ClientRemoved

2579

2067

client.disable(quiet=True)

2580

2068

if use_dbus:

2581

2069

# Emit D-Bus signal

2582

mandos_dbus_service.ClientRemoved(client

2583

.dbus_object_path,

2070

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

2584

2071

client.name)

2585

client_settings.clear()

2586

2072

2587

2073

atexit.register(cleanup)

2588

2074

2589

for client in tcp_server.clients.itervalues():

2075

for client in tcp_server.clients:

2590

2076

if use_dbus:

2591

2077

# Emit D-Bus signal

2592

2078

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2593

# Need to initiate checking of clients

2594

if client.enabled:

2595

client.init_checker()

2079

client.enable()

2596

2080

2597

2081

tcp_server.enable()

2598

2082

tcp_server.server_activate()

2601

2085

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

2602

2086

if use_ipv6:

2603

2087

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

2604

" flowinfo %d, scope_id %d",

2605

*tcp_server.socket.getsockname())

2088

" flowinfo %d, scope_id %d"

2089

% tcp_server.socket.getsockname())

2606

2090

else: # IPv4

2607

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

2608

*tcp_server.socket.getsockname())

2091

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

2092

% tcp_server.socket.getsockname())

2609

2093

2610

2094

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

2611

2095

2614

2098

try:

2615

2099

service.activate()

2616

2100

except dbus.exceptions.DBusException as error:

2617

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

2101

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

2618

2102

cleanup()

2619

2103

sys.exit(1)

2620

2104

# End of Avahi example code

2627

2111

logger.debug("Starting main loop")

2628

2112

main_loop.run()

2629

2113

except AvahiError as error:

2630

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

2114

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

2631

2115

cleanup()

2632

2116

sys.exit(1)

2633

2117

except KeyboardInterrupt:

2638

2122

# Must run before the D-Bus bus name gets deregistered

2639

2123

cleanup()

2640

2124

2125

2641

2126

if __name__ == '__main__':

2642

2127

main()