Backpressure mitigation option

The current mode for handling too much backpressure (maxBackpressure) is to skip sending more. This works fine for application protocols that have no hard dependency on history, but silently breaks those who do.

• closeOnBackpressureLimit is a new option that takes bool. The default will be false (skip sending without closing).
• To avoid classic reentry bugs, closeOnBackpressureLimit = true will defer the close handler until next event loop iteration. It will not emit immediately.

Gracefully abort large requests

The server can now initiate a "Connection: close" procedure even if the client didn't. This can be used to refuse large Http bodies while still properly responding (before getting all data). This was possible before only with unreliable hacks but is now implemented correctly as the second argument to HttpResponse::end.

Ancient HTTP 1.0 & more fuzzing

• Benchmarks with ancient HTTP 1.0 (from 1996!) clients such as ApacheBench will now score high, rather than just timeout with no score. This also applies to "Connection: Close" kind of requests.
• The new extension negotiation rewrite of v18.19.0 now has fuzzing tests running.
• negotiateCompression multiple definition fix.

Extension negotiation rewrite

• Introduces a completely rewritten extensions negotiator with accompanying unit tests.
• Adds support for x-webkit-deflate-frame extension for Safari browsers (old, deprecated draft apparently still in use by Safari).
• Significantly more relaxed extension negotiation allowing the client to request certain features we rejected before.
• Fixes a bug where using a non-256KB DEDICATED_COMPRESSOR while getting server_no_context_takeover from client would result in an invalid negotiation (leading to corrupt data sent/received).
• Checked with Autobahn and passing every test.

Pub/sub compression bug

• Fixes a segfault when using a DEDICATED_COMPRESSOR_xKB together with pub/sub, while specifying to not compress.
• Fixes an inconsistency regarding writeHeader(int64) and writeStatus.
• Fixes the last remaining compiler warning when using WITH_PROXY=1.

Multipart parser and other fixes

• Introduces support for parsing multipart POSTs in an efficient and simple way. Runs about 155x faster than Node.js alternatives - especially on parts larger than a few hundred kilobytes.
• The library now compiles without any warnings using -Wall -Wextra -Wpedantic -Wsign-conversion -Wconversion on both GCC and Clang. Hundreds of (non-default) warnings have been fixed in this release and from now we aim to keep things pedantically clean.
• Fixes a permessage-deflate regression introduced in v0.17.4.
• Fixes parsing bugs when compiling using WITH_PROXY=1 (introduced in v18.1.0).

Build fixes

Apparently the added QueryParser of v18.14.0 had multiple definition flaws that have now been fixed and will build properly.

getQuery with key

• HttpRequest::getQuery now takes (optional) key and returns the URI-decoded value if present in the querystring.
• Fuzz test for QueryParser added, with dictionary.
• Make sure to use this feature when possible, as decodeURIComponent is roughly 400x slower.

Fixes

• A particular edge case causing stack buffer overflow of "triggered topics" was found by fuzzing, and has been fixed.
• The newly added ServerName example caused a drop in reported code quality due to a pedantic alert, which has been fixed.

Server Name Indication (and more fuzzing)

Adds App::missingServerName, App::addServerName and App::removeServerName for managing multiple certificates/configurations for SSL.

Fuzzing coverage is now about 95% overall for both uSockets and uWebSockets. This is a big improvement, esp. for uSockets coverage.

Improving fuzzing coverage and fixing bugs

OSS-Fuzz is now reporting 99.5% function coverage and ~94% region coverage. Furthermore there is now fuzzing of large parts of uSockets thanks to libEpollFuzzer - about 80% of non-SSL use. Overall this is a major improvement in fuzzing coverage and has led to new bugs being discovered and fixed.

• TopicTree has seen two bug fixes; one stack overflow when trimming large trees, and one CPU hang when publishing to a large tree using wildcards (which is ill-use according to MQTT).
• Minor misuse of HTTP header BloomFilter has been corrected.

Larger HTTP streams

HttpResponse::onWritable, HttpResponse::getWriteOffset and HttpResponse::tryEnd will now take size_t instead of int wherever size is communicated. This breaks API slightly but allows streaming files larger than 2GB.

Fixes

• Updates fuzzing targets for uSockets 0.5.0
• Minor permessage-deflate tweaks, server_max_window_bits
• Removes unused debug remnants

Meaningful close reasons

The library will now report more meaningful reasons when internally closing a WebSocket:

• Close code 0 is never reported; instead the standard 1005 code will be used to denote missing close code
• Close code 1006 is now accompanied with a meaningful text reason such as "Message too big" or "WebSocket timed out".

Fixes

• Shutting down a WebSocket in the open handler would send WebSocket FIN, but not TCP FIN, causing minor incompatibilities with the Chrome browser.
• AsyncSocket::getBufferedAmount is now unsigned

Fixes

• Update uSockets, fixing SSL builds

Dedicated pub/sub compression support

Pub/sub now supports the use of dedicated compressors, not only the shared one. We've supported dedicated compressors for regular WebSocket::send calls a long time, but now WebSocket::publish will provide the same compression ratios.

A "dedicated" compressor is one with a sliding window, per-socket. This compressor provides better compression for small, mostly-repeated messages in exchange for per-socket memory usage.

A recommended dedicated compressor is the DEDICATED_COMPRESOR_3KB as it uses only 3KB per socket.

Minor features

• App::getNativeHandle and AsyncSocket::getNativeHandle will return the SSL_CTX and SSL pointers, respectively. In the case of non-SSL, the file descriptor or nullptr will be returned.
• maxBackpressure is now applied to WebSocket::send, not only WebSocket::publish. This means any attempt at sending when having too much backpressure will be ignored, skipped, and return success. If you don't want this behavior either disable maxBackpressure or check getBufferedAmount before sending, manually.

Fixes

• Minor corrections to PROXY parser
• Minor changes to unsubscribeAll while closing

Stricter pub/sub guarantees

We've had weird pub/sub behavior reported, caused by the fact that publish is deferred until the end of the event loop iteration. This means that subscribing after a publish may very well end up acting as if you subscribed before publishing, and the opposite for unsubscribe.

In most apps this won't make a difference but now there's stricter guarantees regarding when things happen. Publish still happens at the end of the event loop iteration, but will trigger earlier if needed to keep things in proper sync.