Maximum CD 2011 February/maximum-cd-2011-02.iso/DiscContents/digsby_setup85.exe/lib/util/asynchttp.pyo

Python Compiled Bytecode | 2010-11-24 | 19.3 KB | 554 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.6)

__author__ = '\nDownright Software LLC\nhttp://www.downright.com\n'
__copyright__ = "\nCopyright (c) 2001 Downright Software LLC. All Rights Reserved.\n\nDistributed and Licensed under the provisions of the Python Open Source License\nAgreement which is included by reference. (See 'Front Matter' in the latest\nPython documentation)\n\nWARRANTIES\nYOU UNDERSTAND AND AGREE THAT:\n\na. YOUR USE OF THE PACKAGE IS AT YOUR SOLE RISK.  THE PACKAGE IS PROVIDED ON\nAN 'AS IS' AND 'AS AVAILABLE' BASIS.  DOWNRIGHT EXPRESSLY DISCLAIMS ALL\nWARRANTIES OF ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED\nTO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE\nAND NON-INFRINGEMENT.\n\nb. DOWNRIGHT MAKES NO WARRANTY THAT (1) THE PACKAGE WILL MEET YOUR\nREQUIREMENTS, (2) THE PACKAGE WILL BE UNINTERRUPTED, TIMELY, SECURE, OR\nERROR-FREE, (3) THE RESULTS THAT MAY BE OBTAINED FROM THE USE OF THE PACKAGE\nWILL BE ACCURATE OR RELIABLE, (4) THE OTHER MATERIAL PURCHASED OR OBTAINED BY\nYOU THROUGH THE PACKAGE WILL MEET YOUR EXPECTATIONS,, AND (5) ANY ERRORS IN\nTHE PACKAGE WILL BE CORRECTED.\n\nc. ANY MATERIALS DOWNLOADED OR OTHERWISE OBTAINED THROUGH THE USE OF THE\nPACKAGE IS DONE AT YOUR OWN DISCRETION AND RISK AND THAT YOU WILL BE SOLELY\nRESPONSIBLE FOR ANY DAMAGE TO YOUR COMPUTER SYSTEM OR LOSS OF DATA THAT\nRESULTS FROM THE DOWNLOAD OF ANY SUCH MATERIAL.\n\nd. NO ADVICE OR INFORMATION, WHETHER ORAL OR WRITTEN, OBTAINED BY YOU FROM\nDOWNRIGHT OR THROUGH OR FROM THE PACKAGE SHALL CREATE ANY WARRANTY NOT\nEXPRESSLY STATED IN THE TOS.\n\nLIMITATION OF LIABILITY\nYOU EXPRESSLY UNDERSTAND AND AGREE THAT DOWNRIGHT SHALL NOT BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL OR EXEMPLARY DAMAGES,\nINCLUDING BUT NOT LIMITED TO, DAMAGES FOR LOSS OF PROFITS, GOODWILL, USE,\nDATA OR OTHER INTANGIBLE LOSSES (EVEN IF DOWNRIGHT HAS BEEN ADVISED OF SUCH\nDAMAGES), RESULTING FROM:\n(1) THE USE OR THE INABILITY TO USE THE PACKAGE;\n(2) THE COST OF PROCUREMENT OF SUBSTITUTE GOODS AND SERVICES RESULTING FROM\nANY GOODS, DATA, INFORMATION OR SERVICES PURCHASED OR OBTAINED OR MESSAGES\nRECEIVED OR TRANSACTIONS ENTERED INTO THROUGH OR FROM THE PACKAGE;\n(3) UNAUTHORIZED ACCESS TO OR ALTERATION OF YOUR TRANSMISSIONS OR DATA;\n(4) STATEMENTS OF CONDUCT OF ANY THIRD PARTY ON THE PACKAGE; OR\n(5) ANY OTHER MATTER RELATING TO THE PACKAGE.\n"
__version__ = '0.20'
import sys
import asynchat
import asyncore
import socket
import time
import string
import StringIO
import mimetools
HTTP_PORT = 80
HTTPS_PORT = 443
import common

class AsyncHTTPResponse:

    def __init__(self, fp, debuglevel = 0):
        self.fp = fp
        self.debuglevel = debuglevel
        self.msg = None
        self._replyline = ''
        self.status = None
        self.reason = None
        self.version = None


    def _process_response(self):
        self._replyline = self.fp.readline()
        if self.debuglevel > 0:
            print 'reply: %s' % self._replyline

        replylist = string.split(self._replyline, None, 2)
        if len(replylist) == 3:
            (version, status, reason) = replylist
        elif len(replylist) == 2:
            (version, status) = replylist
            reason = ''
        else:
            raise BadStatusLine(self._replyline, name = str(self))
        if len(replylist) == 3[:5] != 'HTTP/':
            raise BadStatusLine(self._replyline, name = str(self))
        len(replylist) == 3[:5] != 'HTTP/'

        try:
            self.code = self.status = int(status)
        except:
            raise BadStatusLine(self._replyline, name = str(self))

        self.reason = string.strip(reason)
        if version == 'HTTP/1.0':
            self.version = 10
        elif version.startswith('HTTP/1.'):
            self.version = 11
        else:
            raise UnknownProtocol(self._replyline, name = str(self))
        self.msg = (version == 'HTTP/1.0').Message(self.fp, 0)
        if self.debuglevel > 0:
            for hdr in self.msg.headers:
                print 'header: %s' % string.strip(hdr)


        self.error = self.code // 100 != 2
        self.body = None


    def __str__(self):
        return 'AsyncHTTPResponse %r' % self._replyline


    def getheader(self, name, default = None):
        if self.msg is None:
            raise ResponseNotReady(name = str(self))
        self.msg is None
        return self.msg.getheader(name, default)


    def getbody(self):
        if self.body is None:
            raise ResponseNotReady(name = str(self))
        self.body is None
        return self.body


    def read(self, howmuch = -1):
        return self.fp.read(howmuch)


    def info(self):
        return self.msg


_CHUNK_REQUEST_SIZE = 8192
_STATE_IDLE = 'asynchttp._STATE_IDLE'
_STATE_CONNECTING = 'asynchttp._STATE_CONNECTING'
_STATE_ACTIVE = 'asynchttp._STATE_ACTIVE'
_STATE_ACCEPTING_HEADERS = 'asynchttp._STATE_ACCEPTING_HEADERS'
_STATE_REQUESTING_BODY = 'asynchttp._STATE_REQUESTING_BODY'
_STATE_CHUNK_START = 'asynchttp._STATE_CHUNK_START'
_STATE_CHUNK_BODY = 'asynchttp._STATE_CHUNK_BODY'
_STATE_CHUNK_RESIDUE = 'asynchttp._STATE_CHUNK_RESIDUE'

class AsyncHTTPConnection(common.socket):
    _http_vsn = 11
    _http_vsn_str = 'HTTP/1.1'
    response_class = AsyncHTTPResponse
    default_port = HTTP_PORT
    auto_open = 1
    debuglevel = 0

    def __init__(self, host = None, port = None):
        self._TERMINATOR_MAP = {
            _STATE_IDLE: self._no_action,
            _STATE_CONNECTING: self._no_action,
            _STATE_ACTIVE: self._no_action,
            _STATE_ACCEPTING_HEADERS: self._header_data,
            _STATE_REQUESTING_BODY: self._body_data,
            _STATE_CHUNK_START: self._chunk_start_data,
            _STATE_CHUNK_BODY: self._chunk_body_data,
            _STATE_CHUNK_RESIDUE: self._chunk_residue_data }
        self._AsyncHTTPConnection__state = None
        self._AsyncHTTPConnection__set_state(_STATE_IDLE)
        self._headerdict = { }
        self._requestfp = None
        self._responsefp = StringIO.StringIO()
        self._chunkfp = None
        self.response = self.response_class(self._responsefp, self.debuglevel)
        self._set_hostport(host, port)
        self._willclose = 0
        import primitives.funcs as funcs
        self._on_connect = funcs.Delegate()
        common.socket.__init__(self, False)


    def _set_hostport(self, host, port):
        if host and port is None:
            i = string.find(host, ':')
            if i >= 0:
                port = int(host[i + 1:])
                host = host[:i]
            else:
                port = self.default_port

        self.host = host
        self.port = port


    def set_debuglevel(self, level):
        self.debuglevel = level


    def connect(self):
        self._AsyncHTTPConnection__set_state(_STATE_CONNECTING)
        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        if self.debuglevel > 0:
            print 'connecting: (%s, %s)' % (self.host, self.port)

        import util.net as net
        import socks
        pi = net.GetProxyInfo()
        use_proxy = True
        host = self.host
        port = self.port
        if pi.get('proxytype', 0) == socks.PROXY_TYPE_HTTP:
            use_proxy = False

        common.socket.connect(self, (host, port), use_proxy = use_proxy, error = self.handle_error)


    def close(self):
        if self.debuglevel > 0:
            print 'asynchttp.close() (%s, %s)' % (self.host, self.port)

        self.connected = 0
        if self.socket:
            common.socket.close(self)

        self._set_hostport(None, None)


    def send_entity(self, str):
        if self.debuglevel > 0:
            print 'send_entity %r' % str

        self._requestfp.write(str)


    def putrequest(self, method, url):
        if self.debuglevel > 0:
            print 'putrequest %s %s' % (method, url)

        if self._AsyncHTTPConnection__state is not _STATE_ACTIVE:
            raise RequestNotReady('Invalid putrequest() %s' % self._AsyncHTTPConnection__state, name = str(self))
        self._AsyncHTTPConnection__state is not _STATE_ACTIVE
        self._requestfp = StringIO.StringIO()
        if not url:
            url = '/'

        self._requestfp.write('%s %s %s\r\n' % (method, url, self._http_vsn_str))
        if self._http_vsn == 11:
            self.putheader('Host', self.host)
            self.putheader('Accept-Encoding', 'identity')



    def putheader(self, header, value):
        if self.debuglevel > 0:
            print 'putheader %s: %s' % (header, value)

        self._headerdict[header] = value


    def endheaders(self):
        if self._AsyncHTTPConnection__state is not _STATE_ACTIVE:
            self._on_connect += self.endheaders
            return None
        for header, value in self._headerdict.items():
            self._requestfp.write('%s: %s\r\n' % (header, value))

        self._requestfp.write('\r\n')


    def request(self, method, url, body = None, headers = { }):
        if self.debuglevel > 0:
            print 'request'

        if self._AsyncHTTPConnection__state is not _STATE_ACTIVE:
            (None, None, self, self, self._on_connect) += (lambda : self.request(method, url, body, headers))
            return None
        self._send_request(method, url, body, headers)


    def _send_request(self, method, url, body, headers):
        if self.debuglevel > 0:
            print '_send_request'

        self.putrequest(method, url)
        if body:
            self.putheader('Content-Length', str(len(body)))

        for hdr, value in headers.items():
            self.putheader(hdr, value)

        self.endheaders()
        if body:
            self.send_entity(body)



    def getresponse(self):
        if self._AsyncHTTPConnection__state is not _STATE_ACTIVE:
            self._on_connect += self.getresponse
            return self.response
        self._AsyncHTTPConnection__set_state(_STATE_ACCEPTING_HEADERS)
        self.push(self._requestfp.getvalue())
        self._requestfp = None
        self.set_terminator('\r\n\r\n')
        return self.response


    def handle_connect(self):
        self._AsyncHTTPConnection__set_state(_STATE_ACTIVE)
        if self.debuglevel > 0:
            print 'connected: (%s, %s)' % (self.host, self.port)

        self._on_connect.call_and_clear()


    def handle_close(self):
        if self.debuglevel > 0:
            print 'closed by server: (%s, %s) %s' % (self.host, self.port, self._AsyncHTTPConnection__state)

        common.socket.handle_close(self)
        self.close()
        if self._AsyncHTTPConnection__state in [
            _STATE_REQUESTING_BODY,
            _STATE_CHUNK_BODY,
            _STATE_CHUNK_RESIDUE]:
            self.found_terminator()
            return None


    def handle_error(self, why = None):
        self._AsyncHTTPConnection__set_state(_STATE_IDLE)
        common.socket.handle_error(self, why)


    def collect_incoming_data(self, data):
        if not self._responsefp:
            raise UnexpectedData("%s '%s' '%s' '%s'" % (self._AsyncHTTPConnection__state, data, self.get_terminator(), self.ac_in_buffer), name = str(self))
        self._responsefp
        self._responsefp.write(data)


    def _no_action(self):
        raise UnexpectedTerminator("%s '%s'" % (self._AsyncHTTPConnection__state, self.get_terminator()), name = str(self))


    def _header_data(self):
        self._responsefp.seek(0)
        self.response._process_response()
        self._willclose = string.lower(self.response.getheader('connection', '')) == 'close'
        transferencoding = string.lower(self.response.getheader('transfer-encoding', ''))
        self._responsefp = StringIO.StringIO()
        if transferencoding:
            if transferencoding == 'chunked':
                self._chunkfp = StringIO.StringIO()
                self.set_terminator('\r\n')
                self._AsyncHTTPConnection__set_state(_STATE_CHUNK_START)
                return None
            raise UnknownTransferEncoding(self.response.getheader('transfer-encoding', ''), name = str(self))
        transferencoding
        contentlengthstr = self.response.getheader('content-length', None)
        if contentlengthstr:
            contentlength = int(contentlengthstr)
        else:
            contentlength = None
        self.set_terminator(contentlength)
        self._AsyncHTTPConnection__set_state(_STATE_REQUESTING_BODY)


    def _body_data(self):
        self.response.body = self._responsefp.getvalue()
        self._responsefp = None
        if self._willclose:
            self.close()

        self._AsyncHTTPConnection__set_state(_STATE_ACTIVE)
        self.handle_response()


    def _get_chunk_size(self):
        splitlist = self._chunkbuffer.lstrip().split('\r\n', 1)
        if len(splitlist) == 1:
            chunkline = splitlist[0]
            self._chunkbuffer = ''
        else:
            (chunkline, self._chunkbuffer) = splitlist
        i = string.find(chunkline, ';')
        if i >= 0:
            chunkline = chunkline[:i]


        try:
            chunksize = string.atoi(chunkline, 16)
        except:
            raise InvalidChunk("Can't compute chunk size from '%s' '%s'" % (chunkline, self._chunkbuffer))

        if self.debuglevel > 0:
            print "chunksize = '%d" % chunksize

        return chunksize


    def _chunk_start_data(self):
        self._chunkbuffer = self._responsefp.getvalue()
        self._chunksize = self._get_chunk_size()
        if self._chunksize == 0:
            if self.debuglevel > 0:
                print '0 size Chunk: ending chunk processing'

            self.response.body = self._chunkfp.getvalue()
            self._chunkfp = None
            self.set_terminator('\r\n\r\n')
            self._responsefp = StringIO.StringIO()
            self._AsyncHTTPConnection__set_state(_STATE_CHUNK_RESIDUE)
            return None
        self.set_terminator(self._chunksize + 2)
        self._responsefp = StringIO.StringIO()
        self._AsyncHTTPConnection__set_state(_STATE_CHUNK_BODY)


    def _chunk_body_data(self):
        self._chunkbuffer += self._responsefp.getvalue()
        while self._chunkbuffer:
            chunk_plus_crlf_size = self._chunksize + 2
            if len(self._chunkbuffer) > chunk_plus_crlf_size:
                chunkbody = self._chunkbuffer[:chunk_plus_crlf_size]
                self._chunkbuffer = self._chunkbuffer[chunk_plus_crlf_size:]
                self._chunkbuffer = self._chunkbuffer.lstrip()
            else:
                chunkbody = self._chunkbuffer
                self._chunkbuffer = ''
            self._chunkfp.write(chunkbody)
            if not self._chunkbuffer:
                break

            if self._chunkbuffer.find('\r\n') < 0:
                self._responsefp = StringIO.StringIO()
                self.set_terminator('\r\n')
                self._AsyncHTTPConnection__set_state(_STATE_CHUNK_START)
                return None
            self._chunksize = self._get_chunk_size()
            if self._chunksize == 0:
                self.response.body = self._chunkfp.getvalue()
                self._chunkfp = None
                if self._chunkbuffer:
                    self._chunkbuffer = ''
                    self._AsyncHTTPConnection__set_state(_STATE_ACTIVE)
                    if self._willclose:
                        self.close()

                    self.handle_response()
                    return None
                self.set_terminator('\r\n\r\n')
                self._responsefp = StringIO.StringIO()
                self._AsyncHTTPConnection__set_state(_STATE_CHUNK_RESIDUE)
                return None
            chunk_plus_crlf_size = self._chunksize + 2
            bufsize = len(self._chunkbuffer)
            if bufsize < chunk_plus_crlf_size:
                self.set_terminator(chunk_plus_crlf_size - bufsize)
                self._responsefp = StringIO.StringIO()
                self._AsyncHTTPConnection__set_state(_STATE_CHUNK_BODY)
                return None
            continue
            bufsize < chunk_plus_crlf_size
        self._responsefp = StringIO.StringIO()
        self.set_terminator('\r\n')
        self._AsyncHTTPConnection__set_state(_STATE_CHUNK_START)


    def _chunk_residue_data(self):
        residue = string.strip(self._responsefp.getvalue())
        if self.debuglevel > 0 and residue:
            print "chunk residue '%s'" % residue

        self._responsefp = None
        if self._willclose:
            self.close()

        self._AsyncHTTPConnection__set_state(_STATE_ACTIVE)
        self.handle_response()


    def handle_response(self):
        raise HandleResponse('Call to AsyncHTTPConnection.handle_response', name = str(self))


    def __set_state(self, next_state):
        if self.debuglevel > 0:
            print '%s to %s' % (self._AsyncHTTPConnection__state, next_state)

        self._AsyncHTTPConnection__state = next_state
        self.found_terminator = self._TERMINATOR_MAP[self._AsyncHTTPConnection__state]



class AsyncHTTPException(Exception):

    def __init__(self, message = '', name = ''):
        self._message = message
        self._name = name


    def __str__(self):
        return '%s %s' % (self._name, self._message)



class NotConnected(AsyncHTTPException):
    pass


class UnknownProtocol(AsyncHTTPException):
    pass


class UnknownTransferEncoding(AsyncHTTPException):
    pass


class BadStatusLine(AsyncHTTPException):
    pass


class ImproperConnectionState(AsyncHTTPException):
    pass


class RequestNotReady(ImproperConnectionState):
    pass


class ResponseNotReady(ImproperConnectionState):
    pass


class HandleResponse(ImproperConnectionState):
    pass


class UnexpectedData(AsyncHTTPException):
    pass


class UnexpectedTerminator(AsyncHTTPException):
    pass


class InvalidChunk(AsyncHTTPException):
    pass


class __test_AsyncHTTPConnection(AsyncHTTPConnection):

    def __init__(self, host, port, url):
        AsyncHTTPConnection.__init__(self, host, port)
        self._url = url


    def handle_response(self):
        self.close()


    def handle_connect(self):
        print '__test_AsyncHTTPConnection.handle_connect'
        AsyncHTTPConnection.handle_connect(self)
        self.putrequest('GET', self._url)
        self.endheaders()
        self.getresponse()


if __name__ == '__main__':
    if len(sys.argv) < 4:
        print 'Usage:  asynchttp.py <host> <port> <request>'
        print "\t\tUsing www.google.com 80 '/'"
        sys.argv[1:] = [
            'www.google.com',
            '80',
            '/']

    tester = __test_AsyncHTTPConnection(sys.argv[1], int(sys.argv[2]), sys.argv[3])
    tester.set_debuglevel(1)
    tester.connect()
    asyncore.loop()
    if not hasattr(tester, 'response'):
        print 'No rsponse'
        sys.exit(-1)

    print 'results %s %d %s' % (tester.response.version, tester.response.status, tester.response.reason)
    print 'headers:'
    for hdr in tester.response.msg.headers:
        print '%s' % string.strip(hdr)

    if tester.response.status == 200:
        print 'body:'
        print tester.response.body