/mandos/trunk : revision 450

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

31

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

32

#

33

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

34

from __future__ import division, with_statement, absolute_import

36

35

37

36

import SocketServer as socketserver

38

37

import socket

39

import argparse

38

import optparse

40

39

import datetime

41

40

import errno

42

41

import gnutls.crypto

82

81

SO_BINDTODEVICE = None

83

82

84

83

85

version = "1.3.1"

84

version = "1.2"

86

85

87

#logger = logging.getLogger('mandos')

88

logger = logging.Logger('mandos')

86

#logger = logging.getLogger(u'mandos')

87

logger = logging.Logger(u'mandos')

89

88

syslogger = (logging.handlers.SysLogHandler

90

89

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

91

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

90

address = "/dev/log"))

92

91

syslogger.setFormatter(logging.Formatter

93

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

94

' %(message)s'))

92

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

93

u' %(message)s'))

95

94

logger.addHandler(syslogger)

96

95

97

96

console = logging.StreamHandler()

98

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

99

' %(levelname)s:'

100

' %(message)s'))

97

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

98

u' %(levelname)s:'

99

u' %(message)s'))

101

100

logger.addHandler(console)

102

101

103

102

class AvahiError(Exception):

120

119

Attributes:

121

120

interface: integer; avahi.IF_UNSPEC or an interface index.

122

121

Used to optionally bind to the specified interface.

123

name: string; Example: 'Mandos'

124

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

122

name: string; Example: u'Mandos'

123

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

125

124

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

126

125

port: integer; what port to announce

127

126

TXT: list of strings; TXT record for the service

136

135

"""

137

136

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

138

137

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

139

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

138

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

140

139

protocol = avahi.PROTO_UNSPEC, bus = None):

141

140

self.interface = interface

142

141

self.name = name

151

150

self.group = None # our entry group

152

151

self.server = None

153

152

self.bus = bus

154

self.entry_group_state_changed_match = None

155

153

def rename(self):

156

154

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

157

155

if self.rename_count >= self.max_renames:

158

logger.critical("No suitable Zeroconf service name found"

159

" after %i retries, exiting.",

156

logger.critical(u"No suitable Zeroconf service name found"

157

u" after %i retries, exiting.",

160

158

self.rename_count)

161

raise AvahiServiceError("Too many renames")

159

raise AvahiServiceError(u"Too many renames")

162

160

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

163

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

161

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

164

162

self.name)

165

163

syslogger.setFormatter(logging.Formatter

166

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

167

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

164

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

165

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

168

166

% self.name))

169

167

self.remove()

170

168

try:

171

169

self.add()

172

except dbus.exceptions.DBusException as error:

173

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

170

except dbus.exceptions.DBusException, error:

171

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

174

172

self.cleanup()

175

173

os._exit(1)

176

174

self.rename_count += 1

177

175

def remove(self):

178

176

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

179

if self.entry_group_state_changed_match is not None:

180

self.entry_group_state_changed_match.remove()

181

self.entry_group_state_changed_match = None

182

177

if self.group is not None:

183

178

self.group.Reset()

184

179

def add(self):

185

180

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

186

self.remove()

187

181

if self.group is None:

188

182

self.group = dbus.Interface(

189

183

self.bus.get_object(avahi.DBUS_NAME,

190

184

self.server.EntryGroupNew()),

191

185

avahi.DBUS_INTERFACE_ENTRY_GROUP)

192

self.entry_group_state_changed_match = (

193

self.group.connect_to_signal(

194

'StateChanged', self .entry_group_state_changed))

195

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

186

self.group.connect_to_signal('StateChanged',

187

self

188

.entry_group_state_changed)

189

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

196

190

self.name, self.type)

197

191

self.group.AddService(

198

192

self.interface,

205

199

self.group.Commit()

206

200

def entry_group_state_changed(self, state, error):

207

201

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

208

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

202

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

209

203

210

204

if state == avahi.ENTRY_GROUP_ESTABLISHED:

211

logger.debug("Zeroconf service established.")

205

logger.debug(u"Zeroconf service established.")

212

206

elif state == avahi.ENTRY_GROUP_COLLISION:

213

logger.info("Zeroconf service name collision.")

207

logger.warning(u"Zeroconf service name collision.")

214

208

self.rename()

215

209

elif state == avahi.ENTRY_GROUP_FAILURE:

216

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

210

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

217

211

unicode(error))

218

raise AvahiGroupError("State changed: %s"

212

raise AvahiGroupError(u"State changed: %s"

219

213

% unicode(error))

220

214

def cleanup(self):

221

215

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

222

216

if self.group is not None:

223

try:

224

self.group.Free()

225

except (dbus.exceptions.UnknownMethodException,

226

dbus.exceptions.DBusException) as e:

227

pass

217

self.group.Free()

228

218

self.group = None

229

self.remove()

230

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

219

def server_state_changed(self, state):

231

220

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

232

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

233

bad_states = { avahi.SERVER_INVALID:

234

"Zeroconf server invalid",

235

avahi.SERVER_REGISTERING: None,

236

avahi.SERVER_COLLISION:

237

"Zeroconf server name collision",

238

avahi.SERVER_FAILURE:

239

"Zeroconf server failure" }

240

if state in bad_states:

241

if bad_states[state] is not None:

242

if error is None:

243

logger.error(bad_states[state])

244

else:

245

logger.error(bad_states[state] + ": %r", error)

246

self.cleanup()

221

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

222

if state == avahi.SERVER_COLLISION:

223

logger.error(u"Zeroconf server name collision")

224

self.remove()

247

225

elif state == avahi.SERVER_RUNNING:

248

226

self.add()

249

else:

250

if error is None:

251

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

252

else:

253

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

254

227

def activate(self):

255

228

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

256

229

if self.server is None:

257

230

self.server = dbus.Interface(

258

231

self.bus.get_object(avahi.DBUS_NAME,

259

avahi.DBUS_PATH_SERVER,

260

follow_name_owner_changes=True),

232

avahi.DBUS_PATH_SERVER),

261

233

avahi.DBUS_INTERFACE_SERVER)

262

self.server.connect_to_signal("StateChanged",

234

self.server.connect_to_signal(u"StateChanged",

263

235

self.server_state_changed)

264

236

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

265

237

297

269

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

298

270

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

299

271

until this client is disabled

300

extended_timeout: extra long timeout when password has been sent

301

272

runtime_expansions: Allowed attributes for runtime expansion.

302

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

303

disabled, or None

304

273

"""

305

274

306

runtime_expansions = ("approval_delay", "approval_duration",

307

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

308

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

309

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

275

runtime_expansions = (u"approval_delay", u"approval_duration",

276

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

277

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

278

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

310

279

311

280

@staticmethod

312

281

def _timedelta_to_milliseconds(td):

318

287

def timeout_milliseconds(self):

319

288

"Return the 'timeout' attribute in milliseconds"

320

289

return self._timedelta_to_milliseconds(self.timeout)

321

322

def extended_timeout_milliseconds(self):

323

"Return the 'extended_timeout' attribute in milliseconds"

324

return self._timedelta_to_milliseconds(self.extended_timeout)

325

290

326

291

def interval_milliseconds(self):

327

292

"Return the 'interval' attribute in milliseconds"

337

302

self.name = name

338

303

if config is None:

339

304

config = {}

340

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

305

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

341

306

# Uppercase and remove spaces from fingerprint for later

342

307

# comparison purposes with return value from the fingerprint()

343

308

# function

344

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

345

.replace(" ", ""))

346

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

347

if "secret" in config:

348

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

349

elif "secfile" in config:

309

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

310

.replace(u" ", u""))

311

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

312

if u"secret" in config:

313

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

314

elif u"secfile" in config:

350

315

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

351

(config["secfile"])),

316

(config[u"secfile"])),

352

317

"rb") as secfile:

353

318

self.secret = secfile.read()

354

319

else:

355

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

320

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

356

321

% self.name)

357

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

322

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

358

323

self.created = datetime.datetime.utcnow()

359

324

self.enabled = False

360

325

self.last_approval_request = None

361

326

self.last_enabled = None

362

327

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

328

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

329

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

366

330

self.disable_hook = disable_hook

367

331

self.checker = None

368

332

self.checker_initiator_tag = None

369

333

self.disable_initiator_tag = None

370

self.expires = None

371

334

self.checker_callback_tag = None

372

self.checker_command = config["checker"]

335

self.checker_command = config[u"checker"]

373

336

self.current_checker_command = None

374

337

self.last_connect = None

375

338

self._approved = None

376

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

339

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

377

340

True)

378

341

self.approvals_pending = 0

379

342

self.approval_delay = string_to_delta(

380

config["approval_delay"])

343

config[u"approval_delay"])

381

344

self.approval_duration = string_to_delta(

382

config["approval_duration"])

345

config[u"approval_duration"])

383

346

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

384

347

385

348

def send_changedstate(self):

389

352

390

353

def enable(self):

391

354

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

392

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

355

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

393

356

# Already enabled

394

357

return

395

358

self.send_changedstate()

400

363

(self.interval_milliseconds(),

401

364

self.start_checker))

402

365

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

403

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

404

366

self.disable_initiator_tag = (gobject.timeout_add

405

367

(self.timeout_milliseconds(),

406

368

self.disable))

415

377

if not quiet:

416

378

self.send_changedstate()

417

379

if not quiet:

418

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

419

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

380

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

381

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

420

382

gobject.source_remove(self.disable_initiator_tag)

421

383

self.disable_initiator_tag = None

422

self.expires = None

423

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

384

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

424

385

gobject.source_remove(self.checker_initiator_tag)

425

386

self.checker_initiator_tag = None

426

387

self.stop_checker()

441

402

if os.WIFEXITED(condition):

442

403

exitstatus = os.WEXITSTATUS(condition)

443

404

if exitstatus == 0:

444

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

405

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

445

406

vars(self))

446

407

self.checked_ok()

447

408

else:

448

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

409

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

449

410

vars(self))

450

411

else:

451

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

412

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

452

413

vars(self))

453

414

454

def checked_ok(self, timeout=None):

415

def checked_ok(self):

455

416

"""Bump up the timeout for this client.

456

417

457

418

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

458

419

alive and well.

459

420

"""

460

if timeout is None:

461

timeout = self.timeout

462

421

self.last_checked_ok = datetime.datetime.utcnow()

463

422

gobject.source_remove(self.disable_initiator_tag)

464

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

465

423

self.disable_initiator_tag = (gobject.timeout_add

466

(self._timedelta_to_milliseconds(timeout),

424

(self.timeout_milliseconds(),

467

425

self.disable))

468

426

469

427

def need_approval(self):

486

444

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

487

445

try:

488

446

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

489

except (AttributeError, OSError) as error:

447

except (AttributeError, OSError), error:

490

448

if (isinstance(error, OSError)

491

449

and error.errno != errno.ECHILD):

492

450

raise error

493

451

else:

494

452

if pid:

495

logger.warning("Checker was a zombie")

453

logger.warning(u"Checker was a zombie")

496

454

gobject.source_remove(self.checker_callback_tag)

497

455

self.checker_callback(pid, status,

498

456

self.current_checker_command)

505

463

# Escape attributes for the shell

506

464

escaped_attrs = dict(

507

465

(attr,

508

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

466

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

509

467

errors=

510

'replace')))

468

u'replace')))

511

469

for attr in

512

470

self.runtime_expansions)

513

471

514

472

try:

515

473

command = self.checker_command % escaped_attrs

516

except TypeError as error:

517

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

518

' %s', self.checker_command, error)

474

except TypeError, error:

475

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

476

u' %s', self.checker_command, error)

519

477

return True # Try again later

520

478

self.current_checker_command = command

521

479

try:

522

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

480

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

523

481

command, self.name)

524

482

# We don't need to redirect stdout and stderr, since

525

483

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

527

485

# always replaced by /dev/null.)

528

486

self.checker = subprocess.Popen(command,

529

487

close_fds=True,

530

shell=True, cwd="/")

488

shell=True, cwd=u"/")

531

489

self.checker_callback_tag = (gobject.child_watch_add

532

490

(self.checker.pid,

533

491

self.checker_callback,

538

496

if pid:

539

497

gobject.source_remove(self.checker_callback_tag)

540

498

self.checker_callback(pid, status, command)

541

except OSError as error:

542

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

499

except OSError, error:

500

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

543

501

error)

544

502

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

545

503

return True

549

507

if self.checker_callback_tag:

550

508

gobject.source_remove(self.checker_callback_tag)

551

509

self.checker_callback_tag = None

552

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

510

if getattr(self, u"checker", None) is None:

553

511

return

554

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

512

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

555

513

try:

556

514

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

557

515

#time.sleep(0.5)

558

516

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

559

517

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

560

except OSError as error:

518

except OSError, error:

561

519

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

562

520

raise

563

521

self.checker = None

564

522

565

def dbus_service_property(dbus_interface, signature="v",

566

access="readwrite", byte_arrays=False):

523

def dbus_service_property(dbus_interface, signature=u"v",

524

access=u"readwrite", byte_arrays=False):

567

525

"""Decorators for marking methods of a DBusObjectWithProperties to

568

526

become properties on the D-Bus.

569

527

576

534

"""

577

535

# Encoding deeply encoded byte arrays is not supported yet by the

578

536

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

579

if byte_arrays and signature != "ay":

580

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

581

" signature %r" % signature)

537

if byte_arrays and signature != u"ay":

538

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

539

u" signature %r" % signature)

582

540

def decorator(func):

583

541

func._dbus_is_property = True

584

542

func._dbus_interface = dbus_interface

585

543

func._dbus_signature = signature

586

544

func._dbus_access = access

587

545

func._dbus_name = func.__name__

588

if func._dbus_name.endswith("_dbus_property"):

546

if func._dbus_name.endswith(u"_dbus_property"):

589

547

func._dbus_name = func._dbus_name[:-14]

590

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

548

func._dbus_get_args_options = {u'byte_arrays': byte_arrays }

591

549

return func

592

550

return decorator

593

551

621

579

622

580

@staticmethod

623

581

def _is_dbus_property(obj):

624

return getattr(obj, "_dbus_is_property", False)

582

return getattr(obj, u"_dbus_is_property", False)

625

583

626

584

def _get_all_dbus_properties(self):

627

585

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

635

593

property with the specified name and interface.

636

594

"""

637

595

for name in (property_name,

638

property_name + "_dbus_property"):

596

property_name + u"_dbus_property"):

639

597

prop = getattr(self, name, None)

640

598

if (prop is None

641

599

or not self._is_dbus_property(prop)

645

603

continue

646

604

return prop

647

605

# No such property

648

raise DBusPropertyNotFound(self.dbus_object_path + ":"

649

+ interface_name + "."

606

raise DBusPropertyNotFound(self.dbus_object_path + u":"

607

+ interface_name + u"."

650

608

+ property_name)

651

609

652

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

653

out_signature="v")

610

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

611

out_signature=u"v")

654

612

def Get(self, interface_name, property_name):

655

613

"""Standard D-Bus property Get() method, see D-Bus standard.

656

614

"""

657

615

prop = self._get_dbus_property(interface_name, property_name)

658

if prop._dbus_access == "write":

616

if prop._dbus_access == u"write":

659

617

raise DBusPropertyAccessException(property_name)

660

618

value = prop()

661

if not hasattr(value, "variant_level"):

619

if not hasattr(value, u"variant_level"):

662

620

return value

663

621

return type(value)(value, variant_level=value.variant_level+1)

664

622

665

@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")

623

@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")

666

624

def Set(self, interface_name, property_name, value):

667

625

"""Standard D-Bus property Set() method, see D-Bus standard.

668

626

"""

669

627

prop = self._get_dbus_property(interface_name, property_name)

670

if prop._dbus_access == "read":

628

if prop._dbus_access == u"read":

671

629

raise DBusPropertyAccessException(property_name)

672

if prop._dbus_get_args_options["byte_arrays"]:

630

if prop._dbus_get_args_options[u"byte_arrays"]:

673

631

# The byte_arrays option is not supported yet on

674

632

# signatures other than "ay".

675

if prop._dbus_signature != "ay":

633

if prop._dbus_signature != u"ay":

676

634

raise ValueError

677

635

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

678

636

for byte in value))

679

637

prop(value)

680

638

681

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

682

out_signature="a{sv}")

639

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

640

out_signature=u"a{sv}")

683

641

def GetAll(self, interface_name):

684

642

"""Standard D-Bus property GetAll() method, see D-Bus

685

643

standard.

693

651

# Interface non-empty but did not match

694

652

continue

695

653

# Ignore write-only properties

696

if prop._dbus_access == "write":

654

if prop._dbus_access == u"write":

697

655

continue

698

656

value = prop()

699

if not hasattr(value, "variant_level"):

657

if not hasattr(value, u"variant_level"):

700

658

all[name] = value

701

659

continue

702

660

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

703

661

value.variant_level+1)

704

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

662

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

705

663

706

664

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

707

out_signature="s",

665

out_signature=u"s",

708

666

path_keyword='object_path',

709

667

connection_keyword='connection')

710

668

def Introspect(self, object_path, connection):

715

673

try:

716

674

document = xml.dom.minidom.parseString(xmlstring)

717

675

def make_tag(document, name, prop):

718

e = document.createElement("property")

719

e.setAttribute("name", name)

720

e.setAttribute("type", prop._dbus_signature)

721

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

676

e = document.createElement(u"property")

677

e.setAttribute(u"name", name)

678

e.setAttribute(u"type", prop._dbus_signature)

679

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

722

680

return e

723

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

681

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

724

682

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

725

683

for name, prop

726

684

in self._get_all_dbus_properties()

727

685

if prop._dbus_interface

728

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

686

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

729

687

if_tag.appendChild(tag)

730

688

# Add the names to the return values for the

731

689

# "org.freedesktop.DBus.Properties" methods

732

if (if_tag.getAttribute("name")

733

== "org.freedesktop.DBus.Properties"):

734

for cn in if_tag.getElementsByTagName("method"):

735

if cn.getAttribute("name") == "Get":

736

for arg in cn.getElementsByTagName("arg"):

737

if (arg.getAttribute("direction")

738

== "out"):

739

arg.setAttribute("name", "value")

740

elif cn.getAttribute("name") == "GetAll":

741

for arg in cn.getElementsByTagName("arg"):

742

if (arg.getAttribute("direction")

743

== "out"):

744

arg.setAttribute("name", "props")

745

xmlstring = document.toxml("utf-8")

690

if (if_tag.getAttribute(u"name")

691

== u"org.freedesktop.DBus.Properties"):

692

for cn in if_tag.getElementsByTagName(u"method"):

693

if cn.getAttribute(u"name") == u"Get":

694

for arg in cn.getElementsByTagName(u"arg"):

695

if (arg.getAttribute(u"direction")

696

== u"out"):

697

arg.setAttribute(u"name", u"value")

698

elif cn.getAttribute(u"name") == u"GetAll":

699

for arg in cn.getElementsByTagName(u"arg"):

700

if (arg.getAttribute(u"direction")

701

== u"out"):

702

arg.setAttribute(u"name", u"props")

703

xmlstring = document.toxml(u"utf-8")

746

704

document.unlink()

747

705

except (AttributeError, xml.dom.DOMException,

748

xml.parsers.expat.ExpatError) as error:

749

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

706

xml.parsers.expat.ExpatError), error:

707

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

750

708

error)

751

709

return xmlstring

752

710

760

718

"""

761

719

762

720

runtime_expansions = (Client.runtime_expansions

763

+ ("dbus_object_path",))

721

+ (u"dbus_object_path",))

764

722

765

723

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

766

724

771

729

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

772

730

# the D-Bus

773

731

client_object_name = unicode(self.name).translate(

774

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

775

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

732

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

733

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

776

734

self.dbus_object_path = (dbus.ObjectPath

777

("/clients/" + client_object_name))

735

(u"/clients/" + client_object_name))

778

736

DBusObjectWithProperties.__init__(self, self.bus,

779

737

self.dbus_object_path)

780

def _set_expires(self, value):

781

old_value = getattr(self, "_expires", None)

782

self._expires = value

783

if hasattr(self, "dbus_object_path") and old_value != value:

784

dbus_time = (self._datetime_to_dbus(self._expires,

785

variant_level=1))

786

self.PropertyChanged(dbus.String("Expires"),

787

dbus_time)

788

expires = property(lambda self: self._expires, _set_expires)

789

del _set_expires

790

738

791

739

def _get_approvals_pending(self):

792

740

return self._approvals_pending

797

745

if (hasattr(self, "dbus_object_path")

798

746

and bval is not bool(old_value)):

799

747

dbus_bool = dbus.Boolean(bval, variant_level=1)

800

self.PropertyChanged(dbus.String("ApprovalPending"),

748

self.PropertyChanged(dbus.String(u"ApprovalPending"),

801

749

dbus_bool)

802

750

803

751

approvals_pending = property(_get_approvals_pending,

807

755

@staticmethod

808

756

def _datetime_to_dbus(dt, variant_level=0):

809

757

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

810

if dt is None:

811

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

812

758

return dbus.String(dt.isoformat(),

813

759

variant_level=variant_level)

814

760

815

761

def enable(self):

816

oldstate = getattr(self, "enabled", False)

762

oldstate = getattr(self, u"enabled", False)

817

763

r = Client.enable(self)

818

764

if oldstate != self.enabled:

819

765

# Emit D-Bus signals

820

self.PropertyChanged(dbus.String("Enabled"),

766

self.PropertyChanged(dbus.String(u"Enabled"),

821

767

dbus.Boolean(True, variant_level=1))

822

768

self.PropertyChanged(

823

dbus.String("LastEnabled"),

769

dbus.String(u"LastEnabled"),

824

770

self._datetime_to_dbus(self.last_enabled,

825

771

variant_level=1))

826

772

return r

827

773

828

774

def disable(self, quiet = False):

829

oldstate = getattr(self, "enabled", False)

775

oldstate = getattr(self, u"enabled", False)

830

776

r = Client.disable(self, quiet=quiet)

831

777

if not quiet and oldstate != self.enabled:

832

778

# Emit D-Bus signal

833

self.PropertyChanged(dbus.String("Enabled"),

779

self.PropertyChanged(dbus.String(u"Enabled"),

834

780

dbus.Boolean(False, variant_level=1))

835

781

return r

836

782

839

785

self.remove_from_connection()

840

786

except LookupError:

841

787

pass

842

if hasattr(DBusObjectWithProperties, "__del__"):

788

if hasattr(DBusObjectWithProperties, u"__del__"):

843

789

DBusObjectWithProperties.__del__(self, *args, **kwargs)

844

790

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

845

791

848

794

self.checker_callback_tag = None

849

795

self.checker = None

850

796

# Emit D-Bus signal

851

self.PropertyChanged(dbus.String("CheckerRunning"),

797

self.PropertyChanged(dbus.String(u"CheckerRunning"),

852

798

dbus.Boolean(False, variant_level=1))

853

799

if os.WIFEXITED(condition):

854

800

exitstatus = os.WEXITSTATUS(condition)

866

812

*args, **kwargs)

867

813

868

814

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

869

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

815

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

870

816

# Emit D-Bus signal

871

817

self.PropertyChanged(

872

dbus.String("LastCheckedOK"),

818

dbus.String(u"LastCheckedOK"),

873

819

(self._datetime_to_dbus(self.last_checked_ok,

874

820

variant_level=1)))

821

return r

875

822

876

823

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

877

824

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

878

825

# Emit D-Bus signal

879

826

self.PropertyChanged(

880

dbus.String("LastApprovalRequest"),

827

dbus.String(u"LastApprovalRequest"),

881

828

(self._datetime_to_dbus(self.last_approval_request,

882

829

variant_level=1)))

883

830

return r

895

842

# Emit D-Bus signal

896

843

self.CheckerStarted(self.current_checker_command)

897

844

self.PropertyChanged(

898

dbus.String("CheckerRunning"),

845

dbus.String(u"CheckerRunning"),

899

846

dbus.Boolean(True, variant_level=1))

900

847

return r

901

848

902

849

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

903

old_checker = getattr(self, "checker", None)

850

old_checker = getattr(self, u"checker", None)

904

851

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

905

852

if (old_checker is not None

906

and getattr(self, "checker", None) is None):

907

self.PropertyChanged(dbus.String("CheckerRunning"),

853

and getattr(self, u"checker", None) is None):

854

self.PropertyChanged(dbus.String(u"CheckerRunning"),

908

855

dbus.Boolean(False, variant_level=1))

909

856

return r

910

857

921

868

922

869

923

870

## D-Bus methods, signals & properties

924

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

871

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

925

872

926

873

## Signals

927

874

928

875

# CheckerCompleted - signal

929

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

876

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

930

877

def CheckerCompleted(self, exitcode, waitstatus, command):

931

878

"D-Bus signal"

932

879

pass

933

880

934

881

# CheckerStarted - signal

935

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

882

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

936

883

def CheckerStarted(self, command):

937

884

"D-Bus signal"

938

885

pass

939

886

940

887

# PropertyChanged - signal

941

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

888

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

942

889

def PropertyChanged(self, property, value):

943

890

"D-Bus signal"

944

891

pass

953

900

pass

954

901

955

902

# Rejected - signal

956

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

903

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

957

904

def Rejected(self, reason):

958

905

"D-Bus signal"

959

906

pass

960

907

961

908

# NeedApproval - signal

962

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

909

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

963

910

def NeedApproval(self, timeout, default):

964

911

"D-Bus signal"

965

912

return self.need_approval()

967

914

## Methods

968

915

969

916

# Approve - method

970

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

917

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

971

918

def Approve(self, value):

972

919

self.approve(value)

973

920

974

921

# CheckedOK - method

975

922

@dbus.service.method(_interface)

976

923

def CheckedOK(self):

977

self.checked_ok()

924

return self.checked_ok()

978

925

979

926

# Enable - method

980

927

@dbus.service.method(_interface)

1002

949

## Properties

1003

950

1004

951

# ApprovalPending - property

1005

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

952

@dbus_service_property(_interface, signature=u"b", access=u"read")

1006

953

def ApprovalPending_dbus_property(self):

1007

954

return dbus.Boolean(bool(self.approvals_pending))

1008

955

1009

956

# ApprovedByDefault - property

1010

@dbus_service_property(_interface, signature="b",

1011

access="readwrite")

957

@dbus_service_property(_interface, signature=u"b",

958

access=u"readwrite")

1012

959

def ApprovedByDefault_dbus_property(self, value=None):

1013

960

if value is None: # get

1014

961

return dbus.Boolean(self.approved_by_default)

1015

old_value = self.approved_by_default

1016

962

self.approved_by_default = bool(value)

1017

963

# Emit D-Bus signal

1018

if old_value != self.approved_by_default:

1019

self.PropertyChanged(dbus.String("ApprovedByDefault"),

1020

dbus.Boolean(value, variant_level=1))

964

self.PropertyChanged(dbus.String(u"ApprovedByDefault"),

965

dbus.Boolean(value, variant_level=1))

1021

966

1022

967

# ApprovalDelay - property

1023

@dbus_service_property(_interface, signature="t",

1024

access="readwrite")

968

@dbus_service_property(_interface, signature=u"t",

969

access=u"readwrite")

1025

970

def ApprovalDelay_dbus_property(self, value=None):

1026

971

if value is None: # get

1027

972

return dbus.UInt64(self.approval_delay_milliseconds())

1028

old_value = self.approval_delay

1029

973

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

1030

974

# Emit D-Bus signal

1031

if old_value != self.approval_delay:

1032

self.PropertyChanged(dbus.String("ApprovalDelay"),

1033

dbus.UInt64(value, variant_level=1))

975

self.PropertyChanged(dbus.String(u"ApprovalDelay"),

976

dbus.UInt64(value, variant_level=1))

1034

977

1035

978

# ApprovalDuration - property

1036

@dbus_service_property(_interface, signature="t",

1037

access="readwrite")

979

@dbus_service_property(_interface, signature=u"t",

980

access=u"readwrite")

1038

981

def ApprovalDuration_dbus_property(self, value=None):

1039

982

if value is None: # get

1040

983

return dbus.UInt64(self._timedelta_to_milliseconds(

1041

984

self.approval_duration))

1042

old_value = self.approval_duration

1043

985

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

1044

986

# Emit D-Bus signal

1045

if old_value != self.approval_duration:

1046

self.PropertyChanged(dbus.String("ApprovalDuration"),

1047

dbus.UInt64(value, variant_level=1))

987

self.PropertyChanged(dbus.String(u"ApprovalDuration"),

988

dbus.UInt64(value, variant_level=1))

1048

989

1049

990

# Name - property

1050

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

991

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

1051

992

def Name_dbus_property(self):

1052

993

return dbus.String(self.name)

1053

994

1054

995

# Fingerprint - property

1055

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

996

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

1056

997

def Fingerprint_dbus_property(self):

1057

998

return dbus.String(self.fingerprint)

1058

999

1059

1000

# Host - property

1060

@dbus_service_property(_interface, signature="s",

1061

access="readwrite")

1001

@dbus_service_property(_interface, signature=u"s",

1002

access=u"readwrite")

1062

1003

def Host_dbus_property(self, value=None):

1063

1004

if value is None: # get

1064

1005

return dbus.String(self.host)

1065

old_value = self.host

1066

1006

self.host = value

1067

1007

# Emit D-Bus signal

1068

if old_value != self.host:

1069

self.PropertyChanged(dbus.String("Host"),

1070

dbus.String(value, variant_level=1))

1008

self.PropertyChanged(dbus.String(u"Host"),

1009

dbus.String(value, variant_level=1))

1071

1010

1072

1011

# Created - property

1073

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

1012

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

1074

1013

def Created_dbus_property(self):

1075

1014

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

1076

1015

1077

1016

# LastEnabled - property

1078

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

1017

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

1079

1018

def LastEnabled_dbus_property(self):

1080

return self._datetime_to_dbus(self.last_enabled)

1019

if self.last_enabled is None:

1020

return dbus.String(u"")

1021

return dbus.String(self._datetime_to_dbus(self.last_enabled))

1081

1022

1082

1023

# Enabled - property

1083

@dbus_service_property(_interface, signature="b",

1084

access="readwrite")

1024

@dbus_service_property(_interface, signature=u"b",

1025

access=u"readwrite")

1085

1026

def Enabled_dbus_property(self, value=None):

1086

1027

if value is None: # get

1087

1028

return dbus.Boolean(self.enabled)

1091

1032

self.disable()

1092

1033

1093

1034

# LastCheckedOK - property

1094

@dbus_service_property(_interface, signature="s",

1095

access="readwrite")

1035

@dbus_service_property(_interface, signature=u"s",

1036

access=u"readwrite")

1096

1037

def LastCheckedOK_dbus_property(self, value=None):

1097

1038

if value is not None:

1098

1039

self.checked_ok()

1099

1040

return

1100

return self._datetime_to_dbus(self.last_checked_ok)

1101

1102

# Expires - property

1103

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

1104

def Expires_dbus_property(self):

1105

return self._datetime_to_dbus(self.expires)

1041

if self.last_checked_ok is None:

1042

return dbus.String(u"")

1043

return dbus.String(self._datetime_to_dbus(self

1044

.last_checked_ok))

1106

1045

1107

1046

# LastApprovalRequest - property

1108

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

1047

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

1109

1048

def LastApprovalRequest_dbus_property(self):

1110

return self._datetime_to_dbus(self.last_approval_request)

1049

if self.last_approval_request is None:

1050

return dbus.String(u"")

1051

return dbus.String(self.

1052

_datetime_to_dbus(self

1053

.last_approval_request))

1111

1054

1112

1055

# Timeout - property

1113

@dbus_service_property(_interface, signature="t",

1114

access="readwrite")

1056

@dbus_service_property(_interface, signature=u"t",

1057

access=u"readwrite")

1115

1058

def Timeout_dbus_property(self, value=None):

1116

1059

if value is None: # get

1117

1060

return dbus.UInt64(self.timeout_milliseconds())

1118

old_value = self.timeout

1119

1061

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

1120

1062

# Emit D-Bus signal

1121

if old_value != self.timeout:

1122

self.PropertyChanged(dbus.String("Timeout"),

1123

dbus.UInt64(value, variant_level=1))

1124

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

1063

self.PropertyChanged(dbus.String(u"Timeout"),

1064

dbus.UInt64(value, variant_level=1))

1065

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

1125

1066

return

1126

1067

# Reschedule timeout

1127

1068

gobject.source_remove(self.disable_initiator_tag)

1128

1069

self.disable_initiator_tag = None

1129

self.expires = None

1130

1070

time_to_die = (self.

1131

1071

_timedelta_to_milliseconds((self

1132

1072

.last_checked_ok

1137

1077

# The timeout has passed

1138

1078

self.disable()

1139

1079

else:

1140

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

1141

+ datetime.timedelta(milliseconds = time_to_die))

1142

1080

self.disable_initiator_tag = (gobject.timeout_add

1143

1081

(time_to_die, self.disable))

1144

1145

# ExtendedTimeout - property

1146

@dbus_service_property(_interface, signature="t",

1147

access="readwrite")

1148

def ExtendedTimeout_dbus_property(self, value=None):

1149

if value is None: # get

1150

return dbus.UInt64(self.extended_timeout_milliseconds())

1151

old_value = self.extended_timeout

1152

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

1153

# Emit D-Bus signal

1154

if old_value != self.extended_timeout:

1155

self.PropertyChanged(dbus.String("ExtendedTimeout"),

1156

dbus.UInt64(value, variant_level=1))

1157

1082

1158

1083

# Interval - property

1159

@dbus_service_property(_interface, signature="t",

1160

access="readwrite")

1084

@dbus_service_property(_interface, signature=u"t",

1085

access=u"readwrite")

1161

1086

def Interval_dbus_property(self, value=None):

1162

1087

if value is None: # get

1163

1088

return dbus.UInt64(self.interval_milliseconds())

1164

old_value = self.interval

1165

1089

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

1166

1090

# Emit D-Bus signal

1167

if old_value != self.interval:

1168

self.PropertyChanged(dbus.String("Interval"),

1169

dbus.UInt64(value, variant_level=1))

1170

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

1091

self.PropertyChanged(dbus.String(u"Interval"),

1092

dbus.UInt64(value, variant_level=1))

1093

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

1171

1094

return

1172

1095

# Reschedule checker run

1173

1096

gobject.source_remove(self.checker_initiator_tag)

1176

1099

self.start_checker() # Start one now, too

1177

1100

1178

1101

# Checker - property

1179

@dbus_service_property(_interface, signature="s",

1180

access="readwrite")

1102

@dbus_service_property(_interface, signature=u"s",

1103

access=u"readwrite")

1181

1104

def Checker_dbus_property(self, value=None):

1182

1105

if value is None: # get

1183

1106

return dbus.String(self.checker_command)

1184

old_value = self.checker_command

1185

1107

self.checker_command = value

1186

1108

# Emit D-Bus signal

1187

if old_value != self.checker_command:

1188

self.PropertyChanged(dbus.String("Checker"),

1189

dbus.String(self.checker_command,

1190

variant_level=1))

1109

self.PropertyChanged(dbus.String(u"Checker"),

1110

dbus.String(self.checker_command,

1111

variant_level=1))

1191

1112

1192

1113

# CheckerRunning - property

1193

@dbus_service_property(_interface, signature="b",

1194

access="readwrite")

1114

@dbus_service_property(_interface, signature=u"b",

1115

access=u"readwrite")

1195

1116

def CheckerRunning_dbus_property(self, value=None):

1196

1117

if value is None: # get

1197

1118

return dbus.Boolean(self.checker is not None)

1201

1122

self.stop_checker()

1202

1123

1203

1124

# ObjectPath - property

1204

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

1125

@dbus_service_property(_interface, signature=u"o", access=u"read")

1205

1126

def ObjectPath_dbus_property(self):

1206

1127

return self.dbus_object_path # is already a dbus.ObjectPath

1207

1128

1208

1129

# Secret = property

1209

@dbus_service_property(_interface, signature="ay",

1210

access="write", byte_arrays=True)

1130

@dbus_service_property(_interface, signature=u"ay",

1131

access=u"write", byte_arrays=True)

1211

1132

def Secret_dbus_property(self, value):

1212

1133

self.secret = str(value)

1213

1134

1248

1169

1249

1170

def handle(self):

1250

1171

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

1251

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

1172

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

1252

1173

unicode(self.client_address))

1253

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

1174

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

1254

1175

self.server.child_pipe.fileno())

1255

1176

1256

1177

session = (gnutls.connection

1263

1184

# no X.509 keys are added to it. Therefore, we can use it

1264

1185

# here despite using OpenPGP certificates.

1265

1186

1266

#priority = ':'.join(("NONE", "+VERS-TLS1.1",

1267

# "+AES-256-CBC", "+SHA1",

1268

# "+COMP-NULL", "+CTYPE-OPENPGP",

1269

# "+DHE-DSS"))

1187

#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",

1188

# u"+AES-256-CBC", u"+SHA1",

1189

# u"+COMP-NULL", u"+CTYPE-OPENPGP",

1190

# u"+DHE-DSS"))

1270

1191

# Use a fallback default, since this MUST be set.

1271

1192

priority = self.server.gnutls_priority

1272

1193

if priority is None:

1273

priority = "NORMAL"

1194

priority = u"NORMAL"

1274

1195

(gnutls.library.functions

1275

1196

.gnutls_priority_set_direct(session._c_object,

1276

1197

priority, None))

1278

1199

# Start communication using the Mandos protocol

1279

1200

# Get protocol number

1280

1201

line = self.request.makefile().readline()

1281

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

1202

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

1282

1203

try:

1283

1204

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

1284

1205

raise RuntimeError

1285

except (ValueError, IndexError, RuntimeError) as error:

1286

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

1206

except (ValueError, IndexError, RuntimeError), error:

1207

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

1287

1208

return

1288

1209

1289

1210

# Start GnuTLS connection

1290

1211

try:

1291

1212

session.handshake()

1292

except gnutls.errors.GNUTLSError as error:

1293

logger.warning("Handshake failed: %s", error)

1213

except gnutls.errors.GNUTLSError, error:

1214

logger.warning(u"Handshake failed: %s", error)

1294

1215

# Do not run session.bye() here: the session is not

1295

1216

# established. Just abandon the request.

1296

1217

return

1297

logger.debug("Handshake succeeded")

1218

logger.debug(u"Handshake succeeded")

1298

1219

1299

1220

approval_required = False

1300

1221

try:

1301

1222

try:

1302

1223

fpr = self.fingerprint(self.peer_certificate

1303

1224

(session))

1304

except (TypeError,

1305

gnutls.errors.GNUTLSError) as error:

1306

logger.warning("Bad certificate: %s", error)

1225

except (TypeError, gnutls.errors.GNUTLSError), error:

1226

logger.warning(u"Bad certificate: %s", error)

1307

1227

return

1308

logger.debug("Fingerprint: %s", fpr)

1228

logger.debug(u"Fingerprint: %s", fpr)

1309

1229

1310

1230

try:

1311

1231

client = ProxyClient(child_pipe, fpr,

1320

1240

1321

1241

while True:

1322

1242

if not client.enabled:

1323

logger.info("Client %s is disabled",

1243

logger.warning(u"Client %s is disabled",

1324

1244

client.name)

1325

1245

if self.server.use_dbus:

1326

1246

# Emit D-Bus signal

1331

1251

#We are approved or approval is disabled

1332

1252

break

1333

1253

elif client._approved is None:

1334

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

1254

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

1335

1255

client.name)

1336

1256

if self.server.use_dbus:

1337

1257

# Emit D-Bus signal

1339

1259

client.approval_delay_milliseconds(),

1340

1260

client.approved_by_default)

1341

1261

else:

1342

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

1262

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

1343

1263

client.name)

1344

1264

if self.server.use_dbus:

1345

1265

# Emit D-Bus signal

1371

1291

while sent_size < len(client.secret):

1372

1292

try:

1373

1293

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

1374

except gnutls.errors.GNUTLSError as error:

1294

except (gnutls.errors.GNUTLSError), error:

1375

1295

logger.warning("gnutls send failed")

1376

1296

return

1377

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

1297

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

1378

1298

sent, len(client.secret)

1379

1299

- (sent_size + sent))

1380

1300

sent_size += sent

1381

1301

1382

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

1302

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

1383

1303

# bump the timeout as if seen

1384

client.checked_ok(client.extended_timeout)

1304

client.checked_ok()

1385

1305

if self.server.use_dbus:

1386

1306

# Emit D-Bus signal

1387

1307

client.GotSecret()

1391

1311

client.approvals_pending -= 1

1392

1312

try:

1393

1313

session.bye()

1394

except gnutls.errors.GNUTLSError as error:

1314

except (gnutls.errors.GNUTLSError), error:

1395

1315

logger.warning("GnuTLS bye failed")

1396

1316

1397

1317

@staticmethod

1408

1328

.gnutls_certificate_get_peers

1409

1329

(session._c_object, ctypes.byref(list_size)))

1410

1330

if not bool(cert_list) and list_size.value != 0:

1411

raise gnutls.errors.GNUTLSError("error getting peer"

1412

" certificate")

1331

raise gnutls.errors.GNUTLSError(u"error getting peer"

1332

u" certificate")

1413

1333

if list_size.value == 0:

1414

1334

return None

1415

1335

cert = cert_list[0]

1441

1361

if crtverify.value != 0:

1442

1362

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1443

1363

raise (gnutls.errors.CertificateSecurityError

1444

("Verify failed"))

1364

(u"Verify failed"))

1445

1365

# New buffer for the fingerprint

1446

1366

buf = ctypes.create_string_buffer(20)

1447

1367

buf_len = ctypes.c_size_t()

1454

1374

# Convert the buffer to a Python bytestring

1455

1375

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

1456

1376

# Convert the bytestring to hexadecimal notation

1457

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

1377

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

1458

1378

return hex_fpr

1459

1379

1460

1380

1488

1408

1489

1409

def add_pipe(self, parent_pipe):

1490

1410

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

1491

raise NotImplementedError

1411

pass

1492

1412

1493

1413

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1494

1414

socketserver.TCPServer, object):

1512

1432

bind to an address or port if they were not specified."""

1513

1433

if self.interface is not None:

1514

1434

if SO_BINDTODEVICE is None:

1515

logger.error("SO_BINDTODEVICE does not exist;"

1516

" cannot bind to interface %s",

1435

logger.error(u"SO_BINDTODEVICE does not exist;"

1436

u" cannot bind to interface %s",

1517

1437

self.interface)

1518

1438

else:

1519

1439

try:

1520

1440

self.socket.setsockopt(socket.SOL_SOCKET,

1521

1441

SO_BINDTODEVICE,

1522

1442

str(self.interface

1523

+ '\0'))

1524

except socket.error as error:

1443

+ u'\0'))

1444

except socket.error, error:

1525

1445

if error[0] == errno.EPERM:

1526

logger.error("No permission to"

1527

" bind to interface %s",

1446

logger.error(u"No permission to"

1447

u" bind to interface %s",

1528

1448

self.interface)

1529

1449

elif error[0] == errno.ENOPROTOOPT:

1530

logger.error("SO_BINDTODEVICE not available;"

1531

" cannot bind to interface %s",

1450

logger.error(u"SO_BINDTODEVICE not available;"

1451

u" cannot bind to interface %s",

1532

1452

self.interface)

1533

1453

else:

1534

1454

raise

1536

1456

if self.server_address[0] or self.server_address[1]:

1537

1457

if not self.server_address[0]:

1538

1458

if self.address_family == socket.AF_INET6:

1539

any_address = "::" # in6addr_any

1459

any_address = u"::" # in6addr_any

1540

1460

else:

1541

1461

any_address = socket.INADDR_ANY

1542

1462

self.server_address = (any_address,

1591

1511

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

1592

1512

client_object=None):

1593

1513

condition_names = {

1594

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

1595

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

1514

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

1515

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

1596

1516

# blocking).

1597

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

1598

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

1599

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

1517

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

1518

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

1519

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

1600

1520

# broken, usually for pipes and

1601

1521

# sockets).

1602

1522

}

1621

1541

client = c

1622

1542

break

1623

1543

else:

1624

logger.info("Client not found for fingerprint: %s, ad"

1625

"dress: %s", fpr, address)

1544

logger.warning(u"Client not found for fingerprint: %s, ad"

1545

u"dress: %s", fpr, address)

1626

1546

if self.use_dbus:

1627

1547

# Emit D-Bus signal

1628

1548

mandos_dbus_service.ClientNotFound(fpr, address[0])

1662

1582

def string_to_delta(interval):

1663

1583

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

1664

1584

1665

>>> string_to_delta('7d')

1585

>>> string_to_delta(u'7d')

1666

1586

datetime.timedelta(7)

1667

>>> string_to_delta('60s')

1587

>>> string_to_delta(u'60s')

1668

1588

datetime.timedelta(0, 60)

1669

>>> string_to_delta('60m')

1589

>>> string_to_delta(u'60m')

1670

1590

datetime.timedelta(0, 3600)

1671

>>> string_to_delta('24h')

1591

>>> string_to_delta(u'24h')

1672

1592

datetime.timedelta(1)

1673

>>> string_to_delta('1w')

1593

>>> string_to_delta(u'1w')

1674

1594

datetime.timedelta(7)

1675

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

1595

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

1676

1596

datetime.timedelta(0, 330)

1677

1597

"""

1678

1598

timevalue = datetime.timedelta(0)

1680

1600

try:

1681

1601

suffix = unicode(s[-1])

1682

1602

value = int(s[:-1])

1683

if suffix == "d":

1603

if suffix == u"d":

1684

1604

delta = datetime.timedelta(value)

1685

elif suffix == "s":

1605

elif suffix == u"s":

1686

1606

delta = datetime.timedelta(0, value)

1687

elif suffix == "m":

1607

elif suffix == u"m":

1688

1608

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

1689

elif suffix == "h":

1609

elif suffix == u"h":

1690

1610

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

1691

elif suffix == "w":

1611

elif suffix == u"w":

1692

1612

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

1693

1613

else:

1694

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

1695

except (ValueError, IndexError) as e:

1696

raise ValueError(*(e.args))

1614

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

1615

except (ValueError, IndexError), e:

1616

raise ValueError(e.message)

1697

1617

timevalue += delta

1698

1618

return timevalue

1699

1619

1705

1625

global if_nametoindex

1706

1626

try:

1707

1627

if_nametoindex = (ctypes.cdll.LoadLibrary

1708

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

1628

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

1709

1629

.if_nametoindex)

1710

1630

except (OSError, AttributeError):

1711

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

1631

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

1712

1632

def if_nametoindex(interface):

1713

1633

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

1714

1634

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

1715

1635

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

1716

1636

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1717

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

1637

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

1718

1638

interface))

1719

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

1639

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

1720

1640

ifreq[16:20])[0]

1721

1641

return interface_index

1722

1642

return if_nametoindex(interface)

1730

1650

sys.exit()

1731

1651

os.setsid()

1732

1652

if not nochdir:

1733

os.chdir("/")

1653

os.chdir(u"/")

1734

1654

if os.fork():

1735

1655

sys.exit()

1736

1656

if not noclose:

1738

1658

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

1739

1659

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

1740

1660

raise OSError(errno.ENODEV,

1741

"%s not a character device"

1661

u"%s not a character device"

1742

1662

% os.path.devnull)

1743

1663

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

1744

1664

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

1752

1672

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

1753

1673

# Parsing of options, both command line and config file

1754

1674

1755

parser = argparse.ArgumentParser()

1756

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

1757

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

1758

help="show version number and exit")

1759

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

1760

help="Bind to interface IF")

1761

parser.add_argument("-a", "--address",

1762

help="Address to listen for requests on")

1763

parser.add_argument("-p", "--port", type=int,

1764

help="Port number to receive requests on")

1765

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

1766

help="Run self-test")

1767

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

1768

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

1769

" to terminal")

1770

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

1771

help="Debug level for stdout output")

1772

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

1773

" priority string (see GnuTLS documentation)")

1774

parser.add_argument("--servicename",

1775

metavar="NAME", help="Zeroconf service name")

1776

parser.add_argument("--configdir",

1777

default="/etc/mandos", metavar="DIR",

1778

help="Directory to search for configuration"

1779

" files")

1780

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

1781

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

1782

" system bus interface")

1783

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

1784

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

1785

options = parser.parse_args()

1675

parser = optparse.OptionParser(version = "%%prog %s" % version)

1676

parser.add_option("-i", u"--interface", type=u"string",

1677

metavar="IF", help=u"Bind to interface IF")

1678

parser.add_option("-a", u"--address", type=u"string",

1679

help=u"Address to listen for requests on")

1680

parser.add_option("-p", u"--port", type=u"int",

1681

help=u"Port number to receive requests on")

1682

parser.add_option("--check", action=u"store_true",

1683

help=u"Run self-test")

1684

parser.add_option("--debug", action=u"store_true",

1685

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

1686

u" terminal")

1687

parser.add_option("--debuglevel", type=u"string", metavar="LEVEL",

1688

help=u"Debug level for stdout output")

1689

parser.add_option("--priority", type=u"string", help=u"GnuTLS"

1690

u" priority string (see GnuTLS documentation)")

1691

parser.add_option("--servicename", type=u"string",

1692

metavar=u"NAME", help=u"Zeroconf service name")

1693

parser.add_option("--configdir", type=u"string",

1694

default=u"/etc/mandos", metavar=u"DIR",

1695

help=u"Directory to search for configuration"

1696

u" files")

1697

parser.add_option("--no-dbus", action=u"store_false",

1698

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

1699

u" system bus interface")

1700

parser.add_option("--no-ipv6", action=u"store_false",

1701

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

1702

options = parser.parse_args()[0]

1786

1703

1787

1704

if options.check:

1788

1705

import doctest

1790

1707

sys.exit()

1791

1708

1792

1709

# Default values for config file for server-global settings

1793

server_defaults = { "interface": "",

1794

"address": "",

1795

"port": "",

1796

"debug": "False",

1797

"priority":

1798

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

1799

"servicename": "Mandos",

1800

"use_dbus": "True",

1801

"use_ipv6": "True",

1802

"debuglevel": "",

1710

server_defaults = { u"interface": u"",

1711

u"address": u"",

1712

u"port": u"",

1713

u"debug": u"False",

1714

u"priority":

1715

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

1716

u"servicename": u"Mandos",

1717

u"use_dbus": u"True",

1718

u"use_ipv6": u"True",

1719

u"debuglevel": u"",

1803

1720

}

1804

1721

1805

1722

# Parse config file for server-global settings

1806

1723

server_config = configparser.SafeConfigParser(server_defaults)

1807

1724

del server_defaults

1808

1725

server_config.read(os.path.join(options.configdir,

1809

"mandos.conf"))

1726

u"mandos.conf"))

1810

1727

# Convert the SafeConfigParser object to a dict

1811

1728

server_settings = server_config.defaults()

1812

1729

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

1813

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

1814

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

1730

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

1731

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

1815

1732

option)

1816

1733

if server_settings["port"]:

1817

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

1818

"port")

1734

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

1735

u"port")

1819

1736

del server_config

1820

1737

1821

1738

# Override the settings from the config file with command line

1822

1739

# options, if set.

1823

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

1824

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

1825

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

1740

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

1741

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

1742

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

1826

1743

value = getattr(options, option)

1827

1744

if value is not None:

1828

1745

server_settings[option] = value

1836

1753

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

1837

1754

1838

1755

# For convenience

1839

debug = server_settings["debug"]

1840

debuglevel = server_settings["debuglevel"]

1841

use_dbus = server_settings["use_dbus"]

1842

use_ipv6 = server_settings["use_ipv6"]

1756

debug = server_settings[u"debug"]

1757

debuglevel = server_settings[u"debuglevel"]

1758

use_dbus = server_settings[u"use_dbus"]

1759

use_ipv6 = server_settings[u"use_ipv6"]

1843

1760

1844

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

1761

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

1845

1762

syslogger.setFormatter(logging.Formatter

1846

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

1847

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

1848

% server_settings["servicename"]))

1763

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

1764

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

1765

% server_settings[u"servicename"]))

1849

1766

1850

1767

# Parse config file with clients

1851

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

1852

"extended_timeout": "15m",

1853

"interval": "2m",

1854

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

1855

"host": "",

1856

"approval_delay": "0s",

1857

"approval_duration": "1s",

1768

client_defaults = { u"timeout": u"1h",

1769

u"interval": u"5m",

1770

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

1771

u"host": u"",

1772

u"approval_delay": u"0s",

1773

u"approval_duration": u"1s",

1858

1774

}

1859

1775

client_config = configparser.SafeConfigParser(client_defaults)

1860

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

1861

"clients.conf"))

1776

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

1777

u"clients.conf"))

1862

1778

1863

1779

global mandos_dbus_service

1864

1780

mandos_dbus_service = None

1865

1781

1866

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

1867

server_settings["port"]),

1782

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

1783

server_settings[u"port"]),

1868

1784

ClientHandler,

1869

interface=(server_settings["interface"]

1785

interface=(server_settings[u"interface"]

1870

1786

or None),

1871

1787

use_ipv6=use_ipv6,

1872

1788

gnutls_priority=

1873

server_settings["priority"],

1789

server_settings[u"priority"],

1874

1790

use_dbus=use_dbus)

1875

1791

if not debug:

1876

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

1792

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

1877

1793

try:

1878

pidfile = open(pidfilename, "w")

1794

pidfile = open(pidfilename, u"w")

1879

1795

except IOError:

1880

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

1796

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

1881

1797

1882

1798

try:

1883

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

1884

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

1799

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

1800

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

1885

1801

except KeyError:

1886

1802

try:

1887

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

1888

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

1803

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

1804

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

1889

1805

except KeyError:

1890

1806

try:

1891

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

1892

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

1807

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

1808

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

1893

1809

except KeyError:

1894

1810

uid = 65534

1895

1811

gid = 65534

1896

1812

try:

1897

1813

os.setgid(gid)

1898

1814

os.setuid(uid)

1899

except OSError as error:

1815

except OSError, error:

1900

1816

if error[0] != errno.EPERM:

1901

1817

raise error

1902

1818

1917

1833

1918

1834

@gnutls.library.types.gnutls_log_func

1919

1835

def debug_gnutls(level, string):

1920

logger.debug("GnuTLS: %s", string[:-1])

1836

logger.debug(u"GnuTLS: %s", string[:-1])

1921

1837

1922

1838

(gnutls.library.functions

1923

1839

.gnutls_global_set_log_function(debug_gnutls))

1931

1847

# No console logging

1932

1848

logger.removeHandler(console)

1933

1849

1934

# Need to fork before connecting to D-Bus

1935

if not debug:

1936

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

1937

daemon()

1938

1850

1939

1851

global main_loop

1940

1852

# From the Avahi example code

1944

1856

# End of Avahi example code

1945

1857

if use_dbus:

1946

1858

try:

1947

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

1859

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

1948

1860

bus, do_not_queue=True)

1949

except dbus.exceptions.NameExistsException as e:

1950

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

1861

except dbus.exceptions.NameExistsException, e:

1862

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

1951

1863

use_dbus = False

1952

server_settings["use_dbus"] = False

1864

server_settings[u"use_dbus"] = False

1953

1865

tcp_server.use_dbus = False

1954

1866

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1955

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

1956

servicetype = "_mandos._tcp",

1867

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

1868

servicetype = u"_mandos._tcp",

1957

1869

protocol = protocol, bus = bus)

1958

1870

if server_settings["interface"]:

1959

1871

service.interface = (if_nametoindex

1960

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

1961

1872

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

1873

1874

if not debug:

1875

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

1876

daemon()

1877

1962

1878

global multiprocessing_manager

1963

1879

multiprocessing_manager = multiprocessing.Manager()

1964

1880

1983

1899

client_config, section)))

1984

1900

for section in client_config.sections()))

1985

1901

if not tcp_server.clients:

1986

logger.warning("No clients defined")

1902

logger.warning(u"No clients defined")

1987

1903

1988

1904

if not debug:

1989

1905

try:

1990

1906

with pidfile:

1991

1907

pid = os.getpid()

1992

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

1908

pidfile.write(str(pid) + "\n")

1993

1909

del pidfile

1994

1910

except IOError:

1995

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

1911

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

1996

1912

pidfilename, pid)

1997

1913

except NameError:

1998

1914

# "pidfile" was never created

2008

1924

class MandosDBusService(dbus.service.Object):

2009

1925

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

2010

1926

def __init__(self):

2011

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

2012

_interface = "se.bsnet.fukt.Mandos"

1927

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

1928

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

2013

1929

2014

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

1930

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

2015

1931

def ClientAdded(self, objpath):

2016

1932

"D-Bus signal"

2017

1933

pass

2018

1934

2019

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

1935

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

2020

1936

def ClientNotFound(self, fingerprint, address):

2021

1937

"D-Bus signal"

2022

1938

pass

2023

1939

2024

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

1940

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

2025

1941

def ClientRemoved(self, objpath, name):

2026

1942

"D-Bus signal"

2027

1943

pass

2028

1944

2029

@dbus.service.method(_interface, out_signature="ao")

1945

@dbus.service.method(_interface, out_signature=u"ao")

2030

1946

def GetAllClients(self):

2031

1947

"D-Bus method"

2032

1948

return dbus.Array(c.dbus_object_path

2033

1949

for c in tcp_server.clients)

2034

1950

2035

1951

@dbus.service.method(_interface,

2036

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

1952

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

2037

1953

def GetAllClientsWithProperties(self):

2038

1954

"D-Bus method"

2039

1955

return dbus.Dictionary(

2040

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

1956

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

2041

1957

for c in tcp_server.clients),

2042

signature="oa{sv}")

1958

signature=u"oa{sv}")

2043

1959

2044

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

1960

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

2045

1961

def RemoveClient(self, object_path):

2046

1962

"D-Bus method"

2047

1963

for c in tcp_server.clients:

2089

2005

# Find out what port we got

2090

2006

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

2091

2007

if use_ipv6:

2092

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

2008

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

2093

2009

" flowinfo %d, scope_id %d"

2094

2010

% tcp_server.socket.getsockname())

2095

2011

else: # IPv4

2096

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

2012

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

2097

2013

% tcp_server.socket.getsockname())

2098

2014

2099

2015

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

2102

2018

# From the Avahi example code

2103

2019

try:

2104

2020

service.activate()

2105

except dbus.exceptions.DBusException as error:

2106

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

2021

except dbus.exceptions.DBusException, error:

2022

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

2107

2023

cleanup()

2108

2024

sys.exit(1)

2109

2025

# End of Avahi example code

2113

2029

(tcp_server.handle_request

2114

2030

(*args[2:], **kwargs) or True))

2115

2031

2116

logger.debug("Starting main loop")

2032

logger.debug(u"Starting main loop")

2117

2033

main_loop.run()

2118

except AvahiError as error:

2119

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

2034

except AvahiError, error:

2035

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

2120

2036

cleanup()

2121

2037

sys.exit(1)

2122

2038

except KeyboardInterrupt:

2123

2039

if debug:

2124

print("", file=sys.stderr)

2125

logger.debug("Server received KeyboardInterrupt")

2126

logger.debug("Server exiting")

2040

print >> sys.stderr

2041

logger.debug(u"Server received KeyboardInterrupt")

2042

logger.debug(u"Server exiting")

2127

2043

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

2128

2044

cleanup()

2129

2045