/mandos/trunk : revision 505.1.6

28

# along with this program. If not, see

29

# <http://www.gnu.org/licenses/>.

30

#

31

# Contact the authors at <mandos@fukt.bsnet.se>.

31

# Contact the authors at <mandos@recompile.se>.

32

#

33

34

from __future__ import (division, absolute_import, print_function,

62

import functools

63

import cPickle as pickle

64

import multiprocessing

65

import types

65

66

67

import dbus

67

68

import dbus.service

159

160

" after %i retries, exiting.",

160

161

self.rename_count)

161

162

raise AvahiServiceError("Too many renames")

162

self.name = unicode(self.server.GetAlternativeServiceName(self.name))

163

self.name = unicode(self.server

164

.GetAlternativeServiceName(self.name))

163

165

logger.info("Changing Zeroconf service name to %r ...",

164

166

self.name)

165

167

syslogger.setFormatter(logging.Formatter

264

266

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

265

267

266

268

269

def _timedelta_to_milliseconds(td):

270

"Convert a datetime.timedelta() to milliseconds"

271

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

272

+ (td.seconds * 1000)

273

+ (td.microseconds // 1000))

274

267

275

class Client(object):

268

276

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

269

277

308

316

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

309

317

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

310

318

311

@staticmethod

312

def _timedelta_to_milliseconds(td):

313

"Convert a datetime.timedelta() to milliseconds"

314

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

315

+ (td.seconds * 1000)

316

+ (td.microseconds // 1000))

317

318

319

def timeout_milliseconds(self):

319

320

"Return the 'timeout' attribute in milliseconds"

320

return self._timedelta_to_milliseconds(self.timeout)

321

return _timedelta_to_milliseconds(self.timeout)

322

323

def extended_timeout_milliseconds(self):

323

324

"Return the 'extended_timeout' attribute in milliseconds"

324

return self._timedelta_to_milliseconds(self.extended_timeout)

325

return _timedelta_to_milliseconds(self.extended_timeout)

325

326

327

def interval_milliseconds(self):

327

328

"Return the 'interval' attribute in milliseconds"

328

return self._timedelta_to_milliseconds(self.interval)

329

return _timedelta_to_milliseconds(self.interval)

330

331

def approval_delay_milliseconds(self):

331

return self._timedelta_to_milliseconds(self.approval_delay)

332

return _timedelta_to_milliseconds(self.approval_delay)

332

333

334

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

334

335

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

361

362

self.last_enabled = None

362

363

self.last_checked_ok = None

363

364

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

364

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

365

self.extended_timeout = string_to_delta(config

366

["extended_timeout"])

365

367

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

366

368

self.disable_hook = disable_hook

367

369

self.checker = None

380

382

config["approval_delay"])

381

383

self.approval_duration = string_to_delta(

382

384

config["approval_duration"])

383

self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())

385

self.changedstate = (multiprocessing_manager

386

.Condition(multiprocessing_manager

387

.Lock()))

384

388

385

389

def send_changedstate(self):

386

390

self.changedstate.acquire()

387

391

self.changedstate.notify_all()

388

392

self.changedstate.release()

389

393

390

394

def enable(self):

391

395

"""Start this client's checker and timeout hooks"""

392

396

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

393

397

# Already enabled

394

398

return

395

399

self.send_changedstate()

396

self.last_enabled = datetime.datetime.utcnow()

397

400

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

398

401

# and every interval from then on.

399

402

self.checker_initiator_tag = (gobject.timeout_add

405

408

(self.timeout_milliseconds(),

406

409

self.disable))

407

410

self.enabled = True

411

self.last_enabled = datetime.datetime.utcnow()

408

412

# Also start a new checker *right now*.

409

413

self.start_checker()

410

414

463

467

gobject.source_remove(self.disable_initiator_tag)

464

468

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

465

469

self.disable_initiator_tag = (gobject.timeout_add

466

(self._timedelta_to_milliseconds(timeout),

467

self.disable))

470

(_timedelta_to_milliseconds

471

(timeout), self.disable))

468

472

469

473

def need_approval(self):

470

474

self.last_approval_request = datetime.datetime.utcnow()

510

514

'replace')))

511

515

for attr in

512

516

self.runtime_expansions)

513

517

514

518

try:

515

519

command = self.checker_command % escaped_attrs

516

520

except TypeError as error:

562

566

raise

563

567

self.checker = None

564

568

569

565

570

def dbus_service_property(dbus_interface, signature="v",

566

571

access="readwrite", byte_arrays=False):

567

572

"""Decorators for marking methods of a DBusObjectWithProperties to

613

618

614

619

class DBusObjectWithProperties(dbus.service.Object):

615

620

"""A D-Bus object with properties.

616

621

617

622

Classes inheriting from this can use the dbus_service_property

618

623

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

619

624

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

626

631

def _get_all_dbus_properties(self):

627

632

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

628

633

"""

629

return ((prop._dbus_name, prop)

634

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

635

for cls in self.__class__.__mro__

630

636

for name, prop in

631

inspect.getmembers(self, self._is_dbus_property))

637

inspect.getmembers(cls, self._is_dbus_property))

632

638

633

639

def _get_dbus_property(self, interface_name, property_name):

634

640

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

635

641

property with the specified name and interface.

636

642

"""

637

for name in (property_name,

638

property_name + "_dbus_property"):

639

prop = getattr(self, name, None)

640

if (prop is None

641

or not self._is_dbus_property(prop)

642

or prop._dbus_name != property_name

643

or (interface_name and prop._dbus_interface

644

and interface_name != prop._dbus_interface)):

645

continue

646

return prop

643

for cls in self.__class__.__mro__:

644

for name, value in (inspect.getmembers

645

(cls, self._is_dbus_property)):

646

if (value._dbus_name == property_name

647

and value._dbus_interface == interface_name):

648

return value.__get__(self)

649

647

650

# No such property

648

651

raise DBusPropertyNotFound(self.dbus_object_path + ":"

649

652

+ interface_name + "."

683

686

def GetAll(self, interface_name):

684

687

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

685

688

standard.

686

689

687

690

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

688

691

"""

689

692

all = {}

751

754

return xmlstring

752

755

753

756

757

def datetime_to_dbus (dt, variant_level=0):

758

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

759

if dt is None:

760

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

761

return dbus.String(dt.isoformat(),

762

variant_level=variant_level)

763

764

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

765

.__metaclass__):

766

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

767

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

768

"""

769

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

770

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

771

# methods, signals, or properties in them

772

for base in (b for b in bases

773

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

774

# Go though all attributes of the base class

775

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

776

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

777

# with the wrong interface name

778

if (not hasattr(attribute, "_dbus_interface")

779

or not attribute._dbus_interface

780

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

781

continue

782

# Create an alternate D-Bus interface name based on

783

# the current name

784

alt_interface = (attribute._dbus_interface

785

.replace("se.recompile.Mandos",

786

"se.bsnet.fukt.Mandos"))

787

# Is this a D-Bus signal?

788

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

789

# Extract the original non-method function by

790

# black magic

791

nonmethod_func = (dict(

792

zip(attribute.func_code.co_freevars,

793

attribute.__closure__))["func"]

794

.cell_contents)

795

# Create a new, but exactly alike, function

796

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

797

# with the alternate D-Bus interface name

798

new_function = (dbus.service.signal

799

(alt_interface,

800

attribute._dbus_signature)

801

(types.FunctionType(

802

nonmethod_func.func_code,

803

nonmethod_func.func_globals,

804

nonmethod_func.func_name,

805

nonmethod_func.func_defaults,

806

nonmethod_func.func_closure)))

807

# Define a creator of a function to call both the

808

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

809

# signals gets sent when the function is called

810

def fixscope(func1, func2):

811

"""This function is a scope container to pass

812

func1 and func2 to the "call_both" function

813

outside of its arguments"""

814

def call_both(*args, **kwargs):

815

"""This function will emit two D-Bus

816

signals by calling func1 and func2"""

817

func1(*args, **kwargs)

818

func2(*args, **kwargs)

819

return call_both

820

# Create the "call_both" function and add it to

821

# the class

822

attr[attrname] = fixscope(attribute,

823

new_function)

824

# Is this a D-Bus method?

825

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

826

# Create a new, but exactly alike, function

827

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

828

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

829

# to the class.

830

attr[attrname] = (dbus.service.method

831

(alt_interface,

832

attribute._dbus_in_signature,

833

attribute._dbus_out_signature)

834

(types.FunctionType

835

(attribute.func_code,

836

attribute.func_globals,

837

attribute.func_name,

838

attribute.func_defaults,

839

attribute.func_closure)))

840

# Is this a D-Bus property?

841

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

842

# Create a new, but exactly alike, function

843

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

844

# property with the alternate D-Bus interface

845

# name. Add it to the class.

846

attr[attrname] = (dbus_service_property

847

(alt_interface,

848

attribute._dbus_signature,

849

attribute._dbus_access,

850

attribute

851

._dbus_get_args_options

852

["byte_arrays"])

853

(types.FunctionType

854

(attribute.func_code,

855

attribute.func_globals,

856

attribute.func_name,

857

attribute.func_defaults,

858

attribute.func_closure)))

859

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

860

754

861

class ClientDBus(Client, DBusObjectWithProperties):

755

862

"""A Client class using D-Bus

756

863

777

884

("/clients/" + client_object_name))

778

885

DBusObjectWithProperties.__init__(self, self.bus,

779

886

self.dbus_object_path)

780

def _set_expires(self, value):

781

old_value = getattr(self, "_expires", None)

782

self._expires = value

783

if hasattr(self, "dbus_object_path") and old_value != value:

784

dbus_time = (self._datetime_to_dbus(self._expires,

785

variant_level=1))

786

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

787

dbus_time)

788

expires = property(lambda self: self._expires, _set_expires)

789

del _set_expires

790

887

791

def _get_approvals_pending(self):

792

return self._approvals_pending

793

def _set_approvals_pending(self, value):

794

old_value = self._approvals_pending

795

self._approvals_pending = value

796

bval = bool(value)

797

if (hasattr(self, "dbus_object_path")

798

and bval is not bool(old_value)):

799

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

800

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

801

dbus_bool)

888

def notifychangeproperty(transform_func,

889

dbus_name, type_func=lambda x: x,

890

variant_level=1):

891

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

892

its changes to DBus.

802

893

803

approvals_pending = property(_get_approvals_pending,

804

_set_approvals_pending)

805

del _get_approvals_pending, _set_approvals_pending

806

807

@staticmethod

808

def _datetime_to_dbus(dt, variant_level=0):

809

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

810

if dt is None:

811

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

812

return dbus.String(dt.isoformat(),

813

variant_level=variant_level)

814

815

def enable(self):

816

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

817

r = Client.enable(self)

818

if oldstate != self.enabled:

819

# Emit D-Bus signals

820

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

821

dbus.Boolean(True, variant_level=1))

822

self.PropertyChanged(

823

dbus.String("LastEnabled"),

824

self._datetime_to_dbus(self.last_enabled,

825

variant_level=1))

826

return r

827

828

def disable(self, quiet = False):

829

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

830

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

831

if not quiet and oldstate != self.enabled:

832

# Emit D-Bus signal

833

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

834

dbus.Boolean(False, variant_level=1))

835

return r

894

transform_fun: Function that takes a value and transforms it

895

to a D-Bus type.

896

dbus_name: D-Bus name of the variable

897

type_func: Function that transform the value before sending it

898

to the D-Bus. Default: no transform

899

variant_level: D-Bus variant level. Default: 1

900

"""

901

attrname = "_{0}".format(dbus_name)

902

def setter(self, value):

903

if hasattr(self, "dbus_object_path"):

904

if (not hasattr(self, attrname) or

905

type_func(getattr(self, attrname, None))

906

!= type_func(value)):

907

dbus_value = transform_func(type_func(value),

908

variant_level)

909

self.PropertyChanged(dbus.String(dbus_name),

910

dbus_value)

911

setattr(self, attrname, value)

912

913

return property(lambda self: getattr(self, attrname), setter)

914

915

916

expires = notifychangeproperty(datetime_to_dbus, "Expires")

917

approvals_pending = notifychangeproperty(dbus.Boolean,

918

"ApprovalPending",

919

type_func = bool)

920

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

921

last_enabled = notifychangeproperty(datetime_to_dbus,

922

"LastEnabled")

923

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

924

type_func = lambda checker:

925

checker is not None)

926

last_checked_ok = notifychangeproperty(datetime_to_dbus,

927

"LastCheckedOK")

928

last_approval_request = notifychangeproperty(

929

datetime_to_dbus, "LastApprovalRequest")

930

approved_by_default = notifychangeproperty(dbus.Boolean,

931

"ApprovedByDefault")

932

approval_delay = notifychangeproperty(dbus.UInt16,

933

"ApprovalDelay",

934

type_func =

935

_timedelta_to_milliseconds)

936

approval_duration = notifychangeproperty(

937

dbus.UInt16, "ApprovalDuration",

938

type_func = _timedelta_to_milliseconds)

939

host = notifychangeproperty(dbus.String, "Host")

940

timeout = notifychangeproperty(dbus.UInt16, "Timeout",

941

type_func =

942

_timedelta_to_milliseconds)

943

extended_timeout = notifychangeproperty(

944

dbus.UInt16, "ExtendedTimeout",

945

type_func = _timedelta_to_milliseconds)

946

interval = notifychangeproperty(dbus.UInt16,

947

"Interval",

948

type_func =

949

_timedelta_to_milliseconds)

950

checker_command = notifychangeproperty(dbus.String, "Checker")

951

952

del notifychangeproperty

836

953

837

954

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

838

955

try:

847

964

*args, **kwargs):

848

965

self.checker_callback_tag = None

849

966

self.checker = None

850

# Emit D-Bus signal

851

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

852

dbus.Boolean(False, variant_level=1))

853

967

if os.WIFEXITED(condition):

854

968

exitstatus = os.WEXITSTATUS(condition)

855

969

# Emit D-Bus signal

865

979

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

866

980

*args, **kwargs)

867

981

868

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

869

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

870

# Emit D-Bus signal

871

self.PropertyChanged(

872

dbus.String("LastCheckedOK"),

873

(self._datetime_to_dbus(self.last_checked_ok,

874

variant_level=1)))

875

876

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

877

r = Client.need_approval(self, *args, **kwargs)

878

# Emit D-Bus signal

879

self.PropertyChanged(

880

dbus.String("LastApprovalRequest"),

881

(self._datetime_to_dbus(self.last_approval_request,

882

variant_level=1)))

883

return r

884

885

982

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

886

983

old_checker = self.checker

887

984

if self.checker is not None:

894

991

and old_checker_pid != self.checker.pid):

895

992

# Emit D-Bus signal

896

993

self.CheckerStarted(self.current_checker_command)

897

self.PropertyChanged(

898

dbus.String("CheckerRunning"),

899

dbus.Boolean(True, variant_level=1))

900

994

return r

901

995

902

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

903

old_checker = getattr(self, "checker", None)

904

r = Client.stop_checker(self, *args, **kwargs)

905

if (old_checker is not None

906

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

907

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

908

dbus.Boolean(False, variant_level=1))

909

return r

910

911

996

def _reset_approved(self):

912

997

self._approved = None

913

998

return False

915

1000

def approve(self, value=True):

916

1001

self.send_changedstate()

917

1002

self._approved = value

918

gobject.timeout_add(self._timedelta_to_milliseconds

1003

gobject.timeout_add(_timedelta_to_milliseconds

919

1004

(self.approval_duration),

920

1005

self._reset_approved)

921

1006

922

1007

923

1008

## D-Bus methods, signals & properties

924

_interface = "se.bsnet.fukt.Mandos.Client"

1009

_interface = "se.recompile.Mandos.Client"

925

1010

926

1011

## Signals

927

1012

1097

def ApprovedByDefault_dbus_property(self, value=None):

1013

1098

if value is None: # get

1014

1099

return dbus.Boolean(self.approved_by_default)

1015

old_value = self.approved_by_default

1016

1100

self.approved_by_default = bool(value)

1017

# Emit D-Bus signal

1018

if old_value != self.approved_by_default:

1019

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

1020

dbus.Boolean(value, variant_level=1))

1021

1101

1022

1102

# ApprovalDelay - property

1023

1103

@dbus_service_property(_interface, signature="t",

1025

1105

def ApprovalDelay_dbus_property(self, value=None):

1026

1106

if value is None: # get

1027

1107

return dbus.UInt64(self.approval_delay_milliseconds())

1028

old_value = self.approval_delay

1029

1108

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

1030

# Emit D-Bus signal

1031

if old_value != self.approval_delay:

1032

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

1033

dbus.UInt64(value, variant_level=1))

1034

1109

1035

1110

# ApprovalDuration - property

1036

1111

@dbus_service_property(_interface, signature="t",

1037

1112

access="readwrite")

1038

1113

def ApprovalDuration_dbus_property(self, value=None):

1039

1114

if value is None: # get

1040

return dbus.UInt64(self._timedelta_to_milliseconds(

1115

return dbus.UInt64(_timedelta_to_milliseconds(

1041

1116

self.approval_duration))

1042

old_value = self.approval_duration

1043

1117

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

1044

# Emit D-Bus signal

1045

if old_value != self.approval_duration:

1046

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

1047

dbus.UInt64(value, variant_level=1))

1048

1118

1049

1119

# Name - property

1050

1120

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

1062

1132

def Host_dbus_property(self, value=None):

1063

1133

if value is None: # get

1064

1134

return dbus.String(self.host)

1065

old_value = self.host

1066

1135

self.host = value

1067

# Emit D-Bus signal

1068

if old_value != self.host:

1069

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

1070

dbus.String(value, variant_level=1))

1071

1136

1072

1137

# Created - property

1073

1138

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

1074

1139

def Created_dbus_property(self):

1075

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

1140

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

1076

1141

1077

1142

# LastEnabled - property

1078

1143

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

1079

1144

def LastEnabled_dbus_property(self):

1080

return self._datetime_to_dbus(self.last_enabled)

1145

return datetime_to_dbus(self.last_enabled)

1081

1146

1082

1147

# Enabled - property

1083

1148

@dbus_service_property(_interface, signature="b",

1097

1162

if value is not None:

1098

1163

self.checked_ok()

1099

1164

return

1100

return self._datetime_to_dbus(self.last_checked_ok)

1165

return datetime_to_dbus(self.last_checked_ok)

1101

1166

1102

1167

# Expires - property

1103

1168

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

1104

1169

def Expires_dbus_property(self):

1105

return self._datetime_to_dbus(self.expires)

1170

return datetime_to_dbus(self.expires)

1106

1171

1107

1172

# LastApprovalRequest - property

1108

1173

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

1109

1174

def LastApprovalRequest_dbus_property(self):

1110

return self._datetime_to_dbus(self.last_approval_request)

1175

return datetime_to_dbus(self.last_approval_request)

1111

1176

1112

1177

# Timeout - property

1113

1178

@dbus_service_property(_interface, signature="t",

1115

1180

def Timeout_dbus_property(self, value=None):

1116

1181

if value is None: # get

1117

1182

return dbus.UInt64(self.timeout_milliseconds())

1118

old_value = self.timeout

1119

1183

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

1120

# Emit D-Bus signal

1121

if old_value != self.timeout:

1122

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

1123

dbus.UInt64(value, variant_level=1))

1124

1184

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

1125

1185

return

1126

1186

# Reschedule timeout

1138

1198

self.disable()

1139

1199

else:

1140

1200

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

1141

+ datetime.timedelta(milliseconds = time_to_die))

1201

+ datetime.timedelta(milliseconds =

1202

time_to_die))

1142

1203

self.disable_initiator_tag = (gobject.timeout_add

1143

1204

(time_to_die, self.disable))

1144

1205

1145

1206

# ExtendedTimeout - property

1146

1207

@dbus_service_property(_interface, signature="t",

1147

1208

access="readwrite")

1148

1209

def ExtendedTimeout_dbus_property(self, value=None):

1149

1210

if value is None: # get

1150

1211

return dbus.UInt64(self.extended_timeout_milliseconds())

1151

old_value = self.extended_timeout

1152

1212

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

1153

# Emit D-Bus signal

1154

if old_value != self.extended_timeout:

1155

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

1156

dbus.UInt64(value, variant_level=1))

1157

1213

1158

1214

# Interval - property

1159

1215

@dbus_service_property(_interface, signature="t",

1160

1216

access="readwrite")

1161

1217

def Interval_dbus_property(self, value=None):

1162

1218

if value is None: # get

1163

1219

return dbus.UInt64(self.interval_milliseconds())

1164

old_value = self.interval

1165

1220

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

1166

# Emit D-Bus signal

1167

if old_value != self.interval:

1168

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

1169

dbus.UInt64(value, variant_level=1))

1170

1221

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

1171

1222

return

1172

1223

# Reschedule checker run

1174

1225

self.checker_initiator_tag = (gobject.timeout_add

1175

1226

(value, self.start_checker))

1176

1227

self.start_checker() # Start one now, too

1177

1228

1178

1229

# Checker - property

1179

1230

@dbus_service_property(_interface, signature="s",

1180

1231

access="readwrite")

1181

1232

def Checker_dbus_property(self, value=None):

1182

1233

if value is None: # get

1183

1234

return dbus.String(self.checker_command)

1184

old_value = self.checker_command

1185

1235

self.checker_command = value

1186

# Emit D-Bus signal

1187

if old_value != self.checker_command:

1188

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

1189

dbus.String(self.checker_command,

1190

variant_level=1))

1191

1236

1192

1237

# CheckerRunning - property

1193

1238

@dbus_service_property(_interface, signature="b",

1220

1265

self._pipe.send(('init', fpr, address))

1221

1266

if not self._pipe.recv():

1222

1267

raise KeyError()

1223

1268

1224

1269

def __getattribute__(self, name):

1225

1270

if(name == '_pipe'):

1226

1271

return super(ProxyClient, self).__getattribute__(name)

1233

1278

self._pipe.send(('funcall', name, args, kwargs))

1234

1279

return self._pipe.recv()[1]

1235

1280

return func

1236

1281

1237

1282

def __setattr__(self, name, value):

1238

1283

if(name == '_pipe'):

1239

1284

return super(ProxyClient, self).__setattr__(name, value)

1240

1285

self._pipe.send(('setattr', name, value))

1241

1286

1287

class ClientDBusTransitional(ClientDBus):

1288

__metaclass__ = AlternateDBusNamesMetaclass

1242

1289

1243

1290

class ClientHandler(socketserver.BaseRequestHandler, object):

1244

1291

"""A class to handle client connections.

1252

1299

unicode(self.client_address))

1253

1300

logger.debug("Pipe FD: %d",

1254

1301

self.server.child_pipe.fileno())

1255

1302

1256

1303

session = (gnutls.connection

1257

1304

.ClientSession(self.request,

1258

1305

gnutls.connection

1259

1306

.X509Credentials()))

1260

1307

1261

1308

# Note: gnutls.connection.X509Credentials is really a

1262

1309

# generic GnuTLS certificate credentials object so long as

1263

1310

# no X.509 keys are added to it. Therefore, we can use it

1264

1311

# here despite using OpenPGP certificates.

1265

1312

1266

1313

#priority = ':'.join(("NONE", "+VERS-TLS1.1",

1267

1314

# "+AES-256-CBC", "+SHA1",

1268

1315

# "+COMP-NULL", "+CTYPE-OPENPGP",

1274

1321

(gnutls.library.functions

1275

1322

.gnutls_priority_set_direct(session._c_object,

1276

1323

priority, None))

1277

1324

1278

1325

# Start communication using the Mandos protocol

1279

1326

# Get protocol number

1280

1327

line = self.request.makefile().readline()

1285

1332

except (ValueError, IndexError, RuntimeError) as error:

1286

1333

logger.error("Unknown protocol version: %s", error)

1287

1334

return

1288

1335

1289

1336

# Start GnuTLS connection

1290

1337

try:

1291

1338

session.handshake()

1295

1342

# established. Just abandon the request.

1296

1343

return

1297

1344

logger.debug("Handshake succeeded")

1298

1345

1299

1346

approval_required = False

1300

1347

try:

1301

1348

try:

1306

1353

logger.warning("Bad certificate: %s", error)

1307

1354

return

1308

1355

logger.debug("Fingerprint: %s", fpr)

1309

1356

1310

1357

try:

1311

1358

client = ProxyClient(child_pipe, fpr,

1312

1359

self.client_address)

1324

1371

client.name)

1325

1372

if self.server.use_dbus:

1326

1373

# Emit D-Bus signal

1327

client.Rejected("Disabled")

1374

client.Rejected("Disabled")

1328

1375

return

1329

1376

1330

1377

if client._approved or not client.approval_delay:

1347

1394

return

1348

1395

1349

1396

#wait until timeout or approved

1350

#x = float(client._timedelta_to_milliseconds(delay))

1397

#x = float(client

1398

# ._timedelta_to_milliseconds(delay))

1351

1399

time = datetime.datetime.now()

1352

1400

client.changedstate.acquire()

1353

client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))

1401

(client.changedstate.wait

1402

(float(client._timedelta_to_milliseconds(delay)

1403

/ 1000)))

1354

1404

client.changedstate.release()

1355

1405

time2 = datetime.datetime.now()

1356

1406

if (time2 - time) >= delay:

1378

1428

sent, len(client.secret)

1379

1429

- (sent_size + sent))

1380

1430

sent_size += sent

1381

1431

1382

1432

logger.info("Sending secret to %s", client.name)

1383

1433

# bump the timeout as if seen

1384

1434

client.checked_ok(client.extended_timeout)

1472

1522

multiprocessing.Process(target = self.sub_process_main,

1473

1523

args = (request, address)).start()

1474

1524

1525

1475

1526

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1476

1527

""" adds a pipe to the MixIn """

1477

1528

def process_request(self, request, client_address):

1480

1531

This function creates a new pipe in self.pipe

1481

1532

"""

1482

1533

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1483

1534

1484

1535

super(MultiprocessingMixInWithPipe,

1485

1536

self).process_request(request, client_address)

1486

1537

self.child_pipe.close()

1487

1538

self.add_pipe(parent_pipe)

1488

1539

1489

1540

def add_pipe(self, parent_pipe):

1490

1541

"""Dummy function; override as necessary"""

1491

1542

raise NotImplementedError

1492

1543

1544

1493

1545

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1494

1546

socketserver.TCPServer, object):

1495

1547

"""IPv6-capable TCP server. Accepts 'None' as address and/or port

1586

1638

gobject.io_add_watch(parent_pipe.fileno(),

1587

1639

gobject.IO_IN | gobject.IO_HUP,

1588

1640

functools.partial(self.handle_ipc,

1589

parent_pipe = parent_pipe))

1641

parent_pipe =

1642

parent_pipe))

1590

1643

1591

1644

def handle_ipc(self, source, condition, parent_pipe=None,

1592

1645

client_object=None):

1625

1678

"dress: %s", fpr, address)

1626

1679

if self.use_dbus:

1627

1680

# Emit D-Bus signal

1628

mandos_dbus_service.ClientNotFound(fpr, address[0])

1681

mandos_dbus_service.ClientNotFound(fpr,

1682

address[0])

1629

1683

parent_pipe.send(False)

1630

1684

return False

1631

1685

1632

1686

gobject.io_add_watch(parent_pipe.fileno(),

1633

1687

gobject.IO_IN | gobject.IO_HUP,

1634

1688

functools.partial(self.handle_ipc,

1635

parent_pipe = parent_pipe,

1636

client_object = client))

1689

parent_pipe =

1690

parent_pipe,

1691

client_object =

1692

client))

1637

1693

parent_pipe.send(True)

1638

# remove the old hook in favor of the new above hook on same fileno

1694

# remove the old hook in favor of the new above hook on

1695

# same fileno

1639

1696

return False

1640

1697

if command == 'funcall':

1641

1698

funcname = request[1]

1642

1699

args = request[2]

1643

1700

kwargs = request[3]

1644

1701

1645

parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))

1646

1702

parent_pipe.send(('data', getattr(client_object,

1703

funcname)(*args,

1704

**kwargs)))

1705

1647

1706

if command == 'getattr':

1648

1707

attrname = request[1]

1649

1708

if callable(client_object.__getattribute__(attrname)):

1650

1709

parent_pipe.send(('function',))

1651

1710

else:

1652

parent_pipe.send(('data', client_object.__getattribute__(attrname)))

1711

parent_pipe.send(('data', client_object

1712

.__getattribute__(attrname)))

1653

1713

1654

1714

if command == 'setattr':

1655

1715

attrname = request[1]

1656

1716

value = request[2]

1657

1717

setattr(client_object, attrname, value)

1658

1718

1659

1719

return True

1660

1720

1661

1721

1840

1900

debuglevel = server_settings["debuglevel"]

1841

1901

use_dbus = server_settings["use_dbus"]

1842

1902

use_ipv6 = server_settings["use_ipv6"]

1843

1903

1844

1904

if server_settings["servicename"] != "Mandos":

1845

1905

syslogger.setFormatter(logging.Formatter

1846

1906

('Mandos (%s) [%%(process)d]:'

1907

1967

level = getattr(logging, debuglevel.upper())

1908

1968

syslogger.setLevel(level)

1909

1969

console.setLevel(level)

1910

1970

1911

1971

if debug:

1912

1972

# Enable all possible GnuTLS debugging

1913

1973

1944

2004

# End of Avahi example code

1945

2005

if use_dbus:

1946

2006

try:

1947

bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",

2007

bus_name = dbus.service.BusName("se.recompile.Mandos",

1948

2008

bus, do_not_queue=True)

2009

old_bus_name = (dbus.service.BusName

2010

("se.bsnet.fukt.Mandos", bus,

2011

do_not_queue=True))

1949

2012

except dbus.exceptions.NameExistsException as e:

1950

2013

logger.error(unicode(e) + ", disabling D-Bus")

1951

2014

use_dbus = False

1964

2027

1965

2028

client_class = Client

1966

2029

if use_dbus:

1967

client_class = functools.partial(ClientDBus, bus = bus)

2030

client_class = functools.partial(ClientDBusTransitional,

2031

bus = bus)

1968

2032

def client_config_items(config, section):

1969

2033

special_settings = {

1970

2034

"approved_by_default":

2000

2064

del pidfilename

2001

2065

2002

2066

signal.signal(signal.SIGINT, signal.SIG_IGN)

2003

2067

2004

2068

signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())

2005

2069

signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())

2006

2070

2009

2073

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

2010

2074

def __init__(self):

2011

2075

dbus.service.Object.__init__(self, bus, "/")

2012

_interface = "se.bsnet.fukt.Mandos"

2076

_interface = "se.recompile.Mandos"

2013

2077

2014

2078

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

2015

2079

def ClientAdded(self, objpath):

2057

2121

2058

2122

del _interface

2059

2123

2060

mandos_dbus_service = MandosDBusService()

2124

class MandosDBusServiceTransitional(MandosDBusService):

2125

__metaclass__ = AlternateDBusNamesMetaclass

2126

mandos_dbus_service = MandosDBusServiceTransitional()

2061

2127

2062

2128

def cleanup():

2063

2129

"Cleanup function; run on exit"

2072

2138

client.disable(quiet=True)

2073

2139

if use_dbus:

2074

2140

# Emit D-Bus signal

2075

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

2141

mandos_dbus_service.ClientRemoved(client

2142

.dbus_object_path,

2076

2143

client.name)

2077

2144

2078

2145

atexit.register(cleanup)

2127

2194

# Must run before the D-Bus bus name gets deregistered

2128

2195

cleanup()

2129

2196

2197

2130

2198

if __name__ == '__main__':

2131

2199

main()