/mandos/release : revision 296

65

import types

66

import binascii

67

import tempfile

68

import itertools

69

68

70

69

import dbus

71

70

import dbus.service

86

85

except ImportError:

87

86

SO_BINDTODEVICE = None

88

87

89

version = "1.5.3"

88

version = "1.5.2"

90

89

stored_state_file = "clients.pickle"

91

90

92

91

logger = logging.getLogger()

176

175

177

176

def encrypt(self, data, password):

178

177

self.gnupg.passphrase = self.password_encode(password)

179

with open(os.devnull, "w") as devnull:

178

with open(os.devnull) as devnull:

180

179

try:

181

180

proc = self.gnupg.run(['--symmetric'],

182

181

create_fhs=['stdin', 'stdout'],

193

192

194

193

def decrypt(self, data, password):

195

194

self.gnupg.passphrase = self.password_encode(password)

196

with open(os.devnull, "w") as devnull:

195

with open(os.devnull) as devnull:

197

196

try:

198

197

proc = self.gnupg.run(['--decrypt'],

199

198

create_fhs=['stdin', 'stdout'],

200

199

attach_fhs={'stderr': devnull})

201

with contextlib.closing(proc.handles['stdin']) as f:

200

with contextlib.closing(proc.handles['stdin'] ) as f:

202

201

f.write(data)

203

202

with contextlib.closing(proc.handles['stdout']) as f:

204

203

decrypted_plaintext = f.read()

209

208

return decrypted_plaintext

210

209

211

210

211

212

class AvahiError(Exception):

213

def __init__(self, value, *args, **kwargs):

214

self.value = value

243

server: D-Bus Server

244

bus: dbus.SystemBus()

245

"""

246

247

246

def __init__(self, interface = avahi.IF_UNSPEC, name = None,

248

247

servicetype = None, port = None, TXT = None,

249

248

domain = "", host = "", max_renames = 32768,

262

261

self.server = None

263

262

self.bus = bus

264

263

self.entry_group_state_changed_match = None

265

266

264

def rename(self):

267

265

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

268

266

if self.rename_count >= self.max_renames:

278

276

try:

279

277

self.add()

280

278

except dbus.exceptions.DBusException as error:

281

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

279

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

282

280

self.cleanup()

283

281

os._exit(1)

284

282

self.rename_count += 1

285

286

283

def remove(self):

287

284

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

288

285

if self.entry_group_state_changed_match is not None:

290

287

self.entry_group_state_changed_match = None

291

288

if self.group is not None:

292

289

self.group.Reset()

293

294

290

def add(self):

295

291

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

296

292

self.remove()

313

309

dbus.UInt16(self.port),

314

310

avahi.string_array_to_txt_array(self.TXT))

315

311

self.group.Commit()

316

317

312

def entry_group_state_changed(self, state, error):

318

313

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

319

314

logger.debug("Avahi entry group state change: %i", state)

326

321

elif state == avahi.ENTRY_GROUP_FAILURE:

327

322

logger.critical("Avahi: Error in group state changed %s",

328

323

unicode(error))

329

raise AvahiGroupError("State changed: {0!s}"

330

.format(error))

331

324

raise AvahiGroupError("State changed: %s"

325

% unicode(error))

332

326

def cleanup(self):

333

327

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

334

328

if self.group is not None:

339

333

pass

340

334

self.group = None

341

335

self.remove()

342

343

336

def server_state_changed(self, state, error=None):

344

337

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

345

338

logger.debug("Avahi server state change: %i", state)

364

357

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

365

358

else:

366

359

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

367

368

360

def activate(self):

369

361

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

370

362

if self.server is None:

382

374

"""Add the new name to the syslog messages"""

383

375

ret = AvahiService.rename(self)

384

376

syslogger.setFormatter(logging.Formatter

385

('Mandos ({0}) [%(process)d]:'

386

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

387

.format(self.name)))

377

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

378

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

379

% self.name))

388

380

return ret

389

381

390

382

def timedelta_to_milliseconds(td):

392

384

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

393

385

+ (td.seconds * 1000)

394

386

+ (td.microseconds // 1000))

395

387

396

388

class Client(object):

397

389

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

398

390

465

457

466

458

def approval_delay_milliseconds(self):

467

459

return timedelta_to_milliseconds(self.approval_delay)

468

460

469

461

@staticmethod

470

462

def config_parser(config):

471

463

"""Construct a new dict of client settings of this form:

496

488

"rb") as secfile:

497

489

client["secret"] = secfile.read()

498

490

else:

499

raise TypeError("No secret or secfile for section {0}"

500

.format(section))

491

raise TypeError("No secret or secfile for section %s"

492

% section)

501

493

client["timeout"] = string_to_delta(section["timeout"])

502

494

client["extended_timeout"] = string_to_delta(

503

495

section["extended_timeout"])

512

504

client["last_checker_status"] = -2

513

505

514

506

return settings

515

507

508

516

509

def __init__(self, settings, name = None):

510

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

511

'checker_command' attribute and *not* the 'checker'

512

attribute."""

517

513

self.name = name

518

514

# adding all client settings

519

515

for setting, value in settings.iteritems():

528

524

else:

529

525

self.last_enabled = None

530

526

self.expires = None

531

527

532

528

logger.debug("Creating client %r", self.name)

533

529

# Uppercase and remove spaces from fingerprint for later

534

530

# comparison purposes with return value from the fingerprint()

536

532

logger.debug(" Fingerprint: %s", self.fingerprint)

537

533

self.created = settings.get("created",

538

534

datetime.datetime.utcnow())

539

535

540

536

# attributes specific for this server instance

541

537

self.checker = None

542

538

self.checker_initiator_tag = None

696

692

try:

697

693

command = self.checker_command % escaped_attrs

698

694

except TypeError as error:

699

logger.error('Could not format string "%s"',

700

self.checker_command, exc_info=error)

695

logger.error('Could not format string "%s":'

696

' %s', self.checker_command, error)

701

697

return True # Try again later

702

698

self.current_checker_command = command

703

699

try:

721

717

gobject.source_remove(self.checker_callback_tag)

722

718

self.checker_callback(pid, status, command)

723

719

except OSError as error:

724

logger.error("Failed to start subprocess",

725

exc_info=error)

720

logger.error("Failed to start subprocess: %s",

721

error)

726

722

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

727

723

return True

728

724

735

731

return

736

732

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

737

733

try:

738

self.checker.terminate()

734

os.kill(self.checker.pid, signal.SIGTERM)

739

735

#time.sleep(0.5)

740

736

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

741

# self.checker.kill()

737

# os.kill(self.checker.pid, signal.SIGKILL)

742

738

except OSError as error:

743

739

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

744

740

raise

761

757

# "Set" method, so we fail early here:

762

758

if byte_arrays and signature != "ay":

763

759

raise ValueError("Byte arrays not supported for non-'ay'"

764

" signature {0!r}".format(signature))

760

" signature %r" % signature)

765

761

def decorator(func):

766

762

func._dbus_is_property = True

767

763

func._dbus_interface = dbus_interface

775

771

return decorator

776

772

777

773

778

def dbus_interface_annotations(dbus_interface):

779

"""Decorator for marking functions returning interface annotations

780

781

Usage:

782

783

@dbus_interface_annotations("org.example.Interface")

784

def _foo(self): # Function name does not matter

785

return {"org.freedesktop.DBus.Deprecated": "true",

786

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

787

"false"}

788

"""

789

def decorator(func):

790

func._dbus_is_interface = True

791

func._dbus_interface = dbus_interface

792

func._dbus_name = dbus_interface

793

return func

794

return decorator

795

796

797

def dbus_annotations(annotations):

798

"""Decorator to annotate D-Bus methods, signals or properties

799

Usage:

800

801

@dbus_service_property("org.example.Interface", signature="b",

802

access="r")

803

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

804

"org.freedesktop.DBus.Property."

805

"EmitsChangedSignal": "false"})

806

def Property_dbus_property(self):

807

return dbus.Boolean(False)

808

"""

809

def decorator(func):

810

func._dbus_annotations = annotations

811

return func

812

return decorator

813

814

815

774

class DBusPropertyException(dbus.exceptions.DBusException):

816

775

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

817

776

"""

840

799

"""

841

800

842

801

@staticmethod

843

def _is_dbus_thing(thing):

844

"""Returns a function testing if an attribute is a D-Bus thing

845

846

If called like _is_dbus_thing("method") it returns a function

847

suitable for use as predicate to inspect.getmembers().

848

"""

849

return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),

850

False)

802

def _is_dbus_property(obj):

803

return getattr(obj, "_dbus_is_property", False)

851

804

852

def _get_all_dbus_things(self, thing):

805

def _get_all_dbus_properties(self):

853

806

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

854

807

"""

855

return ((getattr(athing.__get__(self), "_dbus_name",

856

name),

857

athing.__get__(self))

808

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

858

809

for cls in self.__class__.__mro__

859

for name, athing in

860

inspect.getmembers(cls,

861

self._is_dbus_thing(thing)))

810

for name, prop in

811

inspect.getmembers(cls, self._is_dbus_property))

862

812

863

813

def _get_dbus_property(self, interface_name, property_name):

864

814

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

866

816

"""

867

817

for cls in self.__class__.__mro__:

868

818

for name, value in (inspect.getmembers

869

(cls,

870

self._is_dbus_thing("property"))):

819

(cls, self._is_dbus_property)):

871

820

if (value._dbus_name == property_name

872

821

and value._dbus_interface == interface_name):

873

822

return value.__get__(self)

915

864

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

916

865

"""

917

866

properties = {}

918

for name, prop in self._get_all_dbus_things("property"):

867

for name, prop in self._get_all_dbus_properties():

919

868

if (interface_name

920

869

and interface_name != prop._dbus_interface):

921

870

# Interface non-empty but did not match

936

885

path_keyword='object_path',

937

886

connection_keyword='connection')

938

887

def Introspect(self, object_path, connection):

939

"""Overloading of standard D-Bus method.

940

941

Inserts property tags and interface annotation tags.

888

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

942

889

"""

943

890

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

944

891

connection)

951

898

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

952

899

return e

953

900

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

954

# Add property tags

955

901

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

956

902

for name, prop

957

in self._get_all_dbus_things("property")

903

in self._get_all_dbus_properties()

958

904

if prop._dbus_interface

959

905

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

960

906

if_tag.appendChild(tag)

961

# Add annotation tags

962

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

963

for tag in if_tag.getElementsByTagName(typ):

964

annots = dict()

965

for name, prop in (self.

966

_get_all_dbus_things(typ)):

967

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

968

and prop._dbus_interface

969

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

970

annots.update(getattr

971

(prop,

972

"_dbus_annotations",

973

{}))

974

for name, value in annots.iteritems():

975

ann_tag = document.createElement(

976

"annotation")

977

ann_tag.setAttribute("name", name)

978

ann_tag.setAttribute("value", value)

979

tag.appendChild(ann_tag)

980

# Add interface annotation tags

981

for annotation, value in dict(

982

itertools.chain(

983

*(annotations().iteritems()

984

for name, annotations in

985

self._get_all_dbus_things("interface")

986

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

987

))).iteritems():

988

ann_tag = document.createElement("annotation")

989

ann_tag.setAttribute("name", annotation)

990

ann_tag.setAttribute("value", value)

991

if_tag.appendChild(ann_tag)

992

907

# Add the names to the return values for the

993

908

# "org.freedesktop.DBus.Properties" methods

994

909

if (if_tag.getAttribute("name")

1009

924

except (AttributeError, xml.dom.DOMException,

1010

925

xml.parsers.expat.ExpatError) as error:

1011

926

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

1012

exc_info=error)

927

error)

1013

928

return xmlstring

1014

929

1015

930

1029

944

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

1030

945

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

1031

946

# methods, signals, or properties in them

1032

old_interface_names = []

1033

947

for base in (b for b in bases

1034

948

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

1035

949

# Go though all attributes of the base class

1045

959

alt_interface = (attribute._dbus_interface

1046

960

.replace("se.recompile.Mandos",

1047

961

"se.bsnet.fukt.Mandos"))

1048

if alt_interface != attribute._dbus_interface:

1049

old_interface_names.append(alt_interface)

1050

962

# Is this a D-Bus signal?

1051

963

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

1052

964

# Extract the original non-method function by

1067

979

nonmethod_func.func_name,

1068

980

nonmethod_func.func_defaults,

1069

981

nonmethod_func.func_closure)))

1070

# Copy annotations, if any

1071

try:

1072

new_function._dbus_annotations = (

1073

dict(attribute._dbus_annotations))

1074

except AttributeError:

1075

pass

1076

982

# Define a creator of a function to call both the

1077

983

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

1078

984

# signals gets sent when the function is called

1106

1012

attribute.func_name,

1107

1013

attribute.func_defaults,

1108

1014

attribute.func_closure)))

1109

# Copy annotations, if any

1110

try:

1111

attr[attrname]._dbus_annotations = (

1112

dict(attribute._dbus_annotations))

1113

except AttributeError:

1114

pass

1115

1015

# Is this a D-Bus property?

1116

1016

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

1117

1017

# Create a new, but exactly alike, function

1131

1031

attribute.func_name,

1132

1032

attribute.func_defaults,

1133

1033

attribute.func_closure)))

1134

# Copy annotations, if any

1135

try:

1136

attr[attrname]._dbus_annotations = (

1137

dict(attribute._dbus_annotations))

1138

except AttributeError:

1139

pass

1140

# Is this a D-Bus interface?

1141

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

1142

# Create a new, but exactly alike, function

1143

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

1144

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

1145

# to the class.

1146

attr[attrname] = (dbus_interface_annotations

1147

(alt_interface)

1148

(types.FunctionType

1149

(attribute.func_code,

1150

attribute.func_globals,

1151

attribute.func_name,

1152

attribute.func_defaults,

1153

attribute.func_closure)))

1154

# Deprecate all old interfaces

1155

iname="_AlternateDBusNamesMetaclass_interface_annotation{0}"

1156

for old_interface_name in old_interface_names:

1157

@dbus_interface_annotations(old_interface_name)

1158

def func(self):

1159

return { "org.freedesktop.DBus.Deprecated": "true" }

1160

# Find an unused name

1161

for aname in (iname.format(i) for i in itertools.count()):

1162

if aname not in attr:

1163

attr[aname] = func

1164

break

1165

1034

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

1166

1035

1167

1036

1190

1059

("/clients/" + client_object_name))

1191

1060

DBusObjectWithProperties.__init__(self, self.bus,

1192

1061

self.dbus_object_path)

1193

1062

1194

1063

def notifychangeproperty(transform_func,

1195

1064

dbus_name, type_func=lambda x: x,

1196

1065

variant_level=1):

1219

1088

1220

1089

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

1221

1090

1091

1222

1092

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1223

1093

approvals_pending = notifychangeproperty(dbus.Boolean,

1224

1094

"ApprovalPending",

1312

1182

(self.approval_duration),

1313

1183

self._reset_approved)

1314

1184

1185

1315

1186

## D-Bus methods, signals & properties

1316

1187

_interface = "se.recompile.Mandos.Client"

1317

1188

1318

## Interfaces

1319

1320

@dbus_interface_annotations(_interface)

1321

def _foo(self):

1322

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

1323

"false"}

1324

1325

1189

## Signals

1326

1190

1327

1191

# CheckerCompleted - signal

1741

1605

try:

1742

1606

sent = session.send(client.secret[sent_size:])

1743

1607

except gnutls.errors.GNUTLSError as error:

1744

logger.warning("gnutls send failed",

1745

exc_info=error)

1608

logger.warning("gnutls send failed")

1746

1609

return

1747

1610

logger.debug("Sent: %d, remaining: %d",

1748

1611

sent, len(client.secret)

1762

1625

try:

1763

1626

session.bye()

1764

1627

except gnutls.errors.GNUTLSError as error:

1765

logger.warning("GnuTLS bye failed",

1766

exc_info=error)

1628

logger.warning("GnuTLS bye failed")

1767

1629

1768

1630

@staticmethod

1769

1631

def peer_certificate(session):

2081

1943

elif suffix == "w":

2082

1944

delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)

2083

1945

else:

2084

raise ValueError("Unknown suffix {0!r}"

2085

.format(suffix))

1946

raise ValueError("Unknown suffix %r" % suffix)

2086

1947

except (ValueError, IndexError) as e:

2087

1948

raise ValueError(*(e.args))

2088

1949

timevalue += delta

2102

1963

sys.exit()

2103

1964

if not noclose:

2104

1965

# Close all standard open file descriptors

2105

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

1966

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

2106

1967

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

2107

1968

raise OSError(errno.ENODEV,

2108

"{0} not a character device"

2109

.format(os.devnull))

1969

"%s not a character device"

1970

% os.path.devnull)

2110

1971

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

2111

1972

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

2112

1973

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

2121

1982

2122

1983

parser = argparse.ArgumentParser()

2123

1984

parser.add_argument("-v", "--version", action="version",

2124

version = "%(prog)s {0}".format(version),

1985

version = "%%(prog)s %s" % version,

2125

1986

help="show version number and exit")

2126

1987

parser.add_argument("-i", "--interface", metavar="IF",

2127

1988

help="Bind to interface IF")

2230

2091

2231

2092

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

2232

2093

syslogger.setFormatter(logging.Formatter

2233

('Mandos ({0}) [%(process)d]:'

2234

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

2235

.format(server_settings

2236

["servicename"])))

2094

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

2095

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

2096

% server_settings["servicename"]))

2237

2097

2238

2098

# Parse config file with clients

2239

2099

client_config = configparser.SafeConfigParser(Client

2257

2117

pidfilename = "/var/run/mandos.pid"

2258

2118

try:

2259

2119

pidfile = open(pidfilename, "w")

2260

except IOError as e:

2261

logger.error("Could not open file %r", pidfilename,

2262

exc_info=e)

2120

except IOError:

2121

logger.error("Could not open file %r", pidfilename)

2263

2122

2264

for name in ("_mandos", "mandos", "nobody"):

2123

try:

2124

uid = pwd.getpwnam("_mandos").pw_uid

2125

gid = pwd.getpwnam("_mandos").pw_gid

2126

except KeyError:

2265

2127

try:

2266

uid = pwd.getpwnam(name).pw_uid

2267

gid = pwd.getpwnam(name).pw_gid

2268

break

2128

uid = pwd.getpwnam("mandos").pw_uid

2129

gid = pwd.getpwnam("mandos").pw_gid

2269

2130

except KeyError:

2270

continue

2271

else:

2272

uid = 65534

2273

gid = 65534

2131

try:

2132

uid = pwd.getpwnam("nobody").pw_uid

2133

gid = pwd.getpwnam("nobody").pw_gid

2134

except KeyError:

2135

uid = 65534

2136

gid = 65534

2274

2137

try:

2275

2138

os.setgid(gid)

2276

2139

os.setuid(uid)

2293

2156

.gnutls_global_set_log_function(debug_gnutls))

2294

2157

2295

2158

# Redirect stdin so all checkers get /dev/null

2296

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

2159

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

2297

2160

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

2298

2161

if null > 2:

2299

2162

os.close(null)

2307

2170

2308

2171

global main_loop

2309

2172

# From the Avahi example code

2310

DBusGMainLoop(set_as_default=True)

2173

DBusGMainLoop(set_as_default=True )

2311

2174

main_loop = gobject.MainLoop()

2312

2175

bus = dbus.SystemBus()

2313

2176

# End of Avahi example code

2319

2182

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

2320

2183

do_not_queue=True))

2321

2184

except dbus.exceptions.NameExistsException as e:

2322

logger.error("Disabling D-Bus:", exc_info=e)

2185

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

2323

2186

use_dbus = False

2324

2187

server_settings["use_dbus"] = False

2325

2188

tcp_server.use_dbus = False

2352

2215

(stored_state))

2353

2216

os.remove(stored_state_path)

2354

2217

except IOError as e:

2355

if e.errno == errno.ENOENT:

2356

logger.warning("Could not load persistent state: {0}"

2357

.format(os.strerror(e.errno)))

2358

else:

2359

logger.critical("Could not load persistent state:",

2360

exc_info=e)

2218

logger.warning("Could not load persistent state: {0}"

2219

.format(e))

2220

if e.errno != errno.ENOENT:

2361

2221

raise

2362

2222

except EOFError as e:

2363

2223

logger.warning("Could not load persistent state: "

2364

"EOFError:", exc_info=e)

2224

"EOFError: {0}".format(e))

2365

2225

2366

2226

with PGPEngine() as pgp:

2367

2227

for client_name, client in clients_data.iteritems():

2420

2280

.format(client_name))

2421

2281

client["secret"] = (

2422

2282

client_settings[client_name]["secret"])

2283

2423

2284

2424

2285

# Add/remove clients based on new changes made to config

2425

2286

for client_name in (set(old_client_settings)

2428

2289

for client_name in (set(client_settings)

2429

2290

- set(old_client_settings)):

2430

2291

clients_data[client_name] = client_settings[client_name]

2431

2292

2432

2293

# Create all client objects

2433

2294

for client_name, client in clients_data.iteritems():

2434

2295

tcp_server.clients[client_name] = client_class(

2436

2297

2437

2298

if not tcp_server.clients:

2438

2299

logger.warning("No clients defined")

2439

2300

2440

2301

if not debug:

2441

2302

try:

2442

2303

with pidfile:

2456

2317

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

2457

2318

2458

2319

if use_dbus:

2459

class MandosDBusService(DBusObjectWithProperties):

2320

class MandosDBusService(dbus.service.Object):

2460

2321

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

2461

2322

def __init__(self):

2462

2323

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

2463

2324

_interface = "se.recompile.Mandos"

2464

2325

2465

@dbus_interface_annotations(_interface)

2466

def _foo(self):

2467

return { "org.freedesktop.DBus.Property"

2468

".EmitsChangedSignal":

2469

"false"}

2470

2471

2326

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

2472

2327

def ClientAdded(self, objpath):

2473

2328

"D-Bus signal"

2564

2419

pickle.dump((clients, client_settings), stored_state)

2565

2420

os.rename(tempname, stored_state_path)

2566

2421

except (IOError, OSError) as e:

2422

logger.warning("Could not save persistent state: {0}"

2423

.format(e))

2567

2424

if not debug:

2568

2425

try:

2569

2426

os.remove(tempname)

2570

2427

except NameError:

2571

2428

pass

2572

if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):

2573

logger.warning("Could not save persistent state: {0}"

2574

.format(os.strerror(e.errno)))

2575

else:

2576

logger.warning("Could not save persistent state:",

2577

exc_info=e)

2429

if e.errno not in set((errno.ENOENT, errno.EACCES,

2430

errno.EEXIST)):

2578

2431

raise e

2579

2432

2580

2433

# Delete all clients, and settings from config

2608

2461

service.port = tcp_server.socket.getsockname()[1]

2609

2462

if use_ipv6:

2610

2463

logger.info("Now listening on address %r, port %d,"

2611

" flowinfo %d, scope_id %d",

2612

*tcp_server.socket.getsockname())

2464

" flowinfo %d, scope_id %d"

2465

% tcp_server.socket.getsockname())

2613

2466

else: # IPv4

2614

logger.info("Now listening on address %r, port %d",

2615

*tcp_server.socket.getsockname())

2467

logger.info("Now listening on address %r, port %d"

2468

% tcp_server.socket.getsockname())

2616

2469

2617

2470

#service.interface = tcp_server.socket.getsockname()[3]

2618

2471

2621

2474

try:

2622

2475

service.activate()

2623

2476

except dbus.exceptions.DBusException as error:

2624

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

2477

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

2625

2478

cleanup()

2626

2479

sys.exit(1)

2627

2480

# End of Avahi example code

2634

2487

logger.debug("Starting main loop")

2635

2488

main_loop.run()

2636

2489

except AvahiError as error:

2637

logger.critical("Avahi Error", exc_info=error)

2490

logger.critical("AvahiError: %s", error)

2638

2491

cleanup()

2639

2492

sys.exit(1)

2640

2493

except KeyboardInterrupt: