/mandos/release : revision 234

11

# and some lines 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

31

30

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

32

31

#

33

32

34

from __future__ import division, with_statement, absolute_import

33

from __future__ import division

35

34

36

35

import SocketServer

37

36

import socket

56

55

import logging

57

56

import logging.handlers

58

57

import pwd

59

from contextlib import closing

60

58

61

59

import dbus

62

import dbus.service

63

60

import gobject

64

61

import avahi

65

62

from dbus.mainloop.glib import DBusGMainLoop

69

66

version = "1.0.2"

70

67

71

68

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

69

syslogger = logging.handlers.SysLogHandler\

70

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

71

address = "/dev/log")

72

syslogger.setFormatter(logging.Formatter\

73

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

77

74

logger.addHandler(syslogger)

78

75

79

76

console = logging.StreamHandler()

112

109

a sensible number of times

113

110

"""

114

111

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

115

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

116

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

112

servicetype = None, port = None, TXT = None, domain = "",

113

host = "", max_renames = 32768):

117

114

self.interface = interface

118

115

self.name = name

119

116

self.type = servicetype

120

117

self.port = port

121

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

118

if TXT is None:

119

self.TXT = []

120

else:

121

self.TXT = TXT

122

self.domain = domain

123

self.host = host

124

self.rename_count = 0

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

136

syslogger.setFormatter(logging.Formatter\

137

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

138

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

138

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

139

self.remove()

140

self.add()

141

self.rename_count += 1

147

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

148

global group

149

if group is None:

150

group = dbus.Interface(bus.get_object

151

(avahi.DBUS_NAME,

150

group = dbus.Interface\

151

(bus.get_object(avahi.DBUS_NAME,

152

server.EntryGroupNew()),

153

avahi.DBUS_INTERFACE_ENTRY_GROUP)

153

avahi.DBUS_INTERFACE_ENTRY_GROUP)

154

group.connect_to_signal('StateChanged',

155

entry_group_state_changed)

156

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

170

# End of Avahi example code

171

172

173

class Client(dbus.service.Object):

173

class Client(object):

174

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

175

Attributes:

176

name: string; from the config file, used in log messages

178

uniquely identify the client

179

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

180

host: string; available for use by the checker command

181

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

182

started: datetime.datetime(); (UTC) last started

183

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

181

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

182

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

184

183

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

185

184

until this client is invalid

186

185

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

202

201

_interval_milliseconds: - '' -

203

202

"""

204

203

def _set_timeout(self, timeout):

205

"Setter function for the 'timeout' attribute"

204

"Setter function for 'timeout' attribute"

206

205

self._timeout = timeout

207

206

self._timeout_milliseconds = ((self.timeout.days

208

207

* 24 * 60 * 60 * 1000)

209

208

+ (self.timeout.seconds * 1000)

210

209

+ (self.timeout.microseconds

211

210

// 1000))

212

# Emit D-Bus signal

213

self.TimeoutChanged(self._timeout_milliseconds)

214

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

211

timeout = property(lambda self: self._timeout,

212

_set_timeout)

215

213

del _set_timeout

216

217

214

def _set_interval(self, interval):

218

"Setter function for the 'interval' attribute"

215

"Setter function for 'interval' attribute"

219

216

self._interval = interval

220

217

self._interval_milliseconds = ((self.interval.days

221

218

* 24 * 60 * 60 * 1000)

223

220

* 1000)

224

221

+ (self.interval.microseconds

225

222

// 1000))

226

# Emit D-Bus signal

227

self.IntervalChanged(self._interval_milliseconds)

228

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

223

interval = property(lambda self: self._interval,

224

_set_interval)

229

225

del _set_interval

230

231

226

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

232

227

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

233

228

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

234

229

attribute."""

235

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

236

"/Mandos/clients/%s"

237

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

238

230

if config is None:

239

231

config = {}

240

232

self.name = name

242

234

# Uppercase and remove spaces from fingerprint for later

243

235

# comparison purposes with return value from the fingerprint()

244

236

# function

245

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

246

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

237

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

238

.replace(u" ", u"")

247

239

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

248

240

if "secret" in config:

249

241

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

250

242

elif "secfile" in config:

251

with closing(open(os.path.expanduser

252

(os.path.expandvars

253

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

254

self.secret = secfile.read()

243

secfile = open(os.path.expanduser(os.path.expandvars

244

(config["secfile"])))

245

self.secret = secfile.read()

246

secfile.close()

255

247

else:

256

248

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

257

249

% self.name)

258

250

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

259

self.created = datetime.datetime.utcnow()

260

self.started = None

251

self.created = datetime.datetime.now()

261

252

self.last_checked_ok = None

262

253

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

263

254

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

267

258

self.stop_initiator_tag = None

268

259

self.checker_callback_tag = None

269

260

self.check_command = config["checker"]

270

271

261

def start(self):

272

262

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

273

self.started = datetime.datetime.utcnow()

274

263

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

275

264

# and every interval from then on.

276

self.checker_initiator_tag = (gobject.timeout_add

277

(self._interval_milliseconds,

278

self.start_checker))

265

self.checker_initiator_tag = gobject.timeout_add\

266

(self._interval_milliseconds,

267

self.start_checker)

279

268

# Also start a new checker *right now*.

280

269

self.start_checker()

281

270

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

282

self.stop_initiator_tag = (gobject.timeout_add

283

(self._timeout_milliseconds,

284

self.stop))

285

# Emit D-Bus signal

286

self.StateChanged(True)

287

271

self.stop_initiator_tag = gobject.timeout_add\

272

(self._timeout_milliseconds,

273

self.stop)

288

274

def stop(self):

289

"""Stop this client."""

290

if getattr(self, "started", None) is not None:

275

"""Stop this client.

276

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

277

but not currently used."""

278

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

279

if hasattr(self, "secret") and self.secret:

291

280

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

281

self.secret = None

292

282

else:

293

283

return False

294

284

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

300

290

self.stop_checker()

301

291

if self.stop_hook:

302

292

self.stop_hook(self)

303

self.started = None

304

# Emit D-Bus signal

305

self.StateChanged(False)

306

293

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

307

294

return False

308

309

295

def __del__(self):

310

296

self.stop_hook = None

311

297

self.stop()

312

313

298

def checker_callback(self, pid, condition):

314

299

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

300

now = datetime.datetime.now()

315

301

self.checker_callback_tag = None

316

302

self.checker = None

317

if (os.WIFEXITED(condition)

318

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

303

if os.WIFEXITED(condition) \

304

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

319

305

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

320

306

vars(self))

321

# Emit D-Bus signal

322

self.CheckerCompleted(True)

323

self.bump_timeout()

307

self.last_checked_ok = now

308

gobject.source_remove(self.stop_initiator_tag)

309

self.stop_initiator_tag = gobject.timeout_add\

310

(self._timeout_milliseconds,

311

self.stop)

324

312

elif not os.WIFEXITED(condition):

325

313

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

326

314

vars(self))

327

# Emit D-Bus signal

328

self.CheckerCompleted(False)

329

315

else:

330

316

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

331

317

vars(self))

332

# Emit D-Bus signal

333

self.CheckerCompleted(False)

334

335

def bump_timeout(self):

336

"""Bump up the timeout for this client.

337

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

338

alive and well.

339

"""

340

self.last_checked_ok = datetime.datetime.utcnow()

341

gobject.source_remove(self.stop_initiator_tag)

342

self.stop_initiator_tag = (gobject.timeout_add

343

(self._timeout_milliseconds,

344

self.stop))

345

346

318

def start_checker(self):

347

319

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

348

320

If a checker already exists, leave it running and do

380

352

self.checker = subprocess.Popen(command,

381

353

close_fds=True,

382

354

shell=True, cwd="/")

383

self.checker_callback_tag = (gobject.child_watch_add

384

(self.checker.pid,

385

self.checker_callback))

386

# Emit D-Bus signal

387

self.CheckerStarted(command)

355

self.checker_callback_tag = gobject.child_watch_add\

356

(self.checker.pid,

357

self.checker_callback)

388

358

except OSError, error:

389

359

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

390

360

error)

391

361

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

392

362

return True

393

394

363

def stop_checker(self):

395

364

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

396

365

if self.checker_callback_tag:

408

377

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

409

378

raise

410

379

self.checker = None

411

412

380

def still_valid(self):

413

381

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

414

if not self.started:

415

return False

416

now = datetime.datetime.utcnow()

382

now = datetime.datetime.now()

417

383

if self.last_checked_ok is None:

418

384

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

419

385

else:

420

386

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

421

422

## D-Bus methods & signals

423

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

424

425

def _datetime_to_dbus_struct(dt):

426

return dbus.Struct(dt.year, dt.month, dt.day, dt.hour,

427

dt.minute, dt.second, dt.microsecond,

428

signature="nyyyyyu")

429

430

# BumpTimeout - method

431

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

432

BumpTimeout.__name__ = "BumpTimeout"

433

434

# IntervalChanged - signal

435

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

436

def IntervalChanged(self, t):

437

"D-Bus signal"

438

pass

439

440

# CheckerCompleted - signal

441

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

442

def CheckerCompleted(self, success):

443

"D-Bus signal"

444

pass

445

446

# CheckerIsRunning - method

447

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

448

def CheckerIsRunning(self):

449

"D-Bus getter method"

450

return self.checker is not None

451

452

# CheckerStarted - signal

453

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

454

def CheckerStarted(self, command):

455

"D-Bus signal"

456

pass

457

458

# GetChecker - method

459

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

460

def GetChecker(self):

461

"D-Bus getter method"

462

return self.checker_command

463

464

# GetCreated - method

465

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

466

def GetCreated(self):

467

"D-Bus getter method"

468

return datetime_to_dbus_struct(self.created)

469

470

# GetFingerprint - method

471

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

472

def GetFingerprint(self):

473

"D-Bus getter method"

474

return self.fingerprint

475

476

# GetHost - method

477

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

478

def GetHost(self):

479

"D-Bus getter method"

480

return self.host

481

482

# GetInterval - method

483

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

484

def GetInterval(self):

485

"D-Bus getter method"

486

return self._interval_milliseconds

487

488

# GetName - method

489

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

490

def GetName(self):

491

"D-Bus getter method"

492

return self.name

493

494

# GetStarted - method

495

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

496

def GetStarted(self):

497

"D-Bus getter method"

498

if self.started is not None:

499

return datetime_to_dbus_struct(self.started)

500

else:

501

return dbus.Struct(0, 0, 0, 0, 0, 0, 0,

502

signature="nyyyyyu")

503

504

# GetTimeout - method

505

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

506

def GetTimeout(self):

507

"D-Bus getter method"

508

return self._timeout_milliseconds

509

510

# SetChecker - method

511

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

512

def SetChecker(self, checker):

513

"D-Bus setter method"

514

self.checker_command = checker

515

516

# SetHost - method

517

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

518

def SetHost(self, host):

519

"D-Bus setter method"

520

self.host = host

521

522

# SetInterval - method

523

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

524

def SetInterval(self, milliseconds):

525

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

526

527

# SetTimeout - method

528

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

529

def SetTimeout(self, milliseconds):

530

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

531

532

# SetSecret - method

533

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

534

byte_arrays=True)

535

def SetSecret(self, secret):

536

"D-Bus setter method"

537

self.secret = str(secret)

538

539

# Start - method

540

Start = dbus.service.method(_interface)(start)

541

Start.__name__ = "Start"

542

543

# StartChecker - method

544

StartChecker = dbus.service.method(_interface)(start_checker)

545

StartChecker.__name__ = "StartChecker"

546

547

# StateChanged - signal

548

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

549

def StateChanged(self, started):

550

"D-Bus signal"

551

pass

552

553

# StillValid - method

554

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

555

(still_valid))

556

StillValid.__name__ = "StillValid"

557

558

# Stop - method

559

Stop = dbus.service.method(_interface)(stop)

560

Stop.__name__ = "Stop"

561

562

# StopChecker - method

563

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

564

StopChecker.__name__ = "StopChecker"

565

566

# TimeoutChanged - signal

567

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

568

def TimeoutChanged(self, t):

569

"D-Bus signal"

570

pass

571

572

del _datetime_to_dbus_struct

573

del _interface

574

387

575

388

576

389

def peer_certificate(session):

577

390

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

578

391

# If not an OpenPGP certificate...

579

if (gnutls.library.functions

580

.gnutls_certificate_type_get(session._c_object)

581

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

392

if gnutls.library.functions.gnutls_certificate_type_get\

393

(session._c_object) \

394

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:

582

395

# ...do the normal thing

583

396

return session.peer_certificate

584

397

list_size = ctypes.c_uint()

585

cert_list = (gnutls.library.functions

586

.gnutls_certificate_get_peers

587

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

398

cert_list = gnutls.library.functions.gnutls_certificate_get_peers\

399

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

588

400

if list_size.value == 0:

589

401

return None

590

402

cert = cert_list[0]

594

406

def fingerprint(openpgp):

595

407

"Convert an OpenPGP bytestring to a hexdigit fingerprint string"

596

408

# New GnuTLS "datum" with the OpenPGP public key

597

datum = (gnutls.library.types

598

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

599

ctypes.POINTER

600

(ctypes.c_ubyte)),

601

ctypes.c_uint(len(openpgp))))

409

datum = gnutls.library.types.gnutls_datum_t\

410

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

411

ctypes.POINTER(ctypes.c_ubyte)),

412

ctypes.c_uint(len(openpgp)))

602

413

# New empty GnuTLS certificate

603

414

crt = gnutls.library.types.gnutls_openpgp_crt_t()

604

(gnutls.library.functions

605

.gnutls_openpgp_crt_init(ctypes.byref(crt)))

415

gnutls.library.functions.gnutls_openpgp_crt_init\

416

(ctypes.byref(crt))

606

417

# Import the OpenPGP public key into the certificate

607

(gnutls.library.functions

608

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

609

gnutls.library.constants

610

.GNUTLS_OPENPGP_FMT_RAW))

418

gnutls.library.functions.gnutls_openpgp_crt_import\

419

(crt, ctypes.byref(datum),

420

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

611

421

# Verify the self signature in the key

612

422

crtverify = ctypes.c_uint()

613

(gnutls.library.functions

614

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

423

gnutls.library.functions.gnutls_openpgp_crt_verify_self\

424

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

615

425

if crtverify.value != 0:

616

426

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

617

427

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

619

429

buf = ctypes.create_string_buffer(20)

620

430

buf_len = ctypes.c_size_t()

621

431

# Get the fingerprint from the certificate into the buffer

622

(gnutls.library.functions

623

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

624

ctypes.byref(buf_len)))

432

gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\

433

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

625

434

# Deinit the certificate

626

435

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

627

436

# Convert the buffer to a Python bytestring

638

447

639

448

def handle(self):

640

449

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

641

unicode(self.client_address))

642

session = (gnutls.connection

643

.ClientSession(self.request,

644

gnutls.connection

645

.X509Credentials()))

450

unicode(self.client_address))

451

session = gnutls.connection.ClientSession\

452

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

646

453

647

454

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

648

455

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

661

468

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

662

469

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

663

470

# "+DHE-DSS"))

664

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

665

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

666

(gnutls.library.functions

667

.gnutls_priority_set_direct(session._c_object,

668

priority, None))

471

priority = "NORMAL" # Fallback default, since this

472

# MUST be set.

473

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

474

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

475

gnutls.library.functions.gnutls_priority_set_direct\

476

(session._c_object, priority, None)

669

477

670

478

try:

671

479

session.handshake()

681

489

session.bye()

682

490

return

683

491

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

492

client = None

684

493

for c in self.server.clients:

685

494

if c.fingerprint == fpr:

686

495

client = c

687

496

break

688

else:

497

if not client:

689

498

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

690

499

fpr)

691

500

session.bye()

698

507

vars(client))

699

508

session.bye()

700

509

return

701

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

702

# client.bump_timeout()

703

510

sent_size = 0

704

511

while sent_size < len(client.secret):

705

512

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

710

517

session.bye()

711

518

712

519

713

class IPv6_TCPServer(SocketServer.ForkingMixIn,

714

SocketServer.TCPServer, object):

520

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

715

521

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

716

522

Attributes:

717

523

settings: Server settings

836

642

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

837

643

global if_nametoindex

838

644

try:

839

if_nametoindex = (ctypes.cdll.LoadLibrary

840

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

841

.if_nametoindex)

645

if_nametoindex = ctypes.cdll.LoadLibrary\

646

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

842

647

except (OSError, AttributeError):

843

648

if "struct" not in sys.modules:

844

649

import struct

847

652

def if_nametoindex(interface):

848

653

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

849

654

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

850

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

851

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

852

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

655

s = socket.socket()

656

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

657

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

658

s.close()

853

659

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

854

660

return interface_index

855

661

return if_nametoindex(interface)

923

729

# Convert the SafeConfigParser object to a dict

924

730

server_settings = server_config.defaults()

925

731

# Use getboolean on the boolean config option

926

server_settings["debug"] = (server_config.getboolean

927

("DEFAULT", "debug"))

732

server_settings["debug"] = server_config.getboolean\

733

("DEFAULT", "debug")

928

734

del server_config

929

735

930

736

# Override the settings from the config file with command line

944

750

console.setLevel(logging.WARNING)

945

751

946

752

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

947

syslogger.setFormatter(logging.Formatter

753

syslogger.setFormatter(logging.Formatter\

948

754

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

949

755

' %%(message)s'

950

756

% server_settings["servicename"]))

998

804

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

999

805

servicetype = "_mandos._tcp", )

1000

806

if server_settings["interface"]:

1001

service.interface = (if_nametoindex

1002

(server_settings["interface"]))

807

service.interface = if_nametoindex\

808

(server_settings["interface"])

1003

809

1004

810

global main_loop

1005

811

global bus

1012

818

avahi.DBUS_PATH_SERVER),

1013

819

avahi.DBUS_INTERFACE_SERVER)

1014

820

# End of Avahi example code

1015

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

1016

821

1017

822

def remove_from_clients(client):

1018

823

clients.remove(client)

1100

905

1101

906

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

1102

907

lambda *args, **kwargs:

1103

(tcp_server.handle_request

1104

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

908

tcp_server.handle_request\

909

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

1105

910

1106

911

logger.debug(u"Starting main loop")

1107

912

main_loop.run()