/mandos/trunk : revision 571

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

from future_builtins import *

38

39

37

import SocketServer as socketserver

40

38

import socket

41

39

import argparse

211

209

return decrypted_plaintext

212

210

213

211

212

214

213

class AvahiError(Exception):

215

214

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

216

215

self.value = value

245

244

server: D-Bus Server

246

245

bus: dbus.SystemBus()

247

246

"""

248

249

247

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

250

248

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

251

249

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

264

262

self.server = None

265

263

self.bus = bus

266

264

self.entry_group_state_changed_match = None

267

268

265

def rename(self):

269

266

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

270

267

if self.rename_count >= self.max_renames:

284

281

self.cleanup()

285

282

os._exit(1)

286

283

self.rename_count += 1

287

288

284

def remove(self):

289

285

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

290

286

if self.entry_group_state_changed_match is not None:

292

288

self.entry_group_state_changed_match = None

293

289

if self.group is not None:

294

290

self.group.Reset()

295

296

291

def add(self):

297

292

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

298

293

self.remove()

315

310

dbus.UInt16(self.port),

316

311

avahi.string_array_to_txt_array(self.TXT))

317

312

self.group.Commit()

318

319

313

def entry_group_state_changed(self, state, error):

320

314

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

321

315

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

330

324

unicode(error))

331

325

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

332

326

.format(error))

333

334

327

def cleanup(self):

335

328

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

336

329

if self.group is not None:

341

334

pass

342

335

self.group = None

343

336

self.remove()

344

345

337

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

346

338

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

347

339

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

366

358

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

367

359

else:

368

360

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

369

370

361

def activate(self):

371

362

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

372

363

if self.server is None:

379

370

self.server_state_changed)

380

371

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

381

372

382

383

373

class AvahiServiceToSyslog(AvahiService):

384

374

def rename(self):

385

375

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

390

380

.format(self.name)))

391

381

return ret

392

382

393

394

383

def timedelta_to_milliseconds(td):

395

384

"Convert a datetime.timedelta() to milliseconds"

396

385

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

397

386

+ (td.seconds * 1000)

398

387

+ (td.microseconds // 1000))

399

400

388

401

389

class Client(object):

402

390

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

403

391

442

430

"""

443

431

444

432

runtime_expansions = ("approval_delay", "approval_duration",

445

"created", "enabled", "expires",

446

"fingerprint", "host", "interval",

447

"last_approval_request", "last_checked_ok",

433

"created", "enabled", "fingerprint",

434

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

448

435

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

449

436

client_defaults = { "timeout": "5m",

450

437

"extended_timeout": "15m",

471

458

472

459

def approval_delay_milliseconds(self):

473

460

return timedelta_to_milliseconds(self.approval_delay)

474

461

475

462

@staticmethod

476

463

def config_parser(config):

477

464

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

518

505

client["last_checker_status"] = -2

519

506

520

507

return settings

521

508

509

522

510

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

511

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

512

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

513

attribute."""

523

514

self.name = name

524

515

# adding all client settings

525

516

for setting, value in settings.iteritems():

534

525

else:

535

526

self.last_enabled = None

536

527

self.expires = None

537

528

538

529

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

539

530

# Uppercase and remove spaces from fingerprint for later

540

531

# comparison purposes with return value from the fingerprint()

542

533

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

543

534

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

544

535

datetime.datetime.utcnow())

545

536

546

537

# attributes specific for this server instance

547

538

self.checker = None

548

539

self.checker_initiator_tag = None

576

567

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

577

568

# Already enabled

578

569

return

570

self.send_changedstate()

579

571

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

580

572

self.enabled = True

581

573

self.last_enabled = datetime.datetime.utcnow()

582

574

self.init_checker()

583

self.send_changedstate()

584

575

585

576

def disable(self, quiet=True):

586

577

"""Disable this client."""

587

578

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

588

579

return False

589

580

if not quiet:

581

self.send_changedstate()

582

if not quiet:

590

583

logger.info("Disabling client %s", self.name)

591

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

584

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

592

585

gobject.source_remove(self.disable_initiator_tag)

593

586

self.disable_initiator_tag = None

594

587

self.expires = None

595

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

588

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

596

589

gobject.source_remove(self.checker_initiator_tag)

597

590

self.checker_initiator_tag = None

598

591

self.stop_checker()

599

592

self.enabled = False

600

if not quiet:

601

self.send_changedstate()

602

593

# Do not run this again if called by a gobject.timeout_add

603

594

return False

604

595

608

599

def init_checker(self):

609

600

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

610

601

# and every interval from then on.

611

if self.checker_initiator_tag is not None:

612

gobject.source_remove(self.checker_initiator_tag)

613

602

self.checker_initiator_tag = (gobject.timeout_add

614

603

(self.interval_milliseconds(),

615

604

self.start_checker))

616

605

# Schedule a disable() when 'timeout' has passed

617

if self.disable_initiator_tag is not None:

618

gobject.source_remove(self.disable_initiator_tag)

619

606

self.disable_initiator_tag = (gobject.timeout_add

620

607

(self.timeout_milliseconds(),

621

608

self.disable))

652

639

timeout = self.timeout

653

640

if self.disable_initiator_tag is not None:

654

641

gobject.source_remove(self.disable_initiator_tag)

655

self.disable_initiator_tag = None

656

642

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

657

643

self.disable_initiator_tag = (gobject.timeout_add

658

644

(timedelta_to_milliseconds

668

654

If a checker already exists, leave it running and do

669

655

nothing."""

670

656

# The reason for not killing a running checker is that if we

671

# did that, and if a checker (for some reason) started running

672

# slowly and taking more than 'interval' time, then the client

673

# would inevitably timeout, since no checker would get a

674

# chance to run to completion. If we instead leave running

657

# did that, then if a checker (for some reason) started

658

# running slowly and taking more than 'interval' time, the

659

# client would inevitably timeout, since no checker would get

660

# a chance to run to completion. If we instead leave running

675

661

# checkers alone, the checker would have to take more time

676

662

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

677

663

# should be.

691

677

self.current_checker_command)

692

678

# Start a new checker if needed

693

679

if self.checker is None:

694

# Escape attributes for the shell

695

escaped_attrs = dict(

696

(attr, re.escape(unicode(getattr(self, attr))))

697

for attr in

698

self.runtime_expansions)

699

680

try:

700

command = self.checker_command % escaped_attrs

701

except TypeError as error:

702

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

703

self.checker_command, exc_info=error)

704

return True # Try again later

681

# In case checker_command has exactly one % operator

682

command = self.checker_command % self.host

683

except TypeError:

684

# Escape attributes for the shell

685

escaped_attrs = dict(

686

(attr,

687

re.escape(unicode(str(getattr(self, attr, "")),

688

errors=

689

'replace')))

690

for attr in

691

self.runtime_expansions)

692

693

try:

694

command = self.checker_command % escaped_attrs

695

except TypeError as error:

696

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

697

self.checker_command, exc_info=error)

698

return True # Try again later

705

699

self.current_checker_command = command

706

700

try:

707

701

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

713

707

self.checker = subprocess.Popen(command,

714

708

close_fds=True,

715

709

shell=True, cwd="/")

710

self.checker_callback_tag = (gobject.child_watch_add

711

(self.checker.pid,

712

self.checker_callback,

713

data=command))

714

# The checker may have completed before the gobject

715

# watch was added. Check for this.

716

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

717

if pid:

718

gobject.source_remove(self.checker_callback_tag)

719

self.checker_callback(pid, status, command)

716

720

except OSError as error:

717

721

logger.error("Failed to start subprocess",

718

722

exc_info=error)

719

self.checker_callback_tag = (gobject.child_watch_add

720

(self.checker.pid,

721

self.checker_callback,

722

data=command))

723

# The checker may have completed before the gobject

724

# watch was added. Check for this.

725

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

726

if pid:

727

gobject.source_remove(self.checker_callback_tag)

728

self.checker_callback(pid, status, command)

729

723

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

730

724

return True

731

725

779

773

780

774

781

775

def dbus_interface_annotations(dbus_interface):

782

"""Decorator for marking functions returning interface annotations

776

"""Decorator for marking functions returning interface annotations.

783

777

784

778

Usage:

785

779

982

976

tag.appendChild(ann_tag)

983

977

# Add interface annotation tags

984

978

for annotation, value in dict(

985

itertools.chain.from_iterable(

986

annotations().iteritems()

987

for name, annotations in

988

self._get_all_dbus_things("interface")

989

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

990

)).iteritems():

979

itertools.chain(

980

*(annotations().iteritems()

981

for name, annotations in

982

self._get_all_dbus_things("interface")

983

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

984

))).iteritems():

991

985

ann_tag = document.createElement("annotation")

992

986

ann_tag.setAttribute("name", annotation)

993

987

ann_tag.setAttribute("value", value)

1024

1018

variant_level=variant_level)

1025

1019

1026

1020

1027

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1028

"""A class decorator; applied to a subclass of

1029

dbus.service.Object, it will add alternate D-Bus attributes with

1030

interface names according to the "alt_interface_names" mapping.

1031

Usage:

1032

1033

@alternate_dbus_names({"org.example.Interface":

1034

"net.example.AlternateInterface"})

1035

class SampleDBusObject(dbus.service.Object):

1036

@dbus.service.method("org.example.Interface")

1037

def SampleDBusMethod():

1038

pass

1039

1040

The above "SampleDBusMethod" on "SampleDBusObject" will be

1041

reachable via two interfaces: "org.example.Interface" and

1042

"net.example.AlternateInterface", the latter of which will have

1043

its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to

1044

"true", unless "deprecate" is passed with a False value.

1045

1046

This works for methods and signals, and also for D-Bus properties

1047

(from DBusObjectWithProperties) and interfaces (from the

1048

dbus_interface_annotations decorator).

1021

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

1022

.__metaclass__):

1023

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

1024

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

1049

1025

"""

1050

def wrapper(cls):

1051

for orig_interface_name, alt_interface_name in (

1052

alt_interface_names.iteritems()):

1053

attr = {}

1054

interface_names = set()

1055

# Go though all attributes of the class

1056

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

1026

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

1027

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

1028

# methods, signals, or properties in them

1029

old_interface_names = []

1030

for base in (b for b in bases

1031

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

1032

# Go though all attributes of the base class

1033

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

1057

1034

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

1058

1035

# with the wrong interface name

1059

1036

if (not hasattr(attribute, "_dbus_interface")

1060

1037

or not attribute._dbus_interface

1061

.startswith(orig_interface_name)):

1038

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

1062

1039

continue

1063

1040

# Create an alternate D-Bus interface name based on

1064

1041

# the current name

1065

1042

alt_interface = (attribute._dbus_interface

1066

.replace(orig_interface_name,

1067

alt_interface_name))

1068

interface_names.add(alt_interface)

1043

.replace("se.recompile.Mandos",

1044

"se.bsnet.fukt.Mandos"))

1045

if alt_interface != attribute._dbus_interface:

1046

old_interface_names.append(alt_interface)

1069

1047

# Is this a D-Bus signal?

1070

1048

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

1071

1049

# Extract the original non-method function by

1093

1071

except AttributeError:

1094

1072

pass

1095

1073

# Define a creator of a function to call both the

1096

# original and alternate functions, so both the

1097

# original and alternate signals gets sent when

1098

# the function is called

1074

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

1075

# signals gets sent when the function is called

1099

1076

def fixscope(func1, func2):

1100

1077

"""This function is a scope container to pass

1101

1078

func1 and func2 to the "call_both" function

1108

1085

return call_both

1109

1086

# Create the "call_both" function and add it to

1110

1087

# the class

1111

attr[attrname] = fixscope(attribute, new_function)

1088

attr[attrname] = fixscope(attribute,

1089

new_function)

1112

1090

# Is this a D-Bus method?

1113

1091

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

1114

1092

# Create a new, but exactly alike, function

1170

1148

attribute.func_name,

1171

1149

attribute.func_defaults,

1172

1150

attribute.func_closure)))

1173

if deprecate:

1174

# Deprecate all alternate interfaces

1175

iname="_AlternateDBusNames_interface_annotation{0}"

1176

for interface_name in interface_names:

1177

@dbus_interface_annotations(interface_name)

1178

def func(self):

1179

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

1180

"true" }

1181

# Find an unused name

1182

for aname in (iname.format(i)

1183

for i in itertools.count()):

1184

if aname not in attr:

1185

attr[aname] = func

1186

break

1187

if interface_names:

1188

# Replace the class with a new subclass of it with

1189

# methods, signals, etc. as created above.

1190

cls = type(b"{0}Alternate".format(cls.__name__),

1191

(cls,), attr)

1192

return cls

1193

return wrapper

1194

1195

1196

@alternate_dbus_interfaces({"se.recompile.Mandos":

1197

"se.bsnet.fukt.Mandos"})

1151

# Deprecate all old interfaces

1152

basename="_AlternateDBusNamesMetaclass_interface_annotation{0}"

1153

for old_interface_name in old_interface_names:

1154

@dbus_interface_annotations(old_interface_name)

1155

def func(self):

1156

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

1157

# Find an unused name

1158

for aname in (basename.format(i) for i in

1159

itertools.count()):

1160

if aname not in attr:

1161

attr[aname] = func

1162

break

1163

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

1164

1165

1198

1166

class ClientDBus(Client, DBusObjectWithProperties):

1199

1167

"""A Client class using D-Bus

1200

1168

1220

1188

("/clients/" + client_object_name))

1221

1189

DBusObjectWithProperties.__init__(self, self.bus,

1222

1190

self.dbus_object_path)

1223

1191

1224

1192

def notifychangeproperty(transform_func,

1225

1193

dbus_name, type_func=lambda x: x,

1226

1194

variant_level=1):

1249

1217

1250

1218

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

1251

1219

1220

1252

1221

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1253

1222

approvals_pending = notifychangeproperty(dbus.Boolean,

1254

1223

"ApprovalPending",

1336

1305

return False

1337

1306

1338

1307

def approve(self, value=True):

1308

self.send_changedstate()

1339

1309

self.approved = value

1340

1310

gobject.timeout_add(timedelta_to_milliseconds

1341

1311

(self.approval_duration),

1342

1312

self._reset_approved)

1343

self.send_changedstate()

1313

1344

1314

1345

1315

## D-Bus methods, signals & properties

1346

1316

_interface = "se.recompile.Mandos.Client"

1530

1500

def Timeout_dbus_property(self, value=None):

1531

1501

if value is None: # get

1532

1502

return dbus.UInt64(self.timeout_milliseconds())

1533

old_timeout = self.timeout

1534

1503

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

1535

# Reschedule disabling

1504

# Reschedule timeout

1536

1505

if self.enabled:

1537

1506

now = datetime.datetime.utcnow()

1538

self.expires += self.timeout - old_timeout

1539

if self.expires <= now:

1507

time_to_die = timedelta_to_milliseconds(

1508

(self.last_checked_ok + self.timeout) - now)

1509

if time_to_die <= 0:

1540

1510

# The timeout has passed

1541

1511

self.disable()

1542

1512

else:

1513

self.expires = (now +

1514

datetime.timedelta(milliseconds =

1515

time_to_die))

1543

1516

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

1544

1517

is None):

1545

1518

return

1546

1519

gobject.source_remove(self.disable_initiator_tag)

1547

self.disable_initiator_tag = (

1548

gobject.timeout_add(

1549

timedelta_to_milliseconds(self.expires - now),

1550

self.disable))

1520

self.disable_initiator_tag = (gobject.timeout_add

1521

(time_to_die,

1522

self.disable))

1551

1523

1552

1524

# ExtendedTimeout - property

1553

1525

@dbus_service_property(_interface, signature="t",

1632

1604

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

1633

1605

1634

1606

1607

class ClientDBusTransitional(ClientDBus):

1608

__metaclass__ = AlternateDBusNamesMetaclass

1609

1610

1635

1611

class ClientHandler(socketserver.BaseRequestHandler, object):

1636

1612

"""A class to handle client connections.

1637

1613

1741

1717

#wait until timeout or approved

1742

1718

time = datetime.datetime.now()

1743

1719

client.changedstate.acquire()

1744

client.changedstate.wait(

1745

float(timedelta_to_milliseconds(delay)

1746

/ 1000))

1720

(client.changedstate.wait

1721

(float(client.timedelta_to_milliseconds(delay)

1722

/ 1000)))

1747

1723

client.changedstate.release()

1748

1724

time2 = datetime.datetime.now()

1749

1725

if (time2 - time) >= delay:

1765

1741

try:

1766

1742

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

1767

1743

except gnutls.errors.GNUTLSError as error:

1768

logger.warning("gnutls send failed",

1769

exc_info=error)

1744

logger.warning("gnutls send failed")

1770

1745

return

1771

1746

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

1772

1747

sent, len(client.secret)

1786

1761

try:

1787

1762

session.bye()

1788

1763

except gnutls.errors.GNUTLSError as error:

1789

logger.warning("GnuTLS bye failed",

1790

exc_info=error)

1764

logger.warning("GnuTLS bye failed")

1791

1765

1792

1766

@staticmethod

1793

1767

def peer_certificate(session):

1865

1839

def process_request(self, request, address):

1866

1840

"""Start a new process to process the request."""

1867

1841

proc = multiprocessing.Process(target = self.sub_process_main,

1868

args = (request, address))

1842

args = (request,

1843

address))

1869

1844

proc.start()

1870

1845

return proc

1871

1846

1921

1896

str(self.interface

1922

1897

+ '\0'))

1923

1898

except socket.error as error:

1924

if error.errno == errno.EPERM:

1899

if error[0] == errno.EPERM:

1925

1900

logger.error("No permission to"

1926

1901

" bind to interface %s",

1927

1902

self.interface)

1928

elif error.errno == errno.ENOPROTOOPT:

1903

elif error[0] == errno.ENOPROTOOPT:

1929

1904

logger.error("SO_BINDTODEVICE not available;"

1930

1905

" cannot bind to interface %s",

1931

1906

self.interface)

1932

elif error.errno == errno.ENODEV:

1933

logger.error("Interface %s does not"

1934

" exist, cannot bind",

1935

self.interface)

1936

1907

else:

1937

1908

raise

1938

1909

# Only bind(2) the socket if we really need to.

1997

1968

1998

1969

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

1999

1970

proc = None, client_object=None):

1971

condition_names = {

1972

gobject.IO_IN: "IN", # There is data to read.

1973

gobject.IO_OUT: "OUT", # Data can be written (without

1974

# blocking).

1975

gobject.IO_PRI: "PRI", # There is urgent data to read.

1976

gobject.IO_ERR: "ERR", # Error condition.

1977

gobject.IO_HUP: "HUP" # Hung up (the connection has been

1978

# broken, usually for pipes and

1979

# sockets).

1980

}

1981

conditions_string = ' | '.join(name

1982

for cond, name in

1983

condition_names.iteritems()

1984

if cond & condition)

2000

1985

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

2001

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

1986

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

2002

1987

# Wait for other process to exit

2003

1988

proc.join()

2004

1989

return False

2270

2255

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

2271

2256

try:

2272

2257

pidfile = open(pidfilename, "w")

2273

except IOError as e:

2274

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

2275

exc_info=e)

2258

except IOError:

2259

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

2276

2260

2277

2261

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

2278

2262

try:

2288

2272

os.setgid(gid)

2289

2273

os.setuid(uid)

2290

2274

except OSError as error:

2291

if error.errno != errno.EPERM:

2275

if error[0] != errno.EPERM:

2292

2276

raise error

2293

2277

2294

2278

if debug:

2332

2316

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

2333

2317

do_not_queue=True))

2334

2318

except dbus.exceptions.NameExistsException as e:

2335

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

2319

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

2336

2320

use_dbus = False

2337

2321

server_settings["use_dbus"] = False

2338

2322

tcp_server.use_dbus = False

2350

2334

2351

2335

client_class = Client

2352

2336

if use_dbus:

2353

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

2337

client_class = functools.partial(ClientDBusTransitional,

2338

bus = bus)

2354

2339

2355

2340

client_settings = Client.config_parser(client_config)

2356

2341

old_client_settings = {}

2364

2349

(stored_state))

2365

2350

os.remove(stored_state_path)

2366

2351

except IOError as e:

2367

if e.errno == errno.ENOENT:

2368

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

2369

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

2370

else:

2371

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

2372

exc_info=e)

2352

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

2353

.format(e))

2354

if e.errno != errno.ENOENT:

2373

2355

raise

2374

2356

except EOFError as e:

2375

2357

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

2376

"EOFError:", exc_info=e)

2358

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

2377

2359

2378

2360

with PGPEngine() as pgp:

2379

2361

for client_name, client in clients_data.iteritems():

2432

2414

.format(client_name))

2433

2415

client["secret"] = (

2434

2416

client_settings[client_name]["secret"])

2417

2435

2418

2436

2419

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

2437

2420

for client_name in (set(old_client_settings)

2440

2423

for client_name in (set(client_settings)

2441

2424

- set(old_client_settings)):

2442

2425

clients_data[client_name] = client_settings[client_name]

2443

2426

2444

2427

# Create all client objects

2445

2428

for client_name, client in clients_data.iteritems():

2446

2429

tcp_server.clients[client_name] = client_class(

2448

2431

2449

2432

if not tcp_server.clients:

2450

2433

logger.warning("No clients defined")

2451

2434

2452

2435

if not debug:

2453

2436

try:

2454

2437

with pidfile:

2462

2445

# "pidfile" was never created

2463

2446

pass

2464

2447

del pidfilename

2448

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

2465

2449

2466

2450

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

2467

2451

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

2468

2452

2469

2453

if use_dbus:

2470

@alternate_dbus_interfaces({"se.recompile.Mandos":

2471

"se.bsnet.fukt.Mandos"})

2472

2454

class MandosDBusService(DBusObjectWithProperties):

2473

2455

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

2474

2456

def __init__(self):

2528

2510

2529

2511

del _interface

2530

2512

2531

mandos_dbus_service = MandosDBusService()

2513

class MandosDBusServiceTransitional(MandosDBusService):

2514

__metaclass__ = AlternateDBusNamesMetaclass

2515

mandos_dbus_service = MandosDBusServiceTransitional()

2532

2516

2533

2517

def cleanup():

2534

2518

"Cleanup function; run on exit"

2567

2551

del client_settings[client.name]["secret"]

2568

2552

2569

2553

try:

2570

with (tempfile.NamedTemporaryFile

2571

(mode='wb', suffix=".pickle", prefix='clients-',

2572

dir=os.path.dirname(stored_state_path),

2573

delete=False)) as stored_state:

2554

tempfd, tempname = tempfile.mkstemp(suffix=".pickle",

2555

prefix="clients-",

2556

dir=os.path.dirname

2557

(stored_state_path))

2558

with os.fdopen(tempfd, "wb") as stored_state:

2574

2559

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

2575

tempname=stored_state.name

2576

2560

os.rename(tempname, stored_state_path)

2577

2561

except (IOError, OSError) as e:

2562

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

2563

.format(e))

2578

2564

if not debug:

2579

2565

try:

2580

2566

os.remove(tempname)

2581

2567

except NameError:

2582

2568

pass

2583

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

2584

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

2585

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

2586

else:

2587

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

2588

exc_info=e)

2569

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

2570

errno.EEXIST)):

2589

2571

raise e

2590

2572

2591

2573

# Delete all clients, and settings from config