To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to server.py
- browse files at revision 26
- compare with another revision
- download diff
- download tarball
- view history from revision 26
- Committer: Teddy Hogeborn
- Date: 2008-07-22 06:23:59 UTC
- mfrom: (24.1.1 mandos)
- Revision ID: teddy@fukt.bsnet.se-20080722062359-qti3ecst69bq3ltk
Merge.
- files added:
- ca.pem
- files removed:
- COPYING
- files renamed:
- clients.conf => mandos-clients.conf
- plugin-runner.c => plugbasedclient.c
- plugins.d/password-request.c => plugins.d/mandosclient.c
- plugins.d/password-prompt.c => plugins.d/passprompt.c
- mandos => server.py
- files modified:
- Makefile
added
removed
server.py
6
6
# This program is partly derived from an example program for an Avahi
7
7
# service publisher, downloaded from
8
8
# <http://avahi.org/wiki/PythonPublishExample>. This includes the
9
# methods "add" and "remove" in the "AvahiService" class, the
10
# "server_state_changed" and "entry_group_state_changed" functions,
11
# and some lines in "main".
9
# following functions: "add_service", "remove_service",
10
# "server_state_changed", "entry_group_state_changed", and some lines
11
# in "main".
12
12
#
13
# Everything else is
14
# Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
13
# Everything else is Copyright © 2007-2008 Teddy Hogeborn and Björn
14
# Påhlsson.
15
15
#
16
16
# This program is free software: you can redistribute it and/or modify
17
17
# it under the terms of the GNU General Public License as published by
26
26
# You should have received a copy of the GNU General Public License
27
27
# along with this program. If not, see <http://www.gnu.org/licenses/>.
28
28
#
29
# Contact the authors at <mandos@fukt.bsnet.se>.
29
# Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and
30
# <https://www.fukt.bsnet.se/~teddy/>.
30
31
#
31
32
32
33
from __future__ import division
61
62
from dbus.mainloop.glib import DBusGMainLoop
62
63
import ctypes
63
64
64
version = "1.0"
65
# Brief description of the operation of this program:
66
#
67
# This server announces itself as a Zeroconf service. Connecting
68
# clients use the TLS protocol, with the unusual quirk that this
69
# server program acts as a TLS "client" while the connecting clients
70
# acts as a TLS "server". The clients (acting as a TLS "server") must
71
# supply an OpenPGP certificate, and the fingerprint of this
72
# certificate is used by this server to look up (in a list read from a
73
# file at start time) which binary blob to give the client. No other
74
# authentication or authorization is done by this server.
75
65
76
66
77
logger = logging.Logger('mandos')
67
78
syslogger = logging.handlers.SysLogHandler\
68
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
69
address = "/dev/log")
79
(facility = logging.handlers.SysLogHandler.LOG_DAEMON)
70
80
syslogger.setFormatter(logging.Formatter\
71
('Mandos: %(levelname)s: %(message)s'))
81
('%(levelname)s: %(message)s'))
72
82
logger.addHandler(syslogger)
73
74
console = logging.StreamHandler()
75
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
76
' %(message)s'))
77
logger.addHandler(console)
78
79
class AvahiError(Exception):
80
def __init__(self, value):
81
self.value = value
82
def __str__(self):
83
return repr(self.value)
84
85
class AvahiServiceError(AvahiError):
86
pass
87
88
class AvahiGroupError(AvahiError):
89
pass
90
91
92
class AvahiService(object):
93
"""An Avahi (Zeroconf) service.
94
Attributes:
95
interface: integer; avahi.IF_UNSPEC or an interface index.
96
Used to optionally bind to the specified interface.
97
name: string; Example: 'Mandos'
98
type: string; Example: '_mandos._tcp'.
99
See <http://www.dns-sd.org/ServiceTypes.html>
100
port: integer; what port to announce
101
TXT: list of strings; TXT record for the service
102
domain: string; Domain to publish on, default to .local if empty.
103
host: string; Host to publish records for, default is localhost
104
max_renames: integer; maximum number of renames
105
rename_count: integer; counter so we only rename after collisions
106
a sensible number of times
107
"""
108
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
109
type = None, port = None, TXT = None, domain = "",
110
host = "", max_renames = 32768):
111
self.interface = interface
112
self.name = name
113
self.type = type
114
self.port = port
115
if TXT is None:
116
self.TXT = []
117
else:
118
self.TXT = TXT
119
self.domain = domain
120
self.host = host
121
self.rename_count = 0
122
self.max_renames = max_renames
123
def rename(self):
124
"""Derived from the Avahi example code"""
125
if self.rename_count >= self.max_renames:
126
logger.critical(u"No suitable service name found after %i"
127
u" retries, exiting.", rename_count)
128
raise AvahiServiceError("Too many renames")
129
self.name = server.GetAlternativeServiceName(self.name)
130
logger.info(u"Changing name to %r ...", str(self.name))
131
syslogger.setFormatter(logging.Formatter\
132
('Mandos (%s): %%(levelname)s:'
133
' %%(message)s' % self.name))
134
self.remove()
135
self.add()
136
self.rename_count += 1
137
def remove(self):
138
"""Derived from the Avahi example code"""
139
if group is not None:
140
group.Reset()
141
def add(self):
142
"""Derived from the Avahi example code"""
143
global group
144
if group is None:
145
group = dbus.Interface\
146
(bus.get_object(avahi.DBUS_NAME,
147
server.EntryGroupNew()),
148
avahi.DBUS_INTERFACE_ENTRY_GROUP)
149
group.connect_to_signal('StateChanged',
150
entry_group_state_changed)
151
logger.debug(u"Adding service '%s' of type '%s' ...",
152
service.name, service.type)
153
group.AddService(
154
self.interface, # interface
155
avahi.PROTO_INET6, # protocol
156
dbus.UInt32(0), # flags
157
self.name, self.type,
158
self.domain, self.host,
159
dbus.UInt16(self.port),
160
avahi.string_array_to_txt_array(self.TXT))
161
group.Commit()
162
83
del syslogger
84
85
# This variable is used to optionally bind to a specified interface.
86
# It is a global variable to fit in with the other variables from the
87
# Avahi example code.
88
serviceInterface = avahi.IF_UNSPEC
163
89
# From the Avahi example code:
164
group = None # our entry group
90
serviceName = None
91
serviceType = "_mandos._tcp" # http://www.dns-sd.org/ServiceTypes.html
92
servicePort = None # Not known at startup
93
serviceTXT = [] # TXT record for the service
94
domain = "" # Domain to publish on, default to .local
95
host = "" # Host to publish records for, default to localhost
96
group = None #our entry group
97
rename_count = 12 # Counter so we only rename after collisions a
98
# sensible number of times
165
99
# End of Avahi example code
166
100
167
101
172
106
fingerprint: string (40 or 32 hexadecimal digits); used to
173
107
uniquely identify the client
174
108
secret: bytestring; sent verbatim (over TLS) to client
175
host: string; available for use by the checker command
176
created: datetime.datetime(); object creation, not client host
177
last_checked_ok: datetime.datetime() or None if not yet checked OK
178
timeout: datetime.timedelta(); How long from last_checked_ok
179
until this client is invalid
109
fqdn: string (FQDN); available for use by the checker command
110
created: datetime.datetime()
111
last_seen: datetime.datetime() or None if not yet seen
112
timeout: datetime.timedelta(); How long from last_seen until
113
this client is invalid
180
114
interval: datetime.timedelta(); How often to start a new checker
181
115
stop_hook: If set, called by stop() as stop_hook(self)
182
116
checker: subprocess.Popen(); a running checker process used
183
117
to see if the client lives.
184
'None' if no process is running.
118
Is None if no process is running.
185
119
checker_initiator_tag: a gobject event source tag, or None
186
120
stop_initiator_tag: - '' -
187
121
checker_callback_tag: - '' -
188
122
checker_command: string; External command which is run to check if
189
client lives. %() expansions are done at
123
client lives. %()s expansions are done at
190
124
runtime with vars(self) as dict, so that for
191
125
instance %(name)s can be used in the command.
192
126
Private attibutes:
193
127
_timeout: Real variable for 'timeout'
194
128
_interval: Real variable for 'interval'
195
_timeout_milliseconds: Used when calling gobject.timeout_add()
129
_timeout_milliseconds: Used by gobject.timeout_add()
196
130
_interval_milliseconds: - '' -
197
131
"""
198
132
def _set_timeout(self, timeout):
218
152
interval = property(lambda self: self._interval,
219
153
_set_interval)
220
154
del _set_interval
221
def __init__(self, name = None, stop_hook=None, config={}):
222
"""Note: the 'checker' key in 'config' sets the
223
'checker_command' attribute and *not* the 'checker'
224
attribute."""
155
def __init__(self, name=None, stop_hook=None, fingerprint=None,
156
secret=None, secfile=None, fqdn=None, timeout=None,
157
interval=-1, checker=None):
158
"""Note: the 'checker' argument sets the 'checker_command'
159
attribute and not the 'checker' attribute.."""
225
160
self.name = name
226
161
logger.debug(u"Creating client %r", self.name)
227
# Uppercase and remove spaces from fingerprint for later
228
# comparison purposes with return value from the fingerprint()
229
# function
230
self.fingerprint = config["fingerprint"].upper()\
231
.replace(u" ", u"")
162
# Uppercase and remove spaces from fingerprint
163
# for later comparison purposes with return value of
164
# the fingerprint() function
165
self.fingerprint = fingerprint.upper().replace(u" ", u"")
232
166
logger.debug(u" Fingerprint: %s", self.fingerprint)
233
if "secret" in config:
234
self.secret = config["secret"].decode(u"base64")
235
elif "secfile" in config:
236
sf = open(config["secfile"])
167
if secret:
168
self.secret = secret.decode(u"base64")
169
elif secfile:
170
sf = open(secfile)
237
171
self.secret = sf.read()
238
172
sf.close()
239
173
else:
240
raise TypeError(u"No secret or secfile for client %s"
241
% self.name)
242
self.host = config.get("host", "")
174
raise RuntimeError(u"No secret or secfile for client %s"
175
% self.name)
176
self.fqdn = fqdn # string
243
177
self.created = datetime.datetime.now()
244
self.last_checked_ok = None
245
self.timeout = string_to_delta(config["timeout"])
246
self.interval = string_to_delta(config["interval"])
178
self.last_seen = None
179
self.timeout = string_to_delta(timeout)
180
self.interval = string_to_delta(interval)
247
181
self.stop_hook = stop_hook
248
182
self.checker = None
249
183
self.checker_initiator_tag = None
250
184
self.stop_initiator_tag = None
251
185
self.checker_callback_tag = None
252
self.check_command = config["checker"]
186
self.check_command = checker
253
187
def start(self):
254
188
"""Start this client's checker and timeout hooks"""
255
189
# Schedule a new checker to be started an 'interval' from now,
265
199
self.stop)
266
200
def stop(self):
267
201
"""Stop this client.
268
The possibility that a client might be restarted is left open,
269
but not currently used."""
202
The possibility that this client might be restarted is left
203
open, but not currently used."""
270
204
# If this client doesn't have a secret, it is already stopped.
271
if hasattr(self, "secret") and self.secret:
272
logger.info(u"Stopping client %s", self.name)
205
if self.secret:
206
logger.debug(u"Stopping client %s", self.name)
273
207
self.secret = None
274
208
else:
275
209
return False
276
if getattr(self, "stop_initiator_tag", False):
210
if hasattr(self, "stop_initiator_tag") \
211
and self.stop_initiator_tag:
277
212
gobject.source_remove(self.stop_initiator_tag)
278
213
self.stop_initiator_tag = None
279
if getattr(self, "checker_initiator_tag", False):
214
if hasattr(self, "checker_initiator_tag") \
215
and self.checker_initiator_tag:
280
216
gobject.source_remove(self.checker_initiator_tag)
281
217
self.checker_initiator_tag = None
282
218
self.stop_checker()
294
230
self.checker = None
295
231
if os.WIFEXITED(condition) \
296
232
and (os.WEXITSTATUS(condition) == 0):
297
logger.info(u"Checker for %(name)s succeeded",
298
vars(self))
299
self.last_checked_ok = now
233
logger.debug(u"Checker for %(name)s succeeded",
234
vars(self))
235
self.last_seen = now
300
236
gobject.source_remove(self.stop_initiator_tag)
301
237
self.stop_initiator_tag = gobject.timeout_add\
302
238
(self._timeout_milliseconds,
305
241
logger.warning(u"Checker for %(name)s crashed?",
306
242
vars(self))
307
243
else:
308
logger.info(u"Checker for %(name)s failed",
309
vars(self))
244
logger.debug(u"Checker for %(name)s failed",
245
vars(self))
310
246
def start_checker(self):
311
247
"""Start a new checker subprocess if one is not running.
312
248
If a checker already exists, leave it running and do
321
257
# is as it should be.
322
258
if self.checker is None:
323
259
try:
324
# In case check_command has exactly one % operator
325
command = self.check_command % self.host
260
command = self.check_command % self.fqdn
326
261
except TypeError:
327
# Escape attributes for the shell
328
262
escaped_attrs = dict((key, re.escape(str(val)))
329
263
for key, val in
330
264
vars(self).iteritems())
331
265
try:
332
266
command = self.check_command % escaped_attrs
333
267
except TypeError, error:
334
logger.error(u'Could not format string "%s":'
335
u' %s', self.check_command, error)
268
logger.critical(u'Could not format string "%s":'
269
u' %s', self.check_command, error)
336
270
return True # Try again later
337
271
try:
338
logger.info(u"Starting checker %r for %s",
339
command, self.name)
340
# We don't need to redirect stdout and stderr, since
341
# in normal mode, that is already done by daemon(),
342
# and in debug mode we don't want to. (Stdin is
343
# always replaced by /dev/null.)
344
self.checker = subprocess.Popen(command,
345
close_fds=True,
346
shell=True, cwd="/")
272
logger.debug(u"Starting checker %r for %s",
273
command, self.name)
274
self.checker = subprocess.\
275
Popen(command,
276
close_fds=True, shell=True,
277
cwd="/")
347
278
self.checker_callback_tag = gobject.child_watch_add\
348
279
(self.checker.pid,
349
280
self.checker_callback)
350
except OSError, error:
281
except subprocess.OSError, error:
351
282
logger.error(u"Failed to start subprocess: %s",
352
283
error)
353
284
# Re-run this periodically if run by gobject.timeout_add
357
288
if self.checker_callback_tag:
358
289
gobject.source_remove(self.checker_callback_tag)
359
290
self.checker_callback_tag = None
360
if getattr(self, "checker", None) is None:
291
if not hasattr(self, "checker") or self.checker is None:
361
292
return
362
logger.debug(u"Stopping checker for %(name)s", vars(self))
293
logger.debug("Stopping checker for %(name)s", vars(self))
363
294
try:
364
295
os.kill(self.checker.pid, signal.SIGTERM)
365
296
#os.sleep(0.5)
366
297
#if self.checker.poll() is None:
367
298
# os.kill(self.checker.pid, signal.SIGKILL)
368
299
except OSError, error:
369
if error.errno != errno.ESRCH: # No such process
300
if error.errno != errno.ESRCH:
370
301
raise
371
302
self.checker = None
372
def still_valid(self):
303
def still_valid(self, now=None):
373
304
"""Has the timeout not yet passed for this client?"""
374
now = datetime.datetime.now()
375
if self.last_checked_ok is None:
305
if now is None:
306
now = datetime.datetime.now()
307
if self.last_seen is None:
376
308
return now < (self.created + self.timeout)
377
309
else:
378
return now < (self.last_checked_ok + self.timeout)
310
return now < (self.last_seen + self.timeout)
379
311
380
312
381
313
def peer_certificate(session):
397
329
398
330
def fingerprint(openpgp):
399
331
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
332
# New empty GnuTLS certificate
333
crt = gnutls.library.types.gnutls_openpgp_crt_t()
334
gnutls.library.functions.gnutls_openpgp_crt_init\
335
(ctypes.byref(crt))
400
336
# New GnuTLS "datum" with the OpenPGP public key
401
337
datum = gnutls.library.types.gnutls_datum_t\
402
338
(ctypes.cast(ctypes.c_char_p(openpgp),
403
339
ctypes.POINTER(ctypes.c_ubyte)),
404
340
ctypes.c_uint(len(openpgp)))
405
# New empty GnuTLS certificate
406
crt = gnutls.library.types.gnutls_openpgp_crt_t()
407
gnutls.library.functions.gnutls_openpgp_crt_init\
408
(ctypes.byref(crt))
409
341
# Import the OpenPGP public key into the certificate
410
gnutls.library.functions.gnutls_openpgp_crt_import\
411
(crt, ctypes.byref(datum),
412
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
342
ret = gnutls.library.functions.gnutls_openpgp_crt_import\
343
(crt,
344
ctypes.byref(datum),
345
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
413
346
# New buffer for the fingerprint
414
347
buffer = ctypes.create_string_buffer(20)
415
348
buffer_length = ctypes.c_size_t()
431
364
Note: This will run in its own forked process."""
432
365
433
366
def handle(self):
434
logger.info(u"TCP connection from: %s",
367
logger.debug(u"TCP connection from: %s",
435
368
unicode(self.client_address))
436
session = gnutls.connection.ClientSession\
437
(self.request, gnutls.connection.X509Credentials())
438
439
line = self.request.makefile().readline()
440
logger.debug(u"Protocol version: %r", line)
441
try:
442
if int(line.strip().split()[0]) > 1:
443
raise RuntimeError
444
except (ValueError, IndexError, RuntimeError), error:
445
logger.error(u"Unknown protocol version: %s", error)
446
return
447
448
# Note: gnutls.connection.X509Credentials is really a generic
449
# GnuTLS certificate credentials object so long as no X.509
450
# keys are added to it. Therefore, we can use it here despite
451
# using OpenPGP certificates.
369
session = gnutls.connection.ClientSession(self.request,
370
gnutls.connection.\
371
X509Credentials())
452
372
453
373
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
454
374
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
455
375
# "+DHE-DSS"))
456
priority = "NORMAL" # Fallback default, since this
457
# MUST be set.
458
if self.server.settings["priority"]:
459
priority = self.server.settings["priority"]
376
priority = "NORMAL"
377
if self.server.options.priority:
378
priority = self.server.options.priority
460
379
gnutls.library.functions.gnutls_priority_set_direct\
461
380
(session._c_object, priority, None);
462
381
463
382
try:
464
383
session.handshake()
465
384
except gnutls.errors.GNUTLSError, error:
466
logger.warning(u"Handshake failed: %s", error)
385
logger.debug(u"Handshake failed: %s", error)
467
386
# Do not run session.bye() here: the session is not
468
387
# established. Just abandon the request.
469
388
return
470
389
try:
471
390
fpr = fingerprint(peer_certificate(session))
472
391
except (TypeError, gnutls.errors.GNUTLSError), error:
473
logger.warning(u"Bad certificate: %s", error)
392
logger.debug(u"Bad certificate: %s", error)
474
393
session.bye()
475
394
return
476
395
logger.debug(u"Fingerprint: %s", fpr)
479
398
if c.fingerprint == fpr:
480
399
client = c
481
400
break
482
if not client:
483
logger.warning(u"Client not found for fingerprint: %s",
484
fpr)
485
session.bye()
486
return
487
401
# Have to check if client.still_valid(), since it is possible
488
402
# that the client timed out while establishing the GnuTLS
489
403
# session.
490
if not client.still_valid():
491
logger.warning(u"Client %(name)s is invalid",
492
vars(client))
404
if (not client) or (not client.still_valid()):
405
if client:
406
logger.debug(u"Client %(name)s is invalid",
407
vars(client))
408
else:
409
logger.debug(u"Client not found for fingerprint: %s",
410
fpr)
493
411
session.bye()
494
412
return
495
413
sent_size = 0
505
423
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
506
424
"""IPv6 TCP server. Accepts 'None' as address and/or port.
507
425
Attributes:
508
settings: Server settings
426
options: Command line options
509
427
clients: Set() of Client objects
510
428
"""
511
429
address_family = socket.AF_INET6
512
430
def __init__(self, *args, **kwargs):
513
if "settings" in kwargs:
514
self.settings = kwargs["settings"]
515
del kwargs["settings"]
431
if "options" in kwargs:
432
self.options = kwargs["options"]
433
del kwargs["options"]
516
434
if "clients" in kwargs:
517
435
self.clients = kwargs["clients"]
518
436
del kwargs["clients"]
521
439
"""This overrides the normal server_bind() function
522
440
to bind to an interface if one was specified, and also NOT to
523
441
bind to an address or port if they were not specified."""
524
if self.settings["interface"]:
525
# 25 is from /usr/include/asm-i486/socket.h
526
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
442
if self.options.interface:
443
if not hasattr(socket, "SO_BINDTODEVICE"):
444
# From /usr/include/asm-i486/socket.h
445
socket.SO_BINDTODEVICE = 25
527
446
try:
528
447
self.socket.setsockopt(socket.SOL_SOCKET,
529
SO_BINDTODEVICE,
530
self.settings["interface"])
448
socket.SO_BINDTODEVICE,
449
self.options.interface)
531
450
except socket.error, error:
532
451
if error[0] == errno.EPERM:
533
logger.error(u"No permission to"
534
u" bind to interface %s",
535
self.settings["interface"])
452
logger.warning(u"No permission to"
453
u" bind to interface %s",
454
self.options.interface)
536
455
else:
537
456
raise error
538
457
# Only bind(2) the socket if we really need to.
541
460
in6addr_any = "::"
542
461
self.server_address = (in6addr_any,
543
462
self.server_address[1])
544
elif not self.server_address[1]:
463
elif self.server_address[1] is None:
545
464
self.server_address = (self.server_address[0],
546
465
0)
547
# if self.settings["interface"]:
548
# self.server_address = (self.server_address[0],
549
# 0, # port
550
# 0, # flowinfo
551
# if_nametoindex
552
# (self.settings
553
# ["interface"]))
554
466
return super(type(self), self).server_bind()
555
467
556
468
567
479
datetime.timedelta(1)
568
480
>>> string_to_delta(u'1w')
569
481
datetime.timedelta(7)
570
>>> string_to_delta('5m 30s')
571
datetime.timedelta(0, 330)
572
482
"""
573
timevalue = datetime.timedelta(0)
574
for s in interval.split():
575
try:
576
suffix=unicode(s[-1])
577
value=int(s[:-1])
578
if suffix == u"d":
579
delta = datetime.timedelta(value)
580
elif suffix == u"s":
581
delta = datetime.timedelta(0, value)
582
elif suffix == u"m":
583
delta = datetime.timedelta(0, 0, 0, 0, value)
584
elif suffix == u"h":
585
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
586
elif suffix == u"w":
587
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
588
else:
589
raise ValueError
590
except (ValueError, IndexError):
483
try:
484
suffix=unicode(interval[-1])
485
value=int(interval[:-1])
486
if suffix == u"d":
487
delta = datetime.timedelta(value)
488
elif suffix == u"s":
489
delta = datetime.timedelta(0, value)
490
elif suffix == u"m":
491
delta = datetime.timedelta(0, 0, 0, 0, value)
492
elif suffix == u"h":
493
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
494
elif suffix == u"w":
495
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
496
else:
591
497
raise ValueError
592
timevalue += delta
593
return timevalue
498
except (ValueError, IndexError):
499
raise ValueError
500
return delta
501
502
503
def add_service():
504
"""Derived from the Avahi example code"""
505
global group, serviceName, serviceType, servicePort, serviceTXT, \
506
domain, host
507
if group is None:
508
group = dbus.Interface(
509
bus.get_object( avahi.DBUS_NAME,
510
server.EntryGroupNew()),
511
avahi.DBUS_INTERFACE_ENTRY_GROUP)
512
group.connect_to_signal('StateChanged',
513
entry_group_state_changed)
514
logger.debug(u"Adding service '%s' of type '%s' ...",
515
serviceName, serviceType)
516
517
group.AddService(
518
serviceInterface, # interface
519
avahi.PROTO_INET6, # protocol
520
dbus.UInt32(0), # flags
521
serviceName, serviceType,
522
domain, host,
523
dbus.UInt16(servicePort),
524
avahi.string_array_to_txt_array(serviceTXT))
525
group.Commit()
526
527
528
def remove_service():
529
"""From the Avahi example code"""
530
global group
531
532
if not group is None:
533
group.Reset()
594
534
595
535
596
536
def server_state_changed(state):
597
537
"""Derived from the Avahi example code"""
598
538
if state == avahi.SERVER_COLLISION:
599
logger.error(u"Server name collision")
600
service.remove()
539
logger.warning(u"Server name collision")
540
remove_service()
601
541
elif state == avahi.SERVER_RUNNING:
602
service.add()
542
add_service()
603
543
604
544
605
545
def entry_group_state_changed(state, error):
606
546
"""Derived from the Avahi example code"""
547
global serviceName, server, rename_count
548
607
549
logger.debug(u"state change: %i", state)
608
550
609
551
if state == avahi.ENTRY_GROUP_ESTABLISHED:
610
552
logger.debug(u"Service established.")
611
553
elif state == avahi.ENTRY_GROUP_COLLISION:
612
logger.warning(u"Service name collision.")
613
service.rename()
554
555
rename_count = rename_count - 1
556
if rename_count > 0:
557
name = server.GetAlternativeServiceName(name)
558
logger.warning(u"Service name collision, "
559
u"changing name to '%s' ...", name)
560
remove_service()
561
add_service()
562
563
else:
564
logger.error(u"No suitable service name found after %i"
565
u" retries, exiting.", n_rename)
566
killme(1)
614
567
elif state == avahi.ENTRY_GROUP_FAILURE:
615
logger.critical(u"Error in group state changed %s",
616
unicode(error))
617
raise AvahiGroupError("State changed: %s", str(error))
568
logger.error(u"Error in group state changed %s",
569
unicode(error))
570
killme(1)
571
618
572
619
573
def if_nametoindex(interface):
620
"""Call the C function if_nametoindex(), or equivalent"""
621
global if_nametoindex
574
"""Call the C function if_nametoindex()"""
622
575
try:
623
if "ctypes.util" not in sys.modules:
624
import ctypes.util
625
if_nametoindex = ctypes.cdll.LoadLibrary\
626
(ctypes.util.find_library("c")).if_nametoindex
576
libc = ctypes.cdll.LoadLibrary("libc.so.6")
577
return libc.if_nametoindex(interface)
627
578
except (OSError, AttributeError):
628
579
if "struct" not in sys.modules:
629
580
import struct
630
581
if "fcntl" not in sys.modules:
631
582
import fcntl
632
def if_nametoindex(interface):
633
"Get an interface index the hard way, i.e. using fcntl()"
634
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
635
s = socket.socket()
636
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
637
struct.pack("16s16x", interface))
638
s.close()
639
interface_index = struct.unpack("I", ifreq[16:20])[0]
640
return interface_index
641
return if_nametoindex(interface)
642
643
644
def daemon(nochdir = False, noclose = False):
583
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
584
s = socket.socket()
585
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
586
struct.pack("16s16x", interface))
587
s.close()
588
interface_index = struct.unpack("I", ifreq[16:20])[0]
589
return interface_index
590
591
592
def daemon(nochdir, noclose):
645
593
"""See daemon(3). Standard BSD Unix function.
646
594
This should really exist as os.daemon, but it doesn't (yet)."""
647
595
if os.fork():
649
597
os.setsid()
650
598
if not nochdir:
651
599
os.chdir("/")
652
if os.fork():
653
sys.exit()
654
600
if not noclose:
655
601
# Close all standard open file descriptors
656
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
602
null = os.open("/dev/null", os.O_NOCTTY | os.O_RDWR)
657
603
if not stat.S_ISCHR(os.fstat(null).st_mode):
658
604
raise OSError(errno.ENODEV,
659
605
"/dev/null not a character device")
664
610
os.close(null)
665
611
666
612
613
def killme(status = 0):
614
logger.debug("Stopping server with exit status %d", status)
615
exitstatus = status
616
if main_loop_started:
617
main_loop.quit()
618
else:
619
sys.exit(status)
620
621
667
622
def main():
623
global exitstatus
624
exitstatus = 0
668
625
global main_loop_started
669
626
main_loop_started = False
670
627
671
parser = OptionParser(version = "%%prog %s" % version)
628
parser = OptionParser()
672
629
parser.add_option("-i", "--interface", type="string",
673
metavar="IF", help="Bind to interface IF")
674
parser.add_option("-a", "--address", type="string",
630
default=None, metavar="IF",
631
help="Bind to interface IF")
632
parser.add_option("-a", "--address", type="string", default=None,
675
633
help="Address to listen for requests on")
676
parser.add_option("-p", "--port", type="int",
634
parser.add_option("-p", "--port", type="int", default=None,
677
635
help="Port number to receive requests on")
678
636
parser.add_option("--check", action="store_true", default=False,
679
637
help="Run self-test")
680
parser.add_option("--debug", action="store_true",
681
help="Debug mode; run in foreground and log to"
682
" terminal")
683
parser.add_option("--priority", type="string", help="GnuTLS"
684
" priority string (see GnuTLS documentation)")
685
parser.add_option("--servicename", type="string", metavar="NAME",
686
help="Zeroconf service name")
687
parser.add_option("--configdir", type="string",
688
default="/etc/mandos", metavar="DIR",
689
help="Directory to search for configuration"
690
" files")
638
parser.add_option("--debug", action="store_true", default=False,
639
help="Debug mode")
640
parser.add_option("--priority", type="string",
641
default="SECURE256",
642
help="GnuTLS priority string"
643
" (see GnuTLS documentation)")
644
parser.add_option("--servicename", type="string",
645
default="Mandos", help="Zeroconf service name")
691
646
(options, args) = parser.parse_args()
692
647
693
648
if options.check:
695
650
doctest.testmod()
696
651
sys.exit()
697
652
698
# Default values for config file for server-global settings
699
server_defaults = { "interface": "",
700
"address": "",
701
"port": "",
702
"debug": "False",
703
"priority":
704
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
705
"servicename": "Mandos",
706
}
707
708
# Parse config file for server-global settings
709
server_config = ConfigParser.SafeConfigParser(server_defaults)
710
del server_defaults
711
server_config.read(os.path.join(options.configdir, "mandos.conf"))
712
# Convert the SafeConfigParser object to a dict
713
server_settings = server_config.defaults()
714
# Use getboolean on the boolean config option
715
server_settings["debug"] = server_config.getboolean\
716
("DEFAULT", "debug")
717
del server_config
718
719
# Override the settings from the config file with command line
720
# options, if set.
721
for option in ("interface", "address", "port", "debug",
722
"priority", "servicename", "configdir"):
723
value = getattr(options, option)
724
if value is not None:
725
server_settings[option] = value
726
del options
727
# Now we have our good server settings in "server_settings"
728
729
debug = server_settings["debug"]
730
731
if not debug:
732
syslogger.setLevel(logging.WARNING)
733
console.setLevel(logging.WARNING)
734
735
if server_settings["servicename"] != "Mandos":
736
syslogger.setFormatter(logging.Formatter\
737
('Mandos (%s): %%(levelname)s:'
738
' %%(message)s'
739
% server_settings["servicename"]))
740
741
# Parse config file with clients
742
client_defaults = { "timeout": "1h",
743
"interval": "5m",
744
"checker": "fping -q -- %(host)s",
745
"host": "",
746
}
747
client_config = ConfigParser.SafeConfigParser(client_defaults)
748
client_config.read(os.path.join(server_settings["configdir"],
749
"clients.conf"))
750
751
global service
752
service = AvahiService(name = server_settings["servicename"],
753
type = "_mandos._tcp", );
754
if server_settings["interface"]:
755
service.interface = if_nametoindex(server_settings["interface"])
653
# Parse config file
654
defaults = { "timeout": "1h",
655
"interval": "5m",
656
"checker": "fping -q -- %%(fqdn)s",
657
}
658
client_config = ConfigParser.SafeConfigParser(defaults)
659
#client_config.readfp(open("global.conf"), "global.conf")
660
client_config.read("mandos-clients.conf")
661
662
global serviceName
663
serviceName = options.servicename;
756
664
757
665
global main_loop
758
666
global bus
766
674
avahi.DBUS_INTERFACE_SERVER )
767
675
# End of Avahi example code
768
676
677
debug = options.debug
678
679
if debug:
680
console = logging.StreamHandler()
681
# console.setLevel(logging.DEBUG)
682
console.setFormatter(logging.Formatter\
683
('%(levelname)s: %(message)s'))
684
logger.addHandler(console)
685
del console
686
769
687
clients = Set()
770
688
def remove_from_clients(client):
771
689
clients.remove(client)
772
690
if not clients:
773
logger.critical(u"No clients left, exiting")
774
sys.exit()
691
logger.debug(u"No clients left, exiting")
692
killme()
775
693
776
clients.update(Set(Client(name = section,
694
clients.update(Set(Client(name=section,
777
695
stop_hook = remove_from_clients,
778
config
779
= dict(client_config.items(section)))
696
**(dict(client_config\
697
.items(section))))
780
698
for section in client_config.sections()))
781
if not clients:
782
logger.critical(u"No clients defined")
783
sys.exit(1)
784
785
if debug:
786
# Redirect stdin so all checkers get /dev/null
787
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
788
os.dup2(null, sys.stdin.fileno())
789
if null > 2:
790
os.close(null)
791
else:
792
# No console logging
793
logger.removeHandler(console)
794
# Close all input and output, do double fork, etc.
795
daemon()
796
797
pidfilename = "/var/run/mandos/mandos.pid"
798
pid = os.getpid()
799
try:
800
pidfile = open(pidfilename, "w")
801
pidfile.write(str(pid) + "\n")
802
pidfile.close()
803
del pidfile
804
except IOError, err:
805
logger.error(u"Could not write %s file with PID %d",
806
pidfilename, os.getpid())
699
700
if not debug:
701
daemon(False, False)
807
702
808
703
def cleanup():
809
704
"Cleanup function; run on exit"
823
718
824
719
if not debug:
825
720
signal.signal(signal.SIGINT, signal.SIG_IGN)
826
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
827
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
721
signal.signal(signal.SIGHUP, lambda signum, frame: killme())
722
signal.signal(signal.SIGTERM, lambda signum, frame: killme())
828
723
829
724
for client in clients:
830
725
client.start()
831
726
832
tcp_server = IPv6_TCPServer((server_settings["address"],
833
server_settings["port"]),
727
tcp_server = IPv6_TCPServer((options.address, options.port),
834
728
tcp_handler,
835
settings=server_settings,
729
options=options,
836
730
clients=clients)
837
# Find out what port we got
838
service.port = tcp_server.socket.getsockname()[1]
839
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
840
u" scope_id %d" % tcp_server.socket.getsockname())
841
842
#service.interface = tcp_server.socket.getsockname()[3]
843
844
try:
845
# From the Avahi example code
846
server.connect_to_signal("StateChanged", server_state_changed)
847
try:
848
server_state_changed(server.GetState())
849
except dbus.exceptions.DBusException, error:
850
logger.critical(u"DBusException: %s", error)
851
sys.exit(1)
852
# End of Avahi example code
853
854
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
855
lambda *args, **kwargs:
856
tcp_server.handle_request\
857
(*args[2:], **kwargs) or True)
858
859
logger.debug(u"Starting main loop")
731
# Find out what random port we got
732
global servicePort
733
servicePort = tcp_server.socket.getsockname()[1]
734
logger.debug(u"Now listening on port %d", servicePort)
735
736
if options.interface is not None:
737
global serviceInterface
738
serviceInterface = if_nametoindex(options.interface)
739
740
# From the Avahi example code
741
server.connect_to_signal("StateChanged", server_state_changed)
742
try:
743
server_state_changed(server.GetState())
744
except dbus.exceptions.DBusException, error:
745
logger.critical(u"DBusException: %s", error)
746
killme(1)
747
# End of Avahi example code
748
749
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
750
lambda *args, **kwargs:
751
tcp_server.handle_request(*args[2:],
752
**kwargs) or True)
753
try:
754
logger.debug("Starting main loop")
860
755
main_loop_started = True
861
756
main_loop.run()
862
except AvahiError, error:
863
logger.critical(u"AvahiError: %s" + unicode(error))
864
sys.exit(1)
865
757
except KeyboardInterrupt:
866
758
if debug:
867
759
print
760
761
sys.exit(exitstatus)
868
762
869
763
if __name__ == '__main__':
870
764
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0