The I2P HTTP proxy was unable to process your request.
" f"Error: {error_type}
" f"" ) return ( f"HTTP/1.1 {status_code} {message}\r\n" f"Content-Type: text/html; charset=UTF-8\r\n" f"Content-Length: {len(body)}\r\n" f"Connection: close\r\n" f"\r\n" f"{body}" ).encode("utf-8") # --- Header Parsing Helpers --- @staticmethod async def _read_headers(reader) -> dict[str, str]: """Read HTTP headers until blank line.""" headers: dict[str, str] = {} while True: line = await reader.readline() if not line or line == b"\r\n" or line == b"\n": break text = line.decode("utf-8", errors="replace").strip() if ":" in text: key, _, value = text.partition(":") headers[key.strip()] = value.strip() return headers @staticmethod async def _read_body(reader, headers: dict[str, str]) -> bytes: """Read request body based on Content-Length header.""" cl = headers.get("Content-Length", headers.get("content-length", "0")) try: length = int(cl) except ValueError: length = 0 if length > 0: return await reader.read(length) return b"" # --- Resolution --- async def _resolve(self, hostname: str) -> str | None: """Resolve an I2P hostname to base64 destination.""" # Check address helper cache first cached = self._get_cached_helper(hostname) if cached: return cached if hostname.endswith(".b32.i2p"): return hostname return await self._session.lookup(hostname) # --- Request Rebuilding --- @staticmethod def _rebuild_request(method: str, path: str, headers: dict[str, str], body: bytes) -> bytes: """Rebuild an HTTP request with relative path and filtered headers.""" lines = [f"{method} {path} HTTP/1.1"] for key, value in headers.items(): lines.append(f"{key}: {value}") lines.append("") lines.append("") request = "\r\n".join(lines).encode("utf-8") if body: request += body return request # --- Main Handler --- async def handle_client(self, reader, writer) -> None: try: first_line_bytes = await reader.readline() if not first_line_bytes: return first_line = first_line_bytes.decode("utf-8", errors="replace").strip() try: request = parse_http_request(first_line) except ValueError: writer.write(self._error_page("baduri", 400)) await writer.drain() return headers = await self._read_headers(reader) # Reject localhost if self._is_localhost(request.host): writer.write(self._error_page("localhost", 403)) await writer.drain() return if request.is_connect: await self._handle_connect(request, reader, writer) elif self._is_i2p_request(request.host): body = await self._read_body(reader, headers) await self._handle_i2p(request, headers, body, reader, writer) elif self._has_outproxy(): body = await self._read_body(reader, headers) await self._handle_outproxy(request, headers, body, reader, writer) else: writer.write(self._error_page("noproxy", 503)) await writer.drain() except Exception: logger.exception("Error in HTTP proxy handler") async def _handle_i2p(self, request, headers, body, reader, writer) -> None: """Route request to .i2p destination via SAM.""" # Check for address helper _, helper = self._extract_address_helper(request.raw_first_line) if helper: self._cache_address_helper(request.host, helper) dest = await self._resolve(request.host) if dest is None: writer.write(self._error_page("dnf", 503)) await writer.drain() return try: remote_reader, remote_writer = await self._session.connect(dest) except Exception: writer.write(self._error_page("timeout", 504)) await writer.drain() return # Filter headers and rebuild request with relative path filtered = self._filter_outbound_headers(headers, is_i2p=True) if "Host" not in filtered and "host" not in filtered: filtered["Host"] = request.host path = request.path or "/" request_bytes = self._rebuild_request(request.method, path, filtered, body) await bridge_with_initial_data( reader, writer, remote_reader, remote_writer, request_bytes ) async def _handle_connect(self, request, reader, writer) -> None: """Handle CONNECT method for HTTPS tunneling.""" # Consume remaining headers await self._read_headers(reader) if self._is_i2p_request(request.host): dest = await self._resolve(request.host) if dest is None: writer.write(self._error_page("dnf", 503)) await writer.drain() return try: remote_reader, remote_writer = await self._session.connect(dest) except Exception: writer.write(self._error_page("timeout", 504)) await writer.drain() return writer.write(b"HTTP/1.1 200 Connection Established\r\n\r\n") await writer.drain() await bridge(reader, writer, remote_reader, remote_writer) else: writer.write(self._error_page("ssl", 403)) await writer.drain() async def _handle_outproxy(self, request, headers, body, reader, writer) -> None: """Forward non-.i2p request to outproxy.""" outproxy = self._pick_outproxy() if not outproxy: writer.write(self._error_page("noproxy", 503)) await writer.drain() return dest = await self._resolve(outproxy) if dest is None: self._failed_outproxies.add(outproxy) writer.write(self._error_page("dnf", 503)) await writer.drain() return try: remote_reader, remote_writer = await self._session.connect(dest) except Exception: self._failed_outproxies.add(outproxy) writer.write(self._error_page("timeout", 504)) await writer.drain() return # Forward the original request (with absolute URL) to the outproxy filtered = self._filter_outbound_headers(headers, is_i2p=False) request_bytes = self._rebuild_request( request.method, request.raw_first_line.split()[1], filtered, body ) await bridge_with_initial_data( reader, writer, remote_reader, remote_writer, request_bytes )