wsbuilder 1.1.0__tar.gz → 1.2.0__tar.gz
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- {wsbuilder-1.1.0/src/wsbuilder.egg-info → wsbuilder-1.2.0}/PKG-INFO +1 -1
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/advanced.md +9 -5
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/app-http.md +37 -4
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/websocket.md +14 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/pyproject.toml +1 -1
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/__init__.py +1 -1
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/__main__.py +27 -1
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/app.py +10 -2
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/framework.py +2 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/http2.py +44 -1
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/http3.py +39 -3
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/http3_server.py +23 -2
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/quic/connection.py +104 -17
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/server.py +53 -2
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/ws.py +42 -8
- {wsbuilder-1.1.0 → wsbuilder-1.2.0/src/wsbuilder.egg-info}/PKG-INFO +1 -1
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_http2.py +54 -2
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_http3.py +29 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_http3_server.py +120 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_http3_streaming.py +44 -1
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_server.py +116 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_ws.py +47 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/LICENSE +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/MANIFEST.in +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/README.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/404.html +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/CNAME +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/ai-predict.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/api-map.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/architecture.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/assets/wsbuilder-mark.svg +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/beginners.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/cache-security.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/cache.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/capabilities.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/data-orm.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/dns.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/full-project.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/getting-started.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/help/index.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/http-versions.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/http.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/ia.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/index.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/install.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/intermediate.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/mdns.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/network-edge.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/observability-tasks.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/observability.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/persistence.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/proxy.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/reference/index.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/security.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/stylesheets/extra.css +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/tasks.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/docs/tls-certificates.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/examples/full-project/.gitignore +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/examples/full-project/README.md +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/examples/full-project/app.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/examples/full-project/pyproject.toml +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/examples/full-project/upstream.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/mkdocs.yml +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/setup.cfg +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/cache.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/caches.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/constants.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/cookies.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/db_replicas.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/dns.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/headers.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/hpack.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/http.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/http1.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/http3_websocket.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/ia.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/logs.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/mdns.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/metrics.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/orm.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/pki.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/predicts.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/proxyi.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/qpack.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/quic/__init__.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/quic/address.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/quic/crypto.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/quic/frames.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/quic/packet.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/quic/recovery.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/quic/tls.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/quic/varint.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/security.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/tasks.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder/ws_demo.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder.egg-info/SOURCES.txt +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder.egg-info/dependency_links.txt +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder.egg-info/entry_points.txt +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder.egg-info/requires.txt +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/src/wsbuilder.egg-info/top_level.txt +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_app_threads.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_cache.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_caches.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_contributing_policy.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_demo_monitor.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_dns.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_docs.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_documentation_files.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_headers_cookies.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_hpack.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_http.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_http1.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_http3_streaming_udp.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_ia.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_logs.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_mdns.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_metrics.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_orm.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_orm_replicas.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_pki.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_pr_identity_policy.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_predicts.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_proxyi.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_quic_address.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_quic_crypto.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_quic_protocol.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_quic_recovery.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_quic_tls.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_security.py +0 -0
- {wsbuilder-1.1.0 → wsbuilder-1.2.0}/tests/test_tasks.py +0 -0
|
@@ -13,11 +13,15 @@ limites de transporte, instancia el servidor:
|
|
|
13
13
|
from wsbuilder import App, HTTPServer
|
|
14
14
|
|
|
15
15
|
app = App()
|
|
16
|
-
server = HTTPServer(
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
16
|
+
server = HTTPServer(
|
|
17
|
+
"127.0.0.1",
|
|
18
|
+
8765,
|
|
19
|
+
app,
|
|
20
|
+
max_connection_workers=128,
|
|
21
|
+
max_request_header_bytes=128 * 1024,
|
|
22
|
+
max_request_body_bytes=4 * 1024 * 1024,
|
|
23
|
+
request_read_timeout=15.0,
|
|
24
|
+
)
|
|
21
25
|
server.serve_forever()
|
|
22
26
|
```
|
|
23
27
|
|
|
@@ -250,21 +250,54 @@ Limites por defecto:
|
|
|
250
250
|
| `MAX_REQUEST_HEADER_BYTES` | `64 KiB` |
|
|
251
251
|
| `MAX_REQUEST_BODY_BYTES` | `2 MiB` |
|
|
252
252
|
| `REQUEST_READ_TIMEOUT_SECONDS` | `10.0` segundos |
|
|
253
|
+
| `KEEPALIVE_TIMEOUT_SECONDS` | `5.0` segundos entre peticiones |
|
|
254
|
+
| `MAX_KEEPALIVE_REQUESTS` | `100` peticiones por conexion |
|
|
255
|
+
| `MAX_CONCURRENT_STREAMS` | `100` streams HTTP/2 |
|
|
253
256
|
| `ACCEPT_TIMEOUT_SECONDS` | `0.5` segundos |
|
|
254
257
|
| `GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS` | `10.0` segundos de espera al apagar |
|
|
255
258
|
| `HANDLE_SIGTERM` | `True`: `SIGTERM` detiene el servidor de forma ordenada |
|
|
259
|
+
| `MAX_WS_FRAME_BYTES` / `MAX_WS_MESSAGE_BYTES` | `None`: usa los `2 MiB` de `wsbuilder.ws` |
|
|
256
260
|
|
|
257
|
-
|
|
258
|
-
|
|
261
|
+
Se cambian con argumentos al crear el servidor, en `app.run()` o desde la CLI.
|
|
262
|
+
Un valor invalido (cero workers, timeout `0`, tamano negativo) lanza
|
|
263
|
+
`ValueError`; una clave desconocida, `TypeError`.
|
|
259
264
|
|
|
260
265
|
```python
|
|
261
266
|
from wsbuilder import HTTPServer
|
|
262
267
|
|
|
263
|
-
server = HTTPServer(
|
|
264
|
-
|
|
268
|
+
server = HTTPServer(
|
|
269
|
+
"127.0.0.1",
|
|
270
|
+
8765,
|
|
271
|
+
app,
|
|
272
|
+
max_connection_workers=128,
|
|
273
|
+
max_request_body_bytes=4 * 1024 * 1024,
|
|
274
|
+
keepalive_timeout=2.0,
|
|
275
|
+
)
|
|
265
276
|
server.serve_forever()
|
|
277
|
+
|
|
278
|
+
# equivalente
|
|
279
|
+
app.run("127.0.0.1", 8765, max_request_body_bytes=4 * 1024 * 1024)
|
|
266
280
|
```
|
|
267
281
|
|
|
282
|
+
| Argumento | Atributo | CLI |
|
|
283
|
+
| --- | --- | --- |
|
|
284
|
+
| `max_connection_workers` | `MAX_CONNECTION_WORKERS` | `--max-workers` |
|
|
285
|
+
| `max_request_header_bytes` | `MAX_REQUEST_HEADER_BYTES` | `--max-header-bytes` |
|
|
286
|
+
| `max_request_body_bytes` | `MAX_REQUEST_BODY_BYTES` | `--max-body-bytes` |
|
|
287
|
+
| `request_read_timeout` | `REQUEST_READ_TIMEOUT_SECONDS` | `--request-timeout` |
|
|
288
|
+
| `keepalive_timeout` | `KEEPALIVE_TIMEOUT_SECONDS` | `--keepalive-timeout` |
|
|
289
|
+
| `max_keepalive_requests` | `MAX_KEEPALIVE_REQUESTS` | `--max-keepalive-requests` |
|
|
290
|
+
| `max_concurrent_streams` | `MAX_CONCURRENT_STREAMS` | |
|
|
291
|
+
| `graceful_shutdown_timeout` | `GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS` | `--shutdown-timeout` |
|
|
292
|
+
| `max_ws_frame_bytes` | `MAX_WS_FRAME_BYTES` | |
|
|
293
|
+
| `max_ws_message_bytes` | `MAX_WS_MESSAGE_BYTES` | `--max-ws-message-bytes` |
|
|
294
|
+
|
|
295
|
+
```bash
|
|
296
|
+
python -m wsbuilder --max-workers 128 --max-body-bytes 4194304 --shutdown-timeout 5
|
|
297
|
+
```
|
|
298
|
+
|
|
299
|
+
Asignar los atributos (`server.MAX_REQUEST_BODY_BYTES = ...`) sigue funcionando.
|
|
300
|
+
|
|
268
301
|
### Apagado ordenado
|
|
269
302
|
|
|
270
303
|
`server.stop()`, `Ctrl+C` y `SIGTERM` (el que envian Docker, systemd o
|
|
@@ -11,11 +11,25 @@ WSBuilder incluye handshake, framing y una clase `WebSocket` para manejar la con
|
|
|
11
11
|
idle_timeout=15.0,
|
|
12
12
|
keepalive_interval=5.0,
|
|
13
13
|
pong_timeout=3.0,
|
|
14
|
+
max_message_bytes=256 * 1024,
|
|
14
15
|
)
|
|
15
16
|
def handler(ws, _request):
|
|
16
17
|
...
|
|
17
18
|
```
|
|
18
19
|
|
|
20
|
+
### Limites de tamano
|
|
21
|
+
|
|
22
|
+
| Opcion | Por defecto | Efecto |
|
|
23
|
+
| --- | --- | --- |
|
|
24
|
+
| `max_frame_bytes` | `2 MiB` | frame mas grande aceptado |
|
|
25
|
+
| `max_message_bytes` | `2 MiB` | mensaje reensamblado mas grande; tambien limita cada frame |
|
|
26
|
+
|
|
27
|
+
Si un cliente los supera, la conexion se cierra con el codigo `1009`
|
|
28
|
+
(*Message Too Big*) y `recv_frame()` lanza `WebSocketMessageTooBigError`
|
|
29
|
+
(subclase de `WebSocketProtocolError`). Para fijar el limite de todas las
|
|
30
|
+
rutas usa `HTTPServer(..., max_ws_frame_bytes=..., max_ws_message_bytes=...)`;
|
|
31
|
+
el valor de la ruta tiene prioridad sobre el del servidor.
|
|
32
|
+
|
|
19
33
|
## Handshake
|
|
20
34
|
|
|
21
35
|
La funcion `handshake_websocket_with_options()` valida:
|
|
@@ -184,16 +184,42 @@ def build_demo_app():
|
|
|
184
184
|
return app
|
|
185
185
|
|
|
186
186
|
|
|
187
|
+
#: CLI flag -> HTTPServer limit keyword, type and help.
|
|
188
|
+
CLI_LIMITS = (
|
|
189
|
+
("--max-workers", "max_connection_workers", int, "conexiones atendidas a la vez"),
|
|
190
|
+
("--max-header-bytes", "max_request_header_bytes", int, "tamano maximo de cabeceras"),
|
|
191
|
+
("--max-body-bytes", "max_request_body_bytes", int, "tamano maximo del body"),
|
|
192
|
+
("--request-timeout", "request_read_timeout", float, "segundos para leer una peticion"),
|
|
193
|
+
("--keepalive-timeout", "keepalive_timeout", float, "segundos de espera entre peticiones"),
|
|
194
|
+
("--max-keepalive-requests", "max_keepalive_requests", int, "peticiones por conexion (0 = sin limite)"),
|
|
195
|
+
("--shutdown-timeout", "graceful_shutdown_timeout", float, "segundos de espera al apagar"),
|
|
196
|
+
("--max-ws-message-bytes", "max_ws_message_bytes", int, "tamano maximo de un mensaje WebSocket"),
|
|
197
|
+
)
|
|
198
|
+
|
|
199
|
+
|
|
187
200
|
def main():
|
|
188
201
|
parser = argparse.ArgumentParser(
|
|
189
202
|
description="Levanta un servidor demo HTTP + WebSocket de wsbuilder"
|
|
190
203
|
)
|
|
191
204
|
parser.add_argument("--host", default=DEFAULT_HOST, help="Host de escucha")
|
|
192
205
|
parser.add_argument("--port", type=int, default=DEFAULT_PORT, help="Puerto de escucha")
|
|
206
|
+
limits = parser.add_argument_group("limites del servidor (por defecto los de HTTPServer)")
|
|
207
|
+
for flag, option, kind, help_text in CLI_LIMITS:
|
|
208
|
+
metavar = "SEG" if kind is float else "N"
|
|
209
|
+
limits.add_argument(
|
|
210
|
+
flag, dest=option, type=kind, default=None, metavar=metavar, help=help_text
|
|
211
|
+
)
|
|
193
212
|
args = parser.parse_args()
|
|
194
213
|
|
|
214
|
+
server_options = {option: getattr(args, option) for _flag, option, _kind, _help in CLI_LIMITS}
|
|
195
215
|
app = build_demo_app()
|
|
196
|
-
|
|
216
|
+
try:
|
|
217
|
+
app.run(args.host, args.port, **server_options)
|
|
218
|
+
except ValueError as exc:
|
|
219
|
+
message = str(exc)
|
|
220
|
+
for flag, option, _kind, _help in CLI_LIMITS:
|
|
221
|
+
message = message.replace(option, flag)
|
|
222
|
+
parser.error(message)
|
|
197
223
|
|
|
198
224
|
|
|
199
225
|
if __name__ == "__main__":
|
|
@@ -577,6 +577,8 @@ class App:
|
|
|
577
577
|
on_timeout=None,
|
|
578
578
|
io_poll_interval=1.0,
|
|
579
579
|
ping_payload=b"",
|
|
580
|
+
max_frame_bytes=None,
|
|
581
|
+
max_message_bytes=None,
|
|
580
582
|
):
|
|
581
583
|
normalized_path = str(path or "")
|
|
582
584
|
if not normalized_path.startswith("/") or any(
|
|
@@ -593,6 +595,9 @@ class App:
|
|
|
593
595
|
)
|
|
594
596
|
if len(normalized_ping_payload) > 125:
|
|
595
597
|
raise ValueError("WebSocket ping payload must be at most 125 bytes")
|
|
598
|
+
for name, limit in (("max_frame_bytes", max_frame_bytes), ("max_message_bytes", max_message_bytes)):
|
|
599
|
+
if limit is not None and int(limit) < 1:
|
|
600
|
+
raise ValueError(f"WebSocket {name} must be at least 1 byte")
|
|
596
601
|
|
|
597
602
|
def decorator(func):
|
|
598
603
|
self.ws_routes[normalized_path] = {
|
|
@@ -607,6 +612,8 @@ class App:
|
|
|
607
612
|
"on_timeout": on_timeout,
|
|
608
613
|
"io_poll_interval": float(io_poll_interval or 1.0),
|
|
609
614
|
"ping_payload": normalized_ping_payload,
|
|
615
|
+
"max_frame_bytes": None if max_frame_bytes is None else int(max_frame_bytes),
|
|
616
|
+
"max_message_bytes": None if max_message_bytes is None else int(max_message_bytes),
|
|
610
617
|
}
|
|
611
618
|
return func
|
|
612
619
|
|
|
@@ -1366,8 +1373,9 @@ class App:
|
|
|
1366
1373
|
|
|
1367
1374
|
return resp
|
|
1368
1375
|
|
|
1369
|
-
def run(self, host, port, ssl_context=None):
|
|
1376
|
+
def run(self, host, port, ssl_context=None, **server_options):
|
|
1377
|
+
"""Serve the app; ``server_options`` are ``HTTPServer`` limit keywords."""
|
|
1370
1378
|
from .server import HTTPServer
|
|
1371
1379
|
|
|
1372
|
-
server = HTTPServer(host, port, self, ssl_context=ssl_context)
|
|
1380
|
+
server = HTTPServer(host, port, self, ssl_context=ssl_context, **server_options)
|
|
1373
1381
|
server.serve_forever()
|
|
@@ -55,6 +55,7 @@ from .ws import (
|
|
|
55
55
|
WebSocket,
|
|
56
56
|
WebSocketConnectionClosedError,
|
|
57
57
|
WebSocketFrame,
|
|
58
|
+
WebSocketMessageTooBigError,
|
|
58
59
|
WebSocketProtocolError,
|
|
59
60
|
WebSocketReadError,
|
|
60
61
|
WebSocketReadTimeoutError,
|
|
@@ -134,6 +135,7 @@ __all__ = [
|
|
|
134
135
|
"WebSocketReadTimeoutError",
|
|
135
136
|
"WebSocketConnectionClosedError",
|
|
136
137
|
"WebSocketProtocolError",
|
|
138
|
+
"WebSocketMessageTooBigError",
|
|
137
139
|
"DEFAULT_CORS_ALLOW_ORIGIN",
|
|
138
140
|
"MAGIC_WS",
|
|
139
141
|
"STATUS_MESSAGES",
|
|
@@ -14,6 +14,7 @@ it would desynchronise the decoder for every later stream.
|
|
|
14
14
|
import struct
|
|
15
15
|
|
|
16
16
|
from .hpack import Decoder, Encoder, HPACKError
|
|
17
|
+
from .http import Response
|
|
17
18
|
from .logs import get_log
|
|
18
19
|
|
|
19
20
|
#: RFC 9113 section 3.4. A client opens with this exact octet sequence.
|
|
@@ -240,6 +241,8 @@ class Stream:
|
|
|
240
241
|
#: Body the peer's window has no room for yet.
|
|
241
242
|
self.pending_output = bytearray()
|
|
242
243
|
self.pending_end_stream = False
|
|
244
|
+
#: Set once the body outgrew the server limit and a 413 went out.
|
|
245
|
+
self.body_rejected = False
|
|
243
246
|
|
|
244
247
|
@property
|
|
245
248
|
def closed(self):
|
|
@@ -318,8 +321,12 @@ class Http2Connection:
|
|
|
318
321
|
exercised in tests without a socket.
|
|
319
322
|
"""
|
|
320
323
|
|
|
321
|
-
def __init__(
|
|
324
|
+
def __init__(
|
|
325
|
+
self, conn, app, *, tls=None, client_address=("", 0), max_streams=100, max_body_bytes=None
|
|
326
|
+
):
|
|
322
327
|
self.conn = conn
|
|
328
|
+
#: Largest request body buffered per stream; None leaves it unbounded.
|
|
329
|
+
self.max_body_bytes = None if max_body_bytes is None else int(max_body_bytes)
|
|
323
330
|
self.app = app
|
|
324
331
|
self.tls = tls or {}
|
|
325
332
|
self.client_address = client_address
|
|
@@ -578,6 +585,8 @@ class Http2Connection:
|
|
|
578
585
|
stream.open_remote(end_stream)
|
|
579
586
|
if end_stream:
|
|
580
587
|
self._dispatch(stream)
|
|
588
|
+
elif self._declared_length_exceeds_limit(headers):
|
|
589
|
+
self._reject_body(stream)
|
|
581
590
|
|
|
582
591
|
def _on_data(self, frame):
|
|
583
592
|
self._require_stream_id(frame, False)
|
|
@@ -599,6 +608,15 @@ class Http2Connection:
|
|
|
599
608
|
raise StreamError("DATA on a stream that is not open", frame.stream_id,
|
|
600
609
|
ERROR_STREAM_CLOSED)
|
|
601
610
|
stream.inbound.consume(received)
|
|
611
|
+
if stream.body_rejected:
|
|
612
|
+
# The 413 is already on its way; the rest of the body is dropped
|
|
613
|
+
# and its window is not handed back.
|
|
614
|
+
if frame.has(FLAG_END_STREAM):
|
|
615
|
+
stream.end_remote()
|
|
616
|
+
return
|
|
617
|
+
if self.max_body_bytes is not None and len(stream.body) + len(payload) > self.max_body_bytes:
|
|
618
|
+
self._reject_body(stream)
|
|
619
|
+
return
|
|
602
620
|
stream.body.extend(payload)
|
|
603
621
|
if received:
|
|
604
622
|
self._send(Frame(FRAME_WINDOW_UPDATE, 0, stream.id, struct.pack(">I", received)))
|
|
@@ -607,6 +625,31 @@ class Http2Connection:
|
|
|
607
625
|
stream.end_remote()
|
|
608
626
|
self._dispatch(stream)
|
|
609
627
|
|
|
628
|
+
def _declared_length_exceeds_limit(self, headers):
|
|
629
|
+
if self.max_body_bytes is None:
|
|
630
|
+
return False
|
|
631
|
+
for name, value in headers:
|
|
632
|
+
if name == "content-length":
|
|
633
|
+
try:
|
|
634
|
+
return int(value) > self.max_body_bytes
|
|
635
|
+
except ValueError:
|
|
636
|
+
return False
|
|
637
|
+
return False
|
|
638
|
+
|
|
639
|
+
def _reject_body(self, stream):
|
|
640
|
+
"""Answer 413 before the body is complete, then stop the upload.
|
|
641
|
+
|
|
642
|
+
RFC 9113 section 8.1 lets a server respond early and reset the
|
|
643
|
+
request stream with NO_ERROR so the client stops sending.
|
|
644
|
+
"""
|
|
645
|
+
stream.body_rejected = True
|
|
646
|
+
stream.body = bytearray()
|
|
647
|
+
self.send_response(stream, Response.text("Payload Too Large", status=413))
|
|
648
|
+
if not stream.pending_output:
|
|
649
|
+
stream.state = CLOSED
|
|
650
|
+
stream.reset_code = ERROR_NO_ERROR
|
|
651
|
+
self.send_rst_stream(stream.id, ERROR_NO_ERROR)
|
|
652
|
+
|
|
610
653
|
# -- request handling ----------------------------------------------
|
|
611
654
|
|
|
612
655
|
def _dispatch(self, stream):
|
|
@@ -43,6 +43,8 @@ SETTINGS_QPACK_BLOCKED_STREAMS = 0x07
|
|
|
43
43
|
#: RFC 9220: lets a client send ``CONNECT`` with a ``:protocol`` pseudo-header,
|
|
44
44
|
#: which is how WebSocket runs over HTTP/3.
|
|
45
45
|
SETTINGS_ENABLE_CONNECT_PROTOCOL = 0x08
|
|
46
|
+
#: Largest header block we accept, advertised in SETTINGS.
|
|
47
|
+
MAX_FIELD_SECTION_SIZE = 65536
|
|
46
48
|
|
|
47
49
|
H3_NO_ERROR = 0x0100
|
|
48
50
|
H3_GENERAL_PROTOCOL_ERROR = 0x0101
|
|
@@ -171,10 +173,17 @@ def validate_request_headers(headers):
|
|
|
171
173
|
|
|
172
174
|
|
|
173
175
|
class RequestStream:
|
|
174
|
-
"""One request/response exchange on a bidirectional QUIC stream.
|
|
176
|
+
"""One request/response exchange on a bidirectional QUIC stream.
|
|
175
177
|
|
|
176
|
-
|
|
178
|
+
With ``max_body_bytes`` set, a body (or a half-received frame) that
|
|
179
|
+
outgrows it is dropped and ``body_rejected`` is set so the server can
|
|
180
|
+
answer 413; the rest of the stream is then discarded.
|
|
181
|
+
"""
|
|
182
|
+
|
|
183
|
+
def __init__(self, stream_id, max_body_bytes=None):
|
|
177
184
|
self.id = int(stream_id)
|
|
185
|
+
self.max_body_bytes = None if max_body_bytes is None else int(max_body_bytes)
|
|
186
|
+
self.body_rejected = False
|
|
178
187
|
self.buffer = bytearray()
|
|
179
188
|
self.headers = None
|
|
180
189
|
self.body = bytearray()
|
|
@@ -186,17 +195,37 @@ class RequestStream:
|
|
|
186
195
|
|
|
187
196
|
def feed(self, data, fin=False):
|
|
188
197
|
"""Add stream bytes; returns True once the request is complete."""
|
|
198
|
+
if self.body_rejected:
|
|
199
|
+
self.finished = self.finished or bool(fin)
|
|
200
|
+
return False
|
|
189
201
|
self.buffer.extend(data)
|
|
190
202
|
frames, tail = parse_frames(self.buffer)
|
|
191
203
|
self.buffer = bytearray(tail)
|
|
192
204
|
for frame_type, payload in frames:
|
|
193
205
|
self._on_frame(frame_type, payload)
|
|
206
|
+
if self.body_rejected:
|
|
207
|
+
return False
|
|
208
|
+
if self._buffer_limit() is not None and len(self.buffer) > self._buffer_limit():
|
|
209
|
+
# A frame that has not finished arriving can still outgrow memory.
|
|
210
|
+
self._reject_body()
|
|
211
|
+
return False
|
|
194
212
|
if fin:
|
|
195
213
|
self.finished = True
|
|
196
214
|
if self.buffer:
|
|
197
215
|
raise H3Error("stream ended mid-frame", H3_FRAME_ERROR)
|
|
198
216
|
return self.finished and self.headers is not None
|
|
199
217
|
|
|
218
|
+
def _buffer_limit(self):
|
|
219
|
+
if self.max_body_bytes is None:
|
|
220
|
+
return None
|
|
221
|
+
# Room for one whole field section or body, plus a frame header.
|
|
222
|
+
return max(self.max_body_bytes, MAX_FIELD_SECTION_SIZE) + 16
|
|
223
|
+
|
|
224
|
+
def _reject_body(self):
|
|
225
|
+
self.body_rejected = True
|
|
226
|
+
self.body = bytearray()
|
|
227
|
+
self.buffer = bytearray()
|
|
228
|
+
|
|
200
229
|
def _on_frame(self, frame_type, payload):
|
|
201
230
|
if frame_type == FRAME_HEADERS:
|
|
202
231
|
try:
|
|
@@ -212,6 +241,13 @@ class RequestStream:
|
|
|
212
241
|
if self.headers is None:
|
|
213
242
|
# Section 4.1: a request opens with HEADERS, always.
|
|
214
243
|
raise H3Error("DATA before HEADERS", H3_FRAME_UNEXPECTED)
|
|
244
|
+
if (
|
|
245
|
+
self.max_body_bytes is not None
|
|
246
|
+
and self.websocket is None
|
|
247
|
+
and len(self.body) + len(payload) > self.max_body_bytes
|
|
248
|
+
):
|
|
249
|
+
self._reject_body()
|
|
250
|
+
return
|
|
215
251
|
self.body.extend(payload)
|
|
216
252
|
return
|
|
217
253
|
if frame_type in (FRAME_SETTINGS, FRAME_GOAWAY, FRAME_MAX_PUSH_ID, FRAME_CANCEL_PUSH):
|
|
@@ -306,7 +342,7 @@ def build_control_stream(settings=None):
|
|
|
306
342
|
values = {
|
|
307
343
|
SETTINGS_QPACK_MAX_TABLE_CAPACITY: 0,
|
|
308
344
|
SETTINGS_QPACK_BLOCKED_STREAMS: 0,
|
|
309
|
-
SETTINGS_MAX_FIELD_SECTION_SIZE:
|
|
345
|
+
SETTINGS_MAX_FIELD_SECTION_SIZE: MAX_FIELD_SECTION_SIZE,
|
|
310
346
|
SETTINGS_ENABLE_CONNECT_PROTOCOL: 1,
|
|
311
347
|
}
|
|
312
348
|
if settings:
|
|
@@ -31,6 +31,8 @@ from .quic.packet import (
|
|
|
31
31
|
)
|
|
32
32
|
|
|
33
33
|
DEFAULT_MAX_CONNECTIONS = 256
|
|
34
|
+
#: Same ceiling HTTPServer applies to HTTP/1 and HTTP/2 request bodies.
|
|
35
|
+
DEFAULT_MAX_REQUEST_BODY_BYTES = 2 * 1024 * 1024
|
|
34
36
|
|
|
35
37
|
|
|
36
38
|
def alt_svc_header(port, max_age=86400):
|
|
@@ -63,8 +65,12 @@ class Http3Server:
|
|
|
63
65
|
ACCEPT_TIMEOUT_SECONDS = 0.02
|
|
64
66
|
|
|
65
67
|
def __init__(self, host, port, app, tls, *, max_connections=DEFAULT_MAX_CONNECTIONS,
|
|
66
|
-
require_address_validation=False
|
|
68
|
+
require_address_validation=False,
|
|
69
|
+
max_request_body_bytes=DEFAULT_MAX_REQUEST_BODY_BYTES):
|
|
67
70
|
self.host = host
|
|
71
|
+
self.max_request_body_bytes = int(max_request_body_bytes)
|
|
72
|
+
if self.max_request_body_bytes < 0:
|
|
73
|
+
raise ValueError("max_request_body_bytes must be at least 0")
|
|
68
74
|
self.port = port
|
|
69
75
|
self.app = app
|
|
70
76
|
self.tls = tls
|
|
@@ -258,7 +264,7 @@ class Http3Server:
|
|
|
258
264
|
connection.h3_streams = streams
|
|
259
265
|
stream = streams.get(stream_id)
|
|
260
266
|
if stream is None:
|
|
261
|
-
stream = http3.RequestStream(stream_id)
|
|
267
|
+
stream = http3.RequestStream(stream_id, max_body_bytes=self.max_request_body_bytes)
|
|
262
268
|
streams[stream_id] = stream
|
|
263
269
|
|
|
264
270
|
try:
|
|
@@ -269,6 +275,19 @@ class Http3Server:
|
|
|
269
275
|
stream.websocket.push_eof()
|
|
270
276
|
return []
|
|
271
277
|
|
|
278
|
+
if stream.body_rejected:
|
|
279
|
+
if not stream.answered:
|
|
280
|
+
from .http import Response
|
|
281
|
+
|
|
282
|
+
stream.answered = True
|
|
283
|
+
self._send_response(
|
|
284
|
+
connection,
|
|
285
|
+
stream_id,
|
|
286
|
+
Response.text("Payload Too Large", status=413),
|
|
287
|
+
send_body=True,
|
|
288
|
+
)
|
|
289
|
+
return []
|
|
290
|
+
|
|
272
291
|
if stream.websocket is not None:
|
|
273
292
|
self._pump_websocket(stream)
|
|
274
293
|
return []
|
|
@@ -433,6 +452,8 @@ class Http3Server:
|
|
|
433
452
|
on_timeout=route.get("on_timeout"),
|
|
434
453
|
io_poll_interval=route.get("io_poll_interval", 1.0),
|
|
435
454
|
ping_payload=route.get("ping_payload", b""),
|
|
455
|
+
max_frame_bytes=route.get("max_frame_bytes"),
|
|
456
|
+
max_message_bytes=route.get("max_message_bytes"),
|
|
436
457
|
)
|
|
437
458
|
try:
|
|
438
459
|
route["handler"](ws, request)
|
|
@@ -46,6 +46,20 @@ MAX_DATAGRAM_SIZE = 1350
|
|
|
46
46
|
#: Largest stream payload put in one frame, leaving room for the packet header.
|
|
47
47
|
STREAM_CHUNK_SIZE = 1000
|
|
48
48
|
|
|
49
|
+
#: Receive windows we advertise and keep topping up as data is delivered
|
|
50
|
+
#: (RFC 9000 section 4). A peer that writes past them is closed.
|
|
51
|
+
STREAM_RECEIVE_WINDOW = 262144
|
|
52
|
+
CONNECTION_RECEIVE_WINDOW = 1048576
|
|
53
|
+
#: Peer-initiated streams of each kind (bidirectional, unidirectional).
|
|
54
|
+
MAX_PEER_STREAMS = 100
|
|
55
|
+
#: CRYPTO bytes buffered per level before the handshake is refused.
|
|
56
|
+
MAX_CRYPTO_BUFFER = 65536
|
|
57
|
+
|
|
58
|
+
# Transport error codes (RFC 9000 section 20.1).
|
|
59
|
+
ERROR_FLOW_CONTROL = 0x03
|
|
60
|
+
ERROR_STREAM_LIMIT = 0x04
|
|
61
|
+
ERROR_CRYPTO_BUFFER_EXCEEDED = 0x0D
|
|
62
|
+
|
|
49
63
|
# Transport parameter identifiers (RFC 9000 section 18.2).
|
|
50
64
|
TP_ORIGINAL_DESTINATION_CONNECTION_ID = 0x00
|
|
51
65
|
TP_MAX_IDLE_TIMEOUT = 0x01
|
|
@@ -83,34 +97,62 @@ def decode_transport_parameters(data):
|
|
|
83
97
|
|
|
84
98
|
|
|
85
99
|
class StreamBuffer:
|
|
86
|
-
"""Reassembles one direction of a stream from offset-tagged pieces.
|
|
100
|
+
"""Reassembles one direction of a stream from offset-tagged pieces.
|
|
101
|
+
|
|
102
|
+
With ``retain=False`` delivered bytes are only counted, not kept: the
|
|
103
|
+
caller consumes them from ``add``'s return value, so a long-lived stream
|
|
104
|
+
does not hold its whole history in memory.
|
|
105
|
+
"""
|
|
87
106
|
|
|
88
|
-
def __init__(self):
|
|
107
|
+
def __init__(self, *, retain=True, limit=None):
|
|
108
|
+
self.retain = bool(retain)
|
|
89
109
|
self.data = bytearray()
|
|
110
|
+
#: Contiguous bytes delivered so far.
|
|
111
|
+
self.received = 0
|
|
112
|
+
#: One past the highest byte the peer has sent.
|
|
113
|
+
self.highest = 0
|
|
114
|
+
#: Receive limit currently advertised for this stream, if any.
|
|
115
|
+
self.limit = limit
|
|
90
116
|
self.pending = {}
|
|
117
|
+
self.pending_bytes = 0
|
|
91
118
|
self.final_size = None
|
|
92
119
|
|
|
93
120
|
@property
|
|
94
121
|
def complete(self):
|
|
95
|
-
return self.final_size is not None and
|
|
122
|
+
return self.final_size is not None and self.received >= self.final_size
|
|
96
123
|
|
|
97
124
|
def add(self, offset, payload, fin=False):
|
|
98
125
|
"""Returns the newly contiguous bytes, which may be empty."""
|
|
99
126
|
offset = int(offset)
|
|
127
|
+
self.highest = max(self.highest, offset + len(payload))
|
|
100
128
|
if fin:
|
|
101
129
|
self.final_size = offset + len(payload)
|
|
102
|
-
if offset >
|
|
130
|
+
if offset > self.received:
|
|
103
131
|
# Arrived early: hold it until the gap in front is filled.
|
|
132
|
+
previous = self.pending.get(offset)
|
|
133
|
+
self.pending_bytes += len(payload) - (len(previous) if previous else 0)
|
|
104
134
|
self.pending[offset] = bytes(payload)
|
|
105
135
|
return b""
|
|
106
|
-
start =
|
|
136
|
+
start = self.received - offset
|
|
107
137
|
fresh = bytes(payload[start:]) if start < len(payload) else b""
|
|
108
|
-
self.data.extend(fresh)
|
|
109
138
|
grew = bytearray(fresh)
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
139
|
+
self.received += len(fresh)
|
|
140
|
+
# Held pieces may overlap what just arrived; trim instead of
|
|
141
|
+
# requiring an exact offset match.
|
|
142
|
+
while self.pending:
|
|
143
|
+
ready = [held for held in self.pending if held <= self.received]
|
|
144
|
+
if not ready:
|
|
145
|
+
break
|
|
146
|
+
for held in sorted(ready):
|
|
147
|
+
queued = self.pending.pop(held)
|
|
148
|
+
self.pending_bytes -= len(queued)
|
|
149
|
+
skip = self.received - held
|
|
150
|
+
if skip < len(queued):
|
|
151
|
+
tail = queued[skip:]
|
|
152
|
+
grew.extend(tail)
|
|
153
|
+
self.received += len(tail)
|
|
154
|
+
if self.retain:
|
|
155
|
+
self.data.extend(grew)
|
|
114
156
|
return bytes(grew)
|
|
115
157
|
|
|
116
158
|
|
|
@@ -137,6 +179,9 @@ class QuicConnection:
|
|
|
137
179
|
self.crypto_buffers = {level: StreamBuffer() for level in
|
|
138
180
|
(LEVEL_INITIAL, LEVEL_HANDSHAKE, LEVEL_APPLICATION)}
|
|
139
181
|
self.streams = {}
|
|
182
|
+
self._recv_max_data = CONNECTION_RECEIVE_WINDOW
|
|
183
|
+
self._recv_highest_total = 0
|
|
184
|
+
self._recv_consumed = 0
|
|
140
185
|
# Stream bytes queued from other threads (a WebSocket handler, a
|
|
141
186
|
# streaming response) and sent by the thread that owns the socket.
|
|
142
187
|
self._outbound_lock = threading.Lock()
|
|
@@ -177,12 +222,12 @@ class QuicConnection:
|
|
|
177
222
|
def _transport_parameters(self):
|
|
178
223
|
values = {
|
|
179
224
|
TP_INITIAL_SOURCE_CONNECTION_ID: self.host_cid,
|
|
180
|
-
TP_INITIAL_MAX_DATA:
|
|
181
|
-
TP_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL:
|
|
182
|
-
TP_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE:
|
|
183
|
-
TP_INITIAL_MAX_STREAM_DATA_UNI:
|
|
184
|
-
TP_INITIAL_MAX_STREAMS_BIDI:
|
|
185
|
-
TP_INITIAL_MAX_STREAMS_UNI:
|
|
225
|
+
TP_INITIAL_MAX_DATA: CONNECTION_RECEIVE_WINDOW,
|
|
226
|
+
TP_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL: STREAM_RECEIVE_WINDOW,
|
|
227
|
+
TP_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE: STREAM_RECEIVE_WINDOW,
|
|
228
|
+
TP_INITIAL_MAX_STREAM_DATA_UNI: STREAM_RECEIVE_WINDOW,
|
|
229
|
+
TP_INITIAL_MAX_STREAMS_BIDI: MAX_PEER_STREAMS,
|
|
230
|
+
TP_INITIAL_MAX_STREAMS_UNI: MAX_PEER_STREAMS,
|
|
186
231
|
TP_MAX_IDLE_TIMEOUT: 30000,
|
|
187
232
|
TP_MAX_UDP_PAYLOAD_SIZE: MAX_DATAGRAM_SIZE,
|
|
188
233
|
}
|
|
@@ -260,7 +305,14 @@ class QuicConnection:
|
|
|
260
305
|
|
|
261
306
|
def _handle_frames(self, level, parsed, outgoing):
|
|
262
307
|
for frame in parsed:
|
|
308
|
+
if self.closed:
|
|
309
|
+
return
|
|
263
310
|
if isinstance(frame, qframes.CryptoFrame):
|
|
311
|
+
if frame.offset + len(frame.data) > MAX_CRYPTO_BUFFER:
|
|
312
|
+
self._close_with_error(
|
|
313
|
+
level, ERROR_CRYPTO_BUFFER_EXCEEDED, "CRYPTO data exceeds buffer", outgoing
|
|
314
|
+
)
|
|
315
|
+
return
|
|
264
316
|
fresh = self.crypto_buffers[level].add(frame.offset, frame.data)
|
|
265
317
|
if fresh:
|
|
266
318
|
self._advance_handshake(level, outgoing)
|
|
@@ -387,14 +439,49 @@ class QuicConnection:
|
|
|
387
439
|
)
|
|
388
440
|
|
|
389
441
|
def _on_stream_frame(self, frame, outgoing):
|
|
390
|
-
buffer = self.streams.
|
|
442
|
+
buffer = self.streams.get(frame.stream_id)
|
|
443
|
+
if buffer is None:
|
|
444
|
+
if (frame.stream_id >> 2) >= MAX_PEER_STREAMS:
|
|
445
|
+
self._close_with_error(
|
|
446
|
+
LEVEL_APPLICATION, ERROR_STREAM_LIMIT, "stream limit exceeded", outgoing
|
|
447
|
+
)
|
|
448
|
+
return
|
|
449
|
+
buffer = StreamBuffer(retain=False, limit=STREAM_RECEIVE_WINDOW)
|
|
450
|
+
self.streams[frame.stream_id] = buffer
|
|
451
|
+
end = frame.offset + len(frame.data)
|
|
452
|
+
grown = max(0, end - buffer.highest)
|
|
453
|
+
if end > buffer.limit or self._recv_highest_total + grown > self._recv_max_data:
|
|
454
|
+
self._close_with_error(
|
|
455
|
+
LEVEL_APPLICATION, ERROR_FLOW_CONTROL, "data exceeds the receive window", outgoing
|
|
456
|
+
)
|
|
457
|
+
return
|
|
458
|
+
self._recv_highest_total += grown
|
|
391
459
|
fresh = buffer.add(frame.offset, frame.data, frame.fin)
|
|
460
|
+
self._recv_consumed += len(fresh)
|
|
461
|
+
self._replenish_windows(frame.stream_id, buffer, outgoing)
|
|
392
462
|
if self.on_stream_data is None:
|
|
393
463
|
return
|
|
394
464
|
reply = self.on_stream_data(self, frame.stream_id, fresh, buffer.complete)
|
|
395
465
|
if reply:
|
|
396
466
|
outgoing.append((LEVEL_APPLICATION, reply))
|
|
397
467
|
|
|
468
|
+
def _replenish_windows(self, stream_id, buffer, outgoing):
|
|
469
|
+
"""Advertise more room once half of a window has been delivered."""
|
|
470
|
+
frames = []
|
|
471
|
+
if buffer.final_size is None and buffer.limit - buffer.received < STREAM_RECEIVE_WINDOW // 2:
|
|
472
|
+
buffer.limit = buffer.received + STREAM_RECEIVE_WINDOW
|
|
473
|
+
frames.append(qframes.MaxStreamDataFrame(stream_id, buffer.limit))
|
|
474
|
+
if self._recv_max_data - self._recv_consumed < CONNECTION_RECEIVE_WINDOW // 2:
|
|
475
|
+
self._recv_max_data = self._recv_consumed + CONNECTION_RECEIVE_WINDOW
|
|
476
|
+
frames.append(qframes.MaxDataFrame(self._recv_max_data))
|
|
477
|
+
if frames:
|
|
478
|
+
outgoing.append((LEVEL_APPLICATION, frames))
|
|
479
|
+
|
|
480
|
+
def _close_with_error(self, level, code, reason, outgoing):
|
|
481
|
+
"""Send CONNECTION_CLOSE for a transport error and stop processing."""
|
|
482
|
+
outgoing.append((level, [qframes.ConnectionCloseFrame(code, reason)]))
|
|
483
|
+
self.closed = True
|
|
484
|
+
|
|
398
485
|
# -- sending -------------------------------------------------------
|
|
399
486
|
|
|
400
487
|
def send_stream_data(self, stream_id, payload, fin=True, offset=0):
|