/mandos/trunk : revision 24.1.185

62

import functools

63

import cPickle as pickle

64

import multiprocessing

65

import types

65

66

67

import dbus

67

68

import dbus.service

264

265

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

265

266

267

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

267

274

class Client(object):

268

275

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

269

276

297

304

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

298

305

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

299

306

until this client is disabled

307

extended_timeout: extra long timeout when password has been sent

300

308

runtime_expansions: Allowed attributes for runtime expansion.

309

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

310

disabled, or None

301

311

"""

302

312

303

313

runtime_expansions = ("approval_delay", "approval_duration",

305

315

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

306

316

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

307

317

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

315

318

def timeout_milliseconds(self):

316

319

"Return the 'timeout' attribute in milliseconds"

317

return self._timedelta_to_milliseconds(self.timeout)

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)

318

325

319

326

def interval_milliseconds(self):

320

327

"Return the 'interval' attribute in milliseconds"

321

return self._timedelta_to_milliseconds(self.interval)

322

328

return _timedelta_to_milliseconds(self.interval)

329

323

330

def approval_delay_milliseconds(self):

324

return self._timedelta_to_milliseconds(self.approval_delay)

331

return _timedelta_to_milliseconds(self.approval_delay)

325

332

326

333

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

327

334

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

354

361

self.last_enabled = None

355

362

self.last_checked_ok = None

356

363

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

364

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

357

365

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

358

366

self.disable_hook = disable_hook

359

367

self.checker = None

360

368

self.checker_initiator_tag = None

361

369

self.disable_initiator_tag = None

370

self.expires = None

362

371

self.checker_callback_tag = None

363

372

self.checker_command = config["checker"]

364

373

self.current_checker_command = None

384

393

# Already enabled

385

394

return

386

395

self.send_changedstate()

387

self.last_enabled = datetime.datetime.utcnow()

388

396

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

389

397

# and every interval from then on.

390

398

self.checker_initiator_tag = (gobject.timeout_add

391

399

(self.interval_milliseconds(),

392

400

self.start_checker))

393

401

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

402

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

394

403

self.disable_initiator_tag = (gobject.timeout_add

395

404

(self.timeout_milliseconds(),

396

405

self.disable))

397

406

self.enabled = True

407

self.last_enabled = datetime.datetime.utcnow()

398

408

# Also start a new checker *right now*.

399

409

self.start_checker()

400

410

409

419

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

410

420

gobject.source_remove(self.disable_initiator_tag)

411

421

self.disable_initiator_tag = None

422

self.expires = None

412

423

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

413

424

gobject.source_remove(self.checker_initiator_tag)

414

425

self.checker_initiator_tag = None

440

451

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

441

452

vars(self))

442

453

443

def checked_ok(self):

454

def checked_ok(self, timeout=None):

444

455

"""Bump up the timeout for this client.

445

456

446

457

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

447

458

alive and well.

448

459

"""

460

if timeout is None:

461

timeout = self.timeout

449

462

self.last_checked_ok = datetime.datetime.utcnow()

450

463

gobject.source_remove(self.disable_initiator_tag)

464

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

451

465

self.disable_initiator_tag = (gobject.timeout_add

452

(self.timeout_milliseconds(),

466

(_timedelta_to_milliseconds(timeout),

453

467

self.disable))

454

468

455

469

def need_approval(self):

496

510

'replace')))

497

511

for attr in

498

512

self.runtime_expansions)

499

513

500

514

try:

501

515

command = self.checker_command % escaped_attrs

502

516

except TypeError as error:

548

562

raise

549

563

self.checker = None

550

564

565

551

566

def dbus_service_property(dbus_interface, signature="v",

552

567

access="readwrite", byte_arrays=False):

553

568

"""Decorators for marking methods of a DBusObjectWithProperties to

599

614

600

615

class DBusObjectWithProperties(dbus.service.Object):

601

616

"""A D-Bus object with properties.

602

617

603

618

Classes inheriting from this can use the dbus_service_property

604

619

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

605

620

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

616

631

for name, prop in

617

632

inspect.getmembers(self, self._is_dbus_property))

618

633

634

# def _get_dbus_property(self, interface_name, property_name):

635

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

636

# property with the specified name and interface.

637

# """

638

# print("get_property({0!r}, {1!r}".format(interface_name, property_name),file=sys.stderr)

639

# print(dir(self), sys.stderr)

640

# for name in (property_name,

641

# property_name + "_dbus_property"):

642

# prop = getattr(self, name, None)

643

# if (prop is None

644

# or not self._is_dbus_property(prop)

645

# or prop._dbus_name != property_name

646

# or (interface_name and prop._dbus_interface

647

# and interface_name != prop._dbus_interface)):

648

# continue

649

# return prop

650

# # No such property

651

# raise DBusPropertyNotFound(self.dbus_object_path + ":"

652

# + interface_name + "."

653

# + property_name)

654

619

655

def _get_dbus_property(self, interface_name, property_name):

620

656

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

621

657

property with the specified name and interface.

622

658

"""

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

659

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

660

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

661

return value

662

633

663

# No such property

634

664

raise DBusPropertyNotFound(self.dbus_object_path + ":"

635

665

+ interface_name + "."

636

666

+ property_name)

667

637

668

638

669

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

639

670

out_signature="v")

669

700

def GetAll(self, interface_name):

670

701

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

671

702

standard.

672

703

673

704

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

674

705

"""

675

706

all = {}

737

768

return xmlstring

738

769

739

770

771

def datetime_to_dbus (dt, variant_level=0):

772

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

773

if dt is None:

774

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

775

return dbus.String(dt.isoformat(),

776

variant_level=variant_level)

777

778

class transitional_clientdbus(DBusObjectWithProperties.__metaclass__):

779

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

780

for key, old_dbusobj in attr.items():

781

new_interface = getattr(old_dbusobj, "_dbus_interface", "").replace("se.bsnet.fukt.", "se.recompile.")

782

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

783

unwrappedfunc = dict(zip(old_dbusobj.func_code.co_freevars,

784

old_dbusobj.__closure__))["func"].cell_contents

785

newfunc = types.FunctionType(unwrappedfunc.func_code,

786

unwrappedfunc.func_globals,

787

unwrappedfunc.func_name,

788

unwrappedfunc.func_defaults,

789

unwrappedfunc.func_closure)

790

new_dbusfunc = dbus.service.signal(

791

new_interface, old_dbusobj._dbus_signature)(newfunc)

792

attr["_transitional_{0}_1".format(key)] = new_dbusfunc

793

attr["_transitional_{0}_0".format(key)] = old_dbusobj

794

def fixscope(func1, func2):

795

def newcall(*args, **kwargs):

796

func1(*args, **kwargs)

797

func2(*args, **kwargs)

798

return newcall

799

800

attr[key] = fixscope(

801

old_dbusobj, attr["_transitional_{0}_1".format(key)])

802

803

if getattr(old_dbusobj, "_dbus_is_method", False):

804

new_dbusfunc = (dbus.service.method

805

(new_interface,

806

old_dbusobj._dbus_in_signature,

807

old_dbusobj._dbus_out_signature)

808

(types.FunctionType

809

(old_dbusobj.func_code,

810

old_dbusobj.func_globals,

811

old_dbusobj.func_name,

812

old_dbusobj.func_defaults,

813

old_dbusobj.func_closure)))

814

815

attr["_transitional_{0}".format(key)] = new_dbusfunc

816

if getattr(old_dbusobj, "_dbus_is_property", False):

817

new_dbusfunc = (dbus_service_property

818

(new_interface,

819

old_dbusobj._dbus_signature,

820

old_dbusobj._dbus_access,

821

old_dbusobj._dbus_get_args_options["byte_arrays"])

822

(types.FunctionType

823

(old_dbusobj.func_code,

824

old_dbusobj.func_globals,

825

old_dbusobj.func_name,

826

old_dbusobj.func_defaults,

827

old_dbusobj.func_closure)))

828

829

attr["_transitional_{0}".format(key)] = new_dbusfunc

830

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

831

740

832

class ClientDBus(Client, DBusObjectWithProperties):

741

833

"""A Client class using D-Bus

742

834

747

839

748

840

runtime_expansions = (Client.runtime_expansions

749

841

+ ("dbus_object_path",))

842

843

__metaclass__ = transitional_clientdbus

750

844

751

845

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

752

846

764

858

DBusObjectWithProperties.__init__(self, self.bus,

765

859

self.dbus_object_path)

766

860

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)

778

779

approvals_pending = property(_get_approvals_pending,

780

_set_approvals_pending)

781

del _get_approvals_pending, _set_approvals_pending

782

783

@staticmethod

784

def _datetime_to_dbus(dt, variant_level=0):

785

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

786

return dbus.String(dt.isoformat(),

787

variant_level=variant_level)

788

789

def enable(self):

790

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

791

r = Client.enable(self)

792

if oldstate != self.enabled:

793

# Emit D-Bus signals

794

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

795

dbus.Boolean(True, variant_level=1))

796

self.PropertyChanged(

797

dbus.String("LastEnabled"),

798

self._datetime_to_dbus(self.last_enabled,

799

variant_level=1))

800

return r

801

802

def disable(self, quiet = False):

803

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

804

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

805

if not quiet and oldstate != self.enabled:

806

# Emit D-Bus signal

807

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

808

dbus.Boolean(False, variant_level=1))

809

return r

861

def notifychangeproperty(transform_func,

862

dbus_name, type_func=lambda x: x,

863

variant_level=1):

864

""" Modify a variable so that its a property that announce its

865

changes to DBus.

866

transform_fun: Function that takes a value and transform it to

867

DBus type.

868

dbus_name: DBus name of the variable

869

type_func: Function that transform the value before sending it

870

to DBus

871

variant_level: DBus variant level. default: 1

872

"""

873

real_value = [None,]

874

def setter(self, value):

875

old_value = real_value[0]

876

real_value[0] = value

877

if hasattr(self, "dbus_object_path"):

878

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

879

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

880

variant_level)

881

self.PropertyChanged(dbus.String(dbus_name),

882

dbus_value)

883

884

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

885

886

887

expires = notifychangeproperty(datetime_to_dbus, "Expires")

888

approvals_pending = notifychangeproperty(dbus.Boolean,

889

"ApprovalPending",

890

type_func = bool)

891

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

892

last_enabled = notifychangeproperty(datetime_to_dbus,

893

"LastEnabled")

894

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

895

type_func = lambda checker: checker is not None)

896

last_checked_ok = notifychangeproperty(datetime_to_dbus,

897

"LastCheckedOK")

898

last_approval_request = notifychangeproperty(datetime_to_dbus,

899

"LastApprovalRequest")

900

approved_by_default = notifychangeproperty(dbus.Boolean,

901

"ApprovedByDefault")

902

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

903