/mandos/trunk : revision 752

395

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

396

self.cleanup()

397

elif state == avahi.SERVER_RUNNING:

398

try:

399

self.add()

400

except dbus.exceptions.DBusException as error:

401

if (error.get_dbus_name()

402

== "org.freedesktop.Avahi.CollisionError"):

403

logger.info("Local Zeroconf service name"

404

" collision.")

405

return self.rename(remove=False)

406

else:

407

logger.critical("D-Bus Exception", exc_info=error)

408

self.cleanup()

409

os._exit(1)

398

self.add()

410

399

else:

411

400

if error is None:

412

401

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

435

424

.format(self.name)))

436

425

return ret

437

426

438

def call_pipe(connection, # : multiprocessing.Connection

439

func, *args, **kwargs):

440

"""This function is meant to be called by multiprocessing.Process

441

442

This function runs func(*args, **kwargs), and writes the resulting

443

return value on the provided multiprocessing.Connection.

444

"""

445

connection.send(func(*args, **kwargs))

446

connection.close()

447

427

448

428

class Client(object):

449

429

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

476

456

last_checker_status: integer between 0 and 255 reflecting exit

477

457

status of last checker. -1 reflects crashed

478

458

checker, -2 means no checker completed yet.

479

last_checker_signal: The signal which killed the last checker, if

480

last_checker_status is -1

481

459

last_enabled: datetime.datetime(); (UTC) or None

482

460

name: string; from the config file, used in log messages and

483

461

D-Bus identifiers

657

635

# Also start a new checker *right now*.

658

636

self.start_checker()

659

637

660

def checker_callback(self, source, condition, connection,

661

command):

638

def checker_callback(self, pid, condition, command):

662

639

"""The checker has completed, so take appropriate actions."""

663

640

self.checker_callback_tag = None

664

641

self.checker = None

665

# Read return code from connection (see call_pipe)

666

returncode = connection.recv()

667

connection.close()

668

669

if returncode >= 0:

670

self.last_checker_status = returncode

671

self.last_checker_signal = None

642

if os.WIFEXITED(condition):

643

self.last_checker_status = os.WEXITSTATUS(condition)

672

644

if self.last_checker_status == 0:

673

645

logger.info("Checker for %(name)s succeeded",

674

646

vars(self))

677

649

logger.info("Checker for %(name)s failed", vars(self))

678

650

else:

679

651

self.last_checker_status = -1

680

self.last_checker_signal = -returncode

681

652

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

682

653

vars(self))

683

return False

684

654

685

655

def checked_ok(self):

686

656

"""Assert that the client has been seen, alive and well."""

687

657

self.last_checked_ok = datetime.datetime.utcnow()

688

658

self.last_checker_status = 0

689

self.last_checker_signal = None

690

659

self.bump_timeout()

691

660

692

661

def bump_timeout(self, timeout=None):

718

687

# than 'timeout' for the client to be disabled, which is as it

719

688

# should be.

720

689

721

if self.checker is not None and not self.checker.is_alive():

722

logger.warning("Checker was not alive; joining")

723

self.checker.join()

724

self.checker = None

690

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

691

try:

692

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

693

except AttributeError:

694

pass

695

except OSError as error:

696

if error.errno != errno.ECHILD:

697

raise

698

else:

699

if pid:

700

logger.warning("Checker was a zombie")

701

gobject.source_remove(self.checker_callback_tag)

702

self.checker_callback(pid, status,

703

self.current_checker_command)

725

704

# Start a new checker if needed

726

705

if self.checker is None:

727

706

# Escape attributes for the shell

736

715

exc_info=error)

737

716

return True # Try again later

738

717

self.current_checker_command = command

739

logger.info("Starting checker %r for %s", command,

740

self.name)

741

# We don't need to redirect stdout and stderr, since

742

# in normal mode, that is already done by daemon(),

743

# and in debug mode we don't want to. (Stdin is

744

# always replaced by /dev/null.)

745

# The exception is when not debugging but nevertheless

746

# running in the foreground; use the previously

747

# created wnull.

748

popen_args = { "close_fds": True,

749

"shell": True,

750

"cwd": "/" }

751

if (not self.server_settings["debug"]

752

and self.server_settings["foreground"]):

753

popen_args.update({"stdout": wnull,

754

"stderr": wnull })

755

pipe = multiprocessing.Pipe(duplex = False)

756

self.checker = multiprocessing.Process(

757

target = call_pipe,

758

args = (pipe[1], subprocess.call, command),

759

kwargs = popen_args)

760

self.checker.start()

761

self.checker_callback_tag = gobject.io_add_watch(

762

pipe[0].fileno(), gobject.IO_IN,

763

self.checker_callback, pipe[0], command)

718

try:

719

logger.info("Starting checker %r for %s", command,

720

self.name)

721

# We don't need to redirect stdout and stderr, since

722

# in normal mode, that is already done by daemon(),

723

# and in debug mode we don't want to. (Stdin is

724

# always replaced by /dev/null.)

725

# The exception is when not debugging but nevertheless

726

# running in the foreground; use the previously

727

# created wnull.

728

popen_args = {}

729

if (not self.server_settings["debug"]

730

and self.server_settings["foreground"]):

731

popen_args.update({"stdout": wnull,

732

"stderr": wnull })

733

self.checker = subprocess.Popen(command,

734

close_fds=True,

735

shell=True,

736

cwd="/",

737

**popen_args)

738

except OSError as error:

739

logger.error("Failed to start subprocess",

740

exc_info=error)

741

return True

742

self.checker_callback_tag = gobject.child_watch_add(

743

self.checker.pid, self.checker_callback, data=command)

744

# The checker may have completed before the gobject

745

# watch was added. Check for this.

746

try:

747

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

748

except OSError as error:

749

if error.errno == errno.ECHILD:

750

# This should never happen

751

logger.error("Child process vanished",

752

exc_info=error)

753

return True

754

raise

755

if pid:

756

gobject.source_remove(self.checker_callback_tag)

757

self.checker_callback(pid, status, command)

764

758

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

765

759

return True

766

760

772

766

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

773

767

return

774

768

logger.debug("Stopping checker for %(name)s", vars(self))

775

self.checker.terminate()

769

try:

770

self.checker.terminate()

771

#time.sleep(0.5)

772

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

773

# self.checker.kill()

774

except OSError as error:

775

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

776

raise

776

777

self.checker = None

777

778

779

842

843

access="r")

843

844

def Property_dbus_property(self):

844

845

return dbus.Boolean(False)

845

846

See also the DBusObjectWithAnnotations class.

847

846

"""

848

847

849

848

def decorator(func):

871

870

pass

872

871

873

872

874

class DBusObjectWithAnnotations(dbus.service.Object):

875

"""A D-Bus object with annotations.

873

class DBusObjectWithProperties(dbus.service.Object):

874

"""A D-Bus object with properties.

876

875

877

Classes inheriting from this can use the dbus_annotations

878

decorator to add annotations to methods or signals.

876

Classes inheriting from this can use the dbus_service_property

877

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

878

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

879

"""

880

881

@staticmethod

897

for name, athing in

898

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

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

971

900

def _get_dbus_property(self, interface_name, property_name):

972

901

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

973

902

property with the specified name and interface.

983

912

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

984

913

self.dbus_object_path, interface_name, property_name))

985

914

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

995

915

@dbus.service.method(dbus.PROPERTIES_IFACE,

996

916

in_signature="ss",

997

917

out_signature="v")

1067

987

1068

988

Inserts property tags and interface annotation tags.

1069

989

"""

1070

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1071

object_path,

1072

connection)

990

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

991

connection)

1073

992

try:

1074

993

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

1075

994

1088

1007

if prop._dbus_interface

1089

1008

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

1090

1009

if_tag.appendChild(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)

1010

# Add annotation tags

1011

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

1012

for tag in if_tag.getElementsByTagName(typ):

1013

annots = dict()

1014

for name, prop in (self.

1015

_get_all_dbus_things(typ)):

1016

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

1017

and prop._dbus_interface

1018

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

1019

annots.update(getattr(

1020

prop, "_dbus_annotations", {}))

1021

for name, value in annots.items():

1022

ann_tag = document.createElement(

1023

"annotation")

1024

ann_tag.setAttribute("name", name)

1025

ann_tag.setAttribute("value", value)

1026

tag.appendChild(ann_tag)

1027

# Add interface annotation tags

1028

for annotation, value in dict(

1029

itertools.chain.from_iterable(

1030

annotations().items()

1031

for name, annotations

1032

in self._get_all_dbus_things("interface")

1033

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

1034

)).items():

1035

ann_tag = document.createElement("annotation")

1036

ann_tag.setAttribute("name", annotation)

1037

ann_tag.setAttribute("value", value)

1038

if_tag.appendChild(ann_tag)

1107

1039

# Add the names to the return values for the

1108

1040

# "org.freedesktop.DBus.Properties" methods

1109

1041

if (if_tag.getAttribute("name")

1127

1059

exc_info=error)

1128

1060

return xmlstring

1129

1061

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,

1158

signature = "oas")

1159

def InterfacesRemoved(self, object_path, interfaces):

1160

pass

1161

1162

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1163

out_signature = "s",

1164

path_keyword = 'object_path',

1165

connection_keyword = 'connection')

1166

def Introspect(self, object_path, connection):

1167

"""Overloading of standard D-Bus method.

1168

1169

Override return argument name of GetManagedObjects to be

1170

"objpath_interfaces_and_properties"

1171

"""

1172

xmlstring = DBusObjectWithAnnotations(self, 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

1198

1062

1199

1063

def datetime_to_dbus(dt, variant_level=0):

1200

1064

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

1247

1111

interface_names.add(alt_interface)

1248

1112

# Is this a D-Bus signal?

1249

1113

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

1250

if sys.version_info.major == 2:

1251

# Extract the original non-method undecorated

1252

# function by black magic

1253

nonmethod_func = (dict(

1254

zip(attribute.func_code.co_freevars,

1255

attribute.__closure__))

1256

["func"].cell_contents)

1257

else:

1258

nonmethod_func = attribute

1114

# Extract the original non-method undecorated

1115

# function by black magic

1116

nonmethod_func = (dict(

1117

zip(attribute.func_code.co_freevars,

1118

attribute.__closure__))

1119

["func"].cell_contents)

1259

1120

# Create a new, but exactly alike, function

1260

1121

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

1261

1122

# with the alternate D-Bus interface name

1262

if sys.version_info.major == 2:

1263

new_function = types.FunctionType(

1264

nonmethod_func.func_code,

1265

nonmethod_func.func_globals,

1266

nonmethod_func.func_name,

1267

nonmethod_func.func_defaults,

1268

nonmethod_func.func_closure)

1269

else:

1270

new_function = types.FunctionType(

1271

nonmethod_func.__code__,

1272

nonmethod_func.__globals__,

1273

nonmethod_func.__name__,

1274

nonmethod_func.__defaults__,

1275

nonmethod_func.__closure__)

1276

1123

new_function = (dbus.service.signal(

1277

alt_interface,

1278

attribute._dbus_signature)(new_function))

1124

alt_interface, attribute._dbus_signature)

1125

(types.FunctionType(

1126

nonmethod_func.func_code,

1127

nonmethod_func.func_globals,

1128

nonmethod_func.func_name,

1129

nonmethod_func.func_defaults,

1130

nonmethod_func.func_closure)))

1279

1131

# Copy annotations, if any

1280

1132

try:

1281

1133

new_function._dbus_annotations = dict(

1504

1356

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

1505

1357

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

1506

1358

1507

def checker_callback(self, source, condition,

1508

connection, command, *args, **kwargs):

1509

ret = Client.checker_callback(self, source, condition,

1510

connection, command, *args,

1511

**kwargs)

1512

exitstatus = self.last_checker_status

1513

if exitstatus >= 0:

1359

def checker_callback(self, pid, condition, command,

1360

*args, **kwargs):

1361

self.checker_callback_tag = None

1362

self.checker = None

1363

if os.WIFEXITED(condition):

1364

exitstatus = os.WEXITSTATUS(condition)

1514

1365

# Emit D-Bus signal

1515

1366

self.CheckerCompleted(dbus.Int16(exitstatus),

1516

# This is specific to GNU libC

1517

dbus.Int64(exitstatus << 8),

1367

dbus.Int64(condition),

1518

1368

dbus.String(command))

1519

1369

else:

1520

1370

# Emit D-Bus signal

1521

1371

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

1522

dbus.Int64(

1523

# This is specific to GNU libC

1524

(exitstatus << 8)

1525

| self.last_checker_signal),

1372

dbus.Int64(condition),

1526

1373

dbus.String(command))

1527

return ret

1374

1375

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

1376

*args, **kwargs)

1528

1377

1529

1378

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

1530

1379

old_checker_pid = getattr(self.checker, "pid", None)

1605

1454

self.checked_ok()

1606

1455

1607

1456

# Enable - method

1608

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

1609

1457

@dbus.service.method(_interface)

1610

1458

def Enable(self):

1611

1459

"D-Bus method"

1612

1460

self.enable()

1613

1461

1614

1462

# StartChecker - method

1615

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

1616

1463

@dbus.service.method(_interface)

1617

1464

def StartChecker(self):

1618

1465

"D-Bus method"

1619

1466

self.start_checker()

1620

1467

1621

1468

# Disable - method

1622

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

1623

1469

@dbus.service.method(_interface)

1624

1470

def Disable(self):

1625

1471

"D-Bus method"

1626

1472

self.disable()

1627

1473

1628

1474

# StopChecker - method

1629

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

1630

1475

@dbus.service.method(_interface)

1631

1476

def StopChecker(self):

1632

1477

self.stop_checker()

1668

1513

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

1669

1514

1670

1515

# Name - property

1671

@dbus_annotations(

1672

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

1673

1516

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

1674

1517

def Name_dbus_property(self):

1675

1518

return dbus.String(self.name)

1676

1519

1677

1520

# Fingerprint - property

1678

@dbus_annotations(

1679

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

1680

1521

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

1681

1522

def Fingerprint_dbus_property(self):

1682

1523

return dbus.String(self.fingerprint)

1691

1532

self.host = str(value)

1692

1533

1693

1534

# Created - property

1694

@dbus_annotations(

1695

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

1696

1535

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

1697

1536

def Created_dbus_property(self):

1698

1537

return datetime_to_dbus(self.created)

1813

1652

self.stop_checker()

1814

1653

1815

1654

# ObjectPath - property

1816

@dbus_annotations(

1817

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

1818

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

1819

1655

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

1820

1656

def ObjectPath_dbus_property(self):

1821

1657

return self.dbus_object_path # is already a dbus.ObjectPath

1822

1658

1823

1659

# Secret = property

1824

@dbus_annotations(

1825

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

1826

"invalidates"})

1827

1660

@dbus_service_property(_interface,

1828

1661

signature="ay",

1829

1662

access="write",

2308

2141

2309

2142

if command == 'getattr':

2310

2143

attrname = request[1]

2311

if isinstance(client_object.__getattribute__(attrname),

2312

collections.Callable):

2144

if callable(client_object.__getattribute__(attrname)):

2313

2145

parent_pipe.send(('function', ))

2314

2146

else:

2315

2147

parent_pipe.send((

2350

2182

# avoid excessive use of external libraries.

2351

2183

2352

2184

# New type for defining tokens, syntax, and semantics all-in-one

2185

Token = collections.namedtuple("Token",

2186

("regexp", # To match token; if

2187

# "value" is not None,

2188

# must have a "group"

2189

# containing digits

2190

"value", # datetime.timedelta or

2191

# None

2192

"followers")) # Tokens valid after

2193

# this token

2353

2194

Token = collections.namedtuple("Token", (

2354

2195

"regexp", # To match token; if "value" is not None, must have

2355

2196

# a "group" containing digits

2390

2231

# Define starting values

2391

2232

value = datetime.timedelta() # Value so far

2392

2233

found_token = None

2393

followers = frozenset((token_duration, )) # Following valid tokens

2234

followers = frozenset((token_duration,)) # Following valid tokens

2394

2235

s = duration # String left to parse

2395

2236

# Loop until end token is found

2396

2237

while found_token is not token_end:

2553

2394

"debug": "False",

2554

2395

"priority":

2555

2396

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"

2556

":+SIGN-DSA-SHA256",

2397

":+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",

2557

2398

"servicename": "Mandos",

2558

2399

"use_dbus": "True",

2559

2400

"use_ipv6": "True",

2815

2656

pass

2816

2657

2817

2658

# Clients who has passed its expire date can still be

2818

# enabled if its last checker was successful. A Client

2659

# enabled if its last checker was successful. Clients

2819

2660

# whose checker succeeded before we stored its state is

2820

2661

# assumed to have successfully run all checkers during

2821

2662

# downtime.

2890

2731

2891

2732

@alternate_dbus_interfaces(

2892

2733

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

2893

class MandosDBusService(DBusObjectWithObjectManager):

2734

class MandosDBusService(DBusObjectWithProperties):

2894

2735

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

2895

2736

2896

2737

def __init__(self):

2898

2739

2899

2740

_interface = "se.recompile.Mandos"

2900

2741

2742

@dbus_interface_annotations(_interface)

2743

def _foo(self):

2744

return {

2745

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

2746

"false" }

2747

2901

2748

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

2902

2749

def ClientAdded(self, objpath):

2903

2750

"D-Bus signal"

2908

2755

"D-Bus signal"

2909

2756

pass

2910

2757

2911

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

2912

"true"})

2913

2758

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

2914

2759

def ClientRemoved(self, objpath, name):

2915

2760

"D-Bus signal"

2916

2761

pass

2917

2762

2918

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

2919

"true"})

2920

2763

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

2921

2764

def GetAllClients(self):

2922

2765

"D-Bus method"

2923

2766

return dbus.Array(c.dbus_object_path for c in

2924

2767

tcp_server.clients.itervalues())

2925

2768

2926

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

2927

"true"})

2928

2769

@dbus.service.method(_interface,

2929

2770

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

2930

2771

def GetAllClientsWithProperties(self):

2931

2772

"D-Bus method"

2932

2773

return dbus.Dictionary(

2933

{ c.dbus_object_path: c.GetAll(

2934

"se.recompile.Mandos.Client")

2774

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

2935

2775

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

2936

2776

signature="oa{sv}")

2937

2777

2942

2782

if c.dbus_object_path == object_path:

2943

2783

del tcp_server.clients[c.name]

2944

2784

c.remove_from_connection()

2945

# Don't signal the disabling

2785

# Don't signal anything except ClientRemoved

2946

2786

c.disable(quiet=True)

2947

# Emit D-Bus signal for removal

2948

self.client_removed_signal(c)

2787

# Emit D-Bus signal

2788

self.ClientRemoved(object_path, c.name)

2949

2789

return

2950

2790

raise KeyError(object_path)

2951

2791

2952

2792

del _interface

2953

2954

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

2955

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

2956

def GetManagedObjects(self):

2957

"""D-Bus method"""

2958

return dbus.Dictionary(

2959

{ client.dbus_object_path:

2960

dbus.Dictionary(

2961

{ interface: client.GetAll(interface)

2962

for interface in

2963

client._get_all_interface_names()})

2964

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

2965

2966

def client_added_signal(self, client):

2967

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

2968

if use_dbus:

2969

# New standard signal

2970

self.InterfacesAdded(

2971

client.dbus_object_path,

2972

dbus.Dictionary(

2973

{ interface: client.GetAll(interface)

2974

for interface in

2975

client._get_all_interface_names()}))

2976

# Old signal

2977

self.ClientAdded(client.dbus_object_path)

2978

2979

def client_removed_signal(self, client):

2980

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

2981

if use_dbus:

2982

# New standard signal

2983

self.InterfacesRemoved(

2984

client.dbus_object_path,

2985

client._get_all_interface_names())

2986

# Old signal

2987

self.ClientRemoved(client.dbus_object_path,

2988

client.name)

2989

2793

2990

2794

mandos_dbus_service = MandosDBusService()

2991

2795

3056

2860

name, client = tcp_server.clients.popitem()

3057

2861

if use_dbus:

3058

2862

client.remove_from_connection()

3059

# Don't signal the disabling

2863

# Don't signal anything except ClientRemoved

3060

2864

client.disable(quiet=True)

3061

# Emit D-Bus signal for removal

3062

mandos_dbus_service.client_removed_signal(client)

2865

if use_dbus:

2866

# Emit D-Bus signal

2867

mandos_dbus_service.ClientRemoved(

2868

client.dbus_object_path, client.name)

3063

2869

client_settings.clear()

3064

2870

3065

2871

atexit.register(cleanup)

3066

2872

3067

2873

for client in tcp_server.clients.itervalues():

3068

2874

if use_dbus:

3069

# Emit D-Bus signal for adding

3070

mandos_dbus_service.client_added_signal(client)

2875

# Emit D-Bus signal

2876

mandos_dbus_service.ClientAdded(client.dbus_object_path)

3071

2877

# Need to initiate checking of clients

3072

2878

if client.enabled:

3073

2879

client.init_checker()