Hi,

HAProxy 3.4.8 was released on 2026/11/18. It added 153 new commits
after version 3.4.7.

This release contains 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, 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.

The volume of automated reports we receive keeps growing, and most of them
do not correspond to problems actually met in the field: a large part of our
time is now spent triaging and fixing those. We therefore restricted this
release to fixes for reported issues and for bugs that can have a visible
impact. The remaining pending backports will be shipped in the next release.

* 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. This dates back to 2.1 for H2; H3
  backends are still experimental but were fixed too.

* 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 GOAWAY parsing error, or a QPACK decoding error,
  reached "tune.quic.{fe,be}.sec.glitches-threshold", the connection error
  was set twice and an internal consistency check aborted the process,
  remotely triggerable by any client. The glitch reporting was reworked for
  all these cases. 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.
  - A stream accounting counter could underflow when a connection could not be
    initialized.
  - The server ALPN was read outside the server lock with 0-RTT.
  - A QUIC backend health check could hit an assertion when shutting a stream
    down.
  - An unidirectional hq-interop stream was reset, which the peer may treat as
    a protocol violation.
  - An assertion could fire on an empty QMux record.

* 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.
  - Payload parsing glitches are now reported to the session and counted in the
    stats.

* 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. A
  failed attempt to acquire the certificate lock could also release another
  operation's lock, after which later certificate commands remained blocked.

  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.

  With wolfSSL builds, certificate loading could fail even without any .sctl
  file present: this library provides the custom-extension registration call
  as a stub that always fails, and the SCT fix above now registers the
  extension on every frontend context. The capability is no longer
  advertised for wolfSSL.

* 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). Expired entries were also no longer purged on a
  soft-stop for backends in 3.4, since their management task was not
  allocated.

* 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/cli: 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. Similarly, a Lua filter
  using "filter.wake_time()" could 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 also 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 and accepting
  new ones (SPOE timeouts under pipelining with large ACK frames). Finally,
  a CLI command with a payload line longer than "tune.bufsize" could make
  the CLI loop on the same partial line, burning CPU without ever executing
  the command or unblocking the client.

  The same analysis-timer reset used to drop an auto-close that forwarded
  shutdowns when an unhandled client error was caught, which could freeze
  the stream once no analyser was left; auto-close is restored.

* http-ana: Server-sent events with a charset were not detected as such.

  Since 3.4, responses advertising "text/event-stream" automatically have
  the equivalent of "option http-no-delay" enabled towards the client, so
  that events are forwarded immediately. The media type was compared
  exactly, so the common form "text/event-stream; charset=utf-8" was not
  recognized and events could be delayed by up to ~200 ms.

* 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.

* applet: A size check was missing with "tune.bufsize.large".

  With "tune.bufsize.large" and "wait-for-body" using "use-large-buffer",
  the channel buffer may be larger than the applet input buffer. A fast-path
  transfer could then attempt to move more data than the destination could
  hold, triggering a fatal bounds check and terminating the worker.

* 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.

* stats-file: Counter restoration over reloads was broken for backends.

  With "shm-stats-file", shared counters are preserved across reloads by
  associating objects through their GUID. Since the per-thread-group
  counters were dynamically allocated, the mechanism checked the frontend's
  shared map instead of the backend's one for backend objects, so the
  restoration aborted and backend counters were no longer restored
  consistently from one process to the next.

* deviceatlas: A hot-reloaded atlas could crash the process or flood the logs.

  While a new data file was compiled, other threads kept using the current
  atlas without any lock, and the old image was freed under a lock they did
  not take: a request could search a freed or partially copied atlas and
  crash, while the other threads spun on the lock long enough for the
  watchdog to fire with large files. The swap is now performed with all
  threads paused.  A failing data file was also retried on every request
  (one alert per request and lowered throughput, and a recompilation each
  time), because the update flag was only cleared on success; it is now
  reported once and retried when a new file is published. A partial path
  written by the scheduler no longer emits a spurious "invalid path" alert,
  "da-csv-conv" no longer uses a stale user-agent evidence id after
  reloading a file with a different header list, and properties are printed
  with the type carried by the result.

* 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 and an incomplete peers
  section is detected.

  "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 (GH
  #3568). A "peers" section declaring the local peer with a server line but
  without the matching "bind" directive made no sense and could crash on
  reload; it is now reported as a fatal configuration error.

* checks/log: An implicit check on a UDP log server no longer uses the TCP API.

  Declaring a UDP log server with "check" but without a check port started a
  check using TCP-oriented functions on a datagram address: the check always
  failed, and it could even crash on systems where the network API does not
  expect a datagram family with "connect()". The check now falls back to TCP
  (UDP and ICMP checks are not supported), and the documentation describes
  the pitfall.

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.4.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.4/src/
   Git repository   : https://git.haproxy.org/git/haproxy-3.4.git/
   Git Web browsing : https://git.haproxy.org/?p=haproxy-3.4.git
   Changelog        : https://www.haproxy.org/download/3.4/src/CHANGELOG
   Dataplane API    : 
https://github.com/haproxytech/dataplaneapi/releases/latest
   OpenTelemetry    : https://github.com/haproxytech/haproxy-opentelemetry
   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 Crawford (1):
      BUG/MEDIUM: applet: check buffer sizes before HTX transfer

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 (40):
      BUG/MINOR: mux_quic: prevent RS/SS on unistream with hq-interop
      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 on GOAWAY 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
      Revert "BUG/MAJOR: mux-quic: do not crash on connection error after glitch 
threshold"
      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/MAJOR: mux_quic: remove data not yet sent on reset stream
      BUG/MEDIUM: mux_quic: do not reset timeout after shut
      BUG/MINOR: mux_quic: fix possible BUG_ON() after frame alloc failure
      BUG/MINOR: mux_quic: fix ALPN retrieval from server
      BUG/MINOR: mux_quic: fix stream elasticity dec on qcm_init() failure
      BUG/MEDIUM: proxy: fix stick table expired entries cleanup on stopping
      BUG/MINOR: quic: fix ACK_ECN parsing after optional ack ranges
      BUG/MINOR: qmux: remove invalid BUG_ON() on empty record
      BUG/MEDIUM: mux_quic: fix Rx flow control increment on RESET_STREAM
      BUG/MEDIUM: h3: reject standalone FIN on invalid request/response

Aurelien DARRAGON (3):
      BUG/MEDIUM: stats-file: shm-stats-file be counters not working anymore
      BUG/MINOR: cfgparse/peers: warn and prevent undefined behavior when peers 
is missing bind info
      BUG/MINOR: checks/log: force implicit UDP checks as TCP for log backend

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 (47):
      BUG/MEDIUM: cli: Fix parsing of big payloads with dynamically allocated 
buffer
      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/MINOR: mux-h1: report payload parsing glitches to the session
      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/MEDIUM: stream: reset analyse_exp when analysers are stripped on error
      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: keep channel_auto_close() on the request error path

David Carlier (5):
      BUG/MEDIUM: deviceatlas: isolate threads while swapping the reloaded atlas
      BUG/MINOR: deviceatlas: refresh the user-agent evidence id after a reload
      BUG/MINOR: deviceatlas: ignore the scheduler's update in progress marker
      BUG/MINOR: deviceatlas: use the result's property type when printing
      BUG/MINOR: deviceatlas: consume a scheduled update before loading it

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 (9):
      BUG/MEDIUM: resolvers: reject too long labels when encoding a name
      BUG/MAJOR: mux-quic: do not crash on connection error after glitch 
threshold
      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):
      DOC: configuration: document AWS-LC compatibility restrictions
      BUG/MEDIUM: task: do not destroy twice the tasks already killed in 
mworker_cleantasks()
      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/MEDIUM: ssl/cli: don't unlock the certificate lock after a failed 
trylock
      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

Willy Tarreau (6):
      BUILD: makefile: better support git worktrees
      MINOR: http-ana: also match text/event-stream with trailing parameters
      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



Reply via email to