/mandos/trunk : revision 493

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

265

264

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

266

265

267

266

268

def _timedelta_to_milliseconds(td):

269

"Convert a datetime.timedelta() to milliseconds"

270

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

271

+ (td.seconds * 1000)

272

+ (td.microseconds // 1000))

273

274

267

class Client(object):

275

268

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

276

269

304

297

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

305

298

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

306

299

until this client is disabled

307

extended_timeout: extra long timeout when password has been sent

308

300

runtime_expansions: Allowed attributes for runtime expansion.

309

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

310

disabled, or None

311

301

"""

312

302

313

303

runtime_expansions = ("approval_delay", "approval_duration",

315

305

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

316

306

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

317

307

308

@staticmethod

309

def _timedelta_to_milliseconds(td):

310

"Convert a datetime.timedelta() to milliseconds"

311

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

312

+ (td.seconds * 1000)

313

+ (td.microseconds // 1000))

314

318

315

def timeout_milliseconds(self):

319

316

"Return the 'timeout' attribute in milliseconds"

320

return _timedelta_to_milliseconds(self.timeout)

321

322

def extended_timeout_milliseconds(self):

323

"Return the 'extended_timeout' attribute in milliseconds"

324

return _timedelta_to_milliseconds(self.extended_timeout)

317

return self._timedelta_to_milliseconds(self.timeout)

325

318

326

319

def interval_milliseconds(self):

327

320

"Return the 'interval' attribute in milliseconds"

328

return _timedelta_to_milliseconds(self.interval)

329

321

return self._timedelta_to_milliseconds(self.interval)

322

330

323

def approval_delay_milliseconds(self):

331

return _timedelta_to_milliseconds(self.approval_delay)

324

return self._timedelta_to_milliseconds(self.approval_delay)

332

325

333

326

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

334

327

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

361

354

self.last_enabled = None

362

355

self.last_checked_ok = None

363

356

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

364

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

365

357

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

366

358

self.disable_hook = disable_hook

367

359

self.checker = None

368

360

self.checker_initiator_tag = None

369

361

self.disable_initiator_tag = None

370

self.expires = None

371

362

self.checker_callback_tag = None

372

363

self.checker_command = config["checker"]

373

364

self.current_checker_command = None

393

384

# Already enabled

394

385

return

395

386

self.send_changedstate()

387

self.last_enabled = datetime.datetime.utcnow()

396

388

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

397

389

# and every interval from then on.

398

390

self.checker_initiator_tag = (gobject.timeout_add

399

391

(self.interval_milliseconds(),

400

392

self.start_checker))

401

393

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

402

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

403

394

self.disable_initiator_tag = (gobject.timeout_add

404

395

(self.timeout_milliseconds(),

405

396

self.disable))

406

397

self.enabled = True

407

self.last_enabled = datetime.datetime.utcnow()

408

398

# Also start a new checker *right now*.

409

399

self.start_checker()

410

400

419

409

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

420

410

gobject.source_remove(self.disable_initiator_tag)

421

411

self.disable_initiator_tag = None

422

self.expires = None

423

412

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

424

413

gobject.source_remove(self.checker_initiator_tag)

425

414

self.checker_initiator_tag = None

451

440

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

452

441

vars(self))

453

442

454

def checked_ok(self, timeout=None):

443

def checked_ok(self):

455

444

"""Bump up the timeout for this client.

456

445

457

446

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

458

447

alive and well.

459

448

"""

460

if timeout is None:

461

timeout = self.timeout

462

449

self.last_checked_ok = datetime.datetime.utcnow()

463

450

gobject.source_remove(self.disable_initiator_tag)

464

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

465

451

self.disable_initiator_tag = (gobject.timeout_add

466

(_timedelta_to_milliseconds(timeout),

452

(self.timeout_milliseconds(),

467

453

self.disable))

468

454

469

455

def need_approval(self):

510

496

'replace')))

511

497

for attr in

512

498

self.runtime_expansions)

513

499

514

500

try:

515

501

command = self.checker_command % escaped_attrs

516

502

except TypeError as error:

562

548

raise

563

549

self.checker = None

564

550

565

566

551

def dbus_service_property(dbus_interface, signature="v",

567

552

access="readwrite", byte_arrays=False):

568

553

"""Decorators for marking methods of a DBusObjectWithProperties to

614

599

615

600

class DBusObjectWithProperties(dbus.service.Object):

616

601

"""A D-Bus object with properties.

617

602

618

603

Classes inheriting from this can use the dbus_service_property

619

604

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

620

605

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

627

612

def _get_all_dbus_properties(self):

628

613

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

629

614

"""

630

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

631

for cls in self.__class__.__mro__

632

for name, prop in inspect.getmembers(cls, self._is_dbus_property))

615

return ((prop._dbus_name, prop)

616

for name, prop in

617

inspect.getmembers(self, self._is_dbus_property))

633

618

634

619

def _get_dbus_property(self, interface_name, property_name):

635

620

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

636

621

property with the specified name and interface.

637

622

"""

638

for cls in self.__class__.__mro__:

639

for name, value in inspect.getmembers(cls, self._is_dbus_property):

640

if value._dbus_name == property_name and value._dbus_interface == interface_name:

641

return value.__get__(self)

642

623

for name in (property_name,

624

property_name + "_dbus_property"):

625

prop = getattr(self, name, None)

626

if (prop is None

627

or not self._is_dbus_property(prop)

628

or prop._dbus_name != property_name

629

or (interface_name and prop._dbus_interface

630

and interface_name != prop._dbus_interface)):

631

continue

632

return prop

643

633

# No such property

644

634

raise DBusPropertyNotFound(self.dbus_object_path + ":"

645

635

+ interface_name + "."

679

669

def GetAll(self, interface_name):

680

670

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

681

671

standard.

682

672

683

673

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

684

674

"""

685

675

all = {}

747

737

return xmlstring

748

738

749

739

750

def datetime_to_dbus (dt, variant_level=0):

751

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

752

if dt is None:

753

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

754

return dbus.String(dt.isoformat(),

755

variant_level=variant_level)

756

757

class AlternateDBusNamesMetaclass(DBusObjectWithProperties.__metaclass__):

758

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

759

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

760

"""

761

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

762

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

763

# methods, signals, or properties in them

764

for base in (b for b in bases

765

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

766

# Go though all attributes of the base class

767

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

768

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

769

# with the wrong interface name

770

if (not hasattr(attribute, "_dbus_interface")

771

or not attribute._dbus_interface

772

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

773

continue

774

# Create an alternate D-Bus interface name based on

775

# the current name

776

alt_interface = (attribute._dbus_interface

777

.replace("se.recompile.Mandos",

778

"se.bsnet.fukt.Mandos"))

779

# Is this a D-Bus signal?

780

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

781

# Extract the original non-method function by

782

# black magic

783

nonmethod_func = (dict(

784

zip(attribute.func_code.co_freevars,

785

attribute.__closure__))["func"]

786

.cell_contents)

787

# Create a new, but exactly alike, function

788

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

789

# with the alternate D-Bus interface name

790

new_function = (dbus.service.signal

791

(alt_interface,

792

attribute._dbus_signature)

793

(types.FunctionType(

794

nonmethod_func.func_code,

795

nonmethod_func.func_globals,

796

nonmethod_func.func_name,

797

nonmethod_func.func_defaults,

798

nonmethod_func.func_closure)))

799

# Define a creator of a function to call both the

800

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

801

# signals gets sent when the function is called

802

def fixscope(func1, func2):

803

"""This function is a scope container to pass

804

func1 and func2 to the "call_both" function

805

outside of its arguments"""

806

def call_both(*args, **kwargs):

807

"""This function will emit two D-Bus

808

signals by calling func1 and func2"""

809

func1(*args, **kwargs)

810

func2(*args, **kwargs)

811

return call_both

812

# Create the "call_both" function and add it to

813

# the class

814

attr[attrname] = fixscope(attribute,

815

new_function)

816

# Is this a D-Bus method?

817

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

818

# Create a new, but exactly alike, function

819

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

820

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

821

# to the class.

822

attr[attrname] = (dbus.service.method

823

(alt_interface,

824

attribute._dbus_in_signature,

825

attribute._dbus_out_signature)

826

(types.FunctionType

827

(attribute.func_code,

828

attribute.func_globals,

829

attribute.func_name,

830

attribute.func_defaults,

831

attribute.func_closure)))

832

# Is this a D-Bus property?

833

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

834

# Create a new, but exactly alike, function

835

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

836

# property with the alternate D-Bus interface

837

# name. Add it to the class.

838

attr[attrname] = (dbus_service_property

839

(alt_interface,

840

attribute._dbus_signature,

841

attribute._dbus_access,

842

attribute

843

._dbus_get_args_options

844

["byte_arrays"])

845

(types.FunctionType

846

(attribute.func_code,

847

attribute.func_globals,

848

attribute.func_name,

849

attribute.func_defaults,

850

attribute.func_closure)))

851

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

852

853

740

class ClientDBus(Client, DBusObjectWithProperties):

854

741

"""A Client class using D-Bus

855

742

877

764

DBusObjectWithProperties.__init__(self, self.bus,

878

765

self.dbus_object_path)

879

766

880

def notifychangeproperty(transform_func,

881

dbus_name, type_func=lambda x: x,

882

variant_level=1):

883

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

884

its changes to DBus.

767

def _get_approvals_pending(self):

768

return self._approvals_pending

769

def _set_approvals_pending(self, value):

770

old_value = self._approvals_pending

771

self._approvals_pending = value

772

bval = bool(value)

773

if (hasattr(self, "dbus_object_path")

774

and bval is not bool(old_value)):

775

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

776

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

777

dbus_bool)

885

778

886

transform_fun: Function that takes a value and transforms it

887

to a D-Bus type.

888

dbus_name: D-Bus name of the variable

889

type_func: Function that transform the value before sending it

890

to the D-Bus. Default: no transform

891

variant_level: D-Bus variant level. Default: 1

892

"""

893

real_value = [None,]

894

def setter(self, value):

895

old_value = real_value[0]

896

real_value[0] = value

897

if hasattr(self, "dbus_object_path"):

898

if type_func(old_value) != type_func(real_value[0]):

899

dbus_value = transform_func(type_func(real_value[0]),

900

variant_level)

901

self.PropertyChanged(dbus.String(dbus_name),

902

dbus_value)

903

904

return property(lambda self: real_value[0], setter)

905

906

907

expires = notifychangeproperty(datetime_to_dbus, "Expires")

908

approvals_pending = notifychangeproperty(dbus.Boolean,

909

"ApprovalPending",

910

type_func = bool)

911

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

912

last_enabled = notifychangeproperty(datetime_to_dbus,

913

"LastEnabled")

914

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

915

type_func = lambda checker: checker is not None)

916

last_checked_ok = notifychangeproperty(datetime_to_dbus,

917

"LastCheckedOK")

918

last_approval_request = notifychangeproperty(datetime_to_dbus,

919

"LastApprovalRequest")

920

approved_by_default = notifychangeproperty(dbus.Boolean,

921

"ApprovedByDefault")

922

approval_delay = notifychangeproperty(dbus.UInt16, "ApprovalDelay",

923