http_client.py

一个java写的proxy的例子

from proxy4_base import *
from connection import *
import http_match

# DEBUGGING
PRINT_BROWSER_HEADERS = 1

class HttpClient(Connection):
    # States:
    # request (read first line)
    # headers (read HTTP headers)
    # data (read any additional data and forward it to the server)
    
    def __init__(self, socket, addr):
        self.addr = addr
        self.state = 'request'
        self.server = None
        self.request = ''
        self.headers = None
        self.bytes_remaining = None # for content only
        self.content = ''
        Connection.__init__(self, socket)
        self.socket.setblocking(0)

    def __repr__(self):
        extra = 'being read'
        if self.state != 'request':
            try: extra = split(self.request)[1][7:] # Remove http://
            except: extra = '???' + self.request
        if len(extra) > 46: extra = extra[:43] + '...'
        return '<%s:%-8s %s>' % (color(1, 'client'), self.state, extra)

    def process_read(self):
        if self.state == 'request':
            i = find(self.recv_buffer, '\r\n')
            if i >= 0: # One newline ends request
                self.request = self.read(i) # not including the newline
                self.state = 'headers'

        if self.state == 'headers':
            i = find(self.recv_buffer, '\r\n\r\n')
            if i >= 0: # Two newlines ends headers
                i = i+4 # Skip over newline terminator
                assert self.read(2) == '\r\n'
                i = i-2 # Skip over newline before headers
                self.headers = rfc822.Message(StringIO(self.read(i)))
                self.state = 'content'
                
                if PRINT_BROWSER_HEADERS:
                    print color(1, ' ______')+color(7, ' Browser headers ', 1)+color(1, '_'*(79-26))
                    print color(1, '|'), self.request
                    print color(1, '|'), join(self.headers.headers, color(1, '| ')), color(1, '|' + '_'*(79-1))
                
                if self.headers.has_key('content-length'):
                    self.bytes_remaining = int(self.headers.getheader('content-length'))
                else:
                    self.bytes_remaining = 0
                    
        if self.state == 'content' and self.bytes_remaining > 0:
            # Just pass everything through to the server
            # NOTE: It's possible to have 'chunked' encoding here,
            # and then the current system of counting bytes remaining
            # won't work; we have to deal with chunks
            data = self.read()
            self.bytes_remaining = self.bytes_remaining - len(data)
            self.content = self.content + data

        if self.state == 'content' and self.bytes_remaining <= 0:
            # We're done reading content
            self.state = 'receive'
            # This object will call server_connected at some point
            http_match.ClientServerMatchmaker(self, self.request,
                                              self.headers,
                                              self.content) 
            
        if self.state in ('receive', 'closed') and self.recv_buffer:
            assert 0, 'client in state %s sent data %s' % (self.state, `self.recv_buffer`)

    def server_response(self, server, response, headers):
        self.server = server
        assert self.server.connected
        #message(None, 'S/response', None, None, self)
        self.write(response)
        self.write(join(headers.headers, ''))
        self.write('\r\n')

    def server_no_response(self):
        #message(None, 'S/failed', None, None, self)
        self.write('**Aborted**')
        self.delayed_close()

    def server_content(self, data):
        assert self.server
        self.write(data)

    def server_close(self):
        assert self.server
        #message(None, 'S/close', None, None, self)
        if self.connected and not self.close_pending:
            self.delayed_close()
        self.server = None

    def server_abort(self):
        #message(None, 'S/abort', None, None, self)
        self.close()
        self.server = None
        
    def handle_error(self, type, value, traceback=None):
        # We should also close the server connection
        message(1, 'client error', None, None, self, type, value)
        Connection.handle_error(self, type, value, traceback)
        if self.server:
            server, self.server = self.server, None
            server.client_abort()

    def handle_close(self):
        # The client closed the connection, so cancel the server connection
        message(1, 'client close', None, None, self)
        self.send_buffer = ''
        Connection.handle_close(self)
        if self.server:
            server, self.server = self.server, None
            server.client_abort()
            # If there isn't a server, then it's in the process of
            # doing DNS lookup or connecting.  The matchmaker will
            # check to see if the client is still connected.
            
    def close(self):
        self.state = 'closed'
        Connection.close(self)