# Copyright 2010, Google Inc.

# All rights reserved.

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions are

# met:

#

#     * Redistributions of source code must retain the above copyright

# notice, this list of conditions and the following disclaimer.

#     * Redistributions in binary form must reproduce the above

# copyright notice, this list of conditions and the following disclaimer

# in the documentation and/or other materials provided with the

# distribution.

#     * Neither the name of Google Inc. nor the names of its

# contributors may be used to endorse or promote products derived from

# this software without specific prior written permission.

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

"""Improved HTTP/1.1 client library

This library contains an HTTPConnection which is similar to the one in

httplib, but has several additional features:

  * supports keepalives natively

  * uses select() to block for incoming data

  * notices when the server responds early to a request

  * implements ssl inline instead of in a different class

"""

from __future__ import absolute_import

# Many functions in this file have too many arguments.

# pylint: disable=R0913

import email

import email.message

import errno

import inspect

import logging

import select

import socket

import ssl

import sys

try:

    import cStringIO as io

    io.StringIO

except ImportError:

    import io

try:

    import httplib

    httplib.HTTPException

except ImportError:

    import http.client as httplib

from . import (

    _readers,

)

logger = logging.getLogger(__name__)

__all__ = ['HTTPConnection', 'HTTPResponse']

HTTP_VER_1_0 = b'HTTP/1.0'

HTTP_VER_1_1 = b'HTTP/1.1'

OUTGOING_BUFFER_SIZE = 1 << 15

INCOMING_BUFFER_SIZE = 1 << 20

HDR_ACCEPT_ENCODING = 'accept-encoding'

HDR_CONNECTION_CTRL = 'connection'

HDR_CONTENT_LENGTH = 'content-length'

HDR_XFER_ENCODING = 'transfer-encoding'

XFER_ENCODING_CHUNKED = 'chunked'

CONNECTION_CLOSE = 'close'

EOL = b'\r\n'

_END_HEADERS = EOL * 2

# Based on some searching around, 1 second seems like a reasonable

# default here.

TIMEOUT_ASSUME_CONTINUE = 1

TIMEOUT_DEFAULT = None

if sys.version_info > (3, 0):

    _unicode = str

else:

    _unicode = unicode

def _ensurebytes(data):

    if not isinstance(data, (_unicode, bytes)):

        data = str(data)

    if not isinstance(data, bytes):

        try:

            return data.encode('latin-1')

        except UnicodeEncodeError as err:

            raise UnicodeEncodeError(

                err.encoding,

                err.object,

                err.start,

                err.end,

                '%r is not valid Latin-1 Use .encode("utf-8") '

                'if sending as utf-8 is desired.' % (

                    data[err.start:err.end],))

    return data

class _CompatMessage(email.message.Message):

    """Workaround for rfc822.Message and email.message.Message API diffs."""

    @classmethod

    def from_string(cls, s):

        if sys.version_info > (3, 0):

            # Python 3 can't decode headers from bytes, so we have to

            # trust RFC 2616 and decode the headers as iso-8859-1

            # bytes.

            s = s.decode('iso-8859-1')

        headers = email.message_from_string(s, _class=_CompatMessage)

        # Fix multi-line headers to match httplib's behavior from

        # Python 2.x, since email.message.Message handles them in

        # slightly different ways.

        if sys.version_info < (3, 0):

            new = []

            for h, v in headers._headers:

                if '\r\n' in v:

                    v = '\n'.join([' ' + x.lstrip() for x in v.split('\r\n')])[1:]

                new.append((h, v))

            headers._headers = new

        return headers

    def getheaders(self, key):

        return self.get_all(key)

    def getheader(self, key, default=None):

        return self.get(key, failobj=default)

class HTTPResponse(object):

    """Response from an HTTP server.

    The response will continue to load as available. If you need the

    complete response before continuing, check the .complete() method.

    """

    def __init__(self, sock, timeout, method):

        self.sock = sock

        self.method = method

        self.raw_response = b''

        self._headers_len = 0

        self.headers = None

        self.will_close = False

        self.status_line = b''

        self.status = None

        self.continued = False

        self.http_version = None

        self.reason = None

        self._reader = None

        self._read_location = 0

        self._eol = EOL

        self._timeout = timeout

    @property

    def _end_headers(self):

        return self._eol * 2

    def complete(self):

        """Returns true if this response is completely loaded.

        Note that if this is a connection where complete means the

        socket is closed, this will nearly always return False, even

        in cases where all the data has actually been loaded.

        """

        if self._reader:

            return self._reader.done()

    def _close(self):

        if self._reader is not None:

            # We're a friend of the reader class here.

            # pylint: disable=W0212

            self._reader._close()

    def getheader(self, header, default=None):

        return self.headers.getheader(header, default=default)

    def getheaders(self):

        if sys.version_info < (3, 0):

            return [(k.lower(), v) for k, v in self.headers.items()]

        # Starting in Python 3, headers aren't lowercased before being

        # returned here.

        return self.headers.items()

    def readline(self):

        """Read a single line from the response body.

        This may block until either a line ending is found or the

        response is complete.

        """

        blocks = []

        while True:

            self._reader.readto(b'\n', blocks)

            if blocks and blocks[-1][-1:] == b'\n' or self.complete():

                break

            self._select()

        return b''.join(blocks)

    def read(self, length=None):

        """Read data from the response body."""

        # if length is None, unbounded read

        while (not self.complete()  # never select on a finished read

               and (not length  # unbounded, so we wait for complete()

                    or length > self._reader.available_data)):

            self._select()

        if not length:

            length = self._reader.available_data

        r = self._reader.read(length)

        if self.complete() and self.will_close:

            self.sock.close()

        return r

    def _select(self):

        r, unused_write, unused_err = select.select(

            [self.sock], [], [], self._timeout)

        if not r:

            # socket was not readable. If the response is not

            # complete, raise a timeout.

            if not self.complete():

                logger.info('timed out with timeout of %s', self._timeout)

                raise HTTPTimeoutException('timeout reading data')

        try:

            data = self.sock.recv(INCOMING_BUFFER_SIZE)

        except ssl.SSLError as e:

            if e.args[0] != ssl.SSL_ERROR_WANT_READ:

                raise

            logger.debug('SSL_ERROR_WANT_READ in _select, should retry later')

            return True

        logger.debug('response read %d data during _select', len(data))

        # If the socket was readable and no data was read, that means

        # the socket was closed. Inform the reader (if any) so it can

        # raise an exception if this is an invalid situation.

        if not data:

            if self._reader:

                # We're a friend of the reader class here.

                # pylint: disable=W0212

                self._reader._close()

            return False

        else:

            self._load_response(data)

            return True

    # This method gets replaced by _load later, which confuses pylint.

    def _load_response(self, data): # pylint: disable=E0202

        # Being here implies we're not at the end of the headers yet,

        # since at the end of this method if headers were completely

        # loaded we replace this method with the load() method of the

        # reader we created.

        self.raw_response += data

        # This is a bogus server with bad line endings

        if self._eol not in self.raw_response:

            for bad_eol in (b'\n', b'\r'):

                if (bad_eol in self.raw_response

                    # verify that bad_eol is not the end of the incoming data

                    # as this could be a response line that just got

                    # split between \r and \n.

                    and (self.raw_response.index(bad_eol) <

                         (len(self.raw_response) - 1))):

                    logger.info('bogus line endings detected, '

                                'using %r for EOL', bad_eol)

                    self._eol = bad_eol

                    break

        # exit early if not at end of headers

        if self._end_headers not in self.raw_response or self.headers:

            return

        # handle 100-continue response

        hdrs, body = self.raw_response.split(self._end_headers, 1)

        unused_http_ver, status = hdrs.split(b' ', 1)

        if status.startswith(b'100'):

            self.raw_response = body

            self.continued = True

            logger.debug('continue seen, setting body to %r', body)

            return

        # arriving here means we should parse response headers

        # as all headers have arrived completely

        hdrs, body = self.raw_response.split(self._end_headers, 1)

        del self.raw_response

        if self._eol in hdrs:

            self.status_line, hdrs = hdrs.split(self._eol, 1)

        else:

            self.status_line = hdrs

            hdrs = b''

        # TODO HTTP < 1.0 support

        (self.http_version, self.status,

         self.reason) = self.status_line.split(b' ', 2)

        self.status = int(self.status)

        if self._eol != EOL:

            hdrs = hdrs.replace(self._eol, b'\r\n')

        headers = _CompatMessage.from_string(hdrs)

        content_len = None

        if HDR_CONTENT_LENGTH in headers:

            content_len = int(headers[HDR_CONTENT_LENGTH])

        if self.http_version == HTTP_VER_1_0:

            self.will_close = True

        elif HDR_CONNECTION_CTRL in headers:

            self.will_close = (

                headers[HDR_CONNECTION_CTRL].lower() == CONNECTION_CLOSE)

        if (HDR_XFER_ENCODING in headers

            and headers[HDR_XFER_ENCODING].lower() == XFER_ENCODING_CHUNKED):

            self._reader = _readers.ChunkedReader(self._eol)

            logger.debug('using a chunked reader')

        else:

            # HEAD responses are forbidden from returning a body, and

            # it's implausible for a CONNECT response to use

            # close-is-end logic for an OK response.

            if (self.method == b'HEAD' or

                (self.method == b'CONNECT' and content_len is None)):

                content_len = 0

            if content_len is not None:

                logger.debug('using a content-length reader with length %d',

                             content_len)

                self._reader = _readers.ContentLengthReader(content_len)

            else:

                # Response body had no length specified and is not

                # chunked, so the end of the body will only be

                # identifiable by the termination of the socket by the

                # server. My interpretation of the spec means that we

                # are correct in hitting this case if

                # transfer-encoding, content-length, and

                # connection-control were left unspecified.

                self._reader = _readers.CloseIsEndReader()

                logger.debug('using a close-is-end reader')

                self.will_close = True

        if body:

            # We're a friend of the reader class here.

            # pylint: disable=W0212

            self._reader._load(body)

        logger.debug('headers complete')

        self.headers = headers

        # We're a friend of the reader class here.

        # pylint: disable=W0212

        self._load_response = self._reader._load

def _foldheaders(headers):

    """Given some headers, rework them so we can safely overwrite values.

    >>> _foldheaders({'Accept-Encoding': 'wat'})

    {'accept-encoding': ('Accept-Encoding', 'wat')}

    """

    return dict((k.lower(), (k, v)) for k, v in headers.items())

try:

    inspect.signature

    def _handlesarg(func, arg):

        """ Try to determine if func accepts arg

        If it takes arg, return True

        If it happens to take **args, then it could do anything:

            * It could throw a different TypeError, just for fun

            * It could throw an ArgumentError or anything else

            * It could choose not to throw an Exception at all

        ... return 'unknown'

        Otherwise, return False

        """

        params = inspect.signature(func).parameters

        if arg in params:

            return True

        for p in params:

            if params[p].kind == inspect._ParameterKind.VAR_KEYWORD:

                return 'unknown'

        return False

except AttributeError:

    def _handlesarg(func, arg):

        """ Try to determine if func accepts arg

        If it takes arg, return True

        If it happens to take **args, then it could do anything:

            * It could throw a different TypeError, just for fun

            * It could throw an ArgumentError or anything else

            * It could choose not to throw an Exception at all

        ... return 'unknown'

        Otherwise, return False

        """

        spec = inspect.getargspec(func)

        if arg in spec.args:

            return True

        if spec.keywords:

            return 'unknown'