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 9
- compare with another revision
- download diff
- download tarball
- view history from revision 9
- Committer: Teddy Hogeborn
- Date: 2008-01-30 17:28:18 UTC
- Revision ID: teddy@fukt.bsnet.se-20080130172818-fnrq2xmtg1wa8wo2
* client.cpp (main): Get t_old early since it is used on error exits.
* server.py (Client.checker): New attribute.
(Client.check_action, Client.start_checker, Client.stop_checker,
Client.fileno, Client.next_stop, Client.still_valid,
Client.it_is_time_to_check): New methods.
(Client.handle_request): Alias to "check_action".
(main): Stop all started checkers on exit. Exit cleanly on keyboard
interrupt.
* server.py (Client.checker): New attribute.
(Client.check_action, Client.start_checker, Client.stop_checker,
Client.fileno, Client.next_stop, Client.still_valid,
Client.it_is_time_to_check): New methods.
(Client.handle_request): Alias to "check_action".
(main): Stop all started checkers on exit. Exit cleanly on keyboard
interrupt.
- files added:
- ca.pem
- files removed:
- .bzr-builddeb
- debian
- debian/po
- plugins.d
- files renamed:
- clients.conf => mandos-clients.conf
- mandos => server.py
- files modified:
- Makefile
added
removed
server.py
1
1
#!/usr/bin/python
2
# -*- mode: python; coding: utf-8 -*-
3
#
4
# Mandos server - give out binary blobs to connecting clients.
5
#
6
# This program is partly derived from an example program for an Avahi
7
# service publisher, downloaded from
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".
12
#
13
# Everything else is
14
# Copyright © 2008 Teddy Hogeborn
15
# Copyright © 2008 Björn Påhlsson
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
19
# the Free Software Foundation, either version 3 of the License, or
20
# (at your option) any later version.
21
#
22
# This program is distributed in the hope that it will be useful,
23
# but WITHOUT ANY WARRANTY; without even the implied warranty of
24
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25
# GNU General Public License for more details.
26
#
27
# You should have received a copy of the GNU General Public License
28
# along with this program. If not, see
29
# <http://www.gnu.org/licenses/>.
30
#
31
# Contact the authors at <mandos@fukt.bsnet.se>.
32
#
33
34
from __future__ import division, with_statement, absolute_import
35
2
36
3
import SocketServer
37
4
import socket
5
import select
38
6
from optparse import OptionParser
39
7
import datetime
40
8
import errno
41
9
import gnutls.crypto
42
10
import gnutls.connection
43
11
import gnutls.errors
44
import gnutls.library.functions
45
import gnutls.library.constants
46
import gnutls.library.types
47
12
import ConfigParser
48
13
import sys
49
14
import re
50
15
import os
51
16
import signal
52
from sets import Set
53
import subprocess
54
import atexit
55
import stat
56
import logging
57
import logging.handlers
58
import pwd
59
from contextlib import closing
60
61
import dbus
62
import dbus.service
63
import gobject
64
import avahi
65
from dbus.mainloop.glib import DBusGMainLoop
66
import ctypes
67
import ctypes.util
68
69
version = "1.0.2"
70
71
logger = logging.Logger('mandos')
72
syslogger = (logging.handlers.SysLogHandler
73
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
74
address = "/dev/log"))
75
syslogger.setFormatter(logging.Formatter
76
('Mandos: %(levelname)s: %(message)s'))
77
logger.addHandler(syslogger)
78
79
console = logging.StreamHandler()
80
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
81
' %(message)s'))
82
logger.addHandler(console)
83
84
class AvahiError(Exception):
85
def __init__(self, value):
86
self.value = value
87
super(AvahiError, self).__init__()
88
def __str__(self):
89
return repr(self.value)
90
91
class AvahiServiceError(AvahiError):
92
pass
93
94
class AvahiGroupError(AvahiError):
95
pass
96
97
98
class AvahiService(object):
99
"""An Avahi (Zeroconf) service.
100
Attributes:
101
interface: integer; avahi.IF_UNSPEC or an interface index.
102
Used to optionally bind to the specified interface.
103
name: string; Example: 'Mandos'
104
type: string; Example: '_mandos._tcp'.
105
See <http://www.dns-sd.org/ServiceTypes.html>
106
port: integer; what port to announce
107
TXT: list of strings; TXT record for the service
108
domain: string; Domain to publish on, default to .local if empty.
109
host: string; Host to publish records for, default is localhost
110
max_renames: integer; maximum number of renames
111
rename_count: integer; counter so we only rename after collisions
112
a sensible number of times
113
"""
114
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
115
servicetype = None, port = None, TXT = None,
116
domain = "", host = "", max_renames = 32768):
117
self.interface = interface
118
self.name = name
119
self.type = servicetype
120
self.port = port
121
self.TXT = TXT if TXT is not None else []
122
self.domain = domain
123
self.host = host
124
self.rename_count = 0
125
self.max_renames = max_renames
126
def rename(self):
127
"""Derived from the Avahi example code"""
128
if self.rename_count >= self.max_renames:
129
logger.critical(u"No suitable Zeroconf service name found"
130
u" after %i retries, exiting.",
131
self.rename_count)
132
raise AvahiServiceError("Too many renames")
133
self.name = server.GetAlternativeServiceName(self.name)
134
logger.info(u"Changing Zeroconf service name to %r ...",
135
str(self.name))
136
syslogger.setFormatter(logging.Formatter
137
('Mandos (%s): %%(levelname)s:'
138
' %%(message)s' % self.name))
139
self.remove()
140
self.add()
141
self.rename_count += 1
142
def remove(self):
143
"""Derived from the Avahi example code"""
144
if group is not None:
145
group.Reset()
146
def add(self):
147
"""Derived from the Avahi example code"""
148
global group
149
if group is None:
150
group = dbus.Interface(bus.get_object
151
(avahi.DBUS_NAME,
152
server.EntryGroupNew()),
153
avahi.DBUS_INTERFACE_ENTRY_GROUP)
154
group.connect_to_signal('StateChanged',
155
entry_group_state_changed)
156
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
157
service.name, service.type)
158
group.AddService(
159
self.interface, # interface
160
avahi.PROTO_INET6, # protocol
161
dbus.UInt32(0), # flags
162
self.name, self.type,
163
self.domain, self.host,
164
dbus.UInt16(self.port),
165
avahi.string_array_to_txt_array(self.TXT))
166
group.Commit()
167
168
# From the Avahi example code:
169
group = None # our entry group
170
# End of Avahi example code
171
172
173
def _datetime_to_dbus(dt, variant_level=0):
174
"""Convert a UTC datetime.datetime() to a D-Bus type."""
175
return dbus.String(dt.isoformat(), variant_level=variant_level)
176
177
178
class Client(dbus.service.Object):
179
"""A representation of a client host served by this server.
180
Attributes:
181
name: string; from the config file, used in log messages
182
fingerprint: string (40 or 32 hexadecimal digits); used to
183
uniquely identify the client
184
secret: bytestring; sent verbatim (over TLS) to client
185
host: string; available for use by the checker command
186
created: datetime.datetime(); (UTC) object creation
187
last_enabled: datetime.datetime(); (UTC)
188
enabled: bool()
189
last_checked_ok: datetime.datetime(); (UTC) or None
190
timeout: datetime.timedelta(); How long from last_checked_ok
191
until this client is invalid
192
interval: datetime.timedelta(); How often to start a new checker
193
disable_hook: If set, called by disable() as disable_hook(self)
194
checker: subprocess.Popen(); a running checker process used
195
to see if the client lives.
196
'None' if no process is running.
197
checker_initiator_tag: a gobject event source tag, or None
198
disable_initiator_tag: - '' -
199
checker_callback_tag: - '' -
200
checker_command: string; External command which is run to check if
201
client lives. %() expansions are done at
202
runtime with vars(self) as dict, so that for
203
instance %(name)s can be used in the command.
204
dbus_object_path: dbus.ObjectPath
205
Private attibutes:
206
_timeout: Real variable for 'timeout'
207
_interval: Real variable for 'interval'
208
_timeout_milliseconds: Used when calling gobject.timeout_add()
209
_interval_milliseconds: - '' -
210
"""
211
def _set_timeout(self, timeout):
212
"Setter function for the 'timeout' attribute"
213
self._timeout = timeout
214
self._timeout_milliseconds = ((self.timeout.days
215
* 24 * 60 * 60 * 1000)
216
+ (self.timeout.seconds * 1000)
217
+ (self.timeout.microseconds
218
// 1000))
219
# Emit D-Bus signal
220
self.PropertyChanged(dbus.String(u"timeout"),
221
(dbus.UInt64(self._timeout_milliseconds,
222
variant_level=1)))
223
timeout = property(lambda self: self._timeout, _set_timeout)
224
del _set_timeout
225
226
def _set_interval(self, interval):
227
"Setter function for the 'interval' attribute"
228
self._interval = interval
229
self._interval_milliseconds = ((self.interval.days
230
* 24 * 60 * 60 * 1000)
231
+ (self.interval.seconds
232
* 1000)
233
+ (self.interval.microseconds
234
// 1000))
235
# Emit D-Bus signal
236
self.PropertyChanged(dbus.String(u"interval"),
237
(dbus.UInt64(self._interval_milliseconds,
238
variant_level=1)))
239
interval = property(lambda self: self._interval, _set_interval)
240
del _set_interval
241
242
def __init__(self, name = None, disable_hook=None, config=None):
243
"""Note: the 'checker' key in 'config' sets the
244
'checker_command' attribute and *not* the 'checker'
245
attribute."""
246
self.dbus_object_path = (dbus.ObjectPath
247
("/Mandos/clients/"
248
+ name.replace(".", "_")))
249
dbus.service.Object.__init__(self, bus,
250
self.dbus_object_path)
251
if config is None:
252
config = {}
253
self.name = name
254
logger.debug(u"Creating client %r", self.name)
255
# Uppercase and remove spaces from fingerprint for later
256
# comparison purposes with return value from the fingerprint()
257
# function
258
self.fingerprint = (config["fingerprint"].upper()
259
.replace(u" ", u""))
260
logger.debug(u" Fingerprint: %s", self.fingerprint)
261
if "secret" in config:
262
self.secret = config["secret"].decode(u"base64")
263
elif "secfile" in config:
264
with closing(open(os.path.expanduser
265
(os.path.expandvars
266
(config["secfile"])))) as secfile:
267
self.secret = secfile.read()
17
18
class Client(object):
19
def __init__(self, name=None, options=None, dn=None,
20
password=None, passfile=None, fqdn=None,
21
timeout=None, interval=-1):
22
self.name = name
23
self.dn = dn
24
if password:
25
self.password = password
26
elif passfile:
27
self.password = open(passfile).readall()
268
28
else:
269
raise TypeError(u"No secret or secfile for client %s"
270
% self.name)
271
self.host = config.get("host", "")
272
self.created = datetime.datetime.utcnow()
273
self.enabled = False
274
self.last_enabled = None
275
self.last_checked_ok = None
276
self.timeout = string_to_delta(config["timeout"])
277
self.interval = string_to_delta(config["interval"])
278
self.disable_hook = disable_hook
279
self.checker = None
280
self.checker_initiator_tag = None
281
self.disable_initiator_tag = None
282
self.checker_callback_tag = None
283
self.checker_command = config["checker"]
284
285
def enable(self):
286
"""Start this client's checker and timeout hooks"""
287
self.last_enabled = datetime.datetime.utcnow()
288
# Schedule a new checker to be started an 'interval' from now,
289
# and every interval from then on.
290
self.checker_initiator_tag = (gobject.timeout_add
291
(self._interval_milliseconds,
292
self.start_checker))
293
# Also start a new checker *right now*.
294
self.start_checker()
295
# Schedule a disable() when 'timeout' has passed
296
self.disable_initiator_tag = (gobject.timeout_add
297
(self._timeout_milliseconds,
298
self.disable))
299
self.enabled = True
300
# Emit D-Bus signal
301
self.PropertyChanged(dbus.String(u"enabled"),
302
dbus.Boolean(True, variant_level=1))
303
self.PropertyChanged(dbus.String(u"last_enabled"),
304
(_datetime_to_dbus(self.last_enabled,
305
variant_level=1)))
306
307
def disable(self):
308
"""Disable this client."""
309
if not getattr(self, "enabled", False):
310
return False
311
logger.info(u"Disabling client %s", self.name)
312
if getattr(self, "disable_initiator_tag", False):
313
gobject.source_remove(self.disable_initiator_tag)
314
self.disable_initiator_tag = None
315
if getattr(self, "checker_initiator_tag", False):
316
gobject.source_remove(self.checker_initiator_tag)
317
self.checker_initiator_tag = None
29
print "No Password or Passfile in client config file"
30
# raise RuntimeError XXX
31
self.password = "gazonk"
32
self.fqdn = fqdn # string
33
self.created = datetime.datetime.now()
34
self.last_seen = None # datetime.datetime()
35
if timeout is None:
36
timeout = options.timeout
37
self.timeout = timeout # datetime.timedelta()
38
if interval == -1:
39
interval = options.interval
40
self.interval = interval # datetime.timedelta()
41
self.next_check = datetime.datetime.now() # datetime.datetime()
42
self.checker = None # or a subprocess.Popen()
43
def check_action(self, now=None):
44
"""The checker said something and might have completed.
45
Check if is has, and take appropriate actions."""
46
if self.checker.poll() is None:
47
# False alarm, no result yet
48
#self.checker.read()
49
return
50
if now is None:
51
now = datetime.datetime.now()
52
if self.checker.returncode == 0:
53
self.last_seen = now
54
while self.next_check <= now:
55
self.next_check += self.interval
56
handle_request = check_action
57
def start_checker(self):
318
58
self.stop_checker()
319
if self.disable_hook:
320
self.disable_hook(self)
321
self.enabled = False
322
# Emit D-Bus signal
323
self.PropertyChanged(dbus.String(u"enabled"),
324
dbus.Boolean(False, variant_level=1))
325
# Do not run this again if called by a gobject.timeout_add
326
return False
327
328
def __del__(self):
329
self.disable_hook = None
330
self.disable()
331
332
def checker_callback(self, pid, condition, command):
333
"""The checker has completed, so take appropriate actions."""
334
self.checker_callback_tag = None
59
try:
60
self.checker = subprocess.Popen("sleep 1; fping -q -- %s"
61
% re.escape(self.fqdn),
62
stdout=subprocess.PIPE,
63
close_fds=True,
64
shell=True, cwd="/")
65
except subprocess.OSError, e:
66
print "Failed to start subprocess:", e
67
def stop_checker(self):
68
if self.checker is None:
69
return
70
os.kill(self.checker.pid, signal.SIGTERM)
71
if self.checker.poll() is None:
72
os.kill(self.checker.pid, signal.SIGKILL)
335
73
self.checker = None
336
# Emit D-Bus signal
337
self.PropertyChanged(dbus.String(u"checker_running"),
338
dbus.Boolean(False, variant_level=1))
339
if (os.WIFEXITED(condition)
340
and (os.WEXITSTATUS(condition) == 0)):
341
logger.info(u"Checker for %(name)s succeeded",
342
vars(self))
343
# Emit D-Bus signal
344
self.CheckerCompleted(dbus.Boolean(True),
345
dbus.UInt16(condition),
346
dbus.String(command))
347
self.bump_timeout()
348
elif not os.WIFEXITED(condition):
349
logger.warning(u"Checker for %(name)s crashed?",
350
vars(self))
351
# Emit D-Bus signal
352
self.CheckerCompleted(dbus.Boolean(False),
353
dbus.UInt16(condition),
354
dbus.String(command))
355
else:
356
logger.info(u"Checker for %(name)s failed",
357
vars(self))
358
# Emit D-Bus signal
359
self.CheckerCompleted(dbus.Boolean(False),
360
dbus.UInt16(condition),
361
dbus.String(command))
362
363
def bump_timeout(self):
364
"""Bump up the timeout for this client.
365
This should only be called when the client has been seen,
366
alive and well.
367
"""
368
self.last_checked_ok = datetime.datetime.utcnow()
369
gobject.source_remove(self.disable_initiator_tag)
370
self.disable_initiator_tag = (gobject.timeout_add
371
(self._timeout_milliseconds,
372
self.disable))
373
self.PropertyChanged(dbus.String(u"last_checked_ok"),
374
(_datetime_to_dbus(self.last_checked_ok,
375
variant_level=1)))
376
377
def start_checker(self):
378
"""Start a new checker subprocess if one is not running.
379
If a checker already exists, leave it running and do
380
nothing."""
381
# The reason for not killing a running checker is that if we
382
# did that, then if a checker (for some reason) started
383
# running slowly and taking more than 'interval' time, the
384
# client would inevitably timeout, since no checker would get
385
# a chance to run to completion. If we instead leave running
386
# checkers alone, the checker would have to take more time
387
# than 'timeout' for the client to be declared invalid, which
388
# is as it should be.
74
__del__ = stop_checker
75
def fileno(self):
389
76
if self.checker is None:
390
try:
391
# In case checker_command has exactly one % operator
392
command = self.checker_command % self.host
393
except TypeError:
394
# Escape attributes for the shell
395
escaped_attrs = dict((key, re.escape(str(val)))
396
for key, val in
397
vars(self).iteritems())
77
return None
78
return self.checker.stdout.fileno()
79
def next_stop(self):
80
"""The time when something must be done about this client"""
81
return min(self.last_seen + self.timeout, self.next_check)
82
def still_valid(self, now=None):
83
"""Has this client's timeout not passed?"""
84
if now is None:
85
now = datetime.datetime.now()
86
return now < (self.last_seen + timeout)
87
def it_is_time_to_check(self, now=None):
88
if now is None:
89
now = datetime.datetime.now()
90
return self.next_check <= now
91
92
93
class server_metaclass(type):
94
"Common behavior for the UDP and TCP server classes"
95
def __new__(cls, name, bases, attrs):
96
attrs["address_family"] = socket.AF_INET6
97
attrs["allow_reuse_address"] = True
98
def server_bind(self):
99
if self.options.interface:
100
if not hasattr(socket, "SO_BINDTODEVICE"):
101
# From /usr/include/asm-i486/socket.h
102
socket.SO_BINDTODEVICE = 25
398
103
try:
399
command = self.checker_command % escaped_attrs
400
except TypeError, error:
401
logger.error(u'Could not format string "%s":'
402
u' %s', self.checker_command, error)
403
return True # Try again later
404
try:
405
logger.info(u"Starting checker %r for %s",
406
command, self.name)
407
# We don't need to redirect stdout and stderr, since
408
# in normal mode, that is already done by daemon(),
409
# and in debug mode we don't want to. (Stdin is
410
# always replaced by /dev/null.)
411
self.checker = subprocess.Popen(command,
412
close_fds=True,
413
shell=True, cwd="/")
414
# Emit D-Bus signal
415
self.CheckerStarted(command)
416
self.PropertyChanged(dbus.String("checker_running"),
417
dbus.Boolean(True, variant_level=1))
418
self.checker_callback_tag = (gobject.child_watch_add
419
(self.checker.pid,
420
self.checker_callback,
421
data=command))
422
except OSError, error:
423
logger.error(u"Failed to start subprocess: %s",
424
error)
425
# Re-run this periodically if run by gobject.timeout_add
426
return True
427
428
def stop_checker(self):
429
"""Force the checker process, if any, to stop."""
430
if self.checker_callback_tag:
431
gobject.source_remove(self.checker_callback_tag)
432
self.checker_callback_tag = None
433
if getattr(self, "checker", None) is None:
434
return
435
logger.debug(u"Stopping checker for %(name)s", vars(self))
436
try:
437
os.kill(self.checker.pid, signal.SIGTERM)
438
#os.sleep(0.5)
439
#if self.checker.poll() is None:
440
# os.kill(self.checker.pid, signal.SIGKILL)
441
except OSError, error:
442
if error.errno != errno.ESRCH: # No such process
443
raise
444
self.checker = None
445
self.PropertyChanged(dbus.String(u"checker_running"),
446
dbus.Boolean(False, variant_level=1))
447
448
def still_valid(self):
449
"""Has the timeout not yet passed for this client?"""
450
if not getattr(self, "enabled", False):
451
return False
452
now = datetime.datetime.utcnow()
453
if self.last_checked_ok is None:
454
return now < (self.created + self.timeout)
455
else:
456
return now < (self.last_checked_ok + self.timeout)
457
458
## D-Bus methods & signals
459
_interface = u"org.mandos_system.Mandos.Client"
460
461
# BumpTimeout - method
462
BumpTimeout = dbus.service.method(_interface)(bump_timeout)
463
BumpTimeout.__name__ = "BumpTimeout"
464
465
# CheckerCompleted - signal
466
@dbus.service.signal(_interface, signature="bqs")
467
def CheckerCompleted(self, success, condition, command):
468
"D-Bus signal"
469
pass
470
471
# CheckerStarted - signal
472
@dbus.service.signal(_interface, signature="s")
473
def CheckerStarted(self, command):
474
"D-Bus signal"
475
pass
476
477
# GetAllProperties - method
478
@dbus.service.method(_interface, out_signature="a{sv}")
479
def GetAllProperties(self):
480
"D-Bus method"
481
return dbus.Dictionary({
482
dbus.String("name"):
483
dbus.String(self.name, variant_level=1),
484
dbus.String("fingerprint"):
485
dbus.String(self.fingerprint, variant_level=1),
486
dbus.String("host"):
487
dbus.String(self.host, variant_level=1),
488
dbus.String("created"):
489
_datetime_to_dbus(self.created, variant_level=1),
490
dbus.String("last_enabled"):
491
(_datetime_to_dbus(self.last_enabled,
492
variant_level=1)
493
if self.last_enabled is not None
494
else dbus.Boolean(False, variant_level=1)),
495
dbus.String("enabled"):
496
dbus.Boolean(self.enabled, variant_level=1),
497
dbus.String("last_checked_ok"):
498
(_datetime_to_dbus(self.last_checked_ok,
499
variant_level=1)
500
if self.last_checked_ok is not None
501
else dbus.Boolean (False, variant_level=1)),
502
dbus.String("timeout"):
503
dbus.UInt64(self._timeout_milliseconds,
504
variant_level=1),
505
dbus.String("interval"):
506
dbus.UInt64(self._interval_milliseconds,
507
variant_level=1),
508
dbus.String("checker"):
509
dbus.String(self.checker_command,
510
variant_level=1),
511
dbus.String("checker_running"):
512
dbus.Boolean(self.checker is not None,
513
variant_level=1),
514
}, signature="sv")
515
516
# IsStillValid - method
517
IsStillValid = (dbus.service.method(_interface, out_signature="b")
518
(still_valid))
519
IsStillValid.__name__ = "IsStillValid"
520
521
# PropertyChanged - signal
522
@dbus.service.signal(_interface, signature="sv")
523
def PropertyChanged(self, property, value):
524
"D-Bus signal"
525
pass
526
527
# SetChecker - method
528
@dbus.service.method(_interface, in_signature="s")
529
def SetChecker(self, checker):
530
"D-Bus setter method"
531
self.checker_command = checker
532
533
# SetHost - method
534
@dbus.service.method(_interface, in_signature="s")
535
def SetHost(self, host):
536
"D-Bus setter method"
537
self.host = host
538
539
# SetInterval - method
540
@dbus.service.method(_interface, in_signature="t")
541
def SetInterval(self, milliseconds):
542
self.interval = datetime.timdeelta(0, 0, 0, milliseconds)
543
544
# SetSecret - method
545
@dbus.service.method(_interface, in_signature="ay",
546
byte_arrays=True)
547
def SetSecret(self, secret):
548
"D-Bus setter method"
549
self.secret = str(secret)
550
551
# SetTimeout - method
552
@dbus.service.method(_interface, in_signature="t")
553
def SetTimeout(self, milliseconds):
554
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
555
556
# Enable - method
557
Enable = dbus.service.method(_interface)(enable)
558
Enable.__name__ = "Enable"
559
560
# StartChecker - method
561
@dbus.service.method(_interface)
562
def StartChecker(self):
563
"D-Bus method"
564
self.start_checker()
565
566
# Disable - method
567
@dbus.service.method(_interface)
568
def Disable(self):
569
"D-Bus method"
570
self.disable()
571
572
# StopChecker - method
573
StopChecker = dbus.service.method(_interface)(stop_checker)
574
StopChecker.__name__ = "StopChecker"
575
576
del _interface
577
578
579
def peer_certificate(session):
580
"Return the peer's OpenPGP certificate as a bytestring"
581
# If not an OpenPGP certificate...
582
if (gnutls.library.functions
583
.gnutls_certificate_type_get(session._c_object)
584
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
585
# ...do the normal thing
586
return session.peer_certificate
587
list_size = ctypes.c_uint()
588
cert_list = (gnutls.library.functions
589
.gnutls_certificate_get_peers
590
(session._c_object, ctypes.byref(list_size)))
591
if list_size.value == 0:
592
return None
593
cert = cert_list[0]
594
return ctypes.string_at(cert.data, cert.size)
595
596
597
def fingerprint(openpgp):
598
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
599
# New GnuTLS "datum" with the OpenPGP public key
600
datum = (gnutls.library.types
601
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
602
ctypes.POINTER
603
(ctypes.c_ubyte)),
604
ctypes.c_uint(len(openpgp))))
605
# New empty GnuTLS certificate
606
crt = gnutls.library.types.gnutls_openpgp_crt_t()
607
(gnutls.library.functions
608
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
609
# Import the OpenPGP public key into the certificate
610
(gnutls.library.functions
611
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
612
gnutls.library.constants
613
.GNUTLS_OPENPGP_FMT_RAW))
614
# Verify the self signature in the key
615
crtverify = ctypes.c_uint()
616
(gnutls.library.functions
617
.gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
618
if crtverify.value != 0:
619
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
620
raise gnutls.errors.CertificateSecurityError("Verify failed")
621
# New buffer for the fingerprint
622
buf = ctypes.create_string_buffer(20)
623
buf_len = ctypes.c_size_t()
624
# Get the fingerprint from the certificate into the buffer
625
(gnutls.library.functions
626
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
627
ctypes.byref(buf_len)))
628
# Deinit the certificate
629
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
630
# Convert the buffer to a Python bytestring
631
fpr = ctypes.string_at(buf, buf_len.value)
632
# Convert the bytestring to hexadecimal notation
633
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
634
return hex_fpr
635
636
637
class TCP_handler(SocketServer.BaseRequestHandler, object):
638
"""A TCP request handler class.
639
Instantiated by IPv6_TCPServer for each request to handle it.
640
Note: This will run in its own forked process."""
641
642
def handle(self):
643
logger.info(u"TCP connection from: %s",
644
unicode(self.client_address))
645
session = (gnutls.connection
646
.ClientSession(self.request,
647
gnutls.connection
648
.X509Credentials()))
649
650
line = self.request.makefile().readline()
651
logger.debug(u"Protocol version: %r", line)
652
try:
653
if int(line.strip().split()[0]) > 1:
654
raise RuntimeError
655
except (ValueError, IndexError, RuntimeError), error:
656
logger.error(u"Unknown protocol version: %s", error)
657
return
658
659
# Note: gnutls.connection.X509Credentials is really a generic
660
# GnuTLS certificate credentials object so long as no X.509
661
# keys are added to it. Therefore, we can use it here despite
662
# using OpenPGP certificates.
663
664
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
665
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
666
# "+DHE-DSS"))
667
# Use a fallback default, since this MUST be set.
668
priority = self.server.settings.get("priority", "NORMAL")
669
(gnutls.library.functions
670
.gnutls_priority_set_direct(session._c_object,
671
priority, None))
672
673
try:
674
session.handshake()
675
except gnutls.errors.GNUTLSError, error:
676
logger.warning(u"Handshake failed: %s", error)
677
# Do not run session.bye() here: the session is not
678
# established. Just abandon the request.
679
return
680
try:
681
fpr = fingerprint(peer_certificate(session))
682
except (TypeError, gnutls.errors.GNUTLSError), error:
683
logger.warning(u"Bad certificate: %s", error)
684
session.bye()
685
return
686
logger.debug(u"Fingerprint: %s", fpr)
687
for c in self.server.clients:
688
if c.fingerprint == fpr:
689
client = c
690
break
691
else:
692
logger.warning(u"Client not found for fingerprint: %s",
693
fpr)
694
session.bye()
695
return
696
# Have to check if client.still_valid(), since it is possible
697
# that the client timed out while establishing the GnuTLS
698
# session.
699
if not client.still_valid():
700
logger.warning(u"Client %(name)s is invalid",
701
vars(client))
702
session.bye()
703
return
704
## This won't work here, since we're in a fork.
705
# client.bump_timeout()
706
sent_size = 0
707
while sent_size < len(client.secret):
708
sent = session.send(client.secret[sent_size:])
709
logger.debug(u"Sent: %d, remaining: %d",
710
sent, len(client.secret)
711
- (sent_size + sent))
712
sent_size += sent
104
self.socket.setsockopt(socket.SOL_SOCKET,
105
socket.SO_BINDTODEVICE,
106
self.options.interface)
107
except socket.error, error:
108
if error[0] == errno.EPERM:
109
print "Warning: No permission to bind to interface", \
110
self.options.interface
111
else:
112
raise error
113
return super(type(self), self).server_bind()
114
attrs["server_bind"] = server_bind
115
def init(self, *args, **kwargs):
116
if "options" in kwargs:
117
self.options = kwargs["options"]
118
del kwargs["options"]
119
if "clients" in kwargs:
120
self.clients = kwargs["clients"]
121
del kwargs["clients"]
122
if "credentials" in kwargs:
123
self.credentials = kwargs["credentials"]
124
del kwargs["credentials"]
125
return super(type(self), self).__init__(*args, **kwargs)
126
attrs["__init__"] = init
127
return type.__new__(cls, name, bases, attrs)
128
129
130
class udp_handler(SocketServer.DatagramRequestHandler, object):
131
def handle(self):
132
self.wfile.write("Polo")
133
print "UDP request answered"
134
135
136
class IPv6_UDPServer(SocketServer.UDPServer, object):
137
__metaclass__ = server_metaclass
138
def verify_request(self, request, client_address):
139
print "UDP request came"
140
return request[0] == "Marco"
141
142
143
class tcp_handler(SocketServer.BaseRequestHandler, object):
144
def handle(self):
145
print "TCP request came"
146
print "Request:", self.request
147
print "Client Address:", self.client_address
148
print "Server:", self.server
149
session = gnutls.connection.ServerSession(self.request,
150
self.server.credentials)
151
session.handshake()
152
if session.peer_certificate:
153
print "DN:", session.peer_certificate.subject
154
try:
155
session.verify_peer()
156
except gnutls.errors.CertificateError, error:
157
print "Verify failed", error
158
session.bye()
159
return
160
try:
161
session.send(dict((client.dn, client.password)
162
for client in self.server.clients)
163
[session.peer_certificate.subject])
164
except KeyError:
165
session.send("gazonk")
166
# Log maybe? XXX
713
167
session.bye()
714
168
715
169
716
class IPv6_TCPServer(SocketServer.ForkingMixIn,
717
SocketServer.TCPServer, object):
718
"""IPv6 TCP server. Accepts 'None' as address and/or port.
719
Attributes:
720
settings: Server settings
721
clients: Set() of Client objects
722
enabled: Boolean; whether this server is activated yet
723
"""
724
address_family = socket.AF_INET6
725
def __init__(self, *args, **kwargs):
726
if "settings" in kwargs:
727
self.settings = kwargs["settings"]
728
del kwargs["settings"]
729
if "clients" in kwargs:
730
self.clients = kwargs["clients"]
731
del kwargs["clients"]
732
self.enabled = False
733
super(IPv6_TCPServer, self).__init__(*args, **kwargs)
734
def server_bind(self):
735
"""This overrides the normal server_bind() function
736
to bind to an interface if one was specified, and also NOT to
737
bind to an address or port if they were not specified."""
738
if self.settings["interface"]:
739
# 25 is from /usr/include/asm-i486/socket.h
740
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
741
try:
742
self.socket.setsockopt(socket.SOL_SOCKET,
743
SO_BINDTODEVICE,
744
self.settings["interface"])
745
except socket.error, error:
746
if error[0] == errno.EPERM:
747
logger.error(u"No permission to"
748
u" bind to interface %s",
749
self.settings["interface"])
750
else:
751
raise error
752
# Only bind(2) the socket if we really need to.
753
if self.server_address[0] or self.server_address[1]:
754
if not self.server_address[0]:
755
in6addr_any = "::"
756
self.server_address = (in6addr_any,
757
self.server_address[1])
758
elif not self.server_address[1]:
759
self.server_address = (self.server_address[0],
760
0)
761
# if self.settings["interface"]:
762
# self.server_address = (self.server_address[0],
763
# 0, # port
764
# 0, # flowinfo
765
# if_nametoindex
766
# (self.settings
767
# ["interface"]))
768
return super(IPv6_TCPServer, self).server_bind()
769
def server_activate(self):
770
if self.enabled:
771
return super(IPv6_TCPServer, self).server_activate()
772
def enable(self):
773
self.enabled = True
774
170
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
171
__metaclass__ = server_metaclass
172
request_queue_size = 1024
173
174
175
in6addr_any = "::"
775
176
776
177
def string_to_delta(interval):
777
178
"""Parse a string and return a datetime.timedelta
786
187
datetime.timedelta(1)
787
188
>>> string_to_delta(u'1w')
788
189
datetime.timedelta(7)
789
>>> string_to_delta('5m 30s')
790
datetime.timedelta(0, 330)
791
190
"""
792
timevalue = datetime.timedelta(0)
793
for s in interval.split():
794
try:
795
suffix = unicode(s[-1])
796
value = int(s[:-1])
797
if suffix == u"d":
798
delta = datetime.timedelta(value)
799
elif suffix == u"s":
800
delta = datetime.timedelta(0, value)
801
elif suffix == u"m":
802
delta = datetime.timedelta(0, 0, 0, 0, value)
803
elif suffix == u"h":
804
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
805
elif suffix == u"w":
806
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
807
else:
808
raise ValueError
809
except (ValueError, IndexError):
191
try:
192
suffix=unicode(interval[-1])
193
value=int(interval[:-1])
194
if suffix == u"d":
195
delta = datetime.timedelta(value)
196
elif suffix == u"s":
197
delta = datetime.timedelta(0, value)
198
elif suffix == u"m":
199
delta = datetime.timedelta(0, 0, 0, 0, value)
200
elif suffix == u"h":
201
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
202
elif suffix == u"w":
203
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
204
else:
810
205
raise ValueError
811
timevalue += delta
812
return timevalue
813
814
815
def server_state_changed(state):
816
"""Derived from the Avahi example code"""
817
if state == avahi.SERVER_COLLISION:
818
logger.error(u"Zeroconf server name collision")
819
service.remove()
820
elif state == avahi.SERVER_RUNNING:
821
service.add()
822
823
824
def entry_group_state_changed(state, error):
825
"""Derived from the Avahi example code"""
826
logger.debug(u"Avahi state change: %i", state)
827
828
if state == avahi.ENTRY_GROUP_ESTABLISHED:
829
logger.debug(u"Zeroconf service established.")
830
elif state == avahi.ENTRY_GROUP_COLLISION:
831
logger.warning(u"Zeroconf service name collision.")
832
service.rename()
833
elif state == avahi.ENTRY_GROUP_FAILURE:
834
logger.critical(u"Avahi: Error in group state changed %s",
835
unicode(error))
836
raise AvahiGroupError("State changed: %s", str(error))
837
838
def if_nametoindex(interface):
839
"""Call the C function if_nametoindex(), or equivalent"""
840
global if_nametoindex
841
try:
842
if_nametoindex = (ctypes.cdll.LoadLibrary
843
(ctypes.util.find_library("c"))
844
.if_nametoindex)
845
except (OSError, AttributeError):
846
if "struct" not in sys.modules:
847
import struct
848
if "fcntl" not in sys.modules:
849
import fcntl
850
def if_nametoindex(interface):
851
"Get an interface index the hard way, i.e. using fcntl()"
852
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
853
with closing(socket.socket()) as s:
854
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
855
struct.pack("16s16x", interface))
856
interface_index = struct.unpack("I", ifreq[16:20])[0]
857
return interface_index
858
return if_nametoindex(interface)
859
860
861
def daemon(nochdir = False, noclose = False):
862
"""See daemon(3). Standard BSD Unix function.
863
This should really exist as os.daemon, but it doesn't (yet)."""
864
if os.fork():
865
sys.exit()
866
os.setsid()
867
if not nochdir:
868
os.chdir("/")
869
if os.fork():
870
sys.exit()
871
if not noclose:
872
# Close all standard open file descriptors
873
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
874
if not stat.S_ISCHR(os.fstat(null).st_mode):
875
raise OSError(errno.ENODEV,
876
"/dev/null not a character device")
877
os.dup2(null, sys.stdin.fileno())
878
os.dup2(null, sys.stdout.fileno())
879
os.dup2(null, sys.stderr.fileno())
880
if null > 2:
881
os.close(null)
206
except (ValueError, IndexError):
207
raise ValueError
208
return delta
882
209
883
210
884
211
def main():
885
parser = OptionParser(version = "%%prog %s" % version)
212
parser = OptionParser()
886
213
parser.add_option("-i", "--interface", type="string",
887
metavar="IF", help="Bind to interface IF")
888
parser.add_option("-a", "--address", type="string",
889
help="Address to listen for requests on")
890
parser.add_option("-p", "--port", type="int",
214
default="eth0", metavar="IF",
215
help="Interface to bind to")
216
parser.add_option("--cert", type="string", default="cert.pem",
217
metavar="FILE",
218
help="Public key certificate to use")
219
parser.add_option("--key", type="string", default="key.pem",
220
metavar="FILE",
221
help="Private key to use")
222
parser.add_option("--ca", type="string", default="ca.pem",
223
metavar="FILE",
224
help="Certificate Authority certificate to use")
225
parser.add_option("--crl", type="string", default="crl.pem",
226
metavar="FILE",
227
help="Certificate Revokation List to use")
228
parser.add_option("-p", "--port", type="int", default=49001,
891
229
help="Port number to receive requests on")
230
parser.add_option("--dh", type="int", metavar="BITS",
231
help="DH group to use")
232
parser.add_option("-t", "--timeout", type="string", # Parsed later
233
default="15m",
234
help="Amount of downtime allowed for clients")
235
parser.add_option("--interval", type="string", # Parsed later
236
default="5m",
237
help="How often to check that a client is up")
892
238
parser.add_option("--check", action="store_true", default=False,
893
239
help="Run self-test")
894
parser.add_option("--debug", action="store_true",
895
help="Debug mode; run in foreground and log to"
896
" terminal")
897
parser.add_option("--priority", type="string", help="GnuTLS"
898
" priority string (see GnuTLS documentation)")
899
parser.add_option("--servicename", type="string", metavar="NAME",
900
help="Zeroconf service name")
901
parser.add_option("--configdir", type="string",
902
default="/etc/mandos", metavar="DIR",
903
help="Directory to search for configuration"
904
" files")
905
options = parser.parse_args()[0]
906
240
(options, args) = parser.parse_args()
241
907
242
if options.check:
908
243
import doctest
909
244
doctest.testmod()
910
245
sys.exit()
911
246
912
# Default values for config file for server-global settings
913
server_defaults = { "interface": "",
914
"address": "",
915
"port": "",
916
"debug": "False",
917
"priority":
918
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
919
"servicename": "Mandos",
920
}
921
922
# Parse config file for server-global settings
923
server_config = ConfigParser.SafeConfigParser(server_defaults)
924
del server_defaults
925
server_config.read(os.path.join(options.configdir, "mandos.conf"))
926
# Convert the SafeConfigParser object to a dict
927
server_settings = server_config.defaults()
928
# Use getboolean on the boolean config option
929
server_settings["debug"] = (server_config.getboolean
930
("DEFAULT", "debug"))
931
del server_config
932
933
# Override the settings from the config file with command line
934
# options, if set.
935
for option in ("interface", "address", "port", "debug",
936
"priority", "servicename", "configdir"):
937
value = getattr(options, option)
938
if value is not None:
939
server_settings[option] = value
940
del options
941
# Now we have our good server settings in "server_settings"
942
943
debug = server_settings["debug"]
944
945
if not debug:
946
syslogger.setLevel(logging.WARNING)
947
console.setLevel(logging.WARNING)
948
949
if server_settings["servicename"] != "Mandos":
950
syslogger.setFormatter(logging.Formatter
951
('Mandos (%s): %%(levelname)s:'
952
' %%(message)s'
953
% server_settings["servicename"]))
954
955
# Parse config file with clients
956
client_defaults = { "timeout": "1h",
957
"interval": "5m",
958
"checker": "fping -q -- %(host)s",
959
"host": "",
960
}
961
client_config = ConfigParser.SafeConfigParser(client_defaults)
962
client_config.read(os.path.join(server_settings["configdir"],
963
"clients.conf"))
964
965
clients = Set()
966
tcp_server = IPv6_TCPServer((server_settings["address"],
967
server_settings["port"]),
968
TCP_handler,
969
settings=server_settings,
970
clients=clients)
971
pidfilename = "/var/run/mandos.pid"
972
try:
973
pidfile = open(pidfilename, "w")
974
except IOError, error:
975
logger.error("Could not open file %r", pidfilename)
976
977
try:
978
uid = pwd.getpwnam("_mandos").pw_uid
979
except KeyError:
980
try:
981
uid = pwd.getpwnam("mandos").pw_uid
982
except KeyError:
983
try:
984
uid = pwd.getpwnam("nobody").pw_uid
985
except KeyError:
986
uid = 65534
987
try:
988
gid = pwd.getpwnam("_mandos").pw_gid
989
except KeyError:
990
try:
991
gid = pwd.getpwnam("mandos").pw_gid
992
except KeyError:
993
try:
994
gid = pwd.getpwnam("nogroup").pw_gid
995
except KeyError:
996
gid = 65534
997
try:
998
os.setuid(uid)
999
os.setgid(gid)
1000
except OSError, error:
1001
if error[0] != errno.EPERM:
1002
raise error
1003
1004
global service
1005
service = AvahiService(name = server_settings["servicename"],
1006
servicetype = "_mandos._tcp", )
1007
if server_settings["interface"]:
1008
service.interface = (if_nametoindex
1009
(server_settings["interface"]))
1010
1011
global main_loop
1012
global bus
1013
global server
1014
# From the Avahi example code
1015
DBusGMainLoop(set_as_default=True )
1016
main_loop = gobject.MainLoop()
1017
bus = dbus.SystemBus()
1018
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1019
avahi.DBUS_PATH_SERVER),
1020
avahi.DBUS_INTERFACE_SERVER)
1021
# End of Avahi example code
1022
bus_name = dbus.service.BusName(u"org.mandos-system.Mandos", bus)
1023
1024
clients.update(Set(Client(name = section,
1025
config
1026
= dict(client_config.items(section)))
1027
for section in client_config.sections()))
1028
if not clients:
1029
logger.critical(u"No clients defined")
1030
sys.exit(1)
1031
1032
if debug:
1033
# Redirect stdin so all checkers get /dev/null
1034
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1035
os.dup2(null, sys.stdin.fileno())
1036
if null > 2:
1037
os.close(null)
1038
else:
1039
# No console logging
1040
logger.removeHandler(console)
1041
# Close all input and output, do double fork, etc.
1042
daemon()
1043
1044
try:
1045
pid = os.getpid()
1046
pidfile.write(str(pid) + "\n")
1047
pidfile.close()
1048
del pidfile
1049
except IOError:
1050
logger.error(u"Could not write to file %r with PID %d",
1051
pidfilename, pid)
1052
except NameError:
1053
# "pidfile" was never created
1054
pass
1055
del pidfilename
1056
1057
def cleanup():
1058
"Cleanup function; run on exit"
1059
global group
1060
# From the Avahi example code
1061
if not group is None:
1062
group.Free()
1063
group = None
1064
# End of Avahi example code
1065
1066
while clients:
1067
client = clients.pop()
1068
client.disable_hook = None
1069
client.disable()
1070
1071
atexit.register(cleanup)
1072
1073
if not debug:
1074
signal.signal(signal.SIGINT, signal.SIG_IGN)
1075
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1076
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1077
1078
class MandosServer(dbus.service.Object):
1079
"""A D-Bus proxy object"""
1080
def __init__(self):
1081
dbus.service.Object.__init__(self, bus,
1082
"/Mandos")
1083
_interface = u"org.mandos_system.Mandos"
1084
1085
@dbus.service.signal(_interface, signature="oa{sv}")
1086
def ClientAdded(self, objpath, properties):
1087
"D-Bus signal"
1088
pass
1089
1090
@dbus.service.signal(_interface, signature="o")
1091
def ClientRemoved(self, objpath):
1092
"D-Bus signal"
1093
pass
1094
1095
@dbus.service.method(_interface, out_signature="ao")
1096
def GetAllClients(self):
1097
return dbus.Array(c.dbus_object_path for c in clients)
1098
1099
@dbus.service.method(_interface, out_signature="a{oa{sv}}")
1100
def GetAllClientsWithProperties(self):
1101
return dbus.Dictionary(
1102
((c.dbus_object_path, c.GetAllProperties())
1103
for c in clients),
1104
signature="oa{sv}")
1105
1106
@dbus.service.method(_interface, in_signature="o")
1107
def RemoveClient(self, object_path):
1108
for c in clients:
1109
if c.dbus_object_path == object_path:
1110
c.disable()
1111
clients.remove(c)
1112
return
1113
raise KeyError
1114
1115
del _interface
1116
1117
mandos_server = MandosServer()
1118
247
# Parse the time arguments
248
try:
249
options.timeout = string_to_delta(options.timeout)
250
except ValueError:
251
parser.error("option --timeout: Unparseable time")
252
253
try:
254
options.interval = string_to_delta(options.interval)
255
except ValueError:
256
parser.error("option --interval: Unparseable time")
257
258
cert = gnutls.crypto.X509Certificate(open(options.cert).read())
259
key = gnutls.crypto.X509PrivateKey(open(options.key).read())
260
ca = gnutls.crypto.X509Certificate(open(options.ca).read())
261
crl = gnutls.crypto.X509CRL(open(options.crl).read())
262
cred = gnutls.connection.X509Credentials(cert, key, [ca], [crl])
263
264
# Parse config file
265
defaults = {}
266
client_config_object = ConfigParser.SafeConfigParser(defaults)
267
client_config_object.read("mandos-clients.conf")
268
clients = [Client(name=section, options=options,
269
**(dict(client_config_object.items(section))))
270
for section in client_config_object.sections()]
271
272
udp_server = IPv6_UDPServer((in6addr_any, options.port),
273
udp_handler,
274
options=options)
275
276
tcp_server = IPv6_TCPServer((in6addr_any, options.port),
277
tcp_handler,
278
options=options,
279
clients=clients,
280
credentials=cred)
281
282
while True:
283
try:
284
input, out, err = select.select((udp_server,
285
tcp_server), (), ())
286
if not input:
287
pass
288
else:
289
for obj in input:
290
obj.handle_request()
291
except KeyboardInterrupt:
292
break
293
294
# Cleanup here
1119
295
for client in clients:
1120
# Emit D-Bus signal
1121
mandos_server.ClientAdded(client.dbus_object_path,
1122
client.GetAllProperties())
1123
client.enable()
1124
1125
tcp_server.enable()
1126
tcp_server.server_activate()
1127
1128
# Find out what port we got
1129
service.port = tcp_server.socket.getsockname()[1]
1130
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
1131
u" scope_id %d" % tcp_server.socket.getsockname())
1132
1133
#service.interface = tcp_server.socket.getsockname()[3]
1134
1135
try:
1136
# From the Avahi example code
1137
server.connect_to_signal("StateChanged", server_state_changed)
1138
try:
1139
server_state_changed(server.GetState())
1140
except dbus.exceptions.DBusException, error:
1141
logger.critical(u"DBusException: %s", error)
1142
sys.exit(1)
1143
# End of Avahi example code
1144
1145
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1146
lambda *args, **kwargs:
1147
(tcp_server.handle_request
1148
(*args[2:], **kwargs) or True))
1149
1150
logger.debug(u"Starting main loop")
1151
main_loop.run()
1152
except AvahiError, error:
1153
logger.critical(u"AvahiError: %s" + unicode(error))
1154
sys.exit(1)
1155
except KeyboardInterrupt:
1156
if debug:
1157
print
1158
1159
if __name__ == '__main__':
296
client.stop_checker()
297
298
299
if __name__ == "__main__":
1160
300
main()
301
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0