To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to server.py
- browse files at revision 27
- compare with another revision
- download diff
- download tarball
- view history from revision 27
- Committer: Teddy Hogeborn
- Date: 2008-07-22 06:25:35 UTC
- mfrom: (24.1.2 mandos)
- Revision ID: teddy@fukt.bsnet.se-20080722062535-whz5do0b3dzw6m08
Merge.
- files added:
- ca.pem
- files removed:
- mandos-client.xml
- files renamed:
- clients.conf => mandos-clients.conf
- mandos-client.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
def rename(self):
123
"""Derived from the Avahi example code"""
124
if self.rename_count >= self.max_renames:
125
logger.critical(u"No suitable service name found after %i"
126
u" retries, exiting.", rename_count)
127
raise AvahiServiceError("Too many renames")
128
name = server.GetAlternativeServiceName(name)
129
logger.error(u"Changing name to %r ...", name)
130
syslogger.setFormatter(logging.Formatter\
131
('Mandos (%s): %%(levelname)s:'
132
' %%(message)s' % name))
133
self.remove()
134
self.add()
135
self.rename_count += 1
136
def remove(self):
137
"""Derived from the Avahi example code"""
138
if group is not None:
139
group.Reset()
140
def add(self):
141
"""Derived from the Avahi example code"""
142
global group
143
if group is None:
144
group = dbus.Interface\
145
(bus.get_object(avahi.DBUS_NAME,
146
server.EntryGroupNew()),
147
avahi.DBUS_INTERFACE_ENTRY_GROUP)
148
group.connect_to_signal('StateChanged',
149
entry_group_state_changed)
150
logger.debug(u"Adding service '%s' of type '%s' ...",
151
service.name, service.type)
152
group.AddService(
153
self.interface, # interface
154
avahi.PROTO_INET6, # protocol
155
dbus.UInt32(0), # flags
156
self.name, self.type,
157
self.domain, self.host,
158
dbus.UInt16(self.port),
159
avahi.string_array_to_txt_array(self.TXT))
160
group.Commit()
161
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
162
89
# From the Avahi example code:
163
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
164
99
# End of Avahi example code
165
100
166
101
171
106
fingerprint: string (40 or 32 hexadecimal digits); used to
172
107
uniquely identify the client
173
108
secret: bytestring; sent verbatim (over TLS) to client
174
host: string; available for use by the checker command
175
created: datetime.datetime(); object creation, not client host
176
last_checked_ok: datetime.datetime() or None if not yet checked OK
177
timeout: datetime.timedelta(); How long from last_checked_ok
178
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
179
114
interval: datetime.timedelta(); How often to start a new checker
180
115
stop_hook: If set, called by stop() as stop_hook(self)
181
116
checker: subprocess.Popen(); a running checker process used
182
117
to see if the client lives.
183
'None' if no process is running.
118
Is None if no process is running.
184
119
checker_initiator_tag: a gobject event source tag, or None
185
120
stop_initiator_tag: - '' -
186
121
checker_callback_tag: - '' -
187
122
checker_command: string; External command which is run to check if
188
client lives. %() expansions are done at
123
client lives. %()s expansions are done at
189
124
runtime with vars(self) as dict, so that for
190
125
instance %(name)s can be used in the command.
191
126
Private attibutes:
192
127
_timeout: Real variable for 'timeout'
193
128
_interval: Real variable for 'interval'
194
_timeout_milliseconds: Used when calling gobject.timeout_add()
129
_timeout_milliseconds: Used by gobject.timeout_add()
195
130
_interval_milliseconds: - '' -
196
131
"""
197
132
def _set_timeout(self, timeout):
217
152
interval = property(lambda self: self._interval,
218
153
_set_interval)
219
154
del _set_interval
220
def __init__(self, name = None, stop_hook=None, config={}):
221
"""Note: the 'checker' key in 'config' sets the
222
'checker_command' attribute and *not* the 'checker'
223
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.."""
224
160
self.name = name
225
161
logger.debug(u"Creating client %r", self.name)
226
# Uppercase and remove spaces from fingerprint for later
227
# comparison purposes with return value from the fingerprint()
228
# function
229
self.fingerprint = config["fingerprint"].upper()\
230
.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"")
231
166
logger.debug(u" Fingerprint: %s", self.fingerprint)
232
if "secret" in config:
233
self.secret = config["secret"].decode(u"base64")
234
elif "secfile" in config:
235
sf = open(config["secfile"])
167
if secret:
168
self.secret = secret.decode(u"base64")
169
elif secfile:
170
sf = open(secfile)
236
171
self.secret = sf.read()
237
172
sf.close()
238
173
else:
239
raise TypeError(u"No secret or secfile for client %s"
240
% self.name)
241
self.host = config.get("host", "")
174
raise RuntimeError(u"No secret or secfile for client %s"
175
% self.name)
176
self.fqdn = fqdn # string
242
177
self.created = datetime.datetime.now()
243
self.last_checked_ok = None
244
self.timeout = string_to_delta(config["timeout"])
245
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)
246
181
self.stop_hook = stop_hook
247
182
self.checker = None
248
183
self.checker_initiator_tag = None
249
184
self.stop_initiator_tag = None
250
185
self.checker_callback_tag = None
251
self.check_command = config["checker"]
186
self.check_command = checker
252
187
def start(self):
253
188
"""Start this client's checker and timeout hooks"""
254
189
# Schedule a new checker to be started an 'interval' from now,
264
199
self.stop)
265
200
def stop(self):
266
201
"""Stop this client.
267
The possibility that a client might be restarted is left open,
268
but not currently used."""
202
The possibility that this client might be restarted is left
203
open, but not currently used."""
269
204
# If this client doesn't have a secret, it is already stopped.
270
if hasattr(self, "secret") and self.secret:
271
logger.info(u"Stopping client %s", self.name)
205
if self.secret:
206
logger.debug(u"Stopping client %s", self.name)
272
207
self.secret = None
273
208
else:
274
209
return False
275
if getattr(self, "stop_initiator_tag", False):
210
if hasattr(self, "stop_initiator_tag") \
211
and self.stop_initiator_tag:
276
212
gobject.source_remove(self.stop_initiator_tag)
277
213
self.stop_initiator_tag = None
278
if getattr(self, "checker_initiator_tag", False):
214
if hasattr(self, "checker_initiator_tag") \
215
and self.checker_initiator_tag:
279
216
gobject.source_remove(self.checker_initiator_tag)
280
217
self.checker_initiator_tag = None
281
218
self.stop_checker()
293
230
self.checker = None
294
231
if os.WIFEXITED(condition) \
295
232
and (os.WEXITSTATUS(condition) == 0):
296
logger.info(u"Checker for %(name)s succeeded",
297
vars(self))
298
self.last_checked_ok = now
233
logger.debug(u"Checker for %(name)s succeeded",
234
vars(self))
235
self.last_seen = now
299
236
gobject.source_remove(self.stop_initiator_tag)
300
237
self.stop_initiator_tag = gobject.timeout_add\
301
238
(self._timeout_milliseconds,
304
241
logger.warning(u"Checker for %(name)s crashed?",
305
242
vars(self))
306
243
else:
307
logger.info(u"Checker for %(name)s failed",
308
vars(self))
244
logger.debug(u"Checker for %(name)s failed",
245
vars(self))
309
246
def start_checker(self):
310
247
"""Start a new checker subprocess if one is not running.
311
248
If a checker already exists, leave it running and do
320
257
# is as it should be.
321
258
if self.checker is None:
322
259
try:
323
# In case check_command has exactly one % operator
324
command = self.check_command % self.host
260
command = self.check_command % self.fqdn
325
261
except TypeError:
326
# Escape attributes for the shell
327
262
escaped_attrs = dict((key, re.escape(str(val)))
328
263
for key, val in
329
264
vars(self).iteritems())
330
265
try:
331
266
command = self.check_command % escaped_attrs
332
267
except TypeError, error:
333
logger.error(u'Could not format string "%s":'
334
u' %s', self.check_command, error)
268
logger.critical(u'Could not format string "%s":'
269
u' %s', self.check_command, error)
335
270
return True # Try again later
336
271
try:
337
logger.info(u"Starting checker %r for %s",
338
command, self.name)
339
self.checker = subprocess.Popen(command,
340
close_fds=True,
341
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="/")
342
278
self.checker_callback_tag = gobject.child_watch_add\
343
279
(self.checker.pid,
344
280
self.checker_callback)
352
288
if self.checker_callback_tag:
353
289
gobject.source_remove(self.checker_callback_tag)
354
290
self.checker_callback_tag = None
355
if getattr(self, "checker", None) is None:
291
if not hasattr(self, "checker") or self.checker is None:
356
292
return
357
logger.debug(u"Stopping checker for %(name)s", vars(self))
293
logger.debug("Stopping checker for %(name)s", vars(self))
358
294
try:
359
295
os.kill(self.checker.pid, signal.SIGTERM)
360
296
#os.sleep(0.5)
361
297
#if self.checker.poll() is None:
362
298
# os.kill(self.checker.pid, signal.SIGKILL)
363
299
except OSError, error:
364
if error.errno != errno.ESRCH: # No such process
300
if error.errno != errno.ESRCH:
365
301
raise
366
302
self.checker = None
367
def still_valid(self):
303
def still_valid(self, now=None):
368
304
"""Has the timeout not yet passed for this client?"""
369
now = datetime.datetime.now()
370
if self.last_checked_ok is None:
305
if now is None:
306
now = datetime.datetime.now()
307
if self.last_seen is None:
371
308
return now < (self.created + self.timeout)
372
309
else:
373
return now < (self.last_checked_ok + self.timeout)
310
return now < (self.last_seen + self.timeout)
374
311
375
312
376
313
def peer_certificate(session):
392
329
393
330
def fingerprint(openpgp):
394
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))
395
336
# New GnuTLS "datum" with the OpenPGP public key
396
337
datum = gnutls.library.types.gnutls_datum_t\
397
338
(ctypes.cast(ctypes.c_char_p(openpgp),
398
339
ctypes.POINTER(ctypes.c_ubyte)),
399
340
ctypes.c_uint(len(openpgp)))
400
# New empty GnuTLS certificate
401
crt = gnutls.library.types.gnutls_openpgp_crt_t()
402
gnutls.library.functions.gnutls_openpgp_crt_init\
403
(ctypes.byref(crt))
404
341
# Import the OpenPGP public key into the certificate
405
gnutls.library.functions.gnutls_openpgp_crt_import\
406
(crt, ctypes.byref(datum),
407
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)
408
346
# New buffer for the fingerprint
409
347
buffer = ctypes.create_string_buffer(20)
410
348
buffer_length = ctypes.c_size_t()
426
364
Note: This will run in its own forked process."""
427
365
428
366
def handle(self):
429
logger.info(u"TCP connection from: %s",
367
logger.debug(u"TCP connection from: %s",
430
368
unicode(self.client_address))
431
session = gnutls.connection.ClientSession\
432
(self.request, gnutls.connection.X509Credentials())
433
434
line = self.request.makefile().readline()
435
logger.debug(u"Protocol version: %r", line)
436
try:
437
if int(line.strip().split()[0]) > 1:
438
raise RuntimeError
439
except (ValueError, IndexError, RuntimeError), error:
440
logger.error(u"Unknown protocol version: %s", error)
441
return
442
443
# Note: gnutls.connection.X509Credentials is really a generic
444
# GnuTLS certificate credentials object so long as no X.509
445
# keys are added to it. Therefore, we can use it here despite
446
# using OpenPGP certificates.
369
session = gnutls.connection.ClientSession(self.request,
370
gnutls.connection.\
371
X509Credentials())
447
372
448
373
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
449
374
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
450
375
# "+DHE-DSS"))
451
priority = "NORMAL" # Fallback default, since this
452
# MUST be set.
453
if self.server.settings["priority"]:
454
priority = self.server.settings["priority"]
376
priority = "NORMAL"
377
if self.server.options.priority:
378
priority = self.server.options.priority
455
379
gnutls.library.functions.gnutls_priority_set_direct\
456
380
(session._c_object, priority, None);
457
381
458
382
try:
459
383
session.handshake()
460
384
except gnutls.errors.GNUTLSError, error:
461
logger.warning(u"Handshake failed: %s", error)
385
logger.debug(u"Handshake failed: %s", error)
462
386
# Do not run session.bye() here: the session is not
463
387
# established. Just abandon the request.
464
388
return
465
389
try:
466
390
fpr = fingerprint(peer_certificate(session))
467
391
except (TypeError, gnutls.errors.GNUTLSError), error:
468
logger.warning(u"Bad certificate: %s", error)
392
logger.debug(u"Bad certificate: %s", error)
469
393
session.bye()
470
394
return
471
395
logger.debug(u"Fingerprint: %s", fpr)
474
398
if c.fingerprint == fpr:
475
399
client = c
476
400
break
477
if not client:
478
logger.warning(u"Client not found for fingerprint: %s",
479
fpr)
480
session.bye()
481
return
482
401
# Have to check if client.still_valid(), since it is possible
483
402
# that the client timed out while establishing the GnuTLS
484
403
# session.
485
if not client.still_valid():
486
logger.warning(u"Client %(name)s is invalid",
487
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)
488
411
session.bye()
489
412
return
490
413
sent_size = 0
500
423
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
501
424
"""IPv6 TCP server. Accepts 'None' as address and/or port.
502
425
Attributes:
503
settings: Server settings
426
options: Command line options
504
427
clients: Set() of Client objects
505
428
"""
506
429
address_family = socket.AF_INET6
507
430
def __init__(self, *args, **kwargs):
508
if "settings" in kwargs:
509
self.settings = kwargs["settings"]
510
del kwargs["settings"]
431
if "options" in kwargs:
432
self.options = kwargs["options"]
433
del kwargs["options"]
511
434
if "clients" in kwargs:
512
435
self.clients = kwargs["clients"]
513
436
del kwargs["clients"]
516
439
"""This overrides the normal server_bind() function
517
440
to bind to an interface if one was specified, and also NOT to
518
441
bind to an address or port if they were not specified."""
519
if self.settings["interface"]:
520
# 25 is from /usr/include/asm-i486/socket.h
521
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
522
446
try:
523
447
self.socket.setsockopt(socket.SOL_SOCKET,
524
SO_BINDTODEVICE,
525
self.settings["interface"])
448
socket.SO_BINDTODEVICE,
449
self.options.interface)
526
450
except socket.error, error:
527
451
if error[0] == errno.EPERM:
528
logger.error(u"No permission to"
529
u" bind to interface %s",
530
self.settings["interface"])
452
logger.warning(u"No permission to"
453
u" bind to interface %s",
454
self.options.interface)
531
455
else:
532
456
raise error
533
457
# Only bind(2) the socket if we really need to.
536
460
in6addr_any = "::"
537
461
self.server_address = (in6addr_any,
538
462
self.server_address[1])
539
elif not self.server_address[1]:
463
elif self.server_address[1] is None:
540
464
self.server_address = (self.server_address[0],
541
465
0)
542
# if self.settings["interface"]:
543
# self.server_address = (self.server_address[0],
544
# 0, # port
545
# 0, # flowinfo
546
# if_nametoindex
547
# (self.settings
548
# ["interface"]))
549
466
return super(type(self), self).server_bind()
550
467
551
468
583
500
return delta
584
501
585
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()
534
535
586
536
def server_state_changed(state):
587
537
"""Derived from the Avahi example code"""
588
538
if state == avahi.SERVER_COLLISION:
589
logger.error(u"Server name collision")
590
service.remove()
539
logger.warning(u"Server name collision")
540
remove_service()
591
541
elif state == avahi.SERVER_RUNNING:
592
service.add()
542
add_service()
593
543
594
544
595
545
def entry_group_state_changed(state, error):
596
546
"""Derived from the Avahi example code"""
547
global serviceName, server, rename_count
548
597
549
logger.debug(u"state change: %i", state)
598
550
599
551
if state == avahi.ENTRY_GROUP_ESTABLISHED:
600
552
logger.debug(u"Service established.")
601
553
elif state == avahi.ENTRY_GROUP_COLLISION:
602
logger.warning(u"Service name collision.")
603
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)
604
567
elif state == avahi.ENTRY_GROUP_FAILURE:
605
logger.critical(u"Error in group state changed %s",
606
unicode(error))
607
raise AvahiGroupError("State changed: %s", str(error))
568
logger.error(u"Error in group state changed %s",
569
unicode(error))
570
killme(1)
571
608
572
609
573
def if_nametoindex(interface):
610
"""Call the C function if_nametoindex(), or equivalent"""
611
global if_nametoindex
574
"""Call the C function if_nametoindex()"""
612
575
try:
613
if "ctypes.util" not in sys.modules:
614
import ctypes.util
615
if_nametoindex = ctypes.cdll.LoadLibrary\
616
(ctypes.util.find_library("c")).if_nametoindex
576
libc = ctypes.cdll.LoadLibrary("libc.so.6")
577
return libc.if_nametoindex(interface)
617
578
except (OSError, AttributeError):
618
579
if "struct" not in sys.modules:
619
580
import struct
620
581
if "fcntl" not in sys.modules:
621
582
import fcntl
622
def if_nametoindex(interface):
623
"Get an interface index the hard way, i.e. using fcntl()"
624
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
625
s = socket.socket()
626
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
627
struct.pack("16s16x", interface))
628
s.close()
629
interface_index = struct.unpack("I", ifreq[16:20])[0]
630
return interface_index
631
return if_nametoindex(interface)
632
633
634
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):
635
593
"""See daemon(3). Standard BSD Unix function.
636
594
This should really exist as os.daemon, but it doesn't (yet)."""
637
595
if os.fork():
639
597
os.setsid()
640
598
if not nochdir:
641
599
os.chdir("/")
642
if os.fork():
643
sys.exit()
644
600
if not noclose:
645
601
# Close all standard open file descriptors
646
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
602
null = os.open("/dev/null", os.O_NOCTTY | os.O_RDWR)
647
603
if not stat.S_ISCHR(os.fstat(null).st_mode):
648
604
raise OSError(errno.ENODEV,
649
605
"/dev/null not a character device")
654
610
os.close(null)
655
611
656
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
657
622
def main():
623
global exitstatus
624
exitstatus = 0
658
625
global main_loop_started
659
626
main_loop_started = False
660
627
661
parser = OptionParser(version = "%%prog %s" % version)
628
parser = OptionParser()
662
629
parser.add_option("-i", "--interface", type="string",
663
metavar="IF", help="Bind to interface IF")
664
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,
665
633
help="Address to listen for requests on")
666
parser.add_option("-p", "--port", type="int",
634
parser.add_option("-p", "--port", type="int", default=None,
667
635
help="Port number to receive requests on")
668
636
parser.add_option("--check", action="store_true", default=False,
669
637
help="Run self-test")
670
parser.add_option("--debug", action="store_true",
671
help="Debug mode; run in foreground and log to"
672
" terminal")
673
parser.add_option("--priority", type="string", help="GnuTLS"
674
" priority string (see GnuTLS documentation)")
675
parser.add_option("--servicename", type="string", metavar="NAME",
676
help="Zeroconf service name")
677
parser.add_option("--configdir", type="string",
678
default="/etc/mandos", metavar="DIR",
679
help="Directory to search for configuration"
680
" 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")
681
646
(options, args) = parser.parse_args()
682
647
683
648
if options.check:
685
650
doctest.testmod()
686
651
sys.exit()
687
652
688
# Default values for config file for server-global settings
689
server_defaults = { "interface": "",
690
"address": "",
691
"port": "",
692
"debug": "False",
693
"priority":
694
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
695
"servicename": "Mandos",
696
}
697
698
# Parse config file for server-global settings
699
server_config = ConfigParser.SafeConfigParser(server_defaults)
700
del server_defaults
701
server_config.read(os.path.join(options.configdir, "mandos.conf"))
702
server_section = "server"
703
# Convert the SafeConfigParser object to a dict
704
server_settings = dict(server_config.items(server_section))
705
# Use getboolean on the boolean config option
706
server_settings["debug"] = server_config.getboolean\
707
(server_section, "debug")
708
del server_config
709
710
# Override the settings from the config file with command line
711
# options, if set.
712
for option in ("interface", "address", "port", "debug",
713
"priority", "servicename", "configdir"):
714
value = getattr(options, option)
715
if value is not None:
716
server_settings[option] = value
717
del options
718
# Now we have our good server settings in "server_settings"
719
720
debug = server_settings["debug"]
721
722
if not debug:
723
syslogger.setLevel(logging.WARNING)
724
console.setLevel(logging.WARNING)
725
726
if server_settings["servicename"] != "Mandos":
727
syslogger.setFormatter(logging.Formatter\
728
('Mandos (%s): %%(levelname)s:'
729
' %%(message)s'
730
% server_settings["servicename"]))
731
732
# Parse config file with clients
733
client_defaults = { "timeout": "1h",
734
"interval": "5m",
735
"checker": "fping -q -- %%(host)s",
736
}
737
client_config = ConfigParser.SafeConfigParser(client_defaults)
738
client_config.read(os.path.join(server_settings["configdir"],
739
"clients.conf"))
740
741
global service
742
service = AvahiService(name = server_settings["servicename"],
743
type = "_mandos._tcp", );
744
if server_settings["interface"]:
745
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;
746
664
747
665
global main_loop
748
666
global bus
756
674
avahi.DBUS_INTERFACE_SERVER )
757
675
# End of Avahi example code
758
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
759
687
clients = Set()
760
688
def remove_from_clients(client):
761
689
clients.remove(client)
762
690
if not clients:
763
logger.critical(u"No clients left, exiting")
764
sys.exit()
691
logger.debug(u"No clients left, exiting")
692
killme()
765
693
766
clients.update(Set(Client(name = section,
694
clients.update(Set(Client(name=section,
767
695
stop_hook = remove_from_clients,
768
config
769
= dict(client_config.items(section)))
696
**(dict(client_config\
697
.items(section))))
770
698
for section in client_config.sections()))
771
if not clients:
772
logger.critical(u"No clients defined")
773
sys.exit(1)
774
699
775
700
if not debug:
776
logger.removeHandler(console)
777
daemon()
778
779
pidfilename = "/var/run/mandos/mandos.pid"
780
pid = os.getpid()
781
try:
782
pidfile = open(pidfilename, "w")
783
pidfile.write(str(pid) + "\n")
784
pidfile.close()
785
del pidfile
786
except IOError, err:
787
logger.error(u"Could not write %s file with PID %d",
788
pidfilename, os.getpid())
701
daemon(False, False)
789
702
790
703
def cleanup():
791
704
"Cleanup function; run on exit"
805
718
806
719
if not debug:
807
720
signal.signal(signal.SIGINT, signal.SIG_IGN)
808
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
809
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())
810
723
811
724
for client in clients:
812
725
client.start()
813
726
814
tcp_server = IPv6_TCPServer((server_settings["address"],
815
server_settings["port"]),
727
tcp_server = IPv6_TCPServer((options.address, options.port),
816
728
tcp_handler,
817
settings=server_settings,
729
options=options,
818
730
clients=clients)
819
# Find out what port we got
820
service.port = tcp_server.socket.getsockname()[1]
821
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
822
u" scope_id %d" % tcp_server.socket.getsockname())
823
824
#service.interface = tcp_server.socket.getsockname()[3]
825
826
try:
827
# From the Avahi example code
828
server.connect_to_signal("StateChanged", server_state_changed)
829
try:
830
server_state_changed(server.GetState())
831
except dbus.exceptions.DBusException, error:
832
logger.critical(u"DBusException: %s", error)
833
sys.exit(1)
834
# End of Avahi example code
835
836
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
837
lambda *args, **kwargs:
838
tcp_server.handle_request\
839
(*args[2:], **kwargs) or True)
840
841
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")
842
755
main_loop_started = True
843
756
main_loop.run()
844
except AvahiError, error:
845
logger.critical(u"AvahiError: %s" + unicode(error))
846
sys.exit(1)
847
757
except KeyboardInterrupt:
848
758
if debug:
849
759
print
760
761
sys.exit(exitstatus)
850
762
851
763
if __name__ == '__main__':
852
764
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0