Hi, HAProxy 3.3.18 was released on 2026/11/18. It added 133 new commits after version 3.3.17.
This release is mostly made of backports of the fixes shipped in 3.4.8. It starts with four important fixes. A peer could send a message whose payload did not fit in the channel once the buffer reserve was accounted for: the stream was then marked as waiting for room although nothing had been transferred, a state that can never be resolved. The H2, H3 and QUIC multiplexers treated it as an internal error and killed the worker; they now report a regular stream error. In the same conditions a hard assertion in the buffer shift code could fire, which is now relaxed to only reject truly impossible moves. Crashes could be experienced because of these issues, so do not delay the upgrade. The rest of the release focuses on issues that can be observed on a running platform: a cache poisoning with "process-vary", connection failures with QUIC behind wildcard listens, truncated or stalled HTTP/1 responses, malformed HTTP/3 traffic crashing the process, several remotely triggerable crashes, a leak of file descriptors and a few others that can exhaust resources over time, and the delivery of signed certificate timestamps which was broken in several cases. Three behaviour changes deserve attention: "cache-use"/"cache-store" rules are now rejected in "defaults" sections, kTLS is now refused on OpenSSL versions affected by a known upstream bug (the new "tune.ssl.ktls-unsafe" option allows opting in anyway), and the HTTP/1 parser now rejects more invalid request targets. It also synthesizes a missing Host header from the request target, so host-based rules apply to what is really sent to the server. * buf/muxes: A stream could be left waiting for room that could never come. When data could not be moved from a receive buffer to the channel because the channel was empty but its reserve left no usable room, the stream was flagged as waiting for room even though nothing had been transferred, and that state could never be resolved. The H2, H3 and QUIC multiplexers detected it as an internal error and aborted the process. They now report a stream error, so only the affected stream is closed. Under the same conditions, a hard assertion in the buffer shift code could also fire; it is relaxed to only reject truly impossible moves. Reported with a reproducer and a fix proposal by Adam Crawford; the buffer assertion was found by code analysis (Yuqi Qiu and Xiang Li, Nankai University). * cache: With "process-vary on", a cached variant could be delivered to clients it was not meant for. When a server varies its response on different headers depending on the request (typically "Vary: Origin" added only when an Origin header is present, as most CORS implementations do), a variant stored for one client was delivered to every client of the resource, whatever its Origin or Referer. Any client could thus poison the cache for all the others, breaking the CORS checks of legitimate sites or mixing contents meant for different referrers. This requires "process-vary" (not the default), but must be considered as a cache poisoning issue for deployments that enable it. Two other cache bugs were fixed: a configuration with two "cache-use" rules that both hit leaked an applet and a cache row on every request, until memory and cache space were exhausted (any client could trigger it by requesting cached objects), and "show cache" could crash or skip entries when several caches were configured. Finally, "cache-use" and "cache-store" rules declared in a "defaults" section never worked and could crash or silently break caching; they are now rejected with an explicit alert at startup, so they must be moved to the proxies. * mux-h2/h3: Host and path based rules could be bypassed when forwarding absolute URIs. When a request carried an absolute URI (e.g. "GET http://host/path"), the authority and the path sent to an HTTP/2 or HTTP/3 server were not extracted the same way as HAProxy's own analyzers do it: the authority stopped at the first '/' instead of the first '/', '?' or '#', and the userinfo was not stripped correctly (not at all on H3, up to the first '@' instead of the last one on H2). A request evaluated by HAProxy for one host or path could therefore be delivered to the server with another one, bypassing host and path based rules. Both muxes now split absolute URIs exactly like the HTTP analyzers do. * h1: Invalid request targets were accepted and a Host header could be missing. Several ambiguous or invalid request targets were accepted and forwarded as-is to the server. An absolute http(s) URI with an empty host ("GET http:///admin/x") was accepted, although servers using WHATWG-style URL parsers see another host and path in it: this parser differential may be used to bypass host or path based rules. CONNECT requests whose target was not exactly "host:port" ("CONNECT internal:[email protected]:443", "CONNECT allowed.com:443/x", or an empty host) were also accepted, while the Host header was validated against a different value. These requests are now rejected with a 400, or only captured when "option accept-unsafe-violations-in-http-request" is set. In addition, when a request carried no Host header but an authority in its target (absolute-form, or the authority-form of CONNECT), the rules saw no host at all and could not match the real target. A Host header is now synthesized from the authority, with the default port removed, so that rules apply to what is actually sent to the server. * quic: Retry, version negotiation and stateless reset were emitted from the wrong source address. When a QUIC listener is bound to a wildcard address, the address targeted by the client must be used as source for all the datagrams of the connection, otherwise the kernel picks one from the route to the client. This matters when the host has several addresses, typically VIPs configured on a loopback interface behind a load balancer in direct routing mode: QUIC clients usually use connected UDP sockets and silently drop datagrams coming from another address. Packets emitted before any connection exists (Retry, Version Negotiation and Stateless Reset) did not honour this and were sent without a source address. As a result, such clients never received the Retry (handshakes were retried until giving up, intermittently when "quic-force-retry" or the retry threshold was involved), could not downgrade to a supported version, and were not notified of a stateless reset after a restart with a cluster-secret (they waited for their idle timeout instead). Binding the individual addresses instead of, or in addition to, the wildcard one was the workaround. * quic: Several crashes, handshake stalls and timeouts were fixed. A client retiring two connection IDs in the same packet could make HAProxy build a NEW_CONNECTION_ID frame from an already freed connection ID (duplicate IDs with the pool cache, or freed heap contents sent to the peer otherwise). Connections created with a valid NEW_TOKEN were still counted as half-open and subject to the anti-amplification limit, delaying the handshake and making the Retry threshold easier to reach for other clients. An unset loss timer could hide a real one and make the server loop on padded Initial packets without ever retransmitting the Handshake data, stalling the handshake for minutes with some clients. A connection was also closed by the idle timeout while still active when the client only sent non ack-eliciting frames (e.g. ACKs only while an SSE stream is pushed), and ACK_ECN frames carrying optional ranges were misparsed. On backend connections, a Version Negotiation packet or a packet with an unsupported version (which a server may legitimately send) could crash the process; such packets are now dropped. QUIC health checks could crash as well when the connection had no file descriptor, and packets emitted without a connection now retry on EINTR. * h3: Malformed HTTP/3 traffic reaching the glitch threshold could kill the process. When a SETTINGS or QPACK decoding error was detected, or an unknown frame was received, the glitch was counted before the connection error was set. If the count reached "tune.quic.{fe,be}.sec.glitches-threshold", the glitch handler set the connection error first and the caller set it again: the internal consistency check that forbids it aborted the process, remotely triggerable by any client. The error is now always set before the glitch is reported. A stream already scheduled for release could also crash when its last data were read, and a stream reset while output was blocked could still emit STREAM frames after RESET_STREAM, in violation of the advertised final size. * h3: Transfers could be corrupted or never complete. An HTTP/3 POST body larger than the buffer could be forwarded with duplicated data blocks, i.e. with a larger payload than the original. The end of the message was also not reported when a DATA frame wrapped, so the stream was aborted as interrupted. Encoding trailers could corrupt memory when data was still present in the send buffer, valid trailers could close the connection with an internal error when no room was left, and a trailer block larger than a buffer could loop forever before the watchdog fired. An allocation failure while re-encoding a header now closes the connection instead of leaving the stream waiting. The "maxrewrite" limit is now enforced on request and response headers, and the :path pseudo-header is checked for all scheme values (it was only checked for http and https, so an invalid path was accepted with any other scheme). Finally, a request stream closed with a standalone FIN before any valid request or response was received is now rejected instead of being treated as an empty complete message, so it no longer stays accounted and its memory is released promptly. * mux-quic: Flow control, stream resets and shutdown timeouts were fixed. Data discarded when a RESET_STREAM is received were not accounted for in the connection flow control: both peers could diverge over time, until the sender was blocked indefinitely and had to open a new connection, and a legitimate client could even be reported as violating the flow control. A stream reset could also leave the upper layer waiting for an event until its timeout when the stream was already subscribed, and a FIN received with an already known offset did not close the receive side before the timeout. The shut-timeout was reset on every activity, so a connection being closed could stay open indefinitely. Streams were not woken on soft-stop when the listener socket was used, delaying worker termination until their own timeouts. Other fixes: - A crash could be hit on a stream closed remotely twice. - Data could be corrupted after a send buffer realign. - A flow control frame could be used after free when a send error occurred. - An assertion could fire after a frame allocation failure under memory pressure. - A finished stream could linger in the release list. * mux-h1: Responses could be truncated, and transfers stalled. Several cases led to a client receiving a truncated response: a soft-stop while the last response was still being downloaded released the connection and dropped the remaining data; the same happened when the response finished while the request was still being uploaded and the connection had to be closed ("Connection: close", HTTP/1.0, or an early "http-request deny/return" response larger than the buffers); a message truncated by the server but with data still pending was cut too, and the CRLF ending the previous chunk could be lost in zero-copy forwarding, producing an invalid chunked message. Conversely, a bodyless response carrying a content-length could be sent to a client that was then kept alive, so it took the next response as the body of the previous one (this happened with "http-request set-method HEAD" applied to a GET). Transfers could also stall: a pipelined request ending exactly at the end of the buffer was not parsed until "timeout http-request" (or was rejected with a 414 on a valid request), draining more than one buffer of request data left the remaining data and the next pipelined request unprocessed until the client timeout, and an H1 connection could spin on wake-ups while tunnel data was blocked waiting for a CONNECT response. Chunked responses are no longer sent to HTTP/1.0 clients (RFC9112 forbids it): they are now close-delimited. A 101 response following a "100 Continue" in the same segment was rejected with a 502 because the websocket key was searched in the wrong message. Error responses (e.g. 400) were not sent at all when the payload could not be parsed or when a content-length had already been read; they are now emitted before the connection closes, which also lets health checks report an invalid response immediately instead of a timeout. Finally, "option idle-close-on-response" is now honoured during a soft-stop combined with "close-spread-time". * mux-h1/h1: Other robustness fixes. - "h1-case-adjust" rules now match header names regardless of case, as the documentation states. - A request trailer named like "http-send-name-header" is no longer forwarded after the header added by HAProxy. - "option accept-unsafe-violations-in-http-{request,response}" remains effective on the final response after a 1xx, and after parsing restarted on a full output buffer. - The Connection/Upgrade header cleanup is now idempotent when the headers are received in several parts. - In TCP mode, the Upgrade header is no longer modified in flight while HTTP sample fetches are evaluated. - A response whose status code is split across two reads is no longer rejected. - An FCGI response whose headers arrive in several parts no longer loses its content-length. - A 1xx response carrying "content-length: 0" no longer breaks the following final response. - No 408 is sent or logged when a connection that is already closed times out, so "408 <BADREQ>" log lines and failed request counters are no longer inflated. - Fast-forwarding is no longer left disabled for the following streams once one could not use it (performance only). - The "h1_open_streams" counter exposed in the stats no longer drifts (and can no longer become negative) when a stream cannot be created. - "%Ti" and "%Tt" are now correct for streams on an H2/H3 frontend with an H1 server. - Reads are no longer subscribed after a read0 or an error, which could theoretically spin until the server responds. - Data are no longer transferred by swapping buffers when room is reserved for a chunk size. - A NULL opposite endpoint is no longer dereferenced in fast-forwarding. * ssl: kTLS is refused on affected OpenSSL versions, and a worker crash was fixed. With vanilla OpenSSL, a blocked kTLS record keeps referencing the caller's buffer and the library retries from it, even when SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER is set. The H2 fast-forward reuses that buffer, so streams could be corrupted. kTLS is now disabled and reported on the affected versions, with "tune.ssl.ktls-unsafe" to opt in anyway. On newer versions, MSG_MORE is no longer used for kTLS control records, since Linux rejects it: the failed close_notify could leave the tail of the response unsent. "generate-certificates" on a QUIC bind line crashed the worker when the ClientHello had no SNI: connecting to an IP address was enough (SIGSEGV). Separately, a websocket connection could reuse a cached ALPN that does not apply to it, making it attempt the wrong multiplexer and fail; the cached value is no longer used for websockets (0-RTT is therefore not attempted for them). * ssl: Signed certificate timestamps were fixed and extended. A .sctl sidecar file could cause an out-of-bounds read (and possibly a write past an array, depending on the heap contents) when a ClientHello selected a certificate with an SCT list, which any client could trigger. The list was also freed twice when a certificate was shared by several contexts, which could abort the deinit phase and "haproxy -c"; each context now keeps its own copy. On AWS-LC the list was silently ignored, because this library owns the SCT extension and rejects custom extension registration: .sctl files are now honoured there too, and a list rejected by the library is reported as a warning while the certificate remains usable. SCTs were also only delivered in TLS 1.2 and earlier ServerHello messages, so clients negotiating TLS 1.3 never received them; they are now sent in the TLS 1.3 Certificate message as well, with OpenSSL 1.1.1 and later, for the selected leaf certificate and only when the client requested them. SCT delivery over QUIC is not supported (native OpenSSL mishandles custom extensions during context switches). The documentation now states which libraries and TLS versions support it. * ssl: Certificate management from the CLI and inherited server settings were fixed. When "commit ssl cert" was interrupted (e.g. the CLI client closed the connection) after building its new instances in several passes, the freed transaction was still referenced: the next certificate command on the same certificate could crash the process or corrupt memory. A certificate used by more than 10 instances was enough to make the command multi-pass. On the server side, "curves", "sigalgs" and "client-sigalgs" inherited from "default-server" were not duplicated, leading to a use-after-free when the original context was destroyed; they were also leaked when redefined on a server line. Finally, when a QUIC listener served two certificates matching the SNI, the RSA one was selected instead of the ECDSA one if no "ssl-max-ver" was set. * ssl: A new "ocsp-update.timeout" global option bounds OCSP fetches. The HTTP client used to fetch OCSP responses during automatic updates had a connect timeout but no server timeout: a response starting but never completing could hang forever. This task is shared by the whole update queue, so a single stuck responder blocked all further OCSP updates. "ocsp-update.timeout" (10 seconds by default, bare numbers are milliseconds like for the other timeouts) now bounds the whole fetch, and a slow responder is simply retried later following the "ocsp-update.mindelay/maxdelay" rules. * peers: Stick-table updates could be lost or misapplied between peers. When an update carrying a "server_key" did not fit in the peer's output buffer, the new dictionary entry was kept in the transmission cache while the value was never sent. The remote peer then resolved its identifier to an unknown or stale entry, losing the server name for the whole session (or associating it with another server). This was visible during a resync of a table holding server keys with long names. The identifier of updates sent without an explicit one was also byte-swapped on little-endian machines, which could make updates be skipped or resent after a reconnection. In addition, when a peer reconnected, the sync task deadline was overwritten by each peer, so heartbeats to idle peers could be delayed until the remote peer closed the connection for inactivity. On the stick-table side, the dictionary reference held by "server_key" was only released on one destruction path, so memory grew with the number of distinct values that went through the table (expiry, eviction and "clear table" leaked it). * resolvers: Name resolution could fail, crash, or read out of bounds. With a "resolve-net" list mixing IPv4 and IPv6 networks, a record was ignored as soon as a network of the other family was met before a matching one, so the server never got an address and stayed in maintenance (e.g. "resolve-net 2001:db8::/32,10.0.0.0/8" with "resolve-prefer ipv4"). A server of a proxy using a SRV name but without "resolvers" keyword was kept attached to the SRV request of the other servers: the first SRV response could then crash the process, and a reload with a server state file crashed too. Finally, "do-resolve" with a client-controlled value such as hdr(host) could build a DNS name with a 256-byte label or an embedded NUL, leading to out-of-bounds reads and disclosure of heap data in DNS queries. * mux-fcgi: Responses were truncated for slow clients. The FCGI connection timeout was enforced even when streams were still attached. With a slow client, HAProxy stops reading from the FastCGI server once buffers are full, nothing happens on the connection for a while, and it was killed in the middle of the response: the client received a truncated response, logged as "SD--", and the server got a reset while blocked in write(). The timeout is now only enforced when no stream remains attached, as already done for H2; a FastCGI server that does not answer at all still gets a 504 after "timeout server". * stream/spoe/hlua/bwlim: Several busy loops ending in a watchdog kill were fixed. With a filter engine bound to "on-http-response" (e.g. SPOE) and an H2 backend answering early and resetting its stream while the request body was still being uploaded, the stream spun until the watchdog killed the worker. The analysis timer is now reset when analysers are stripped on error, SPOE stops waiting on a dead producer channel, and "http-response" actions get a final chance when the server dies. The same analysis-timer reset used to drop an auto-close that forwarded shutdowns on the request error path, which could freeze a stream with no analyser left; auto-close is restored. A Lua filter using "filter.wake_time()" could also leave the analysis timer armed after it was done with the channel, causing a busy loop long after the filter finished; wake-ups are now armed on the stream task instead. The bandwidth limitation filter could report more data than the channel held when a shared limitation used a burst size, corrupting the channel and spinning at 100% CPU, and the SPOP multiplexer could leave a connection stuck with a full demux buffer, timing out all its streams (SPOE timeouts under pipelining with large ACK frames). * fd/connection: A descriptor leak could exhaust "maxsock", and a descriptor could be closed twice. When an accepted connection could not be prepared, for instance because "maxsslconn" was reached, its file descriptor was left open. Incoming connections on that listener kept accumulating leaked descriptors even after SSL connections were released, until "maxsock" was exhausted, which also prevented non-SSL frontends from accepting. Conversely, when a connection failed during a health check and the socket had already been closed, the descriptor could be closed a second time, closing an unrelated file descriptor. * listener: "rate-limit sessions" was multiplied by the number of thread groups. Since session rates are accounted per thread group, the limit was compared for each group against the full configured value: a frontend accepted up to the limit multiplied by the number of groups, and the limit was never enforced when some groups received no traffic. No explicit thread setting is needed to be affected, since the default "performance" CPU policy creates one group per CCX on machines with several of them. With three groups, a limit of 100 sessions/s measured about 270 sessions/s on a bind using all groups and more than 21000 on a bind restricted to the first one. The limit now applies to the frontend as a whole; "thread-groups 1" was the workaround. * leastconn: Requests got 503 responses although a backup server was available. With "balance leastconn" and "option allbackups", when the last active server went down or into maintenance, the idle backup servers were not found because the lookup started from a key that was not reset. Streams were queued in the backend and every request ended with a 503 after "timeout queue", even though a backup server was up, until a server was queued at a lower key again. * task: A task could be destroyed twice in master-worker mode. A task already flagged as killed but still linked in a queue could be destroyed a second time when a forked child cleans the tasks before executing (master-worker mode with a "peers" section and a local peer). This aborted the child with SIGILL on older branches; the leftover window is now closed by ignoring already-killed tasks, which the scheduler frees when dequeuing them. * samples: A crash and two wrong results were fixed in converters. The time converters ("ms_ltime", "us_ltime", "ms_utime", "us_utime") did not check that the formatted result was available, so a configuration using a long format (e.g. many "%N") accepted by "haproxy -c" crashed the process on the first request evaluating it; a failed allocation had the same effect with an ordinary format. "jwt_member_query" only checked one of the two error codes of the base64 decoder, and the "ungrpc" converter could return a field taken from the wrong message when a body carried several gRPC messages. * cfgparse: Unsupported password hashes are rejected. "crypt()" may return NULL or an error token for unsupported hash types (on Debian/Ubuntu, strings starting with '*'), and this was not checked, so a user or group password using such a hash was accepted at startup and could never authenticate. It is now detected during configuration validation. It is strongly recommended to upgrade to this version. Crashes could be experienced because of the four fixes listed first. No configuration change is needed to benefit from them, and none of them alters the protocol or the configuration syntax: any 3.3.x build can be replaced in place. Deployments exposing HTTP/2 or HTTP/3 to the Internet, and those enabling the cache with "process-vary", should treat this release as mandatory. Thanks everyone for your help on this release. Please find the usual URLs below : Site index : https://www.haproxy.org/ Documentation : https://docs.haproxy.org/ Wiki : https://github.com/haproxy/wiki/wiki Discourse : https://discourse.haproxy.org/ Slack channel : https://slack.haproxy.org/ Issue tracker : https://github.com/haproxy/haproxy/issues Q&A from devs : https://github.com/orgs/haproxy/discussions Sources : https://www.haproxy.org/download/3.3/src/ Git repository : https://git.haproxy.org/git/haproxy-3.3.git/ Git Web browsing : https://git.haproxy.org/?p=haproxy-3.3.git Changelog : https://www.haproxy.org/download/3.3/src/CHANGELOG Dataplane API : https://github.com/haproxytech/dataplaneapi/releases/latest Pending bugs : https://www.haproxy.org/l/pending-bugs Reviewed bugs : https://www.haproxy.org/l/reviewed-bugs Code reports : https://www.haproxy.org/l/code-reports Latest builds : https://www.haproxy.org/l/dev-packages --- Complete changelog : Adam Szymanski (1): BUG/MEDIUM: mux-spop: Don't include DALLOC/DFULL flags in SPOP_CF_DEM_BLOCK_ANY Aleksandar Lazic (2): BUG/MEDIUM: leastconn: reset the smallest key when backups take over BUG/MEDIUM: mux-fcgi: do not enforce the timeout on connections with streams Alex Szakaly (1): MEDIUM: ssl: add ocsp-update.timeout global option Amaury Denoyelle (33): BUG/MINOR: check: do not inspect errno if conn FDLESS BUG/MINOR: mux_quic: do not crash on SE_SHR_DRAIN shut BUG/MEDIUM: h3: fix BUG_ON() crash with glitch on SETTINGS parsing BUG/MEDIUM: h3: fix BUG_ON() crash with glitch after QPACK dec err BUG/MINOR: h3: fix risk of BUG_ON() crash with glitch on unknown frame BUG/MINOR: h3: fix BUG_ON() crash with glitch on htx_set_eom() failure BUG/MAJOR: mux-quic: prevent crash on QCS already set for purging BUG/MINOR: mux_quic: prevent purgeable QCS lingering BUG/MINOR: mux_quic: report conn error on RESET_STREAM fctl violation BUG/MEDIUM: mux_quic: account discarded data in connection flow control BUG/MINOR: mux_quic: account data in conn fctl on early detach BUG/MEDIUM: mux_quic: notify stream on RESET_STREAM reception BUG/MEDIUM: h3: fix end-of-input report on DATA wrapping BUG/MEDIUM: h3: fix incorrect DATA size block on DEM FULL BUG/MINOR: quic: rearm packet on packet received even non ack-eliciting BUG/MEDIUM: mux_quic: prevent uaf on fctl frame after send error BUG/MEDIUM: h3: fix memory corruption on trailers parsing realign BUG/MINOR: mux_quic: wake streams on soft-stop using listener socket BUG/MINOR: h3: enforce maxrewrite on request headers BUG/MINOR: h3: fix crash with maxrewrite on response headers BUG/MEDIUM: mux_quic: fix crash on QCS double remote close BUG/MINOR: mux-quic: prevent send corruption on buf realign BUG/MEDIUM: mux_quic: fix FIN received with an already known offset BUG/MAJOR: h3: always check :path for all scheme values BUG/MEDIUM: h3: prevent conn failure on trailers decoding without space BUG/MINOR: h3: do not retry on trailers too large BUG/MINOR: h3: do not wait after Tx realloc failure BUG/MEDIUM: mux_quic: do not reset timeout after shut BUG/MINOR: quic: fix ACK_ECN parsing after optional ack ranges BUG/MEDIUM: mux_quic: fix Rx flow control increment on RESET_STREAM BUG/MEDIUM: h3: reject standalone FIN on invalid request/response BUG/MINOR: mux_quic: fix possible BUG_ON() after frame alloc failure BUG/MAJOR: mux_quic: remove data not yet sent on reset stream Björn Jacke (1): DOC: config: explain per ACL line limitations Chris Staite (1): BUG/MEDIUM: ssl/cli: reset the ongoing transaction when "commit ssl cert" is interrupted Christopher Faulet (45): BUG/MEDIUM: mux-h1: Don't close the connection on a payload parsing error BUG/MEDIUM: h1: make the Connection/Upgrade headers cleanup idempotent BUG/MINOR: h1: keep accepting unsafe violations after a parser reset BUG/MEDIUM: h1: don't rewrite the Upgrade header when not cleaning headers BUG/MEDIUM: h1-htx: don't stall on messages ending exactly at the buffer's end BUG/MEDIUM: mux-h1: don't truncate the response when closing after draining BUG/MEDIUM: mux-h1: don't truncate responses on soft-stop BUG/MINOR: h1: don't use uninitialized start line pointers when restarting BUG/MINOR: mux-h1: only reset the session's timing info on the frontend side BUG/MINOR: mux-h1: fix the open streams counter on stream creation failure BUG/MINOR: mux-h1: don't dereference a NULL opposite sedesc in h1_fastfwd() BUG/MEDIUM: mux-h1: don't lose the end of the previous chunk in h1_make_chunk() BUG/MEDIUM: mux-h1: don't stall when draining more than a buffer of data BUG/MINOR: mux-h1: reset the content-length/chunking state after a 1xx response BUG/MINOR: mux-h1: don't keep fast-forwarding disabled for the next streams BUG/MINOR: mux-h1: don't report a 408 error on timeout of a closed connection BUG/MEDIUM: mux-h1: don't swap buffers when transferring data with a reserved offset BUG/MEDIUM: mux-h1: don't lose error responses once a content-length was parsed BUG/MINOR: h1: forget a previous pass' results when parsing headers only BUG/MEDIUM: mux-h1: don't send chunked responses to HTTP/1.0 clients BUG/MINOR: mux-h1: convert the <from> argument of h1-case-adjust to lower case BUG/MINOR: mux-h1: only rely on the client's method for bodyless responses BUG/MINOR: mux-h1: search the websocket key in the right message BUG/MINOR: mux-h1: don't forward request trailers named like server name header BUG/MEDIUM: mux-h1: don't spread-close idle conns with idle-close-on-response BUG/MINOR: mux-h1: Don't subscribe for receives once read0 or error received BUG/MEDIUM: bwlim: never burst more than the pending data in input BUG/MEDIUM: mux-h1: Don't subscribe for sends while output is blocked BUG/MEDIUM: h1: reject CONNECT request targets other than "host:port" BUG/MEDIUM: h1: build a missing Host header from the authority of the URI BUG/MINOR: h1: reject CONNECT authorities with an empty host BUG/MEDIUM: h1: reject absolute http(s) URIs with an empty host BUG/MEDIUM: connection: don't leak the fd of an accepted connection BUG/MEDIUM: hlua/filters: Never arm the analysis timer for the lua wake-ups BUG/MINOR: http-ana: also set FINAL on http-response actions on server error BUG/MEDIUM: spoe: stop waiting on a dead producer channel BUG/MEDIUM: resolvers: detach servers without resolvers from the SRV request BUG/MEDIUM: resolvers: don't ignore records not matching a resolve-net family BUG/MEDIUM: cache: fix "show cache" crash/skip with several caches BUG/MAJOR: cache: do not mix variants varying on different headers BUG/MEDIUM: cache: do not create a second applet when two cache-use rules hit BUG/MEDIUM: cache: forbid cache rules in defaults sections BUG/MEDIUM: mux-h1: Report EOS when a demux error is handled by the app layer BUG/MEDIUM: stream: reset analyse_exp when analysers are stripped on error BUG/MEDIUM: stream: keep channel_auto_close() on the request error path Frederic Lecaille (8): BUG/MEDIUM: peers: keep the earliest sync task deadline BUG/MINOR: quic: valid NEW_TOKEN connections are counted as half-open BUG/MEDIUM: peers: do not keep a dict entry cached when its update was not sent BUG/MEDIUM: peers: fix byte order of last_get on updates without identifier BUG/MEDIUM: ssl-gencert: fix a NULL dereference with QUIC listeners BUG/MINOR: sample: realign the ungrpc converter on message boundaries BUG/MEDIUM: quic: fix loss time selection in quic_loss_pktns() BUG/MINOR: stick-table: release server_key on any stksess destruction Gihyeon Ryu (1): BUG/MAJOR: quic: don't reference a retired CID from a NEW_CONNECTION_ID frame Manu Nicolas (1): BUG/MEDIUM: listener: enforce rate-limit sessions across thread groups Martin Mirchev (1): BUG/MINOR: sample: fix NULL dereference in the ltime/utime converters Olivier Houchard (8): BUG/MEDIUM: resolvers: reject too long labels when encoding a name BUG/MAJOR: mux-h2: split absolute URIs like the HTTP analysers do on output BUG/MEDIUM: h3: split absolute URIs like the HTTP analysers do on output BUG/MEDIUM: server: Don't use the cached ALPN for websocket BUG/MEDIUM: fd: Mark a fd as dead on early close BUG/MEDIUM: mux-h1: don't drop pending output on a short content-length BUG/MEDIUM: ssl: disable kTLS on OpenSSL versions affected by a known bug BUG/MEDIUM: ssl: don't use MSG_MORE for kTLS control records Remi Tricot-Le Breton (1): BUG/MINOR: sample: Fix wrong 'base64urldec' return value check in 'jwt_member_query' William Dauchy (1): BUG/MINOR: quic-be: drop long header packets with unsupported version William Lallemand (16): BUG/MEDIUM: task: do not destroy twice the tasks already killed in mworker_cleantasks() DOC: configuration: document AWS-LC compatibility restrictions BUG/MINOR: ssl: copy curves, sigalgs and client_sigalgs in srv_ssl_settings_cpy() BUG/MINOR: ssl: free curves, sigalgs and client_sigalgs in ssl_sock_free_srv_ctx() BUG/MINOR: ssl: free curves, sigalgs and client_sigalgs in srv_parse_*() BUG/MEDIUM: ssl: fix an out-of-bounds read on SSL_CTX switch with a .sctl file BUG/MINOR: quic/ssl: record TLS version bounds for certificate selection BUG/MINOR: cfgparse: detect unsupported crypt() hashes on Debian/Ubuntu BUG/MEDIUM: ssl: support SCTL with AWS-LC BUG/MINOR: ssl: fix a double-free of the .sctl buffer with several contexts BUG/MINOR: ssl: support SCTL in TLS 1.3 Certificate messages DOC: configuration: clarify SCT support by TLS library and version BUG/MINOR: ssl: exclude wolfSSL from custom extension support SCRIPTS: vtest: allow overriding the Git repository URL CI: github: use haproxytech/VTest2 for regression tests CI: github: use haproxytech/VTest2 for musl regression tests Willy Tarreau (5): BUILD: makefile: better support git worktrees BUG/MAJOR: buf: make the shift distance check less strict in b_move() BUG/MAJOR: mux-h2: fail on impossible data transfers in rcv_buf() BUG/MAJOR: h3: do not panic on HTX_FL_PARSING_ERROR after htx_xfer() BUG/MAJOR: mux-quic: fail on impossible data transfers in rcv_buf() Yeonggi Kim (7): MINOR: quic: use the listener for Retry and Version Negotiation emission MINOR: quic: define a function to emit a datagram on a listener socket BUG/MEDIUM: quic: use datagram destination as source for Retry BUG/MINOR: quic: use datagram destination as source for stateless reset BUG/MINOR: quic: use datagram destination as source for version negotiation REGTESTS: quic: check Retry source address on a wildcard listener BUG/MINOR: quic: handle EINTR on emission of packets without connection -- Christopher Faulet

