/mandos/trunk : revision 24.2.1

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

84

version = "1.0.14"

86

85

87

#logger = logging.getLogger('mandos')

88

logger = logging.Logger('mandos')

86

logger = logging.Logger(u'mandos')

89

87

syslogger = (logging.handlers.SysLogHandler

90

88

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

91

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

89

address = "/dev/log"))

92

90

syslogger.setFormatter(logging.Formatter

93

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

94

' %(message)s'))

91

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

92

u' %(message)s'))

95

93

logger.addHandler(syslogger)

96

94

97

95

console = logging.StreamHandler()

98

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

99

' %(levelname)s:'

100

' %(message)s'))

96

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

97

u' %(levelname)s:'

98

u' %(message)s'))

101

99

logger.addHandler(console)

102

100

101

multiprocessing_manager = multiprocessing.Manager()

102

103

class AvahiError(Exception):

104

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

105

self.value = value

120

Attributes:

121

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

122

Used to optionally bind to the specified interface.

123

124

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

123

124

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

125

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

126

port: integer; what port to announce

127

TXT: list of strings; TXT record for the service

136

"""

137

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

138

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

139

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

139

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

140

protocol = avahi.PROTO_UNSPEC, bus = None):

141

self.interface = interface

142

self.name = name

154

def rename(self):

155

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

156

if self.rename_count >= self.max_renames:

157

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

158

" after %i retries, exiting.",

157

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

158

u" after %i retries, exiting.",

159

self.rename_count)

160

raise AvahiServiceError("Too many renames")

161

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

162

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

163

self.name)

160

raise AvahiServiceError(u"Too many renames")

161

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

162

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

163

unicode(self.name))

164

syslogger.setFormatter(logging.Formatter

165

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

166

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

165

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

166

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

167

% self.name))

168

self.remove()

169

try:

170

self.add()

171

except dbus.exceptions.DBusException, error:

172

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

173

self.cleanup()

174

os._exit(1)

169

self.add()

175

170

self.rename_count += 1

176

171

def remove(self):

177

172

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

187

182

self.group.connect_to_signal('StateChanged',

188

183

self

189

184

.entry_group_state_changed)

190

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

185

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

191

186

self.name, self.type)

192

187

self.group.AddService(

193

188

self.interface,

200

195

self.group.Commit()

201

196

def entry_group_state_changed(self, state, error):

202

197

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

203

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

198

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

204

199

205

200

if state == avahi.ENTRY_GROUP_ESTABLISHED:

206

logger.debug("Zeroconf service established.")

201

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

207

202

elif state == avahi.ENTRY_GROUP_COLLISION:

208

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

203

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

209

204

self.rename()

210

205

elif state == avahi.ENTRY_GROUP_FAILURE:

211

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

206

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

212

207

unicode(error))

213

raise AvahiGroupError("State changed: %s"

208

raise AvahiGroupError(u"State changed: %s"

214

209

% unicode(error))

215

210

def cleanup(self):

216

211

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

219

214

self.group = None

220

215

def server_state_changed(self, state):

221

216

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

222

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

223

217

if state == avahi.SERVER_COLLISION:

224

logger.error("Zeroconf server name collision")

218

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

225

219

self.remove()

226

220

elif state == avahi.SERVER_RUNNING:

227

221

self.add()

232

226

self.bus.get_object(avahi.DBUS_NAME,

233

227

avahi.DBUS_PATH_SERVER),

234

228

avahi.DBUS_INTERFACE_SERVER)

235

self.server.connect_to_signal("StateChanged",

229

self.server.connect_to_signal(u"StateChanged",

236

230

self.server_state_changed)

237

231

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

238

232

241

235

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

242

236

243

237

Attributes:

244

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

245

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

246

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

238

239

D-Bus identifiers

240

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

241

uniquely identify the client

242

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

243

host: string; available for use by the checker command

244

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

245

last_enabled: datetime.datetime(); (UTC)

246

enabled: bool()

247

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

248

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

249

until this client is disabled

250

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

251

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

247

252

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

248

253

to see if the client lives.

249

254

'None' if no process is running.

250

checker_callback_tag: a gobject event source tag, or None

251

checker_command: string; External command which is run to check

252

if client lives. %() expansions are done at

255

checker_initiator_tag: a gobject event source tag, or None

256

disable_initiator_tag: - '' -

257

checker_callback_tag: - '' -

258

checker_command: string; External command which is run to check if

259

client lives. %() expansions are done at

253

260

runtime with vars(self) as dict, so that for

254

261

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

255

checker_initiator_tag: a gobject event source tag, or None

256

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

257

262

current_checker_command: string; current running checker_command

258

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

259

disable_initiator_tag: a gobject event source tag, or None

260

enabled: bool()

261

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

262

uniquely identify the client

263

host: string; available for use by the checker command

264

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

265

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

266

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

267

last_enabled: datetime.datetime(); (UTC)

268

269

D-Bus identifiers

270

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

271

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

272

until this client is disabled

273

runtime_expansions: Allowed attributes for runtime expansion.

263

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

264

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

265

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

274

266

"""

275

267

276

runtime_expansions = ("approval_delay", "approval_duration",

277

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

278

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

279

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

280

281

268

@staticmethod

282

269

def _timedelta_to_milliseconds(td):

283

270

"Convert a datetime.timedelta() to milliseconds"

293

280

"Return the 'interval' attribute in milliseconds"

294

281

return self._timedelta_to_milliseconds(self.interval)

295

282

296

def approval_delay_milliseconds(self):

297

return self._timedelta_to_milliseconds(self.approval_delay)

283

def approved_delay_milliseconds(self):

284

return self._timedelta_to_milliseconds(self.approved_delay)

298

285

299

286

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

300

287

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

303

290

self.name = name

304

291

if config is None:

305

292

config = {}

306

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

293

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

307

294

# Uppercase and remove spaces from fingerprint for later

308

295

# comparison purposes with return value from the fingerprint()

309

296

# function

310

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

311

.replace(" ", ""))

312

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

313

if "secret" in config:

314

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

315

elif "secfile" in config:

297

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

298

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

299

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

300

if u"secret" in config:

301

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

302

elif u"secfile" in config:

316

303

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

317

(config["secfile"])),

304

(config[u"secfile"])),

318

305

"rb") as secfile:

319

306

self.secret = secfile.read()

320

307

else:

321

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

308

#XXX Need to allow secret on demand!

309

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

322

310

% self.name)

323

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

311

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

324

312

self.created = datetime.datetime.utcnow()

325

313

self.enabled = False

326

self.last_approval_request = None

327

314

self.last_enabled = None

328

315

self.last_checked_ok = None

329

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

330

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

316

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

317

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

331

318

self.disable_hook = disable_hook

332

319

self.checker = None

333

320

self.checker_initiator_tag = None

334

321

self.disable_initiator_tag = None

335

322

self.checker_callback_tag = None

336

self.checker_command = config["checker"]

323

self.checker_command = config[u"checker"]

337

324

self.current_checker_command = None

338

325

self.last_connect = None

326

self.approvals_pending = 0

339

327

self._approved = None

340

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

328

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

341

329

True)

342

self.approvals_pending = 0

343

self.approval_delay = string_to_delta(

344

config["approval_delay"])

345

self.approval_duration = string_to_delta(

346

config["approval_duration"])

330

self.approved_delay = string_to_delta(

331

config[u"approved_delay"])

332

self.approved_duration = string_to_delta(

333

config[u"approved_duration"])

347

334

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

348

335

349

336

def send_changedstate(self):

350

337

self.changedstate.acquire()

351

338

self.changedstate.notify_all()

353

340

354

341

def enable(self):

355

342

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

356

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

343

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

357

344

# Already enabled

358

345

return

359

346

self.send_changedstate()

378

365

if not quiet:

379

366

self.send_changedstate()

380

367

if not quiet:

381

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

382

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

368

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

369

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

383

370

gobject.source_remove(self.disable_initiator_tag)

384

371

self.disable_initiator_tag = None

385

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

372

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

386

373

gobject.source_remove(self.checker_initiator_tag)

387

374

self.checker_initiator_tag = None

388

375

self.stop_checker()

403

390

if os.WIFEXITED(condition):

404

391

exitstatus = os.WEXITSTATUS(condition)

405

392

if exitstatus == 0:

406

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

393

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

407

394

vars(self))

408

395

self.checked_ok()

409

396

else:

410

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

397

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

411

398

vars(self))

412

399

else:

413

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

400

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

414

401

vars(self))

415

402

416

403

def checked_ok(self):

425

412

(self.timeout_milliseconds(),

426

413

self.disable))

427

414

428

def need_approval(self):

429

self.last_approval_request = datetime.datetime.utcnow()

430

431

415

def start_checker(self):

432

416

"""Start a new checker subprocess if one is not running.

433

417

451

435

raise error

452

436

else:

453

437

if pid:

454

logger.warning("Checker was a zombie")

438

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

455

439

gobject.source_remove(self.checker_callback_tag)

456

440

self.checker_callback(pid, status,

457

441

self.current_checker_command)

462

446

command = self.checker_command % self.host

463

447

except TypeError:

464

448

# Escape attributes for the shell

465

escaped_attrs = dict(

466

(attr,

467

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

468

errors=

469

'replace')))

470

for attr in

471

self.runtime_expansions)

472

449

escaped_attrs = dict((key,

450

re.escape(unicode(str(val),

451

errors=

452

u'replace')))

453

for key, val in

454

vars(self).iteritems())

473

455

try:

474

456

command = self.checker_command % escaped_attrs

475

457

except TypeError, error:

476

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

477

' %s', self.checker_command, error)

458

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

459

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

478

460

return True # Try again later

479

461

self.current_checker_command = command

480

462

try:

481

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

463

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

482

464

command, self.name)

483

465

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

484

466

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

486

468

# always replaced by /dev/null.)

487

469

self.checker = subprocess.Popen(command,

488

470

close_fds=True,

489

shell=True, cwd="/")

471

shell=True, cwd=u"/")

490

472

self.checker_callback_tag = (gobject.child_watch_add

491

473

(self.checker.pid,

492

474

self.checker_callback,

498

480

gobject.source_remove(self.checker_callback_tag)

499

481

self.checker_callback(pid, status, command)

500

482

except OSError, error:

501

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

483

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

502

484

error)

503

485

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

504

486

return True

508

490

if self.checker_callback_tag:

509

491

gobject.source_remove(self.checker_callback_tag)

510

492

self.checker_callback_tag = None

511

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

493

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

512

494

return

513

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

495

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

514

496

try:

515

497

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

516

498

#time.sleep(0.5)

521

503

raise

522

504

self.checker = None

523

505

524

def dbus_service_property(dbus_interface, signature="v",

525

access="readwrite", byte_arrays=False):

506

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

507

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

526

508

"""Decorators for marking methods of a DBusObjectWithProperties to

527

509

become properties on the D-Bus.

528

510

535

517

"""

536

518

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

537

519

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

538

if byte_arrays and signature != "ay":

539

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

540

" signature %r" % signature)

520

if byte_arrays and signature != u"ay":

521

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

522

u" signature %r" % signature)

541

523

def decorator(func):

542

524

func._dbus_is_property = True

543

525

func._dbus_interface = dbus_interface

544

526

func._dbus_signature = signature

545

527

func._dbus_access = access

546

528

func._dbus_name = func.__name__

547

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

529

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

548

530

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

549

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

531

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

550

532

return func

551

533

return decorator

552

534

580

562

581

563

@staticmethod

582

564

def _is_dbus_property(obj):

583

return getattr(obj, "_dbus_is_property", False)

565

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

584

566

585

567

def _get_all_dbus_properties(self):

586

568

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

594

576

property with the specified name and interface.

595

577

"""

596

578

for name in (property_name,

597

property_name + "_dbus_property"):

579

property_name + u"_dbus_property"):

598

580

prop = getattr(self, name, None)

599

581

if (prop is None

600

582

or not self._is_dbus_property(prop)

604

586

continue

605

587

return prop

606

588

# No such property

607

raise DBusPropertyNotFound(self.dbus_object_path + ":"

608

+ interface_name + "."

589

raise DBusPropertyNotFound(self.dbus_object_path + u":"

590

+ interface_name + u"."

609

591

+ property_name)

610

592

611

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

612

out_signature="v")

593

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

594

out_signature=u"v")

613

595

def Get(self, interface_name, property_name):

614

596

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

615

597

"""

616

598

prop = self._get_dbus_property(interface_name, property_name)

617

if prop._dbus_access == "write":

599

if prop._dbus_access == u"write":

618

600

raise DBusPropertyAccessException(property_name)

619

601

value = prop()

620

if not hasattr(value, "variant_level"):

602

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

621

603

return value

622

604

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

623

605

624

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

606

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

625

607

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

626

608

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

627

609

"""

628

610

prop = self._get_dbus_property(interface_name, property_name)

629

if prop._dbus_access == "read":

611

if prop._dbus_access == u"read":

630

612

raise DBusPropertyAccessException(property_name)

631

if prop._dbus_get_args_options["byte_arrays"]:

613

if prop._dbus_get_args_options[u"byte_arrays"]:

632

614

# The byte_arrays option is not supported yet on

633

615

# signatures other than "ay".

634

if prop._dbus_signature != "ay":

616

if prop._dbus_signature != u"ay":

635

617

raise ValueError

636

618

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

637

619

for byte in value))

638

620

prop(value)

639

621

640

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

641

out_signature="a{sv}")

622

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

623

out_signature=u"a{sv}")

642

624

def GetAll(self, interface_name):

643

625

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

644

626

standard.

652

634

# Interface non-empty but did not match

653

635

continue

654

636

# Ignore write-only properties

655

if prop._dbus_access == "write":

637

if prop._dbus_access == u"write":

656

638

continue

657

639

value = prop()

658

if not hasattr(value, "variant_level"):

640

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

659

641

all[name] = value

660

642

continue

661

643

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

662

644

value.variant_level+1)

663

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

645

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

664

646

665

647

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

666

out_signature="s",

648

out_signature=u"s",

667

649

path_keyword='object_path',

668

650

connection_keyword='connection')

669

651

def Introspect(self, object_path, connection):

674

656

try:

675

657

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

676

658

def make_tag(document, name, prop):

677

e = document.createElement("property")

678

e.setAttribute("name", name)

679

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

680

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

659

e = document.createElement(u"property")

660

e.setAttribute(u"name", name)

661

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

662

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

681

663

return e

682

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

664

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

683

665

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

684

666

for name, prop

685

667

in self._get_all_dbus_properties()

686

668

if prop._dbus_interface

687

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

669

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

688

670

if_tag.appendChild(tag)

689

671

# Add the names to the return values for the

690

672

# "org.freedesktop.DBus.Properties" methods

691

if (if_tag.getAttribute("name")

692

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

693

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

694

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

695

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

696

if (arg.getAttribute("direction")

697

== "out"):

698

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

699

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

700

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

701

if (arg.getAttribute("direction")

702

== "out"):

703

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

704

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

673

if (if_tag.getAttribute(u"name")

674

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

675

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

676

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

677

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

678

if (arg.getAttribute(u"direction")

679

== u"out"):

680

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

681

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

682

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

683

if (arg.getAttribute(u"direction")

684

== u"out"):

685

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

686

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

705

687

document.unlink()

706

688

except (AttributeError, xml.dom.DOMException,

707

689

xml.parsers.expat.ExpatError), error:

708

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

690

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

709

691

error)

710

692

return xmlstring

711

693

717

699

dbus_object_path: dbus.ObjectPath

718

700

bus: dbus.SystemBus()

719

701

"""

720

721

runtime_expansions = (Client.runtime_expansions

722

+ ("dbus_object_path",))

723

724

702

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

725

703

726

704

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

727

self._approvals_pending = 0

728

705

self.bus = bus

729

706

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

730

707

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

731

708

# the D-Bus

732

client_object_name = unicode(self.name).translate(

733

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

734

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

735

709

self.dbus_object_path = (dbus.ObjectPath

736

("/clients/" + client_object_name))

710

(u"/clients/"

711

+ self.name.replace(u".", u"_")))

737

712

DBusObjectWithProperties.__init__(self, self.bus,

738

713

self.dbus_object_path)

739

740

def _get_approvals_pending(self):

741

return self._approvals_pending

742

def _set_approvals_pending(self, value):

743

old_value = self._approvals_pending

744

self._approvals_pending = value

745

bval = bool(value)

746

if (hasattr(self, "dbus_object_path")

747

and bval is not bool(old_value)):

748

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

749

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

750

dbus_bool)

751

752

approvals_pending = property(_get_approvals_pending,

753

_set_approvals_pending)

754

del _get_approvals_pending, _set_approvals_pending

755

714

756

715

@staticmethod

757

716

def _datetime_to_dbus(dt, variant_level=0):

760

719

variant_level=variant_level)

761

720

762

721

def enable(self):

763

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

722

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

764

723

r = Client.enable(self)

765

724

if oldstate != self.enabled:

766

725

# Emit D-Bus signals

767

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

726

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

768

727

dbus.Boolean(True, variant_level=1))

769

728

self.PropertyChanged(

770

dbus.String("LastEnabled"),

729

dbus.String(u"last_enabled"),

771

730

self._datetime_to_dbus(self.last_enabled,

772

731

variant_level=1))

773

732

return r

774

733

775

734

def disable(self, quiet = False):

776

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

735

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

777

736

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

778

737

if not quiet and oldstate != self.enabled:

779

738

# Emit D-Bus signal

780

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

739

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

781

740

dbus.Boolean(False, variant_level=1))

782

741

return r

783

742

786

745

self.remove_from_connection()

787

746

except LookupError:

788

747

pass

789

if hasattr(DBusObjectWithProperties, "__del__"):

748

if hasattr(DBusObjectWithProperties, u"__del__"):

790

749

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

791

750

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

792

751

795

754

self.checker_callback_tag = None

796

755

self.checker = None

797

756

# Emit D-Bus signal

798

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

757

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

799

758

dbus.Boolean(False, variant_level=1))

800

759

if os.WIFEXITED(condition):

801

760

exitstatus = os.WEXITSTATUS(condition)

816

775

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

817

776

# Emit D-Bus signal

818

777

self.PropertyChanged(

819

dbus.String("LastCheckedOK"),

778

dbus.String(u"last_checked_ok"),

820

779

(self._datetime_to_dbus(self.last_checked_ok,

821

780

variant_level=1)))

822

781

return r

823

782

824

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

825

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

826

# Emit D-Bus signal

827

self.PropertyChanged(

828

dbus.String("LastApprovalRequest"),

829

(self._datetime_to_dbus(self.last_approval_request,

830

variant_level=1)))

831

return r

832

833

783

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

834

784

old_checker = self.checker

835

785

if self.checker is not None:

843

793

# Emit D-Bus signal

844

794

self.CheckerStarted(self.current_checker_command)

845

795

self.PropertyChanged(

846

dbus.String("CheckerRunning"),

796

dbus.String(u"checker_running"),

847

797

dbus.Boolean(True, variant_level=1))

848

798

return r

849

799

850

800

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

851

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

801

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

852

802

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

853

803

if (old_checker is not None

854

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

855

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

804

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

805

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

856

806

dbus.Boolean(False, variant_level=1))

857

807

return r

858

808

861

811

return False

862

812

863

813

def approve(self, value=True):

864

self.send_changedstate()

865

814

self._approved = value

866

gobject.timeout_add(self._timedelta_to_milliseconds

867

(self.approval_duration),

868

self._reset_approved)

815

gobject.timeout_add(self._timedelta_to_milliseconds(self.approved_duration, self._reset_approved))

816

817

def approved_pending(self):

818

return self.approvals_pending > 0

869

819

870

820

871

821

## D-Bus methods, signals & properties

872

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

822

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

873

823

874

824

## Signals

875

825

876

826

# CheckerCompleted - signal

877

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

827

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

878

828

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

879

829

"D-Bus signal"

880

830

pass

881

831

882

832

# CheckerStarted - signal

883

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

833

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

884

834

def CheckerStarted(self, command):

885

835

"D-Bus signal"

886

836

pass

887

837

888

838

# PropertyChanged - signal

889

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

839

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

890

840

def PropertyChanged(self, property, value):

891

841

"D-Bus signal"

892

842

pass

894

844

# GotSecret - signal

895

845

@dbus.service.signal(_interface)

896

846

def GotSecret(self):

897

"""D-Bus signal

898

Is sent after a successful transfer of secret from the Mandos

899

server to mandos-client

900

"""

901

pass

847

"D-Bus signal"

848

if self.approved_pending():

849

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

850

dbus.Boolean(False, variant_level=1))

902

851

903

852

# Rejected - signal

904

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

853

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

905

854

def Rejected(self, reason):

906

855

"D-Bus signal"

907

pass

856

if self.approved_pending():

857

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

858

dbus.Boolean(False, variant_level=1))

908

859

909

860

# NeedApproval - signal

910

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

861

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

911

862

def NeedApproval(self, timeout, default):

912

863

"D-Bus signal"

913

return self.need_approval()

864

if not self.approved_pending():

865

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

866

dbus.Boolean(True, variant_level=1))

914

867

915

868

## Methods

916

869

917

870

# Approve - method

918

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

871

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

919

872

def Approve(self, value):

920

873

self.approve(value)

921

874

922

875

# CheckedOK - method

923

876

@dbus.service.method(_interface)

924

877

def CheckedOK(self):

949

902

950

903

## Properties

951

904

952

# ApprovalPending - property

953

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

954

def ApprovalPending_dbus_property(self):

955

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

956

957

# ApprovedByDefault - property

958

@dbus_service_property(_interface, signature="b",

959

access="readwrite")

960

def ApprovedByDefault_dbus_property(self, value=None):

961

if value is None: # get

962

return dbus.Boolean(self.approved_by_default)

963

self.approved_by_default = bool(value)

964

# Emit D-Bus signal

965

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

966

dbus.Boolean(value, variant_level=1))

967

968

# ApprovalDelay - property

969

@dbus_service_property(_interface, signature="t",

970

access="readwrite")

971

def ApprovalDelay_dbus_property(self, value=None):

972

if value is None: # get

973

return dbus.UInt64(self.approval_delay_milliseconds())

974

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

975

# Emit D-Bus signal

976

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

977

dbus.UInt64(value, variant_level=1))

978

979

# ApprovalDuration - property

980

@dbus_service_property(_interface, signature="t",

981

access="readwrite")

982

def ApprovalDuration_dbus_property(self, value=None):

983

if value is None: # get

984

return dbus.UInt64(self._timedelta_to_milliseconds(

985

self.approval_duration))

986

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

987

# Emit D-Bus signal

988

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

989

dbus.UInt64(value, variant_level=1))

990

991

# Name - property

992

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

993

def Name_dbus_property(self):

905

# approved_pending - property

906

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

907

def approved_pending_dbus_property(self):

908

return dbus.Boolean(self.approved_pending())

909

910

# approved_by_default - property

911

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

912

access=u"readwrite")

913

def approved_by_default_dbus_property(self):

914

return dbus.Boolean(self.approved_by_default)

915

916

# approved_delay - property

917

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

918

access=u"readwrite")

919

def approved_delay_dbus_property(self):

920

return dbus.UInt64(self.approved_delay_milliseconds())

921

922

# approved_duration - property

923

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

924

access=u"readwrite")

925

def approved_duration_dbus_property(self):

926

return dbus.UInt64(self._timedelta_to_milliseconds(

927

self.approved_duration))

928

929

# name - property

930

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

931

def name_dbus_property(self):

994

932

return dbus.String(self.name)

995

933

996

# Fingerprint - property

997

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

998

def Fingerprint_dbus_property(self):

934

# fingerprint - property

935

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

936

def fingerprint_dbus_property(self):

999

937

return dbus.String(self.fingerprint)

1000

938

1001

# Host - property

1002

@dbus_service_property(_interface, signature="s",

1003

access="readwrite")

1004

def Host_dbus_property(self, value=None):

939

# host - property

940

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

941

access=u"readwrite")

942

def host_dbus_property(self, value=None):

1005

943

if value is None: # get

1006

944

return dbus.String(self.host)

1007

945

self.host = value

1008

946

# Emit D-Bus signal

1009

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

947

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

1010

948

dbus.String(value, variant_level=1))

1011

949

1012

# Created - property

1013

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

1014

def Created_dbus_property(self):

950

# created - property

951

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

952

def created_dbus_property(self):

1015

953

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

1016

954

1017

# LastEnabled - property

1018

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

1019

def LastEnabled_dbus_property(self):

955

# last_enabled - property

956

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

957

def last_enabled_dbus_property(self):

1020

958

if self.last_enabled is None:

1021

return dbus.String("")

959

return dbus.String(u"")

1022

960

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

1023

961

1024

# Enabled - property

1025

@dbus_service_property(_interface, signature="b",

1026

access="readwrite")

1027

def Enabled_dbus_property(self, value=None):

962

# enabled - property

963

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

964

access=u"readwrite")

965

def enabled_dbus_property(self, value=None):

1028

966

if value is None: # get

1029

967

return dbus.Boolean(self.enabled)

1030

968

if value:

1032

970

else:

1033

971

self.disable()

1034

972

1035

# LastCheckedOK - property

1036

@dbus_service_property(_interface, signature="s",

1037

access="readwrite")

1038

def LastCheckedOK_dbus_property(self, value=None):

973

# last_checked_ok - property

974

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

975

access=u"readwrite")

976

def last_checked_ok_dbus_property(self, value=None):

1039

977

if value is not None:

1040

978

self.checked_ok()

1041

979

return

1042

980

if self.last_checked_ok is None:

1043

return dbus.String("")

981

return dbus.String(u"")

1044

982

return dbus.String(self._datetime_to_dbus(self

1045

983

.last_checked_ok))

1046

984

1047

# LastApprovalRequest - property

1048

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

1049

def LastApprovalRequest_dbus_property(self):

1050

if self.last_approval_request is None:

1051

return dbus.String("")

1052

return dbus.String(self.

1053

_datetime_to_dbus(self

1054

.last_approval_request))

1055

1056

# Timeout - property

1057

@dbus_service_property(_interface, signature="t",

1058

access="readwrite")

1059

def Timeout_dbus_property(self, value=None):

985

# timeout - property

986

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

987

access=u"readwrite")

988

def timeout_dbus_property(self, value=None):

1060

989

if value is None: # get

1061

990

return dbus.UInt64(self.timeout_milliseconds())

1062

991

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

1063

992

# Emit D-Bus signal

1064

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

993

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

1065

994

dbus.UInt64(value, variant_level=1))

1066

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

995

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

1067

996

return

1068

997

# Reschedule timeout

1069

998

gobject.source_remove(self.disable_initiator_tag)

1081

1010

self.disable_initiator_tag = (gobject.timeout_add

1082

1011

(time_to_die, self.disable))

1083

1012

1084

# Interval - property

1085

@dbus_service_property(_interface, signature="t",

1086

access="readwrite")

1087

def Interval_dbus_property(self, value=None):

1013

# interval - property

1014

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

1015

access=u"readwrite")

1016

def interval_dbus_property(self, value=None):

1088

1017

if value is None: # get

1089

1018

return dbus.UInt64(self.interval_milliseconds())

1090

1019

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

1091

1020

# Emit D-Bus signal

1092

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

1021

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

1093

1022

dbus.UInt64(value, variant_level=1))

1094

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

1023

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

1095

1024

return

1096

1025

# Reschedule checker run

1097

1026

gobject.source_remove(self.checker_initiator_tag)

1099

1028

(value, self.start_checker))

1100

1029

self.start_checker() # Start one now, too

1101

1030

1102

# Checker - property

1103

@dbus_service_property(_interface, signature="s",

1104

access="readwrite")

1105

def Checker_dbus_property(self, value=None):

1031

# checker - property

1032

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

1033

access=u"readwrite")

1034

def checker_dbus_property(self, value=None):

1106

1035

if value is None: # get

1107

1036

return dbus.String(self.checker_command)

1108

1037

self.checker_command = value

1109

1038

# Emit D-Bus signal

1110

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

1039

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

1111

1040

dbus.String(self.checker_command,

1112

1041

variant_level=1))

1113

1042

1114

# CheckerRunning - property

1115

@dbus_service_property(_interface, signature="b",

1116

access="readwrite")

1117

def CheckerRunning_dbus_property(self, value=None):

1043

# checker_running - property

1044

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

1045

access=u"readwrite")

1046

def checker_running_dbus_property(self, value=None):

1118

1047

if value is None: # get

1119

1048

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

1120

1049

if value:

1122

1051

else:

1123

1052

self.stop_checker()

1124

1053

1125

# ObjectPath - property

1126

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

1127

def ObjectPath_dbus_property(self):

1054

# object_path - property

1055

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

1056

def object_path_dbus_property(self):

1128

1057

return self.dbus_object_path # is already a dbus.ObjectPath

1129

1058

1130

# Secret = property

1131

@dbus_service_property(_interface, signature="ay",

1132

access="write", byte_arrays=True)

1133

def Secret_dbus_property(self, value):

1059

# secret = property

1060

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

1061

access=u"write", byte_arrays=True)

1062

def secret_dbus_property(self, value):

1134

1063

self.secret = str(value)

1135

1064

1136

1065

del _interface

1170

1099

1171

1100

def handle(self):

1172

1101

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

1173

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

1102

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

1174

1103

unicode(self.client_address))

1175

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

1104

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

1176

1105

self.server.child_pipe.fileno())

1177

1106

1178

1107

session = (gnutls.connection

1185

1114

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

1186

1115

# here despite using OpenPGP certificates.

1187

1116

1188

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

1189

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

1190

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

1191

# "+DHE-DSS"))

1117

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

1118

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

1119

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

1120

# u"+DHE-DSS"))

1192

1121

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

1193

1122

priority = self.server.gnutls_priority

1194

1123

if priority is None:

1195

priority = "NORMAL"

1124

priority = u"NORMAL"

1196

1125

(gnutls.library.functions

1197

1126

.gnutls_priority_set_direct(session._c_object,

1198

1127

priority, None))

1200

1129

# Start communication using the Mandos protocol

1201

1130

# Get protocol number

1202

1131

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

1203

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

1132

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

1204

1133

try:

1205

1134

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

1206

1135

raise RuntimeError

1207

1136

except (ValueError, IndexError, RuntimeError), error:

1208

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

1137

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

1209

1138

return

1210

1139

1211

1140

# Start GnuTLS connection

1212

1141

try:

1213

1142

session.handshake()

1214

1143

except gnutls.errors.GNUTLSError, error:

1215

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

1144

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

1216

1145

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

1217

1146

# established. Just abandon the request.

1218

1147

return

1219

logger.debug("Handshake succeeded")

1148

logger.debug(u"Handshake succeeded")

1220

1149

1221

1150

approval_required = False

1222

1151

try:

1224

1153

fpr = self.fingerprint(self.peer_certificate

1225

1154

(session))

1226

1155

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

1227

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

1156

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

1228

1157

return

1229

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

1158

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

1230

1159

1231

1160

try:

1232

1161

client = ProxyClient(child_pipe, fpr,

1234

1163

except KeyError:

1235

1164

return

1236

1165

1237

if client.approval_delay:

1238

delay = client.approval_delay

1166

if client.approved_delay:

1167

delay = client.approved_delay

1239

1168

client.approvals_pending += 1

1240

1169

approval_required = True

1241

1170

1242

1171

while True:

1243

1172

if not client.enabled:

1244

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

1173

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

1245

1174

client.name)

1246

1175

if self.server.use_dbus:

1247

1176

# Emit D-Bus signal

1248

1177

client.Rejected("Disabled")

1249

1178

return

1250

1179

1251

if client._approved or not client.approval_delay:

1180

if client._approved or not client.approved_delay:

1252

1181

#We are approved or approval is disabled

1253

1182

break

1254

1183

elif client._approved is None:

1255

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

1184

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

1256

1185

client.name)

1257

1186

if self.server.use_dbus:

1258

1187

# Emit D-Bus signal

1259

1188

client.NeedApproval(

1260

client.approval_delay_milliseconds(),

1189

client.approved_delay_milliseconds(),

1261

1190

client.approved_by_default)

1262

1191

else:

1263

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

1192

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

1264

1193

client.name)

1265

1194

if self.server.use_dbus:

1266

1195

# Emit D-Bus signal

1267

client.Rejected("Denied")

1196

client.Rejected("Disapproved")

1268

1197

return

1269

1198

1270

1199

#wait until timeout or approved

1281

1210

client.name)

1282

1211

if self.server.use_dbus:

1283

1212

# Emit D-Bus signal

1284

client.Rejected("Approval timed out")

1213

client.Rejected("Time out")

1285

1214

return

1286

1215

else:

1287

1216

break

1290

1219

1291

1220

sent_size = 0

1292

1221

while sent_size < len(client.secret):

1293

try:

1294

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

1295

except (gnutls.errors.GNUTLSError), error:

1296

logger.warning("gnutls send failed")

1297

return

1298

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

1222

# XXX handle session exception

1223

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

1224

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

1299

1225

sent, len(client.secret)

1300

1226

- (sent_size + sent))

1301

1227

sent_size += sent

1302

1228

1303

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

1229

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

1304

1230

# bump the timeout as if seen

1305

1231

client.checked_ok()

1306

1232

if self.server.use_dbus:

1310

1236

finally:

1311

1237

if approval_required:

1312

1238

client.approvals_pending -= 1

1313

try:

1314

session.bye()

1315

except (gnutls.errors.GNUTLSError), error:

1316

logger.warning("GnuTLS bye failed")

1239

session.bye()

1317

1240

1318

1241

@staticmethod

1319

1242

def peer_certificate(session):

1329

1252

.gnutls_certificate_get_peers

1330

1253

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

1331

1254

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

1332

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

1333

" certificate")

1255

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

1256

u" certificate")

1334

1257

if list_size.value == 0:

1335

1258

return None

1336

1259

cert = cert_list[0]

1362

1285

if crtverify.value != 0:

1363

1286

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1364

1287

raise (gnutls.errors.CertificateSecurityError

1365

("Verify failed"))

1288

(u"Verify failed"))

1366

1289

# New buffer for the fingerprint

1367

1290

buf = ctypes.create_string_buffer(20)

1368

1291

buf_len = ctypes.c_size_t()

1375

1298

# Convert the buffer to a Python bytestring

1376

1299

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

1377

1300

# Convert the bytestring to hexadecimal notation

1378

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

1301

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

1379

1302

return hex_fpr

1380

1303

1381

1304

1404

1327

1405

1328

super(MultiprocessingMixInWithPipe,

1406

1329

self).process_request(request, client_address)

1407

self.child_pipe.close()

1408

1330

self.add_pipe(parent_pipe)

1409

1410

1331

def add_pipe(self, parent_pipe):

1411

1332

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

1412

raise NotImplementedError

1333

pass

1413

1334

1414

1335

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1415

1336

socketserver.TCPServer, object):

1433

1354

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

1434

1355

if self.interface is not None:

1435

1356

if SO_BINDTODEVICE is None:

1436

logger.error("SO_BINDTODEVICE does not exist;"

1437

" cannot bind to interface %s",

1357

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

1358

u" cannot bind to interface %s",

1438

1359

self.interface)

1439

1360

else:

1440

1361

try:

1441

1362

self.socket.setsockopt(socket.SOL_SOCKET,

1442

1363

SO_BINDTODEVICE,

1443

1364

str(self.interface

1444

+ '\0'))

1365

+ u'\0'))

1445

1366

except socket.error, error:

1446

1367

if error[0] == errno.EPERM:

1447

logger.error("No permission to"

1448

" bind to interface %s",

1368

logger.error(u"No permission to"

1369

u" bind to interface %s",

1449

1370

self.interface)

1450

1371

elif error[0] == errno.ENOPROTOOPT:

1451

logger.error("SO_BINDTODEVICE not available;"

1452

" cannot bind to interface %s",

1372

logger.error(u"SO_BINDTODEVICE not available;"

1373

u" cannot bind to interface %s",

1453

1374

self.interface)

1454

1375

else:

1455

1376

raise

1457

1378

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

1458

1379

if not self.server_address[0]:

1459

1380

if self.address_family == socket.AF_INET6:

1460

any_address = "::" # in6addr_any

1381

any_address = u"::" # in6addr_any

1461

1382

else:

1462

1383

any_address = socket.INADDR_ANY

1463

1384

self.server_address = (any_address,

1512

1433

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

1513

1434

client_object=None):

1514

1435

condition_names = {

1515

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

1516

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

1436

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

1437

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

1517

1438

# blocking).

1518

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

1519

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

1520

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

1439

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

1440

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

1441

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

1521

1442

# broken, usually for pipes and

1522

1443

# sockets).

1523

1444

}

1525

1446

for cond, name in

1526

1447

condition_names.iteritems()

1527

1448

if cond & condition)

1528

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

1529

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

1530

return False

1449

logger.debug(u"Handling IPC: FD = %d, condition = %s", source,

1450

conditions_string)

1531

1451

1532

1452

# Read a request from the child

1533

1453

request = parent_pipe.recv()

1542

1462

client = c

1543

1463

break

1544

1464

else:

1545

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

1546

"dress: %s", fpr, address)

1465

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

1466

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

1547

1467

if self.use_dbus:

1548

1468

# Emit D-Bus signal

1549

mandos_dbus_service.ClientNotFound(fpr, address[0])

1469

mandos_dbus_service.ClientNotFound(fpr, address)

1550

1470

parent_pipe.send(False)

1551

1471

return False

1552

1472

1571

1491

parent_pipe.send(('function',))

1572

1492

else:

1573

1493

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

1574

1494

1575

1495

if command == 'setattr':

1576

1496

attrname = request[1]

1577

1497

value = request[2]

1578

1498

setattr(client_object, attrname, value)

1579

1499

1580

1500

return True

1581

1501

1582

1502

1583

1503

def string_to_delta(interval):

1584

1504

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

1585

1505

1586

>>> string_to_delta('7d')

1506

>>> string_to_delta(u'7d')

1587

1507

datetime.timedelta(7)

1588

>>> string_to_delta('60s')

1508

>>> string_to_delta(u'60s')

1589

1509

datetime.timedelta(0, 60)

1590

>>> string_to_delta('60m')

1510

>>> string_to_delta(u'60m')

1591

1511

datetime.timedelta(0, 3600)

1592

>>> string_to_delta('24h')

1512

>>> string_to_delta(u'24h')

1593

1513

datetime.timedelta(1)

1594

>>> string_to_delta('1w')

1514

>>> string_to_delta(u'1w')

1595

1515

datetime.timedelta(7)

1596

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

1516

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

1597

1517

datetime.timedelta(0, 330)

1598

1518

"""

1599

1519

timevalue = datetime.timedelta(0)

1601

1521

try:

1602

1522

suffix = unicode(s[-1])

1603

1523

value = int(s[:-1])

1604

if suffix == "d":

1524

if suffix == u"d":

1605

1525

delta = datetime.timedelta(value)

1606

elif suffix == "s":

1526

elif suffix == u"s":

1607

1527

delta = datetime.timedelta(0, value)

1608

elif suffix == "m":

1528

elif suffix == u"m":

1609

1529

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

1610

elif suffix == "h":

1530

elif suffix == u"h":

1611

1531

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

1612

elif suffix == "w":

1532

elif suffix == u"w":

1613

1533

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

1614

1534

else:

1615

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

1535

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

1616

1536

except (ValueError, IndexError), e:

1617

raise ValueError(*(e.args))

1537

raise ValueError(e.message)

1618

1538

timevalue += delta

1619

1539

return timevalue

1620

1540

1626

1546

global if_nametoindex

1627

1547

try:

1628

1548

if_nametoindex = (ctypes.cdll.LoadLibrary

1629

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

1549

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

1630

1550

.if_nametoindex)

1631

1551

except (OSError, AttributeError):

1632

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

1552

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

1633

1553

def if_nametoindex(interface):

1634

1554

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

1635

1555

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

1636

1556

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

1637

1557

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1638

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

1558

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

1639

1559

interface))

1640

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

1560

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

1641

1561

ifreq[16:20])[0]

1642

1562

return interface_index

1643

1563

return if_nametoindex(interface)

1651

1571

sys.exit()

1652

1572

os.setsid()

1653

1573

if not nochdir:

1654

os.chdir("/")

1574

os.chdir(u"/")

1655

1575

if os.fork():

1656

1576

sys.exit()

1657

1577

if not noclose:

1659

1579

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

1660

1580

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

1661

1581

raise OSError(errno.ENODEV,

1662

"%s not a character device"

1582

u"%s not a character device"

1663

1583

% os.path.devnull)

1664

1584

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

1665

1585

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

1673

1593

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

1674

1594

# Parsing of options, both command line and config file

1675

1595

1676

parser = argparse.ArgumentParser()

1677

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

1678

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

1679

help="show version number and exit")

1680

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

1681

help="Bind to interface IF")

1682

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

1683

help="Address to listen for requests on")

1684

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

1685

help="Port number to receive requests on")

1686

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

1687

help="Run self-test")

1688

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

1689

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

1690

" to terminal")

1691

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

1692

help="Debug level for stdout output")

1693

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

1694

" priority string (see GnuTLS documentation)")

1695

parser.add_argument("--servicename",

1696

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

1697

parser.add_argument("--configdir",

1698

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

1699

help="Directory to search for configuration"

1700

" files")

1701

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

1702

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

1703

" system bus interface")

1704

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

1705

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

1706

options = parser.parse_args()

1596

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

1597

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

1598

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

1599

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

1600

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

1601

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

1602

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

1603

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

1604

help=u"Run self-test")

1605

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

1606

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

1607

u" terminal")

1608

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

1609

u" priority string (see GnuTLS documentation)")

1610

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

1611

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

1612

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

1613

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

1614

help=u"Directory to search for configuration"

1615

u" files")

1616

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

1617

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

1618

u" system bus interface")

1619

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

1620

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

1621

options = parser.parse_args()[0]

1707

1622

1708

1623

if options.check:

1709

1624

import doctest

1711

1626

sys.exit()

1712

1627

1713

1628

# Default values for config file for server-global settings

1714

server_defaults = { "interface": "",

1715

"address": "",

1716

"port": "",

1717

"debug": "False",

1718

"priority":

1719

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

1720

"servicename": "Mandos",

1721

"use_dbus": "True",

1722

"use_ipv6": "True",

1723

"debuglevel": "",

1629

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

1630

u"address": u"",

1631

u"port": u"",

1632

u"debug": u"False",

1633

u"priority":

1634

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

1635

u"servicename": u"Mandos",

1636

u"use_dbus": u"True",

1637

u"use_ipv6": u"True",

1724

1638

}

1725

1639

1726

1640

# Parse config file for server-global settings

1727

1641

server_config = configparser.SafeConfigParser(server_defaults)

1728

1642

del server_defaults

1729

1643

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

1730

"mandos.conf"))

1644

u"mandos.conf"))

1731

1645

# Convert the SafeConfigParser object to a dict

1732

1646

server_settings = server_config.defaults()

1733

1647

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

1734

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

1735

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

1648

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

1649

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

1736

1650

option)

1737

1651

if server_settings["port"]:

1738

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

1739

"port")

1652

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

1653

u"port")

1740

1654

del server_config

1741

1655

1742

1656

# Override the settings from the config file with command line

1743

1657

# options, if set.

1744

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

1745

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

1746

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

1658

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

1659

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

1660

u"use_dbus", u"use_ipv6"):

1747

1661

value = getattr(options, option)

1748

1662

if value is not None:

1749

1663

server_settings[option] = value

1757

1671

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

1758

1672

1759

1673

# For convenience

1760

debug = server_settings["debug"]

1761

debuglevel = server_settings["debuglevel"]

1762

use_dbus = server_settings["use_dbus"]

1763

use_ipv6 = server_settings["use_ipv6"]

1764

1765

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

1674

debug = server_settings[u"debug"]

1675

use_dbus = server_settings[u"use_dbus"]

1676

use_ipv6 = server_settings[u"use_ipv6"]

1677

1678

if not debug:

1679

syslogger.setLevel(logging.WARNING)

1680

console.setLevel(logging.WARNING)

1681

1682

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

1766

1683

syslogger.setFormatter(logging.Formatter

1767

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

1768

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

1769

% server_settings["servicename"]))

1684

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

1685

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

1686

% server_settings[u"servicename"]))

1770

1687

1771

1688

# Parse config file with clients

1772

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

1773

"interval": "5m",

1774

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

1775

"host": "",

1776

"approval_delay": "0s",

1777

"approval_duration": "1s",

1689

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

1690

u"interval": u"5m",

1691

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

1692

u"host": u"",

1693

u"approved_delay": u"0s",

1694

u"approved_duration": u"1s",

1778

1695

}

1779

1696

client_config = configparser.SafeConfigParser(client_defaults)

1780

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

1781

"clients.conf"))

1697

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

1698

u"clients.conf"))

1782

1699

1783

1700

global mandos_dbus_service

1784

1701

mandos_dbus_service = None

1785

1702

1786

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

1787

server_settings["port"]),

1703

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

1704

server_settings[u"port"]),

1788

1705

ClientHandler,

1789

interface=(server_settings["interface"]

1790

or None),

1706

interface=server_settings[u"interface"],

1791

1707

use_ipv6=use_ipv6,

1792

1708

gnutls_priority=

1793

server_settings["priority"],

1709

server_settings[u"priority"],

1794

1710

use_dbus=use_dbus)

1795

if not debug:

1796

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

1797

try:

1798

pidfile = open(pidfilename, "w")

1799

except IOError:

1800

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

1711

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

1712

try:

1713

pidfile = open(pidfilename, u"w")

1714

except IOError:

1715

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

1801

1716

1802

1717

try:

1803

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

1804

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

1718

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

1719

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

1805

1720

except KeyError:

1806

1721

try:

1807

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

1808

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

1722

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

1723

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

1809

1724

except KeyError:

1810

1725

try:

1811

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

1812

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

1726

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

1727

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

1813

1728

except KeyError:

1814

1729

uid = 65534

1815

1730

gid = 65534

1820

1735

if error[0] != errno.EPERM:

1821

1736

raise error

1822

1737

1823

if not debug and not debuglevel:

1824

syslogger.setLevel(logging.WARNING)

1825

console.setLevel(logging.WARNING)

1826

if debuglevel:

1827

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

1828

syslogger.setLevel(level)

1829

console.setLevel(level)

1830

1738

# Enable all possible GnuTLS debugging

1831

1739

if debug:

1832

# Enable all possible GnuTLS debugging

1833

1834

1740

# "Use a log level over 10 to enable all debugging options."

1835

1741

# - GnuTLS manual

1836

1742

gnutls.library.functions.gnutls_global_set_log_level(11)

1837

1743

1838

1744

@gnutls.library.types.gnutls_log_func

1839

1745

def debug_gnutls(level, string):

1840

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

1746

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

1841

1747

1842

1748

(gnutls.library.functions

1843

1749

.gnutls_global_set_log_function(debug_gnutls))

1844

1845

# Redirect stdin so all checkers get /dev/null

1846

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

1847

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

1848

if null > 2:

1849

os.close(null)

1850

else:

1851

# No console logging

1852

logger.removeHandler(console)

1853

1854

# Need to fork before connecting to D-Bus

1855

if not debug:

1856

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

1857

daemon()

1858

1750

1859

1751

global main_loop

1860

1752

# From the Avahi example code

1864

1756

# End of Avahi example code

1865

1757

if use_dbus:

1866

1758

try:

1867

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

1759

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

1868

1760

bus, do_not_queue=True)

1869

1761

except dbus.exceptions.NameExistsException, e:

1870

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

1762

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

1871

1763

use_dbus = False

1872

server_settings["use_dbus"] = False

1764

server_settings[u"use_dbus"] = False

1873

1765

tcp_server.use_dbus = False

1874

1766

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1875

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

1876

servicetype = "_mandos._tcp",

1767

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

1768

servicetype = u"_mandos._tcp",

1877

1769

protocol = protocol, bus = bus)

1878

1770

if server_settings["interface"]:

1879

1771

service.interface = (if_nametoindex

1880

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

1881

1882

global multiprocessing_manager

1883

multiprocessing_manager = multiprocessing.Manager()

1772

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

1884

1773

1885

1774

client_class = Client

1886

1775

if use_dbus:

1903

1792

client_config, section)))

1904

1793

for section in client_config.sections()))

1905

1794

if not tcp_server.clients:

1906

logger.warning("No clients defined")

1907

1795

logger.warning(u"No clients defined")

1796

1797

if debug:

1798

# Redirect stdin so all checkers get /dev/null

1799

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

1800

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

1801

if null > 2:

1802

os.close(null)

1803

else:

1804

# No console logging

1805

logger.removeHandler(console)

1806

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

1807

daemon()

1808

1809

try:

1810

with pidfile:

1811

pid = os.getpid()

1812

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

1813

del pidfile

1814

except IOError:

1815

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

1816

pidfilename, pid)

1817

except NameError:

1818

# "pidfile" was never created

1819

pass

1820

del pidfilename

1821

1908

1822

if not debug:

1909

try:

1910

with pidfile:

1911

pid = os.getpid()

1912

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

1913

del pidfile

1914

except IOError:

1915

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

1916

pidfilename, pid)

1917

except NameError:

1918

# "pidfile" was never created

1919

pass

1920

del pidfilename

1921

1922

1823

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

1923

1924

1824

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

1925

1825

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

1926

1826

1928

1828

class MandosDBusService(dbus.service.Object):

1929

1829

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

1930

1830

def __init__(self):

1931

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

1932

_interface = "se.bsnet.fukt.Mandos"

1831

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

1832

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

1933

1833

1934

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

1834

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

1935

1835

def ClientAdded(self, objpath):

1936

1836

"D-Bus signal"

1937

1837

pass

1938

1838

1939

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

1839

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

1940

1840

def ClientNotFound(self, fingerprint, address):

1941

1841

"D-Bus signal"

1942

1842

pass

1943

1843

1944

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

1844

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

1945

1845

def ClientRemoved(self, objpath, name):

1946

1846

"D-Bus signal"

1947

1847

pass

1948

1848

1949

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

1849

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

1950

1850

def GetAllClients(self):

1951

1851

"D-Bus method"

1952

1852

return dbus.Array(c.dbus_object_path

1953

1853

for c in tcp_server.clients)

1954

1854

1955

1855

@dbus.service.method(_interface,

1956

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

1856

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

1957

1857

def GetAllClientsWithProperties(self):

1958

1858

"D-Bus method"

1959

1859

return dbus.Dictionary(

1960

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

1860

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

1961

1861

for c in tcp_server.clients),

1962

signature="oa{sv}")

1862

signature=u"oa{sv}")

1963

1863

1964

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

1864

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

1965

1865

def RemoveClient(self, object_path):

1966

1866

"D-Bus method"

1967

1867

for c in tcp_server.clients:

2009

1909

# Find out what port we got

2010

1910

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

2011

1911

if use_ipv6:

2012

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

1912

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

2013

1913

" flowinfo %d, scope_id %d"

2014

1914

% tcp_server.socket.getsockname())

2015

1915

else: # IPv4

2016

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

1916

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

2017

1917

% tcp_server.socket.getsockname())

2018

1918

2019

1919

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

2023

1923

try:

2024

1924

service.activate()

2025

1925

except dbus.exceptions.DBusException, error:

2026

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

1926

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

2027

1927

cleanup()

2028

1928

sys.exit(1)

2029

1929

# End of Avahi example code

2033

1933

(tcp_server.handle_request

2034

1934

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

2035

1935

2036

logger.debug("Starting main loop")

1936

logger.debug(u"Starting main loop")

2037

1937

main_loop.run()

2038

1938

except AvahiError, error:

2039

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

1939

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

2040

1940

cleanup()

2041

1941

sys.exit(1)

2042

1942

except KeyboardInterrupt:

2043

1943

if debug:

2044

print("", file=sys.stderr)

2045

logger.debug("Server received KeyboardInterrupt")

2046

logger.debug("Server exiting")

1944

print >> sys.stderr

1945

logger.debug(u"Server received KeyboardInterrupt")

1946

logger.debug(u"Server exiting")

2047

1947

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

2048

1948

cleanup()

2049

1949