/mandos/release : revision 237.7.127

11

# "AvahiService" class, and some lines in "main".

12

#

13

# Everything else is

14

15

14

15

16

#

17

# This program is free software: you can redistribute it and/or modify

18

# it under the terms of the GNU General Public License as published by

68

import binascii

69

import tempfile

70

import itertools

71

import collections

72

71

73

72

import dbus

74

73

import dbus.service

79

78

import ctypes.util

80

79

import xml.dom.minidom

81

80

import inspect

81

import GnuPGInterface

82

83

try:

84

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

88

except ImportError:

89

SO_BINDTODEVICE = None

90

91

version = "1.6.2"

91

version = "1.5.3"

92

stored_state_file = "clients.pickle"

93

94

logger = logging.getLogger()

139

class PGPEngine(object):

140

"""A simple class for OpenPGP symmetric encryption & decryption"""

141

def __init__(self):

142

self.gnupg = GnuPGInterface.GnuPG()

142

143

self.tempdir = tempfile.mkdtemp(prefix="mandos-")

143

self.gnupgargs = ['--batch',

144

'--home', self.tempdir,

145

'--force-mdc',

146

'--quiet',

147

'--no-use-agent']

144

self.gnupg = GnuPGInterface.GnuPG()

145

self.gnupg.options.meta_interactive = False

146

self.gnupg.options.homedir = self.tempdir

147

self.gnupg.options.extra_args.extend(['--force-mdc',

148

'--quiet',

149

'--no-use-agent'])

148

150

149

151

def __enter__(self):

150

152

return self

151

153

152

def __exit__(self, exc_type, exc_value, traceback):

154

def __exit__ (self, exc_type, exc_value, traceback):

153

155

self._cleanup()

154

156

return False

155

157

172

174

def password_encode(self, password):

173

175

# Passphrase can not be empty and can not contain newlines or

174

176

# NUL bytes. So we prefix it and hex encode it.

175

encoded = b"mandos" + binascii.hexlify(password)

176

if len(encoded) > 2048:

177

# GnuPG can't handle long passwords, so encode differently

178

encoded = (b"mandos" + password.replace(b"\\", b"\\\\")

179

.replace(b"\n", b"\\n")

180

.replace(b"\0", b"\\x00"))

181

return encoded

177

return b"mandos" + binascii.hexlify(password)

182

178

183

179

def encrypt(self, data, password):

184

passphrase = self.password_encode(password)

185

with tempfile.NamedTemporaryFile(dir=self.tempdir

186

) as passfile:

187

passfile.write(passphrase)

188

passfile.flush()

189

proc = subprocess.Popen(['gpg', '--symmetric',

190

'--passphrase-file',

191

passfile.name]

192

+ self.gnupgargs,

193

stdin = subprocess.PIPE,

194

stdout = subprocess.PIPE,

195

stderr = subprocess.PIPE)

196

ciphertext, err = proc.communicate(input = data)

197

if proc.returncode != 0:

198

raise PGPError(err)

180

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

181

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

182

try:

183

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

184

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

185

attach_fhs={'stderr': devnull})

186

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

187

f.write(data)

188

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

189

ciphertext = f.read()

190

proc.wait()

191

except IOError as e:

192

raise PGPError(e)

193

self.gnupg.passphrase = None

199

194

return ciphertext

200

195

201

196

def decrypt(self, data, password):

202

passphrase = self.password_encode(password)

203

with tempfile.NamedTemporaryFile(dir = self.tempdir

204

) as passfile:

205

passfile.write(passphrase)

206

passfile.flush()

207

proc = subprocess.Popen(['gpg', '--decrypt',

208

'--passphrase-file',

209

passfile.name]

210

+ self.gnupgargs,

211

stdin = subprocess.PIPE,

212

stdout = subprocess.PIPE,

213

stderr = subprocess.PIPE)

214

decrypted_plaintext, err = proc.communicate(input

215

= data)

216

if proc.returncode != 0:

217

raise PGPError(err)

197

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

198

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

199

try:

200

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

201

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

202

attach_fhs={'stderr': devnull})

203

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

204

f.write(data)

205

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

206

decrypted_plaintext = f.read()

207

proc.wait()

208

except IOError as e:

209

raise PGPError(e)

210

self.gnupg.passphrase = None

218

211

return decrypted_plaintext

219

212

220

213

240

233

Used to optionally bind to the specified interface.

241

234

name: string; Example: 'Mandos'

242

235

type: string; Example: '_mandos._tcp'.

243

See <https://www.iana.org/assignments/service-names-port-numbers>

236

See <http://www.dns-sd.org/ServiceTypes.html>

244

237

port: integer; what port to announce

245

238

TXT: list of strings; TXT record for the service

246

239

domain: string; Domain to publish on, default to .local if empty.

386

379

self.server_state_changed)

387

380

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

388

381

389

390

382

class AvahiServiceToSyslog(AvahiService):

391

383

def rename(self):

392

384

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

397

389

.format(self.name)))

398

390

return ret

399

391

400

401

392

def timedelta_to_milliseconds(td):

402

393

"Convert a datetime.timedelta() to milliseconds"

403

394

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

404

395

+ (td.seconds * 1000)

405

396

+ (td.microseconds // 1000))

406

397

407

408

398

class Client(object):

409

399

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

410

400

446

436

runtime_expansions: Allowed attributes for runtime expansion.

447

437

expires: datetime.datetime(); time (UTC) when a client will be

448

438

disabled, or None

449

server_settings: The server_settings dict from main()

450

439

"""

451

440

452

441

runtime_expansions = ("approval_delay", "approval_duration",

453

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

454

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

455

"last_approval_request", "last_checked_ok",

442

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

443

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

456

444

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

457

client_defaults = { "timeout": "PT5M",

458

"extended_timeout": "PT15M",

459

"interval": "PT2M",

445

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

446

"extended_timeout": "15m",

447

"interval": "2m",

460

448

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

461

449

"host": "",

462

"approval_delay": "PT0S",

463

"approval_duration": "PT1S",

450

"approval_delay": "0s",

451

"approval_duration": "1s",

464

452

"approved_by_default": "True",

465

453

"enabled": "True",

466

454

}

527

515

528

516

return settings

529

517

530

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

518

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

531

519

self.name = name

532

if server_settings is None:

533

server_settings = {}

534

self.server_settings = server_settings

535

520

# adding all client settings

536

521

for setting, value in settings.iteritems():

537

522

setattr(self, setting, value)

587

572

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

588

573

# Already enabled

589

574

return

575

self.send_changedstate()

590

576

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

591

577

self.enabled = True

592

578

self.last_enabled = datetime.datetime.utcnow()

593

579

self.init_checker()

594

self.send_changedstate()

595

580

596

581

def disable(self, quiet=True):

597

582

"""Disable this client."""

598

583

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

599

584

return False

600

585

if not quiet:

586

self.send_changedstate()

587

if not quiet:

601

588

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

602

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

589

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

603

590

gobject.source_remove(self.disable_initiator_tag)

604

591

self.disable_initiator_tag = None

605

592

self.expires = None

606

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

593

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

607

594

gobject.source_remove(self.checker_initiator_tag)

608

595

self.checker_initiator_tag = None

609

596

self.stop_checker()

610

597

self.enabled = False

611

if not quiet:

612

self.send_changedstate()

613

598

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

614

599

return False

615

600

619

604

def init_checker(self):

620

605

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

621

606

# and every interval from then on.

622

if self.checker_initiator_tag is not None:

623

gobject.source_remove(self.checker_initiator_tag)

624

607

self.checker_initiator_tag = (gobject.timeout_add

625

608

(self.interval_milliseconds(),

626

609

self.start_checker))

627

610

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

628

if self.disable_initiator_tag is not None:

629

gobject.source_remove(self.disable_initiator_tag)

630

611

self.disable_initiator_tag = (gobject.timeout_add

631

612

(self.timeout_milliseconds(),

632

613

self.disable))

663

644

timeout = self.timeout

664

645

if self.disable_initiator_tag is not None:

665

646

gobject.source_remove(self.disable_initiator_tag)

666

self.disable_initiator_tag = None

667

647

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

668

648

self.disable_initiator_tag = (gobject.timeout_add

669

649

(timedelta_to_milliseconds

702

682

self.current_checker_command)

703

683

# Start a new checker if needed

704

684

if self.checker is None:

705

# Escape attributes for the shell

706

escaped_attrs = dict(

707

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

708

for attr in

709

self.runtime_expansions)

710

685

try:

711

command = self.checker_command % escaped_attrs

712

except TypeError as error:

713

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

714

self.checker_command, exc_info=error)

715

return True # Try again later

686

# In case checker_command has exactly one % operator

687

command = self.checker_command % self.host

688

except TypeError:

689

# Escape attributes for the shell

690

escaped_attrs = dict(

691

(attr,

692

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

693

errors=

694

'replace')))

695

for attr in

696

self.runtime_expansions)

697

698

try:

699

command = self.checker_command % escaped_attrs

700

except TypeError as error:

701

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

702

self.checker_command, exc_info=error)

703

return True # Try again later

716

704

self.current_checker_command = command

717

705

try:

718

706

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

721

709

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

722

710

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

723

711

# always replaced by /dev/null.)

724

# The exception is when not debugging but nevertheless

725

# running in the foreground; use the previously

726

# created wnull.

727

popen_args = {}

728

if (not self.server_settings["debug"]

729

and self.server_settings["foreground"]):

730

popen_args.update({"stdout": wnull,

731

"stderr": wnull })

732

712

self.checker = subprocess.Popen(command,

733

713

close_fds=True,

734

shell=True, cwd="/",

735

**popen_args)

714

shell=True, cwd="/")

715

self.checker_callback_tag = (gobject.child_watch_add

716

(self.checker.pid,

717

self.checker_callback,

718

data=command))

719

# The checker may have completed before the gobject

720

# watch was added. Check for this.

721

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

722

if pid:

723

gobject.source_remove(self.checker_callback_tag)

724

self.checker_callback(pid, status, command)

736

725

except OSError as error:

737

726

logger.error("Failed to start subprocess",

738

727

exc_info=error)

739

return True

740

self.checker_callback_tag = (gobject.child_watch_add

741

(self.checker.pid,

742

self.checker_callback,

743

data=command))

744

# The checker may have completed before the gobject

745

# watch was added. Check for this.

746

try:

747

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

748

except OSError as error:

749

if error.errno == errno.ECHILD:

750

# This should never happen

751

logger.error("Child process vanished",

752

exc_info=error)

753

return True

754

raise

755

if pid:

756

gobject.source_remove(self.checker_callback_tag)

757

self.checker_callback(pid, status, command)

758

728

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

759

729

return True

760

730

1045

1015

return xmlstring

1046

1016

1047

1017

1048

def datetime_to_dbus(dt, variant_level=0):

1018

def datetime_to_dbus (dt, variant_level=0):

1049

1019

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

1050

1020

if dt is None:

1051

1021

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

1059

1029

interface names according to the "alt_interface_names" mapping.

1060

1030

Usage:

1061

1031

1062

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

1063

"net.example.AlternateInterface"})

1032

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

1033

"net.example.AlternateInterface"})

1064

1034

class SampleDBusObject(dbus.service.Object):

1065

1035

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

1066

1036

def SampleDBusMethod():

1097

1067

interface_names.add(alt_interface)

1098

1068

# Is this a D-Bus signal?

1099

1069

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

1100

# Extract the original non-method undecorated

1101

# function by black magic

1070

# Extract the original non-method function by

1071

# black magic

1102

1072

nonmethod_func = (dict(

1103

1073

zip(attribute.func_code.co_freevars,

1104

1074

attribute.__closure__))["func"]

1365

1335

return False

1366

1336

1367

1337

def approve(self, value=True):

1338

self.send_changedstate()

1368

1339

self.approved = value

1369

1340

gobject.timeout_add(timedelta_to_milliseconds

1370

1341

(self.approval_duration),

1371

1342

self._reset_approved)

1372

self.send_changedstate()

1373

1343

1374

1344

## D-Bus methods, signals & properties

1375

1345

_interface = "se.recompile.Mandos.Client"

1559

1529

def Timeout_dbus_property(self, value=None):

1560

1530

if value is None: # get

1561

1531

return dbus.UInt64(self.timeout_milliseconds())

1562

old_timeout = self.timeout

1563

1532

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

1564

# Reschedule disabling

1533

# Reschedule timeout

1565

1534

if self.enabled:

1566

1535

now = datetime.datetime.utcnow()

1567

self.expires += self.timeout - old_timeout

1568

if self.expires <= now:

1536

time_to_die = timedelta_to_milliseconds(

1537

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

1538

if time_to_die <= 0:

1569

1539

# The timeout has passed

1570

1540

self.disable()

1571

1541

else:

1542

self.expires = (now +

1543

datetime.timedelta(milliseconds =

1544

time_to_die))

1572

1545

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

1573

1546

is None):

1574

1547

return

1575

1548

gobject.source_remove(self.disable_initiator_tag)

1576

self.disable_initiator_tag = (

1577

gobject.timeout_add(

1578

timedelta_to_milliseconds(self.expires - now),

1579

self.disable))

1549

self.disable_initiator_tag = (gobject.timeout_add

1550

(time_to_die,

1551

self.disable))

1580

1552

1581

1553

# ExtendedTimeout - property

1582

1554

@dbus_service_property(_interface, signature="t",

1770

1742

#wait until timeout or approved

1771

1743

time = datetime.datetime.now()

1772

1744

client.changedstate.acquire()

1773

client.changedstate.wait(

1774

float(timedelta_to_milliseconds(delay)

1775

/ 1000))

1745

(client.changedstate.wait

1746

(float(client.timedelta_to_milliseconds(delay)

1747

/ 1000)))

1776

1748

client.changedstate.release()

1777

1749

time2 = datetime.datetime.now()

1778

1750

if (time2 - time) >= delay:

1928

1900

use_ipv6: Boolean; to use IPv6 or not

1929

1901

"""

1930

1902

def __init__(self, server_address, RequestHandlerClass,

1931

interface=None, use_ipv6=True, socketfd=None):

1932

"""If socketfd is set, use that file descriptor instead of

1933

creating a new one with socket.socket().

1934

"""

1903

interface=None, use_ipv6=True):

1935

1904

self.interface = interface

1936

1905

if use_ipv6:

1937

1906

self.address_family = socket.AF_INET6

1938

if socketfd is not None:

1939

# Save the file descriptor

1940

self.socketfd = socketfd

1941

# Save the original socket.socket() function

1942

self.socket_socket = socket.socket

1943

# To implement --socket, we monkey patch socket.socket.

1944

#

1945

# (When socketserver.TCPServer is a new-style class, we

1946

# could make self.socket into a property instead of monkey

1947

# patching socket.socket.)

1948

#

1949

# Create a one-time-only replacement for socket.socket()

1950

@functools.wraps(socket.socket)

1951

def socket_wrapper(*args, **kwargs):

1952

# Restore original function so subsequent calls are

1953

# not affected.

1954

socket.socket = self.socket_socket

1955

del self.socket_socket

1956

# This time only, return a new socket object from the

1957

# saved file descriptor.

1958

return socket.fromfd(self.socketfd, *args, **kwargs)

1959

# Replace socket.socket() function with wrapper

1960

socket.socket = socket_wrapper

1961

# The socketserver.TCPServer.__init__ will call

1962

# socket.socket(), which might be our replacement,

1963

# socket_wrapper(), if socketfd was set.

1964

1907

socketserver.TCPServer.__init__(self, server_address,

1965

1908

RequestHandlerClass)

1966

1967

1909

def server_bind(self):

1968

1910

"""This overrides the normal server_bind() function

1969

1911

to bind to an interface if one was specified, and also NOT to

1977

1919

try:

1978

1920

self.socket.setsockopt(socket.SOL_SOCKET,

1979

1921

SO_BINDTODEVICE,

1980

str(self.interface + '\0'))

1922

str(self.interface

1923

+ '\0'))

1981

1924

except socket.error as error:

1982

if error.errno == errno.EPERM:

1983

logger.error("No permission to bind to"

1984

" interface %s", self.interface)

1985

elif error.errno == errno.ENOPROTOOPT:

1925

if error[0] == errno.EPERM:

1926

logger.error("No permission to"

1927

" bind to interface %s",

1928

self.interface)

1929

elif error[0] == errno.ENOPROTOOPT:

1986

1930

logger.error("SO_BINDTODEVICE not available;"

1987

1931

" cannot bind to interface %s",

1988

1932

self.interface)

1989

elif error.errno == errno.ENODEV:

1990

logger.error("Interface %s does not exist,"

1991

" cannot bind", self.interface)

1992

1933

else:

1993

1934

raise

1994

1935

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

1997

1938

if self.address_family == socket.AF_INET6:

1998

1939

any_address = "::" # in6addr_any

1999

1940

else:

2000

any_address = "0.0.0.0" # INADDR_ANY

1941

any_address = socket.INADDR_ANY

2001

1942

self.server_address = (any_address,

2002

1943

self.server_address[1])

2003

1944

elif not self.server_address[1]:

2024

1965

"""

2025

1966

def __init__(self, server_address, RequestHandlerClass,

2026

1967

interface=None, use_ipv6=True, clients=None,

2027

gnutls_priority=None, use_dbus=True, socketfd=None):

1968

gnutls_priority=None, use_dbus=True):

2028

1969

self.enabled = False

2029

1970

self.clients = clients

2030

1971

if self.clients is None:

2034

1975

IPv6_TCPServer.__init__(self, server_address,

2035

1976

RequestHandlerClass,

2036

1977

interface = interface,

2037

use_ipv6 = use_ipv6,

2038

socketfd = socketfd)

1978

use_ipv6 = use_ipv6)

2039

1979

def server_activate(self):

2040

1980

if self.enabled:

2041

1981

return socketserver.TCPServer.server_activate(self)

2119

2059

return True

2120

2060

2121

2061

2122

def rfc3339_duration_to_delta(duration):

2123

"""Parse an RFC 3339 "duration" and return a datetime.timedelta

2124

2125

>>> rfc3339_duration_to_delta("P7D")

2126

datetime.timedelta(7)

2127

>>> rfc3339_duration_to_delta("PT60S")

2128

datetime.timedelta(0, 60)

2129

>>> rfc3339_duration_to_delta("PT60M")

2130

datetime.timedelta(0, 3600)

2131

>>> rfc3339_duration_to_delta("PT24H")

2132

datetime.timedelta(1)

2133

>>> rfc3339_duration_to_delta("P1W")

2134

datetime.timedelta(7)

2135

>>> rfc3339_duration_to_delta("PT5M30S")

2136

datetime.timedelta(0, 330)

2137

>>> rfc3339_duration_to_delta("P1DT3M20S")

2138

datetime.timedelta(1, 200)

2139

"""

2140

2141

# Parsing an RFC 3339 duration with regular expressions is not

2142

# possible - there would have to be multiple places for the same

2143

# values, like seconds. The current code, while more esoteric, is

2144

# cleaner without depending on a parsing library. If Python had a

2145

# built-in library for parsing we would use it, but we'd like to

2146

# avoid excessive use of external libraries.

2147

2148

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

2149

Token = collections.namedtuple("Token",

2150

("regexp", # To match token; if

2151

# "value" is not None,

2152

# must have a "group"

2153

# containing digits

2154

"value", # datetime.timedelta or

2155

# None

2156

"followers")) # Tokens valid after

2157

# this token

2158

# RFC 3339 "duration" tokens, syntax, and semantics; taken from

2159

# the "duration" ABNF definition in RFC 3339, Appendix A.

2160

token_end = Token(re.compile(r"$"), None, frozenset())

2161

token_second = Token(re.compile(r"(\d+)S"),

2162

datetime.timedelta(seconds=1),

2163

frozenset((token_end,)))

2164

token_minute = Token(re.compile(r"(\d+)M"),

2165

datetime.timedelta(minutes=1),

2166

frozenset((token_second, token_end)))

2167

token_hour = Token(re.compile(r"(\d+)H"),

2168

datetime.timedelta(hours=1),

2169

frozenset((token_minute, token_end)))

2170

token_time = Token(re.compile(r"T"),

2171

None,

2172

frozenset((token_hour, token_minute,

2173

token_second)))

2174

token_day = Token(re.compile(r"(\d+)D"),

2175

datetime.timedelta(days=1),

2176

frozenset((token_time, token_end)))

2177

token_month = Token(re.compile(r"(\d+)M"),

2178

datetime.timedelta(weeks=4),

2179

frozenset((token_day, token_end)))

2180

token_year = Token(re.compile(r"(\d+)Y"),

2181

datetime.timedelta(weeks=52),

2182

frozenset((token_month, token_end)))

2183

token_week = Token(re.compile(r"(\d+)W"),

2184

datetime.timedelta(weeks=1),

2185

frozenset((token_end,)))

2186

token_duration = Token(re.compile(r"P"), None,

2187

frozenset((token_year, token_month,

2188

token_day, token_time,

2189

token_week))),

2190

# Define starting values

2191

value = datetime.timedelta() # Value so far

2192

found_token = None

2193

followers = frozenset(token_duration,) # Following valid tokens

2194

s = duration # String left to parse

2195

# Loop until end token is found

2196

while found_token is not token_end:

2197

# Search for any currently valid tokens

2198

for token in followers:

2199

match = token.regexp.match(s)

2200

if match is not None:

2201

# Token found

2202

if token.value is not None:

2203

# Value found, parse digits

2204

factor = int(match.group(1), 10)

2205

# Add to value so far

2206

value += factor * token.value

2207

# Strip token from string

2208

s = token.regexp.sub("", s, 1)

2209

# Go to found token

2210

found_token = token

2211

# Set valid next tokens

2212

followers = found_token.followers

2213

break

2214

else:

2215

# No currently valid tokens were found

2216

raise ValueError("Invalid RFC 3339 duration")

2217

# End token found

2218

return value

2219

2220

2221

2062

def string_to_delta(interval):

2222

2063

"""Parse a string and return a datetime.timedelta

2223

2064

2234

2075

>>> string_to_delta('5m 30s')

2235

2076

datetime.timedelta(0, 330)

2236

2077

"""

2237

2238

try:

2239

return rfc3339_duration_to_delta(interval)

2240

except ValueError:

2241

pass

2242

2243

2078

timevalue = datetime.timedelta(0)

2244

2079

for s in interval.split():

2245

2080

try:

2308

2143

help="Run self-test")

2309

2144

parser.add_argument("--debug", action="store_true",

2310

2145

help="Debug mode; run in foreground and log"

2311

" to terminal", default=None)

2146

" to terminal")

2312

2147

parser.add_argument("--debuglevel", metavar="LEVEL",

2313

2148

help="Debug level for stdout output")

2314

2149

parser.add_argument("--priority", help="GnuTLS"

2321

2156

" files")

2322

2157

parser.add_argument("--no-dbus", action="store_false",

2323

2158

dest="use_dbus", help="Do not provide D-Bus"

2324

" system bus interface", default=None)

2159

" system bus interface")

2325

2160

parser.add_argument("--no-ipv6", action="store_false",

2326

dest="use_ipv6", help="Do not use IPv6",

2327

default=None)

2161

dest="use_ipv6", help="Do not use IPv6")

2328

2162

parser.add_argument("--no-restore", action="store_false",

2329

2163

dest="restore", help="Do not restore stored"

2330

" state", default=None)

2331

parser.add_argument("--socket", type=int,

2332

help="Specify a file descriptor to a network"

2333

" socket to use instead of creating one")

2164

" state")

2334

2165

parser.add_argument("--statedir", metavar="DIR",

2335

2166

help="Directory to save/restore state in")

2336

parser.add_argument("--foreground", action="store_true",

2337

help="Run in foreground", default=None)

2338

2167

2339

2168

options = parser.parse_args()

2340

2169

2349

2178

"port": "",

2350

2179

"debug": "False",

2351

2180

"priority":

2352

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",

2181

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

2353

2182

"servicename": "Mandos",

2354

2183

"use_dbus": "True",

2355

2184

"use_ipv6": "True",

2356

2185

"debuglevel": "",

2357

2186

"restore": "True",

2358

"socket": "",

2359

"statedir": "/var/lib/mandos",

2360

"foreground": "False",

2187

"statedir": "/var/lib/mandos"

2361

2188

}

2362

2189

2363

2190

# Parse config file for server-global settings

2368

2195

# Convert the SafeConfigParser object to a dict

2369

2196

server_settings = server_config.defaults()

2370

2197

# Use the appropriate methods on the non-string config options

2371

for option in ("debug", "use_dbus", "use_ipv6", "foreground"):

2198

for option in ("debug", "use_dbus", "use_ipv6"):

2372

2199

server_settings[option] = server_config.getboolean("DEFAULT",

2373

2200

option)

2374

2201

if server_settings["port"]:

2375

2202

server_settings["port"] = server_config.getint("DEFAULT",

2376

2203

"port")

2377

if server_settings["socket"]:

2378

server_settings["socket"] = server_config.getint("DEFAULT",

2379

"socket")

2380

# Later, stdin will, and stdout and stderr might, be dup'ed

2381

# over with an opened os.devnull. But we don't want this to

2382

# happen with a supplied network socket.

2383

if 0 <= server_settings["socket"] <= 2:

2384

server_settings["socket"] = os.dup(server_settings

2385

["socket"])

2386

2204

del server_config

2387

2205

2388

2206

# Override the settings from the config file with command line

2390

2208

for option in ("interface", "address", "port", "debug",

2391

2209

"priority", "servicename", "configdir",

2392

2210

"use_dbus", "use_ipv6", "debuglevel", "restore",

2393

"statedir", "socket", "foreground"):

2211

"statedir"):

2394

2212

value = getattr(options, option)

2395

2213

if value is not None:

2396

2214

server_settings[option] = value

2399

2217

for option in server_settings.keys():

2400

2218

if type(server_settings[option]) is str:

2401

2219

server_settings[option] = unicode(server_settings[option])

2402

# Force all boolean options to be boolean

2403

for option in ("debug", "use_dbus", "use_ipv6", "restore",

2404

"foreground"):

2405

server_settings[option] = bool(server_settings[option])

2406

# Debug implies foreground

2407

if server_settings["debug"]:

2408

server_settings["foreground"] = True

2409

2220

# Now we have our good server settings in "server_settings"

2410

2221

2411

2222

##################################################################

2417

2228

use_ipv6 = server_settings["use_ipv6"]

2418

2229

stored_state_path = os.path.join(server_settings["statedir"],

2419

2230

stored_state_file)

2420

foreground = server_settings["foreground"]

2421

2231

2422

2232

if debug:

2423

2233

initlogger(debug, logging.DEBUG)

2452

2262

use_ipv6=use_ipv6,

2453

2263

gnutls_priority=

2454

2264

server_settings["priority"],

2455

use_dbus=use_dbus,

2456

socketfd=(server_settings["socket"]

2457

or None))

2458

if not foreground:

2459

pidfilename = "/run/mandos.pid"

2460

pidfile = None

2265

use_dbus=use_dbus)

2266

if not debug:

2267

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

2461

2268

try:

2462

2269

pidfile = open(pidfilename, "w")

2463

2270

except IOError as e:

2478

2285

os.setgid(gid)

2479

2286

os.setuid(uid)

2480

2287

except OSError as error:

2481

if error.errno != errno.EPERM:

2288

if error[0] != errno.EPERM:

2482

2289

raise error

2483

2290

2484

2291

if debug:

2502

2309

os.close(null)

2503

2310

2504

2311

# Need to fork before connecting to D-Bus

2505

if not foreground:

2312

if not debug:

2506

2313

# Close all input and output, do double fork, etc.

2507

2314

daemon()

2508

2315

2509

# multiprocessing will use threads, so before we use gobject we

2510

# need to inform gobject that threads will be used.

2511

2316

gobject.threads_init()

2512

2317

2513

2318

global main_loop

2548

2353

old_client_settings = {}

2549

2354

clients_data = {}

2550

2355

2551

# This is used to redirect stdout and stderr for checker processes

2552

global wnull

2553

wnull = open(os.devnull, "w") # A writable /dev/null

2554

# Only used if server is running in foreground but not in debug

2555

# mode

2556

if debug or not foreground:

2557

wnull.close()

2558

2559

2356

# Get client data and settings from last running state.

2560

2357

if server_settings["restore"]:

2561

2358

try:

2577

2374

2578

2375

with PGPEngine() as pgp:

2579

2376

for client_name, client in clients_data.iteritems():

2580

# Skip removed clients

2581

if client_name not in client_settings:

2582

continue

2583

2584

2377

# Decide which value to use after restoring saved state.

2585

2378

# We have three different values: Old config file,

2586

2379

# new config file, and saved state.

2648

2441

# Create all client objects

2649

2442

for client_name, client in clients_data.iteritems():

2650

2443

tcp_server.clients[client_name] = client_class(

2651

name = client_name, settings = client,

2652

server_settings = server_settings)

2444

name = client_name, settings = client)

2653

2445

2654

2446

if not tcp_server.clients:

2655

2447

logger.warning("No clients defined")

2656

2448

2657

if not foreground:

2658

if pidfile is not None:

2659

try:

2660

with pidfile:

2661

pid = os.getpid()

2662

pidfile.write(str(pid) + "\n".encode("utf-8"))

2663

except IOError:

2664

logger.error("Could not write to file %r with PID %d",

2665

pidfilename, pid)

2666

del pidfile

2449

if not debug:

2450

try:

2451

with pidfile:

2452

pid = os.getpid()

2453

pidfile.write(str(pid) + "\n".encode("utf-8"))

2454

del pidfile

2455

except IOError:

2456

logger.error("Could not write to file %r with PID %d",

2457

pidfilename, pid)

2458

except NameError:

2459

# "pidfile" was never created

2460

pass

2667

2461

del pidfilename

2462

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

2668

2463

2669

2464

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

2670

2465

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

2738

2533

service.cleanup()

2739

2534

2740

2535

multiprocessing.active_children()

2741

wnull.close()

2742

2536

if not (tcp_server.clients or client_settings):

2743

2537

return

2744

2538

2756

2550

# A list of attributes that can not be pickled

2757

2551

# + secret.

2758

2552

exclude = set(("bus", "changedstate", "secret",

2759

"checker", "server_settings"))

2553

"checker"))

2760

2554

for name, typ in (inspect.getmembers

2761

2555

(dbus.service.Object)):

2762

2556

exclude.add(name)