/mandos/trunk : revision 341

67

from dbus.mainloop.glib import DBusGMainLoop

68

import ctypes

69

import ctypes.util

70

import xml.dom.minidom

71

import inspect

72

70

73

71

try:

74

72

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

79

77

SO_BINDTODEVICE = None

80

78

81

79

82

version = "1.0.14"

80

version = "1.0.8"

83

81

84

82

logger = logging.Logger(u'mandos')

85

83

syslogger = (logging.handlers.SysLogHandler

176

174

self.server.EntryGroupNew()),

177

175

avahi.DBUS_INTERFACE_ENTRY_GROUP)

178

176

self.group.connect_to_signal('StateChanged',

179

self

180

.entry_group_state_changed)

177

self.entry_group_state_changed)

181

178

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

182

179

self.name, self.type)

183

180

self.group.AddService(

249

246

to see if the client lives.

250

247

'None' if no process is running.

251

248

checker_initiator_tag: a gobject event source tag, or None

252

disable_initiator_tag: - '' -

249

disable_initiator_tag: - '' -

253

250

checker_callback_tag: - '' -

254

251

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

255

252

client lives. %() expansions are done at

259

256

"""

260

257

261

258

@staticmethod

262

def _timedelta_to_milliseconds(td):

263

"Convert a datetime.timedelta() to milliseconds"

264

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

265

+ (td.seconds * 1000)

266

+ (td.microseconds // 1000))

259

def _datetime_to_milliseconds(dt):

260

"Convert a datetime.datetime() to milliseconds"

261

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

262

+ (dt.seconds * 1000)

263

+ (dt.microseconds // 1000))

267

264

268

265

def timeout_milliseconds(self):

269

266

"Return the 'timeout' attribute in milliseconds"

270

return self._timedelta_to_milliseconds(self.timeout)

267

return self._datetime_to_milliseconds(self.timeout)

271

268

272

269

def interval_milliseconds(self):

273

270

"Return the 'interval' attribute in milliseconds"

274

return self._timedelta_to_milliseconds(self.interval)

271

return self._datetime_to_milliseconds(self.interval)

275

272

276

273

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

277

274

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

292

289

elif u"secfile" in config:

293

290

with closing(open(os.path.expanduser

294

291

(os.path.expandvars

295

(config[u"secfile"])),

296

"rb")) as secfile:

292

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

297

293

self.secret = secfile.read()

298

294

else:

299

295

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

399

395

# is as it should be.

400

396

401

397

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

402

try:

398

if self.checker is not None:

403

399

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

404

except (AttributeError, OSError), error:

405

if (isinstance(error, OSError)

406

and error.errno != errno.ECHILD):

407

raise error

408

else:

409

400

if pid:

410

401

logger.warning(u"Checker was a zombie")

411

402

gobject.source_remove(self.checker_callback_tag)

486

477

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

487

478

488

479

489

def dbus_service_property(dbus_interface, signature=u"v",

490

access=u"readwrite", byte_arrays=False):

491

"""Decorators for marking methods of a DBusObjectWithProperties to

492

become properties on the D-Bus.

493

494

The decorated method will be called with no arguments by "Get"

495

and with one argument by "Set".

496

497

The parameters, where they are supported, are the same as

498

dbus.service.method, except there is only "signature", since the

499

type from Get() and the type sent to Set() is the same.

500

"""

501

def decorator(func):

502

func._dbus_is_property = True

503

func._dbus_interface = dbus_interface

504

func._dbus_signature = signature

505

func._dbus_access = access

506

func._dbus_name = func.__name__

507

if func._dbus_name.endswith(u"_dbus_property"):

508

func._dbus_name = func._dbus_name[:-14]

509

func._dbus_get_args_options = {u'byte_arrays': byte_arrays }

510

return func

511

return decorator

512

513

514

class DBusPropertyException(dbus.exceptions.DBusException):

515

"""A base class for D-Bus property-related exceptions

516

"""

517

def __unicode__(self):

518

return unicode(str(self))

519

520

521

class DBusPropertyAccessException(DBusPropertyException):

522

"""A property's access permissions disallows an operation.

523

"""

524

pass

525

526

527

class DBusPropertyNotFound(DBusPropertyException):

528

"""An attempt was made to access a non-existing property.

529

"""

530

pass

531

532

533

class DBusObjectWithProperties(dbus.service.Object):

534

"""A D-Bus object with properties.

535

536

Classes inheriting from this can use the dbus_service_property

537

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

538

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

539

"""

540

541

@staticmethod

542

def _is_dbus_property(obj):

543

return getattr(obj, u"_dbus_is_property", False)

544

545

def _get_all_dbus_properties(self):

546

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

547

"""

548

return ((prop._dbus_name, prop)

549

for name, prop in

550

inspect.getmembers(self, self._is_dbus_property))

551

552

def _get_dbus_property(self, interface_name, property_name):

553

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

554

property with the specified name and interface.

555

"""

556

for name in (property_name,

557

property_name + u"_dbus_property"):

558

prop = getattr(self, name, None)

559

if (prop is None

560

or not self._is_dbus_property(prop)

561

or prop._dbus_name != property_name

562

or (interface_name and prop._dbus_interface

563

and interface_name != prop._dbus_interface)):

564

continue

565

return prop

566

# No such property

567

raise DBusPropertyNotFound(self.dbus_object_path + u":"

568

+ interface_name + u"."

569

+ property_name)

570

571

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

572

out_signature=u"v")

573

def Get(self, interface_name, property_name):

574

"""Standard D-Bus property Get() method, see D-Bus standard.

575

"""

576

prop = self._get_dbus_property(interface_name, property_name)

577

if prop._dbus_access == u"write":

578

raise DBusPropertyAccessException(property_name)

579

value = prop()

580

if not hasattr(value, u"variant_level"):

581

return value

582

return type(value)(value, variant_level=value.variant_level+1)

583

584

@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")

585

def Set(self, interface_name, property_name, value):

586

"""Standard D-Bus property Set() method, see D-Bus standard.

587

"""

588

prop = self._get_dbus_property(interface_name, property_name)

589

if prop._dbus_access == u"read":

590

raise DBusPropertyAccessException(property_name)

591

if prop._dbus_get_args_options[u"byte_arrays"]:

592

value = dbus.ByteArray(''.join(unichr(byte)

593

for byte in value))

594

prop(value)

595

596

@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",

597

out_signature=u"a{sv}")

598

def GetAll(self, interface_name):

599

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

600

standard.

601

602

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

603

"""

604

all = {}

605

for name, prop in self._get_all_dbus_properties():

606

if (interface_name

607

and interface_name != prop._dbus_interface):

608

# Interface non-empty but did not match

609

continue

610

# Ignore write-only properties

611

if prop._dbus_access == u"write":

612

continue

613

value = prop()

614

if not hasattr(value, u"variant_level"):

615

all[name] = value

616

continue

617

all[name] = type(value)(value, variant_level=

618

value.variant_level+1)

619

return dbus.Dictionary(all, signature=u"sv")

620

621

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

622

out_signature=u"s",

623

path_keyword='object_path',

624

connection_keyword='connection')

625

def Introspect(self, object_path, connection):

626

"""Standard D-Bus method, overloaded to insert property tags.

627

"""

628

xmlstring = dbus.service.Object.Introspect(self, object_path,

629

connection)

630

try:

631

document = xml.dom.minidom.parseString(xmlstring)

632

def make_tag(document, name, prop):

633

e = document.createElement(u"property")

634

e.setAttribute(u"name", name)

635

e.setAttribute(u"type", prop._dbus_signature)

636

e.setAttribute(u"access", prop._dbus_access)

637

return e

638

for if_tag in document.getElementsByTagName(u"interface"):

639

for tag in (make_tag(document, name, prop)

640

for name, prop

641

in self._get_all_dbus_properties()

642

if prop._dbus_interface

643

== if_tag.getAttribute(u"name")):

644

if_tag.appendChild(tag)

645

# Add the names to the return values for the

646

# "org.freedesktop.DBus.Properties" methods

647

if (if_tag.getAttribute(u"name")

648

== u"org.freedesktop.DBus.Properties"):

649

for cn in if_tag.getElementsByTagName(u"method"):

650

if cn.getAttribute(u"name") == u"Get":

651

for arg in cn.getElementsByTagName(u"arg"):

652

if (arg.getAttribute(u"direction")

653

== u"out"):

654

arg.setAttribute(u"name", u"value")

655

elif cn.getAttribute(u"name") == u"GetAll":

656

for arg in cn.getElementsByTagName(u"arg"):

657

if (arg.getAttribute(u"direction")

658

== u"out"):

659

arg.setAttribute(u"name", u"props")

660

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

661

document.unlink()

662

except (AttributeError, xml.dom.DOMException,

663

xml.parsers.expat.ExpatError), error:

664

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

665

error)

666

return xmlstring

667

668

669

class ClientDBus(Client, DBusObjectWithProperties):

480

class ClientDBus(Client, dbus.service.Object):

670

481

"""A Client class using D-Bus

671

482

672

483

Attributes:

683

494

self.dbus_object_path = (dbus.ObjectPath

684

495

(u"/clients/"

685

496

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

686

DBusObjectWithProperties.__init__(self, self.bus,

687

self.dbus_object_path)

497

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

498

self.dbus_object_path)

688

499

689

500

@staticmethod

690

501

def _datetime_to_dbus(dt, variant_level=0):

719

530

self.remove_from_connection()

720

531

except LookupError:

721

532

pass

722

if hasattr(DBusObjectWithProperties, u"__del__"):

723

DBusObjectWithProperties.__del__(self, *args, **kwargs)

533

if hasattr(dbus.service.Object, u"__del__"):

534

dbus.service.Object.__del__(self, *args, **kwargs)

724

535

Client.__del__(self, *args, **kwargs)

725

536

726

537

def checker_callback(self, pid, condition, command,

800

611

"D-Bus signal"

801

612

pass

802

613

614

# GetAllProperties - method

615

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

616

def GetAllProperties(self):

617

"D-Bus method"

618

return dbus.Dictionary({

619

dbus.String(u"name"):

620

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

621

dbus.String(u"fingerprint"):

622

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

623

dbus.String(u"host"):

624

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

625

dbus.String(u"created"):

626

self._datetime_to_dbus(self.created,

627

variant_level=1),

628

dbus.String(u"last_enabled"):

629

(self._datetime_to_dbus(self.last_enabled,

630

variant_level=1)

631

if self.last_enabled is not None

632

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

633

dbus.String(u"enabled"):

634

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

635

dbus.String(u"last_checked_ok"):

636

(self._datetime_to_dbus(self.last_checked_ok,

637

variant_level=1)

638

if self.last_checked_ok is not None

639

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

640

dbus.String(u"timeout"):

641

dbus.UInt64(self.timeout_milliseconds(),

642

variant_level=1),

643

dbus.String(u"interval"):

644

dbus.UInt64(self.interval_milliseconds(),

645

variant_level=1),

646

dbus.String(u"checker"):

647

dbus.String(self.checker_command,

648

variant_level=1),

649

dbus.String(u"checker_running"):

650

dbus.Boolean(self.checker is not None,

651

variant_level=1),

652

dbus.String(u"object_path"):

653

dbus.ObjectPath(self.dbus_object_path,

654

variant_level=1)

655

}, signature=u"sv")

656

657

# IsStillValid - method

658

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

659

def IsStillValid(self):

660

return self.still_valid()

661

803

662

# PropertyChanged - signal

804

663

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

805

664

def PropertyChanged(self, property, value):

806

665

"D-Bus signal"

807

666

pass

808

667

809

# GotSecret - signal

668

# ReceivedSecret - signal

810

669

@dbus.service.signal(_interface)

811

def GotSecret(self):

670

def ReceivedSecret(self):

812

671

"D-Bus signal"

813

672

pass

814

673

818

677

"D-Bus signal"

819

678

pass

820

679

680

# SetChecker - method

681

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

682

def SetChecker(self, checker):

683

"D-Bus setter method"

684

self.checker_command = checker

685

# Emit D-Bus signal

686

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

687

dbus.String(self.checker_command,

688

variant_level=1))

689

690

# SetHost - method

691

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

692

def SetHost(self, host):

693

"D-Bus setter method"

694

self.host = host

695

# Emit D-Bus signal

696

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

697

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

698

699

# SetInterval - method

700

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

701

def SetInterval(self, milliseconds):

702

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

703

# Emit D-Bus signal

704

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

705

(dbus.UInt64(self.interval_milliseconds(),

706

variant_level=1)))

707

708

# SetSecret - method

709

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

710

byte_arrays=True)

711

def SetSecret(self, secret):

712

"D-Bus setter method"

713

self.secret = str(secret)

714

715

# SetTimeout - method

716

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

717

def SetTimeout(self, milliseconds):

718

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

719

# Emit D-Bus signal

720

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

721

(dbus.UInt64(self.timeout_milliseconds(),

722

variant_level=1)))

723

821

724

# Enable - method

822

725

@dbus.service.method(_interface)

823

726

def Enable(self):

841

744

def StopChecker(self):

842

745

self.stop_checker()

843

746

844

# name - property

845

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

846

def name_dbus_property(self):

847

return dbus.String(self.name)

848

849

# fingerprint - property

850

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

851

def fingerprint_dbus_property(self):

852

return dbus.String(self.fingerprint)

853

854

# host - property

855

@dbus_service_property(_interface, signature=u"s",

856

access=u"readwrite")

857

def host_dbus_property(self, value=None):

858

if value is None: # get

859

return dbus.String(self.host)

860

self.host = value

861

# Emit D-Bus signal

862

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

863

dbus.String(value, variant_level=1))

864

865

# created - property

866

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

867

def created_dbus_property(self):

868

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

869

870

# last_enabled - property

871

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

872

def last_enabled_dbus_property(self):

873

if self.last_enabled is None:

874

return dbus.String(u"")

875

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

876

877

# enabled - property

878

@dbus_service_property(_interface, signature=u"b",

879

access=u"readwrite")

880

def enabled_dbus_property(self, value=None):

881

if value is None: # get

882

return dbus.Boolean(self.enabled)

883

if value:

884

self.enable()

885

else:

886

self.disable()

887

888

# last_checked_ok - property

889

@dbus_service_property(_interface, signature=u"s",

890

access=u"readwrite")

891

def last_checked_ok_dbus_property(self, value=None):

892

if value is not None:

893

self.checked_ok()

894

return

895

if self.last_checked_ok is None:

896

return dbus.String(u"")

897

return dbus.String(self._datetime_to_dbus(self

898

.last_checked_ok))

899

900

# timeout - property

901

@dbus_service_property(_interface, signature=u"t",

902

access=u"readwrite")

903

def timeout_dbus_property(self, value=None):

904

if value is None: # get

905

return dbus.UInt64(self.timeout_milliseconds())

906

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

907

# Emit D-Bus signal

908

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

909

dbus.UInt64(value, variant_level=1))

910

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

911

return

912

# Reschedule timeout

913

gobject.source_remove(self.disable_initiator_tag)

914

self.disable_initiator_tag = None

915

time_to_die = (self.

916

_timedelta_to_milliseconds((self

917

.last_checked_ok

918

+ self.timeout)

919

- datetime.datetime

920

.utcnow()))

921

if time_to_die <= 0:

922

# The timeout has passed

923

self.disable()

924

else:

925

self.disable_initiator_tag = (gobject.timeout_add

926

(time_to_die, self.disable))

927

928

# interval - property

929

@dbus_service_property(_interface, signature=u"t",

930

access=u"readwrite")

931

def interval_dbus_property(self, value=None):

932

if value is None: # get

933

return dbus.UInt64(self.interval_milliseconds())

934

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

935

# Emit D-Bus signal

936

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

937

dbus.UInt64(value, variant_level=1))

938

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

939

return

940

# Reschedule checker run

941

gobject.source_remove(self.checker_initiator_tag)

942

self.checker_initiator_tag = (gobject.timeout_add

943

(value, self.start_checker))

944

self.start_checker() # Start one now, too

945

946

# checker - property

947

@dbus_service_property(_interface, signature=u"s",

948

access=u"readwrite")

949

def checker_dbus_property(self, value=None):

950

if value is None: # get

951

return dbus.String(self.checker_command)

952

self.checker_command = value

953

# Emit D-Bus signal

954

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

955

dbus.String(self.checker_command,

956

variant_level=1))

957

958

# checker_running - property

959

@dbus_service_property(_interface, signature=u"b",

960

access=u"readwrite")

961

def checker_running_dbus_property(self, value=None):

962

if value is None: # get

963

return dbus.Boolean(self.checker is not None)

964

if value:

965

self.start_checker()

966

else:

967

self.stop_checker()

968

969

# object_path - property

970

@dbus_service_property(_interface, signature=u"o", access=u"read")

971

def object_path_dbus_property(self):

972

return self.dbus_object_path # is already a dbus.ObjectPath

973

974

# secret = property

975

@dbus_service_property(_interface, signature=u"ay",

976

access=u"write", byte_arrays=True)

977

def secret_dbus_property(self, value):

978

self.secret = str(value)

979

980

747

del _interface

981

748

982

749

1044

811

client = c

1045

812

break

1046

813

else:

1047

ipc.write(u"NOTFOUND %s %s\n"

1048

% (fpr, unicode(self.client_address)))

814

ipc.write(u"NOTFOUND %s\n" % fpr)

1049

815

session.bye()

1050

816

return

1051

817

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

1134

900

def process_request(self, request, client_address):

1135

901

"""Overrides and wraps the original process_request().

1136

902

1137

This function creates a new pipe in self.pipe

903

This function creates a new pipe in self.pipe

1138

904

"""

1139

905

self.pipe = os.pipe()

1140

906

super(ForkingMixInWithPipe,

1216

982

clients: set of Client objects

1217

983

gnutls_priority GnuTLS priority string

1218

984

use_dbus: Boolean; to emit D-Bus signals or not

985

clients: set of Client objects

986

gnutls_priority GnuTLS priority string

987

use_dbus: Boolean; to emit D-Bus signals or not

1219

988

1220

989

Assumes a gobject.MainLoop event loop.

1221

990

"""

1301

1070

client.checked_ok()

1302

1071

if self.use_dbus:

1303

1072

# Emit D-Bus signal

1304

client.GotSecret()

1073

client.ReceivedSecret()

1305

1074

break

1306

1075

else:

1307

1076

logger.error(u"Sending secret to unknown client %s",

1392

1161

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

1393

1162

if not stat.S_ISCHR(os.fstat(null).st_mode):

1394

1163

raise OSError(errno.ENODEV,

1395

u"%s not a character device"

1396

% os.path.devnull)

1164

u"/dev/null not a character device")

1397

1165

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

1398

1166

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

1399

1167

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

1403

1171

1404

1172

def main():

1405

1173

1406

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

1174

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

1407

1175

# Parsing of options, both command line and config file

1408

1176

1409

1177

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

1659

1427

def GetAllClientsWithProperties(self):

1660

1428

"D-Bus method"

1661

1429

return dbus.Dictionary(

1662

((c.dbus_object_path, c.GetAll(u""))

1430

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

1663

1431

for c in tcp_server.clients),

1664

1432

signature=u"oa{sv}")

1665

1433

1685

1453

if use_dbus:

1686

1454

# Emit D-Bus signal

1687

1455

mandos_dbus_service.ClientAdded(client.dbus_object_path,

1688

client.GetAll(u""))

1456

client.GetAllProperties())

1689

1457

client.enable()

1690

1458

1691

1459

tcp_server.enable()