/mandos/trunk : revision 423

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

124

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

122

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

177

if self.group is not None:

180

try:

181

self.group.Free()

182

except (dbus.exceptions.UnknownMethodException,

183

dbus.exceptions.DBusException) as e:

184

pass

185

self.group = None

186

if self.entry_group_state_changed_match is not None:

187

self.entry_group_state_changed_match.remove()

188

self.entry_group_state_changed_match = None

178

self.group.Reset()

189

179

def add(self):

190

180

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

191

self.remove()

192

self.group = dbus.Interface(

193

self.bus.get_object(avahi.DBUS_NAME,

194

self.server.EntryGroupNew(),

195

follow_name_owner_changes=True),

196

avahi.DBUS_INTERFACE_ENTRY_GROUP)

197

self.entry_group_state_changed_match = (

198

self.group.connect_to_signal(

199

'StateChanged', self .entry_group_state_changed))

200

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

181

if self.group is None:

182

self.group = dbus.Interface(

183

self.bus.get_object(avahi.DBUS_NAME,

184

self.server.EntryGroupNew()),

185

avahi.DBUS_INTERFACE_ENTRY_GROUP)

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

201

190

self.name, self.type)

202

191

self.group.AddService(

203

192

self.interface,

210

199

self.group.Commit()

211

200

def entry_group_state_changed(self, state, error):

212

201

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

213

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

202

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

214

203

215

204

if state == avahi.ENTRY_GROUP_ESTABLISHED:

216

logger.debug("Zeroconf service established.")

205

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

217

206

elif state == avahi.ENTRY_GROUP_COLLISION:

218

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

207

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

219

208

self.rename()

220

209

elif state == avahi.ENTRY_GROUP_FAILURE:

221

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

210

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

222

211

unicode(error))

223

raise AvahiGroupError("State changed: %s"

212

raise AvahiGroupError(u"State changed: %s"

224

213

% unicode(error))

225

214

def cleanup(self):

226

215

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

227

self.remove()

228

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

216

if self.group is not None:

217

self.group.Free()

218

self.group = None

219

def server_state_changed(self, state):

229

220

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

230

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

231

bad_states = { avahi.SERVER_INVALID:

232

"Zeroconf server invalid",

233

avahi.SERVER_REGISTERING: None,

234

avahi.SERVER_COLLISION:

235

"Zeroconf server name collision",

236

avahi.SERVER_FAILURE:

237

"Zeroconf server failure" }

238

if state in bad_states:

239

if bad_states[state]:

240

logger.error(bad_states[state])

221

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

222

if state == avahi.SERVER_COLLISION:

223

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

241

224

self.remove()

242

225

elif state == avahi.SERVER_RUNNING:

243

226

self.add()

244

else:

245

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

246

227

def activate(self):

247

228

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

248

229

if self.server is None:

249

230

self.server = dbus.Interface(

250

231

self.bus.get_object(avahi.DBUS_NAME,

251

avahi.DBUS_PATH_SERVER,

252

follow_name_owner_changes=True),

232

avahi.DBUS_PATH_SERVER),

253

233

avahi.DBUS_INTERFACE_SERVER)

254

self.server.connect_to_signal("StateChanged",

234

self.server.connect_to_signal(u"StateChanged",

255

235

self.server_state_changed)

256

236

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

257

237

260

240

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

261

241

262

242

Attributes:

263

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

264

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

265

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

243

244

D-Bus identifiers

245

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

246

uniquely identify the client

247

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

248

host: string; available for use by the checker command

249

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

250

last_enabled: datetime.datetime(); (UTC)

251

enabled: bool()

252

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

253

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

254

until this client is disabled

255

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

256

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

266

257

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

267

258

to see if the client lives.

268

259

'None' if no process is running.

269

checker_callback_tag: a gobject event source tag, or None

270

checker_command: string; External command which is run to check

271

if client lives. %() expansions are done at

260

checker_initiator_tag: a gobject event source tag, or None

261

disable_initiator_tag: - '' -

262

checker_callback_tag: - '' -

263

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

264

client lives. %() expansions are done at

272

265

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

273

266

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

274

checker_initiator_tag: a gobject event source tag, or None

275

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

276

267

current_checker_command: string; current running checker_command

277

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

278

disable_initiator_tag: a gobject event source tag, or None

279

enabled: bool()

280

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

281

uniquely identify the client

282

host: string; available for use by the checker command

283

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

284

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

285

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

286

last_enabled: datetime.datetime(); (UTC)

287

288

D-Bus identifiers

289

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

290

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

291

until this client is disabled

292

runtime_expansions: Allowed attributes for runtime expansion.

268

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

269

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

270

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

293

271

"""

294

272

295

runtime_expansions = ("approval_delay", "approval_duration",

296

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

297

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

298

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

299

300

273

@staticmethod

301

274

def _timedelta_to_milliseconds(td):

302

275

"Convert a datetime.timedelta() to milliseconds"

322

295

self.name = name

323

296

if config is None:

324

297

config = {}

325

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

298

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

326

299

# Uppercase and remove spaces from fingerprint for later

327

300

# comparison purposes with return value from the fingerprint()

328

301

# function

329

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

330

.replace(" ", ""))

331

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

332

if "secret" in config:

333

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

334

elif "secfile" in config:

302

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

303

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

304

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

305

if u"secret" in config:

306

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

307

elif u"secfile" in config:

335

308

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

336

(config["secfile"])),

309

(config[u"secfile"])),

337

310

"rb") as secfile:

338

311

self.secret = secfile.read()

339

312

else:

340

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

313

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

341

314

% self.name)

342

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

315

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

343

316

self.created = datetime.datetime.utcnow()

344

317

self.enabled = False

345

self.last_approval_request = None

346

318

self.last_enabled = None

347

319

self.last_checked_ok = None

348

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

349

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

320

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

321

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

350

322

self.disable_hook = disable_hook

351

323

self.checker = None

352

324

self.checker_initiator_tag = None

353

325

self.disable_initiator_tag = None

354

326

self.checker_callback_tag = None

355

self.checker_command = config["checker"]

327

self.checker_command = config[u"checker"]

356

328

self.current_checker_command = None

357

329

self.last_connect = None

358

330

self._approved = None

359

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

331

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

360

332

True)

361

333

self.approvals_pending = 0

362

334

self.approval_delay = string_to_delta(

363

config["approval_delay"])

335

config[u"approval_delay"])

364

336

self.approval_duration = string_to_delta(

365

config["approval_duration"])

337

config[u"approval_duration"])

366

338

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

367

339

368

340

def send_changedstate(self):

372

344

373

345

def enable(self):

374

346

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

375

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

347

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

376

348

# Already enabled

377

349

return

378

350

self.send_changedstate()

397

369

if not quiet:

398

370

self.send_changedstate()

399

371

if not quiet:

400

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

401

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

372

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

373

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

402

374

gobject.source_remove(self.disable_initiator_tag)

403

375

self.disable_initiator_tag = None

404

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

376

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

405

377

gobject.source_remove(self.checker_initiator_tag)

406

378

self.checker_initiator_tag = None

407

379

self.stop_checker()

422

394

if os.WIFEXITED(condition):

423

395

exitstatus = os.WEXITSTATUS(condition)

424

396

if exitstatus == 0:

425

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

397

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

426

398

vars(self))

427

399

self.checked_ok()

428

400

else:

429

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

401

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

430

402

vars(self))

431

403

else:

432

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

404

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

433

405

vars(self))

434

406

435

407

def checked_ok(self):

444

416

(self.timeout_milliseconds(),

445

417

self.disable))

446

418

447

def need_approval(self):

448

self.last_approval_request = datetime.datetime.utcnow()

449

450

419

def start_checker(self):

451

420

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

452

421

464

433

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

465

434

try:

466

435

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

467

except (AttributeError, OSError) as error:

436

except (AttributeError, OSError), error:

468

437

if (isinstance(error, OSError)

469

438

and error.errno != errno.ECHILD):

470

439

raise error

471

440

else:

472

441

if pid:

473

logger.warning("Checker was a zombie")

442

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

474

443

gobject.source_remove(self.checker_callback_tag)

475

444

self.checker_callback(pid, status,

476

445

self.current_checker_command)

481

450

command = self.checker_command % self.host

482

451

except TypeError:

483

452

# Escape attributes for the shell

484

escaped_attrs = dict(

485

(attr,

486

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

487

errors=

488

'replace')))

489

for attr in

490

self.runtime_expansions)

491

453

escaped_attrs = dict((key,

454

re.escape(unicode(str(val),

455

errors=

456

u'replace')))

457

for key, val in

458

vars(self).iteritems())

492

459

try:

493

460

command = self.checker_command % escaped_attrs

494

except TypeError as error:

495

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

496

' %s', self.checker_command, error)

461

except TypeError, error:

462

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

463

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

497

464

return True # Try again later

498

465

self.current_checker_command = command

499

466

try:

500

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

467

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

501

468

command, self.name)

502

469

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

503

470

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

505

472

# always replaced by /dev/null.)

506

473

self.checker = subprocess.Popen(command,

507

474

close_fds=True,

508

shell=True, cwd="/")

475

shell=True, cwd=u"/")

509

476

self.checker_callback_tag = (gobject.child_watch_add

510

477

(self.checker.pid,

511

478

self.checker_callback,

516

483

if pid:

517

484

gobject.source_remove(self.checker_callback_tag)

518

485

self.checker_callback(pid, status, command)

519

except OSError as error:

520

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

486

except OSError, error:

487

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

521

488

error)

522

489

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

523

490

return True

527

494

if self.checker_callback_tag:

528

495

gobject.source_remove(self.checker_callback_tag)

529

496

self.checker_callback_tag = None

530

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

497

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

531

498

return

532

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

499

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

533

500

try:

534

501

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

535

502

#time.sleep(0.5)

536

503

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

537

504

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

538

except OSError as error:

505

except OSError, error:

539

506

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

540

507

raise

541

508

self.checker = None

542

509

543

def dbus_service_property(dbus_interface, signature="v",

544

access="readwrite", byte_arrays=False):

510

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

511

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

545

512

"""Decorators for marking methods of a DBusObjectWithProperties to

546

513

become properties on the D-Bus.

547

514

554

521

"""

555

522

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

556

523

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

557

if byte_arrays and signature != "ay":

558

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

559

" signature %r" % signature)

524

if byte_arrays and signature != u"ay":

525

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

526

u" signature %r" % signature)

560

527

def decorator(func):

561

528

func._dbus_is_property = True

562

529

func._dbus_interface = dbus_interface

563

530

func._dbus_signature = signature

564

531

func._dbus_access = access

565

532

func._dbus_name = func.__name__

566

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

533

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

567

534

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

568

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

535

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

569

536

return func

570

537

return decorator

571

538

599

566

600

567

@staticmethod

601

568

def _is_dbus_property(obj):

602

return getattr(obj, "_dbus_is_property", False)

569

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

603

570

604

571

def _get_all_dbus_properties(self):

605

572

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

613

580

property with the specified name and interface.

614

581

"""

615

582

for name in (property_name,

616

property_name + "_dbus_property"):

583

property_name + u"_dbus_property"):

617

584

prop = getattr(self, name, None)

618

585

if (prop is None

619

586

or not self._is_dbus_property(prop)

623

590

continue

624

591

return prop

625

592

# No such property

626

raise DBusPropertyNotFound(self.dbus_object_path + ":"

627

+ interface_name + "."

593

raise DBusPropertyNotFound(self.dbus_object_path + u":"

594

+ interface_name + u"."

628

595

+ property_name)

629

596

630

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

631

out_signature="v")

597

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

598

out_signature=u"v")

632

599

def Get(self, interface_name, property_name):

633

600

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

634

601

"""

635

602

prop = self._get_dbus_property(interface_name, property_name)

636

if prop._dbus_access == "write":

603

if prop._dbus_access == u"write":

637

604

raise DBusPropertyAccessException(property_name)

638

605

value = prop()

639

if not hasattr(value, "variant_level"):

606

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

640

607

return value

641

608

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

642

609

643

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

610

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

644

611

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

645

612

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

646

613

"""

647

614

prop = self._get_dbus_property(interface_name, property_name)

648

if prop._dbus_access == "read":

615

if prop._dbus_access == u"read":

649

616

raise DBusPropertyAccessException(property_name)

650

if prop._dbus_get_args_options["byte_arrays"]:

617

if prop._dbus_get_args_options[u"byte_arrays"]:

651

618

# The byte_arrays option is not supported yet on

652

619

# signatures other than "ay".

653

if prop._dbus_signature != "ay":

620

if prop._dbus_signature != u"ay":

654

621

raise ValueError

655

622

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

656

623

for byte in value))

657

624

prop(value)

658

625

659

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

660

out_signature="a{sv}")

626

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

627

out_signature=u"a{sv}")

661

628

def GetAll(self, interface_name):

662

629

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

663

630

standard.

671

638

# Interface non-empty but did not match

672

639

continue

673

640

# Ignore write-only properties

674

if prop._dbus_access == "write":

641

if prop._dbus_access == u"write":

675

642

continue

676

643

value = prop()

677

if not hasattr(value, "variant_level"):

644

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

678

645

all[name] = value

679

646

continue

680

647

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

681

648

value.variant_level+1)

682

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

649

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

683

650

684

651

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

685

out_signature="s",

652

out_signature=u"s",

686

653

path_keyword='object_path',

687

654

connection_keyword='connection')

688

655

def Introspect(self, object_path, connection):

693

660

try:

694

661

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

695

662

def make_tag(document, name, prop):

696

e = document.createElement("property")

697

e.setAttribute("name", name)

698

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

699

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

663

e = document.createElement(u"property")

664

e.setAttribute(u"name", name)

665

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

666

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

700

667

return e

701

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

668

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

702

669

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

703

670

for name, prop

704

671

in self._get_all_dbus_properties()

705

672

if prop._dbus_interface

706

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

673

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

707

674

if_tag.appendChild(tag)

708

675

# Add the names to the return values for the

709

676

# "org.freedesktop.DBus.Properties" methods

710

if (if_tag.getAttribute("name")

711

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

712

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

713

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

714

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

715

if (arg.getAttribute("direction")

716

== "out"):

717

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

718

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

719

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

720

if (arg.getAttribute("direction")

721

== "out"):

722

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

723

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

677

if (if_tag.getAttribute(u"name")

678

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

679

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

680

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

681

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

682

if (arg.getAttribute(u"direction")

683

== u"out"):

684

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

685

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

686

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

687

if (arg.getAttribute(u"direction")

688

== u"out"):

689

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

690

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

724

691

document.unlink()

725

692

except (AttributeError, xml.dom.DOMException,

726

xml.parsers.expat.ExpatError) as error:

727

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

693

xml.parsers.expat.ExpatError), error:

694

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

728

695

error)

729

696

return xmlstring

730

697

736

703

dbus_object_path: dbus.ObjectPath

737

704

bus: dbus.SystemBus()

738

705

"""

739

740

runtime_expansions = (Client.runtime_expansions

741

+ ("dbus_object_path",))

742

743

706

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

744

707

745

708

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

748

711

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

749

712

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

750

713

# the D-Bus

751

client_object_name = unicode(self.name).translate(

752

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

753

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

754

714

self.dbus_object_path = (dbus.ObjectPath

755

("/clients/" + client_object_name))

715

(u"/clients/"

716

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

756

717

DBusObjectWithProperties.__init__(self, self.bus,

757

718

self.dbus_object_path)

758

719

765

726

if (hasattr(self, "dbus_object_path")

766

727

and bval is not bool(old_value)):

767

728

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

768

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

729

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

769

730

dbus_bool)

770

731

771

732

approvals_pending = property(_get_approvals_pending,

779

740

variant_level=variant_level)

780

741

781

742

def enable(self):

782

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

743

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

783

744

r = Client.enable(self)

784

745

if oldstate != self.enabled:

785

746

# Emit D-Bus signals

786

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

747

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

787

748

dbus.Boolean(True, variant_level=1))

788

749

self.PropertyChanged(

789

dbus.String("LastEnabled"),

750

dbus.String(u"LastEnabled"),

790

751

self._datetime_to_dbus(self.last_enabled,

791

752

variant_level=1))

792

753

return r

793

754

794

755

def disable(self, quiet = False):

795

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

756

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

796

757

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

797

758

if not quiet and oldstate != self.enabled:

798

759

# Emit D-Bus signal

799

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

760

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

800

761

dbus.Boolean(False, variant_level=1))

801

762

return r

802

763

805

766

self.remove_from_connection()

806

767

except LookupError:

807

768

pass

808

if hasattr(DBusObjectWithProperties, "__del__"):

769

if hasattr(DBusObjectWithProperties, u"__del__"):

809

770

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

810

771

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

811

772

814

775

self.checker_callback_tag = None

815

776

self.checker = None

816

777

# Emit D-Bus signal

817

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

778

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

818

779

dbus.Boolean(False, variant_level=1))

819

780

if os.WIFEXITED(condition):

820

781

exitstatus = os.WEXITSTATUS(condition)

832

793

*args, **kwargs)

833

794

834

795

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

835

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

796

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

836

797

# Emit D-Bus signal

837

798

self.PropertyChanged(

838

dbus.String("LastCheckedOK"),

799

dbus.String(u"LastCheckedOK"),

839

800

(self._datetime_to_dbus(self.last_checked_ok,

840

801

variant_level=1)))

841

842

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

843

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

844

# Emit D-Bus signal

845

self.PropertyChanged(

846

dbus.String("LastApprovalRequest"),

847

(self._datetime_to_dbus(self.last_approval_request,

848

variant_level=1)))

849

802

return r

850

803

851

804

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

861

814

# Emit D-Bus signal

862

815

self.CheckerStarted(self.current_checker_command)

863

816

self.PropertyChanged(

864

dbus.String("CheckerRunning"),

817

dbus.String(u"CheckerRunning"),

865

818

dbus.Boolean(True, variant_level=1))

866

819

return r

867

820

868

821

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

869

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

822

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

870

823

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

871

824

if (old_checker is not None

872

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

873

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

825

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

826

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

874

827

dbus.Boolean(False, variant_level=1))

875

828

return r

876

829

887

840

888

841

889

842

## D-Bus methods, signals & properties

890

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

843

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

891

844

892

845

## Signals

893

846

894

847

# CheckerCompleted - signal

895

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

848

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

896

849

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

897

850

"D-Bus signal"

898

851

pass

899

852

900

853

# CheckerStarted - signal

901

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

854

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

902

855

def CheckerStarted(self, command):

903

856

"D-Bus signal"

904

857

pass

905

858

906

859

# PropertyChanged - signal

907

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

860

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

908

861

def PropertyChanged(self, property, value):

909

862

"D-Bus signal"

910

863

pass

919

872

pass

920

873

921

874

# Rejected - signal

922

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

875

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

923

876

def Rejected(self, reason):

924

877

"D-Bus signal"

925

878

pass

926

879

927

880

# NeedApproval - signal

928

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

881

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

929

882

def NeedApproval(self, timeout, default):

930

883

"D-Bus signal"

931

return self.need_approval()

884

pass

932

885

933

886

## Methods

934

887

935

888

# Approve - method

936

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

889

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

937

890

def Approve(self, value):

938

891

self.approve(value)

939

892

940

893

# CheckedOK - method

941

894

@dbus.service.method(_interface)

942

895

def CheckedOK(self):

943

self.checked_ok()

896

return self.checked_ok()

944

897

945

898

# Enable - method

946

899

@dbus.service.method(_interface)

968

921

## Properties

969

922

970

923

# ApprovalPending - property

971

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

924

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

972

925

def ApprovalPending_dbus_property(self):

973

926

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

974

927

975

928

# ApprovedByDefault - property

976

@dbus_service_property(_interface, signature="b",

977

access="readwrite")

929

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

930

access=u"readwrite")

978

931

def ApprovedByDefault_dbus_property(self, value=None):

979

932

if value is None: # get

980

933

return dbus.Boolean(self.approved_by_default)

981

934

self.approved_by_default = bool(value)

982

935

# Emit D-Bus signal

983

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

936

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

984

937

dbus.Boolean(value, variant_level=1))

985

938

986

939

# ApprovalDelay - property

987

@dbus_service_property(_interface, signature="t",

988

access="readwrite")

940

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

941

access=u"readwrite")

989

942

def ApprovalDelay_dbus_property(self, value=None):

990

943

if value is None: # get

991

944

return dbus.UInt64(self.approval_delay_milliseconds())

992

945

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

993

946

# Emit D-Bus signal

994

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

947

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

995

948

dbus.UInt64(value, variant_level=1))

996

949

997

950

# ApprovalDuration - property

998

@dbus_service_property(_interface, signature="t",

999

access="readwrite")

951

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

952

access=u"readwrite")

1000

953

def ApprovalDuration_dbus_property(self, value=None):

1001

954

if value is None: # get

1002

955

return dbus.UInt64(self._timedelta_to_milliseconds(

1003

956

self.approval_duration))

1004

957

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

1005

958

# Emit D-Bus signal

1006

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

959

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

1007

960

dbus.UInt64(value, variant_level=1))

1008

961

1009

962

# Name - property

1010

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

963

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

1011

964

def Name_dbus_property(self):

1012

965

return dbus.String(self.name)

1013

966

1014

967

# Fingerprint - property

1015

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

968

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

1016

969

def Fingerprint_dbus_property(self):

1017

970

return dbus.String(self.fingerprint)

1018

971

1019

972

# Host - property

1020

@dbus_service_property(_interface, signature="s",

1021

access="readwrite")

973

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

974

access=u"readwrite")

1022

975

def Host_dbus_property(self, value=None):

1023

976

if value is None: # get

1024

977

return dbus.String(self.host)

1025

978

self.host = value

1026

979

# Emit D-Bus signal

1027

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

980

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

1028

981

dbus.String(value, variant_level=1))

1029

982

1030

983

# Created - property

1031

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

984

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

1032

985

def Created_dbus_property(self):

1033

986

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

1034

987

1035

988

# LastEnabled - property

1036

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

989

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

1037

990

def LastEnabled_dbus_property(self):

1038

991

if self.last_enabled is None:

1039

return dbus.String("")

992

return dbus.String(u"")

1040

993

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

1041

994

1042

995

# Enabled - property

1043

@dbus_service_property(_interface, signature="b",

1044

access="readwrite")

996

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

997

access=u"readwrite")

1045

998

def Enabled_dbus_property(self, value=None):

1046

999

if value is None: # get

1047

1000

return dbus.Boolean(self.enabled)

1051

1004

self.disable()

1052

1005

1053

1006

# LastCheckedOK - property

1054

@dbus_service_property(_interface, signature="s",

1055

access="readwrite")

1007

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

1008

access=u"readwrite")

1056

1009

def LastCheckedOK_dbus_property(self, value=None):

1057

1010

if value is not None:

1058

1011

self.checked_ok()

1059

1012

return

1060

1013

if self.last_checked_ok is None:

1061

return dbus.String("")

1014

return dbus.String(u"")

1062

1015

return dbus.String(self._datetime_to_dbus(self

1063

1016

.last_checked_ok))

1064

1017

1065

# LastApprovalRequest - property

1066

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

1067

def LastApprovalRequest_dbus_property(self):

1068

if self.last_approval_request is None:

1069

return dbus.String("")

1070

return dbus.String(self.

1071

_datetime_to_dbus(self

1072

.last_approval_request))

1073

1074

1018

# Timeout - property

1075

@dbus_service_property(_interface, signature="t",

1076

access="readwrite")

1019

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

1020

access=u"readwrite")

1077

1021

def Timeout_dbus_property(self, value=None):

1078

1022

if value is None: # get

1079

1023

return dbus.UInt64(self.timeout_milliseconds())

1080

1024

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

1081

1025

# Emit D-Bus signal

1082

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

1026

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

1083

1027

dbus.UInt64(value, variant_level=1))

1084

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

1028

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

1085

1029

return

1086

1030

# Reschedule timeout

1087

1031

gobject.source_remove(self.disable_initiator_tag)

1100

1044

(time_to_die, self.disable))

1101

1045

1102

1046

# Interval - property

1103

@dbus_service_property(_interface, signature="t",

1104

access="readwrite")

1047

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

1048

access=u"readwrite")

1105

1049

def Interval_dbus_property(self, value=None):

1106

1050

if value is None: # get

1107

1051

return dbus.UInt64(self.interval_milliseconds())

1108

1052

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

1109

1053

# Emit D-Bus signal

1110

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

1054

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

1111

1055

dbus.UInt64(value, variant_level=1))

1112

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

1056

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

1113

1057

return

1114

1058

# Reschedule checker run

1115

1059

gobject.source_remove(self.checker_initiator_tag)

1118

1062

self.start_checker() # Start one now, too

1119

1063

1120

1064

# Checker - property

1121

@dbus_service_property(_interface, signature="s",

1122

access="readwrite")

1065

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

1066

access=u"readwrite")

1123

1067

def Checker_dbus_property(self, value=None):

1124

1068

if value is None: # get

1125

1069

return dbus.String(self.checker_command)

1126

1070

self.checker_command = value

1127

1071

# Emit D-Bus signal

1128

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

1072

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

1129

1073

dbus.String(self.checker_command,

1130

1074

variant_level=1))

1131

1075

1132

1076

# CheckerRunning - property

1133

@dbus_service_property(_interface, signature="b",

1134

access="readwrite")

1077

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

1078

access=u"readwrite")

1135

1079

def CheckerRunning_dbus_property(self, value=None):

1136

1080

if value is None: # get

1137

1081

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

1141

1085

self.stop_checker()

1142

1086

1143

1087

# ObjectPath - property

1144

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

1088

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

1145

1089

def ObjectPath_dbus_property(self):

1146

1090

return self.dbus_object_path # is already a dbus.ObjectPath

1147

1091

1148

1092

# Secret = property

1149

@dbus_service_property(_interface, signature="ay",

1150

access="write", byte_arrays=True)

1093

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

1094

access=u"write", byte_arrays=True)

1151

1095

def Secret_dbus_property(self, value):

1152

1096

self.secret = str(value)

1153

1097

1188

1132

1189

1133

def handle(self):

1190

1134

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

1191

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

1135

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

1192

1136

unicode(self.client_address))

1193

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

1137

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

1194

1138

self.server.child_pipe.fileno())

1195

1139

1196

1140

session = (gnutls.connection

1203

1147

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

1204

1148

# here despite using OpenPGP certificates.

1205

1149

1206

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

1207

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

1208

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

1209

# "+DHE-DSS"))

1150

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

1151

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

1152

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

1153

# u"+DHE-DSS"))

1210

1154

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

1211

1155

priority = self.server.gnutls_priority

1212

1156

if priority is None:

1213

priority = "NORMAL"

1157

priority = u"NORMAL"

1214

1158

(gnutls.library.functions

1215

1159

.gnutls_priority_set_direct(session._c_object,

1216

1160

priority, None))

1218

1162

# Start communication using the Mandos protocol

1219

1163

# Get protocol number

1220

1164

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

1221

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

1165

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

1222

1166

try:

1223

1167

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

1224

1168

raise RuntimeError

1225

except (ValueError, IndexError, RuntimeError) as error:

1226

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

1169

except (ValueError, IndexError, RuntimeError), error:

1170

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

1227

1171

return

1228

1172

1229

1173

# Start GnuTLS connection

1230

1174

try:

1231

1175

session.handshake()

1232

except gnutls.errors.GNUTLSError as error:

1233

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

1176

except gnutls.errors.GNUTLSError, error:

1177

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

1234

1178

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

1235

1179

# established. Just abandon the request.

1236

1180

return

1237

logger.debug("Handshake succeeded")

1181

logger.debug(u"Handshake succeeded")

1238

1182

1239

1183

approval_required = False

1240

1184

try:

1241

1185

try:

1242

1186

fpr = self.fingerprint(self.peer_certificate

1243

1187

(session))

1244

except (TypeError,

1245

gnutls.errors.GNUTLSError) as error:

1246

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

1188

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

1189

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

1247

1190

return

1248

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

1191

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

1249

1192

1250

1193

try:

1251

1194

client = ProxyClient(child_pipe, fpr,

1260

1203

1261

1204

while True:

1262

1205

if not client.enabled:

1263

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

1206

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

1264

1207

client.name)

1265

1208

if self.server.use_dbus:

1266

1209

# Emit D-Bus signal

1271

1214

#We are approved or approval is disabled

1272

1215

break

1273

1216

elif client._approved is None:

1274

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

1217

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

1275

1218

client.name)

1276

1219

if self.server.use_dbus:

1277

1220

# Emit D-Bus signal

1279

1222

client.approval_delay_milliseconds(),

1280

1223

client.approved_by_default)

1281

1224

else:

1282

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

1225

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

1283

1226

client.name)

1284

1227

if self.server.use_dbus:

1285

1228

# Emit D-Bus signal

1300

1243

client.name)

1301

1244

if self.server.use_dbus:

1302

1245

# Emit D-Bus signal

1303

client.Rejected("Approval timed out")

1246

client.Rejected("Timed out")

1304

1247

return

1305

1248

else:

1306

1249

break

1311

1254

while sent_size < len(client.secret):

1312

1255

try:

1313

1256

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

1314

except gnutls.errors.GNUTLSError as error:

1257

except (gnutls.errors.GNUTLSError), error:

1315

1258

logger.warning("gnutls send failed")

1316

1259

return

1317

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

1260

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

1318

1261

sent, len(client.secret)

1319

1262

- (sent_size + sent))

1320

1263

sent_size += sent

1321

1264

1322

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

1265

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

1323

1266

# bump the timeout as if seen

1324

1267

client.checked_ok()

1325

1268

if self.server.use_dbus:

1331

1274

client.approvals_pending -= 1

1332

1275

try:

1333

1276

session.bye()

1334

except gnutls.errors.GNUTLSError as error:

1277

except (gnutls.errors.GNUTLSError), error:

1335

1278

logger.warning("GnuTLS bye failed")

1336

1279

1337

1280

@staticmethod

1348

1291

.gnutls_certificate_get_peers

1349

1292

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

1350

1293

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

1351

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

1352

" certificate")

1294

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

1295

u" certificate")

1353

1296

if list_size.value == 0:

1354

1297

return None

1355

1298

cert = cert_list[0]

1381

1324

if crtverify.value != 0:

1382

1325

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1383

1326

raise (gnutls.errors.CertificateSecurityError

1384

("Verify failed"))

1327

(u"Verify failed"))

1385

1328

# New buffer for the fingerprint

1386

1329

buf = ctypes.create_string_buffer(20)

1387

1330

buf_len = ctypes.c_size_t()

1394

1337

# Convert the buffer to a Python bytestring

1395

1338

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

1396

1339

# Convert the bytestring to hexadecimal notation

1397

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

1340

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

1398

1341

return hex_fpr

1399

1342

1400

1343

1428

1371

1429

1372

def add_pipe(self, parent_pipe):

1430

1373

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

1431

raise NotImplementedError

1374

pass

1432

1375

1433

1376

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1434

1377

socketserver.TCPServer, object):

1452

1395

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

1453

1396

if self.interface is not None:

1454

1397

if SO_BINDTODEVICE is None:

1455

logger.error("SO_BINDTODEVICE does not exist;"

1456

" cannot bind to interface %s",

1398

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

1399

u" cannot bind to interface %s",

1457

1400

self.interface)

1458

1401

else:

1459

1402

try:

1460

1403

self.socket.setsockopt(socket.SOL_SOCKET,

1461

1404

SO_BINDTODEVICE,

1462

1405

str(self.interface

1463

+ '\0'))

1464

except socket.error as error:

1406

+ u'\0'))

1407

except socket.error, error:

1465

1408

if error[0] == errno.EPERM:

1466

logger.error("No permission to"

1467

" bind to interface %s",

1409

logger.error(u"No permission to"

1410

u" bind to interface %s",

1468

1411

self.interface)

1469

1412

elif error[0] == errno.ENOPROTOOPT:

1470

logger.error("SO_BINDTODEVICE not available;"

1471

" cannot bind to interface %s",

1413

logger.error(u"SO_BINDTODEVICE not available;"

1414

u" cannot bind to interface %s",

1472

1415

self.interface)

1473

1416

else:

1474

1417

raise

1476

1419

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

1477

1420

if not self.server_address[0]:

1478

1421

if self.address_family == socket.AF_INET6:

1479

any_address = "::" # in6addr_any

1422

any_address = u"::" # in6addr_any

1480

1423

else:

1481

1424

any_address = socket.INADDR_ANY

1482

1425

self.server_address = (any_address,

1531

1474

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

1532

1475

client_object=None):

1533

1476

condition_names = {

1534

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

1535

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

1477

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

1478

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

1536

1479

# blocking).

1537

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

1538

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

1539

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

1480

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

1481

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

1482

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

1540

1483

# broken, usually for pipes and

1541

1484

# sockets).

1542

1485

}

1544

1487

for cond, name in

1545

1488

condition_names.iteritems()

1546

1489

if cond & condition)

1490

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

1491

conditions_string)

1492

1547

1493

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

1548

1494

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

1549

1495

return False

1550

1496

1551

1497

# Read a request from the child

1552

1498

request = parent_pipe.recv()

1499

logger.debug(u"IPC request: %s", repr(request))

1553

1500

command = request[0]

1554

1501

1555

1502

if command == 'init':

1561

1508

client = c

1562

1509

break

1563

1510

else:

1564

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

1565

"dress: %s", fpr, address)

1511

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

1512

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

1566

1513

if self.use_dbus:

1567

1514

# Emit D-Bus signal

1568

mandos_dbus_service.ClientNotFound(fpr, address[0])

1515

mandos_dbus_service.ClientNotFound(fpr, address)

1569

1516

parent_pipe.send(False)

1570

1517

return False

1571

1518

1602

1549

def string_to_delta(interval):

1603

1550

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

1604

1551

1605

>>> string_to_delta('7d')

1552

>>> string_to_delta(u'7d')

1606

1553

datetime.timedelta(7)

1607

>>> string_to_delta('60s')

1554

>>> string_to_delta(u'60s')

1608

1555

datetime.timedelta(0, 60)

1609

>>> string_to_delta('60m')

1556

>>> string_to_delta(u'60m')

1610

1557

datetime.timedelta(0, 3600)

1611

>>> string_to_delta('24h')

1558

>>> string_to_delta(u'24h')

1612

1559

datetime.timedelta(1)

1613

>>> string_to_delta('1w')

1560

>>> string_to_delta(u'1w')

1614

1561

datetime.timedelta(7)

1615

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

1562

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

1616

1563

datetime.timedelta(0, 330)

1617

1564

"""

1618

1565

timevalue = datetime.timedelta(0)

1620

1567

try:

1621

1568

suffix = unicode(s[-1])

1622

1569

value = int(s[:-1])

1623

if suffix == "d":

1570

if suffix == u"d":

1624

1571

delta = datetime.timedelta(value)

1625

elif suffix == "s":

1572

elif suffix == u"s":

1626

1573

delta = datetime.timedelta(0, value)

1627

elif suffix == "m":

1574

elif suffix == u"m":

1628

1575

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

1629

elif suffix == "h":

1576

elif suffix == u"h":

1630

1577

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

1631

elif suffix == "w":

1578

elif suffix == u"w":

1632

1579

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

1633

1580

else:

1634

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

1635

except (ValueError, IndexError) as e:

1636

raise ValueError(*(e.args))

1581

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

1582

except (ValueError, IndexError), e:

1583

raise ValueError(e.message)

1637

1584

timevalue += delta

1638

1585

return timevalue

1639

1586

1645

1592

global if_nametoindex

1646

1593

try:

1647

1594

if_nametoindex = (ctypes.cdll.LoadLibrary

1648

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

1595

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

1649

1596

.if_nametoindex)

1650

1597

except (OSError, AttributeError):

1651

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

1598

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

1652

1599

def if_nametoindex(interface):

1653

1600

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

1654

1601

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

1655

1602

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

1656

1603

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1657

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

1604

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

1658

1605

interface))

1659

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

1606

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

1660

1607

ifreq[16:20])[0]

1661

1608

return interface_index

1662

1609

return if_nametoindex(interface)

1670

1617

sys.exit()

1671

1618

os.setsid()

1672

1619

if not nochdir:

1673

os.chdir("/")

1620

os.chdir(u"/")

1674

1621

if os.fork():

1675

1622

sys.exit()

1676

1623

if not noclose:

1678

1625

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

1679

1626

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

1680

1627

raise OSError(errno.ENODEV,

1681

"%s not a character device"

1628

u"%s not a character device"

1682

1629

% os.path.devnull)

1683

1630

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

1684

1631

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

1692

1639

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

1693

1640

# Parsing of options, both command line and config file

1694

1641

1695

parser = argparse.ArgumentParser()

1696

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

1697

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

1698

help="show version number and exit")

1699

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

1700

help="Bind to interface IF")

1701

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

1702

help="Address to listen for requests on")

1703

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

1704

help="Port number to receive requests on")

1705

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

1706

help="Run self-test")

1707

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

1708

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

1709

" to terminal")

1710

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

1711

help="Debug level for stdout output")

1712

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

1713

" priority string (see GnuTLS documentation)")

1714

parser.add_argument("--servicename",

1715

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

1716

parser.add_argument("--configdir",

1717

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

1718

help="Directory to search for configuration"

1719

" files")

1720

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

1721

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

1722

" system bus interface")

1723

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

1724

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

1725

options = parser.parse_args()

1642

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

1643

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

1644

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

1645

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

1646

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

1647

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

1648

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

1649

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

1650

help=u"Run self-test")

1651

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

1652

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

1653

u" terminal")

1654

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

1655

help=u"Debug level for stdout output")

1656

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

1657

u" priority string (see GnuTLS documentation)")

1658

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

1659

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

1660

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

1661

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

1662

help=u"Directory to search for configuration"

1663

u" files")

1664

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

1665

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

1666

u" system bus interface")

1667

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

1668

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

1669

options = parser.parse_args()[0]

1726

1670

1727

1671

if options.check:

1728

1672

import doctest

1730

1674

sys.exit()

1731

1675

1732

1676

# Default values for config file for server-global settings

1733

server_defaults = { "interface": "",

1734

"address": "",

1735

"port": "",

1736

"debug": "False",

1737

"priority":

1738

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

1739

"servicename": "Mandos",

1740

"use_dbus": "True",

1741

"use_ipv6": "True",

1742

"debuglevel": "",

1677

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

1678

u"address": u"",

1679

u"port": u"",

1680

u"debug": u"False",

1681

u"priority":

1682

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

1683

u"servicename": u"Mandos",

1684

u"use_dbus": u"True",

1685

u"use_ipv6": u"True",

1686

u"debuglevel": u"",

1743

1687

}

1744

1688

1745

1689

# Parse config file for server-global settings

1746

1690

server_config = configparser.SafeConfigParser(server_defaults)

1747

1691

del server_defaults

1748

1692

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

1749

"mandos.conf"))

1693

u"mandos.conf"))

1750

1694

# Convert the SafeConfigParser object to a dict

1751

1695

server_settings = server_config.defaults()

1752

1696

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

1753

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

1754

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

1697

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

1698

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

1755

1699

option)

1756

1700

if server_settings["port"]:

1757

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

1758

"port")

1701

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

1702

u"port")

1759

1703

del server_config

1760

1704

1761

1705

# Override the settings from the config file with command line

1762

1706

# options, if set.

1763

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

1764

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

1765

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

1707

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

1708

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

1709

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

1766

1710

value = getattr(options, option)

1767

1711

if value is not None:

1768

1712

server_settings[option] = value

1776

1720

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

1777

1721

1778

1722

# For convenience

1779

debug = server_settings["debug"]

1780

debuglevel = server_settings["debuglevel"]

1781

use_dbus = server_settings["use_dbus"]

1782

use_ipv6 = server_settings["use_ipv6"]

1723

debug = server_settings[u"debug"]

1724

debuglevel = server_settings[u"debuglevel"]

1725

use_dbus = server_settings[u"use_dbus"]

1726

use_ipv6 = server_settings[u"use_ipv6"]

1783

1727

1784

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

1728

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

1785

1729

syslogger.setFormatter(logging.Formatter

1786

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

1787

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

1788

% server_settings["servicename"]))

1730

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

1731

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

1732

% server_settings[u"servicename"]))

1789

1733

1790

1734

# Parse config file with clients

1791

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

1792

"interval": "5m",

1793

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

1794

"host": "",

1795

"approval_delay": "0s",

1796

"approval_duration": "1s",

1735

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

1736

u"interval": u"5m",

1737

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

1738

u"host": u"",

1739

u"approval_delay": u"0s",

1740

u"approval_duration": u"1s",

1797

1741

}

1798

1742

client_config = configparser.SafeConfigParser(client_defaults)

1799

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

1800

"clients.conf"))

1743

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

1744

u"clients.conf"))

1801

1745

1802

1746

global mandos_dbus_service

1803

1747

mandos_dbus_service = None

1804

1748

1805

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

1806

server_settings["port"]),

1749

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

1750

server_settings[u"port"]),

1807

1751

ClientHandler,

1808

interface=(server_settings["interface"]

1752

interface=(server_settings[u"interface"]

1809

1753

or None),

1810

1754

use_ipv6=use_ipv6,

1811

1755

gnutls_priority=

1812

server_settings["priority"],

1756

server_settings[u"priority"],

1813

1757

use_dbus=use_dbus)

1814

if not debug:

1815

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

1816

try:

1817

pidfile = open(pidfilename, "w")

1818

except IOError:

1819

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

1758

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

1759

try:

1760

pidfile = open(pidfilename, u"w")

1761

except IOError:

1762

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

1820

1763

1821

1764

try:

1822

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

1823

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

1765

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

1766

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

1824

1767

except KeyError:

1825

1768

try:

1826

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

1827

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

1769

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

1770

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

1828

1771

except KeyError:

1829

1772

try:

1830

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

1831

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

1773

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

1774

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

1832

1775

except KeyError:

1833

1776

uid = 65534

1834

1777

gid = 65534

1835

1778

try:

1836

1779

os.setgid(gid)

1837

1780

os.setuid(uid)

1838

except OSError as error:

1781

except OSError, error:

1839

1782

if error[0] != errno.EPERM:

1840

1783

raise error

1841

1784

1856

1799

1857

1800

@gnutls.library.types.gnutls_log_func

1858

1801

def debug_gnutls(level, string):

1859

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

1802

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

1860

1803

1861

1804

(gnutls.library.functions

1862

1805

.gnutls_global_set_log_function(debug_gnutls))

1870

1813

# No console logging

1871

1814

logger.removeHandler(console)

1872

1815

1873

# Need to fork before connecting to D-Bus

1874

if not debug:

1875

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

1876

daemon()

1877

1816

1878

1817

global main_loop

1879

1818

# From the Avahi example code

1883

1822

# End of Avahi example code

1884

1823

if use_dbus:

1885

1824

try:

1886

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

1825

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

1887

1826

bus, do_not_queue=True)

1888

except dbus.exceptions.NameExistsException as e:

1889

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

1827

except dbus.exceptions.NameExistsException, e:

1828

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

1890

1829

use_dbus = False

1891

server_settings["use_dbus"] = False

1830

server_settings[u"use_dbus"] = False

1892

1831

tcp_server.use_dbus = False

1893

1832

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1894

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

1895

servicetype = "_mandos._tcp",

1833

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

1834

servicetype = u"_mandos._tcp",

1896

1835

protocol = protocol, bus = bus)

1897

1836

if server_settings["interface"]:

1898

1837

service.interface = (if_nametoindex

1899

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

1900

1838

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

1839

1840

if not debug:

1841

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

1842

daemon()

1843

1901

1844

global multiprocessing_manager

1902

1845

multiprocessing_manager = multiprocessing.Manager()

1903

1846

1922

1865

client_config, section)))

1923

1866

for section in client_config.sections()))

1924

1867

if not tcp_server.clients:

1925

logger.warning("No clients defined")

1868

logger.warning(u"No clients defined")

1926

1869

1870

try:

1871

with pidfile:

1872

pid = os.getpid()

1873

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

1874

del pidfile

1875

except IOError:

1876

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

1877

pidfilename, pid)

1878

except NameError:

1879

# "pidfile" was never created

1880

pass

1881

del pidfilename

1882

1927

1883

if not debug:

1928

try:

1929

with pidfile:

1930

pid = os.getpid()

1931

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

1932

del pidfile

1933

except IOError:

1934

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

1935

pidfilename, pid)

1936

except NameError:

1937

# "pidfile" was never created

1938

pass

1939

del pidfilename

1940

1941

1884

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

1942

1943

1885

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

1944

1886

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

1945

1887

1947

1889

class MandosDBusService(dbus.service.Object):

1948

1890

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

1949

1891

def __init__(self):

1950

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

1951

_interface = "se.bsnet.fukt.Mandos"

1892

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

1893

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

1952

1894

1953

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

1895

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

1954

1896

def ClientAdded(self, objpath):

1955

1897

"D-Bus signal"

1956

1898

pass

1957

1899

1958

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

1900

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

1959

1901

def ClientNotFound(self, fingerprint, address):

1960

1902

"D-Bus signal"

1961

1903

pass

1962

1904

1963

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

1905

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

1964

1906

def ClientRemoved(self, objpath, name):

1965

1907

"D-Bus signal"

1966

1908

pass

1967

1909

1968

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

1910

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

1969

1911

def GetAllClients(self):

1970

1912

"D-Bus method"

1971

1913

return dbus.Array(c.dbus_object_path

1972

1914

for c in tcp_server.clients)

1973

1915

1974

1916

@dbus.service.method(_interface,

1975

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

1917

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

1976

1918

def GetAllClientsWithProperties(self):

1977

1919

"D-Bus method"

1978

1920

return dbus.Dictionary(

1979

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

1921

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

1980

1922

for c in tcp_server.clients),

1981

signature="oa{sv}")

1923

signature=u"oa{sv}")

1982

1924

1983

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

1925

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

1984

1926

def RemoveClient(self, object_path):

1985

1927

"D-Bus method"

1986

1928

for c in tcp_server.clients:

2028

1970

# Find out what port we got

2029

1971

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

2030

1972

if use_ipv6:

2031

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

1973

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

2032

1974

" flowinfo %d, scope_id %d"

2033

1975

% tcp_server.socket.getsockname())

2034

1976

else: # IPv4

2035

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

1977

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

2036

1978

% tcp_server.socket.getsockname())

2037

1979

2038

1980

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

2041

1983

# From the Avahi example code

2042

1984

try:

2043

1985

service.activate()

2044

except dbus.exceptions.DBusException as error:

2045

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

1986

except dbus.exceptions.DBusException, error:

1987

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

2046

1988

cleanup()

2047

1989

sys.exit(1)

2048

1990

# End of Avahi example code

2052

1994

(tcp_server.handle_request

2053

1995

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

2054

1996

2055

logger.debug("Starting main loop")

1997

logger.debug(u"Starting main loop")

2056

1998

main_loop.run()

2057

except AvahiError as error:

2058

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

1999

except AvahiError, error:

2000

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

2059

2001

cleanup()

2060

2002

sys.exit(1)

2061

2003

except KeyboardInterrupt:

2062

2004

if debug:

2063

print("", file=sys.stderr)

2064

logger.debug("Server received KeyboardInterrupt")

2065

logger.debug("Server exiting")

2005

print >> sys.stderr

2006

logger.debug(u"Server received KeyboardInterrupt")

2007

logger.debug(u"Server exiting")

2066

2008

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

2067

2009

cleanup()

2068

2010