/mandos/trunk

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

  • Committer: Teddy Hogeborn
  • Date: 2008-06-21 00:53:32 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080621005332-s4scjdpevuso4lsd
* server.py: Bug fix: Do "from __future__ import division".
  (Client.__init__): Bug fix: parse interval string from config file.
  (Client.check_action): Take no arguments.  Print some debugging
  output.  Reset "checker" to None.
  (Client.start_checker): Sleep 10 seconds before pinging to alleviate
  debugging.
  (Client.next_stop): Bug fix: check if "last_seen" and/or "checker"
  is None.
  (Client.still_valid): Bug fix: check if "last_seen" is None.
  (Client.handle): When finding the right password to send, use a list
  comprehension and an index lookup instead of a generator expression to
  a dict.
  (IPv6_TCPServer.request_queue_size): Removed.
  (in6addr_any): Moved inside "main".
  (main): Changed "clients" to be a Set instead of a list.  Bug fix:
  Exit when/if all clients are removed.  Call "select" with all client
  checkers and a suitable timeout.  Add some debugging output.  Start
  new checkers when needed and delete clients which have timed out.

Show diffs side-by-side

added added

removed removed

Lines of Context:
server.py
1
1
#!/usr/bin/python
2
2
 
 
3
from __future__ import division
 
4
 
3
5
import SocketServer
4
6
import socket
5
7
import select
11
13
import gnutls.errors
12
14
import ConfigParser
13
15
import sys
14
 
 
 
16
import re
 
17
import os
 
18
import signal
 
19
from sets import Set
 
20
import subprocess
15
21
 
16
22
class Client(object):
17
23
    def __init__(self, name=None, options=None, dn=None,
27
33
            print "No Password or Passfile in client config file"
28
34
            # raise RuntimeError XXX
29
35
            self.password = "gazonk"
30
 
        self.fqdn = fqdn
 
36
        self.fqdn = fqdn                # string
31
37
        self.created = datetime.datetime.now()
32
 
        self.last_seen = None
 
38
        self.last_seen = None           # datetime.datetime()
33
39
        if timeout is None:
34
40
            timeout = options.timeout
35
 
        self.timeout = timeout
 
41
        self.timeout = timeout          # datetime.timedelta()
36
42
        if interval == -1:
37
43
            interval = options.interval
38
 
        self.interval = interval
39
 
        self.next_check = datetime.datetime.now()
 
44
        else:
 
45
            interval = string_to_delta(interval)
 
46
        self.interval = interval        # datetime.timedelta()
 
47
        self.next_check = datetime.datetime.now() # datetime.datetime()
 
48
        # Note: next_check may be in the past if checker is not None
 
49
        self.checker = None             # or a subprocess.Popen()
 
50
    def check_action(self):
 
51
        """The checker said something and might have completed.
 
52
        Check if is has, and take appropriate actions."""
 
53
        if self.checker.poll() is None:
 
54
            # False alarm, no result yet
 
55
            #self.checker.read()
 
56
            #print "Checker for %(name)s said nothing?" % vars(self)
 
57
            return
 
58
        now = datetime.datetime.now()
 
59
        if self.checker.returncode == 0:
 
60
            print "Checker for %(name)s succeeded" % vars(self)
 
61
            self.last_seen = now
 
62
        else:
 
63
            print "Checker for %(name)s failed" % vars(self)
 
64
        while self.next_check <= now:
 
65
            self.next_check += self.interval
 
66
        self.checker = None
 
67
    handle_request = check_action
 
68
    def start_checker(self):
 
69
        self.stop_checker()
 
70
        try:
 
71
            self.checker = subprocess.Popen("sleep 10; fping -q -- %s"
 
72
                                            % re.escape(self.fqdn),
 
73
                                            stdout=subprocess.PIPE,
 
74
                                            close_fds=True,
 
75
                                            shell=True, cwd="/")
 
76
        except subprocess.OSError, e:
 
77
            print "Failed to start subprocess:", e
 
78
    def stop_checker(self):
 
79
        if self.checker is None:
 
80
            return
 
81
        os.kill(self.checker.pid, signal.SIGTERM)
 
82
        if self.checker.poll() is None:
 
83
            os.kill(self.checker.pid, signal.SIGKILL)
 
84
        self.checker = None
 
85
    __del__ = stop_checker
 
86
    def fileno(self):
 
87
        if self.checker is None:
 
88
            return None
 
89
        return self.checker.stdout.fileno()
 
90
    def next_stop(self):
 
91
        """The time when something must be done about this client
 
92
        May be in the past."""
 
93
        if self.last_seen is None:
 
94
            # This client has never been seen
 
95
            next_timeout = self.created + self.timeout
 
96
        else:
 
97
            next_timeout = self.last_seen + self.timeout
 
98
        if self.checker is None:
 
99
            return min(next_timeout, self.next_check)
 
100
        else:
 
101
            return next_timeout
 
102
    def still_valid(self, now=None):
 
103
        """Has this client's timeout not passed?"""
 
104
        if now is None:
 
105
            now = datetime.datetime.now()
 
106
        if self.last_seen is None:
 
107
            return now < (self.created + self.timeout)
 
108
        else:
 
109
            return now < (self.last_seen + self.timeout)
 
110
    def it_is_time_to_check(self, now=None):
 
111
        if now is None:
 
112
            now = datetime.datetime.now()
 
113
        return self.next_check <= now
40
114
 
41
115
 
42
116
class server_metaclass(type):
107
181
            session.bye()
108
182
            return
109
183
        try:
110
 
            session.send(dict((client.dn, client.password)
111
 
                              for client in self.server.clients)
112
 
                         [session.peer_certificate.subject])
113
 
        except KeyError:
 
184
            session.send([client.password
 
185
                          for client in self.server.clients
 
186
                          if (client.dn ==
 
187
                              session.peer_certificate.subject)][0])
 
188
        except IndexError:
114
189
            session.send("gazonk")
115
190
            # Log maybe? XXX
116
191
        session.bye()
118
193
 
119
194
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
120
195
    __metaclass__ = server_metaclass
121
 
    request_queue_size = 1024
122
 
 
123
 
 
124
 
in6addr_any = "::"
125
 
 
126
 
cred = None
 
196
 
127
197
 
128
198
def string_to_delta(interval):
129
199
    """Parse a string and return a datetime.timedelta
158
228
        raise ValueError
159
229
    return delta
160
230
 
 
231
 
161
232
def main():
162
233
    parser = OptionParser()
163
234
    parser.add_option("-i", "--interface", type="string",
215
286
    defaults = {}
216
287
    client_config_object = ConfigParser.SafeConfigParser(defaults)
217
288
    client_config_object.read("mandos-clients.conf")
218
 
    clients = [Client(name=section, options=options,
219
 
                      **(dict(client_config_object.items(section))))
220
 
               for section in client_config_object.sections()]
 
289
    clients = Set(Client(name=section, options=options,
 
290
                         **(dict(client_config_object\
 
291
                                 .items(section))))
 
292
                  for section in client_config_object.sections())
221
293
    
 
294
    in6addr_any = "::"
222
295
    udp_server = IPv6_UDPServer((in6addr_any, options.port),
223
296
                                udp_handler,
224
297
                                options=options)
230
303
                                credentials=cred)
231
304
    
232
305
    while True:
233
 
        in_, out, err = select.select((udp_server,
234
 
                                       tcp_server), (), ())
235
 
        for server in in_:
236
 
            server.handle_request()
 
306
        if not clients:
 
307
            break
 
308
        try:
 
309
            next_stop = min(client.next_stop() for client in clients)
 
310
            now = datetime.datetime.now()
 
311
            if next_stop > now:
 
312
                delay = next_stop - now
 
313
                delay_seconds = (delay.days * 24 * 60 * 60
 
314
                                 + delay.seconds
 
315
                                 + delay.microseconds / 1000000)
 
316
                clients_with_checkers = tuple(client for client in
 
317
                                              clients
 
318
                                              if client.checker
 
319
                                              is not None)
 
320
                input_checks = (udp_server, tcp_server) \
 
321
                               + clients_with_checkers
 
322
                print "Waiting for network",
 
323
                if clients_with_checkers:
 
324
                    print "and checkers for:",
 
325
                    for client in clients_with_checkers:
 
326
                        print client.name,
 
327
                print
 
328
                input, out, err = select.select(input_checks, (), (),
 
329
                                                delay_seconds)
 
330
                for obj in input:
 
331
                    obj.handle_request()
 
332
            # start new checkers
 
333
            for client in clients:
 
334
                if client.it_is_time_to_check(now=now) and \
 
335
                       client.checker is None:
 
336
                    print "Starting checker for client %(name)s" \
 
337
                          % vars(client)
 
338
                    client.start_checker()
 
339
            # delete timed-out clients
 
340
            for client in clients.copy():
 
341
                if not client.still_valid(now=now):
 
342
                    # log xxx
 
343
                    print "Removing client %(name)s" % vars(client)
 
344
                    clients.remove(client)
 
345
        except KeyboardInterrupt:
 
346
            break
 
347
    
 
348
    # Cleanup here
 
349
    for client in clients:
 
350
        client.stop_checker()
237
351
 
238
352
 
239
353
if __name__ == "__main__":