def get_file_upload(self): try: if (int(self.request.arguments['flowTotalSize'][0]) / (1024 * 1024)) > GLSetting.defaults.maximum_filesize: log.err("File upload request rejected: file too big") raise errors.FileTooBig if self.request.arguments['flowIdentifier'][0] not in GLUploads: f = GLSecureTemporaryFile(GLSetting.tmp_upload_path) GLUploads[self.request.arguments['flowIdentifier'][0]] = f else: f = GLUploads[self.request.arguments['flowIdentifier'][0]] f.write(self.request.files['file'][0]['body']) if self.request.arguments['flowChunkNumber'][0] != self.request.arguments['flowTotalChunks'][0]: return None uploaded_file = {} uploaded_file['filename'] = self.request.files['file'][0]['filename'] uploaded_file['content_type'] = self.request.files['file'][0]['content_type'] uploaded_file['body_len'] = int(self.request.arguments['flowTotalSize'][0]) uploaded_file['body_filepath'] = f.filepath uploaded_file['body'] = f return uploaded_file except errors.FileTooBig: raise # propagate the exception except Exception as exc: log.err("Error while handling file upload %s" % exc) return None
def get_dummy_file(self, filename=None, content_type=None, content=None): if filename is None: filename = ''.join(unichr(x) for x in range(0x400, 0x40A)) if content_type is None: content_type = 'application/octet' if content is None: content = 'LA VEDI LA SUPERCAZZOLA ? PREMATURA ? unicode €' temporary_file = GLSecureTemporaryFile(GLSettings.tmp_upload_path) temporary_file.write(content) temporary_file.avoid_delete() dummy_file = { 'body': temporary_file, 'body_len': len(content), 'body_filepath': temporary_file.filepath, 'filename': filename, 'content_type': content_type, 'submission': False } return dummy_file
def get_dummy_file(self, filename=None, content_type=None, content=None): if filename is None: filename = ''.join(unichr(x) for x in range(0x400, 0x40A)) if content_type is None: content_type = 'application/octet' if content is None: content = "ANTANI" temporary_file = GLSecureTemporaryFile(GLSetting.tmp_upload_path) temporary_file.write(content) temporary_file.avoid_delete() dummy_file = { 'body': temporary_file, 'body_len': len(content), 'body_filepath': temporary_file.filepath, 'filename': filename, 'content_type': content_type, } return dummy_file
def get_file_upload(self): try: if (int(self.request.arguments['flowTotalSize'][0]) / (1024 * 1024)) > GLSettings.memory_copy.maximum_filesize: log.err("File upload request rejected: file too big") raise errors.FileTooBig(GLSettings.memory_copy.maximum_filesize) if self.request.arguments['flowIdentifier'][0] not in GLUploads: f = GLSecureTemporaryFile(GLSettings.tmp_upload_path) GLUploads[self.request.arguments['flowIdentifier'][0]] = f else: f = GLUploads[self.request.arguments['flowIdentifier'][0]] f.write(self.request.files['file'][0]['body']) if self.request.arguments['flowChunkNumber'][0] != self.request.arguments['flowTotalChunks'][0]: return None uploaded_file = {} uploaded_file['filename'] = self.request.files['file'][0]['filename'] uploaded_file['content_type'] = self.request.files['file'][0]['content_type'] uploaded_file['body_len'] = int(self.request.arguments['flowTotalSize'][0]) uploaded_file['body_filepath'] = f.filepath uploaded_file['body'] = f return uploaded_file except errors.FileTooBig: raise # propagate the exception except Exception as exc: log.err("Error while handling file upload %s" % exc) return None
def get_file_upload(self): try: if len(self.request.files) != 1: raise errors.InvalidInputFormat( "cannot accept more than a file upload at once") chunk_size = len(self.request.files['file'][0]['body']) total_file_size = int( self.request.arguments['flowTotalSize'][0] ) if 'flowTotalSize' in self.request.arguments else chunk_size flow_identifier = self.request.arguments['flowIdentifier'][ 0] if 'flowIdentifier' in self.request.arguments else generateRandomKey( 10) if ((chunk_size / (1024 * 1024)) > GLSettings.memory_copy.maximum_filesize or (total_file_size / (1024 * 1024)) > GLSettings.memory_copy.maximum_filesize): log.err("File upload request rejected: file too big") raise errors.FileTooBig( GLSettings.memory_copy.maximum_filesize) if flow_identifier not in GLUploads: f = GLSecureTemporaryFile(GLSettings.tmp_upload_path) GLUploads[flow_identifier] = f else: f = GLUploads[flow_identifier] f.write(self.request.files['file'][0]['body']) if 'flowChunkNumber' in self.request.arguments and 'flowTotalChunks' in self.request.arguments: if self.request.arguments['flowChunkNumber'][ 0] != self.request.arguments['flowTotalChunks'][0]: return None uploaded_file = {} uploaded_file['filename'] = self.request.files['file'][0][ 'filename'] uploaded_file['content_type'] = self.request.files['file'][0][ 'content_type'] uploaded_file['body_len'] = total_file_size uploaded_file['body_filepath'] = f.filepath uploaded_file['body'] = f upload_time = time.time() - f.creation_date track_handler(self) return uploaded_file except errors.FileTooBig: raise # propagate the exception except Exception as exc: log.err("Error while handling file upload %s" % exc) return None
def test_temporary_file_lost_key_due_to_eventual_bug_or_reboot(self): a = GLSecureTemporaryFile(GLSettings.tmp_upload_path) a.avoid_delete() antani = "0123456789" * 10000 a.write(antani) a.close() self.assertTrue(os.path.exists(a.filepath)) os.remove(a.keypath) self.assertRaises(IOError, GLSecureFile, a.filepath) a.close()
def get_file_upload(self): try: if len(self.request.files) != 1: raise errors.InvalidInputFormat("cannot accept more than a file upload at once") ############################################################### # checks needed in order to offer compatibility with flow.js/fusty-flow.js chunk_size = len(self.request.files['file'][0]['body']) total_file_size = int(self.request.arguments['flowTotalSize'][0]) if 'flowTotalSize' in self.request.arguments else chunk_size flow_identifier = self.request.arguments['flowIdentifier'][0] if 'flowIdentifier' in self.request.arguments else os.random() if 'flowChunkNumber' in self.request.arguments and 'flowTotalChunks' in self.request.arguments: if self.request.arguments['flowChunkNumber'][0] != self.request.arguments['flowTotalChunks'][0]: return None ############################################################### if ((chunk_size / (1024 * 1024)) > GLSettings.memory_copy.maximum_filesize or (total_file_size / (1024 * 1024)) > GLSettings.memory_copy.maximum_filesize): log.err("File upload request rejected: file too big") raise errors.FileTooBig(GLSettings.memory_copy.maximum_filesize) if flow_identifier not in GLUploads: f = GLSecureTemporaryFile(GLSettings.tmp_upload_path) GLUploads[flow_identifier] = f else: f = GLUploads[flow_identifier] f.write(self.request.files['file'][0]['body']) uploaded_file = {} uploaded_file['filename'] = self.request.files['file'][0]['filename'] uploaded_file['content_type'] = self.request.files['file'][0]['content_type'] uploaded_file['body_len'] = total_file_size uploaded_file['body_filepath'] = f.filepath uploaded_file['body'] = f upload_time = time.time() - f.creation_date # file uploads works on chunk basis so that we count 1 the file upload # as a whole in function get_file_upload() for event in outcoming_event_monitored: if event['status_checker'](self._status_code) and \ event['method'] == self.request.method and \ event['handler_check'](self.request.uri): EventTrack(event, upload_time) return uploaded_file except errors.FileTooBig: raise # propagate the exception except Exception as exc: log.err("Error while handling file upload %s" % exc) return None
def get_file_upload(self): try: if len(self.request.files) != 1: raise errors.InvalidInputFormat("cannot accept more than a file upload at once") chunk_size = len(self.request.files['file'][0]['body']) total_file_size = int(self.request.arguments['flowTotalSize'][0]) if 'flowTotalSize' in self.request.arguments else chunk_size flow_identifier = self.request.arguments['flowIdentifier'][0] if 'flowIdentifier' in self.request.arguments else generateRandomKey(10) if ((chunk_size / (1024 * 1024)) > GLSettings.memory_copy.maximum_filesize or (total_file_size / (1024 * 1024)) > GLSettings.memory_copy.maximum_filesize): log.err("File upload request rejected: file too big") raise errors.FileTooBig(GLSettings.memory_copy.maximum_filesize) if flow_identifier not in GLUploads: f = GLSecureTemporaryFile(GLSettings.tmp_upload_path) GLUploads[flow_identifier] = f else: f = GLUploads[flow_identifier] f.write(self.request.files['file'][0]['body']) if 'flowChunkNumber' in self.request.arguments and 'flowTotalChunks' in self.request.arguments: if self.request.arguments['flowChunkNumber'][0] != self.request.arguments['flowTotalChunks'][0]: return None uploaded_file = {} uploaded_file['filename'] = self.request.files['file'][0]['filename'] uploaded_file['content_type'] = self.request.files['file'][0]['content_type'] uploaded_file['body_len'] = total_file_size uploaded_file['body_filepath'] = f.filepath uploaded_file['body'] = f upload_time = time.time() - f.creation_date # file uploads works on chunk basis so that we count 1 the file upload # as a whole in function get_file_upload() for event in outcoming_event_monitored: if event['status_checker'](self._status_code) and \ event['method'] == self.request.method and \ event['handler_check'](self.request.uri): EventTrack(event, upload_time) return uploaded_file except errors.FileTooBig: raise # propagate the exception except Exception as exc: log.err("Error while handling file upload %s" % exc) return None
def get_file_upload(self): try: chunk_size = len(self.request.args['file'][0]) total_file_size = int( self.request.args['flowTotalSize'] [0]) if 'flowTotalSize' in self.request.args else chunk_size flow_identifier = self.request.args['flowIdentifier'][ 0] if 'flowIdentifier' in self.request.args else generateRandomKey( 10) if ((chunk_size / (1024 * 1024)) > GLSettings.memory_copy.maximum_filesize or (total_file_size / (1024 * 1024)) > GLSettings.memory_copy.maximum_filesize): log.err("File upload request rejected: file too big") raise errors.FileTooBig( GLSettings.memory_copy.maximum_filesize) if flow_identifier not in GLUploads: f = GLSecureTemporaryFile(GLSettings.tmp_upload_path) GLUploads[flow_identifier] = f else: f = GLUploads[flow_identifier] f.write(self.request.args['file'][0]) if 'flowChunkNumber' in self.request.args and 'flowTotalChunks' in self.request.args: if self.request.args['flowChunkNumber'][ 0] != self.request.args['flowTotalChunks'][0]: return None mime_type, encoding = mimetypes.guess_type( self.request.args['flowFilename'][0]) uploaded_file = { 'name': self.request.args['flowFilename'][0], 'type': mime_type, 'size': total_file_size, 'path': f.filepath, 'body': f, 'description': self.request.args.get('description', [''])[0] } return uploaded_file except errors.FileTooBig: raise # propagate the exception except Exception as exc: log.err("Error while handling file upload %s" % exc) return None
def get_file_upload(self): try: if (int(self.request.arguments['flowTotalSize'][0]) / (1024 * 1024)) > GLSettings.memory_copy.maximum_filesize: log.err("File upload request rejected: file too big") raise errors.FileTooBig( GLSettings.memory_copy.maximum_filesize) if self.request.arguments['flowIdentifier'][0] not in GLUploads: f = GLSecureTemporaryFile(GLSettings.tmp_upload_path) GLUploads[self.request.arguments['flowIdentifier'][0]] = f else: f = GLUploads[self.request.arguments['flowIdentifier'][0]] f.write(self.request.files['file'][0]['body']) if self.request.arguments['flowChunkNumber'][ 0] != self.request.arguments['flowTotalChunks'][0]: return None uploaded_file = {} uploaded_file['filename'] = self.request.files['file'][0][ 'filename'] uploaded_file['content_type'] = self.request.files['file'][0][ 'content_type'] uploaded_file['body_len'] = int( self.request.arguments['flowTotalSize'][0]) uploaded_file['body_filepath'] = f.filepath uploaded_file['body'] = f upload_time = time.time() - f.creation_date # file uploads works on chunk basis so that we count 1 the file upload # as a whole in function get_file_upload() for event in outcoming_event_monitored: if event['status_checker'](self._status_code) and \ event['method'] == self.request.method and \ event['handler_check'](self.request.uri): EventTrack(event, upload_time) return uploaded_file except errors.FileTooBig: raise # propagate the exception except Exception as exc: log.err("Error while handling file upload %s" % exc) return None
def get_file_upload(self): try: if len(self.request.files) != 1: raise errors.InvalidInputFormat("cannot accept more than a file upload at once") chunk_size = len(self.request.files['file'][0]['body']) total_file_size = int(self.request.arguments['flowTotalSize'][0]) if 'flowTotalSize' in self.request.arguments else chunk_size flow_identifier = self.request.arguments['flowIdentifier'][0] if 'flowIdentifier' in self.request.arguments else generateRandomKey(10) if ((chunk_size / (1024 * 1024)) > GLSettings.memory_copy.maximum_filesize or (total_file_size / (1024 * 1024)) > GLSettings.memory_copy.maximum_filesize): log.err("File upload request rejected: file too big") raise errors.FileTooBig(GLSettings.memory_copy.maximum_filesize) if flow_identifier not in GLUploads: f = GLSecureTemporaryFile(GLSettings.tmp_upload_path) GLUploads[flow_identifier] = f else: f = GLUploads[flow_identifier] f.write(self.request.files['file'][0]['body']) if 'flowChunkNumber' in self.request.arguments and 'flowTotalChunks' in self.request.arguments: if self.request.arguments['flowChunkNumber'][0] != self.request.arguments['flowTotalChunks'][0]: return None uploaded_file = { 'name': self.request.files['file'][0]['filename'], 'type': self.request.files['file'][0]['content_type'], 'size': total_file_size, 'path': f.filepath, 'body': f, 'description': self.request.arguments.get('description', [''])[0] } self.request._start_time = f.creation_date track_handler(self) return uploaded_file except errors.FileTooBig: raise # propagate the exception except Exception as exc: log.err("Error while handling file upload %s" % exc) return None
def test_003_temporary_file_avoid_delete(self): a = GLSecureTemporaryFile(GLSetting.tmp_upload_path) a.avoid_delete() antani = "0123456789" * 10000 a.write(antani) a.close() self.assertTrue(os.path.exists(a.filepath)) b = GLSecureFile(a.filepath) self.assertTrue(antani == b.read())
def test_temporary_file(self): a = GLSecureTemporaryFile(GLSettings.tmp_upload_path) antani = "0123456789" * 10000 a.write(antani) self.assertTrue(antani == a.read()) a.close() self.assertFalse(os.path.exists(a.filepath))
def test_temporary_file_write_after_read(self): a = GLSecureTemporaryFile(GLSettings.tmp_upload_path) antani = "0123456789" * 10000 a.write(antani) self.assertTrue(antani == a.read()) self.assertRaises(AssertionError, a.write, antani) a.close()
def get_file_upload(self): try: if (int(self.request.arguments['flowTotalSize'][0]) / (1024 * 1024)) > GLSettings.memory_copy.maximum_filesize: log.err("File upload request rejected: file too big") raise errors.FileTooBig(GLSettings.memory_copy.maximum_filesize) if self.request.arguments['flowIdentifier'][0] not in GLUploads: f = GLSecureTemporaryFile(GLSettings.tmp_upload_path) GLUploads[self.request.arguments['flowIdentifier'][0]] = f else: f = GLUploads[self.request.arguments['flowIdentifier'][0]] f.write(self.request.files['file'][0]['body']) if self.request.arguments['flowChunkNumber'][0] != self.request.arguments['flowTotalChunks'][0]: return None uploaded_file = {} uploaded_file['filename'] = self.request.files['file'][0]['filename'] uploaded_file['content_type'] = self.request.files['file'][0]['content_type'] uploaded_file['body_len'] = int(self.request.arguments['flowTotalSize'][0]) uploaded_file['body_filepath'] = f.filepath uploaded_file['body'] = f upload_time = time.time() - f.creation_date # file uploads works on chunk basis so that we count 1 the file upload # as a whole in function get_file_upload() for event in outcoming_event_monitored: if event['status_checker'](self._status_code) and \ event['method'] == self.request.method and \ event['handler_check'](self.request.uri): EventTrack(event, upload_time) return uploaded_file except errors.FileTooBig: raise # propagate the exception except Exception as exc: log.err("Error while handling file upload %s" % exc) return None
def get_dummy_file(filename=None, content_type=None, content=None): filename = ''.join(unichr(x) for x in range(0x400, 0x40A)) content_type = 'application/octet' content = ''.join(unichr(x) for x in range(0x400, 0x40A)) temporary_file = GLSecureTemporaryFile(GLSettings.tmp_upload_path) temporary_file.write(content) temporary_file.avoid_delete() return { 'body': temporary_file, 'body_len': len(content), 'body_filepath': temporary_file.filepath, 'filename': filename, 'content_type': content_type, 'submission': False }
def _on_headers(self, data): try: data = native_str(data.decode("latin1")) eol = data.find("\r\n") start_line = data[:eol] try: method, uri, version = start_line.split(" ") except ValueError: raise _BadRequestException("Malformed HTTP request line") if not version.startswith("HTTP/"): raise _BadRequestException( "Malformed HTTP version in HTTP Request-Line") try: headers = httputil.HTTPHeaders.parse(data[eol:]) content_length = int(headers.get("Content-Length", 0)) except ValueError: raise _BadRequestException("Malformed Content-Length header") self._request = HTTPRequest(connection=self, method=method, uri=uri, version=version, headers=headers, remote_ip=self._remote_ip) if content_length: megabytes = int(content_length) / (1024 * 1024) if megabytes > GLSettings.memory_copy.maximum_filesize: raise _BadRequestException( "Request exceeded size limit %d" % GLSettings.memory_copy.maximum_filesize) if headers.get("Expect") == "100-continue": self.transport.write("HTTP/1.1 100 (Continue)\r\n\r\n") if content_length < 100000: self._contentbuffer = StringIO() else: self._contentbuffer = GLSecureTemporaryFile( GLSettings.tmp_upload_path) self.content_length = content_length self.setRawMode() return self.request_callback(self._request) except _BadRequestException as e: log.msg("Exception while handling HTTP request from %s: %s" % (self._remote_ip, e)) self.transport.loseConnection()
def get_dummy_file(filename=None, content_type=None, content=None): global files_count files_count += 1 filename = ''.join(unichr(x) for x in range(0x400, 0x40A)).join('-%d' % files_count) content_type = 'application/octet' content = ''.join(unichr(x) for x in range(0x400, 0x40A)) temporary_file = GLSecureTemporaryFile(GLSettings.tmp_upload_path) temporary_file.write(content) temporary_file.avoid_delete() return { 'name': filename, 'description': 'description', 'body': temporary_file, 'size': len(content), 'path': temporary_file.filepath, 'type': content_type, 'submission': False }
def get_file_upload(self): if 'flowFilename' not in self.request.args: return None total_file_size = int(self.request.args['flowTotalSize'][0]) flow_identifier = self.request.args['flowIdentifier'][0] chunk_size = len(self.request.args['file'][0]) if ((chunk_size / (1024 * 1024)) > GLSettings.memory_copy.maximum_filesize or (total_file_size / (1024 * 1024)) > GLSettings.memory_copy.maximum_filesize): log.err("File upload request rejected: file too big") raise errors.FileTooBig(GLSettings.memory_copy.maximum_filesize) if flow_identifier not in GLUploads: GLUploads[flow_identifier] = GLSecureTemporaryFile( GLSettings.tmp_upload_path) f = GLUploads[flow_identifier] f.write(self.request.args['file'][0]) if self.request.args['flowChunkNumber'][0] != self.request.args[ 'flowTotalChunks'][0]: return None mime_type, encoding = mimetypes.guess_type( self.request.args['flowFilename'][0]) if mime_type is None: mime_type = 'application/octet-stream' return { 'name': self.request.args['flowFilename'][0], 'type': mime_type, 'size': total_file_size, 'path': f.filepath, 'body': f, 'description': self.request.args.get('description', [''])[0] }
def test_post(self): temporary_file = GLSecureTemporaryFile(GLSetting.tmp_upload_path) temporary_file.write("ANTANI") temporary_file.avoid_delete() request_body = { 'body': temporary_file, 'body_len': len("ANTANI"), 'body_filepath': temporary_file.filepath, 'filename': 'en.json', 'content_type': 'application/json' } handler = self.request({}, role='admin', kwargs={'path': GLSetting.static_path}, body=request_body) yield handler.post(lang='en') self.assertTrue(isinstance(self.responses, list)) self.assertEqual(len(self.responses), 1) self._handler.validate_message(json.dumps(self.responses[0]), requests.staticFile)
def get_file_upload(self): try: if len(self.request.files) != 1: raise errors.InvalidInputFormat("cannot accept more than a file upload at once") chunk_size = len(self.request.files["file"][0]["body"]) total_file_size = ( int(self.request.arguments["flowTotalSize"][0]) if "flowTotalSize" in self.request.arguments else chunk_size ) flow_identifier = ( self.request.arguments["flowIdentifier"][0] if "flowIdentifier" in self.request.arguments else generateRandomKey(10) ) if (chunk_size / (1024 * 1024)) > GLSettings.memory_copy.maximum_filesize or ( total_file_size / (1024 * 1024) ) > GLSettings.memory_copy.maximum_filesize: log.err("File upload request rejected: file too big") raise errors.FileTooBig(GLSettings.memory_copy.maximum_filesize) if flow_identifier not in GLUploads: f = GLSecureTemporaryFile(GLSettings.tmp_upload_path) GLUploads[flow_identifier] = f else: f = GLUploads[flow_identifier] f.write(self.request.files["file"][0]["body"]) if "flowChunkNumber" in self.request.arguments and "flowTotalChunks" in self.request.arguments: if self.request.arguments["flowChunkNumber"][0] != self.request.arguments["flowTotalChunks"][0]: return None uploaded_file = {} uploaded_file["filename"] = self.request.files["file"][0]["filename"] uploaded_file["content_type"] = self.request.files["file"][0]["content_type"] uploaded_file["body_len"] = total_file_size uploaded_file["body_filepath"] = f.filepath uploaded_file["body"] = f upload_time = time.time() - f.creation_date # file uploads works on chunk basis so that we count 1 the file upload # as a whole in function get_file_upload() for event in outcoming_event_monitored: if ( event["status_checker"](self._status_code) and event["method"] == self.request.method and event["handler_check"](self.request.uri) ): EventTrack(event, upload_time) return uploaded_file except errors.FileTooBig: raise # propagate the exception except Exception as exc: log.err("Error while handling file upload %s" % exc) return None
def _on_headers(self, data): try: data = native_str(data.decode("latin1")) eol = data.find("\r\n") start_line = data[:eol] try: method, uri, version = start_line.split(" ") except ValueError: raise _BadRequestException("Malformed HTTP request line") if not version.startswith("HTTP/"): raise _BadRequestException( "Malformed HTTP version in HTTP Request-Line") headers = httputil.HTTPHeaders.parse(data[eol:]) self._request = HTTPRequest( connection=self, method=method, uri=uri, version=version, headers=headers, remote_ip=self._remote_ip) try: self.content_length = int(headers.get("Content-Length", 0)) except ValueError: raise _BadRequestException("Malformed Content-Length header") # we always use secure temporary files in case of large json or file uploads if self.content_length < 100000 and self._request.headers.get("Content-Disposition") is None: self._contentbuffer = StringIO('') else: self._contentbuffer = GLSecureTemporaryFile(GLSetting.tmp_upload_path) if headers.get("Expect") == "100-continue": self.transport.write("HTTP/1.1 100 (Continue)\r\n\r\n") c_d_header = self._request.headers.get("Content-Disposition") if c_d_header is not None: key, pdict = parse_header(c_d_header) if key != 'attachment' or 'filename' not in pdict: raise _BadRequestException("Malformed Content-Disposition header") self.file_upload = True self.uploaded_file['filename'] = pdict['filename'] self.uploaded_file['content_type'] = self._request.headers.get("Content-Type", 'application/octet-stream') self.uploaded_file['body'] = self._contentbuffer self.uploaded_file['body_len'] = int(self.content_length) self.uploaded_file['body_filepath'] = self._contentbuffer.filepath megabytes = int(self.content_length) / (1024 * 1024) if self.file_upload: limit_type = "upload" limit = GLSetting.memory_copy.maximum_filesize else: limit_type = "json" limit = 1000000 # 1MB fixme: add GLSetting.memory_copy.maximum_jsonsize # is 1MB probably too high. probably this variable must be in kB # less than 1 megabytes is always accepted if megabytes > limit: log.err("Tried %s request larger than expected (%dMb > %dMb)" % (limit_type, megabytes, limit)) # In HTTP Protocol errors need to be managed differently than handlers raise errors.HTTPRawLimitReach if self.content_length > 0: self.setRawMode() return elif self.file_upload: self._on_request_body(self.uploaded_file) self.file_upload = False self.uploaded_file = {} return self.request_callback(self._request) except Exception as exception: log.msg("Malformed HTTP request from %s: %s" % (self._remote_ip, exception)) log.exception(exception) if self._request: self._request.finish() if self.transport: self.transport.loseConnection()