/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: Björn Påhlsson
  • Date: 2007-12-11 23:40:35 UTC
  • Revision ID: belorn@braxen-20071211234035-m1nsu41vuzkak69h
Python based server
Added client configfile

Show diffs side-by-side

added added

removed removed

Lines of Context:
server.py
10
10
import gnutls.connection
11
11
import gnutls.errors
12
12
import ConfigParser
13
 
import sys
14
13
 
15
14
class Client(object):
16
15
    def __init__(self, name=None, dn=None, password=None,
27
26
            # raise RuntimeError XXX
28
27
            self.password = "gazonk"
29
28
        self.fqdn = fqdn
30
 
        self.created = datetime.datetime.now()
 
29
        # self.created = ...
31
30
        self.last_seen = None
32
31
        if timeout is None:
33
32
            timeout = self.server.options.timeout
35
34
        if interval == -1:
36
35
            interval = self.server.options.interval
37
36
        self.interval = interval
38
 
        self.next_check = datetime.datetime.now()
39
37
 
40
38
def server_bind(self):
41
39
    if self.options.interface:
122
120
 
123
121
cred = None
124
122
 
125
 
def string_to_delta(interval):
126
 
    """Parse a string and return a datetime.timedelta
127
 
 
128
 
    >>> string_to_delta('7d')
129
 
    datetime.timedelta(7)
130
 
    >>> string_to_delta('60s')
131
 
    datetime.timedelta(0, 60)
132
 
    >>> string_to_delta('60m')
133
 
    datetime.timedelta(0, 3600)
134
 
    >>> string_to_delta('24h')
135
 
    datetime.timedelta(1)
136
 
    >>> string_to_delta(u'1w')
137
 
    datetime.timedelta(7)
138
 
    """
139
 
    try:
140
 
        suffix=unicode(interval[-1])
141
 
        value=int(interval[:-1])
142
 
        if suffix == u"d":
143
 
            delta = datetime.timedelta(value)
144
 
        elif suffix == u"s":
145
 
            delta = datetime.timedelta(0, value)
146
 
        elif suffix == u"m":
147
 
            delta = datetime.timedelta(0, 0, 0, 0, value)
148
 
        elif suffix == u"h":
149
 
            delta = datetime.timedelta(0, 0, 0, 0, 0, value)
150
 
        elif suffix == u"w":
151
 
            delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
152
 
        else:
153
 
            raise ValueError
154
 
    except (ValueError, IndexError):
155
 
        raise ValueError
156
 
    return delta
157
 
 
158
123
def main():
159
124
    parser = OptionParser()
160
125
    parser.add_option("-i", "--interface", type="string",
179
144
    parser.add_option("-t", "--timeout", type="string", # Parsed later
180
145
                      default="15m",
181
146
                      help="Amount of downtime allowed for clients")
182
 
    parser.add_option("--interval", type="string", # Parsed later
183
 
                      default="5m",
184
 
                      help="How often to check that a client is up")
185
 
    parser.add_option("--check", action="store_true", default=False,
186
 
                      help="Run self-test")
187
147
    (options, args) = parser.parse_args()
188
 
 
189
 
    if options.check:
190
 
        import doctest
191
 
        doctest.testmod()
192
 
        sys.exit()
193
148
    
194
 
    # Parse the time arguments
 
149
    # Parse the time argument
195
150
    try:
196
 
        options.timeout = string_to_delta(options.timeout)
197
 
    except ValueError:
 
151
        suffix=options.timeout[-1]
 
152
        value=int(options.timeout[:-1])
 
153
        if suffix == "d":
 
154
            options.timeout = datetime.timedelta(value)
 
155
        elif suffix == "s":
 
156
            options.timeout = datetime.timedelta(0, value)
 
157
        elif suffix == "m":
 
158
            options.timeout = datetime.timedelta(0, 0, 0, 0, value)
 
159
        elif suffix == "h":
 
160
            options.timeout = datetime.timedelta(0, 0, 0, 0, 0, value)
 
161
        elif suffix == "w":
 
162
            options.timeout = datetime.timedelta(0, 0, 0, 0, 0, 0,
 
163
                                                 value)
 
164
        else:
 
165
            raise ValueError
 
166
    except (ValueError, IndexError):
198
167
        parser.error("option --timeout: Unparseable time")
199
168
    
200
 
    try:
201
 
        options.interval = string_to_delta(options.interval)
202
 
    except ValueError:
203
 
        parser.error("option --interval: Unparseable time")
204
 
    
205
169
    cert = gnutls.crypto.X509Certificate(open(options.cert).read())
206
170
    key = gnutls.crypto.X509PrivateKey(open(options.key).read())
207
171
    ca = gnutls.crypto.X509Certificate(open(options.ca).read())