/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/HTTPTestUtil.py

  • Committer: Marius Kruger
  • Date: 2007-08-12 08:15:15 UTC
  • mfrom: (2695 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2979.
  • Revision ID: amanic@gmail.com-20070812081515-vgekipfhohcuj6rn
merge with bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/HTTPTestUtil.py
16
16
 
17
17
from cStringIO import StringIO
18
18
import errno
 
19
import md5
19
20
from SimpleHTTPServer import SimpleHTTPRequestHandler
20
21
import re
 
22
import sha
21
23
import socket
 
24
import time
 
25
import urllib2
22
26
import urlparse
23
27
 
24
28
from bzrlib.smart import protocol
146
150
        self.wfile.write(out_buffer.getvalue())
147
151
 
148
152
 
 
153
class LimitedRangeRequestHandler(TestingHTTPRequestHandler):
 
154
    """Errors out when range specifiers exceed the limit"""
 
155
 
 
156
    def get_multiple_ranges(self, file, file_size, ranges):
 
157
        """Refuses the multiple ranges request"""
 
158
        tcs = self.server.test_case_server
 
159
        if tcs.range_limit is not None and len(ranges) > tcs.range_limit:
 
160
            file.close()
 
161
            # Emulate apache behavior
 
162
            self.send_error(400, "Bad Request")
 
163
            return
 
164
        return TestingHTTPRequestHandler.get_multiple_ranges(self, file,
 
165
                                                             file_size, ranges)
 
166
 
 
167
    def do_GET(self):
 
168
        tcs = self.server.test_case_server
 
169
        tcs.GET_request_nb += 1
 
170
        return TestingHTTPRequestHandler.do_GET(self)
 
171
 
 
172
 
 
173
class LimitedRangeHTTPServer(HttpServer):
 
174
    """An HttpServer erroring out on requests with too much range specifiers"""
 
175
 
 
176
    def __init__(self, request_handler=LimitedRangeRequestHandler,
 
177
                 range_limit=None):
 
178
        HttpServer.__init__(self, request_handler)
 
179
        self.range_limit = range_limit
 
180
        self.GET_request_nb = 0
 
181
 
 
182
 
149
183
class SingleRangeRequestHandler(TestingHTTPRequestHandler):
150
184
    """Always reply to range request as if they were single.
151
185
 
158
192
        return self.get_single_range(file, file_size, start, end)
159
193
 
160
194
 
 
195
class SingleOnlyRangeRequestHandler(TestingHTTPRequestHandler):
 
196
    """Only reply to simple range requests, errors out on multiple"""
 
197
 
 
198
    def get_multiple_ranges(self, file, file_size, ranges):
 
199
        """Refuses the multiple ranges request"""
 
200
        if len(ranges) > 1:
 
201
            file.close()
 
202
            self.send_error(416, "Requested range not satisfiable")
 
203
            return
 
204
        (start, end) = ranges[0]
 
205
        return self.get_single_range(file, file_size, start, end)
 
206
 
 
207
 
161
208
class NoRangeRequestHandler(TestingHTTPRequestHandler):
162
209
    """Ignore range requests without notice"""
163
210
 
204
251
        return self.__secondary_server
205
252
 
206
253
 
207
 
class FakeProxyRequestHandler(TestingHTTPRequestHandler):
208
 
    """Append a '-proxied' suffix to file served"""
209
 
 
210
 
    def translate_path(self, path):
211
 
        # We need to act as a proxy and accept absolute urls,
212
 
        # which SimpleHTTPRequestHandler (grand parent) is not
213
 
        # ready for. So we just drop the protocol://host:port
214
 
        # part in front of the request-url (because we know we
215
 
        # would not forward the request to *another* proxy).
216
 
 
217
 
        # So we do what SimpleHTTPRequestHandler.translate_path
218
 
        # do beginning with python 2.4.3: abandon query
219
 
        # parameters, scheme, host port, etc (which ensure we
220
 
        # provide the right behaviour on all python versions).
221
 
        path = urlparse.urlparse(path)[2]
222
 
        # And now, we can apply *our* trick to proxy files
223
 
        self.path += '-proxied'
224
 
        # An finally we leave our mother class do whatever it
225
 
        # wants with the path
226
 
        return TestingHTTPRequestHandler.translate_path(self, path)
 
254
class ProxyServer(HttpServer):
 
255
    """A proxy test server for http transports."""
 
256
 
 
257
    proxy_requests = True
227
258
 
228
259
 
229
260
class RedirectRequestHandler(TestingHTTPRequestHandler):
309
340
       self.old_server = self.get_secondary_server()
310
341
 
311
342
 
 
343
class AuthRequestHandler(TestingHTTPRequestHandler):
 
344
    """Requires an authentication to process requests.
 
345
 
 
346
    This is intended to be used with a server that always and
 
347
    only use one authentication scheme (implemented by daughter
 
348
    classes).
 
349
    """
 
350
 
 
351
    # The following attributes should be defined in the server
 
352
    # - auth_header_sent: the header name sent to require auth
 
353
    # - auth_header_recv: the header received containing auth
 
354
    # - auth_error_code: the error code to indicate auth required
 
355
 
 
356
    def do_GET(self):
 
357
        if self.authorized():
 
358
            return TestingHTTPRequestHandler.do_GET(self)
 
359
        else:
 
360
            # Note that we must update test_case_server *before*
 
361
            # sending the error or the client may try to read it
 
362
            # before we have sent the whole error back.
 
363
            tcs = self.server.test_case_server
 
364
            tcs.auth_required_errors += 1
 
365
            self.send_response(tcs.auth_error_code)
 
366
            self.send_header_auth_reqed()
 
367
            self.end_headers()
 
368
            return
 
369
 
 
370
 
 
371
class BasicAuthRequestHandler(AuthRequestHandler):
 
372
    """Implements the basic authentication of a request"""
 
373
 
 
374
    def authorized(self):
 
375
        tcs = self.server.test_case_server
 
376
        if tcs.auth_scheme != 'basic':
 
377
            return False
 
378
 
 
379
        auth_header = self.headers.get(tcs.auth_header_recv, None)
 
380
        if auth_header:
 
381
            scheme, raw_auth = auth_header.split(' ', 1)
 
382
            if scheme.lower() == tcs.auth_scheme:
 
383
                user, password = raw_auth.decode('base64').split(':')
 
384
                return tcs.authorized(user, password)
 
385
 
 
386
        return False
 
387
 
 
388
    def send_header_auth_reqed(self):
 
389
        tcs = self.server.test_case_server
 
390
        self.send_header(tcs.auth_header_sent,
 
391
                         'Basic realm="%s"' % tcs.auth_realm)
 
392
 
 
393
 
 
394
# FIXME: We could send an Authentication-Info header too when
 
395
# the authentication is succesful
 
396
 
 
397
class DigestAuthRequestHandler(AuthRequestHandler):
 
398
    """Implements the digest authentication of a request.
 
399
 
 
400
    We need persistence for some attributes and that can't be
 
401
    achieved here since we get instantiated for each request. We
 
402
    rely on the DigestAuthServer to take care of them.
 
403
    """
 
404
 
 
405
    def authorized(self):
 
406
        tcs = self.server.test_case_server
 
407
        if tcs.auth_scheme != 'digest':
 
408
            return False
 
409
 
 
410
        auth_header = self.headers.get(tcs.auth_header_recv, None)
 
411
        if auth_header is None:
 
412
            return False
 
413
        scheme, auth = auth_header.split(None, 1)
 
414
        if scheme.lower() == tcs.auth_scheme:
 
415
            auth_dict = urllib2.parse_keqv_list(urllib2.parse_http_list(auth))
 
416
 
 
417
            return tcs.digest_authorized(auth_dict, self.command)
 
418
 
 
419
        return False
 
420
 
 
421
    def send_header_auth_reqed(self):
 
422
        tcs = self.server.test_case_server
 
423
        header = 'Digest realm="%s", ' % tcs.auth_realm
 
424
        header += 'nonce="%s", algorithm="%s", qop="auth"' % (tcs.auth_nonce,
 
425
                                                              'MD5')
 
426
        self.send_header(tcs.auth_header_sent,header)
 
427
 
 
428
 
 
429
class AuthServer(HttpServer):
 
430
    """Extends HttpServer with a dictionary of passwords.
 
431
 
 
432
    This is used as a base class for various schemes which should
 
433
    all use or redefined the associated AuthRequestHandler.
 
434
 
 
435
    Note that no users are defined by default, so add_user should
 
436
    be called before issuing the first request.
 
437
    """
 
438
 
 
439
    # The following attributes should be set dy daughter classes
 
440
    # and are used by AuthRequestHandler.
 
441
    auth_header_sent = None
 
442
    auth_header_recv = None
 
443
    auth_error_code = None
 
444
    auth_realm = "Thou should not pass"
 
445
 
 
446
    def __init__(self, request_handler, auth_scheme):
 
447
        HttpServer.__init__(self, request_handler)
 
448
        self.auth_scheme = auth_scheme
 
449
        self.password_of = {}
 
450
        self.auth_required_errors = 0
 
451
 
 
452
    def add_user(self, user, password):
 
453
        """Declare a user with an associated password.
 
454
 
 
455
        password can be empty, use an empty string ('') in that
 
456
        case, not None.
 
457
        """
 
458
        self.password_of[user] = password
 
459
 
 
460
    def authorized(self, user, password):
 
461
        """Check that the given user provided the right password"""
 
462
        expected_password = self.password_of.get(user, None)
 
463
        return expected_password is not None and password == expected_password
 
464
 
 
465
 
 
466
# FIXME: There is some code duplication with
 
467
# _urllib2_wrappers.py.DigestAuthHandler. If that duplciation
 
468
# grows, it may require a refactoring. Also, we don't implement
 
469
# SHA algorithm nor MD5-sess here, but that does not seem worth
 
470
# it.
 
471
class DigestAuthServer(AuthServer):
 
472
    """A digest authentication server"""
 
473
 
 
474
    auth_nonce = 'now!'
 
475
 
 
476
    def __init__(self, request_handler, auth_scheme):
 
477
        AuthServer.__init__(self, request_handler, auth_scheme)
 
478
 
 
479
    def digest_authorized(self, auth, command):
 
480
        nonce = auth['nonce']
 
481
        if nonce != self.auth_nonce:
 
482
            return False
 
483
        realm = auth['realm']
 
484
        if realm != self.auth_realm:
 
485
            return False
 
486
        user = auth['username']
 
487
        if not self.password_of.has_key(user):
 
488
            return False
 
489
        algorithm= auth['algorithm']
 
490
        if algorithm != 'MD5':
 
491
            return False
 
492
        qop = auth['qop']
 
493
        if qop != 'auth':
 
494
            return False
 
495
 
 
496
        password = self.password_of[user]
 
497
 
 
498
        # Recalculate the response_digest to compare with the one
 
499
        # sent by the client
 
500
        A1 = '%s:%s:%s' % (user, realm, password)
 
501
        A2 = '%s:%s' % (command, auth['uri'])
 
502
 
 
503
        H = lambda x: md5.new(x).hexdigest()
 
504
        KD = lambda secret, data: H("%s:%s" % (secret, data))
 
505
 
 
506
        nonce_count = int(auth['nc'], 16)
 
507
 
 
508
        ncvalue = '%08x' % nonce_count
 
509
 
 
510
        cnonce = auth['cnonce']
 
511
        noncebit = '%s:%s:%s:%s:%s' % (nonce, ncvalue, cnonce, qop, H(A2))
 
512
        response_digest = KD(H(A1), noncebit)
 
513
 
 
514
        return response_digest == auth['response']
 
515
 
 
516
class HTTPAuthServer(AuthServer):
 
517
    """An HTTP server requiring authentication"""
 
518
 
 
519
    def init_http_auth(self):
 
520
        self.auth_header_sent = 'WWW-Authenticate'
 
521
        self.auth_header_recv = 'Authorization'
 
522
        self.auth_error_code = 401
 
523
 
 
524
 
 
525
class ProxyAuthServer(AuthServer):
 
526
    """A proxy server requiring authentication"""
 
527
 
 
528
    def init_proxy_auth(self):
 
529
        self.proxy_requests = True
 
530
        self.auth_header_sent = 'Proxy-Authenticate'
 
531
        self.auth_header_recv = 'Proxy-Authorization'
 
532
        self.auth_error_code = 407
 
533
 
 
534
 
 
535
class HTTPBasicAuthServer(HTTPAuthServer):
 
536
    """An HTTP server requiring basic authentication"""
 
537
 
 
538
    def __init__(self):
 
539
        HTTPAuthServer.__init__(self, BasicAuthRequestHandler, 'basic')
 
540
        self.init_http_auth()
 
541
 
 
542
 
 
543
class HTTPDigestAuthServer(DigestAuthServer, HTTPAuthServer):
 
544
    """An HTTP server requiring digest authentication"""
 
545
 
 
546
    def __init__(self):
 
547
        DigestAuthServer.__init__(self, DigestAuthRequestHandler, 'digest')
 
548
        self.init_http_auth()
 
549
 
 
550
 
 
551
class ProxyBasicAuthServer(ProxyAuthServer):
 
552
    """A proxy server requiring basic authentication"""
 
553
 
 
554
    def __init__(self):
 
555
        ProxyAuthServer.__init__(self, BasicAuthRequestHandler, 'basic')
 
556
        self.init_proxy_auth()
 
557
 
 
558
 
 
559
class ProxyDigestAuthServer(DigestAuthServer, ProxyAuthServer):
 
560
    """A proxy server requiring basic authentication"""
 
561
 
 
562
    def __init__(self):
 
563
        ProxyAuthServer.__init__(self, DigestAuthRequestHandler, 'digest')
 
564
        self.init_proxy_auth()
 
565
 
 
566