Based on the original, available at https://github.com/python/cpython/blob/2.7/Lib/SimpleXMLRPCServer.py

        Only difference is that it denies requests bigger than a certain size.

        Handles the HTTP POST request.
        Attempts to interpret all HTTP POST requests as XML-RPC calls,
        which are forwarded to the server's _dispatch method for handling.

def do_POST(self):
        """
        Based on the original, available at https://github.com/python/cpython/blob/2.7/Lib/SimpleXMLRPCServer.py

        Only difference is that it denies requests bigger than a certain size.

        Handles the HTTP POST request.
        Attempts to interpret all HTTP POST requests as XML-RPC calls,
        which are forwarded to the server's _dispatch method for handling.
        """

        # Check that the path is legal
        if not self.is_rpc_path_valid():
            self.report_404()
            return

        # reject gzip, so size-caps will work
        encoding = self.headers.get("content-encoding", "identity").lower()
        if encoding != 'identity':
            log.error("Reject request with encoding '{}'".format(encoding))
            self.send_response(501, "encoding %r not supported" % encoding)
            return

        try:
            size_remaining = int(self.headers["content-length"])
            if size_remaining > self.MAX_REQUEST_SIZE:
                if os.environ.get("BLOCKSTACK_DEBUG") == "1":
                    log.error("Request is too big!")

                self.send_response(400)
                self.send_header('Content-length', '0')
                self.end_headers()
                return

            if os.environ.get("BLOCKSTACK_DEBUG") == "1":
                log.debug("Message is small enough to parse ({} bytes)".format(size_remaining))

            # Get arguments by reading body of request.
            # never read more than our max size
            L = []
            while size_remaining:
                chunk_size = min(size_remaining, self.MAX_REQUEST_SIZE)
                chunk = self.rfile.read(chunk_size)
                if not chunk:
                    break
                L.append(chunk)
                size_remaining -= len(L[-1])

            data = ''.join(L)

            data = self.decode_request_content(data)
            if data is None:
                return #response has been sent

            # In previous versions of SimpleXMLRPCServer, _dispatch
            # could be overridden in this class, instead of in
            # SimpleXMLRPCDispatcher. To maintain backwards compatibility,
            # check to see if a subclass implements _dispatch and dispatch
            # using that method if present.
            response = self.server._marshaled_dispatch(
                    data, getattr(self, '_dispatch', None), self.path
                )

        except Exception, e: # This should only happen if the module is buggy
            # internal error, report as HTTP server error
            self.send_response(500)
            self.send_header("Content-length", "0")
            self.end_headers()

        else:
            # got a valid XML RPC response
            self.send_response(200)
            self.send_header("Content-type", "text/xml")
            if self.encode_threshold is not None:
                if len(response) > self.encode_threshold:
                    q = self.accept_encodings().get("gzip", 0)
                    if q:
                        try:
                            response = xmlrpclib.gzip_encode(response)
                            self.send_header("Content-Encoding", "gzip")
                        except NotImplementedError:
                            pass

            self.send_header("Content-length", str(len(response)))
            self.end_headers()
            self.wfile.write(response)