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 23
- compare with another revision
- download diff
- download tarball
- view history from revision 23
- Committer: Teddy Hogeborn
- Date: 2008-07-21 23:18:02 UTC
- mfrom: (15.1.5 mandos) (15.1.5 mandos)
- Revision ID: teddy@fukt.bsnet.se-20080721231802-0emzdsxkfy457p9u
merge
- files removed:
- server.conf
- files renamed:
- clients.conf => mandos-clients.conf
- 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
# following functions: "AvahiService.add", "AvahiService.remove",
9
# following functions: "add_service", "remove_service",
10
10
# "server_state_changed", "entry_group_state_changed", and some lines
11
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
65
66
#
66
67
# This server announces itself as a Zeroconf service. Connecting
67
68
# clients use the TLS protocol, with the unusual quirk that this
68
# server program acts as a TLS "client" while a connecting client acts
69
# as a TLS "server". The client (acting as a TLS "server") must
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
70
71
# supply an OpenPGP certificate, and the fingerprint of this
71
72
# certificate is used by this server to look up (in a list read from a
72
73
# file at start time) which binary blob to give the client. No other
81
82
logger.addHandler(syslogger)
82
83
del syslogger
83
84
84
85
class AvahiError(Exception):
86
def __init__(self, value):
87
self.value = value
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
"""
100
interface: integer; avahi.IF_UNSPEC or an interface index.
101
Used to optionally bind to the specified interface.
102
name = string; Example: "Mandos"
103
type = string; Example: "_mandos._tcp".
104
See <http://www.dns-sd.org/ServiceTypes.html>
105
port = integer; what port to announce
106
TXT = list of strings; TXT record for the service
107
domain = string; Domain to publish on, default to .local if empty.
108
host = string; Host to publish records for, default to localhost
109
if empty.
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
type = None, port = None, TXT = None, domain = "",
116
host = "", max_renames = 12):
117
"""An Avahi (Zeroconf) service. """
118
self.interface = interface
119
self.name = name
120
self.type = type
121
self.port = port
122
if TXT is None:
123
self.TXT = []
124
else:
125
self.TXT = TXT
126
self.domain = domain
127
self.host = host
128
self.rename_count = 0
129
def rename(self):
130
"""Derived from the Avahi example code"""
131
if self.rename_count >= self.max_renames:
132
logger.critical(u"No suitable service name found after %i"
133
u" retries, exiting.", rename_count)
134
raise AvahiServiceError("Too many renames")
135
name = server.GetAlternativeServiceName(name)
136
logger.notice(u"Changing name to %r ...", name)
137
self.remove()
138
self.add()
139
self.rename_count += 1
140
def remove(self):
141
"""Derived from the Avahi example code"""
142
if group is not None:
143
group.Reset()
144
def add(self):
145
"""Derived from the Avahi example code"""
146
global group
147
if group is None:
148
group = dbus.Interface\
149
(bus.get_object(avahi.DBUS_NAME,
150
server.EntryGroupNew()),
151
avahi.DBUS_INTERFACE_ENTRY_GROUP)
152
group.connect_to_signal('StateChanged',
153
entry_group_state_changed)
154
logger.debug(u"Adding service '%s' of type '%s' ...",
155
service.name, service.type)
156
group.AddService(
157
self.interface, # interface
158
avahi.PROTO_INET6, # protocol
159
dbus.UInt32(0), # flags
160
self.name, self.type,
161
self.domain, self.host,
162
dbus.UInt16(self.port),
163
avahi.string_array_to_txt_array(self.TXT))
164
group.Commit()
165
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
166
89
# From the Avahi example code:
167
group = None # our entry group
90
serviceName = "Mandos"
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
168
99
# End of Avahi example code
169
100
170
101
176
107
uniquely identify the client
177
108
secret: bytestring; sent verbatim (over TLS) to client
178
109
fqdn: string (FQDN); available for use by the checker command
179
created: datetime.datetime(); object creation, not client host
180
last_checked_ok: datetime.datetime() or None if not yet checked OK
181
timeout: datetime.timedelta(); How long from last_checked_ok
182
until this client is invalid
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
183
114
interval: datetime.timedelta(); How often to start a new checker
184
115
stop_hook: If set, called by stop() as stop_hook(self)
185
116
checker: subprocess.Popen(); a running checker process used
186
117
to see if the client lives.
187
'None' if no process is running.
118
Is None if no process is running.
188
119
checker_initiator_tag: a gobject event source tag, or None
189
120
stop_initiator_tag: - '' -
190
121
checker_callback_tag: - '' -
191
122
checker_command: string; External command which is run to check if
192
client lives. %() expansions are done at
123
client lives. %()s expansions are done at
193
124
runtime with vars(self) as dict, so that for
194
125
instance %(name)s can be used in the command.
195
126
Private attibutes:
196
127
_timeout: Real variable for 'timeout'
197
128
_interval: Real variable for 'interval'
198
_timeout_milliseconds: Used when calling gobject.timeout_add()
129
_timeout_milliseconds: Used by gobject.timeout_add()
199
130
_interval_milliseconds: - '' -
200
131
"""
201
132
def _set_timeout(self, timeout):
221
152
interval = property(lambda self: self._interval,
222
153
_set_interval)
223
154
del _set_interval
224
def __init__(self, name=None, stop_hook=None, fingerprint=None,
225
secret=None, secfile=None, fqdn=None, timeout=None,
226
interval=-1, checker=None):
155
def __init__(self, name=None, options=None, stop_hook=None,
156
fingerprint=None, secret=None, secfile=None,
157
fqdn=None, timeout=None, interval=-1, checker=None):
227
158
"""Note: the 'checker' argument sets the 'checker_command'
228
159
attribute and not the 'checker' attribute.."""
229
160
self.name = name
230
logger.debug(u"Creating client %r", self.name)
231
161
# Uppercase and remove spaces from fingerprint
232
162
# for later comparison purposes with return value of
233
163
# the fingerprint() function
234
164
self.fingerprint = fingerprint.upper().replace(u" ", u"")
235
logger.debug(u" Fingerprint: %s", self.fingerprint)
236
165
if secret:
237
166
self.secret = secret.decode(u"base64")
238
167
elif secfile:
240
169
self.secret = sf.read()
241
170
sf.close()
242
171
else:
243
raise TypeError(u"No secret or secfile for client %s"
244
% self.name)
245
self.fqdn = fqdn
172
raise RuntimeError(u"No secret or secfile for client %s"
173
% self.name)
174
self.fqdn = fqdn # string
246
175
self.created = datetime.datetime.now()
247
self.last_checked_ok = None
248
self.timeout = string_to_delta(timeout)
249
self.interval = string_to_delta(interval)
176
self.last_seen = None
177
if timeout is None:
178
self.timeout = options.timeout
179
else:
180
self.timeout = string_to_delta(timeout)
181
if interval == -1:
182
self.interval = options.interval
183
else:
184
self.interval = string_to_delta(interval)
250
185
self.stop_hook = stop_hook
251
186
self.checker = None
252
187
self.checker_initiator_tag = None
268
203
self.stop)
269
204
def stop(self):
270
205
"""Stop this client.
271
The possibility that a client might be restarted is left open,
272
but not currently used."""
206
The possibility that this client might be restarted is left
207
open, but not currently used."""
273
208
# If this client doesn't have a secret, it is already stopped.
274
209
if self.secret:
275
210
logger.debug(u"Stopping client %s", self.name)
276
211
self.secret = None
277
212
else:
278
213
return False
279
if getattr(self, "stop_initiator_tag", False):
214
if hasattr(self, "stop_initiator_tag") \
215
and self.stop_initiator_tag:
280
216
gobject.source_remove(self.stop_initiator_tag)
281
217
self.stop_initiator_tag = None
282
if getattr(self, "checker_initiator_tag", False):
218
if hasattr(self, "checker_initiator_tag") \
219
and self.checker_initiator_tag:
283
220
gobject.source_remove(self.checker_initiator_tag)
284
221
self.checker_initiator_tag = None
285
222
self.stop_checker()
299
236
and (os.WEXITSTATUS(condition) == 0):
300
237
logger.debug(u"Checker for %(name)s succeeded",
301
238
vars(self))
302
self.last_checked_ok = now
239
self.last_seen = now
303
240
gobject.source_remove(self.stop_initiator_tag)
304
241
self.stop_initiator_tag = gobject.timeout_add\
305
242
(self._timeout_milliseconds,
324
261
# is as it should be.
325
262
if self.checker is None:
326
263
try:
327
# In case check_command has exactly one % operator
328
264
command = self.check_command % self.fqdn
329
265
except TypeError:
330
# Escape attributes for the shell
331
266
escaped_attrs = dict((key, re.escape(str(val)))
332
267
for key, val in
333
268
vars(self).iteritems())
334
269
try:
335
270
command = self.check_command % escaped_attrs
336
271
except TypeError, error:
337
logger.error(u'Could not format string "%s":'
338
u' %s', self.check_command, error)
272
logger.critical(u'Could not format string "%s":'
273
u' %s', self.check_command, error)
339
274
return True # Try again later
340
275
try:
341
276
logger.debug(u"Starting checker %r for %s",
342
277
command, self.name)
343
self.checker = subprocess.Popen(command,
344
close_fds=True,
345
shell=True, cwd="/")
278
self.checker = subprocess.\
279
Popen(command,
280
close_fds=True, shell=True,
281
cwd="/")
346
282
self.checker_callback_tag = gobject.child_watch_add\
347
283
(self.checker.pid,
348
284
self.checker_callback)
356
292
if self.checker_callback_tag:
357
293
gobject.source_remove(self.checker_callback_tag)
358
294
self.checker_callback_tag = None
359
if getattr(self, "checker", None) is None:
295
if not hasattr(self, "checker") or self.checker is None:
360
296
return
361
297
logger.debug("Stopping checker for %(name)s", vars(self))
362
298
try:
365
301
#if self.checker.poll() is None:
366
302
# os.kill(self.checker.pid, signal.SIGKILL)
367
303
except OSError, error:
368
if error.errno != errno.ESRCH: # No such process
304
if error.errno != errno.ESRCH:
369
305
raise
370
306
self.checker = None
371
def still_valid(self):
307
def still_valid(self, now=None):
372
308
"""Has the timeout not yet passed for this client?"""
373
now = datetime.datetime.now()
374
if self.last_checked_ok is None:
309
if now is None:
310
now = datetime.datetime.now()
311
if self.last_seen is None:
375
312
return now < (self.created + self.timeout)
376
313
else:
377
return now < (self.last_checked_ok + self.timeout)
314
return now < (self.last_seen + self.timeout)
378
315
379
316
380
317
def peer_certificate(session):
433
370
def handle(self):
434
371
logger.debug(u"TCP connection from: %s",
435
372
unicode(self.client_address))
436
session = gnutls.connection.ClientSession\
437
(self.request, gnutls.connection.X509Credentials())
438
# Note: gnutls.connection.X509Credentials is really a generic
439
# GnuTLS certificate credentials object so long as no X.509
440
# keys are added to it. Therefore, we can use it here despite
441
# using OpenPGP certificates.
373
session = gnutls.connection.ClientSession(self.request,
374
gnutls.connection.\
375
X509Credentials())
442
376
443
377
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
444
378
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
445
379
# "+DHE-DSS"))
446
priority = "NORMAL" # Fallback default, since this
447
# MUST be set.
448
if self.server.settings["priority"]:
449
priority = self.server.settings["priority"]
380
priority = "SECURE256"
381
450
382
gnutls.library.functions.gnutls_priority_set_direct\
451
383
(session._c_object, priority, None);
452
384
469
401
if c.fingerprint == fpr:
470
402
client = c
471
403
break
472
if not client:
473
logger.debug(u"Client not found for fingerprint: %s", fpr)
474
session.bye()
475
return
476
404
# Have to check if client.still_valid(), since it is possible
477
405
# that the client timed out while establishing the GnuTLS
478
406
# session.
479
if not client.still_valid():
480
logger.debug(u"Client %(name)s is invalid", vars(client))
407
if (not client) or (not client.still_valid()):
408
if client:
409
logger.debug(u"Client %(name)s is invalid",
410
vars(client))
411
else:
412
logger.debug(u"Client not found for fingerprint: %s",
413
fpr)
481
414
session.bye()
482
415
return
483
416
sent_size = 0
493
426
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
494
427
"""IPv6 TCP server. Accepts 'None' as address and/or port.
495
428
Attributes:
496
settings: Server settings
429
options: Command line options
497
430
clients: Set() of Client objects
498
431
"""
499
432
address_family = socket.AF_INET6
500
433
def __init__(self, *args, **kwargs):
501
if "settings" in kwargs:
502
self.settings = kwargs["settings"]
503
del kwargs["settings"]
434
if "options" in kwargs:
435
self.options = kwargs["options"]
436
del kwargs["options"]
504
437
if "clients" in kwargs:
505
438
self.clients = kwargs["clients"]
506
439
del kwargs["clients"]
509
442
"""This overrides the normal server_bind() function
510
443
to bind to an interface if one was specified, and also NOT to
511
444
bind to an address or port if they were not specified."""
512
if self.settings["interface"]:
513
# 25 is from /usr/include/asm-i486/socket.h
514
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
445
if self.options.interface:
446
if not hasattr(socket, "SO_BINDTODEVICE"):
447
# From /usr/include/asm-i486/socket.h
448
socket.SO_BINDTODEVICE = 25
515
449
try:
516
450
self.socket.setsockopt(socket.SOL_SOCKET,
517
SO_BINDTODEVICE,
518
self.settings["interface"])
451
socket.SO_BINDTODEVICE,
452
self.options.interface)
519
453
except socket.error, error:
520
454
if error[0] == errno.EPERM:
521
455
logger.warning(u"No permission to"
522
456
u" bind to interface %s",
523
self.settings["interface"])
457
self.options.interface)
524
458
else:
525
459
raise error
526
460
# Only bind(2) the socket if we really need to.
569
503
return delta
570
504
571
505
506
def add_service():
507
"""Derived from the Avahi example code"""
508
global group, serviceName, serviceType, servicePort, serviceTXT, \
509
domain, host
510
if group is None:
511
group = dbus.Interface(
512
bus.get_object( avahi.DBUS_NAME,
513
server.EntryGroupNew()),
514
avahi.DBUS_INTERFACE_ENTRY_GROUP)
515
group.connect_to_signal('StateChanged',
516
entry_group_state_changed)
517
logger.debug(u"Adding service '%s' of type '%s' ...",
518
serviceName, serviceType)
519
520
group.AddService(
521
serviceInterface, # interface
522
avahi.PROTO_INET6, # protocol
523
dbus.UInt32(0), # flags
524
serviceName, serviceType,
525
domain, host,
526
dbus.UInt16(servicePort),
527
avahi.string_array_to_txt_array(serviceTXT))
528
group.Commit()
529
530
531
def remove_service():
532
"""From the Avahi example code"""
533
global group
534
535
if not group is None:
536
group.Reset()
537
538
572
539
def server_state_changed(state):
573
540
"""Derived from the Avahi example code"""
574
541
if state == avahi.SERVER_COLLISION:
575
542
logger.warning(u"Server name collision")
576
service.remove()
543
remove_service()
577
544
elif state == avahi.SERVER_RUNNING:
578
service.add()
545
add_service()
579
546
580
547
581
548
def entry_group_state_changed(state, error):
582
549
"""Derived from the Avahi example code"""
550
global serviceName, server, rename_count
551
583
552
logger.debug(u"state change: %i", state)
584
553
585
554
if state == avahi.ENTRY_GROUP_ESTABLISHED:
586
555
logger.debug(u"Service established.")
587
556
elif state == avahi.ENTRY_GROUP_COLLISION:
588
logger.warning(u"Service name collision.")
589
service.rename()
557
558
rename_count = rename_count - 1
559
if rename_count > 0:
560
name = server.GetAlternativeServiceName(name)
561
logger.warning(u"Service name collision, "
562
u"changing name to '%s' ...", name)
563
remove_service()
564
add_service()
565
566
else:
567
logger.error(u"No suitable service name found after %i"
568
u" retries, exiting.", n_rename)
569
killme(1)
590
570
elif state == avahi.ENTRY_GROUP_FAILURE:
591
logger.critical(u"Error in group state changed %s",
592
unicode(error))
593
raise AvahiGroupError("State changed: %s", str(error))
594
595
def if_nametoindex(interface, _func=[None]):
596
"""Call the C function if_nametoindex(), or equivalent"""
597
if _func[0] is not None:
598
return _func[0](interface)
571
logger.error(u"Error in group state changed %s",
572
unicode(error))
573
killme(1)
574
575
576
def if_nametoindex(interface):
577
"""Call the C function if_nametoindex()"""
599
578
try:
600
if "ctypes.util" not in sys.modules:
601
import ctypes.util
602
while True:
603
try:
604
libc = ctypes.cdll.LoadLibrary\
605
(ctypes.util.find_library("c"))
606
_func[0] = libc.if_nametoindex
607
return _func[0](interface)
608
except IOError, e:
609
if e != errno.EINTR:
610
raise
579
libc = ctypes.cdll.LoadLibrary("libc.so.6")
580
return libc.if_nametoindex(interface)
611
581
except (OSError, AttributeError):
612
582
if "struct" not in sys.modules:
613
583
import struct
614
584
if "fcntl" not in sys.modules:
615
585
import fcntl
616
def the_hard_way(interface):
617
"Get an interface index the hard way, i.e. using fcntl()"
618
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
619
s = socket.socket()
620
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
621
struct.pack("16s16x", interface))
622
s.close()
623
interface_index = struct.unpack("I", ifreq[16:20])[0]
624
return interface_index
625
_func[0] = the_hard_way
626
return _func[0](interface)
586
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
587
s = socket.socket()
588
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
589
struct.pack("16s16x", interface))
590
s.close()
591
interface_index = struct.unpack("I", ifreq[16:20])[0]
592
return interface_index
627
593
628
594
629
595
def daemon(nochdir, noclose):
636
602
os.chdir("/")
637
603
if not noclose:
638
604
# Close all standard open file descriptors
639
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
605
null = os.open("/dev/null", os.O_NOCTTY | os.O_RDWR)
640
606
if not stat.S_ISCHR(os.fstat(null).st_mode):
641
607
raise OSError(errno.ENODEV,
642
608
"/dev/null not a character device")
647
613
os.close(null)
648
614
649
615
616
def killme(status = 0):
617
logger.debug("Stopping server with exit status %d", status)
618
exitstatus = status
619
if main_loop_started:
620
main_loop.quit()
621
else:
622
sys.exit(status)
623
624
650
625
def main():
626
global exitstatus
627
exitstatus = 0
651
628
global main_loop_started
652
629
main_loop_started = False
653
630
654
631
parser = OptionParser()
655
632
parser.add_option("-i", "--interface", type="string",
656
metavar="IF", help="Bind to interface IF")
657
parser.add_option("-a", "--address", type="string",
633
default=None, metavar="IF",
634
help="Bind to interface IF")
635
parser.add_option("-a", "--address", type="string", default=None,
658
636
help="Address to listen for requests on")
659
parser.add_option("-p", "--port", type="int",
637
parser.add_option("-p", "--port", type="int", default=None,
660
638
help="Port number to receive requests on")
639
parser.add_option("--timeout", type="string", # Parsed later
640
default="1h",
641
help="Amount of downtime allowed for clients")
642
parser.add_option("--interval", type="string", # Parsed later
643
default="5m",
644
help="How often to check that a client is up")
661
645
parser.add_option("--check", action="store_true", default=False,
662
646
help="Run self-test")
663
647
parser.add_option("--debug", action="store_true", default=False,
664
help="Debug mode; run in foreground and log to"
665
" terminal")
666
parser.add_option("--priority", type="string", help="GnuTLS"
667
" priority string (see GnuTLS documentation)")
668
parser.add_option("--servicename", type="string", metavar="NAME",
669
help="Zeroconf service name")
670
parser.add_option("--configdir", type="string",
671
default="/etc/mandos", metavar="DIR",
672
help="Directory to search for configuration"
673
" files")
648
help="Debug mode")
674
649
(options, args) = parser.parse_args()
675
650
676
651
if options.check:
678
653
doctest.testmod()
679
654
sys.exit()
680
655
681
# Default values for config file for server-global settings
682
server_defaults = { "interface": "",
683
"address": "",
684
"port": "",
685
"debug": "False",
686
"priority":
687
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
688
"servicename": "Mandos",
689
}
690
691
# Parse config file for server-global settings
692
server_config = ConfigParser.SafeConfigParser(server_defaults)
693
del server_defaults
694
server_config.read(os.path.join(options.configdir, "server.conf"))
695
server_section = "server"
696
# Convert the SafeConfigParser object to a dict
697
server_settings = dict(server_config.items(server_section))
698
# Use getboolean on the boolean config option
699
server_settings["debug"] = server_config.getboolean\
700
(server_section, "debug")
701
del server_config
702
703
# Override the settings from the config file with command line
704
# options, if set.
705
for option in ("interface", "address", "port", "debug",
706
"priority", "servicename", "configdir"):
707
value = getattr(options, option)
708
if value is not None:
709
server_settings[option] = value
710
del options
711
# Now we have our good server settings in "server_settings"
712
713
# Parse config file with clients
714
client_defaults = { "timeout": "1h",
715
"interval": "5m",
716
"checker": "fping -q -- %%(fqdn)s",
717
}
718
client_config = ConfigParser.SafeConfigParser(client_defaults)
719
client_config.read(os.path.join(server_settings["configdir"],
720
"clients.conf"))
721
722
global service
723
service = AvahiService(name = server_settings["servicename"],
724
type = "_mandos._tcp", );
725
if server_settings["interface"]:
726
service.interface = if_nametoindex(server_settings["interface"])
656
# Parse the time arguments
657
try:
658
options.timeout = string_to_delta(options.timeout)
659
except ValueError:
660
parser.error("option --timeout: Unparseable time")
661
try:
662
options.interval = string_to_delta(options.interval)
663
except ValueError:
664
parser.error("option --interval: Unparseable time")
665
666
# Parse config file
667
defaults = { "checker": "fping -q -- %%(fqdn)s" }
668
client_config = ConfigParser.SafeConfigParser(defaults)
669
#client_config.readfp(open("global.conf"), "global.conf")
670
client_config.read("mandos-clients.conf")
727
671
728
672
global main_loop
729
673
global bus
737
681
avahi.DBUS_INTERFACE_SERVER )
738
682
# End of Avahi example code
739
683
740
debug = server_settings["debug"]
684
debug = options.debug
741
685
742
686
if debug:
743
687
console = logging.StreamHandler()
752
696
clients.remove(client)
753
697
if not clients:
754
698
logger.debug(u"No clients left, exiting")
755
sys.exit()
699
killme()
756
700
757
clients.update(Set(Client(name=section,
701
clients.update(Set(Client(name=section, options=options,
758
702
stop_hook = remove_from_clients,
759
703
**(dict(client_config\
760
704
.items(section))))
781
725
782
726
if not debug:
783
727
signal.signal(signal.SIGINT, signal.SIG_IGN)
784
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
785
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
728
signal.signal(signal.SIGHUP, lambda signum, frame: killme())
729
signal.signal(signal.SIGTERM, lambda signum, frame: killme())
786
730
787
731
for client in clients:
788
732
client.start()
789
733
790
tcp_server = IPv6_TCPServer((server_settings["address"],
791
server_settings["port"]),
734
tcp_server = IPv6_TCPServer((options.address, options.port),
792
735
tcp_handler,
793
settings=server_settings,
736
options=options,
794
737
clients=clients)
795
# Find out what port we got
796
service.port = tcp_server.socket.getsockname()[1]
797
logger.debug(u"Now listening on address %r, port %d, flowinfo %d,"
798
u" scope_id %d" % tcp_server.socket.getsockname())
799
800
#service.interface = tcp_server.socket.getsockname()[3]
801
802
try:
803
# From the Avahi example code
804
server.connect_to_signal("StateChanged", server_state_changed)
805
try:
806
server_state_changed(server.GetState())
807
except dbus.exceptions.DBusException, error:
808
logger.critical(u"DBusException: %s", error)
809
sys.exit(1)
810
# End of Avahi example code
811
812
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
813
lambda *args, **kwargs:
814
tcp_server.handle_request\
815
(*args[2:], **kwargs) or True)
816
738
# Find out what random port we got
739
global servicePort
740
servicePort = tcp_server.socket.getsockname()[1]
741
logger.debug(u"Now listening on port %d", servicePort)
742
743
if options.interface is not None:
744
global serviceInterface
745
serviceInterface = if_nametoindex(options.interface)
746
747
# From the Avahi example code
748
server.connect_to_signal("StateChanged", server_state_changed)
749
try:
750
server_state_changed(server.GetState())
751
except dbus.exceptions.DBusException, error:
752
logger.critical(u"DBusException: %s", error)
753
killme(1)
754
# End of Avahi example code
755
756
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
757
lambda *args, **kwargs:
758
tcp_server.handle_request(*args[2:],
759
**kwargs) or True)
760
try:
817
761
logger.debug("Starting main loop")
818
762
main_loop_started = True
819
763
main_loop.run()
820
except AvahiError, error:
821
logger.critical(u"AvahiError: %s" + unicode(error))
822
sys.exit(1)
823
764
except KeyboardInterrupt:
824
765
if debug:
825
766
print
767
768
sys.exit(exitstatus)
826
769
827
770
if __name__ == '__main__':
828
771
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0