/mandos/trunk : revision 435

11

# "AvahiService" class, and some lines in "main".

12

#

13

# Everything else is

14

15

14

15

16

#

17

# This program is free software: you can redistribute it and/or modify

18

# it under the terms of the GNU General Public License as published by

31

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

32

#

33

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

34

from __future__ import division, with_statement, absolute_import

36

35

37

36

import SocketServer as socketserver

38

37

import socket

39

import argparse

38

import optparse

40

39

import datetime

41

40

import errno

42

41

import gnutls.crypto

82

81

SO_BINDTODEVICE = None

83

82

84

83

85

version = "1.3.1"

84

version = "1.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

if self.entry_group_state_changed_match is not None:

180

self.entry_group_state_changed_match.remove()

181

self.entry_group_state_changed_match = None

182

177

if self.group is not None:

183

178

self.group.Reset()

184

179

def add(self):

185

180

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

186

self.remove()

187

181

if self.group is None:

188

182

self.group = dbus.Interface(

189

183

self.bus.get_object(avahi.DBUS_NAME,

190

184

self.server.EntryGroupNew()),

191

185

avahi.DBUS_INTERFACE_ENTRY_GROUP)

192

self.entry_group_state_changed_match = (

193

self.group.connect_to_signal(

194

'StateChanged', self .entry_group_state_changed))

195

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

186

self.group.connect_to_signal('StateChanged',

187

self

188

.entry_group_state_changed)

189

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

196

190

self.name, self.type)

197

191

self.group.AddService(

198

192

self.interface,

205

199

self.group.Commit()

206

200

def entry_group_state_changed(self, state, error):

207

201

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

208

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

202

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

209

203

210

204

if state == avahi.ENTRY_GROUP_ESTABLISHED:

211

logger.debug("Zeroconf service established.")

205

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

212

206

elif state == avahi.ENTRY_GROUP_COLLISION:

213

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

207

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

214

208

self.rename()

215

209

elif state == avahi.ENTRY_GROUP_FAILURE:

216

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

210

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

217

211

unicode(error))

218

raise AvahiGroupError("State changed: %s"

212

raise AvahiGroupError(u"State changed: %s"

219

213

% unicode(error))

220

214

def cleanup(self):

221

215

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

222

216

if self.group is not None:

223

try:

224

self.group.Free()

225

except (dbus.exceptions.UnknownMethodException,

226

dbus.exceptions.DBusException) as e:

227

pass

217

self.group.Free()

228

218

self.group = None

229

self.remove()

230

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

219

def server_state_changed(self, state):

231

220

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

232

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

233

bad_states = { avahi.SERVER_INVALID:

234

"Zeroconf server invalid",

235

avahi.SERVER_REGISTERING: None,

236

avahi.SERVER_COLLISION:

237

"Zeroconf server name collision",

238

avahi.SERVER_FAILURE:

239

"Zeroconf server failure" }

240

if state in bad_states:

241

if bad_states[state] is not None:

242

if error is None:

243

logger.error(bad_states[state])

244

else:

245

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

246

self.cleanup()

221

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

222

if state == avahi.SERVER_COLLISION:

223

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

224

self.remove()

247

225

elif state == avahi.SERVER_RUNNING:

248

226

self.add()

249

else:

250

if error is None:

251

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

252

else:

253

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

254

227

def activate(self):

255

228

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

256

229

if self.server is None:

257

230

self.server = dbus.Interface(

258

231

self.bus.get_object(avahi.DBUS_NAME,

259

avahi.DBUS_PATH_SERVER,

260

follow_name_owner_changes=True),

232

avahi.DBUS_PATH_SERVER),

261

233

avahi.DBUS_INTERFACE_SERVER)

262

self.server.connect_to_signal("StateChanged",

234

self.server.connect_to_signal(u"StateChanged",

263

235

self.server_state_changed)

264

236

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

265

237

268

240

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

269

241

270

242

Attributes:

271

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

272

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

273

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)

274

257

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

275

258

to see if the client lives.

276

259

'None' if no process is running.

277

checker_callback_tag: a gobject event source tag, or None

278

checker_command: string; External command which is run to check

279

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

280

265

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

281

266

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

282

checker_initiator_tag: a gobject event source tag, or None

283

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

284

267

current_checker_command: string; current running checker_command

285

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

286

disable_initiator_tag: a gobject event source tag, or None

287

enabled: bool()

288

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

289

uniquely identify the client

290

host: string; available for use by the checker command

291

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

292

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

293

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

294

last_enabled: datetime.datetime(); (UTC)

295

296

D-Bus identifiers

297

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

298

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

299

until this client is disabled

300

extended_timeout: extra long timeout when password has been sent

301

runtime_expansions: Allowed attributes for runtime expansion.

302

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

303

disabled, or None

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

304

271

"""

305

272

306

runtime_expansions = ("approval_delay", "approval_duration",

307

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

308

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

309

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

310

311

273

@staticmethod

312

274

def _timedelta_to_milliseconds(td):

313

275

"Convert a datetime.timedelta() to milliseconds"

318

280

def timeout_milliseconds(self):

319

281

"Return the 'timeout' attribute in milliseconds"

320

282

return self._timedelta_to_milliseconds(self.timeout)

321

322

def extended_timeout_milliseconds(self):

323

"Return the 'extended_timeout' attribute in milliseconds"

324

return self._timedelta_to_milliseconds(self.extended_timeout)

325

283

326

284

def interval_milliseconds(self):

327

285

"Return the 'interval' attribute in milliseconds"

337

295

self.name = name

338

296

if config is None:

339

297

config = {}

340

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

298

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

341

299

# Uppercase and remove spaces from fingerprint for later

342

300

# comparison purposes with return value from the fingerprint()

343

301

# function

344

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

345

.replace(" ", ""))

346

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

347

if "secret" in config:

348

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

349

elif "secfile" in config:

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:

350

308

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

351

(config["secfile"])),

309

(config[u"secfile"])),

352

310

"rb") as secfile:

353

311

self.secret = secfile.read()

354

312

else:

355

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

313

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

356

314

% self.name)

357

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

315

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

358

316

self.created = datetime.datetime.utcnow()

359

317

self.enabled = False

360

self.last_approval_request = None

361

318

self.last_enabled = None

362

319

self.last_checked_ok = None

363

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

364

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

365

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

320

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

321

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

366

322

self.disable_hook = disable_hook

367

323

self.checker = None

368

324

self.checker_initiator_tag = None

369

325

self.disable_initiator_tag = None

370

self.expires = None

371

326

self.checker_callback_tag = None

372

self.checker_command = config["checker"]

327

self.checker_command = config[u"checker"]

373

328

self.current_checker_command = None

374

329

self.last_connect = None

375

330

self._approved = None

376

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

331

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

377

332

True)

378

333

self.approvals_pending = 0

379

334

self.approval_delay = string_to_delta(

380

config["approval_delay"])

335

config[u"approval_delay"])

381

336

self.approval_duration = string_to_delta(

382

config["approval_duration"])

337

config[u"approval_duration"])

383

338

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

384

339

385

340

def send_changedstate(self):

389

344

390

345

def enable(self):

391

346

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

392

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

347

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

393

348

# Already enabled

394

349

return

395

350

self.send_changedstate()

400

355

(self.interval_milliseconds(),

401

356

self.start_checker))

402

357

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

403

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

404

358

self.disable_initiator_tag = (gobject.timeout_add

405

359

(self.timeout_milliseconds(),

406

360

self.disable))

415

369

if not quiet:

416

370

self.send_changedstate()

417

371

if not quiet:

418

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

419

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

420

374

gobject.source_remove(self.disable_initiator_tag)

421

375

self.disable_initiator_tag = None

422

self.expires = None

423

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

376

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

424

377

gobject.source_remove(self.checker_initiator_tag)

425

378

self.checker_initiator_tag = None

426

379

self.stop_checker()

441

394

if os.WIFEXITED(condition):

442

395

exitstatus = os.WEXITSTATUS(condition)

443

396

if exitstatus == 0:

444

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

397

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

445

398

vars(self))

446

399

self.checked_ok()

447

400

else:

448

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

401

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

449

402

vars(self))

450

403

else:

451

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

404

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

452

405

vars(self))

453

406

454

def checked_ok(self, timeout=None):

407

def checked_ok(self):

455

408

"""Bump up the timeout for this client.

456

409

457

410

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

458

411

alive and well.

459

412

"""

460

if timeout is None:

461

timeout = self.timeout

462

413

self.last_checked_ok = datetime.datetime.utcnow()

463

414

gobject.source_remove(self.disable_initiator_tag)

464

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

465

415

self.disable_initiator_tag = (gobject.timeout_add

466

(self._timedelta_to_milliseconds(timeout),

416

(self.timeout_milliseconds(),

467

417

self.disable))

468

418

469

def need_approval(self):

470

self.last_approval_request = datetime.datetime.utcnow()

471

472

419

def start_checker(self):

473

420

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

474

421

486

433

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

487

434

try:

488

435

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

489

except (AttributeError, OSError) as error:

436

except (AttributeError, OSError), error:

490

437

if (isinstance(error, OSError)

491

438

and error.errno != errno.ECHILD):

492

439

raise error

493

440

else:

494

441

if pid:

495

logger.warning("Checker was a zombie")

442

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

496

443

gobject.source_remove(self.checker_callback_tag)

497

444

self.checker_callback(pid, status,

498

445

self.current_checker_command)

503

450

command = self.checker_command % self.host

504

451

except TypeError:

505

452

# Escape attributes for the shell

506

escaped_attrs = dict(

507

(attr,

508

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

509

errors=

510

'replace')))

511

for attr in

512

self.runtime_expansions)

513

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

514

459

try:

515

460

command = self.checker_command % escaped_attrs

516

except TypeError as error:

517

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

518

' %s', self.checker_command, error)

461

except TypeError, error:

462

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

463

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

519

464

return True # Try again later

520

465

self.current_checker_command = command

521

466

try:

522

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

467

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

523

468

command, self.name)

524

469

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

525

470

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

527

472

# always replaced by /dev/null.)

528

473

self.checker = subprocess.Popen(command,

529

474

close_fds=True,

530

shell=True, cwd="/")

475

shell=True, cwd=u"/")

531

476

self.checker_callback_tag = (gobject.child_watch_add

532

477

(self.checker.pid,

533

478

self.checker_callback,

538

483

if pid:

539

484

gobject.source_remove(self.checker_callback_tag)

540

485

self.checker_callback(pid, status, command)

541

except OSError as error:

542

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

486

except OSError, error:

487

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

543

488

error)

544

489

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

545

490

return True

549

494

if self.checker_callback_tag:

550

495

gobject.source_remove(self.checker_callback_tag)

551

496

self.checker_callback_tag = None

552

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

497

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

553

498

return

554

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

499

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

555

500

try:

556

501

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

557

502

#time.sleep(0.5)

558

503

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

559

504

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

560

except OSError as error:

505

except OSError, error:

561

506

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

562

507

raise

563

508

self.checker = None

564

509

565

def dbus_service_property(dbus_interface, signature="v",

566

access="readwrite", byte_arrays=False):

510

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

511

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

567

512

"""Decorators for marking methods of a DBusObjectWithProperties to

568

513

become properties on the D-Bus.

569

514

576

521

"""

577

522

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

578

523

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

579

if byte_arrays and signature != "ay":

580

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

581

" signature %r" % signature)

524

if byte_arrays and signature != u"ay":

525

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

526

u" signature %r" % signature)

582

527

def decorator(func):

583

528

func._dbus_is_property = True

584

529

func._dbus_interface = dbus_interface

585

530

func._dbus_signature = signature

586

531

func._dbus_access = access

587

532

func._dbus_name = func.__name__

588

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

533

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

589

534

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

590

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

535

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

591

536

return func

592

537

return decorator

593

538

621

566

622

567

@staticmethod

623

568

def _is_dbus_property(obj):

624

return getattr(obj, "_dbus_is_property", False)

569

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

625

570

626

571

def _get_all_dbus_properties(self):

627

572

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

635

580

property with the specified name and interface.

636

581

"""

637

582

for name in (property_name,

638

property_name + "_dbus_property"):

583

property_name + u"_dbus_property"):

639

584

prop = getattr(self, name, None)

640

585

if (prop is None

641

586

or not self._is_dbus_property(prop)

645

590

continue

646

591

return prop

647

592

# No such property

648

raise DBusPropertyNotFound(self.dbus_object_path + ":"

649

+ interface_name + "."

593

raise DBusPropertyNotFound(self.dbus_object_path + u":"

594

+ interface_name + u"."

650

595

+ property_name)

651

596

652

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

653

out_signature="v")

597

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

598

out_signature=u"v")

654

599

def Get(self, interface_name, property_name):

655

600

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

656

601

"""

657

602

prop = self._get_dbus_property(interface_name, property_name)

658

if prop._dbus_access == "write":

603

if prop._dbus_access == u"write":

659

604

raise DBusPropertyAccessException(property_name)

660

605

value = prop()

661

if not hasattr(value, "variant_level"):

606

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

662

607

return value

663

608

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

664

609

665

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

610

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

666

611

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

667

612

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

668

613

"""

669

614

prop = self._get_dbus_property(interface_name, property_name)

670

if prop._dbus_access == "read":

615

if prop._dbus_access == u"read":

671

616

raise DBusPropertyAccessException(property_name)

672

if prop._dbus_get_args_options["byte_arrays"]:

617

if prop._dbus_get_args_options[u"byte_arrays"]:

673

618

# The byte_arrays option is not supported yet on

674

619

# signatures other than "ay".

675

if prop._dbus_signature != "ay":

620

if prop._dbus_signature != u"ay":

676

621

raise ValueError

677

622

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

678

623

for byte in value))

679

624

prop(value)

680

625

681

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

682

out_signature="a{sv}")

626

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

627

out_signature=u"a{sv}")

683

628

def GetAll(self, interface_name):

684

629

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

685

630

standard.

693

638

# Interface non-empty but did not match

694

639

continue

695

640

# Ignore write-only properties

696

if prop._dbus_access == "write":

641

if prop._dbus_access == u"write":

697

642

continue

698

643

value = prop()

699

if not hasattr(value, "variant_level"):

644

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

700

645

all[name] = value

701

646

continue

702

647

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

703

648

value.variant_level+1)

704

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

649

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

705

650

706

651

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

707

out_signature="s",

652

out_signature=u"s",

708

653

path_keyword='object_path',

709

654

connection_keyword='connection')

710

655

def Introspect(self, object_path, connection):

715

660

try:

716

661

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

717

662

def make_tag(document, name, prop):

718

e = document.createElement("property")

719

e.setAttribute("name", name)

720

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

721

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

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)

722

667

return e

723

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

668

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

724

669

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

725

670

for name, prop

726

671

in self._get_all_dbus_properties()

727

672

if prop._dbus_interface

728

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

673

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

729

674

if_tag.appendChild(tag)

730

675

# Add the names to the return values for the

731

676

# "org.freedesktop.DBus.Properties" methods

732

if (if_tag.getAttribute("name")

733

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

734

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

735

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

736

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

737

if (arg.getAttribute("direction")

738

== "out"):

739

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

740

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

741

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

742

if (arg.getAttribute("direction")

743

== "out"):

744

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

745

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

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

746

691

document.unlink()

747

692

except (AttributeError, xml.dom.DOMException,

748

xml.parsers.expat.ExpatError) as error:

749

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

693

xml.parsers.expat.ExpatError), error:

694

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

750

695

error)

751

696

return xmlstring

752

697

758

703

dbus_object_path: dbus.ObjectPath

759

704

bus: dbus.SystemBus()

760

705

"""

761

762

runtime_expansions = (Client.runtime_expansions

763

+ ("dbus_object_path",))

764

765

706

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

766

707

767

708

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

770

711

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

771

712

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

772

713

# the D-Bus

773

client_object_name = unicode(self.name).translate(

774

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

775

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

776

714

self.dbus_object_path = (dbus.ObjectPath

777

("/clients/" + client_object_name))

715

(u"/clients/"

716

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

778

717

DBusObjectWithProperties.__init__(self, self.bus,

779

718

self.dbus_object_path)

780

def _set_expires(self, value):

781

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

782

self._expires = value

783

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

784

dbus_time = (self._datetime_to_dbus(self._expires,

785

variant_level=1))

786

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

787

dbus_time)

788

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

789

del _set_expires

790

719

791

720

def _get_approvals_pending(self):

792

721

return self._approvals_pending

797

726

if (hasattr(self, "dbus_object_path")

798

727

and bval is not bool(old_value)):

799

728

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

800

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

729

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

801

730

dbus_bool)

802

731

803

732

approvals_pending = property(_get_approvals_pending,

807

736

@staticmethod

808

737

def _datetime_to_dbus(dt, variant_level=0):

809

738

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

810

if dt is None:

811

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

812

739

return dbus.String(dt.isoformat(),

813

740

variant_level=variant_level)

814

741

815

742

def enable(self):

816

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

743

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

817

744

r = Client.enable(self)

818

745

if oldstate != self.enabled:

819

746

# Emit D-Bus signals

820

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

747

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

821

748

dbus.Boolean(True, variant_level=1))

822

749

self.PropertyChanged(

823

dbus.String("LastEnabled"),

750

dbus.String(u"LastEnabled"),

824

751

self._datetime_to_dbus(self.last_enabled,

825

752

variant_level=1))

826

753

return r

827

754

828

755

def disable(self, quiet = False):

829

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

756

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

830

757

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

831

758

if not quiet and oldstate != self.enabled:

832

759

# Emit D-Bus signal

833

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

760

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

834

761

dbus.Boolean(False, variant_level=1))

835

762

return r

836

763

839

766

self.remove_from_connection()

840

767

except LookupError:

841

768

pass

842

if hasattr(DBusObjectWithProperties, "__del__"):

769

if hasattr(DBusObjectWithProperties, u"__del__"):

843

770

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

844

771

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

845

772

848

775

self.checker_callback_tag = None

849

776

self.checker = None

850

777

# Emit D-Bus signal

851

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

778

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

852

779

dbus.Boolean(False, variant_level=1))

853

780

if os.WIFEXITED(condition):

854

781

exitstatus = os.WEXITSTATUS(condition)

866

793

*args, **kwargs)

867

794

868

795

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

869

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

796

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

870

797

# Emit D-Bus signal

871

798

self.PropertyChanged(

872

dbus.String("LastCheckedOK"),

799

dbus.String(u"LastCheckedOK"),

873

800

(self._datetime_to_dbus(self.last_checked_ok,

874

801

variant_level=1)))

875

876

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

877

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

878

# Emit D-Bus signal

879

self.PropertyChanged(

880

dbus.String("LastApprovalRequest"),

881

(self._datetime_to_dbus(self.last_approval_request,

882

variant_level=1)))

883

802

return r

884

803

885

804

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

895

814

# Emit D-Bus signal

896

815

self.CheckerStarted(self.current_checker_command)

897

816

self.PropertyChanged(

898

dbus.String("CheckerRunning"),

817

dbus.String(u"CheckerRunning"),

899

818

dbus.Boolean(True, variant_level=1))

900

819

return r

901

820

902

821

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

903

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

822

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

904

823

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

905

824

if (old_checker is not None

906

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

907

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

825

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

826

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

908

827

dbus.Boolean(False, variant_level=1))

909

828

return r

910

829

921

840

922

841

923

842

## D-Bus methods, signals & properties

924

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

843

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

925

844

926

845

## Signals

927

846

928

847

# CheckerCompleted - signal

929

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

848

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

930

849

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

931

850

"D-Bus signal"

932

851

pass

933

852

934

853

# CheckerStarted - signal

935

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

854

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

936

855

def CheckerStarted(self, command):

937

856

"D-Bus signal"

938

857

pass

939

858

940

859

# PropertyChanged - signal

941

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

860

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

942

861

def PropertyChanged(self, property, value):

943

862

"D-Bus signal"

944

863

pass

953

872

pass

954

873

955

874

# Rejected - signal

956

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

875

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

957

876

def Rejected(self, reason):

958

877

"D-Bus signal"

959

878

pass

960

879

961

880

# NeedApproval - signal

962

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

881

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

963

882

def NeedApproval(self, timeout, default):

964

883

"D-Bus signal"

965

return self.need_approval()

884

pass

966

885

967

886

## Methods

968

887

969

888

# Approve - method

970

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

889

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

971

890

def Approve(self, value):

972

891

self.approve(value)

973

892

974

893

# CheckedOK - method

975

894

@dbus.service.method(_interface)

976

895

def CheckedOK(self):

977

self.checked_ok()

896

return self.checked_ok()

978

897

979

898

# Enable - method

980

899

@dbus.service.method(_interface)

1002

921

## Properties

1003

922

1004

923

# ApprovalPending - property

1005

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

924

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

1006

925

def ApprovalPending_dbus_property(self):

1007

926

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

1008

927

1009

928

# ApprovedByDefault - property

1010

@dbus_service_property(_interface, signature="b",

1011

access="readwrite")

929

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

930

access=u"readwrite")

1012

931

def ApprovedByDefault_dbus_property(self, value=None):

1013

932

if value is None: # get

1014

933

return dbus.Boolean(self.approved_by_default)

1015

old_value = self.approved_by_default

1016

934

self.approved_by_default = bool(value)

1017

935

# Emit D-Bus signal

1018

if old_value != self.approved_by_default:

1019

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

1020

dbus.Boolean(value, variant_level=1))

936

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

937

dbus.Boolean(value, variant_level=1))

1021

938

1022

939

# ApprovalDelay - property

1023

@dbus_service_property(_interface, signature="t",

1024

access="readwrite")

940

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

941

access=u"readwrite")

1025

942

def ApprovalDelay_dbus_property(self, value=None):

1026

943

if value is None: # get

1027

944

return dbus.UInt64(self.approval_delay_milliseconds())

1028

old_value = self.approval_delay

1029

945

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

1030

946

# Emit D-Bus signal

1031

if old_value != self.approval_delay:

1032

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

1033

dbus.UInt64(value, variant_level=1))

947

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

948

dbus.UInt64(value, variant_level=1))

1034

949

1035

950

# ApprovalDuration - property

1036

@dbus_service_property(_interface, signature="t",

1037

access="readwrite")

951

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

952

access=u"readwrite")

1038

953

def ApprovalDuration_dbus_property(self, value=None):

1039

954

if value is None: # get

1040

955

return dbus.UInt64(self._timedelta_to_milliseconds(

1041

956

self.approval_duration))

1042

old_value = self.approval_duration

1043

957

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

1044

958

# Emit D-Bus signal

1045

if old_value != self.approval_duration:

1046

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

1047

dbus.UInt64(value, variant_level=1))

959

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

960

dbus.UInt64(value, variant_level=1))

1048

961

1049

962

# Name - property

1050

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

963

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

1051

964

def Name_dbus_property(self):

1052

965

return dbus.String(self.name)

1053

966

1054

967

# Fingerprint - property

1055

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

968

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

1056

969

def Fingerprint_dbus_property(self):

1057

970

return dbus.String(self.fingerprint)

1058

971

1059

972

# Host - property

1060

@dbus_service_property(_interface, signature="s",

1061

access="readwrite")

973

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

974

access=u"readwrite")

1062

975

def Host_dbus_property(self, value=None):

1063

976

if value is None: # get

1064

977

return dbus.String(self.host)

1065

old_value = self.host

1066

978

self.host = value

1067

979

# Emit D-Bus signal

1068

if old_value != self.host:

1069

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

1070

dbus.String(value, variant_level=1))

980

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

981

dbus.String(value, variant_level=1))

1071

982

1072

983

# Created - property

1073

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

984

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

1074

985

def Created_dbus_property(self):

1075

986

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

1076

987

1077

988

# LastEnabled - property

1078

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

989

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

1079

990

def LastEnabled_dbus_property(self):

1080

return self._datetime_to_dbus(self.last_enabled)

991

if self.last_enabled is None:

992

return dbus.String(u"")

993

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

1081

994

1082

995

# Enabled - property

1083

@dbus_service_property(_interface, signature="b",

1084

access="readwrite")

996

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

997

access=u"readwrite")

1085

998

def Enabled_dbus_property(self, value=None):

1086

999

if value is None: # get

1087

1000

return dbus.Boolean(self.enabled)

1091

1004

self.disable()

1092

1005

1093

1006

# LastCheckedOK - property

1094

@dbus_service_property(_interface, signature="s",

1095

access="readwrite")

1007

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

1008

access=u"readwrite")

1096

1009

def LastCheckedOK_dbus_property(self, value=None):

1097

1010

if value is not None:

1098

1011

self.checked_ok()

1099

1012

return

1100

return self._datetime_to_dbus(self.last_checked_ok)

1101

1102

# Expires - property

1103

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

1104

def Expires_dbus_property(self):

1105

return self._datetime_to_dbus(self.expires)

1106

1107

# LastApprovalRequest - property

1108

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

1109

def LastApprovalRequest_dbus_property(self):

1110

return self._datetime_to_dbus(self.last_approval_request)

1013

if self.last_checked_ok is None:

1014

return dbus.String(u"")

1015

return dbus.String(self._datetime_to_dbus(self

1016

.last_checked_ok))

1111

1017

1112

1018

# Timeout - property

1113

@dbus_service_property(_interface, signature="t",

1114

access="readwrite")

1019

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

1020

access=u"readwrite")

1115

1021

def Timeout_dbus_property(self, value=None):

1116

1022

if value is None: # get

1117

1023

return dbus.UInt64(self.timeout_milliseconds())

1118

old_value = self.timeout

1119

1024

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

1120

1025

# Emit D-Bus signal

1121

if old_value != self.timeout:

1122

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

1123

dbus.UInt64(value, variant_level=1))

1124

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

1026

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

1027

dbus.UInt64(value, variant_level=1))

1028

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

1125

1029

return

1126

1030

# Reschedule timeout

1127

1031

gobject.source_remove(self.disable_initiator_tag)

1128

1032

self.disable_initiator_tag = None

1129

self.expires = None

1130

1033

time_to_die = (self.

1131

1034

_timedelta_to_milliseconds((self

1132

1035

.last_checked_ok

1137

1040

# The timeout has passed

1138

1041

self.disable()

1139

1042

else:

1140

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

1141

+ datetime.timedelta(milliseconds = time_to_die))

1142

1043

self.disable_initiator_tag = (gobject.timeout_add

1143

1044

(time_to_die, self.disable))

1144

1145

# ExtendedTimeout - property

1146

@dbus_service_property(_interface, signature="t",

1147

access="readwrite")

1148

def ExtendedTimeout_dbus_property(self, value=None):

1149

if value is None: # get

1150

return dbus.UInt64(self.extended_timeout_milliseconds())

1151

old_value = self.extended_timeout

1152

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

1153

# Emit D-Bus signal

1154

if old_value != self.extended_timeout:

1155

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

1156

dbus.UInt64(value, variant_level=1))

1157

1045

1158

1046

# Interval - property

1159

@dbus_service_property(_interface, signature="t",

1160

access="readwrite")

1047

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

1048

access=u"readwrite")

1161

1049

def Interval_dbus_property(self, value=None):

1162

1050

if value is None: # get

1163

1051

return dbus.UInt64(self.interval_milliseconds())

1164

old_value = self.interval

1165

1052

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

1166

1053

# Emit D-Bus signal

1167

if old_value != self.interval:

1168

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

1169

dbus.UInt64(value, variant_level=1))

1170

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

1054

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

1055

dbus.UInt64(value, variant_level=1))

1056

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

1171

1057

return

1172

1058

# Reschedule checker run

1173

1059

gobject.source_remove(self.checker_initiator_tag)

1176

1062

self.start_checker() # Start one now, too

1177

1063

1178

1064

# Checker - property

1179

@dbus_service_property(_interface, signature="s",

1180

access="readwrite")

1065

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

1066

access=u"readwrite")

1181

1067

def Checker_dbus_property(self, value=None):

1182

1068

if value is None: # get

1183

1069

return dbus.String(self.checker_command)

1184

old_value = self.checker_command

1185

1070

self.checker_command = value

1186

1071

# Emit D-Bus signal

1187

if old_value != self.checker_command:

1188

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

1189

dbus.String(self.checker_command,

1190

variant_level=1))

1072

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

1073

dbus.String(self.checker_command,

1074

variant_level=1))

1191

1075

1192

1076

# CheckerRunning - property

1193

@dbus_service_property(_interface, signature="b",

1194

access="readwrite")

1077

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

1078

access=u"readwrite")

1195

1079

def CheckerRunning_dbus_property(self, value=None):

1196

1080

if value is None: # get

1197

1081

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

1201

1085

self.stop_checker()

1202

1086

1203

1087

# ObjectPath - property

1204

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

1088

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

1205

1089

def ObjectPath_dbus_property(self):

1206

1090

return self.dbus_object_path # is already a dbus.ObjectPath

1207

1091

1208

1092

# Secret = property

1209

@dbus_service_property(_interface, signature="ay",

1210

access="write", byte_arrays=True)

1093

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

1094

access=u"write", byte_arrays=True)

1211

1095

def Secret_dbus_property(self, value):

1212

1096

self.secret = str(value)

1213

1097

1248

1132

1249

1133

def handle(self):

1250

1134

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

1251

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

1135

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

1252

1136

unicode(self.client_address))

1253

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

1137

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

1254

1138

self.server.child_pipe.fileno())

1255

1139

1256

1140

session = (gnutls.connection

1263

1147

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

1264

1148

# here despite using OpenPGP certificates.

1265

1149

1266

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

1267

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

1268

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

1269

# "+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"))

1270

1154

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

1271

1155

priority = self.server.gnutls_priority

1272

1156

if priority is None:

1273

priority = "NORMAL"

1157

priority = u"NORMAL"

1274

1158

(gnutls.library.functions

1275

1159

.gnutls_priority_set_direct(session._c_object,

1276

1160

priority, None))

1278

1162

# Start communication using the Mandos protocol

1279

1163

# Get protocol number

1280

1164

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

1281

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

1165

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

1282

1166

try:

1283

1167

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

1284

1168

raise RuntimeError

1285

except (ValueError, IndexError, RuntimeError) as error:

1286

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

1169

except (ValueError, IndexError, RuntimeError), error:

1170

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

1287

1171

return

1288

1172

1289

1173

# Start GnuTLS connection

1290

1174

try:

1291

1175

session.handshake()

1292

except gnutls.errors.GNUTLSError as error:

1293

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

1176

except gnutls.errors.GNUTLSError, error:

1177

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

1294

1178

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

1295

1179

# established. Just abandon the request.

1296

1180

return

1297

logger.debug("Handshake succeeded")

1181

logger.debug(u"Handshake succeeded")

1298

1182

1299

1183

approval_required = False

1300

1184

try:

1301

1185

try:

1302

1186

fpr = self.fingerprint(self.peer_certificate

1303

1187

(session))

1304

except (TypeError,

1305

gnutls.errors.GNUTLSError) as error:

1306

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

1188

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

1189

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

1307

1190

return

1308

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

1191

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

1309

1192

1310

1193

try:

1311

1194

client = ProxyClient(child_pipe, fpr,

1320

1203

1321

1204

while True:

1322

1205

if not client.enabled:

1323

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

1206

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

1324

1207

client.name)

1325

1208

if self.server.use_dbus:

1326

1209

# Emit D-Bus signal

1331

1214

#We are approved or approval is disabled

1332

1215

break

1333

1216

elif client._approved is None:

1334

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

1217

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

1335

1218

client.name)

1336

1219

if self.server.use_dbus:

1337

1220

# Emit D-Bus signal

1339

1222

client.approval_delay_milliseconds(),

1340

1223

client.approved_by_default)

1341

1224

else:

1342

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

1225

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

1343

1226

client.name)

1344

1227

if self.server.use_dbus:

1345

1228

# Emit D-Bus signal

1371

1254

while sent_size < len(client.secret):

1372

1255

try:

1373

1256

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

1374

except gnutls.errors.GNUTLSError as error:

1257

except (gnutls.errors.GNUTLSError), error:

1375

1258

logger.warning("gnutls send failed")

1376

1259

return

1377

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

1260

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

1378

1261

sent, len(client.secret)

1379

1262

- (sent_size + sent))

1380

1263

sent_size += sent

1381

1264

1382

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

1265

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

1383

1266

# bump the timeout as if seen

1384

client.checked_ok(client.extended_timeout)

1267

client.checked_ok()

1385

1268

if self.server.use_dbus:

1386

1269

# Emit D-Bus signal

1387

1270

client.GotSecret()

1391

1274

client.approvals_pending -= 1

1392

1275

try:

1393

1276

session.bye()

1394

except gnutls.errors.GNUTLSError as error:

1277

except (gnutls.errors.GNUTLSError), error:

1395

1278

logger.warning("GnuTLS bye failed")

1396

1279

1397

1280

@staticmethod

1408

1291

.gnutls_certificate_get_peers

1409

1292

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

1410

1293

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

1411

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

1412

" certificate")

1294

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

1295

u" certificate")

1413

1296

if list_size.value == 0:

1414

1297

return None

1415

1298

cert = cert_list[0]

1441

1324

if crtverify.value != 0:

1442

1325

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1443

1326

raise (gnutls.errors.CertificateSecurityError

1444

("Verify failed"))

1327

(u"Verify failed"))

1445

1328

# New buffer for the fingerprint

1446

1329

buf = ctypes.create_string_buffer(20)

1447

1330

buf_len = ctypes.c_size_t()

1454

1337

# Convert the buffer to a Python bytestring

1455

1338

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

1456

1339

# Convert the bytestring to hexadecimal notation

1457

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

1340

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

1458

1341

return hex_fpr

1459

1342

1460

1343

1488

1371

1489

1372

def add_pipe(self, parent_pipe):

1490

1373

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

1491

raise NotImplementedError

1374

pass

1492

1375

1493

1376

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1494

1377

socketserver.TCPServer, object):

1512

1395

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

1513

1396

if self.interface is not None:

1514

1397

if SO_BINDTODEVICE is None:

1515

logger.error("SO_BINDTODEVICE does not exist;"

1516

" cannot bind to interface %s",

1398

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

1399

u" cannot bind to interface %s",

1517

1400

self.interface)

1518

1401

else:

1519

1402

try:

1520

1403

self.socket.setsockopt(socket.SOL_SOCKET,

1521

1404

SO_BINDTODEVICE,

1522

1405

str(self.interface

1523

+ '\0'))

1524

except socket.error as error:

1406

+ u'\0'))

1407

except socket.error, error:

1525

1408

if error[0] == errno.EPERM:

1526

logger.error("No permission to"

1527

" bind to interface %s",

1409

logger.error(u"No permission to"

1410

u" bind to interface %s",

1528

1411

self.interface)

1529

1412

elif error[0] == errno.ENOPROTOOPT:

1530

logger.error("SO_BINDTODEVICE not available;"

1531

" cannot bind to interface %s",

1413

logger.error(u"SO_BINDTODEVICE not available;"

1414

u" cannot bind to interface %s",

1532

1415

self.interface)

1533

1416

else:

1534

1417

raise

1536

1419

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

1537

1420

if not self.server_address[0]:

1538

1421

if self.address_family == socket.AF_INET6:

1539

any_address = "::" # in6addr_any

1422

any_address = u"::" # in6addr_any

1540

1423

else:

1541

1424

any_address = socket.INADDR_ANY

1542

1425

self.server_address = (any_address,

1591

1474

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

1592

1475

client_object=None):

1593

1476

condition_names = {

1594

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

1595

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

1596

1479

# blocking).

1597

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

1598

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

1599

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

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

1600

1483

# broken, usually for pipes and

1601

1484

# sockets).

1602

1485

}

1621

1504

client = c

1622

1505

break

1623

1506

else:

1624

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

1625

"dress: %s", fpr, address)

1507

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

1508

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

1626

1509

if self.use_dbus:

1627

1510

# Emit D-Bus signal

1628

mandos_dbus_service.ClientNotFound(fpr, address[0])

1511

mandos_dbus_service.ClientNotFound(fpr, address)

1629

1512

parent_pipe.send(False)

1630

1513

return False

1631

1514

1662

1545

def string_to_delta(interval):

1663

1546

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

1664

1547

1665

>>> string_to_delta('7d')

1548

>>> string_to_delta(u'7d')

1666

1549

datetime.timedelta(7)

1667

>>> string_to_delta('60s')

1550

>>> string_to_delta(u'60s')

1668

1551

datetime.timedelta(0, 60)

1669

>>> string_to_delta('60m')

1552

>>> string_to_delta(u'60m')

1670

1553

datetime.timedelta(0, 3600)

1671

>>> string_to_delta('24h')

1554

>>> string_to_delta(u'24h')

1672

1555

datetime.timedelta(1)

1673

>>> string_to_delta('1w')

1556

>>> string_to_delta(u'1w')

1674

1557

datetime.timedelta(7)

1675

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

1558

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

1676

1559

datetime.timedelta(0, 330)

1677

1560

"""

1678

1561

timevalue = datetime.timedelta(0)

1680

1563

try:

1681

1564

suffix = unicode(s[-1])

1682

1565

value = int(s[:-1])

1683

if suffix == "d":

1566

if suffix == u"d":

1684

1567

delta = datetime.timedelta(value)

1685

elif suffix == "s":

1568

elif suffix == u"s":

1686

1569

delta = datetime.timedelta(0, value)

1687

elif suffix == "m":

1570

elif suffix == u"m":

1688

1571

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

1689

elif suffix == "h":

1572

elif suffix == u"h":

1690

1573

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

1691

elif suffix == "w":

1574

elif suffix == u"w":

1692

1575

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

1693

1576

else:

1694

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

1695

except (ValueError, IndexError) as e:

1696

raise ValueError(*(e.args))

1577

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

1578

except (ValueError, IndexError), e:

1579

raise ValueError(e.message)

1697

1580

timevalue += delta

1698

1581

return timevalue

1699

1582

1705

1588

global if_nametoindex

1706

1589

try:

1707

1590

if_nametoindex = (ctypes.cdll.LoadLibrary

1708

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

1591

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

1709

1592

.if_nametoindex)

1710

1593

except (OSError, AttributeError):

1711

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

1594

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

1712

1595

def if_nametoindex(interface):

1713

1596

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

1714

1597

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

1715

1598

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

1716

1599

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1717

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

1600

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

1718

1601

interface))

1719

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

1602

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

1720

1603

ifreq[16:20])[0]

1721

1604

return interface_index

1722

1605

return if_nametoindex(interface)

1730

1613

sys.exit()

1731

1614

os.setsid()

1732

1615

if not nochdir:

1733

os.chdir("/")

1616

os.chdir(u"/")

1734

1617

if os.fork():

1735

1618

sys.exit()

1736

1619

if not noclose:

1738

1621

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

1739

1622

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

1740

1623

raise OSError(errno.ENODEV,

1741

"%s not a character device"

1624

u"%s not a character device"

1742

1625

% os.path.devnull)

1743

1626

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

1744

1627

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

1752

1635

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

1753

1636

# Parsing of options, both command line and config file

1754

1637

1755

parser = argparse.ArgumentParser()

1756

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

1757

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

1758

help="show version number and exit")

1759

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

1760

help="Bind to interface IF")

1761

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

1762

help="Address to listen for requests on")

1763

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

1764

help="Port number to receive requests on")

1765

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

1766

help="Run self-test")

1767

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

1768

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

1769

" to terminal")

1770

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

1771

help="Debug level for stdout output")

1772

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

1773

" priority string (see GnuTLS documentation)")

1774

parser.add_argument("--servicename",

1775

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

1776

parser.add_argument("--configdir",

1777

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

1778

help="Directory to search for configuration"

1779

" files")

1780

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

1781

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

1782

" system bus interface")

1783

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

1784

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

1785

options = parser.parse_args()

1638

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

1639

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

1640

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

1641

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

1642

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

1643

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

1644

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

1645

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

1646

help=u"Run self-test")

1647

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

1648

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

1649

u" terminal")

1650

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

1651

help=u"Debug level for stdout output")

1652

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

1653

u" priority string (see GnuTLS documentation)")

1654

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

1655

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

1656

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

1657

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

1658

help=u"Directory to search for configuration"

1659

u" files")

1660

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

1661

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

1662

u" system bus interface")

1663

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

1664

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

1665

options = parser.parse_args()[0]

1786

1666

1787

1667

if options.check:

1788

1668

import doctest

1790

1670

sys.exit()

1791

1671

1792

1672

# Default values for config file for server-global settings

1793

server_defaults = { "interface": "",

1794

"address": "",

1795

"port": "",

1796

"debug": "False",

1797

"priority":

1798

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

1799

"servicename": "Mandos",

1800

"use_dbus": "True",

1801

"use_ipv6": "True",

1802

"debuglevel": "",

1673

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

1674

u"address": u"",

1675

u"port": u"",

1676

u"debug": u"False",

1677

u"priority":

1678

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

1679

u"servicename": u"Mandos",

1680

u"use_dbus": u"True",

1681

u"use_ipv6": u"True",

1682

u"debuglevel": u"",

1803

1683

}

1804

1684

1805

1685

# Parse config file for server-global settings

1806

1686

server_config = configparser.SafeConfigParser(server_defaults)

1807

1687

del server_defaults

1808

1688

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

1809

"mandos.conf"))

1689

u"mandos.conf"))

1810

1690

# Convert the SafeConfigParser object to a dict

1811

1691

server_settings = server_config.defaults()

1812

1692

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

1813

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

1814

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

1693

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

1694

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

1815

1695

option)

1816

1696

if server_settings["port"]:

1817

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

1818

"port")

1697

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

1698

u"port")

1819

1699

del server_config

1820

1700

1821

1701

# Override the settings from the config file with command line

1822

1702

# options, if set.

1823

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

1824

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

1825

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

1703

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

1704

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

1705

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

1826

1706

value = getattr(options, option)

1827

1707

if value is not None:

1828

1708

server_settings[option] = value

1836

1716

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

1837

1717

1838

1718

# For convenience

1839

debug = server_settings["debug"]

1840

debuglevel = server_settings["debuglevel"]

1841

use_dbus = server_settings["use_dbus"]

1842

use_ipv6 = server_settings["use_ipv6"]

1719

debug = server_settings[u"debug"]

1720

debuglevel = server_settings[u"debuglevel"]

1721

use_dbus = server_settings[u"use_dbus"]

1722

use_ipv6 = server_settings[u"use_ipv6"]

1843

1723

1844

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

1724

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

1845

1725

syslogger.setFormatter(logging.Formatter

1846

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

1847

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

1848

% server_settings["servicename"]))

1726

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

1727

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

1728

% server_settings[u"servicename"]))

1849

1729

1850

1730

# Parse config file with clients

1851

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

1852

"extended_timeout": "15m",

1853

"interval": "2m",

1854

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

1855

"host": "",

1856

"approval_delay": "0s",

1857

"approval_duration": "1s",

1731

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

1732

u"interval": u"5m",

1733

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

1734

u"host": u"",

1735

u"approval_delay": u"0s",

1736

u"approval_duration": u"1s",

1858

1737

}

1859

1738

client_config = configparser.SafeConfigParser(client_defaults)

1860

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

1861

"clients.conf"))

1739

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

1740

u"clients.conf"))

1862

1741

1863

1742

global mandos_dbus_service

1864

1743

mandos_dbus_service = None

1865

1744

1866

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

1867

server_settings["port"]),

1745

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

1746

server_settings[u"port"]),

1868

1747

ClientHandler,

1869

interface=(server_settings["interface"]

1748

interface=(server_settings[u"interface"]

1870

1749

or None),

1871

1750

use_ipv6=use_ipv6,

1872

1751

gnutls_priority=

1873

server_settings["priority"],

1752

server_settings[u"priority"],

1874

1753

use_dbus=use_dbus)

1875

if not debug:

1876

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

1877

try:

1878

pidfile = open(pidfilename, "w")

1879

except IOError:

1880

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

1754

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

1755

try:

1756

pidfile = open(pidfilename, u"w")

1757

except IOError:

1758

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

1881

1759

1882

1760

try:

1883

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

1884

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

1761

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

1762

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

1885

1763

except KeyError:

1886

1764

try:

1887

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

1888

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

1765

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

1766

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

1889

1767

except KeyError:

1890

1768

try:

1891

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

1892

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

1769

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

1770

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

1893

1771

except KeyError:

1894

1772

uid = 65534

1895

1773

gid = 65534

1896

1774

try:

1897

1775

os.setgid(gid)

1898

1776

os.setuid(uid)

1899

except OSError as error:

1777

except OSError, error:

1900

1778

if error[0] != errno.EPERM:

1901

1779

raise error

1902

1780

1917

1795

1918

1796

@gnutls.library.types.gnutls_log_func

1919

1797

def debug_gnutls(level, string):

1920

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

1798

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

1921

1799

1922

1800

(gnutls.library.functions

1923

1801

.gnutls_global_set_log_function(debug_gnutls))

1931

1809

# No console logging

1932

1810

logger.removeHandler(console)

1933

1811

1934

# Need to fork before connecting to D-Bus

1935

if not debug:

1936

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

1937

daemon()

1938

1812

1939

1813

global main_loop

1940

1814

# From the Avahi example code

1944

1818

# End of Avahi example code

1945

1819

if use_dbus:

1946

1820

try:

1947

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

1821

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

1948

1822

bus, do_not_queue=True)

1949

except dbus.exceptions.NameExistsException as e:

1950

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

1823

except dbus.exceptions.NameExistsException, e:

1824

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

1951

1825

use_dbus = False

1952

server_settings["use_dbus"] = False

1826

server_settings[u"use_dbus"] = False

1953

1827

tcp_server.use_dbus = False

1954

1828

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1955

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

1956

servicetype = "_mandos._tcp",

1829

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

1830

servicetype = u"_mandos._tcp",

1957

1831

protocol = protocol, bus = bus)

1958

1832

if server_settings["interface"]:

1959

1833

service.interface = (if_nametoindex

1960

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

1961

1834

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

1835

1836

if not debug:

1837

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

1838

daemon()

1839

1962

1840

global multiprocessing_manager

1963

1841

multiprocessing_manager = multiprocessing.Manager()

1964

1842

1983

1861

client_config, section)))

1984

1862

for section in client_config.sections()))

1985

1863

if not tcp_server.clients:

1986

logger.warning("No clients defined")

1864

logger.warning(u"No clients defined")

1987

1865

1866

try:

1867

with pidfile:

1868

pid = os.getpid()

1869

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

1870

del pidfile

1871

except IOError:

1872

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

1873

pidfilename, pid)

1874

except NameError:

1875

# "pidfile" was never created

1876

pass

1877

del pidfilename

1878

1988

1879

if not debug:

1989

try:

1990

with pidfile:

1991

pid = os.getpid()

1992

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

1993

del pidfile

1994

except IOError:

1995

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

1996

pidfilename, pid)

1997

except NameError:

1998

# "pidfile" was never created

1999

pass

2000

del pidfilename

2001

2002

1880

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

2003

2004

1881

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

2005

1882

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

2006

1883

2008

1885

class MandosDBusService(dbus.service.Object):

2009

1886

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

2010

1887

def __init__(self):

2011

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

2012

_interface = "se.bsnet.fukt.Mandos"

1888

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

1889

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

2013

1890

2014

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

1891

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

2015

1892

def ClientAdded(self, objpath):

2016

1893

"D-Bus signal"

2017

1894

pass

2018

1895

2019

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

1896

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

2020

1897

def ClientNotFound(self, fingerprint, address):

2021

1898

"D-Bus signal"

2022

1899

pass

2023

1900

2024

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

1901

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

2025

1902

def ClientRemoved(self, objpath, name):

2026

1903

"D-Bus signal"

2027

1904

pass

2028

1905

2029

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

1906

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

2030

1907

def GetAllClients(self):

2031

1908

"D-Bus method"

2032

1909

return dbus.Array(c.dbus_object_path

2033

1910

for c in tcp_server.clients)

2034

1911

2035

1912

@dbus.service.method(_interface,

2036

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

1913

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

2037

1914

def GetAllClientsWithProperties(self):

2038

1915

"D-Bus method"

2039

1916

return dbus.Dictionary(

2040

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

1917

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

2041

1918

for c in tcp_server.clients),

2042

signature="oa{sv}")

1919

signature=u"oa{sv}")

2043

1920

2044

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

1921

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

2045

1922

def RemoveClient(self, object_path):

2046

1923

"D-Bus method"

2047

1924

for c in tcp_server.clients:

2089

1966

# Find out what port we got

2090

1967

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

2091

1968

if use_ipv6:

2092

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

1969

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

2093

1970

" flowinfo %d, scope_id %d"

2094

1971

% tcp_server.socket.getsockname())

2095

1972

else: # IPv4

2096

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

1973

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

2097

1974

% tcp_server.socket.getsockname())

2098

1975

2099

1976

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

2102

1979

# From the Avahi example code

2103

1980

try:

2104

1981

service.activate()

2105

except dbus.exceptions.DBusException as error:

2106

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

1982

except dbus.exceptions.DBusException, error:

1983

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

2107

1984

cleanup()

2108

1985

sys.exit(1)

2109

1986

# End of Avahi example code

2113

1990

(tcp_server.handle_request

2114

1991

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

2115

1992

2116

logger.debug("Starting main loop")

1993

logger.debug(u"Starting main loop")

2117

1994

main_loop.run()

2118

except AvahiError as error:

2119

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

1995

except AvahiError, error:

1996

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

2120

1997

cleanup()

2121

1998

sys.exit(1)

2122

1999

except KeyboardInterrupt:

2123

2000

if debug:

2124

print("", file=sys.stderr)

2125

logger.debug("Server received KeyboardInterrupt")

2126

logger.debug("Server exiting")

2001

print >> sys.stderr

2002

logger.debug(u"Server received KeyboardInterrupt")

2003

logger.debug(u"Server exiting")

2127

2004

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

2128

2005

cleanup()

2129

2006