/mandos/trunk : revision 36

6

# This program is partly derived from an example program for an Avahi

7

# service publisher, downloaded from

8

# <http://avahi.org/wiki/PythonPublishExample>. This includes the

9

# methods "add" and "remove" in the "AvahiService" class, the

10

# "server_state_changed" and "entry_group_state_changed" functions,

11

# and some lines in "main".

9

# following functions: "AvahiService.add", "AvahiService.remove",

10

# "server_state_changed", "entry_group_state_changed", and some lines

11

# in "main".

12

#

13

# Everything else is

14

15

14

16

15

#

17

16

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

18

17

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

25

24

# GNU General Public License for more details.

26

25

#

27

26

# You should have received a copy of the GNU General Public License

28

# along with this program. If not, see

29

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

27

# along with this program. If not, see <http://www.gnu.org/licenses/>.

30

28

#

31

29

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

32

30

#

33

31

34

from __future__ import division, with_statement, absolute_import

32

from __future__ import division

35

33

36

34

import SocketServer

37

35

import socket

36

import select

38

37

from optparse import OptionParser

39

38

import datetime

40

39

import errno

55

54

import stat

56

55

import logging

57

56

import logging.handlers

58

import pwd

59

from contextlib import closing

60

57

61

58

import dbus

62

import dbus.service

63

59

import gobject

64

60

import avahi

65

61

from dbus.mainloop.glib import DBusGMainLoop

66

62

import ctypes

67

import ctypes.util

68

69

version = "1.0.2"

63

64

# Brief description of the operation of this program:

65

#

66

# This server announces itself as a Zeroconf service. Connecting

67

# clients use the TLS protocol, with the unusual quirk that this

68

# server program acts as a TLS "client" while a connecting client acts

69

# as a TLS "server". The client (acting as a TLS "server") must

70

# supply an OpenPGP certificate, and the fingerprint of this

71

# certificate is used by this server to look up (in a list read from a

72

# file at start time) which binary blob to give the client. No other

73

# authentication or authorization is done by this server.

74

70

75

71

76

logger = logging.Logger('mandos')

72

syslogger = (logging.handlers.SysLogHandler

73

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

74

address = "/dev/log"))

75

syslogger.setFormatter(logging.Formatter

76

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

77

syslogger = logging.handlers.SysLogHandler\

78

(facility = logging.handlers.SysLogHandler.LOG_DAEMON)

79

syslogger.setFormatter(logging.Formatter\

80

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

77

81

logger.addHandler(syslogger)

82

del syslogger

78

83

79

console = logging.StreamHandler()

80

console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'

81

' %(message)s'))

82

logger.addHandler(console)

83

84

85

class AvahiError(Exception):

85

86

def __init__(self, value):

86

87

self.value = value

87

super(AvahiError, self).__init__()

88

def __str__(self):

89

return repr(self.value)

90

96

97

98

class AvahiService(object):

99

"""An Avahi (Zeroconf) service.

100

Attributes:

99

"""

101

100

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

102

101

Used to optionally bind to the specified interface.

103

104

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

105

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

106

port: integer; what port to announce

107

TXT: list of strings; TXT record for the service

108

domain: string; Domain to publish on, default to .local if empty.

109

host: string; Host to publish records for, default is localhost

110

max_renames: integer; maximum number of renames

111

rename_count: integer; counter so we only rename after collisions

112

a sensible number of times

102

name = string; Example: "Mandos"

103

type = string; Example: "_mandos._tcp".

104

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

105

port = integer; what port to announce

106

TXT = list of strings; TXT record for the service

107

domain = string; Domain to publish on, default to .local if empty.

108

host = string; Host to publish records for, default to localhost

109

if empty.

110

max_renames = integer; maximum number of renames

111

rename_count = integer; counter so we only rename after collisions

112

a sensible number of times

113

"""

114

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

115

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

116

domain = "", host = "", max_renames = 32768):

115

type = None, port = None, TXT = None, domain = "",

116

host = "", max_renames = 12):

117

"""An Avahi (Zeroconf) service. """

117

118

self.interface = interface

118

119

self.name = name

119

self.type = servicetype

120

self.type = type

120

121

self.port = port

121

self.TXT = TXT if TXT is not None else []

122

if TXT is None:

123

self.TXT = []

124

else:

125

self.TXT = TXT

122

126

self.domain = domain

123

127

self.host = host

124

128

self.rename_count = 0

125

self.max_renames = max_renames

126

129

def rename(self):

127

130

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

128

131

if self.rename_count >= self.max_renames:

129

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

130

u" after %i retries, exiting.",

131

self.rename_count)

132

logger.critical(u"No suitable service name found after %i"

133

u" retries, exiting.", rename_count)

132

134

raise AvahiServiceError("Too many renames")

133

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

134

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

135

str(self.name))

136

syslogger.setFormatter(logging.Formatter

137

('Mandos (%s): %%(levelname)s:'

138

' %%(message)s' % self.name))

135

name = server.GetAlternativeServiceName(name)

136

logger.notice(u"Changing name to %r ...", name)

139

137

self.remove()

140

138

self.add()

141

139

self.rename_count += 1

147

145

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

148

146

global group

149

147

if group is None:

150

group = dbus.Interface(bus.get_object

151

(avahi.DBUS_NAME,

148

group = dbus.Interface\

149

(bus.get_object(avahi.DBUS_NAME,

152

150

server.EntryGroupNew()),

153

avahi.DBUS_INTERFACE_ENTRY_GROUP)

151

avahi.DBUS_INTERFACE_ENTRY_GROUP)

154

152

group.connect_to_signal('StateChanged',

155

153

entry_group_state_changed)

156

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

154

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

157

155

service.name, service.type)

158

156

group.AddService(

159

157

self.interface, # interface

170

168

# End of Avahi example code

171

169

172

170

173

def _datetime_to_dbus(dt, variant_level=0):

174

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

175

return dbus.String(dt.isoformat(), variant_level=variant_level)

176

177

178

class Client(dbus.service.Object):

171

class Client(object):

179

172

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

180

173

Attributes:

181

174

182

175

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

183

176

uniquely identify the client

184

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

185

host: string; available for use by the checker command

186

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

187

last_enabled: datetime.datetime(); (UTC)

188

enabled: bool()

189

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

190

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

191

until this client is invalid

192

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

193

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

194

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

195

to see if the client lives.

196

'None' if no process is running.

177

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

178

fqdn: string (FQDN); available for use by the checker command

179

created: datetime.datetime(); object creation, not client host

180

last_checked_ok: datetime.datetime() or None if not yet checked OK

181

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

182

until this client is invalid

183

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

184

stop_hook: If set, called by stop() as stop_hook(self)

185

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

186

to see if the client lives.

187

'None' if no process is running.

197

188

checker_initiator_tag: a gobject event source tag, or None

198

disable_initiator_tag: - '' -

189

stop_initiator_tag: - '' -

199

190

checker_callback_tag: - '' -

200

191

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

201

192

client lives. %() expansions are done at

202

193

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

203

194

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

204

dbus_object_path: dbus.ObjectPath

205

195

Private attibutes:

206

196

_timeout: Real variable for 'timeout'

207

197

_interval: Real variable for 'interval'

209

199

_interval_milliseconds: - '' -

210

200

"""

211

201

def _set_timeout(self, timeout):

212

"Setter function for the 'timeout' attribute"

202

"Setter function for 'timeout' attribute"

213

203

self._timeout = timeout

214

204

self._timeout_milliseconds = ((self.timeout.days

215

205

* 24 * 60 * 60 * 1000)

216

206

+ (self.timeout.seconds * 1000)

217

207

+ (self.timeout.microseconds

218

208

// 1000))

219

# Emit D-Bus signal

220

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

221

(dbus.UInt64(self._timeout_milliseconds,

222

variant_level=1)))

223

timeout = property(lambda self: self._timeout, _set_timeout)

209

timeout = property(lambda self: self._timeout,

210

_set_timeout)

224

211

del _set_timeout

225

226

212

def _set_interval(self, interval):

227

"Setter function for the 'interval' attribute"

213

"Setter function for 'interval' attribute"

228

214

self._interval = interval

229

215

self._interval_milliseconds = ((self.interval.days

230

216

* 24 * 60 * 60 * 1000)

232

218

* 1000)

233

219

+ (self.interval.microseconds

234

220

// 1000))

235

# Emit D-Bus signal

236

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

237

(dbus.UInt64(self._interval_milliseconds,

238

variant_level=1)))

239

interval = property(lambda self: self._interval, _set_interval)

221

interval = property(lambda self: self._interval,

222

_set_interval)

240

223

del _set_interval

241

242

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

243

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

244

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

245

attribute."""

246

self.dbus_object_path = (dbus.ObjectPath

247

("/Mandos/clients/"

248

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

249

dbus.service.Object.__init__(self, bus,

250

self.dbus_object_path)

251

if config is None:

252

config = {}

224

def __init__(self, name=None, stop_hook=None, fingerprint=None,

225

secret=None, secfile=None, fqdn=None, timeout=None,

226

interval=-1, checker=None):

227

"""Note: the 'checker' argument sets the 'checker_command'

228

attribute and not the 'checker' attribute.."""

253

229

self.name = name

254

230

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

255

# Uppercase and remove spaces from fingerprint for later

256

# comparison purposes with return value from the fingerprint()

257

# function

258

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

259

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

231

# Uppercase and remove spaces from fingerprint

232

# for later comparison purposes with return value of

233

# the fingerprint() function

234

self.fingerprint = fingerprint.upper().replace(u" ", u"")

260

235

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

261

if "secret" in config:

262

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

263

elif "secfile" in config:

264

with closing(open(os.path.expanduser

265

(os.path.expandvars

266

(config["secfile"])))) as secfile:

267

self.secret = secfile.read()

236

if secret:

237

self.secret = secret.decode(u"base64")

238

elif secfile:

239

sf = open(secfile)

240

self.secret = sf.read()

241

sf.close()

268

242

else:

269

243

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

270

244

% self.name)

271

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

272

self.created = datetime.datetime.utcnow()

273

self.enabled = False

274

self.last_enabled = None

245

self.fqdn = fqdn

246

self.created = datetime.datetime.now()

275

247

self.last_checked_ok = None

276

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

277

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

278

self.disable_hook = disable_hook

248

self.timeout = string_to_delta(timeout)

249

self.interval = string_to_delta(interval)

250

self.stop_hook = stop_hook

279

251

self.checker = None

280

252

self.checker_initiator_tag = None

281

self.disable_initiator_tag = None

253

self.stop_initiator_tag = None

282

254

self.checker_callback_tag = None

283

self.checker_command = config["checker"]

284

285

def enable(self):

255

self.check_command = checker

256

def start(self):

286

257

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

287

self.last_enabled = datetime.datetime.utcnow()

288

258

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

289

259

# and every interval from then on.

290

self.checker_initiator_tag = (gobject.timeout_add

291

(self._interval_milliseconds,

292

self.start_checker))

260

self.checker_initiator_tag = gobject.timeout_add\

261

(self._interval_milliseconds,

262

self.start_checker)

293

263

# Also start a new checker *right now*.

294

264

self.start_checker()

295

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

296

self.disable_initiator_tag = (gobject.timeout_add

297

(self._timeout_milliseconds,

298

self.disable))

299

self.enabled = True

300

# Emit D-Bus signal

301

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

302

dbus.Boolean(True, variant_level=1))

303

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

304

(_datetime_to_dbus(self.last_enabled,

305

variant_level=1)))

306

307

def disable(self):

308

"""Disable this client."""

309

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

265

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

266

self.stop_initiator_tag = gobject.timeout_add\

267

(self._timeout_milliseconds,

268

self.stop)

269

def stop(self):

270

"""Stop this client.

271

The possibility that a client might be restarted is left open,

272

but not currently used."""

273

# If this client doesn't have a secret, it is already stopped.

274

if self.secret:

275

logger.debug(u"Stopping client %s", self.name)

276

self.secret = None

277

else:

310

278

return False

311

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

312

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

313

gobject.source_remove(self.disable_initiator_tag)

314

self.disable_initiator_tag = None

279

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

280

gobject.source_remove(self.stop_initiator_tag)

281

self.stop_initiator_tag = None

315

282

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

316

283

gobject.source_remove(self.checker_initiator_tag)

317

284

self.checker_initiator_tag = None

318

285

self.stop_checker()

319

if self.disable_hook:

320

self.disable_hook(self)

321

self.enabled = False

322

# Emit D-Bus signal

323

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

324

dbus.Boolean(False, variant_level=1))

286

if self.stop_hook:

287

self.stop_hook(self)

325

288

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

326

289

return False

327

328

290

def __del__(self):

329

self.disable_hook = None

330

self.disable()

331

332

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

291

self.stop_hook = None

292

self.stop()

293

def checker_callback(self, pid, condition):

333

294

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

295

now = datetime.datetime.now()

334

296

self.checker_callback_tag = None

335

297

self.checker = None

336

# Emit D-Bus signal

337

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

338

dbus.Boolean(False, variant_level=1))

339

if (os.WIFEXITED(condition)

340

and (os.WEXITSTATUS(condition) == 0)):

341

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

342

vars(self))

343

# Emit D-Bus signal

344

self.CheckerCompleted(dbus.Boolean(True),

345

dbus.UInt16(condition),

346

dbus.String(command))

347

self.bump_timeout()

298

if os.WIFEXITED(condition) \

299

and (os.WEXITSTATUS(condition) == 0):

300

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

301

vars(self))

302

self.last_checked_ok = now

303

gobject.source_remove(self.stop_initiator_tag)

304

self.stop_initiator_tag = gobject.timeout_add\

305

(self._timeout_milliseconds,

306

self.stop)

348

307

elif not os.WIFEXITED(condition):

349

308

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

350

309

vars(self))

351

# Emit D-Bus signal

352

self.CheckerCompleted(dbus.Boolean(False),

353

dbus.UInt16(condition),

354

dbus.String(command))

355

310

else:

356

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

357

vars(self))

358

# Emit D-Bus signal

359

self.CheckerCompleted(dbus.Boolean(False),

360

dbus.UInt16(condition),

361

dbus.String(command))

362

363

def bump_timeout(self):

364

"""Bump up the timeout for this client.

365

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

366

alive and well.

367

"""

368

self.last_checked_ok = datetime.datetime.utcnow()

369

gobject.source_remove(self.disable_initiator_tag)

370

self.disable_initiator_tag = (gobject.timeout_add

371

(self._timeout_milliseconds,

372

self.disable))

373

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

374

(_datetime_to_dbus(self.last_checked_ok,

375

variant_level=1)))

376

311

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

312

vars(self))

377

313

def start_checker(self):

378

314

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

379

315

If a checker already exists, leave it running and do

388

324

# is as it should be.

389

325

if self.checker is None:

390

326

try:

391

# In case checker_command has exactly one % operator

392

command = self.checker_command % self.host

327

# In case check_command has exactly one % operator

328

command = self.check_command % self.fqdn

393

329

except TypeError:

394

330

# Escape attributes for the shell

395

331

escaped_attrs = dict((key, re.escape(str(val)))

396

332

for key, val in

397

333

vars(self).iteritems())

398

334

try:

399

command = self.checker_command % escaped_attrs

335

command = self.check_command % escaped_attrs

400

336

except TypeError, error:

401

337

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

402

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

338

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

403

339

return True # Try again later

404

340

try:

405

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

406

command, self.name)

407

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

408

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

409

# and in debug mode we don't want to. (Stdin is

410

# always replaced by /dev/null.)

341

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

342

command, self.name)

411

343

self.checker = subprocess.Popen(command,

412

344

close_fds=True,

413

345

shell=True, cwd="/")

414

# Emit D-Bus signal

415

self.CheckerStarted(command)

416

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

417

dbus.Boolean(True, variant_level=1))

418

self.checker_callback_tag = (gobject.child_watch_add

419

(self.checker.pid,

420

self.checker_callback,

421

data=command))

422

except OSError, error:

346

self.checker_callback_tag = gobject.child_watch_add\

347

(self.checker.pid,

348

self.checker_callback)

349

except subprocess.OSError, error:

423

350

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

424

351

error)

425

352

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

426

353

return True

427

428

354

def stop_checker(self):

429

355

"""Force the checker process, if any, to stop."""

430

356

if self.checker_callback_tag:

432

358

self.checker_callback_tag = None

433

359

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

434

360

return

435

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

361

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

436

362

try:

437

363

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

438

364

#os.sleep(0.5)

442

368

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

443

369

raise

444

370

self.checker = None

445

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

446

dbus.Boolean(False, variant_level=1))

447

448

371

def still_valid(self):

449

372

"""Has the timeout not yet passed for this client?"""

450

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

451

return False

452

now = datetime.datetime.utcnow()

373

now = datetime.datetime.now()

453

374

if self.last_checked_ok is None:

454

375

return now < (self.created + self.timeout)

455

376

else:

456

377

return now < (self.last_checked_ok + self.timeout)

457

458

## D-Bus methods & signals

459

_interface = u"org.mandos_system.Mandos.Client"

460

461

# BumpTimeout - method

462

BumpTimeout = dbus.service.method(_interface)(bump_timeout)

463

BumpTimeout.__name__ = "BumpTimeout"

464

465

# CheckerCompleted - signal

466

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

467

def CheckerCompleted(self, success, condition, command):

468

"D-Bus signal"

469

pass

470

471

# CheckerStarted - signal

472

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

473

def CheckerStarted(self, command):

474

"D-Bus signal"

475

pass

476

477

# GetAllProperties - method

478

@dbus.service.method(_interface, out_signature="a{sv}")

479

def GetAllProperties(self):

480

"D-Bus method"

481

return dbus.Dictionary({

482

dbus.String("name"):

483

dbus.String(self.name, variant_level=1),

484

dbus.String("fingerprint"):

485

dbus.String(self.fingerprint, variant_level=1),

486

dbus.String("host"):

487

dbus.String(self.host, variant_level=1),

488

dbus.String("created"):

489

_datetime_to_dbus(self.created, variant_level=1),

490

dbus.String("last_enabled"):

491

(_datetime_to_dbus(self.last_enabled,

492

variant_level=1)

493

if self.last_enabled is not None

494

else dbus.Boolean(False, variant_level=1)),

495

dbus.String("enabled"):

496

dbus.Boolean(self.enabled, variant_level=1),

497

dbus.String("last_checked_ok"):

498

(_datetime_to_dbus(self.last_checked_ok,

499

variant_level=1)

500

if self.last_checked_ok is not None

501

else dbus.Boolean (False, variant_level=1)),

502

dbus.String("timeout"):

503

dbus.UInt64(self._timeout_milliseconds,

504

variant_level=1),

505

dbus.String("interval"):

506

dbus.UInt64(self._interval_milliseconds,

507

variant_level=1),

508

dbus.String("checker"):

509

dbus.String(self.checker_command,

510

variant_level=1),

511

dbus.String("checker_running"):

512

dbus.Boolean(self.checker is not None,

513

variant_level=1),

514

}, signature="sv")

515

516

# IsStillValid - method

517

IsStillValid = (dbus.service.method(_interface, out_signature="b")

518

(still_valid))

519

IsStillValid.__name__ = "IsStillValid"

520

521

# PropertyChanged - signal

522

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

523

def PropertyChanged(self, property, value):

524

"D-Bus signal"

525

pass

526

527

# SetChecker - method

528

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

529

def SetChecker(self, checker):

530

"D-Bus setter method"

531

self.checker_command = checker

532

533

# SetHost - method

534

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

535

def SetHost(self, host):

536

"D-Bus setter method"

537

self.host = host

538

539

# SetInterval - method

540

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

541

def SetInterval(self, milliseconds):

542

self.interval = datetime.timdeelta(0, 0, 0, milliseconds)

543

544

# SetSecret - method

545

@dbus.service.method(_interface, in_signature="ay",

546

byte_arrays=True)

547

def SetSecret(self, secret):

548

"D-Bus setter method"

549

self.secret = str(secret)

550

551

# SetTimeout - method

552

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

553

def SetTimeout(self, milliseconds):

554

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

555

556

# Enable - method

557

Enable = dbus.service.method(_interface)(enable)

558

Enable.__name__ = "Enable"

559

560

# StartChecker - method

561

@dbus.service.method(_interface)

562

def StartChecker(self):

563

"D-Bus method"

564

self.start_checker()

565

566

# Disable - method

567

@dbus.service.method(_interface)

568

def Disable(self):

569

"D-Bus method"

570

self.disable()

571

572

# StopChecker - method

573

StopChecker = dbus.service.method(_interface)(stop_checker)

574

StopChecker.__name__ = "StopChecker"

575

576

del _interface

577

378

578

379

579

380

def peer_certificate(session):

580

381

"Return the peer's OpenPGP certificate as a bytestring"

581

382

# If not an OpenPGP certificate...

582

if (gnutls.library.functions

583

.gnutls_certificate_type_get(session._c_object)

584

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

383

if gnutls.library.functions.gnutls_certificate_type_get\

384

(session._c_object) \

385

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:

585

386

# ...do the normal thing

586

387

return session.peer_certificate

587

388

list_size = ctypes.c_uint()

588

cert_list = (gnutls.library.functions

589

.gnutls_certificate_get_peers

590

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

389

cert_list = gnutls.library.functions.gnutls_certificate_get_peers\

390

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

591

391

if list_size.value == 0:

592

392

return None

593

393

cert = cert_list[0]

596

396

597

397

def fingerprint(openpgp):

598

398

"Convert an OpenPGP bytestring to a hexdigit fingerprint string"

599

# New GnuTLS "datum" with the OpenPGP public key

600

datum = (gnutls.library.types

601

.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),

602

ctypes.POINTER

603

(ctypes.c_ubyte)),

604

ctypes.c_uint(len(openpgp))))

605

399

# New empty GnuTLS certificate

606

400

crt = gnutls.library.types.gnutls_openpgp_crt_t()

607

(gnutls.library.functions

608

.gnutls_openpgp_crt_init(ctypes.byref(crt)))

401

gnutls.library.functions.gnutls_openpgp_crt_init\

402

(ctypes.byref(crt))

403

# New GnuTLS "datum" with the OpenPGP public key

404

datum = gnutls.library.types.gnutls_datum_t\

405

(ctypes.cast(ctypes.c_char_p(openpgp),

406

ctypes.POINTER(ctypes.c_ubyte)),

407

ctypes.c_uint(len(openpgp)))

609

408

# Import the OpenPGP public key into the certificate

610

(gnutls.library.functions

611

.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),

612

gnutls.library.constants

613

.GNUTLS_OPENPGP_FMT_RAW))

614

# Verify the self signature in the key

615

crtverify = ctypes.c_uint()

616

(gnutls.library.functions

617

.gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))

618

if crtverify.value != 0:

619

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

620

raise gnutls.errors.CertificateSecurityError("Verify failed")

409

ret = gnutls.library.functions.gnutls_openpgp_crt_import\

410

(crt,

411

ctypes.byref(datum),

412

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

621

413

# New buffer for the fingerprint

622

buf = ctypes.create_string_buffer(20)

623

buf_len = ctypes.c_size_t()

414

buffer = ctypes.create_string_buffer(20)

415

buffer_length = ctypes.c_size_t()

624

416

# Get the fingerprint from the certificate into the buffer

625

(gnutls.library.functions

626

.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),

627

ctypes.byref(buf_len)))

417

gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\

418

(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))

628

419

# Deinit the certificate

629

420

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

630

421

# Convert the buffer to a Python bytestring

631

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

422

fpr = ctypes.string_at(buffer, buffer_length.value)

632

423

# Convert the bytestring to hexadecimal notation

633

424

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

634

425

return hex_fpr

635

426

636

427

637

class TCP_handler(SocketServer.BaseRequestHandler, object):

428

class tcp_handler(SocketServer.BaseRequestHandler, object):

638

429

"""A TCP request handler class.

639

430

Instantiated by IPv6_TCPServer for each request to handle it.

640

431

Note: This will run in its own forked process."""

641

432

642

433

def handle(self):

643

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

644

unicode(self.client_address))

645

session = (gnutls.connection

646

.ClientSession(self.request,

647

gnutls.connection

648

.X509Credentials()))

649

650

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

651

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

652

try:

653

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

654

raise RuntimeError

655

except (ValueError, IndexError, RuntimeError), error:

656

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

657

return

658

434

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

435

unicode(self.client_address))

436

session = gnutls.connection.ClientSession\

437

(self.request, gnutls.connection.X509Credentials())

659

438

# Note: gnutls.connection.X509Credentials is really a generic

660

439

# GnuTLS certificate credentials object so long as no X.509

661

440

# keys are added to it. Therefore, we can use it here despite

664

443

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

665

444

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

666

445

# "+DHE-DSS"))

667

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

668

priority = self.server.settings.get("priority", "NORMAL")

669

(gnutls.library.functions

670

.gnutls_priority_set_direct(session._c_object,

671

priority, None))

446

priority = "NORMAL" # Fallback default, since this

447

# MUST be set.

448

if self.server.settings["priority"]:

449

priority = self.server.settings["priority"]

450

gnutls.library.functions.gnutls_priority_set_direct\

451

(session._c_object, priority, None);

672

452

673

453

try:

674

454

session.handshake()

675

455

except gnutls.errors.GNUTLSError, error:

676

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

456

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

677

457

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

678

458

# established. Just abandon the request.

679

459

return

680

460

try:

681

461

fpr = fingerprint(peer_certificate(session))

682

462

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

683

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

463

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

684

464

session.bye()

685

465

return

686

466

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

467

client = None

687

468

for c in self.server.clients:

688

469

if c.fingerprint == fpr:

689

470

client = c

690

471

break

691

else:

692

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

693

fpr)

472

if not client:

473

logger.debug(u"Client not found for fingerprint: %s", fpr)

694

474

session.bye()

695

475

return

696

476

# Have to check if client.still_valid(), since it is possible

697

477

# that the client timed out while establishing the GnuTLS

698

478

# session.

699

479

if not client.still_valid():

700

logger.warning(u"Client %(name)s is invalid",

701

vars(client))

480

logger.debug(u"Client %(name)s is invalid", vars(client))

702

481

session.bye()

703

482

return

704

## This won't work here, since we're in a fork.

705

# client.bump_timeout()

706

483

sent_size = 0

707

484

while sent_size < len(client.secret):

708

485

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

713

490

session.bye()

714

491

715

492

716

class IPv6_TCPServer(SocketServer.ForkingMixIn,

717

SocketServer.TCPServer, object):

493

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

718

494

"""IPv6 TCP server. Accepts 'None' as address and/or port.

719

495

Attributes:

720

496

settings: Server settings

721

497

clients: Set() of Client objects

722

enabled: Boolean; whether this server is activated yet

723

498

"""

724

499

address_family = socket.AF_INET6

725

500

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

729

504

if "clients" in kwargs:

730

505

self.clients = kwargs["clients"]

731

506

del kwargs["clients"]

732

self.enabled = False

733

super(IPv6_TCPServer, self).__init__(*args, **kwargs)

507

return super(type(self), self).__init__(*args, **kwargs)

734

508

def server_bind(self):

735

509

"""This overrides the normal server_bind() function

736

510

to bind to an interface if one was specified, and also NOT to

744

518

self.settings["interface"])

745

519

except socket.error, error:

746

520

if error[0] == errno.EPERM:

747

logger.error(u"No permission to"

748

u" bind to interface %s",

749

self.settings["interface"])

521

logger.warning(u"No permission to"

522

u" bind to interface %s",

523

self.settings["interface"])

750

524

else:

751

525

raise error

752

526

# Only bind(2) the socket if we really need to.

755

529

in6addr_any = "::"

756

530

self.server_address = (in6addr_any,

757

531

self.server_address[1])

758

elif not self.server_address[1]:

532

elif self.server_address[1] is None:

759

533

self.server_address = (self.server_address[0],

760

534

0)

761

# if self.settings["interface"]:

762

# self.server_address = (self.server_address[0],

763

# 0, # port

764

# 0, # flowinfo

765

# if_nametoindex

766

# (self.settings

767

# ["interface"]))

768

return super(IPv6_TCPServer, self).server_bind()

769

def server_activate(self):

770

if self.enabled:

771

return super(IPv6_TCPServer, self).server_activate()

772

def enable(self):

773

self.enabled = True

535

return super(type(self), self).server_bind()

774

536

775

537

776

538

def string_to_delta(interval):

786

548

datetime.timedelta(1)

787

549

>>> string_to_delta(u'1w')

788

550

datetime.timedelta(7)

789

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

790

datetime.timedelta(0, 330)

791

551

"""

792

timevalue = datetime.timedelta(0)

793

for s in interval.split():

794

try:

795

suffix = unicode(s[-1])

796

value = int(s[:-1])

797

if suffix == u"d":

798

delta = datetime.timedelta(value)

799

elif suffix == u"s":

800

delta = datetime.timedelta(0, value)

801

elif suffix == u"m":

802

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

803

elif suffix == u"h":

804

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

805

elif suffix == u"w":

806

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

807

else:

808

raise ValueError

809

except (ValueError, IndexError):

552

try:

553

suffix=unicode(interval[-1])

554

value=int(interval[:-1])

555

if suffix == u"d":

556

delta = datetime.timedelta(value)

557

elif suffix == u"s":

558

delta = datetime.timedelta(0, value)

559

elif suffix == u"m":

560

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

561

elif suffix == u"h":

562

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

563

elif suffix == u"w":

564

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

565

else:

810

566

raise ValueError

811

timevalue += delta

812

return timevalue

567

except (ValueError, IndexError):

568

raise ValueError

569

return delta

813

570

814

571

815

572

def server_state_changed(state):

816

573

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

817

574

if state == avahi.SERVER_COLLISION:

818

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

575

logger.warning(u"Server name collision")

819

576

service.remove()

820

577

elif state == avahi.SERVER_RUNNING:

821

578

service.add()

823

580

824

581

def entry_group_state_changed(state, error):

825

582

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

826

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

583

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

827

584

828

585

if state == avahi.ENTRY_GROUP_ESTABLISHED:

829

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

586

logger.debug(u"Service established.")

830

587

elif state == avahi.ENTRY_GROUP_COLLISION:

831

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

588

logger.warning(u"Service name collision.")

832

589

service.rename()

833

590

elif state == avahi.ENTRY_GROUP_FAILURE:

834

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

591

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

835

592

unicode(error))

836

593

raise AvahiGroupError("State changed: %s", str(error))

837

594

838

def if_nametoindex(interface):

595

def if_nametoindex(interface, _func=[None]):

839

596

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

840

global if_nametoindex

597

if _func[0] is not None:

598

return _func[0](interface)

841

599

try:

842

if_nametoindex = (ctypes.cdll.LoadLibrary

843

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

844

.if_nametoindex)

600

if "ctypes.util" not in sys.modules:

601

import ctypes.util

602

while True:

603

try:

604

libc = ctypes.cdll.LoadLibrary\

605

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

606

_func[0] = libc.if_nametoindex

607

return _func[0](interface)

608

except IOError, e:

609

if e != errno.EINTR:

610

raise

845

611

except (OSError, AttributeError):

846

612

if "struct" not in sys.modules:

847

613

import struct

848

614

if "fcntl" not in sys.modules:

849

615

import fcntl

850

def if_nametoindex(interface):

616

def the_hard_way(interface):

851

617

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

852

618

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

853

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

854

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

855

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

619

s = socket.socket()

620

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

621

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

622

s.close()

856

623

interface_index = struct.unpack("I", ifreq[16:20])[0]

857

624

return interface_index

858

return if_nametoindex(interface)

859

860

861

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

625

_func[0] = the_hard_way

626

return _func[0](interface)

627

628

629

def daemon(nochdir, noclose):

862

630

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

863

631

This should really exist as os.daemon, but it doesn't (yet)."""

864

632

if os.fork():

866

634

os.setsid()

867

635

if not nochdir:

868

636

os.chdir("/")

869

if os.fork():

870

sys.exit()

871

637

if not noclose:

872

638

# Close all standard open file descriptors

873

639

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

882

648

883

649

884

650

def main():

885

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

651

global main_loop_started

652

main_loop_started = False

653

654

parser = OptionParser()

886

655

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

887

656

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

888

657

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

891

660

help="Port number to receive requests on")

892

661

parser.add_option("--check", action="store_true", default=False,

893

662

help="Run self-test")

894

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

663

parser.add_option("--debug", action="store_true", default=False,

895

664

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

896

665

" terminal")

897

666

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

902

671

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

903

672

help="Directory to search for configuration"

904

673

" files")

905

options = parser.parse_args()[0]

674

(options, args) = parser.parse_args()

906

675

907

676

if options.check:

908

677

import doctest

922

691

# Parse config file for server-global settings

923

692

server_config = ConfigParser.SafeConfigParser(server_defaults)

924

693

del server_defaults

925

server_config.read(os.path.join(options.configdir, "mandos.conf"))

694

server_config.read(os.path.join(options.configdir, "server.conf"))

695

server_section = "server"

926

696

# Convert the SafeConfigParser object to a dict

927

server_settings = server_config.defaults()

697

server_settings = dict(server_config.items(server_section))

928

698

# Use getboolean on the boolean config option

929

server_settings["debug"] = (server_config.getboolean

930

("DEFAULT", "debug"))

699

server_settings["debug"] = server_config.getboolean\

700

(server_section, "debug")

931

701

del server_config

932

702

933

703

# Override the settings from the config file with command line

940

710

del options

941

711

# Now we have our good server settings in "server_settings"

942

712

943

debug = server_settings["debug"]

944

945

if not debug:

946

syslogger.setLevel(logging.WARNING)

947

console.setLevel(logging.WARNING)

948

949

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

950

syslogger.setFormatter(logging.Formatter

951

('Mandos (%s): %%(levelname)s:'

952

' %%(message)s'

953

% server_settings["servicename"]))

954

955

713

# Parse config file with clients

956

714

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

957

715

"interval": "5m",

958

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

959

"host": "",

716

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

960

717

}

961

718

client_config = ConfigParser.SafeConfigParser(client_defaults)

962

719

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

963

720

"clients.conf"))

964

721

965

clients = Set()

966

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

967

server_settings["port"]),

968

TCP_handler,

969

settings=server_settings,

970

clients=clients)

971

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

972

try:

973

pidfile = open(pidfilename, "w")

974

except IOError, error:

975

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

976

977

try:

978

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

979

except KeyError:

980

try:

981

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

982

except KeyError:

983

try:

984

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

985

except KeyError:

986

uid = 65534

987

try:

988

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

989

except KeyError:

990

try:

991

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

992

except KeyError:

993

try:

994

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

995

except KeyError:

996

gid = 65534

997

try:

998

os.setuid(uid)

999

os.setgid(gid)

1000

except OSError, error:

1001

if error[0] != errno.EPERM:

1002

raise error

1003

1004

722

global service

1005

723

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

1006

servicetype = "_mandos._tcp", )

724

type = "_mandos._tcp", );

1007

725

if server_settings["interface"]:

1008

service.interface = (if_nametoindex

1009

(server_settings["interface"]))

726

service.interface = if_nametoindex(server_settings["interface"])

1010

727

1011

728

global main_loop

1012

729

global bus

1015

732

DBusGMainLoop(set_as_default=True )

1016

733

main_loop = gobject.MainLoop()

1017

734

bus = dbus.SystemBus()

1018

server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,

1019

avahi.DBUS_PATH_SERVER),

1020

avahi.DBUS_INTERFACE_SERVER)

735

server = dbus.Interface(

736

bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),

737

avahi.DBUS_INTERFACE_SERVER )

1021

738

# End of Avahi example code

1022

bus_name = dbus.service.BusName(u"org.mandos-system.Mandos", bus)

1023

1024

clients.update(Set(Client(name = section,

1025

config

1026

= dict(client_config.items(section)))

739

740

debug = server_settings["debug"]

741

742

if debug:

743

console = logging.StreamHandler()

744

# console.setLevel(logging.DEBUG)

745

console.setFormatter(logging.Formatter\

746

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

747

logger.addHandler(console)

748

del console

749

750

clients = Set()

751

def remove_from_clients(client):

752

clients.remove(client)

753

if not clients:

754

logger.debug(u"No clients left, exiting")

755

sys.exit()

756

757

clients.update(Set(Client(name=section,

758

stop_hook = remove_from_clients,

759

**(dict(client_config\

760

.items(section))))

1027

761

for section in client_config.sections()))

1028

if not clients:

1029

logger.critical(u"No clients defined")

1030

sys.exit(1)

1031

1032

if debug:

1033

# Redirect stdin so all checkers get /dev/null

1034

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

1035

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

1036

if null > 2:

1037

os.close(null)

1038

else:

1039

# No console logging

1040

logger.removeHandler(console)

1041

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

1042

daemon()

1043

1044

try:

1045

pid = os.getpid()

1046

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

1047

pidfile.close()

1048

del pidfile

1049

except IOError:

1050

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

1051

pidfilename, pid)

1052

except NameError:

1053

# "pidfile" was never created

1054

pass

1055

del pidfilename

762

763

if not debug:

764

daemon(False, False)

1056

765

1057

766

def cleanup():

1058

767

"Cleanup function; run on exit"

1065

774

1066

775

while clients:

1067

776

client = clients.pop()

1068

client.disable_hook = None

1069

client.disable()

777

client.stop_hook = None

778

client.stop()

1070

779

1071

780

atexit.register(cleanup)

1072

781

1075

784

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

1076

785

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

1077

786

1078

class MandosServer(dbus.service.Object):

1079

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

1080

def __init__(self):

1081

dbus.service.Object.__init__(self, bus,

1082

"/Mandos")

1083

_interface = u"org.mandos_system.Mandos"

1084

1085

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

1086

def ClientAdded(self, objpath, properties):

1087

"D-Bus signal"

1088

pass

1089

1090

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

1091

def ClientRemoved(self, objpath):

1092

"D-Bus signal"

1093

pass

1094

1095

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

1096

def GetAllClients(self):

1097

return dbus.Array(c.dbus_object_path for c in clients)

1098

1099

@dbus.service.method(_interface, out_signature="a{oa{sv}}")

1100

def GetAllClientsWithProperties(self):

1101

return dbus.Dictionary(

1102

((c.dbus_object_path, c.GetAllProperties())

1103

for c in clients),

1104

signature="oa{sv}")

1105

1106

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

1107

def RemoveClient(self, object_path):

1108

for c in clients:

1109

if c.dbus_object_path == object_path:

1110

c.disable()

1111

clients.remove(c)

1112

return

1113

raise KeyError

1114

1115

del _interface

1116

1117

mandos_server = MandosServer()

1118

1119

787

for client in clients:

1120

# Emit D-Bus signal

1121

mandos_server.ClientAdded(client.dbus_object_path,

1122

client.GetAllProperties())

1123

client.enable()

1124

1125

tcp_server.enable()

1126

tcp_server.server_activate()

1127

788

client.start()

789

790

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

791

server_settings["port"]),

792

tcp_handler,

793

settings=server_settings,

794

clients=clients)

1128

795

# Find out what port we got

1129

796

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

1130

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

1131

u" scope_id %d" % tcp_server.socket.getsockname())

797

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

798

u" scope_id %d" % tcp_server.socket.getsockname())

1132

799

1133

800

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

1134

801

1144

811

1145

812

gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,

1146

813

lambda *args, **kwargs:

1147

(tcp_server.handle_request

1148

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

814

tcp_server.handle_request\

815

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

1149

816

1150

logger.debug(u"Starting main loop")

817

logger.debug("Starting main loop")

818

main_loop_started = True

1151

819

main_loop.run()

1152

820

except AvahiError, error:

1153

821

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