/mandos/release : revision 237.7.19

28

# along with this program. If not, see

29

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

30

#

31

# Contact the authors at <mandos@recompile.se>.

31

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

32

#

33

34

from __future__ import (division, absolute_import, print_function,

36

37

import SocketServer as socketserver

38

import socket

39

import argparse

39

import optparse

40

import datetime

41

import errno

42

import gnutls.crypto

62

import functools

63

import cPickle as pickle

64

import multiprocessing

65

import types

66

65

67

66

import dbus

68

67

import dbus.service

83

82

SO_BINDTODEVICE = None

84

83

85

84

86

version = "1.4.1"

85

version = "1.2.3"

87

86

88

87

#logger = logging.getLogger('mandos')

89

88

logger = logging.Logger('mandos')

152

151

self.group = None # our entry group

153

152

self.server = None

154

153

self.bus = bus

155

self.entry_group_state_changed_match = None

156

154

def rename(self):

157

155

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

158

156

if self.rename_count >= self.max_renames:

160

158

" after %i retries, exiting.",

161

159

self.rename_count)

162

160

raise AvahiServiceError("Too many renames")

163

self.name = unicode(self.server

164

.GetAlternativeServiceName(self.name))

161

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

165

162

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

166

163

self.name)

167

164

syslogger.setFormatter(logging.Formatter

171

168

self.remove()

172

169

try:

173

170

self.add()

174

except dbus.exceptions.DBusException as error:

171

except dbus.exceptions.DBusException, error:

175

172

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

176

173

self.cleanup()

177

174

os._exit(1)

178

175

self.rename_count += 1

179

176

def remove(self):

180

177

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

181

if self.entry_group_state_changed_match is not None:

182

self.entry_group_state_changed_match.remove()

183

self.entry_group_state_changed_match = None

184

178

if self.group is not None:

185

179

self.group.Reset()

186

180

def add(self):

187

181

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

188

self.remove()

189

182

if self.group is None:

190

183

self.group = dbus.Interface(

191

184

self.bus.get_object(avahi.DBUS_NAME,

192

185

self.server.EntryGroupNew()),

193

186

avahi.DBUS_INTERFACE_ENTRY_GROUP)

194

self.entry_group_state_changed_match = (

195

self.group.connect_to_signal(

196

'StateChanged', self .entry_group_state_changed))

187

self.group.connect_to_signal('StateChanged',

188

self

189

.entry_group_state_changed)

197

190

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

198

191

self.name, self.type)

199

192

self.group.AddService(

222

215

def cleanup(self):

223

216

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

224

217

if self.group is not None:

225

try:

226

self.group.Free()

227

except (dbus.exceptions.UnknownMethodException,

228

dbus.exceptions.DBusException) as e:

229

pass

218

self.group.Free()

230

219

self.group = None

231

self.remove()

232

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

220

def server_state_changed(self, state):

233

221

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

234

222

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

235

bad_states = { avahi.SERVER_INVALID:

236

"Zeroconf server invalid",

237

avahi.SERVER_REGISTERING: None,

238

avahi.SERVER_COLLISION:

239

"Zeroconf server name collision",

240

avahi.SERVER_FAILURE:

241

"Zeroconf server failure" }

242

if state in bad_states:

243

if bad_states[state] is not None:

244

if error is None:

245

logger.error(bad_states[state])

246

else:

247

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

248

self.cleanup()

223

if state == avahi.SERVER_COLLISION:

224

logger.error("Zeroconf server name collision")

225

self.remove()

249

226

elif state == avahi.SERVER_RUNNING:

250

227

self.add()

251

else:

252

if error is None:

253

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

254

else:

255

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

256

228

def activate(self):

257

229

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

258

230

if self.server is None:

259

231

self.server = dbus.Interface(

260

232

self.bus.get_object(avahi.DBUS_NAME,

261

avahi.DBUS_PATH_SERVER,

262

follow_name_owner_changes=True),

233

avahi.DBUS_PATH_SERVER),

263

234

avahi.DBUS_INTERFACE_SERVER)

264

235

self.server.connect_to_signal("StateChanged",

265

236

self.server_state_changed)

266

237

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

267

238

268

239

269

def _timedelta_to_milliseconds(td):

270

"Convert a datetime.timedelta() to milliseconds"

271

return ((td.days * 24 * 60 * 60 * 1000)

272

+ (td.seconds * 1000)

273

+ (td.microseconds // 1000))

274

275

240

class Client(object):

276

241

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

277

242

305

270

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

306

271

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

307

272

until this client is disabled

308

extended_timeout: extra long timeout when password has been sent

309

273

runtime_expansions: Allowed attributes for runtime expansion.

310

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

311

disabled, or None

312

274

"""

313

275

314

276

runtime_expansions = ("approval_delay", "approval_duration",

316

278

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

317

279

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

318

280

281

@staticmethod

282

def _timedelta_to_milliseconds(td):

283

"Convert a datetime.timedelta() to milliseconds"

284

return ((td.days * 24 * 60 * 60 * 1000)

285

+ (td.seconds * 1000)

286

+ (td.microseconds // 1000))

287

319

288

def timeout_milliseconds(self):

320

289

"Return the 'timeout' attribute in milliseconds"

321

return _timedelta_to_milliseconds(self.timeout)

322

323

def extended_timeout_milliseconds(self):

324

"Return the 'extended_timeout' attribute in milliseconds"

325

return _timedelta_to_milliseconds(self.extended_timeout)

290

return self._timedelta_to_milliseconds(self.timeout)

326

291

327

292

def interval_milliseconds(self):

328

293

"Return the 'interval' attribute in milliseconds"

329

return _timedelta_to_milliseconds(self.interval)

330

294

return self._timedelta_to_milliseconds(self.interval)

295

331

296

def approval_delay_milliseconds(self):

332

return _timedelta_to_milliseconds(self.approval_delay)

297

return self._timedelta_to_milliseconds(self.approval_delay)

333

298

334

299

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

335

300

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

362

327

self.last_enabled = None

363

328

self.last_checked_ok = None

364

329

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

365

self.extended_timeout = string_to_delta(config

366

["extended_timeout"])

367

330

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

368

331

self.disable_hook = disable_hook

369

332

self.checker = None

370

333

self.checker_initiator_tag = None

371

334

self.disable_initiator_tag = None

372

self.expires = None

373

335

self.checker_callback_tag = None

374

336

self.checker_command = config["checker"]

375

337

self.current_checker_command = None

382

344

config["approval_delay"])

383

345

self.approval_duration = string_to_delta(

384

346

config["approval_duration"])

385

self.changedstate = (multiprocessing_manager

386

.Condition(multiprocessing_manager

387

.Lock()))

347

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

388

348

389

349

def send_changedstate(self):

390

350

self.changedstate.acquire()

391

351

self.changedstate.notify_all()

392

352

self.changedstate.release()

393

353

394

354

def enable(self):

395

355

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

396

356

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

397

357

# Already enabled

398

358

return

399

359

self.send_changedstate()

360

self.last_enabled = datetime.datetime.utcnow()

400

361

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

401

362

# and every interval from then on.

402

363

self.checker_initiator_tag = (gobject.timeout_add

403

364

(self.interval_milliseconds(),

404

365

self.start_checker))

405

366

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

406

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

407

367

self.disable_initiator_tag = (gobject.timeout_add

408

368

(self.timeout_milliseconds(),

409

369

self.disable))

410

370

self.enabled = True

411

self.last_enabled = datetime.datetime.utcnow()

412

371

# Also start a new checker *right now*.

413

372

self.start_checker()

414

373

423

382

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

424

383

gobject.source_remove(self.disable_initiator_tag)

425

384

self.disable_initiator_tag = None

426

self.expires = None

427

385

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

428

386

gobject.source_remove(self.checker_initiator_tag)

429

387

self.checker_initiator_tag = None

455

413

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

456

414

vars(self))

457

415

458

def checked_ok(self, timeout=None):

416

def checked_ok(self):

459

417

"""Bump up the timeout for this client.

460

418

461

419

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

462

420

alive and well.

463

421

"""

464

if timeout is None:

465

timeout = self.timeout

466

422

self.last_checked_ok = datetime.datetime.utcnow()

467

if self.disable_initiator_tag is not None:

468

gobject.source_remove(self.disable_initiator_tag)

469

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

470

self.disable_initiator_tag = (gobject.timeout_add

471

(_timedelta_to_milliseconds

472

(timeout), self.disable))

473

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

423

gobject.source_remove(self.disable_initiator_tag)

424

self.disable_initiator_tag = (gobject.timeout_add

425

(self.timeout_milliseconds(),

426

self.disable))

474

427

475

428

def need_approval(self):

476

429

self.last_approval_request = datetime.datetime.utcnow()

492

445

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

493

446

try:

494

447

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

495

except (AttributeError, OSError) as error:

448

except (AttributeError, OSError), error:

496

449

if (isinstance(error, OSError)

497

450

and error.errno != errno.ECHILD):

498

451

raise error

516

469

'replace')))

517

470

for attr in

518

471

self.runtime_expansions)

519

472

520

473

try:

521

474

command = self.checker_command % escaped_attrs

522

except TypeError as error:

475

except TypeError, error:

523

476

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

524

477

' %s', self.checker_command, error)

525

478

return True # Try again later

544

497

if pid:

545

498

gobject.source_remove(self.checker_callback_tag)

546

499

self.checker_callback(pid, status, command)

547

except OSError as error:

500

except OSError, error:

548

501

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

549

502

error)

550

503

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

563

516

#time.sleep(0.5)

564

517

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

565

518

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

566

except OSError as error:

519

except OSError, error:

567

520

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

568

521

raise

569

522

self.checker = None

570

523

571

572

524

def dbus_service_property(dbus_interface, signature="v",

573

525

access="readwrite", byte_arrays=False):

574

526

"""Decorators for marking methods of a DBusObjectWithProperties to

620

572

621

573

class DBusObjectWithProperties(dbus.service.Object):

622

574

"""A D-Bus object with properties.

623

575

624

576

Classes inheriting from this can use the dbus_service_property

625

577

decorator to expose methods as D-Bus properties. It exposes the

626

578

standard Get(), Set(), and GetAll() methods on the D-Bus.

633

585

def _get_all_dbus_properties(self):

634

586

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

635

587

"""

636

return ((prop.__get__(self)._dbus_name, prop.__get__(self))

637

for cls in self.__class__.__mro__

588

return ((prop._dbus_name, prop)

638

589

for name, prop in

639

inspect.getmembers(cls, self._is_dbus_property))

590

inspect.getmembers(self, self._is_dbus_property))

640

591

641

592

def _get_dbus_property(self, interface_name, property_name):

642

593

"""Returns a bound method if one exists which is a D-Bus

643

594

property with the specified name and interface.

644

595

"""

645

for cls in self.__class__.__mro__:

646

for name, value in (inspect.getmembers

647

(cls, self._is_dbus_property)):

648

if (value._dbus_name == property_name

649

and value._dbus_interface == interface_name):

650

return value.__get__(self)

651

596

for name in (property_name,

597

property_name + "_dbus_property"):

598

prop = getattr(self, name, None)

599

if (prop is None

600

or not self._is_dbus_property(prop)

601

or prop._dbus_name != property_name

602

or (interface_name and prop._dbus_interface

603

and interface_name != prop._dbus_interface)):

604

continue

605

return prop

652

606

# No such property

653

607

raise DBusPropertyNotFound(self.dbus_object_path + ":"

654

608

+ interface_name + "."

688

642

def GetAll(self, interface_name):

689

643

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

690

644

standard.

691

645

692

646

Note: Will not include properties with access="write".

693

647

"""

694

648

all = {}

750

704

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

751

705

document.unlink()

752

706

except (AttributeError, xml.dom.DOMException,

753

xml.parsers.expat.ExpatError) as error:

707

xml.parsers.expat.ExpatError), error:

754

708

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

755

709

error)

756

710

return xmlstring

757

711

758

712

759

def datetime_to_dbus (dt, variant_level=0):

760

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

761

if dt is None:

762

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

763

return dbus.String(dt.isoformat(),

764

variant_level=variant_level)

765

766

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

767

.__metaclass__):

768

"""Applied to an empty subclass of a D-Bus object, this metaclass

769

will add additional D-Bus attributes matching a certain pattern.

770

"""

771

def __new__(mcs, name, bases, attr):

772

# Go through all the base classes which could have D-Bus

773

# methods, signals, or properties in them

774

for base in (b for b in bases

775

if issubclass(b, dbus.service.Object)):

776

# Go though all attributes of the base class

777

for attrname, attribute in inspect.getmembers(base):

778

# Ignore non-D-Bus attributes, and D-Bus attributes

779

# with the wrong interface name

780

if (not hasattr(attribute, "_dbus_interface")

781

or not attribute._dbus_interface

782

.startswith("se.recompile.Mandos")):

783

continue

784

# Create an alternate D-Bus interface name based on

785

# the current name

786

alt_interface = (attribute._dbus_interface

787

.replace("se.recompile.Mandos",

788

"se.bsnet.fukt.Mandos"))

789

# Is this a D-Bus signal?

790

if getattr(attribute, "_dbus_is_signal", False):

791

# Extract the original non-method function by

792

# black magic

793

nonmethod_func = (dict(

794

zip(attribute.func_code.co_freevars,

795

attribute.__closure__))["func"]

796

.cell_contents)

797

# Create a new, but exactly alike, function

798

# object, and decorate it to be a new D-Bus signal

799

# with the alternate D-Bus interface name

800

new_function = (dbus.service.signal

801

(alt_interface,

802

attribute._dbus_signature)

803

(types.FunctionType(

804

nonmethod_func.func_code,

805

nonmethod_func.func_globals,

806

nonmethod_func.func_name,

807

nonmethod_func.func_defaults,

808

nonmethod_func.func_closure)))

809

# Define a creator of a function to call both the

810

# old and new functions, so both the old and new

811

# signals gets sent when the function is called

812

def fixscope(func1, func2):

813

"""This function is a scope container to pass

814

func1 and func2 to the "call_both" function

815

outside of its arguments"""

816

def call_both(*args, **kwargs):

817

"""This function will emit two D-Bus

818

signals by calling func1 and func2"""

819

func1(*args, **kwargs)

820

func2(*args, **kwargs)

821

return call_both

822

# Create the "call_both" function and add it to

823

# the class

824

attr[attrname] = fixscope(attribute,

825

new_function)

826

# Is this a D-Bus method?

827

elif getattr(attribute, "_dbus_is_method", False):

828

# Create a new, but exactly alike, function

829

# object. Decorate it to be a new D-Bus method

830

# with the alternate D-Bus interface name. Add it

831

# to the class.

832

attr[attrname] = (dbus.service.method

833

(alt_interface,

834

attribute._dbus_in_signature,

835

attribute._dbus_out_signature)

836

(types.FunctionType

837

(attribute.func_code,

838

attribute.func_globals,

839

attribute.func_name,

840

attribute.func_defaults,

841

attribute.func_closure)))

842

# Is this a D-Bus property?

843

elif getattr(attribute, "_dbus_is_property", False):

844

# Create a new, but exactly alike, function

845

# object, and decorate it to be a new D-Bus

846

# property with the alternate D-Bus interface

847

# name. Add it to the class.

848

attr[attrname] = (dbus_service_property

849

(alt_interface,

850

attribute._dbus_signature,

851

attribute._dbus_access,

852

attribute

853

._dbus_get_args_options

854

["byte_arrays"])

855

(types.FunctionType

856

(attribute.func_code,

857

attribute.func_globals,

858

attribute.func_name,

859

attribute.func_defaults,

860

attribute.func_closure)))

861

return type.__new__(mcs, name, bases, attr)

862

863

713

class ClientDBus(Client, DBusObjectWithProperties):

864

714

"""A Client class using D-Bus

865

715

887

737

DBusObjectWithProperties.__init__(self, self.bus,

888

738

self.dbus_object_path)

889

739

890

def notifychangeproperty(transform_func,

891

dbus_name, type_func=lambda x: x,

892

variant_level=1):

893

""" Modify a variable so that it's a property which announces

894

its changes to DBus.

740

def _get_approvals_pending(self):

741

return self._approvals_pending

742

def _set_approvals_pending(self, value):

743

old_value = self._approvals_pending

744

self._approvals_pending = value

745

bval = bool(value)

746

if (hasattr(self, "dbus_object_path")

747

and bval is not bool(old_value)):

748

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

749

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

750

dbus_bool)

895

751

896

transform_fun: Function that takes a value and a variant_level

897

and transforms it to a D-Bus type.

898

dbus_name: D-Bus name of the variable

899

type_func: Function that transform the value before sending it

900

to the D-Bus. Default: no transform

901

variant_level: D-Bus variant level. Default: 1

902

"""

903

attrname = "_{0}".format(dbus_name)

904

def setter(self, value):

905

if hasattr(self, "dbus_object_path"):

906

if (not hasattr(self, attrname) or

907

type_func(getattr(self, attrname, None))

908

!= type_func(value)):

909

dbus_value = transform_func(type_func(value),

910

variant_level

911

=variant_level)

912

self.PropertyChanged(dbus.String(dbus_name),

913

dbus_value)

914

setattr(self, attrname, value)

915

916

return property(lambda self: getattr(self, attrname), setter)

917

918

919

expires = notifychangeproperty(datetime_to_dbus, "Expires")

920

approvals_pending = notifychangeproperty(dbus.Boolean,

921

"ApprovalPending",

922

type_func = bool)

923

enabled = notifychangeproperty(dbus.Boolean, "Enabled")

924

last_enabled = notifychangeproperty(datetime_to_dbus,

925

"LastEnabled")

926

checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",

927

type_func = lambda checker:

928

checker is not None)

929

last_checked_ok = notifychangeproperty(datetime_to_dbus,

930

"LastCheckedOK")

931

last_approval_request = notifychangeproperty(

932

datetime_to_dbus, "LastApprovalRequest")

933

approved_by_default = notifychangeproperty(dbus.Boolean,

934

"ApprovedByDefault")

935

approval_delay = notifychangeproperty(dbus.UInt16,

936

"ApprovalDelay",

937

type_func =

938

_timedelta_to_milliseconds)

939

approval_duration = notifychangeproperty(

940

dbus.UInt16, "ApprovalDuration",

941

type_func = _timedelta_to_milliseconds)

942

host = notifychangeproperty(dbus.String, "Host")

943

timeout = notifychangeproperty(dbus.UInt16, "Timeout",

944

type_func =

945

_timedelta_to_milliseconds)

946

extended_timeout = notifychangeproperty(

947

dbus.UInt16, "ExtendedTimeout",

948

type_func = _timedelta_to_milliseconds)

949

interval = notifychangeproperty(dbus.UInt16,

950

"Interval",

951

type_func =

952

_timedelta_to_milliseconds)

953

checker_command = notifychangeproperty(dbus.String, "Checker")

954

955

del notifychangeproperty

752

approvals_pending = property(_get_approvals_pending,

753

_set_approvals_pending)

754

del _get_approvals_pending, _set_approvals_pending

755

756

@staticmethod

757

def _datetime_to_dbus(dt, variant_level=0):

758

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

759

return dbus.String(dt.isoformat(),

760

variant_level=variant_level)

761

762

def enable(self):

763

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

764

r = Client.enable(self)

765

if oldstate != self.enabled:

766

# Emit D-Bus signals

767

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

768

dbus.Boolean(True, variant_level=1))

769

self.PropertyChanged(

770

dbus.String("LastEnabled"),

771

self._datetime_to_dbus(self.last_enabled,

772

variant_level=1))

773

return r

774

775

def disable(self, quiet = False):

776

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

777

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

778

if not quiet and oldstate != self.enabled:

779

# Emit D-Bus signal

780

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

781

dbus.Boolean(False, variant_level=1))

782

return r

956

783

957

784

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

958

785

try:

967

794

*args, **kwargs):

968

795

self.checker_callback_tag = None

969

796

self.checker = None

797

# Emit D-Bus signal

798

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

799

dbus.Boolean(False, variant_level=1))

970

800

if os.WIFEXITED(condition):

971

801

exitstatus = os.WEXITSTATUS(condition)

972

802

# Emit D-Bus signal

982

812

return Client.checker_callback(self, pid, condition, command,

983

813

*args, **kwargs)

984

814

815

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

816

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

817

# Emit D-Bus signal

818

self.PropertyChanged(

819

dbus.String("LastCheckedOK"),

820

(self._datetime_to_dbus(self.last_checked_ok,

821

variant_level=1)))

822

return r

823

824

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

825

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

826

# Emit D-Bus signal

827

self.PropertyChanged(

828

dbus.String("LastApprovalRequest"),

829

(self._datetime_to_dbus(self.last_approval_request,

830

variant_level=1)))

831

return r

832

985

833

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

986

834

old_checker = self.checker

987

835

if self.checker is not None:

994

842

and old_checker_pid != self.checker.pid):

995

843

# Emit D-Bus signal

996

844

self.CheckerStarted(self.current_checker_command)

845

self.PropertyChanged(

846

dbus.String("CheckerRunning"),

847

dbus.Boolean(True, variant_level=1))

997

848

return r

998

849

850

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

851

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

852

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

853

if (old_checker is not None

854

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

855

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

856

dbus.Boolean(False, variant_level=1))

857

return r

858

999

859

def _reset_approved(self):

1000

860

self._approved = None

1001

861

return False

1003

863

def approve(self, value=True):

1004

864

self.send_changedstate()

1005

865

self._approved = value

1006

gobject.timeout_add(_timedelta_to_milliseconds

866

gobject.timeout_add(self._timedelta_to_milliseconds

1007

867

(self.approval_duration),

1008

868

self._reset_approved)

1009

869

1010

870

1011

871

## D-Bus methods, signals & properties

1012

_interface = "se.recompile.Mandos.Client"

872

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

1013

873

1014

874

## Signals

1015

875

1062

922

# CheckedOK - method

1063

923

@dbus.service.method(_interface)

1064

924

def CheckedOK(self):

1065

self.checked_ok()

925

return self.checked_ok()

1066

926

1067

927

# Enable - method

1068

928

@dbus.service.method(_interface)

1101

961

if value is None: # get

1102

962

return dbus.Boolean(self.approved_by_default)

1103

963

self.approved_by_default = bool(value)

964

# Emit D-Bus signal

965

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

966

dbus.Boolean(value, variant_level=1))

1104

967

1105

968

# ApprovalDelay - property

1106

969

@dbus_service_property(_interface, signature="t",

1109

972

if value is None: # get

1110

973

return dbus.UInt64(self.approval_delay_milliseconds())

1111

974

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

975

# Emit D-Bus signal

976

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

977

dbus.UInt64(value, variant_level=1))

1112

978

1113

979

# ApprovalDuration - property

1114

980

@dbus_service_property(_interface, signature="t",

1115

981

access="readwrite")

1116

982

def ApprovalDuration_dbus_property(self, value=None):

1117

983

if value is None: # get

1118

return dbus.UInt64(_timedelta_to_milliseconds(

984

return dbus.UInt64(self._timedelta_to_milliseconds(

1119

985

self.approval_duration))

1120

986

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

987

# Emit D-Bus signal

988

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

989

dbus.UInt64(value, variant_level=1))

1121

990

1122

991

# Name - property

1123

992

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

1136

1005

if value is None: # get

1137

1006

return dbus.String(self.host)

1138

1007

self.host = value

1008

# Emit D-Bus signal

1009

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

1010

dbus.String(value, variant_level=1))

1139

1011

1140

1012

# Created - property

1141

1013

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

1142

1014

def Created_dbus_property(self):

1143

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

1015

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

1144

1016

1145

1017

# LastEnabled - property

1146

1018

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

1147

1019

def LastEnabled_dbus_property(self):

1148

return datetime_to_dbus(self.last_enabled)

1020

if self.last_enabled is None:

1021

return dbus.String("")

1022

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

1149

1023

1150

1024

# Enabled - property

1151

1025

@dbus_service_property(_interface, signature="b",

1165

1039

if value is not None:

1166

1040

self.checked_ok()

1167

1041

return

1168

return datetime_to_dbus(self.last_checked_ok)

1169

1170

# Expires - property

1171

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

1172

def Expires_dbus_property(self):

1173

return datetime_to_dbus(self.expires)

1042

if self.last_checked_ok is None:

1043

return dbus.String("")

1044

return dbus.String(self._datetime_to_dbus(self

1045

.last_checked_ok))

1174

1046

1175

1047

# LastApprovalRequest - property

1176

1048

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

1177

1049

def LastApprovalRequest_dbus_property(self):

1178

return datetime_to_dbus(self.last_approval_request)

1050

if self.last_approval_request is None:

1051

return dbus.String("")

1052

return dbus.String(self.

1053

_datetime_to_dbus(self

1054

.last_approval_request))

1179

1055

1180

1056

# Timeout - property

1181

1057

@dbus_service_property(_interface, signature="t",

1184

1060

if value is None: # get

1185

1061

return dbus.UInt64(self.timeout_milliseconds())

1186

1062

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

1063

# Emit D-Bus signal

1064

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

1065

dbus.UInt64(value, variant_level=1))

1187

1066

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

1188

1067

return

1189

1068

# Reschedule timeout

1190

1069

gobject.source_remove(self.disable_initiator_tag)

1191

1070

self.disable_initiator_tag = None

1192

self.expires = None

1193

time_to_die = _timedelta_to_milliseconds((self

1194

.last_checked_ok

1195

+ self.timeout)

1196

- datetime.datetime

1197

.utcnow())

1071

time_to_die = (self.

1072

_timedelta_to_milliseconds((self

1073

.last_checked_ok

1074

+ self.timeout)

1075

- datetime.datetime

1076

.utcnow()))

1198

1077

if time_to_die <= 0:

1199

1078

# The timeout has passed

1200

1079

self.disable()

1201

1080

else:

1202

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

1203

+ datetime.timedelta(milliseconds =

1204

time_to_die))

1205

1081

self.disable_initiator_tag = (gobject.timeout_add

1206

1082

(time_to_die, self.disable))

1207

1083

1208

# ExtendedTimeout - property

1209

@dbus_service_property(_interface, signature="t",

1210

access="readwrite")

1211

def ExtendedTimeout_dbus_property(self, value=None):

1212

if value is None: # get

1213

return dbus.UInt64(self.extended_timeout_milliseconds())

1214

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

1215

1216

1084

# Interval - property

1217

1085

@dbus_service_property(_interface, signature="t",

1218

1086

access="readwrite")

1220

1088

if value is None: # get

1221

1089

return dbus.UInt64(self.interval_milliseconds())

1222

1090

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

1091

# Emit D-Bus signal

1092

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

1093

dbus.UInt64(value, variant_level=1))

1223

1094

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

1224

1095

return

1225

1096

# Reschedule checker run

1227

1098

self.checker_initiator_tag = (gobject.timeout_add

1228

1099

(value, self.start_checker))

1229

1100

self.start_checker() # Start one now, too

1230

1101

1231

1102

# Checker - property

1232

1103

@dbus_service_property(_interface, signature="s",

1233

1104

access="readwrite")

1235

1106

if value is None: # get

1236

1107

return dbus.String(self.checker_command)

1237

1108

self.checker_command = value

1109

# Emit D-Bus signal

1110

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

1111

dbus.String(self.checker_command,

1112

variant_level=1))

1238

1113

1239

1114

# CheckerRunning - property

1240

1115

@dbus_service_property(_interface, signature="b",

1267

1142

self._pipe.send(('init', fpr, address))

1268

1143

if not self._pipe.recv():

1269

1144

raise KeyError()

1270

1145

1271

1146

def __getattribute__(self, name):

1272

1147

if(name == '_pipe'):

1273

1148

return super(ProxyClient, self).__getattribute__(name)

1280

1155

self._pipe.send(('funcall', name, args, kwargs))

1281

1156

return self._pipe.recv()[1]

1282

1157

return func

1283

1158

1284

1159

def __setattr__(self, name, value):

1285

1160

if(name == '_pipe'):

1286

1161

return super(ProxyClient, self).__setattr__(name, value)

1287

1162

self._pipe.send(('setattr', name, value))

1288

1163

1289

class ClientDBusTransitional(ClientDBus):

1290

__metaclass__ = AlternateDBusNamesMetaclass

1291

1164

1292

1165

class ClientHandler(socketserver.BaseRequestHandler, object):

1293

1166

"""A class to handle client connections.

1301

1174

unicode(self.client_address))

1302

1175

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

1303

1176

self.server.child_pipe.fileno())

1304

1177

1305

1178

session = (gnutls.connection

1306

1179

.ClientSession(self.request,

1307

1180

gnutls.connection

1308

1181

.X509Credentials()))

1309

1182

1310

1183

# Note: gnutls.connection.X509Credentials is really a

1311

1184

# generic GnuTLS certificate credentials object so long as

1312

1185

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

1313

1186

# here despite using OpenPGP certificates.

1314

1187

1315

1188

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

1316

1189

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

1317

1190

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

1323

1196

(gnutls.library.functions

1324

1197

.gnutls_priority_set_direct(session._c_object,

1325

1198

priority, None))

1326

1199

1327

1200

# Start communication using the Mandos protocol

1328

1201

# Get protocol number

1329

1202

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

1331

1204

try:

1332

1205

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

1333

1206

raise RuntimeError

1334

except (ValueError, IndexError, RuntimeError) as error:

1207

except (ValueError, IndexError, RuntimeError), error:

1335

1208

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

1336

1209

return

1337

1210

1338

1211

# Start GnuTLS connection

1339

1212

try:

1340

1213

session.handshake()

1341

except gnutls.errors.GNUTLSError as error:

1214

except gnutls.errors.GNUTLSError, error:

1342

1215

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

1343

1216

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

1344

1217

# established. Just abandon the request.

1345

1218

return

1346

1219

logger.debug("Handshake succeeded")

1347

1220

1348

1221

approval_required = False

1349

1222

try:

1350

1223

try:

1351

1224

fpr = self.fingerprint(self.peer_certificate

1352

1225

(session))

1353

except (TypeError,

1354

gnutls.errors.GNUTLSError) as error:

1226

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

1355

1227

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

1356

1228

return

1357

1229

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

1358

1230

1359

1231

try:

1360

1232

client = ProxyClient(child_pipe, fpr,

1361

1233

self.client_address)

1369

1241

1370

1242

while True:

1371

1243

if not client.enabled:

1372

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

1244

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

1373

1245

client.name)

1374

1246

if self.server.use_dbus:

1375

1247

# Emit D-Bus signal

1376

client.Rejected("Disabled")

1248

client.Rejected("Disabled")

1377

1249

return

1378

1250

1379

1251

if client._approved or not client.approval_delay:

1396

1268

return

1397

1269

1398

1270

#wait until timeout or approved

1271

#x = float(client._timedelta_to_milliseconds(delay))

1399

1272

time = datetime.datetime.now()

1400

1273

client.changedstate.acquire()

1401

(client.changedstate.wait

1402

(float(client._timedelta_to_milliseconds(delay)

1403

/ 1000)))

1274

client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))

1404

1275

client.changedstate.release()

1405

1276

time2 = datetime.datetime.now()

1406

1277

if (time2 - time) >= delay:

1421

1292

while sent_size < len(client.secret):

1422

1293

try:

1423

1294

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

1424

except gnutls.errors.GNUTLSError as error:

1295

except (gnutls.errors.GNUTLSError), error:

1425

1296

logger.warning("gnutls send failed")

1426

1297

return

1427

1298

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

1428

1299

sent, len(client.secret)

1429

1300

- (sent_size + sent))

1430

1301

sent_size += sent

1431

1302

1432

1303

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

1433

# bump the timeout using extended_timeout

1434

client.checked_ok(client.extended_timeout)

1304

# bump the timeout as if seen

1305

client.checked_ok()

1435

1306

if self.server.use_dbus:

1436

1307

# Emit D-Bus signal

1437

1308

client.GotSecret()

1441

1312

client.approvals_pending -= 1

1442

1313

try:

1443

1314

session.bye()

1444

except gnutls.errors.GNUTLSError as error:

1315

except (gnutls.errors.GNUTLSError), error:

1445

1316

logger.warning("GnuTLS bye failed")

1446

1317

1447

1318

@staticmethod

1516

1387

except:

1517

1388

self.handle_error(request, address)

1518

1389

self.close_request(request)

1519

1390

1520

1391

def process_request(self, request, address):

1521

1392

"""Start a new process to process the request."""

1522

proc = multiprocessing.Process(target = self.sub_process_main,

1523

args = (request,

1524

address))

1525

proc.start()

1526

return proc

1527

1393

multiprocessing.Process(target = self.sub_process_main,

1394

args = (request, address)).start()

1528

1395

1529

1396

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1530

1397

""" adds a pipe to the MixIn """

1534

1401

This function creates a new pipe in self.pipe

1535

1402

"""

1536

1403

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1537

1538

proc = MultiprocessingMixIn.process_request(self, request,

1539

client_address)

1404

1405

super(MultiprocessingMixInWithPipe,

1406

self).process_request(request, client_address)

1540

1407

self.child_pipe.close()

1541

self.add_pipe(parent_pipe, proc)

1542

1543

def add_pipe(self, parent_pipe, proc):

1408

self.add_pipe(parent_pipe)

1409

1410

def add_pipe(self, parent_pipe):

1544

1411

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

1545

1412

raise NotImplementedError

1546

1413

1547

1548

1414

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1549

1415

socketserver.TCPServer, object):

1550

1416

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

1576

1442

SO_BINDTODEVICE,

1577

1443

str(self.interface

1578

1444

+ '\0'))

1579

except socket.error as error:

1445

except socket.error, error:

1580

1446

if error[0] == errno.EPERM:

1581

1447

logger.error("No permission to"

1582

1448

" bind to interface %s",

1634

1500

def server_activate(self):

1635

1501

if self.enabled:

1636

1502

return socketserver.TCPServer.server_activate(self)

1637

1638

1503

def enable(self):

1639

1504

self.enabled = True

1640

1641

def add_pipe(self, parent_pipe, proc):

1505

def add_pipe(self, parent_pipe):

1642

1506

# Call "handle_ipc" for both data and EOF events

1643

1507

gobject.io_add_watch(parent_pipe.fileno(),

1644

1508

gobject.IO_IN | gobject.IO_HUP,

1645

1509

functools.partial(self.handle_ipc,

1646

parent_pipe =

1647

parent_pipe,

1648

proc = proc))

1649

1510

parent_pipe = parent_pipe))

1511

1650

1512

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

1651

proc = None, client_object=None):

1513

client_object=None):

1652

1514

condition_names = {

1653

1515

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

1654

1516

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

1663

1525

for cond, name in

1664

1526

condition_names.iteritems()

1665

1527

if cond & condition)

1666

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

1528

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

1667

1529

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

1668

# Wait for other process to exit

1669

proc.join()

1670

1530

return False

1671

1531

1672

1532

# Read a request from the child

1682

1542

client = c

1683

1543

break

1684

1544

else:

1685

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

1686

"dress: %s", fpr, address)

1545

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

1546

"dress: %s", fpr, address)

1687

1547

if self.use_dbus:

1688

1548

# Emit D-Bus signal

1689

mandos_dbus_service.ClientNotFound(fpr,

1690

address[0])

1549

mandos_dbus_service.ClientNotFound(fpr, address[0])

1691

1550

parent_pipe.send(False)

1692

1551

return False

1693

1552

1694

1553

gobject.io_add_watch(parent_pipe.fileno(),

1695

1554

gobject.IO_IN | gobject.IO_HUP,

1696

1555

functools.partial(self.handle_ipc,

1697

parent_pipe =

1698

parent_pipe,

1699

proc = proc,

1700

client_object =

1701

client))

1556

parent_pipe = parent_pipe,

1557

client_object = client))

1702

1558

parent_pipe.send(True)

1703

# remove the old hook in favor of the new above hook on

1704

# same fileno

1559

# remove the old hook in favor of the new above hook on same fileno

1705

1560

return False

1706

1561

if command == 'funcall':

1707

1562

funcname = request[1]

1708

1563

args = request[2]

1709

1564

kwargs = request[3]

1710

1565

1711

parent_pipe.send(('data', getattr(client_object,

1712

funcname)(*args,

1713

**kwargs)))

1714

1566

parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))

1567

1715

1568

if command == 'getattr':

1716

1569

attrname = request[1]

1717

1570

if callable(client_object.__getattribute__(attrname)):

1718

1571

parent_pipe.send(('function',))

1719

1572

else:

1720

parent_pipe.send(('data', client_object

1721

.__getattribute__(attrname)))

1573

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

1722

1574

1723

1575

if command == 'setattr':

1724

1576

attrname = request[1]

1725

1577

value = request[2]

1726

1578

setattr(client_object, attrname, value)

1727

1579

1728

1580

return True

1729

1581

1730

1582

1761

1613

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

1762

1614

else:

1763

1615

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

1764

except (ValueError, IndexError) as e:

1616

except (ValueError, IndexError), e:

1765

1617

raise ValueError(*(e.args))

1766

1618

timevalue += delta

1767

1619

return timevalue

1821

1673

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

1822

1674

# Parsing of options, both command line and config file

1823

1675

1824

parser = argparse.ArgumentParser()

1825

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

1826

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

1827

help="show version number and exit")

1828

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

1829

help="Bind to interface IF")

1830

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

1831

help="Address to listen for requests on")

1832

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

1833

help="Port number to receive requests on")

1834

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

1835

help="Run self-test")

1836

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

1837

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

1838

" to terminal")

1839

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

1840

help="Debug level for stdout output")

1841

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

1842

" priority string (see GnuTLS documentation)")

1843

parser.add_argument("--servicename",

1844

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

1845

parser.add_argument("--configdir",

1846

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

1847

help="Directory to search for configuration"

1848

" files")

1849

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

1850

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

1851

" system bus interface")

1852

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

1853

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

1854

options = parser.parse_args()

1676

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

1677

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

1678

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

1679

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

1680

help="Address to listen for requests on")

1681

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

1682

help="Port number to receive requests on")

1683

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

1684

help="Run self-test")

1685

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

1686

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

1687

" terminal")

1688

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

1689

help="Debug level for stdout output")

1690

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

1691

" priority string (see GnuTLS documentation)")

1692

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

1693

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

1694

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

1695

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

1696

help="Directory to search for configuration"

1697

" files")

1698

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

1699

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

1700

" system bus interface")

1701

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

1702

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

1703

options = parser.parse_args()[0]

1855

1704

1856

1705

if options.check:

1857

1706

import doctest

1909

1758

debuglevel = server_settings["debuglevel"]

1910

1759

use_dbus = server_settings["use_dbus"]

1911

1760

use_ipv6 = server_settings["use_ipv6"]

1912

1761

1913

1762

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

1914

1763

syslogger.setFormatter(logging.Formatter

1915

1764

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

1917

1766

% server_settings["servicename"]))

1918

1767

1919

1768

# Parse config file with clients

1920

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

1921

"extended_timeout": "15m",

1922

"interval": "2m",

1769

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

1770

"interval": "5m",

1923

1771

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

1924

1772

"host": "",

1925

1773

"approval_delay": "0s",

1965

1813

try:

1966

1814

os.setgid(gid)

1967

1815

os.setuid(uid)

1968

except OSError as error:

1816

except OSError, error:

1969

1817

if error[0] != errno.EPERM:

1970

1818

raise error

1971

1819

1976

1824

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

1977

1825

syslogger.setLevel(level)

1978

1826

console.setLevel(level)

1979

1827

1980

1828

if debug:

1981

1829

# Enable all possible GnuTLS debugging

1982

1830

2013

1861

# End of Avahi example code

2014

1862

if use_dbus:

2015

1863

try:

2016

bus_name = dbus.service.BusName("se.recompile.Mandos",

1864

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

2017

1865

bus, do_not_queue=True)

2018

old_bus_name = (dbus.service.BusName

2019

("se.bsnet.fukt.Mandos", bus,

2020

do_not_queue=True))

2021

except dbus.exceptions.NameExistsException as e:

1866

except dbus.exceptions.NameExistsException, e:

2022

1867

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

2023

1868

use_dbus = False

2024

1869

server_settings["use_dbus"] = False

2036

1881

2037

1882

client_class = Client

2038

1883

if use_dbus:

2039

client_class = functools.partial(ClientDBusTransitional,

2040

bus = bus)

1884

client_class = functools.partial(ClientDBus, bus = bus)

2041

1885

def client_config_items(config, section):

2042

1886

special_settings = {

2043

1887

"approved_by_default":

2073

1917

del pidfilename

2074

1918

2075

1919

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

2076

1920

2077

1921

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

2078

1922

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

2079

1923

2082

1926

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

2083

1927

def __init__(self):

2084

1928

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

2085

_interface = "se.recompile.Mandos"

1929

_interface = "se.bsnet.fukt.Mandos"

2086

1930

2087

1931

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

2088

1932

def ClientAdded(self, objpath):

2130

1974

2131

1975

del _interface

2132

1976

2133

class MandosDBusServiceTransitional(MandosDBusService):

2134

__metaclass__ = AlternateDBusNamesMetaclass

2135

mandos_dbus_service = MandosDBusServiceTransitional()

1977

mandos_dbus_service = MandosDBusService()

2136

1978

2137

1979

def cleanup():

2138

1980

"Cleanup function; run on exit"

2139

1981

service.cleanup()

2140

1982

2141

multiprocessing.active_children()

2142

1983

while tcp_server.clients:

2143

1984

client = tcp_server.clients.pop()

2144

1985

if use_dbus:

2148

1989

client.disable(quiet=True)

2149

1990

if use_dbus:

2150

1991

# Emit D-Bus signal

2151

mandos_dbus_service.ClientRemoved(client

2152

.dbus_object_path,

1992

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

2153

1993

client.name)

2154

1994

2155

1995

atexit.register(cleanup)

2179

2019

# From the Avahi example code

2180

2020

try:

2181

2021

service.activate()

2182

except dbus.exceptions.DBusException as error:

2022

except dbus.exceptions.DBusException, error:

2183

2023

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

2184

2024

cleanup()

2185

2025

sys.exit(1)

2192

2032

2193

2033

logger.debug("Starting main loop")

2194

2034

main_loop.run()

2195

except AvahiError as error:

2035

except AvahiError, error:

2196

2036

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

2197

2037

cleanup()

2198

2038

sys.exit(1)

2204

2044

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

2205

2045

cleanup()

2206

2046

2207

2208

2047

if __name__ == '__main__':

2209

2048

main()