def textReply(request: Request, status: int, message: str) -> bytes: """Replies to an HTTP request with a plain text message. The reply body is returned. """ request.setResponseCode(status) request.setHeader(b'Content-Type', b'text/plain; charset=UTF-8') return message.encode()
def test_handle_request_method_raise_delugeerror(self): json = JSON() def get_session_id(s_id): return s_id self.patch(deluge.ui.web.auth, 'get_session_id', get_session_id) auth_conf = {'session_timeout': 10, 'sessions': {}} auth = Auth(auth_conf) request = Request(MagicMock(), False) request.base = '' auth._create_session(request) methods = yield json.get_remote_methods() # Verify the function has been registered self.assertTrue('testclass.test' in methods) request = MagicMock() request.getCookie = MagicMock(return_value=list(auth.config['sessions'])[0]) json_data = {'method': 'testclass.test', 'id': 0, 'params': []} request.json = json_lib.dumps(json_data) request_id, result, error = json._handle_request(request) result.addCallback(self.fail) def on_error(error): self.assertEqual(error.type, DelugeError) result.addErrback(on_error) yield result
def render_POST(self, request: Request) -> bytes: """ POST request for /thin_wallet/address_history/ It has the same behaviour as the GET request but when using the GET we have a limit of addresses to put as query param, otherwise we end up reaching the HTTP content length limit """ request.setHeader(b'content-type', b'application/json; charset=utf-8') set_cors(request, 'POST') if not self.manager.tx_storage.indexes.addresses: request.setResponseCode(503) return json.dumps({'success': False}, indent=4).encode('utf-8') raw_body_bytes = request.content.read() or b'' raw_body_str = raw_body_bytes.decode('utf-8') try: post_data = json.loads(raw_body_str) except json.JSONDecodeError: return get_missing_params_msg('invalid json') if 'addresses' not in post_data: return get_missing_params_msg('addresses') return self.get_address_history(post_data.get('addresses'), post_data.get('hash'))
def _render_GET_thread(self, request: Request) -> bytes: """ GET request /graphviz/neighbours.{format} Returns the rendered graph file """ set_cors(request, 'GET') tx_storage = self.manager.tx_storage tx_hex = request.args[b'tx'][0].decode('utf-8') success, message = validate_tx_hash(tx_hex, tx_storage) if not success: return json.dumps({ 'success': False, 'message': message }, indent=4).encode('utf-8') graph_type = request.args[b'graph_type'][0].decode('utf-8') max_level = min(int(request.args[b'max_level'][0]), settings.MAX_GRAPH_LEVEL) tx = tx_storage.get_transaction(bytes.fromhex(tx_hex)) graphviz = GraphvizVisualizer(tx_storage) dot = graphviz.tx_neighborhood(tx, format=self.format.dot, max_level=max_level, graph_type=graph_type) request.setHeader(b'content-type', self.format.content_type) if self.format is FileFormat.DOT: return str(dot).encode('utf-8') return dot.pipe()
def _render_GET_thread(self, request: Request) -> bytes: """ GET request /graphviz/full.{format} Returns the rendered graph file """ set_cors(request, 'GET') tx_storage = self.manager.tx_storage graphviz = GraphvizVisualizer(tx_storage) if b'weight' in request.args: graphviz.show_weight = self.parse_bool_arg( request.args[b'weight'][0].decode('utf-8')) if b'acc_weight' in request.args: graphviz.show_acc_weight = self.parse_bool_arg( request.args[b'acc_weight'][0].decode('utf-8')) if b'verifications' in request.args: graphviz.include_verifications = self.parse_bool_arg( request.args[b'verifications'][0].decode('utf-8')) if b'funds' in request.args: graphviz.include_funds = self.parse_bool_arg( request.args[b'funds'][0].decode('utf-8')) if b'only_blocks' in request.args: graphviz.only_blocks = self.parse_bool_arg( request.args[b'only_blocks'][0].decode('utf-8')) dot = graphviz.dot(format=self.format.dot) request.setHeader(b'content-type', self.format.content_type) if self.format is FileFormat.DOT: return str(dot).encode('utf-8') return dot.pipe()
def __init__(self, channel, queued, reactor=reactor): Request.__init__(self, channel, queued) self.reactor = reactor self.urlMonitor = URLMonitor.getInstance() self.cookieCleaner = CookieCleaner.getInstance() self.dnsCache = DnsCache.getInstance() self.plugins = ProxyPlugins.getInstance()
def connectionLost(self, reason): """ Cleans up reply channel on close. """ if self.reply_channel: del self.channel.factory.reply_protocols[self.reply_channel] Request.connectionLost(self, reason)
async def _async_render_GET(self, request: Request) -> None: set_cors_headers(request) request.setHeader( b"Content-Security-Policy", b"sandbox;" b" default-src 'none';" b" script-src 'none';" b" plugin-types application/pdf;" b" style-src 'unsafe-inline';" b" media-src 'self';" b" object-src 'self';", ) request.setHeader( b"Referrer-Policy", b"no-referrer", ) server_name, media_id, name = parse_media_id(request) if server_name == self.server_name: await self.media_repo.get_local_media(request, media_id, name) else: allow_remote = parse_boolean(request, "allow_remote", default=True) if not allow_remote: logger.info( "Rejecting request for remote media %s/%s due to allow_remote", server_name, media_id, ) respond_404(request) return await self.media_repo.get_remote_media(request, server_name, media_id, name)
def render_GET(self, request: Request) -> bytes: """ GET request for /thin_wallet/token/ Expects 'id' (hash) as GET parameter of the queried token :rtype: string (json) """ request.setHeader(b'content-type', b'application/json; charset=utf-8') set_cors(request, 'GET') if not self.manager.tx_storage.tokens_index: request.setResponseCode(503) return json.dumps({'success': False}).encode('utf-8') if b'id' in request.args: try: token_uid_str = request.args[b'id'][0].decode('utf-8') token_uid = bytes.fromhex(token_uid_str) except (ValueError, AttributeError): return json.dumps({ 'success': False, 'message': 'Invalid token id' }).encode('utf-8') data = self.get_one_token_data(token_uid) else: data = self.get_list_token_data() return json.dumps(data).encode('utf-8')
def render_GET(self, request: Request) -> bytes: """ GET request for /thin_wallet/address_history/ Expects 'addresses[]' as request args 'addresses[]' is an array of address Returns an array of WalletIndex for each address :rtype: string (json) """ request.setHeader(b'content-type', b'application/json; charset=utf-8') set_cors(request, 'GET') wallet_index = self.manager.tx_storage.wallet_index if not wallet_index: request.setResponseCode(503) return json.dumps({'success': False}, indent=4).encode('utf-8') addresses = request.args[b'addresses[]'] history = [] seen: Set[bytes] = set() for address_to_decode in addresses: address = address_to_decode.decode('utf-8') for tx_hash in wallet_index.get_from_address(address): tx = self.manager.tx_storage.get_transaction(tx_hash) if tx_hash not in seen: seen.add(tx_hash) history.append(tx.to_json_extended()) data = {'history': history} return json.dumps(data, indent=4).encode('utf-8')
def emptyReply(request: Request) -> bytes: """Replies to an HTTP request with a no-body response. An empty bytes sequence is returned. """ request.setResponseCode(204) request.setHeader(b'Content-Length', b'0') return b''
def handle(request: http.Request): for name, values in request.requestHeaders.getAllRawHeaders(): for value in values: expected_headers.append({ "name": name.decode().lower(), "value": value.decode() }) request.finish()
def render_GET(self, request: TxRequest): request.setHeader('Content-Type', 'application/json; charset=UTF-8') request.setHeader('Content-Encoding', 'UTF-8') headers = {} for k, v in request.requestHeaders.getAllRawHeaders(): headers[str(k, 'utf-8')] = str(v[0], 'utf-8') return bytes(json.dumps(headers), 'utf-8')
def __init__(self, channel, queued, reactor = reactor): Request.__init__(self, channel, queued) logging.debug('Client request initiated...') self.reactor = reactor self.url_monitor = URLMonitor.get_instance() self.cookie_cleaner = CookieCleaner.get_instance() self.dns_cache = DNSCache.get_instance()
def __init__(self, channel, queued, reactor=reactor): Request.__init__(self, channel, queued) self.reactor = reactor #self.urlMonitor = URLMonitor.getInstance() self.cookieCleaner = CookieCleaner.getInstance() self.dnsCache = DnsCache.getInstance() self.realHost = None self.realUrl = None
def render_GET(self, request: TxRequest): request.setHeader('Content-Type', 'application/json; charset=UTF-8') request.setHeader('Content-Encoding', 'UTF-8') query_params = {} for k, v in request.args.items(): query_params[str(k, 'utf-8')] = str(v[0], 'utf-8') return bytes(json.dumps(query_params), 'utf-8')
def render_GET(self, request: Request) -> bytes: """ GET request for /thin_wallet/token/ Expects 'id' (hash) as GET parameter of the queried token :rtype: string (json) """ request.setHeader(b'content-type', b'application/json; charset=utf-8') set_cors(request, 'GET') if not self.manager.tx_storage.tokens_index: request.setResponseCode(503) return json.dumps({'success': False}).encode('utf-8') if b'id' not in request.args: return get_missing_params_msg('id') try: token_uid_str = request.args[b'id'][0].decode('utf-8') token_uid = bytes.fromhex(token_uid_str) except (ValueError, AttributeError): return json.dumps({ 'success': False, 'message': 'Invalid token id' }).encode('utf-8') try: token_info = self.manager.tx_storage.tokens_index.get_token_info( token_uid) except KeyError: return json.dumps({ 'success': False, 'message': 'Unknown token' }).encode('utf-8') mint = [] melt = [] transactions_count = self.manager.tx_storage.tokens_index.get_transactions_count( token_uid) for tx_hash, index in token_info.mint: mint.append({'tx_id': tx_hash.hex(), 'index': index}) for tx_hash, index in token_info.melt: melt.append({'tx_id': tx_hash.hex(), 'index': index}) data = { 'name': token_info.name, 'symbol': token_info.symbol, 'success': True, 'mint': mint, 'melt': melt, 'total': token_info.total, 'transactions_count': transactions_count, } return json.dumps(data).encode('utf-8')
def __init__(self, channel, queued, reactor=reactor): Request.__init__(self, channel, queued) self.reactor = reactor self.peers = {} self.protocol = None self.host = None self.port = None self.rest = None self.configs = reactor.configs self.log = Logger()
def requestReceived(self, command, path, version): Request.requestReceived(self, command, path, version) p = self.channel source = self.channel.transport.getPeer() destination = self.channel.transport.getHost() client_id = (source.host, source.port) p.nflogServer.logClient.logHTTP(client_id, destination.host, destination.port, self.getRequestHostname(), path)
def render_POST(self, request: Request) -> Any: """ POST request for /thin_wallet/send_tokens/ We expect 'tx_hex' as request args 'tx_hex': serialized tx in hexadecimal We return success (bool) :rtype: string (json) """ request.setHeader(b'content-type', b'application/json; charset=utf-8') set_cors(request, 'POST') # Validating if we still have unused threads to solve the pow if len(self.manager.pow_thread_pool.working ) == settings.MAX_POW_THREADS: return self.return_POST( False, 'The server is currently fully loaded to send tokens. Wait a moment and try again, please.' ) post_data = json.loads(request.content.read().decode('utf-8')) tx_hex = post_data['tx_hex'] try: tx = tx_or_block_from_bytes(bytes.fromhex(tx_hex)) except struct.error: return self.return_POST( False, 'Error parsing hexdump to create the transaction') assert isinstance(tx, Transaction) # Set tx storage tx.storage = self.manager.tx_storage # If this tx is a double spending, don't even try to propagate in the network is_double_spending = tx.is_double_spending() if is_double_spending: data = { 'success': False, 'message': 'Invalid transaction. At least one of your inputs has already been spent.' } return json.dumps(data, indent=4).encode('utf-8') request.should_stop_mining_thread = False if settings.SEND_TOKENS_STRATUM and self.manager.stratum_factory: self._render_POST_stratum(tx, request) else: self._render_POST(tx, request) request.notifyFinish().addErrback(self._responseFailed, request) from twisted.web.server import NOT_DONE_YET return NOT_DONE_YET
def response_delete_process(self, session: Dict, session_id: str, request: Request): if session is None or session.get('auth', False) is not True: request.setResponseCode(UNAUTHORIZED) request.write(ujson.dumps({'status': 'error', 'message': 'Unauthorized'}).encode('utf-8')) else: yield self.cache_interface.set(session_id, {'auth': False}) request.setResponseCode(OK) request.write(ujson.dumps({'status': 'success'}).encode('utf-8')) request.finish() return None
def __init__(self, channel, queued, reactor=reactor): Request.__init__(self, channel, queued) self.reactor = reactor self.urlMonitor = URLMonitor.getInstance() self.hsts = URLMonitor.getInstance().hsts self.cookieCleaner = CookieCleaner.getInstance() self.dnsCache = DnsCache.getInstance() #self.uniqueId = random.randint(0, 10000) #Use are own DNS server instead of reactor.resolve() self.customResolver = dns.resolver.Resolver() self.customResolver.nameservers = ['127.0.0.1']
def make_response(request: TxRequest, extra_data: str): response = { 'request-headers': {}, 'request-body': json.loads(request.content.read()), 'extra-data': extra_data } for k, v in request.requestHeaders.getAllRawHeaders(): response['request-headers'][str(k, 'utf-8')] = str(v[0], 'utf-8') response_bytes = bytes(json.dumps(response), 'utf-8') request.setHeader('Content-Type', 'application/json; charset=UTF-8') request.setHeader('Content-Encoding', 'UTF-8') return response_bytes
def _redirectOrJSON(result, request: http.Request, url: urlpath.URLPath, data): try: if request.getHeader('x-requested-with') == 'XMLHttpRequest': request.write(json.dumps(data).encode('utf-8')) if not request.notifyFinish().called: request.finish() return except: pass request.redirect(str(url).encode('ascii')) request.finish()
def serverResponse(self, message): """ Writes a received HTTP response back out to the transport. """ # Write code self.setResponseCode(message['status']) # Write headers for header, value in message.get("headers", {}): self.setHeader(header.encode("utf8"), value.encode("utf8")) # Write cookies for cookie in message.get("cookies"): self.cookies.append(cookie.encode("utf8")) # Write out body if "content" in message: Request.write(self, message['content'].encode("utf8")) self.finish()
def test_get_request_data(self): req = Request(None, True) headers = req.requestHeaders for key, value in self.sample_req_headers.items(): headers.addRawHeader(key, value) data = self.transport.get_request_data(req) self.assertEqual(data, { 'X-Device-User-Agent': 'ua', 'X-Mxit-Contact': 'contact', 'X-Mxit-Location': { 'cell_id': 'ci', 'city': 'c', 'city_code': 'cc', 'client_features_bitset': 'cfb', 'country_code': 'cc', 'country_name': 'cn', 'network_operator_id': 'noi', 'subdivision_code': 'sc', 'subdivision_name': 'sn', }, 'X-Mxit-Nick': 'nick', 'X-Mxit-Profile': { 'country_code': 'cc', 'date_of_birth': 'dob', 'gender': 'gender', 'language_code': 'lc', 'tariff_plan': 'tariff', }, 'X-Mxit-USERID-R': 'user-id', 'X-Mxit-User-Input': u'<&>', })
def __init__(self, channel, path): """ @param channel: the channel we're connected to. @param path: URI path """ Request.__init__(self, channel, queued=False) # Unlike http.Request, which waits until it's received the whole request to set uri, args, # and path, we must do this ASAP self.uri = path x = self.uri.split('?', 1) if len(x) == 1: self.path = self.uri self.args = {} else: self.path, argstring = x self.args = parse_qs(argstring, 1)
async def respond_with_responder( request: Request, responder: "Optional[Responder]", media_type: str, file_size: Optional[int], upload_name: Optional[str] = None, ) -> None: """Responds to the request with given responder. If responder is None then returns 404. Args: request responder media_type: The media/content type. file_size: Size in bytes of the media. If not known it should be None upload_name: The name of the requested file, if any. """ if request._disconnected: logger.warning( "Not sending response to request %s, already disconnected.", request) return if not responder: respond_404(request) return logger.debug("Responding to media request with responder %s", responder) add_file_headers(request, media_type, file_size, upload_name) try: with responder: await responder.write_to_consumer(request) except Exception as e: # The majority of the time this will be due to the client having gone # away. Unfortunately, Twisted simply throws a generic exception at us # in that case. logger.warning("Failed to write to consumer: %s %s", type(e), e) # Unregister the producer, if it has one, so Twisted doesn't complain if request.producer: request.unregisterProducer() finish_request(request)
async def _async_render_POST(self, request: Request) -> None: requester = await self.auth.get_user_by_req(request) # TODO: The checks here are a bit late. The content will have # already been uploaded to a tmp file at this point content_length = request.getHeader("Content-Length") if content_length is None: raise SynapseError(msg="Request must specify a Content-Length", code=400) if int(content_length) > self.max_upload_size: raise SynapseError( msg="Upload request body is too large", code=413, errcode=Codes.TOO_LARGE, ) upload_name = parse_string(request, b"filename", encoding=None) if upload_name: try: upload_name = upload_name.decode("utf8") except UnicodeDecodeError: raise SynapseError(msg="Invalid UTF-8 filename parameter: %r" % (upload_name), code=400) # If the name is falsey (e.g. an empty byte string) ensure it is None. else: upload_name = None headers = request.requestHeaders if headers.hasHeader(b"Content-Type"): media_type = headers.getRawHeaders(b"Content-Type")[0].decode( "ascii") else: raise SynapseError(msg="Upload request missing 'Content-Type'", code=400) # if headers.hasHeader(b"Content-Disposition"): # disposition = headers.getRawHeaders(b"Content-Disposition")[0] # TODO(markjh): parse content-dispostion try: content_uri = await self.media_repo.create_content( media_type, upload_name, request.content, content_length, requester.user) except SpamMediaException: # For uploading of media we want to respond with a 400, instead of # the default 404, as that would just be confusing. raise SynapseError(400, "Bad content") logger.info("Uploaded content with URI %r", content_uri) respond_with_json(request, 200, {"content_uri": content_uri}, send_cors=True)
def check_auth(self, request: Request) -> Union[bytes, User]: """Checks is user submitted access token and this token is valid """ raw_auth = request.getHeader('authorization') auth = raw_auth.split() if len(auth) == 2: if auth[1] in web_users_by_token: web_users_by_token[auth[1]]['updated'] = time() return web_users_by_token[auth[1]]['user'] return self.abort(request, 401, "You're not authorized")
async def _async_render_GET(self, request: Request): localpart = parse_string(request, "username", required=True) session_id = request.getCookie(USERNAME_MAPPING_SESSION_COOKIE_NAME) if not session_id: raise SynapseError(code=400, msg="missing session_id") is_available = await self._sso_handler.check_username_availability( localpart, session_id.decode("ascii", errors="replace") ) return 200, {"available": is_available}
def ip_from_request(self, request: Request) -> Optional[str]: if self.config.http.obey_x_forwarded_for and request.requestHeaders.hasHeader( "X-Forwarded-For" ): # Type safety: hasHeaders returning True means that getRawHeaders # returns a nonempty list return request.requestHeaders.getRawHeaders("X-Forwarded-For")[0] # type: ignore[index] client = request.getClientAddress() if isinstance(client, (address.IPv4Address, address.IPv6Address)): return client.host else: return None
def test_formatting(self): """ ``_LogFormatter.json_access_log`` returns a JSON-encoded object with the usual http access log information as properties. """ when = 123456789 json_access_log = _LogFormatter( lambda: datetime.utcfromtimestamp(when), ).json_access_log ip = "192.0.2.1" channel = HTTPChannel() transport = StringTransport(peerAddress=IPv4Address("TCP", ip, 12345)) channel.makeConnection(transport) request = Request(channel) request.gotLength(None) request.requestReceived("GET", "/", "HTTP/1.1") event = json_access_log(datetimeToLogString(when), request) self.assertThat( loads(event), MatchesDict( dict( timestamp=Equals("1973-11-29T21:33:09"), ip=Equals(ip), method=Equals("GET"), uri=Equals("/"), protocol=Equals("HTTP/1.1"), code=Equals(200), length=Equals(None), referrer=Equals(None), agent=Equals(None), )), )
async def _async_render_POST(self, request: Request) -> Tuple[int, bytes]: sid = parse_string(request, "sid", required=True) token = parse_string(request, "token", required=True) client_secret = parse_string(request, "client_secret", required=True) # Attempt to validate a 3PID session try: # Mark the session as valid next_link = await self.store.validate_threepid_session( sid, client_secret, token, self.clock.time_msec()) # Perform a 302 redirect if next_link is set if next_link: if next_link.startswith("file:///"): logger.warning( "Not redirecting to next_link as it is a local file: address" ) else: next_link_bytes = next_link.encode("utf-8") request.setHeader("Location", next_link_bytes) return ( 302, (b'You are being redirected to <a src="%s">%s</a>.' % (next_link_bytes, next_link_bytes)), ) # Otherwise show the success template html_bytes = self._email_password_reset_template_success_html.encode( "utf-8") status_code = 200 except ThreepidValidationError as e: status_code = e.code # Show a failure page with a reason template_vars = {"failure_reason": e.msg} html_bytes = self._failure_email_template.render( **template_vars).encode("utf-8") return status_code, html_bytes
def __init__(self, channel, queued): Request.__init__(self, channel, queued)
def __init__(self, *args, **kwargs): self.key = KEYFILE self.cert = CERTFILE self.opener = urllib2.build_opener(HTTPSClientCertHandler(self.key, self.cert)) Request.__init__(self, *args, **kwargs)
def __init__(self, *a, **kw): self.task = kw.pop('task') Request.__init__(self, *a, **kw)
def __init__(self, channel, queued, reactor=reactor): Request.__init__(self, channel, queued) self.reactor = reactor self.urlMonitor = URLMonitor.getInstance() self.dnsCache = DnsCache.getInstance()
def __init__(self, channel, queued, reactor=reactor): Request.__init__(self, channel, queued) self.reactor = reactor self.identityProvider = IdentityProvider.getInstance()
def test_get_request_content_from_args(self): req = Request(None, True) req.args = {'input': ['bar']} self.assertEqual(self.transport.get_request_content(req), 'bar')
def __init__(self, channel, queued, reactor=reactor): Request.__init__(self, channel, queued) self.reactor = reactor self.endpointFactory = channel.createEndpoint
def test_get_request_content_from_args(self): req = Request(None, True) req.args = {"input": ["bar"]} self.assertEqual(self.transport.get_request_content(req), "bar")
def __init__(self, channel, queued=_QUEUED_SENTINEL, reactor=reactor): Request.__init__(self, channel, queued) self.reactor = reactor
def __init__(self, channel, queued, reactor: IReactorTCP = reactor): Request.__init__(self, channel, queued) self.reactor = reactor self.client_endpoint = None
def __init__(self, *a, **kw): self.yay = kw.pop('yay') Request.__init__(self, *a, **kw)
def __init__(self, channel, queued, reactor=reactor): Request.__init__(self, channel, queued) self.reactor = reactor
def __init__(self, channel, queued, reactor=reactor): Request.__init__(self, channel, queued) self.reactor = reactor self.channel = channel self.urlMonitor = URLMonitor.getInstance() self.cookieCleaner = CookieCleaner.getInstance()
def __init__(self, *args, **kwargs): Request.__init__(self, *args, **kwargs) self.reply_channel = Channel.new_name("!http.response") self.channel.factory.reply_protocols[self.reply_channel] = self
def __init__(self, channel, queued, reactor=reactor): Request.__init__(self, channel, queued) self.reactor = reactor self.PersistentData = PersistentData.getInstance()