/mandos/release : revision 24.1.157

165

u' %%(levelname)s: %%(message)s'

166

% self.name))

167

self.remove()

168

try:

169

self.add()

170

except dbus.exceptions.DBusException, error:

171

logger.critical(u"DBusException: %s", error)

172

self.cleanup()

173

os._exit(1)

168

self.add()

174

169

self.rename_count += 1

175

170

def remove(self):

176

171

"""Derived from the Avahi example code"""

265

260

runtime with vars(self) as dict, so that for

266

261

instance %(name)s can be used in the command.

267

262

current_checker_command: string; current running checker_command

268

approval_delay: datetime.timedelta(); Time to wait for approval

263

approved_delay: datetime.timedelta(); Time to wait for approval

269

264

_approved: bool(); 'None' if not yet approved/disapproved

270

approval_duration: datetime.timedelta(); Duration of one approval

265

approved_duration: datetime.timedelta(); Duration of one approval

271

266

"""

272

267

273

268

@staticmethod

285

280

"Return the 'interval' attribute in milliseconds"

286

281

return self._timedelta_to_milliseconds(self.interval)

287

282

288

def approval_delay_milliseconds(self):

289

return self._timedelta_to_milliseconds(self.approval_delay)

283

def approved_delay_milliseconds(self):

284

return self._timedelta_to_milliseconds(self.approved_delay)

290

285

291

286

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

292

287

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

331

326

self.approved_by_default = config.get(u"approved_by_default",

332

327

True)

333

328

self.approvals_pending = 0

334

self.approval_delay = string_to_delta(

335

config[u"approval_delay"])

336

self.approval_duration = string_to_delta(

337

config[u"approval_duration"])

329

self.approved_delay = string_to_delta(

330

config[u"approved_delay"])

331

self.approved_duration = string_to_delta(

332

config[u"approved_duration"])

338

333

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

339

334

340

335

def send_changedstate(self):

716

711

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

717

712

DBusObjectWithProperties.__init__(self, self.bus,

718

713

self.dbus_object_path)

719

714

720

715

def _get_approvals_pending(self):

721

716

return self._approvals_pending

722

717

def _set_approvals_pending(self, value):

726

721

if (hasattr(self, "dbus_object_path")

727

722

and bval is not bool(old_value)):

728

723

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

729

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

724

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

730

725

dbus_bool)

731

726

732

727

approvals_pending = property(_get_approvals_pending,

744

739

r = Client.enable(self)

745

740

if oldstate != self.enabled:

746

741

# Emit D-Bus signals

747

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

742

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

748

743

dbus.Boolean(True, variant_level=1))

749

744

self.PropertyChanged(

750

dbus.String(u"LastEnabled"),

745

dbus.String(u"last_enabled"),

751

746

self._datetime_to_dbus(self.last_enabled,

752

747

variant_level=1))

753

748

return r

757

752

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

758

753

if not quiet and oldstate != self.enabled:

759

754

# Emit D-Bus signal

760

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

755

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

761

756

dbus.Boolean(False, variant_level=1))

762

757

return r

763

758

775

770

self.checker_callback_tag = None

776

771

self.checker = None

777

772

# Emit D-Bus signal

778

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

773

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

779

774

dbus.Boolean(False, variant_level=1))

780

775

if os.WIFEXITED(condition):

781

776

exitstatus = os.WEXITSTATUS(condition)

796

791

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

797

792

# Emit D-Bus signal

798

793

self.PropertyChanged(

799

dbus.String(u"LastCheckedOK"),

794

dbus.String(u"last_checked_ok"),

800

795

(self._datetime_to_dbus(self.last_checked_ok,

801

796

variant_level=1)))

802

797

return r

814

809

# Emit D-Bus signal

815

810

self.CheckerStarted(self.current_checker_command)

816

811

self.PropertyChanged(

817

dbus.String(u"CheckerRunning"),

812

dbus.String(u"checker_running"),

818

813

dbus.Boolean(True, variant_level=1))

819

814

return r

820

815

823

818

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

824

819

if (old_checker is not None

825

820

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

826

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

821

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

827

822

dbus.Boolean(False, variant_level=1))

828

823

return r

829

824

834

829

def approve(self, value=True):

835

830

self.send_changedstate()

836

831

self._approved = value

837

gobject.timeout_add(self._timedelta_to_milliseconds

838

(self.approval_duration),

832

gobject.timeout_add(self._timedelta_to_milliseconds(self.approved_duration),

839

833

self._reset_approved)

840

834

841

835

878

872

pass

879

873

880

874

# NeedApproval - signal

881

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

875

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

882

876

def NeedApproval(self, timeout, default):

883

877

"D-Bus signal"

884

878

pass

920

914

921

915

## Properties

922

916

923

# ApprovalPending - property

917

# approved_pending - property

924

918

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

925

def ApprovalPending_dbus_property(self):

919

def approved_pending_dbus_property(self):

926

920

return dbus.Boolean(bool(self.approvals_pending))

927

921

928

# ApprovedByDefault - property

922

# approved_by_default - property

929

923

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

930

924

access=u"readwrite")

931

def ApprovedByDefault_dbus_property(self, value=None):

932

if value is None: # get

933

return dbus.Boolean(self.approved_by_default)

934

self.approved_by_default = bool(value)

935

# Emit D-Bus signal

936

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

937

dbus.Boolean(value, variant_level=1))

938

939

# ApprovalDelay - property

940

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

941

access=u"readwrite")

942

def ApprovalDelay_dbus_property(self, value=None):

943

if value is None: # get

944

return dbus.UInt64(self.approval_delay_milliseconds())

945

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

946

# Emit D-Bus signal

947

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

948

dbus.UInt64(value, variant_level=1))

949

950

# ApprovalDuration - property

951

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

952

access=u"readwrite")

953

def ApprovalDuration_dbus_property(self, value=None):

954

if value is None: # get

955

return dbus.UInt64(self._timedelta_to_milliseconds(

956

self.approval_duration))

957

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

958

# Emit D-Bus signal

959

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

960

dbus.UInt64(value, variant_level=1))

961

962

# Name - property

925

def approved_by_default_dbus_property(self):

926

return dbus.Boolean(self.approved_by_default)

927

928

# approved_delay - property

929

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

930

access=u"readwrite")

931

def approved_delay_dbus_property(self):

932

return dbus.UInt64(self.approved_delay_milliseconds())

933

934

# approved_duration - property

935

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

936

access=u"readwrite")

937

def approved_duration_dbus_property(self):

938

return dbus.UInt64(self._timedelta_to_milliseconds(

939

self.approved_duration))

940

941

# name - property

963

942

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

964

def Name_dbus_property(self):

943

def name_dbus_property(self):

965

944

return dbus.String(self.name)

966

945

967

# Fingerprint - property

946

# fingerprint - property

968

947

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

969

def Fingerprint_dbus_property(self):

948

def fingerprint_dbus_property(self):

970

949

return dbus.String(self.fingerprint)

971

950

972

# Host - property

951

# host - property

973

952

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

974

953

access=u"readwrite")

975

def Host_dbus_property(self, value=None):

954

def host_dbus_property(self, value=None):

976

955

if value is None: # get

977

956

return dbus.String(self.host)

978

957

self.host = value

979

958

# Emit D-Bus signal

980

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

959

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

981

960

dbus.String(value, variant_level=1))

982

961

983

# Created - property

962

# created - property

984

963

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

985

def Created_dbus_property(self):

964

def created_dbus_property(self):

986

965

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

987

966

988

# LastEnabled - property

967

# last_enabled - property

989

968

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

990

def LastEnabled_dbus_property(self):

969

def last_enabled_dbus_property(self):

991

970

if self.last_enabled is None:

992

971

return dbus.String(u"")

993

972

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

994

973

995

# Enabled - property

974

# enabled - property

996

975

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

997

976

access=u"readwrite")

998

def Enabled_dbus_property(self, value=None):

977

def enabled_dbus_property(self, value=None):

999

978

if value is None: # get

1000

979

return dbus.Boolean(self.enabled)

1001

980

if value:

1003

982

else:

1004

983

self.disable()

1005

984

1006

# LastCheckedOK - property

985

# last_checked_ok - property

1007

986

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

1008

987

access=u"readwrite")

1009

def LastCheckedOK_dbus_property(self, value=None):

988

def last_checked_ok_dbus_property(self, value=None):

1010

989

if value is not None:

1011

990

self.checked_ok()

1012

991

return

1015

994

return dbus.String(self._datetime_to_dbus(self

1016

995

.last_checked_ok))

1017

996

1018

# Timeout - property

997

# timeout - property

1019

998

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

1020

999

access=u"readwrite")

1021

def Timeout_dbus_property(self, value=None):

1000

def timeout_dbus_property(self, value=None):

1022

1001

if value is None: # get

1023

1002

return dbus.UInt64(self.timeout_milliseconds())

1024

1003

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

1025

1004

# Emit D-Bus signal

1026

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

1005

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

1027

1006

dbus.UInt64(value, variant_level=1))

1028

1007

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

1029

1008

return

1043

1022

self.disable_initiator_tag = (gobject.timeout_add

1044

1023

(time_to_die, self.disable))

1045

1024

1046

# Interval - property

1025

# interval - property

1047

1026

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

1048

1027

access=u"readwrite")

1049

def Interval_dbus_property(self, value=None):

1028

def interval_dbus_property(self, value=None):

1050

1029

if value is None: # get

1051

1030

return dbus.UInt64(self.interval_milliseconds())

1052

1031

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

1053

1032

# Emit D-Bus signal

1054

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

1033

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

1055

1034

dbus.UInt64(value, variant_level=1))

1056

1035

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

1057

1036

return

1061

1040

(value, self.start_checker))

1062

1041

self.start_checker() # Start one now, too

1063

1042

1064

# Checker - property

1043

# checker - property

1065

1044

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

1066

1045

access=u"readwrite")

1067

def Checker_dbus_property(self, value=None):

1046

def checker_dbus_property(self, value=None):

1068

1047

if value is None: # get

1069

1048

return dbus.String(self.checker_command)

1070

1049

self.checker_command = value

1071

1050

# Emit D-Bus signal

1072

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

1051

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

1073

1052

dbus.String(self.checker_command,

1074

1053

variant_level=1))

1075

1054

1076

# CheckerRunning - property

1055

# checker_running - property

1077

1056

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

1078

1057

access=u"readwrite")

1079

def CheckerRunning_dbus_property(self, value=None):

1058

def checker_running_dbus_property(self, value=None):

1080

1059

if value is None: # get

1081

1060

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

1082

1061

if value:

1084

1063

else:

1085

1064

self.stop_checker()

1086

1065

1087

# ObjectPath - property

1066

# object_path - property

1088

1067

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

1089

def ObjectPath_dbus_property(self):

1068

def object_path_dbus_property(self):

1090

1069

return self.dbus_object_path # is already a dbus.ObjectPath

1091

1070

1092

# Secret = property

1071

# secret = property

1093

1072

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

1094

1073

access=u"write", byte_arrays=True)

1095

def Secret_dbus_property(self, value):

1074

def secret_dbus_property(self, value):

1096

1075

self.secret = str(value)

1097

1076

1098

1077

del _interface

1196

1175

except KeyError:

1197

1176

return

1198

1177

1199

if client.approval_delay:

1200

delay = client.approval_delay

1178

if client.approved_delay:

1179

delay = client.approved_delay

1201

1180

client.approvals_pending += 1

1202

1181

approval_required = True

1203

1182

1210

1189

client.Rejected("Disabled")

1211

1190

return

1212

1191

1213

if client._approved or not client.approval_delay:

1192

if client._approved or not client.approved_delay:

1214

1193

#We are approved or approval is disabled

1215

1194

break

1216

1195

elif client._approved is None:

1217

logger.info(u"Client %s needs approval",

1196

logger.info(u"Client %s need approval",

1218

1197

client.name)

1219

1198

if self.server.use_dbus:

1220

1199

# Emit D-Bus signal

1221

1200

client.NeedApproval(

1222

client.approval_delay_milliseconds(),

1201

client.approved_delay_milliseconds(),

1223

1202

client.approved_by_default)

1224

1203

else:

1225

1204

logger.warning(u"Client %s was not approved",

1226

1205

client.name)

1227

1206

if self.server.use_dbus:

1228

1207

# Emit D-Bus signal

1229

client.Rejected("Denied")

1208

client.Rejected("Disapproved")

1230

1209

return

1231

1210

1232

1211

#wait until timeout or approved

1243

1222

client.name)

1244

1223

if self.server.use_dbus:

1245

1224

# Emit D-Bus signal

1246

client.Rejected("Approval timed out")

1225

client.Rejected("Time out")

1247

1226

return

1248

1227

else:

1249

1228

break

1275

1254

try:

1276

1255

session.bye()

1277

1256

except (gnutls.errors.GNUTLSError), error:

1278

logger.warning("GnuTLS bye failed")

1257

logger.warning("gnutls bye failed")

1279

1258

1280

1259

@staticmethod

1281

1260

def peer_certificate(session):

1487

1466

for cond, name in

1488

1467

condition_names.iteritems()

1489

1468

if cond & condition)

1469

logger.debug(u"Handling IPC: FD = %d, condition = %s", source,

1470

conditions_string)

1471

1490

1472

# error or the other end of multiprocessing.Pipe has closed

1491

1473

if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):

1492

1474

return False

1493

1475

1494

1476

# Read a request from the child

1495

1477

request = parent_pipe.recv()

1478

logger.debug(u"IPC request: %s", repr(request))

1496

1479

command = request[0]

1497

1480

1498

1481

if command == 'init':

1732

1715

u"interval": u"5m",

1733

1716

u"checker": u"fping -q -- %%(host)s",

1734

1717

u"host": u"",

1735

u"approval_delay": u"0s",

1736

u"approval_duration": u"1s",

1718

u"approved_delay": u"0s",

1719

u"approved_duration": u"1s",

1737

1720

}

1738

1721

client_config = configparser.SafeConfigParser(client_defaults)

1739

1722

client_config.read(os.path.join(server_settings[u"configdir"],

1745

1728

tcp_server = MandosServer((server_settings[u"address"],

1746

1729

server_settings[u"port"]),

1747

1730

ClientHandler,

1748

interface=(server_settings[u"interface"]

1749

or None),

1731

interface=server_settings[u"interface"],

1750

1732

use_ipv6=use_ipv6,

1751

1733

gnutls_priority=

1752

1734

server_settings[u"priority"],

1778

1760

if error[0] != errno.EPERM:

1779

1761

raise error

1780

1762

1763

# Enable all possible GnuTLS debugging

1764

1765

1781

1766

if not debug and not debuglevel:

1782

1767

syslogger.setLevel(logging.WARNING)

1783

1768

console.setLevel(logging.WARNING)

1787

1772

console.setLevel(level)

1788

1773

1789

1774

if debug:

1790

# Enable all possible GnuTLS debugging

1791

1792

1775

# "Use a log level over 10 to enable all debugging options."

1793

1776

# - GnuTLS manual

1794

1777

gnutls.library.functions.gnutls_global_set_log_level(11)

1799

1782

1800

1783

(gnutls.library.functions

1801

1784

.gnutls_global_set_log_function(debug_gnutls))

1802

1785

1803

1786

# Redirect stdin so all checkers get /dev/null

1804

1787

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

1805

1788

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

1808

1791

else:

1809

1792

# No console logging

1810

1793

logger.removeHandler(console)

1811

1794

1812

1795

1813

1796

global main_loop

1814

1797

# From the Avahi example code