Keep the error body of a failed streaming request, and fix the three framing defects the review found

[Sunrisepeak]

Supersedes #12, which it carries as its first commit with @Cloud_Yun's authorship intact. Fixes #11.

It is one PR rather than two because #12's head is on a fork I cannot push to, and the second half is what makes the first half usable on the library's own defaults.

The reported defect, confirmed

One program, one source file, built against master and against this branch with target/ wiped between them:

master      status=418 events=0 body.size()=0
this branch status=418 events=0 body.size()=135

events=0 confirms the mechanism and not just the symptom: httpbin's teapot document does contain a blank line, so SseParser finds a boundary — the block it extracts has no data:, event: or id: field, so dispatch_event_ returns without pushing. The bytes reached the parser and died there.

The fix is placed correctly. dispatch is the single funnel for every body byte on both framing paths, and captureBody is decided after the headers, where statusCode is final (send_stream follows no redirects). Capturing there is also better than reaching into SseParser's buffer, which is not the whole body once any event has been dispatched.

1. A declared Content-Length — which is why the test had to close the connection

send_stream had no branch for it: a response that was not chunked was read until the connection closed, whatever its headers said. On the library's defaults (keepAlive = true) the server does not close, and the loop ran until readTimeoutMs expired. The evidence was in the test itself:

cfg.keepAlive = false;  // so the server closes and the read loop ends

Measured against /status/418:

keepAlive = false   status=418 body=135   elapsed  1370 ms
keepAlive = true    status=418 body=135   elapsed  9379 ms   (readTimeoutMs = 8000)
after this change:  status=418 body=135   elapsed  1192 ms

The body arrived either way; on the configuration a caller actually gets, it arrived a full read timeout late — a minute, at the shipped default of 60000. send() has had this branch throughout, which is the same asymmetry between the two entry points that #11 is about.

The live test now runs on the default configuration and asserts the elapsed time. A test that closes the connection to make the loop end is examining the one arrangement in which the defect does not appear.

2. A chunk size that does not parse is not a terminal chunk

parse_hex returns what it accumulated when it meets an unrecognised character, and 0 for an empty line — and read_line returns an empty line on a timeout or a closed connection. A stream that was cut short therefore read as a stream that ended cleanly, and the loop reported success.

#9 established parse_chunk_size_line for exactly this and it reached download_to_file alone; send and send_stream were left on the old parser.

3. Content-Length was parsed by keeping the digits

Measured, by compiling that parser on its own:

"135"                  -> 135
"abc"                  -> 0                     <- a refusal, read as a real zero
"12abc"                -> 12                    <- the reader stops twelve bytes in
"-1"                   -> 1                     <- the sign is discarded
"99999999999999999999" -> 7766279631452241919   <- wraps, in silence

The last two are the ones no care at the call site could recover from, because what it receives is a plausible number. parse_content_length is exported and shaped like parse_chunk_size_line, for the reason #9 gave — it is the half of the body framing that can be examined without a server — and both readers use it.

Criteria

Six unit tests over the two pure parsers, and two live ones: the failed stream on the default configuration with the elapsed time asserted, and a chunked 2xx asserted to leave body empty and return promptly, since the chunked branch is the one this change restructured around.

17 tests from 6 test suites pass, plus 3 in test_resolver.

And it works on openkal

tinyhttps builds and runs on openkal-musl: statically linked, zero PT_INTERP, TLS and DNS working, and this change behaves identically there.

One thing invisible from inside this library, recorded so nobody has to re-derive it. Socket::wait_readable is poll_fd, and on openkal-linux before 0.7.1 the bounded wait was performed on the descriptor below the one it then transferred on — so readTimeoutMs silently did nothing:

/delay/10 with readTimeoutMs = 2000
  host gnu (control)      status=0    elapsed  3051 ms
  openkal-linux 0.7.0     status=200  elapsed 11350 ms   <- waited out the server
  openkal-linux 0.7.1     status=0    elapsed  2994 ms

Nothing here needs to change for it; it is fixed beneath, in mcpplibs/openkal-linux#19.

[Sunrisepeak]