/mandos/release : revision 325

842

access="r")

843

def Property_dbus_property(self):

844

return dbus.Boolean(False)

845

846

See also the DBusObjectWithAnnotations class.

845

847

"""

846

848

847

849

def decorator(func):

869

871

pass

870

872

871

873

872

class DBusObjectWithProperties(dbus.service.Object):

873

"""A D-Bus object with properties.

874

class DBusObjectWithAnnotations(dbus.service.Object):

875

"""A D-Bus object with annotations.

874

876

875

Classes inheriting from this can use the dbus_service_property

876

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

877

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

877

Classes inheriting from this can use the dbus_annotations

878

decorator to add annotations to methods or signals.

878

879

"""

879

880

881

@staticmethod

896

897

for name, athing in

897

898

inspect.getmembers(cls, self._is_dbus_thing(thing)))

898

899

900

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

901

out_signature = "s",

902

path_keyword = 'object_path',

903

connection_keyword = 'connection')

904

def Introspect(self, object_path, connection):

905

"""Overloading of standard D-Bus method.

906

907

Inserts annotation tags on methods and signals.

908

"""

909

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

910

connection)

911

try:

912

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

913

914

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

915

# Add annotation tags

916

for typ in ("method", "signal"):

917

for tag in if_tag.getElementsByTagName(typ):

918

annots = dict()

919

for name, prop in (self.

920

_get_all_dbus_things(typ)):

921

if (name == tag.getAttribute("name")

922

and prop._dbus_interface

923

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

924

annots.update(getattr(

925

prop, "_dbus_annotations", {}))

926

for name, value in annots.items():

927

ann_tag = document.createElement(

928

"annotation")

929

ann_tag.setAttribute("name", name)

930

ann_tag.setAttribute("value", value)

931

tag.appendChild(ann_tag)

932

# Add interface annotation tags

933

for annotation, value in dict(

934

itertools.chain.from_iterable(

935

annotations().items()

936

for name, annotations

937

in self._get_all_dbus_things("interface")

938

if name == if_tag.getAttribute("name")

939

)).items():

940

ann_tag = document.createElement("annotation")

941

ann_tag.setAttribute("name", annotation)

942

ann_tag.setAttribute("value", value)

943

if_tag.appendChild(ann_tag)

944

# Fix argument name for the Introspect method itself

945

if (if_tag.getAttribute("name")

946

== dbus.INTROSPECTABLE_IFACE):

947

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

948

if cn.getAttribute("name") == "Introspect":

949

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

950

if (arg.getAttribute("direction")

951

== "out"):

952

arg.setAttribute("name",

953

"xml_data")

954

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

955

document.unlink()

956

except (AttributeError, xml.dom.DOMException,

957

xml.parsers.expat.ExpatError) as error:

958

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

959

exc_info=error)

960

return xmlstring

961

962

963

class DBusObjectWithProperties(DBusObjectWithAnnotations):

964

"""A D-Bus object with properties.

965

966

Classes inheriting from this can use the dbus_service_property

967

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

968

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

969

"""

970

899

971

def _get_dbus_property(self, interface_name, property_name):

900

972

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

901

973

property with the specified name and interface.

911

983

raise DBusPropertyNotFound("{}:{}.{}".format(

912

984

self.dbus_object_path, interface_name, property_name))

913

985

986

@classmethod

987

def _get_all_interface_names(cls):

988

"""Get a sequence of all interfaces supported by an object"""

989

return (name for name in set(getattr(getattr(x, attr),

990

"_dbus_interface", None)

991

for x in (inspect.getmro(cls))

992

for attr in dir(x))

993

if name is not None)

994

914

995

@dbus.service.method(dbus.PROPERTIES_IFACE,

915

996

in_signature="ss",

916

997

out_signature="v")

986

1067

987

1068

Inserts property tags and interface annotation tags.

988

1069

"""

989

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

990

connection)

1070

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1071

object_path,

1072

connection)

991

1073

try:

992

1074

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

993

1075

1006

1088

if prop._dbus_interface

1007

1089

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

1008

1090

if_tag.appendChild(tag)

1009

# Add annotation tags

1010

for typ in ("method", "signal", "property"):

1011

for tag in if_tag.getElementsByTagName(typ):

1012

annots = dict()

1013

for name, prop in (self.

1014

_get_all_dbus_things(typ)):

1015

if (name == tag.getAttribute("name")

1016

and prop._dbus_interface

1017

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

1018

annots.update(getattr(

1019

prop, "_dbus_annotations", {}))

1020

for name, value in annots.items():

1021

ann_tag = document.createElement(

1022

"annotation")

1023

ann_tag.setAttribute("name", name)

1024

ann_tag.setAttribute("value", value)

1025

tag.appendChild(ann_tag)

1026

# Add interface annotation tags

1027

for annotation, value in dict(

1028

itertools.chain.from_iterable(

1029

annotations().items()

1030

for name, annotations

1031

in self._get_all_dbus_things("interface")

1032

if name == if_tag.getAttribute("name")

1033

)).items():

1034

ann_tag = document.createElement("annotation")

1035

ann_tag.setAttribute("name", annotation)

1036

ann_tag.setAttribute("value", value)

1037

if_tag.appendChild(ann_tag)

1091

# Add annotation tags for properties

1092

for tag in if_tag.getElementsByTagName("property"):

1093

annots = dict()

1094

for name, prop in self._get_all_dbus_things(

1095

"property"):

1096

if (name == tag.getAttribute("name")

1097

and prop._dbus_interface

1098

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

1099

annots.update(getattr(

1100

prop, "_dbus_annotations", {}))

1101

for name, value in annots.items():

1102

ann_tag = document.createElement(

1103

"annotation")

1104

ann_tag.setAttribute("name", name)

1105

ann_tag.setAttribute("value", value)

1106

tag.appendChild(ann_tag)

1038

1107

# Add the names to the return values for the

1039

1108

# "org.freedesktop.DBus.Properties" methods

1040

1109

if (if_tag.getAttribute("name")

1058

1127

exc_info=error)

1059

1128

return xmlstring

1060

1129

1130

try:

1131

dbus.OBJECT_MANAGER_IFACE

1132

except AttributeError:

1133

dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"

1134

1135

class DBusObjectWithObjectManager(DBusObjectWithAnnotations):

1136

"""A D-Bus object with an ObjectManager.

1137

1138

Classes inheriting from this exposes the standard

1139

GetManagedObjects call and the InterfacesAdded and

1140

InterfacesRemoved signals on the standard

1141

"org.freedesktop.DBus.ObjectManager" interface.

1142

1143

Note: No signals are sent automatically; they must be sent

1144

manually.

1145

"""

1146

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

1147

out_signature = "a{oa{sa{sv}}}")

1148

def GetManagedObjects(self):

1149

"""This function must be overridden"""

1150

raise NotImplementedError()

1151

1152

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,

1153

signature = "oa{sa{sv}}")

1154

def InterfacesAdded(self, object_path, interfaces_and_properties):

1155

pass

1156

1157

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature = "oas")

1158

def InterfacesRemoved(self, object_path, interfaces):

1159

pass

1160

1161

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1162

out_signature = "s",

1163

path_keyword = 'object_path',

1164

connection_keyword = 'connection')

1165

def Introspect(self, object_path, connection):

1166

"""Overloading of standard D-Bus method.

1167

1168

Override return argument name of GetManagedObjects to be

1169

"objpath_interfaces_and_properties"

1170

"""

1171

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1172

object_path,

1173

connection)

1174

try:

1175

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

1176

1177

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

1178

# Fix argument name for the GetManagedObjects method

1179

if (if_tag.getAttribute("name")

1180

== dbus.OBJECT_MANAGER_IFACE):

1181

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

1182

if (cn.getAttribute("name")

1183

== "GetManagedObjects"):

1184

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

1185

if (arg.getAttribute("direction")

1186

== "out"):

1187

arg.setAttribute(

1188

"name",

1189

"objpath_interfaces"

1190

"_and_properties")

1191

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

1192

document.unlink()

1193

except (AttributeError, xml.dom.DOMException,

1194

xml.parsers.expat.ExpatError) as error:

1195

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

1196

exc_info = error)

1197

return xmlstring

1061

1198

1062

1199

def datetime_to_dbus(dt, variant_level=0):

1063

1200

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

1154

1291

func1 and func2 to the "call_both" function

1155

1292

outside of its arguments"""

1156

1293

1294

@functools.wraps(func2)

1157

1295

def call_both(*args, **kwargs):

1158

1296

"""This function will emit two D-Bus

1159

1297

signals by calling func1 and func2"""

1160

1298

func1(*args, **kwargs)

1161

1299

func2(*args, **kwargs)

1300

# Make wrapper function look like a D-Bus signal

1301

for name, attr in inspect.getmembers(func2):

1302

if name.startswith("_dbus_"):

1303

setattr(call_both, name, attr)

1162

1304

1163

1305

return call_both

1164

1306

# Create the "call_both" function and add it to

1376

1518

if exitstatus >= 0:

1377

1519

# Emit D-Bus signal

1378

1520

self.CheckerCompleted(dbus.Int16(exitstatus),

1379

dbus.Int64(0),

1521

# This is specific to GNU libC

1522

dbus.Int64(exitstatus << 8),

1380

1523

dbus.String(command))

1381

1524

else:

1382

1525

# Emit D-Bus signal

1383

1526

self.CheckerCompleted(dbus.Int16(-1),

1384

1527

dbus.Int64(

1385

self.last_checker_signal),

1528

# This is specific to GNU libC

1529

(exitstatus << 8)

1530

| self.last_checker_signal),

1386

1531

dbus.String(command))

1387

1532

return ret

1388

1533

1465

1610

self.checked_ok()

1466

1611

1467

1612

# Enable - method

1613

@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})

1468

1614

@dbus.service.method(_interface)

1469

1615

def Enable(self):

1470

1616

"D-Bus method"

1471

1617

self.enable()

1472

1618

1473

1619

# StartChecker - method

1620

@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})

1474

1621

@dbus.service.method(_interface)

1475

1622

def StartChecker(self):

1476

1623

"D-Bus method"

1477

1624

self.start_checker()

1478

1625

1479

1626

# Disable - method

1627

@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})

1480

1628

@dbus.service.method(_interface)

1481

1629

def Disable(self):

1482

1630

"D-Bus method"

1483

1631

self.disable()

1484

1632

1485

1633

# StopChecker - method

1634

@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})

1486

1635

@dbus.service.method(_interface)

1487

1636

def StopChecker(self):

1488

1637

self.stop_checker()

1524

1673

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

1525

1674

1526

1675

# Name - property

1676

@dbus_annotations(

1677

{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})

1527

1678

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

1528

1679

def Name_dbus_property(self):

1529

1680

return dbus.String(self.name)

1530

1681

1531

1682

# Fingerprint - property

1683

@dbus_annotations(

1684

{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})

1532

1685

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

1533

1686

def Fingerprint_dbus_property(self):

1534

1687

return dbus.String(self.fingerprint)

1543

1696

self.host = str(value)

1544

1697

1545

1698

# Created - property

1699

@dbus_annotations(

1700

{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})

1546

1701

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

1547

1702

def Created_dbus_property(self):

1548

1703

return datetime_to_dbus(self.created)

1663

1818

self.stop_checker()

1664

1819

1665

1820

# ObjectPath - property

1821

@dbus_annotations(

1822

{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",

1823

"org.freedesktop.DBus.Deprecated": "true"})

1666

1824

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

1667

1825

def ObjectPath_dbus_property(self):

1668

1826

return self.dbus_object_path # is already a dbus.ObjectPath

1669

1827

1670

1828

# Secret = property

1829

@dbus_annotations(

1830

{"org.freedesktop.DBus.Property.EmitsChangedSignal":

1831

"invalidates"})

1671

1832

@dbus_service_property(_interface,

1672

1833

signature="ay",

1673

1834

access="write",

2734

2895

2735

2896

@alternate_dbus_interfaces(

2736

2897

{ "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })

2737

class MandosDBusService(DBusObjectWithProperties):

2898

class MandosDBusService(DBusObjectWithObjectManager):

2738

2899

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

2739

2900

2740

2901

def __init__(self):

2742

2903

2743

2904

_interface = "se.recompile.Mandos"

2744

2905

2745

@dbus_interface_annotations(_interface)

2746

def _foo(self):

2747

return {

2748

"org.freedesktop.DBus.Property.EmitsChangedSignal":

2749

"false" }

2750

2751

2906

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

2752

2907

def ClientAdded(self, objpath):

2753

2908

"D-Bus signal"

2758

2913

"D-Bus signal"

2759

2914

pass

2760

2915

2916

@dbus_annotations({"org.freedesktop.DBus.Deprecated":

2917

"true"})

2761

2918

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

2762

2919

def ClientRemoved(self, objpath, name):

2763

2920

"D-Bus signal"

2764

2921

pass

2765

2922

2923

@dbus_annotations({"org.freedesktop.DBus.Deprecated":

2924

"true"})

2766

2925

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

2767

2926

def GetAllClients(self):

2768

2927

"D-Bus method"

2769

2928

return dbus.Array(c.dbus_object_path for c in

2770

2929

tcp_server.clients.itervalues())

2771

2930

2931

@dbus_annotations({"org.freedesktop.DBus.Deprecated":

2932

"true"})

2772

2933

@dbus.service.method(_interface,

2773

2934

out_signature="a{oa{sv}}")

2774

2935

def GetAllClientsWithProperties(self):

2775

2936

"D-Bus method"

2776

2937

return dbus.Dictionary(

2777

{ c.dbus_object_path: c.GetAll("")

2938

{ c.dbus_object_path: c.GetAll(

2939

"se.recompile.Mandos.Client")

2778

2940

for c in tcp_server.clients.itervalues() },

2779

2941

signature="oa{sv}")

2780

2942

2785

2947

if c.dbus_object_path == object_path:

2786

2948

del tcp_server.clients[c.name]

2787

2949

c.remove_from_connection()

2788

# Don't signal anything except ClientRemoved

2950

# Don't signal the disabling

2789

2951

c.disable(quiet=True)

2790

# Emit D-Bus signal

2791

self.ClientRemoved(object_path, c.name)

2952

# Emit D-Bus signal for removal

2953

self.client_removed_signal(c)

2792

2954

return

2793

2955

raise KeyError(object_path)

2794

2956

2795

2957

del _interface

2958

2959

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

2960

out_signature = "a{oa{sa{sv}}}")

2961

def GetManagedObjects(self):

2962

"""D-Bus method"""

2963

return dbus.Dictionary(

2964

{ client.dbus_object_path:

2965

dbus.Dictionary(

2966

{ interface: client.GetAll(interface)

2967

for interface in

2968

client._get_all_interface_names()})

2969

for client in tcp_server.clients.values()})

2970

2971

def client_added_signal(self, client):

2972

"""Send the new standard signal and the old signal"""

2973

if use_dbus:

2974

# New standard signal

2975

self.InterfacesAdded(

2976

client.dbus_object_path,

2977

dbus.Dictionary(

2978

{ interface: client.GetAll(interface)

2979

for interface in

2980

client._get_all_interface_names()}))

2981

# Old signal

2982

self.ClientAdded(client.dbus_object_path)

2983

2984

def client_removed_signal(self, client):

2985

"""Send the new standard signal and the old signal"""

2986

if use_dbus:

2987

# New standard signal

2988

self.InterfacesRemoved(

2989

client.dbus_object_path,

2990

client._get_all_interface_names())

2991

# Old signal

2992

self.ClientRemoved(client.dbus_object_path,

2993

client.name)

2796

2994

2797

2995

mandos_dbus_service = MandosDBusService()

2798

2996

2863

3061

name, client = tcp_server.clients.popitem()

2864

3062

if use_dbus:

2865

3063

client.remove_from_connection()

2866

# Don't signal anything except ClientRemoved

3064

# Don't signal the disabling

2867

3065

client.disable(quiet=True)

2868

if use_dbus:

2869

# Emit D-Bus signal

2870

mandos_dbus_service.ClientRemoved(

2871

client.dbus_object_path, client.name)

3066

# Emit D-Bus signal for removal

3067

mandos_dbus_service.client_removed_signal(client)

2872

3068

client_settings.clear()

2873

3069

2874

3070

atexit.register(cleanup)

2875

3071

2876

3072

for client in tcp_server.clients.itervalues():

2877

3073

if use_dbus:

2878

# Emit D-Bus signal

2879

mandos_dbus_service.ClientAdded(client.dbus_object_path)

3074

# Emit D-Bus signal for adding

3075

mandos_dbus_service.client_added_signal(client)

2880

3076

# Need to initiate checking of clients

2881

3077

if client.enabled:

2882

3078

client.init_checker()