"""A high-speed, production ready, thread pooled, generic HTTP server.

Simplest example on how to use this module directly

(without using CherryPy's application machinery)::

    from cherrypy import wsgiserver

    def my_crazy_app(environ, start_response):

        status = '200 OK'

        response_headers = [('Content-type','text/plain')]

        start_response(status, response_headers)

        return ['Hello world!']

    server = wsgiserver.CherryPyWSGIServer(

                ('0.0.0.0', 8070), my_crazy_app,

                server_name='www.cherrypy.example')

    server.start()

The CherryPy WSGI server can serve as many WSGI applications 

as you want in one instance by using a WSGIPathInfoDispatcher::

    d = WSGIPathInfoDispatcher({'/': my_crazy_app, '/blog': my_blog_app})

    server = wsgiserver.CherryPyWSGIServer(('0.0.0.0', 80), d)

Want SSL support? Just set server.ssl_adapter to an SSLAdapter instance.

This won't call the CherryPy engine (application side) at all, only the

HTTP server, which is independent from the rest of CherryPy. Don't

let the name "CherryPyWSGIServer" throw you; the name merely reflects

its origin, not its coupling.

For those of you wanting to understand internals of this module, here's the

basic call flow. The server's listening thread runs a very tight loop,

sticking incoming connections onto a Queue::

    server = CherryPyWSGIServer(...)

    server.start()

    while True:

        tick()

        # This blocks until a request comes in:

        child = socket.accept()

        conn = HTTPConnection(child, ...)

        server.requests.put(conn)

Worker threads are kept in a pool and poll the Queue, popping off and then

handling each connection in turn. Each connection can consist of an arbitrary

number of requests and their responses, so we run a nested loop::

    while True:

        conn = server.requests.get()

        conn.communicate()

        ->  while True:

                req = HTTPRequest(...)

                req.parse_request()

                ->  # Read the Request-Line, e.g. "GET /page HTTP/1.1"

                    req.rfile.readline()

                    read_headers(req.rfile, req.inheaders)

                req.respond()

                ->  response = app(...)

                    try:

                        for chunk in response:

                            if chunk:

                                req.write(chunk)

                    finally:

                        if hasattr(response, "close"):

                            response.close()

                if req.close_connection:

                    return

"""

CRLF = '\r\n'

import os

import Queue

import re

quoted_slash = re.compile("(?i)%2F")

import rfc822

import socket

import sys

if 'win' in sys.platform and not hasattr(socket, 'IPPROTO_IPV6'):

    socket.IPPROTO_IPV6 = 41

try:

    import cStringIO as StringIO

except ImportError:

    import StringIO

DEFAULT_BUFFER_SIZE = -1

_fileobject_uses_str_type = isinstance(socket._fileobject(None)._rbuf, basestring)

import threading

import time

import traceback

def format_exc(limit=None):

    """Like print_exc() but return a string. Backport for Python 2.3."""

    try:

        etype, value, tb = sys.exc_info()

        return ''.join(traceback.format_exception(etype, value, tb, limit))

    finally:

        etype = value = tb = None

from urllib import unquote

from urlparse import urlparse

import warnings

import errno

def plat_specific_errors(*errnames):

    """Return error numbers for all errors in errnames on this platform.

    The 'errno' module contains different global constants depending on

    the specific platform (OS). This function will return the list of

    numeric values for a given list of potential names.

    """

    errno_names = dir(errno)

    nums = [getattr(errno, k) for k in errnames if k in errno_names]

    # de-dupe the list

    return dict.fromkeys(nums).keys()

socket_error_eintr = plat_specific_errors("EINTR", "WSAEINTR")

socket_errors_to_ignore = plat_specific_errors(

    "EPIPE",

    "EBADF", "WSAEBADF",

    "ENOTSOCK", "WSAENOTSOCK",

    "ETIMEDOUT", "WSAETIMEDOUT",

    "ECONNREFUSED", "WSAECONNREFUSED",

    "ECONNRESET", "WSAECONNRESET",

    "ECONNABORTED", "WSAECONNABORTED",

    "ENETRESET", "WSAENETRESET",

    "EHOSTDOWN", "EHOSTUNREACH",

    )

socket_errors_to_ignore.append("timed out")

socket_errors_to_ignore.append("The read operation timed out")

socket_errors_nonblocking = plat_specific_errors(

    'EAGAIN', 'EWOULDBLOCK', 'WSAEWOULDBLOCK')

comma_separated_headers = ['Accept', 'Accept-Charset', 'Accept-Encoding',

    'Accept-Language', 'Accept-Ranges', 'Allow', 'Cache-Control',

    'Connection', 'Content-Encoding', 'Content-Language', 'Expect',

    'If-Match', 'If-None-Match', 'Pragma', 'Proxy-Authenticate', 'TE',

    'Trailer', 'Transfer-Encoding', 'Upgrade', 'Vary', 'Via', 'Warning',

    'WWW-Authenticate']

import logging

if not hasattr(logging, 'statistics'): logging.statistics = {}

def read_headers(rfile, hdict=None):

    """Read headers from the given stream into the given header dict.

    If hdict is None, a new header dict is created. Returns the populated

    header dict.

    Headers which are repeated are folded together using a comma if their

    specification so dictates.

    This function raises ValueError when the read bytes violate the HTTP spec.

    You should probably return "400 Bad Request" if this happens.

    """

    if hdict is None:

        hdict = {}

    while True:

        line = rfile.readline()

        if not line:

            # No more data--illegal end of headers

            raise ValueError("Illegal end of headers.")

        if line == CRLF:

            # Normal end of headers

            break

        if not line.endswith(CRLF):

            raise ValueError("HTTP requires CRLF terminators")

        if line[0] in ' \t':

            # It's a continuation line.

            v = line.strip()

        else:

            try:

                k, v = line.split(":", 1)

            except ValueError:

                raise ValueError("Illegal header line.")

            # TODO: what about TE and WWW-Authenticate?

            k = k.strip().title()

            v = v.strip()

            hname = k

        if k in comma_separated_headers:

            existing = hdict.get(hname)

            if existing:

                v = ", ".join((existing, v))

        hdict[hname] = v

    return hdict

class MaxSizeExceeded(Exception):

    pass

class SizeCheckWrapper(object):

    """Wraps a file-like object, raising MaxSizeExceeded if too large."""

    def __init__(self, rfile, maxlen):

        self.rfile = rfile

        self.maxlen = maxlen

        self.bytes_read = 0

    def _check_length(self):

        if self.maxlen and self.bytes_read > self.maxlen:

            raise MaxSizeExceeded()

    def read(self, size=None):

        data = self.rfile.read(size)

        self.bytes_read += len(data)

        self._check_length()

        return data

    def readline(self, size=None):

        if size is not None:

            data = self.rfile.readline(size)

            self.bytes_read += len(data)

            self._check_length()

            return data

        # User didn't specify a size ...

        # We read the line in chunks to make sure it's not a 100MB line !

        res = []

        while True:

            data = self.rfile.readline(256)

            self.bytes_read += len(data)

            self._check_length()

            res.append(data)

            # See http://www.cherrypy.org/ticket/421

            if len(data) < 256 or data[-1:] == "\n":

                return ''.join(res)

    def readlines(self, sizehint=0):

        # Shamelessly stolen from StringIO

        total = 0

        lines = []

        line = self.readline()

        while line:

            lines.append(line)

            total += len(line)

            if 0 < sizehint <= total:

                break

            line = self.readline()

        return lines

    def close(self):

        self.rfile.close()

    def __iter__(self):

        return self

    def next(self):

        data = self.rfile.next()

        self.bytes_read += len(data)

        self._check_length()

        return data

class KnownLengthRFile(object):

    """Wraps a file-like object, returning an empty string when exhausted."""

    def __init__(self, rfile, content_length):

        self.rfile = rfile

        self.remaining = content_length

    def read(self, size=None):

        if self.remaining == 0:

            return ''

        if size is None:

            size = self.remaining

        else:

            size = min(size, self.remaining)

        data = self.rfile.read(size)

        self.remaining -= len(data)

        return data

    def readline(self, size=None):

        if self.remaining == 0:

            return ''

        if size is None:

            size = self.remaining

        else:

            size = min(size, self.remaining)

        data = self.rfile.readline(size)

        self.remaining -= len(data)

        return data

    def readlines(self, sizehint=0):

        # Shamelessly stolen from StringIO

        total = 0

        lines = []

        line = self.readline(sizehint)

        while line:

            lines.append(line)

            total += len(line)

            if 0 < sizehint <= total:

                break

            line = self.readline(sizehint)

        return lines

    def close(self):

        self.rfile.close()

    def __iter__(self):

        return self

    def __next__(self):

        data = next(self.rfile)

        self.remaining -= len(data)

        return data

class ChunkedRFile(object):

    """Wraps a file-like object, returning an empty string when exhausted.

    This class is intended to provide a conforming wsgi.input value for

    request entities that have been encoded with the 'chunked' transfer

    encoding.

    """

    def __init__(self, rfile, maxlen, bufsize=8192):

        self.rfile = rfile

        self.maxlen = maxlen

        self.bytes_read = 0

        self.buffer = ''

        self.bufsize = bufsize

        self.closed = False

    def _fetch(self):

        if self.closed:

            return

        line = self.rfile.readline()

        self.bytes_read += len(line)

        if self.maxlen and self.bytes_read > self.maxlen:

            raise MaxSizeExceeded("Request Entity Too Large", self.maxlen)

        line = line.strip().split(";", 1)

        try:

            chunk_size = line.pop(0)

            chunk_size = int(chunk_size, 16)

        except ValueError:

            raise ValueError("Bad chunked transfer size: " + repr(chunk_size))

        if chunk_size <= 0:

            self.closed = True

            return

##            if line: chunk_extension = line[0]

        if self.maxlen and self.bytes_read + chunk_size > self.maxlen:

            raise IOError("Request Entity Too Large")

        chunk = self.rfile.read(chunk_size)

        self.bytes_read += len(chunk)

        self.buffer += chunk

        crlf = self.rfile.read(2)

        if crlf != CRLF:

            raise ValueError(

                 "Bad chunked transfer coding (expected '\\r\\n', "

                 "got " + repr(crlf) + ")")

    def read(self, size=None):

        data = ''

        while True:

            if size and len(data) >= size:

                return data

            if not self.buffer:

                self._fetch()

                if not self.buffer:

                    # EOF

                    return data

            if size:

                remaining = size - len(data)

                data += self.buffer[:remaining]

                self.buffer = self.buffer[remaining:]

            else:

                data += self.buffer

    def readline(self, size=None):

        data = ''

        while True:

            if size and len(data) >= size:

                return data

            if not self.buffer:

                self._fetch()

                if not self.buffer:

                    # EOF

                    return data

            newline_pos = self.buffer.find('\n')

            if size:

                if newline_pos == -1:

                    remaining = size - len(data)

                    data += self.buffer[:remaining]

                    self.buffer = self.buffer[remaining:]

                else:

                    remaining = min(size - len(data), newline_pos)

                    data += self.buffer[:remaining]

                    self.buffer = self.buffer[remaining:]

            else:

                if newline_pos == -1:

                    data += self.buffer

                else:

                    data += self.buffer[:newline_pos]

                    self.buffer = self.buffer[newline_pos:]

    def readlines(self, sizehint=0):

        # Shamelessly stolen from StringIO

        total = 0

        lines = []

        line = self.readline(sizehint)

        while line:

            lines.append(line)

            total += len(line)

            if 0 < sizehint <= total:

                break

            line = self.readline(sizehint)

        return lines

    def read_trailer_lines(self):

        if not self.closed:

            raise ValueError(

                "Cannot read trailers until the request body has been read.")

        while True:

            line = self.rfile.readline()

            if not line:

                # No more data--illegal end of headers

                raise ValueError("Illegal end of headers.")

            self.bytes_read += len(line)

            if self.maxlen and self.bytes_read > self.maxlen:

                raise IOError("Request Entity Too Large")

            if line == CRLF:

                # Normal end of headers

                break

            if not line.endswith(CRLF):

                raise ValueError("HTTP requires CRLF terminators")

            yield line

    def close(self):

        self.rfile.close()

    def __iter__(self):

        # Shamelessly stolen from StringIO

        total = 0

        line = self.readline(sizehint)

        while line:

            yield line

            total += len(line)

            if 0 < sizehint <= total:

                break

            line = self.readline(sizehint)

class HTTPRequest(object):

    """An HTTP Request (and response).

    A single HTTP connection may consist of multiple request/response pairs.

    """

    server = None

    """The HTTPServer object which is receiving this request."""

    conn = None

    """The HTTPConnection object on which this request connected."""

    inheaders = {}

    """A dict of request headers."""

    outheaders = []

    """A list of header tuples to write in the response."""

    ready = False

    """When True, the request has been parsed and is ready to begin generating

    the response. When False, signals the calling Connection that the response

    should not be generated and the connection should close."""

    close_connection = False

    """Signals the calling Connection that the request should close. This does

    not imply an error! The client and/or server may each request that the

    connection be closed."""

    chunked_write = False

    """If True, output will be encoded with the "chunked" transfer-coding.

    This value is set automatically inside send_headers."""

    def __init__(self, server, conn):

        self.server= server

        self.conn = conn

        self.ready = False

        self.started_request = False

        self.scheme = "http"

        if self.server.ssl_adapter is not None:

            self.scheme = "https"

        # Use the lowest-common protocol in case read_request_line errors.

        self.response_protocol = 'HTTP/1.0'

        self.inheaders = {}

        self.status = ""

        self.outheaders = []

        self.sent_headers = False

        self.close_connection = self.__class__.close_connection

        self.chunked_read = False

        self.chunked_write = self.__class__.chunked_write

    def parse_request(self):

        """Parse the next HTTP request start-line and message-headers."""

        self.rfile = SizeCheckWrapper(self.conn.rfile,

                                      self.server.max_request_header_size)

        try:

            self.read_request_line()

        except MaxSizeExceeded:

            self.simple_response("414 Request-URI Too Long",

                "The Request-URI sent with the request exceeds the maximum "

                "allowed bytes.")

            return

        try:

            success = self.read_request_headers()

        except MaxSizeExceeded:

            self.simple_response("413 Request Entity Too Large",

                "The headers sent with the request exceed the maximum "

                "allowed bytes.")

            return

        else:

            if not success:

                return

        self.ready = True

    def read_request_line(self):

        # HTTP/1.1 connections are persistent by default. If a client

        # requests a page, then idles (leaves the connection open),

        # then rfile.readline() will raise socket.error("timed out").

        # Note that it does this based on the value given to settimeout(),

        # and doesn't need the client to request or acknowledge the close

        # (although your TCP stack might suffer for it: cf Apache's history

        # with FIN_WAIT_2).

        request_line = self.rfile.readline()

        # Set started_request to True so communicate() knows to send 408

        # from here on out.

        self.started_request = True

        if not request_line:

            # Force self.ready = False so the connection will close.

            self.ready = False

            return

        if request_line == CRLF:

            # RFC 2616 sec 4.1: "...if the server is reading the protocol

            # stream at the beginning of a message and receives a CRLF

            # first, it should ignore the CRLF."

            # But only ignore one leading line! else we enable a DoS.

            request_line = self.rfile.readline()

            if not request_line:

                self.ready = False

                return

        if not request_line.endswith(CRLF):

            self.simple_response("400 Bad Request", "HTTP requires CRLF terminators")

            return

        try:

            method, uri, req_protocol = request_line.strip().split(" ", 2)

            rp = int(req_protocol[5]), int(req_protocol[7])

        except (ValueError, IndexError):

            self.simple_response("400 Bad Request", "Malformed Request-Line")

            return

        self.uri = uri

        self.method = method

        # uri may be an abs_path (including "http://host.domain.tld");

        scheme, authority, path = self.parse_request_uri(uri)

        if '#' in path:

            self.simple_response("400 Bad Request",

                                 "Illegal #fragment in Request-URI.")

            return

        if scheme:

            self.scheme = scheme

        qs = ''

        if '?' in path:

            path, qs = path.split('?', 1)

        # Unquote the path+params (e.g. "/this%20path" -> "/this path").

        # http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html#sec5.1.2

        #

        # But note that "...a URI must be separated into its components

        # before the escaped characters within those components can be

        # safely decoded." http://www.ietf.org/rfc/rfc2396.txt, sec 2.4.2

        # Therefore, "/this%2Fpath" becomes "/this%2Fpath", not "/this/path".

        try:

            atoms = [unquote(x) for x in quoted_slash.split(path)]

        except ValueError, ex:

            self.simple_response("400 Bad Request", ex.args[0])

            return

        path = "%2F".join(atoms)

        self.path = path

        # Note that, like wsgiref and most other HTTP servers,

        # we "% HEX HEX"-unquote the path but not the query string.

        self.qs = qs

        # Compare request and server HTTP protocol versions, in case our

        # server does not support the requested protocol. Limit our output

        # to min(req, server). We want the following output:

        #     request    server     actual written   supported response

        #     protocol   protocol  response protocol    feature set

        # a     1.0        1.0           1.0                1.0

        # b     1.0        1.1           1.1                1.0

        # c     1.1        1.0           1.0                1.0

        # d     1.1        1.1           1.1                1.1

        # Notice that, in (b), the response will be "HTTP/1.1" even though

        # the client only understands 1.0. RFC 2616 10.5.6 says we should

        # only return 505 if the _major_ version is different.

        sp = int(self.server.protocol[5]), int(self.server.protocol[7])

        if sp[0] != rp[0]:

            self.simple_response("505 HTTP Version Not Supported")

            return

        self.request_protocol = req_protocol

        self.response_protocol = "HTTP/%s.%s" % min(rp, sp)

    def read_request_headers(self):

        """Read self.rfile into self.inheaders. Return success."""

        # then all the http headers

        try:

            read_headers(self.rfile, self.inheaders)

        except ValueError, ex:

            self.simple_response("400 Bad Request", ex.args[0])

            return False

        mrbs = self.server.max_request_body_size

        if mrbs and int(self.inheaders.get("Content-Length", 0)) > mrbs:

            self.simple_response("413 Request Entity Too Large",

                "The entity sent with the request exceeds the maximum "

                "allowed bytes.")

            return False

        # Persistent connection support

        if self.response_protocol == "HTTP/1.1":

            # Both server and client are HTTP/1.1

            if self.inheaders.get("Connection", "") == "close":

                self.close_connection = True

        else:

            # Either the server or client (or both) are HTTP/1.0

            if self.inheaders.get("Connection", "") != "Keep-Alive":

                self.close_connection = True

        # Transfer-Encoding support

        te = None

        if self.response_protocol == "HTTP/1.1":

            te = self.inheaders.get("Transfer-Encoding")

            if te:

                te = [x.strip().lower() for x in te.split(",") if x.strip()]

        self.chunked_read = False

        if te:

            for enc in te:

                if enc == "chunked":

                    self.chunked_read = True

                else:

                    # Note that, even if we see "chunked", we must reject

                    # if there is an extension we don't recognize.

                    self.simple_response("501 Unimplemented")

                    self.close_connection = True

                    return False

        # From PEP 333:

        # "Servers and gateways that implement HTTP 1.1 must provide

        # transparent support for HTTP 1.1's "expect/continue" mechanism.

        # This may be done in any of several ways:

        #   1. Respond to requests containing an Expect: 100-continue request

        #      with an immediate "100 Continue" response, and proceed normally.

        #   2. Proceed with the request normally, but provide the application

        #      with a wsgi.input stream that will send the "100 Continue"

        #      response if/when the application first attempts to read from

        #      the input stream. The read request must then remain blocked

        #      until the client responds.

        #   3. Wait until the client decides that the server does not support

        #      expect/continue, and sends the request body on its own.

        #      (This is suboptimal, and is not recommended.)

        #

        # We used to do 3, but are now doing 1. Maybe we'll do 2 someday,

        # but it seems like it would be a big slowdown for such a rare case.

        if self.inheaders.get("Expect", "") == "100-continue":

            # Don't use simple_response here, because it emits headers

            # we don't want. See http://www.cherrypy.org/ticket/951

            msg = self.server.protocol + " 100 Continue\r\n\r\n"

            try:

                self.conn.wfile.sendall(msg)

            except socket.error, x:

                if x.args[0] not in socket_errors_to_ignore:

                    raise

        return True

    def parse_request_uri(self, uri):

        """Parse a Request-URI into (scheme, authority, path).

        Note that Request-URI's must be one of::

            Request-URI    = "*" | absoluteURI | abs_path | authority

        Therefore, a Request-URI which starts with a double forward-slash

        cannot be a "net_path"::

            net_path      = "//" authority [ abs_path ]

        Instead, it must be interpreted as an "abs_path" with an empty first

        path segment::

            abs_path      = "/"  path_segments

            path_segments = segment *( "/" segment )

            segment       = *pchar *( ";" param )

            param         = *pchar

        """

        if uri == "*":

            return None, None, uri

        i = uri.find('://')

        if i > 0 and '?' not in uri[:i]:

            # An absoluteURI.

            # If there's a scheme (and it must be http or https), then:

            # http_URL = "http:" "//" host [ ":" port ] [ abs_path [ "?" query ]]

            scheme, remainder = uri[:i].lower(), uri[i + 3:]

            authority, path = remainder.split("/", 1)

            return scheme, authority, path

        if uri.startswith('/'):

            # An abs_path.

            return None, None, uri

        else:

            # An authority.

            return None, uri, None

    def respond(self):

        """Call the gateway and write its iterable output."""

        mrbs = self.server.max_request_body_size

        if self.chunked_read:

            self.rfile = ChunkedRFile(self.conn.rfile, mrbs)

        else:

            cl = int(self.inheaders.get("Content-Length", 0))

            if mrbs and mrbs < cl:

                if not self.sent_headers:

                    self.simple_response("413 Request Entity Too Large",

                        "The entity sent with the request exceeds the maximum "

                        "allowed bytes.")

                return

            self.rfile = KnownLengthRFile(self.conn.rfile, cl)

        self.server.gateway(self).respond()

        if (self.ready and not self.sent_headers):

            self.sent_headers = True

            self.send_headers()

        if self.chunked_write:

            self.conn.wfile.sendall("0\r\n\r\n")

    def simple_response(self, status, msg=""):

        """Write a simple response back to the client."""

        status = str(status)

        buf = [self.server.protocol + " " +

               status + CRLF,

               "Content-Length: %s\r\n" % len(msg),

               "Content-Type: text/plain\r\n"]

        if status[:3] in ("413", "414"):

            # Request Entity Too Large / Request-URI Too Long

            self.close_connection = True

            if self.response_protocol == 'HTTP/1.1':

                # This will not be true for 414, since read_request_line

                # usually raises 414 before reading the whole line, and we

                # therefore cannot know the proper response_protocol.

                buf.append("Connection: close\r\n")

            else:

                # HTTP/1.0 had no 413/414 status nor Connection header.

                # Emit 400 instead and trust the message body is enough.

                status = "400 Bad Request"

        buf.append(CRLF)

        if msg:

            if isinstance(msg, unicode):

                msg = msg.encode("ISO-8859-1")

            buf.append(msg)

        try:

            self.conn.wfile.sendall("".join(buf))

        except socket.error, x:

            if x.args[0] not in socket_errors_to_ignore:

                raise

    def write(self, chunk):

        """Write unbuffered data to the client."""

        if self.chunked_write and chunk:

            buf = [hex(len(chunk))[2:], CRLF, chunk, CRLF]

            self.conn.wfile.sendall("".join(buf))

        else:

            self.conn.wfile.sendall(chunk)

    def send_headers(self):

        """Assert, process, and send the HTTP response message-headers.

        You must set self.status, and self.outheaders before calling this.

        """

        hkeys = [key.lower() for key, value in self.outheaders]

        status = int(self.status[:3])

        if status == 413:

            # Request Entity Too Large. Close conn to avoid garbage.

            self.close_connection = True

        elif "content-length" not in hkeys:

            # "All 1xx (informational), 204 (no content),

            # and 304 (not modified) responses MUST NOT

            # include a message-body." So no point chunking.

            if status < 200 or status in (204, 205, 304):

                pass

            else:

                if (self.response_protocol == 'HTTP/1.1'

                    and self.method != 'HEAD'):

                    # Use the chunked transfer-coding

                    self.chunked_write = True

                    self.outheaders.append(("Transfer-Encoding", "chunked"))

                else:

                    # Closing the conn is the only way to determine len.

                    self.close_connection = True

        if "connection" not in hkeys:

            if self.response_protocol == 'HTTP/1.1':

                # Both server and client are HTTP/1.1 or better

                if self.close_connection:

                    self.outheaders.append(("Connection", "close"))

            else:

                # Server and/or client are HTTP/1.0

                if not self.close_connection:

                    self.outheaders.append(("Connection", "Keep-Alive"))

        if (not self.close_connection) and (not self.chunked_read):

            # Read any remaining request body data on the socket.

            # "If an origin server receives a request that does not include an

            # Expect request-header field with the "100-continue" expectation,

            # the request includes a request body, and the server responds

            # with a final status code before reading the entire request body

            # from the transport connection, then the server SHOULD NOT close

            # the transport connection until it has read the entire request,

            # or until the client closes the connection. Otherwise, the client

            # might not reliably receive the response message. However, this

            # requirement is not be construed as preventing a server from

            # defending itself against denial-of-service attacks, or from

            # badly broken client implementations."

            remaining = getattr(self.rfile, 'remaining', 0)

            if remaining > 0:

                self.rfile.read(remaining)

        if "date" not in hkeys:

            self.outheaders.append(("Date", rfc822.formatdate()))

        if "server" not in hkeys:

            self.outheaders.append(("Server", self.server.server_name))

        buf = [self.server.protocol + " " + self.status + CRLF]

        for k, v in self.outheaders:

            buf.append(k + ": " + v + CRLF)

        buf.append(CRLF)

        self.conn.wfile.sendall("".join(buf))

class NoSSLError(Exception):

    """Exception raised when a client speaks HTTP to an HTTPS socket."""

    pass

class FatalSSLAlert(Exception):

    """Exception raised when the SSL implementation signals a fatal alert."""

    pass

class CP_fileobject(socket._fileobject):

    """Faux file object attached to a socket object."""

    def __init__(self, *args, **kwargs):

        self.bytes_read = 0

        self.bytes_written = 0

        socket._fileobject.__init__(self, *args, **kwargs)

    def sendall(self, data):

        """Sendall for non-blocking sockets."""

        while data:

            try:

                bytes_sent = self.send(data)

                data = data[bytes_sent:]

            except socket.error, e:

                if e.args[0] not in socket_errors_nonblocking:

                    raise

    def send(self, data):

        bytes_sent = self._sock.send(data)

        self.bytes_written += bytes_sent

        return bytes_sent

    def flush(self):

        if self._wbuf:

            buffer = "".join(self._wbuf)

            self._wbuf = []

            self.sendall(buffer)

    def recv(self, size):

        while True:

            try:

                data = self._sock.recv(size)

                self.bytes_read += len(data)

                return data

            except socket.error, e:

                if (e.args[0] not in socket_errors_nonblocking

                    and e.args[0] not in socket_error_eintr):

                    raise

    if not _fileobject_uses_str_type:

        def read(self, size=-1):

            # Use max, disallow tiny reads in a loop as they are very inefficient.

            # We never leave read() with any leftover data from a new recv() call

            # in our internal buffer.

            rbufsize = max(self._rbufsize, self.default_bufsize)

            # Our use of StringIO rather than lists of string objects returned by

            # recv() minimizes memory usage and fragmentation that occurs when

            # rbufsize is large compared to the typical return value of recv().

            buf = self._rbuf

            buf.seek(0, 2)  # seek end

            if size < 0:

                # Read until EOF

                self._rbuf = StringIO.StringIO()  # reset _rbuf.  we consume it via buf.

                while True:

                    data = self.recv(rbufsize)

                    if not data:

                        break

                    buf.write(data)

                return buf.getvalue()

            else:

                # Read until size bytes or EOF seen, whichever comes first

                buf_len = buf.tell()

                if buf_len >= size:

                    # Already have size bytes in our buffer?  Extract and return.

                    buf.seek(0)

                    rv = buf.read(size)

                    self._rbuf = StringIO.StringIO()

                    self._rbuf.write(buf.read())

                    return rv

                self._rbuf = StringIO.StringIO()  # reset _rbuf.  we consume it via buf.

                while True:

                    left = size - buf_len

                    # recv() will malloc the amount of memory given as its

                    # parameter even though it often returns much less data

                    # than that.  The returned data string is short lived

                    # as we copy it into a StringIO and free it.  This avoids

                    # fragmentation issues on many platforms.

                    data = self.recv(left)

                    if not data:

                        break

                    n = len(data)

                    if n == size and not buf_len:

                        # Shortcut.  Avoid buffer data copies when:

                        # - We have no data in our buffer.

                        # AND

                        # - Our call to recv returned exactly the

                        #   number of bytes we were asked to read.

                        return data

                    if n == left:

                        buf.write(data)

                        del data  # explicit free

                        break