/mandos/trunk : revision 710

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

71

72

73

import dbus

73

74

import dbus.service

78

79

import ctypes.util

79

80

import xml.dom.minidom

80

81

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.5.3"

91

version = "1.6.5"

92

stored_state_file = "clients.pickle"

93

94

logger = logging.getLogger()

95

syslogger = (logging.handlers.SysLogHandler

96

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

97

address = str("/dev/log")))

95

syslogger = None

98

96

99

97

try:

100

98

if_nametoindex = (ctypes.cdll.LoadLibrary

116

114

def initlogger(debug, level=logging.WARNING):

117

115

"""init logger and add loglevel"""

118

116

117

global syslogger

118

syslogger = (logging.handlers.SysLogHandler

119

(facility =

120

logging.handlers.SysLogHandler.LOG_DAEMON,

121

address = str("/dev/log")))

119

122

syslogger.setFormatter(logging.Formatter

120

123

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

121

124

' %(message)s'))

139

142

class PGPEngine(object):

140

143

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

141

144

def __init__(self):

142

self.gnupg = GnuPGInterface.GnuPG()

143

145

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

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'])

146

self.gnupgargs = ['--batch',

147

'--home', self.tempdir,

148

'--force-mdc',

149

'--quiet',

150

'--no-use-agent']

150

151

152

def __enter__(self):

152

153

return self

153

154

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

155

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

155

156

self._cleanup()

156

157

return False

157

158

174

175

def password_encode(self, password):

175

176

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

176

177

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

177

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

178

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

179

if len(encoded) > 2048:

180

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

181

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

182

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

183

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

184

return encoded

178

185

179

186

def encrypt(self, data, password):

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

187

passphrase = self.password_encode(password)

188

with tempfile.NamedTemporaryFile(dir=self.tempdir

189

) as passfile:

190

passfile.write(passphrase)

191

passfile.flush()

192

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

193

'--passphrase-file',

194

passfile.name]

195

+ self.gnupgargs,

196

stdin = subprocess.PIPE,

197

stdout = subprocess.PIPE,

198

stderr = subprocess.PIPE)

199

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

200

if proc.returncode != 0:

201

raise PGPError(err)

194

202

return ciphertext

195

203

196

204

def decrypt(self, data, password):

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

205

passphrase = self.password_encode(password)

206

with tempfile.NamedTemporaryFile(dir = self.tempdir

207

) as passfile:

208

passfile.write(passphrase)

209

passfile.flush()

210

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

211

'--passphrase-file',

212

passfile.name]

213

+ self.gnupgargs,

214

stdin = subprocess.PIPE,

215

stdout = subprocess.PIPE,

216

stderr = subprocess.PIPE)

217

decrypted_plaintext, err = proc.communicate(input

218

= data)

219

if proc.returncode != 0:

220

raise PGPError(err)

211

221

return decrypted_plaintext

212

222

213

223

233

243

Used to optionally bind to the specified interface.

234

244

name: string; Example: 'Mandos'

235

245

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

236

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

246

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

237

247

port: integer; what port to announce

238

248

TXT: list of strings; TXT record for the service

239

249

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

439

449

runtime_expansions: Allowed attributes for runtime expansion.

440

450

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

441

451

disabled, or None

452

server_settings: The server_settings dict from main()

442

453

"""

443

454

444

455

runtime_expansions = ("approval_delay", "approval_duration",

446

457

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

447

458

"last_approval_request", "last_checked_ok",

448

459

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

449

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

450

"extended_timeout": "15m",

451

"interval": "2m",

460

client_defaults = { "timeout": "PT5M",

461

"extended_timeout": "PT15M",

462

"interval": "PT2M",

452

463

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

453

464

"host": "",

454

"approval_delay": "0s",

455

"approval_duration": "1s",

465

"approval_delay": "PT0S",

466

"approval_duration": "PT1S",

456

467

"approved_by_default": "True",

457

468

"enabled": "True",

458

469

}

519

530

520

531

return settings

521

532

522

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

533

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

523

534

self.name = name

535

if server_settings is None:

536

server_settings = {}

537

self.server_settings = server_settings

524

538

# adding all client settings

525

539

for setting, value in settings.iteritems():

526

540

setattr(self, setting, value)

679

693

# If a checker exists, make sure it is not a zombie

680

694

try:

681

695

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

682

except (AttributeError, OSError) as error:

683

if (isinstance(error, OSError)

684

and error.errno != errno.ECHILD):

685

raise error

696

except AttributeError:

697

pass

698

except OSError as error:

699

if error.errno != errno.ECHILD:

700

raise

686

701

else:

687

702

if pid:

688

703

logger.warning("Checker was a zombie")

710

725

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

711

726

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

712

727

# always replaced by /dev/null.)

728

# The exception is when not debugging but nevertheless

729

# running in the foreground; use the previously

730

# created wnull.

731

popen_args = {}

732

if (not self.server_settings["debug"]

733

and self.server_settings["foreground"]):

734

popen_args.update({"stdout": wnull,

735

"stderr": wnull })

713

736

self.checker = subprocess.Popen(command,

714

737

close_fds=True,

715

shell=True, cwd="/")

738

shell=True, cwd="/",

739

**popen_args)

716

740

except OSError as error:

717

741

logger.error("Failed to start subprocess",

718

742

exc_info=error)

743

return True

719

744

self.checker_callback_tag = (gobject.child_watch_add

720

745

(self.checker.pid,

721

746

self.checker_callback,

722

747

data=command))

723

748

# The checker may have completed before the gobject

724

749

# watch was added. Check for this.

725

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

750

try:

751

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

752

except OSError as error:

753

if error.errno == errno.ECHILD:

754

# This should never happen

755

logger.error("Child process vanished",

756

exc_info=error)

757

return True

758

raise

726

759

if pid:

727

760

gobject.source_remove(self.checker_callback_tag)

728

761

self.checker_callback(pid, status, command)

904

937

# The byte_arrays option is not supported yet on

905

938

# signatures other than "ay".

906

939

if prop._dbus_signature != "ay":

907

raise ValueError

940

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

941

"'ay' signature {0!r}"

942

.format(prop._dbus_signature))

908

943

value = dbus.ByteArray(b''.join(chr(byte)

909

944

for byte in value))

910

945

prop(value)

1016

1051

return xmlstring

1017

1052

1018

1053

1019

def datetime_to_dbus (dt, variant_level=0):

1054

def datetime_to_dbus(dt, variant_level=0):

1020

1055

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

1021

1056

if dt is None:

1022

1057

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

1030

1065

interface names according to the "alt_interface_names" mapping.

1031

1066

Usage:

1032

1067

1033

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

1034

"net.example.AlternateInterface"})

1068

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

1069

"net.example.AlternateInterface"})

1035

1070

class SampleDBusObject(dbus.service.Object):

1036

1071

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

1037

1072

def SampleDBusMethod():

1068

1103

interface_names.add(alt_interface)

1069

1104

# Is this a D-Bus signal?

1070

1105

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

1071

# Extract the original non-method function by

1072

# black magic

1106

# Extract the original non-method undecorated

1107

# function by black magic

1073

1108

nonmethod_func = (dict(

1074

1109

zip(attribute.func_code.co_freevars,

1075

1110

attribute.__closure__))["func"]

1318

1353

*args, **kwargs)

1319

1354

1320

1355

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

1321

old_checker = self.checker

1322

if self.checker is not None:

1323

old_checker_pid = self.checker.pid

1324

else:

1325

old_checker_pid = None

1356

old_checker_pid = getattr(self.checker, "pid", None)

1326

1357

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

1327

1358

# Only if new checker process was started

1328

1359

if (self.checker is not None

1673

1704

logger.debug("Protocol version: %r", line)

1674

1705

try:

1675

1706

if int(line.strip().split()[0]) > 1:

1676

raise RuntimeError

1707

raise RuntimeError(line)

1677

1708

except (ValueError, IndexError, RuntimeError) as error:

1678

1709

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

1679

1710

return

1886

1917

1887

1918

def add_pipe(self, parent_pipe, proc):

1888

1919

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

1889

raise NotImplementedError

1920

raise NotImplementedError()

1890

1921

1891

1922

1892

1923

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1899

1930

use_ipv6: Boolean; to use IPv6 or not

1900

1931

"""

1901

1932

def __init__(self, server_address, RequestHandlerClass,

1902

interface=None, use_ipv6=True):

1933

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

1934

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

1935

creating a new one with socket.socket().

1936

"""

1903

1937

self.interface = interface

1904

1938

if use_ipv6:

1905

1939

self.address_family = socket.AF_INET6

1940

if socketfd is not None:

1941

# Save the file descriptor

1942

self.socketfd = socketfd

1943

# Save the original socket.socket() function

1944

self.socket_socket = socket.socket

1945

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

1946

#

1947

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

1948

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

1949

# patching socket.socket.)

1950

#

1951

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

1952

@functools.wraps(socket.socket)

1953

def socket_wrapper(*args, **kwargs):

1954

# Restore original function so subsequent calls are

1955

# not affected.

1956

socket.socket = self.socket_socket

1957

del self.socket_socket

1958

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

1959

# saved file descriptor.

1960

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

1961

# Replace socket.socket() function with wrapper

1962

socket.socket = socket_wrapper

1963

# The socketserver.TCPServer.__init__ will call

1964

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

1965

# socket_wrapper(), if socketfd was set.

1906

1966

socketserver.TCPServer.__init__(self, server_address,

1907

1967

RequestHandlerClass)

1968

1908

1969

def server_bind(self):

1909

1970

"""This overrides the normal server_bind() function

1910

1971

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

1918

1979

try:

1919

1980

self.socket.setsockopt(socket.SOL_SOCKET,

1920

1981

SO_BINDTODEVICE,

1921

str(self.interface

1922

+ '\0'))

1982

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

1923

1983

except socket.error as error:

1924

1984

if error.errno == errno.EPERM:

1925

logger.error("No permission to"

1926

" bind to interface %s",

1927

self.interface)

1985

logger.error("No permission to bind to"

1986

" interface %s", self.interface)

1928

1987

elif error.errno == errno.ENOPROTOOPT:

1929

1988

logger.error("SO_BINDTODEVICE not available;"

1930

1989

" cannot bind to interface %s",

1931

1990

self.interface)

1932

1991

elif error.errno == errno.ENODEV:

1933

logger.error("Interface %s does not"

1934

" exist, cannot bind",

1935

self.interface)

1992

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

1993

" cannot bind", self.interface)

1936

1994

else:

1937

1995

raise

1938

1996

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

1941

1999

if self.address_family == socket.AF_INET6:

1942

2000

any_address = "::" # in6addr_any

1943

2001

else:

1944

any_address = socket.INADDR_ANY

2002

any_address = "0.0.0.0" # INADDR_ANY

1945

2003

self.server_address = (any_address,

1946

2004

self.server_address[1])

1947

2005

elif not self.server_address[1]:

1968

2026

"""

1969

2027

def __init__(self, server_address, RequestHandlerClass,

1970

2028

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

1971

gnutls_priority=None, use_dbus=True):

2029

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

1972

2030

self.enabled = False

1973

2031

self.clients = clients

1974

2032

if self.clients is None:

1978

2036

IPv6_TCPServer.__init__(self, server_address,

1979

2037

RequestHandlerClass,

1980

2038

interface = interface,

1981

use_ipv6 = use_ipv6)

2039

use_ipv6 = use_ipv6,

2040

socketfd = socketfd)

1982

2041

def server_activate(self):

1983

2042

if self.enabled:

1984

2043

return socketserver.TCPServer.server_activate(self)

2062

2121

return True

2063

2122

2064

2123

2124

def rfc3339_duration_to_delta(duration):

2125

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

2126

2127

>>> rfc3339_duration_to_delta("P7D")

2128

datetime.timedelta(7)

2129

>>> rfc3339_duration_to_delta("PT60S")

2130

datetime.timedelta(0, 60)

2131

>>> rfc3339_duration_to_delta("PT60M")

2132

datetime.timedelta(0, 3600)

2133

>>> rfc3339_duration_to_delta("PT24H")

2134

datetime.timedelta(1)

2135

>>> rfc3339_duration_to_delta("P1W")

2136

datetime.timedelta(7)

2137

>>> rfc3339_duration_to_delta("PT5M30S")

2138

datetime.timedelta(0, 330)

2139

>>> rfc3339_duration_to_delta("P1DT3M20S")

2140

datetime.timedelta(1, 200)

2141

"""

2142

2143

# Parsing an RFC 3339 duration with regular expressions is not

2144

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

2145

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

2146

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

2147

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

2148

# avoid excessive use of external libraries.

2149

2150

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

2151

Token = collections.namedtuple("Token",

2152

("regexp", # To match token; if

2153

# "value" is not None,

2154

# must have a "group"

2155

# containing digits

2156

"value", # datetime.timedelta or

2157

# None

2158

"followers")) # Tokens valid after

2159

# this token

2160

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

2161

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

2162

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

2163

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

2164

datetime.timedelta(seconds=1),

2165

frozenset((token_end,)))

2166

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

2167

datetime.timedelta(minutes=1),

2168

frozenset((token_second, token_end)))

2169

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

2170

datetime.timedelta(hours=1),

2171

frozenset((token_minute, token_end)))

2172

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

2173

None,

2174

frozenset((token_hour, token_minute,

2175

token_second)))

2176

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

2177

datetime.timedelta(days=1),

2178

frozenset((token_time, token_end)))

2179

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

2180

datetime.timedelta(weeks=4),

2181

frozenset((token_day, token_end)))

2182

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

2183

datetime.timedelta(weeks=52),

2184

frozenset((token_month, token_end)))

2185

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

2186

datetime.timedelta(weeks=1),

2187

frozenset((token_end,)))

2188

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

2189

frozenset((token_year, token_month,

2190

token_day, token_time,

2191

token_week))),

2192

# Define starting values

2193

value = datetime.timedelta() # Value so far

2194

found_token = None

2195

followers = frozenset(token_duration,) # Following valid tokens

2196

s = duration # String left to parse

2197

# Loop until end token is found

2198

while found_token is not token_end:

2199

# Search for any currently valid tokens

2200

for token in followers:

2201

match = token.regexp.match(s)

2202

if match is not None:

2203

# Token found

2204

if token.value is not None:

2205

# Value found, parse digits

2206

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

2207

# Add to value so far

2208

value += factor * token.value

2209

# Strip token from string

2210

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

2211

# Go to found token

2212

found_token = token

2213

# Set valid next tokens

2214

followers = found_token.followers

2215

break

2216

else:

2217

# No currently valid tokens were found

2218

raise ValueError("Invalid RFC 3339 duration")

2219

# End token found

2220

return value

2221

2222

2065

2223

def string_to_delta(interval):

2066

2224

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

2067

2225

2078

2236

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

2079

2237

datetime.timedelta(0, 330)

2080

2238

"""

2239

2240

try:

2241

return rfc3339_duration_to_delta(interval)

2242

except ValueError:

2243

pass

2244

2081

2245

timevalue = datetime.timedelta(0)

2082

2246

for s in interval.split():

2083

2247

try:

2096

2260

else:

2097

2261

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

2098

2262

.format(suffix))

2099

except (ValueError, IndexError) as e:

2263

except IndexError as e:

2100

2264

raise ValueError(*(e.args))

2101

2265

timevalue += delta

2102

2266

return timevalue

2146

2310

help="Run self-test")

2147

2311

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

2148

2312

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

2149

" to terminal")

2313

" to terminal", default=None)

2150

2314

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

2151

2315

help="Debug level for stdout output")

2152

2316

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

2159

2323

" files")

2160

2324

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

2161

2325

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

2162

" system bus interface")

2326

" system bus interface", default=None)

2163

2327

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

2164

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

2328

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

2329

default=None)

2165

2330

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

2166

2331

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

2167

" state")

2332

" state", default=None)

2333

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

2334

help="Specify a file descriptor to a network"

2335

" socket to use instead of creating one")

2168

2336

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

2169

2337

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

2338

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

2339

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

2340

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

2341

dest="zeroconf", help="Do not use Zeroconf",

2342

default=None)

2170

2343

2171

2344

options = parser.parse_args()

2172

2345

2173

2346

if options.check:

2174

2347

import doctest

2175

doctest.testmod()

2176

sys.exit()

2348

fail_count, test_count = doctest.testmod()

2349

sys.exit(os.EX_OK if fail_count == 0 else 1)

2177

2350

2178

2351

# Default values for config file for server-global settings

2179

2352

server_defaults = { "interface": "",

2181

2354

"port": "",

2182

2355

"debug": "False",

2183

2356

"priority":

2184

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

2357

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

2185

2358

"servicename": "Mandos",

2186

2359

"use_dbus": "True",

2187

2360

"use_ipv6": "True",

2188

2361

"debuglevel": "",

2189

2362

"restore": "True",

2190

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

2363

"socket": "",

2364

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

2365

"foreground": "False",

2366

"zeroconf": "True",

2191

2367

}

2192

2368

2193

2369

# Parse config file for server-global settings

2198

2374

# Convert the SafeConfigParser object to a dict

2199

2375

server_settings = server_config.defaults()

2200

2376

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

2201

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

2377

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

2202

2378

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

2203

2379

option)

2204

2380

if server_settings["port"]:

2205

2381

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

2206

2382

"port")

2383

if server_settings["socket"]:

2384

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

2385

"socket")

2386

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

2387

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

2388

# happen with a supplied network socket.

2389

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

2390

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

2391

["socket"])

2207

2392

del server_config

2208

2393

2209

2394

# Override the settings from the config file with command line

2211

2396

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

2212

2397

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

2213

2398

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

2214

"statedir"):

2399

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

2215

2400

value = getattr(options, option)

2216

2401

if value is not None:

2217

2402

server_settings[option] = value

2220

2405

for option in server_settings.keys():

2221

2406

if type(server_settings[option]) is str:

2222

2407

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

2408

# Force all boolean options to be boolean

2409

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

2410

"foreground", "zeroconf"):

2411

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

2412

# Debug implies foreground

2413

if server_settings["debug"]:

2414

server_settings["foreground"] = True

2223

2415

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

2224

2416

2225

2417

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

2226

2418

2419

if (not server_settings["zeroconf"] and

2420

not (server_settings["port"]

2421

or server_settings["socket"] != "")):

2422

parser.error("Needs port or socket to work without"

2423

" Zeroconf")

2424

2227

2425

# For convenience

2228

2426

debug = server_settings["debug"]

2229

2427

debuglevel = server_settings["debuglevel"]

2231

2429

use_ipv6 = server_settings["use_ipv6"]

2232

2430

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

2233

2431

stored_state_file)

2432

foreground = server_settings["foreground"]

2433

zeroconf = server_settings["zeroconf"]

2234

2434

2235

2435

if debug:

2236

2436

initlogger(debug, logging.DEBUG)

2257

2457

global mandos_dbus_service

2258

2458

mandos_dbus_service = None

2259

2459

2460

socketfd = None

2461

if server_settings["socket"] != "":

2462

socketfd = server_settings["socket"]

2260

2463

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

2261

2464

server_settings["port"]),

2262

2465

ClientHandler,

2265

2468

use_ipv6=use_ipv6,

2266

2469

gnutls_priority=

2267

2470

server_settings["priority"],

2268

use_dbus=use_dbus)

2269

if not debug:

2270

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

2471

use_dbus=use_dbus,

2472

socketfd=socketfd)

2473

if not foreground:

2474

pidfilename = "/run/mandos.pid"

2475

if not os.path.isdir("/run/."):

2476

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

2477

pidfile = None

2271

2478

try:

2272

2479

pidfile = open(pidfilename, "w")

2273

2480

except IOError as e:

2289

2496

os.setuid(uid)

2290

2497

except OSError as error:

2291

2498

if error.errno != errno.EPERM:

2292

raise error

2499

raise

2293

2500

2294

2501

if debug:

2295

2502

# Enable all possible GnuTLS debugging

2312

2519

os.close(null)

2313

2520

2314

2521

# Need to fork before connecting to D-Bus

2315

if not debug:

2522

if not foreground:

2316

2523

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

2317

2524

daemon()

2318

2525

2526

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

2527

# need to inform gobject that threads will be used.

2319

2528

gobject.threads_init()

2320

2529

2321

2530

global main_loop

2336

2545

use_dbus = False

2337

2546

server_settings["use_dbus"] = False

2338

2547

tcp_server.use_dbus = False

2339

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2340

service = AvahiServiceToSyslog(name =

2341

server_settings["servicename"],

2342

servicetype = "_mandos._tcp",

2343

protocol = protocol, bus = bus)

2344

if server_settings["interface"]:

2345

service.interface = (if_nametoindex

2346

(str(server_settings["interface"])))

2548

if zeroconf:

2549

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2550

service = AvahiServiceToSyslog(name =

2551

server_settings["servicename"],

2552

servicetype = "_mandos._tcp",

2553

protocol = protocol, bus = bus)

2554

if server_settings["interface"]:

2555

service.interface = (if_nametoindex

2556

(str(server_settings["interface"])))

2347

2557

2348

2558

global multiprocessing_manager

2349

2559

multiprocessing_manager = multiprocessing.Manager()

2356

2566

old_client_settings = {}

2357

2567

clients_data = {}

2358

2568

2569

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

2570

global wnull

2571

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

2572

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

2573

# mode

2574

if debug or not foreground:

2575

wnull.close()

2576

2359

2577

# Get client data and settings from last running state.

2360

2578

if server_settings["restore"]:

2361

2579

try:

2377

2595

2378

2596

with PGPEngine() as pgp:

2379

2597

for client_name, client in clients_data.iteritems():

2598

# Skip removed clients

2599

if client_name not in client_settings:

2600

continue

2601

2380

2602

# Decide which value to use after restoring saved state.

2381

2603

# We have three different values: Old config file,

2382

2604

# new config file, and saved state.

2444

2666

# Create all client objects

2445

2667

for client_name, client in clients_data.iteritems():

2446

2668

tcp_server.clients[client_name] = client_class(

2447

name = client_name, settings = client)

2669

name = client_name, settings = client,

2670

server_settings = server_settings)

2448

2671

2449

2672

if not tcp_server.clients:

2450

2673

logger.warning("No clients defined")

2451

2674

2452

if not debug:

2453

try:

2454

with pidfile:

2455

pid = os.getpid()

2456

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

2457

del pidfile

2458

except IOError:

2459

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

2460

pidfilename, pid)

2461

except NameError:

2462

# "pidfile" was never created

2463

pass

2675

if not foreground:

2676

if pidfile is not None:

2677

try:

2678

with pidfile:

2679

pid = os.getpid()

2680

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

2681

except IOError:

2682

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

2683

pidfilename, pid)

2684

del pidfile

2464

2685

del pidfilename

2465

2686

2466

2687

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

2532

2753

2533

2754

def cleanup():

2534

2755

"Cleanup function; run on exit"

2535

service.cleanup()

2756

if zeroconf:

2757

service.cleanup()

2536

2758

2537

2759

multiprocessing.active_children()

2760

wnull.close()

2538

2761

if not (tcp_server.clients or client_settings):

2539

2762

return

2540

2763

2552

2775

# A list of attributes that can not be pickled

2553

2776

# + secret.

2554

2777

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

2555

"checker"))

2778

"checker", "server_settings"))

2556

2779

for name, typ in (inspect.getmembers

2557

2780

(dbus.service.Object)):

2558

2781

exclude.add(name)

2586

2809

else:

2587

2810

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

2588

2811

exc_info=e)

2589

raise e

2812

raise

2590

2813

2591

2814

# Delete all clients, and settings from config

2592

2815

while tcp_server.clients:

2616

2839

tcp_server.server_activate()

2617

2840

2618

2841

# Find out what port we got

2619

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

2842

if zeroconf:

2843

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

2620

2844

if use_ipv6:

2621

2845

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

2622

2846

" flowinfo %d, scope_id %d",

2628

2852

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

2629

2853

2630

2854

try:

2631

# From the Avahi example code

2632

try:

2633

service.activate()

2634

except dbus.exceptions.DBusException as error:

2635

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

2636

cleanup()

2637

sys.exit(1)

2638

# End of Avahi example code

2855

if zeroconf:

2856

# From the Avahi example code

2857

try:

2858

service.activate()

2859

except dbus.exceptions.DBusException as error:

2860

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

2861

cleanup()

2862

sys.exit(1)

2863

# End of Avahi example code

2639

2864

2640

2865

gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,

2641

2866

lambda *args, **kwargs: