Fixes #286

Carlos Garcia Campos authored Jun 29, 2022 and Carlos Garcia Campos committed Jun 30, 2022

This means it's a graceful goaway and we should not allow new requests,
another goaway is expected with the actual last stream id that should be
processed.

Fixes #233

We don't support http/2 proxies yet.

(get:18601): libsoup-WARNING **: 11:25:03.814: (../libsoup/soup-session.c:318):soup_session_dispose: runtime check failed: (soup_connection_manager_get_num_conns (priv->conn_manager) == 0)

(get:18601): libsoup-WARNING **: 11:25:03.814: (../libsoup/soup-connection-manager.c:78):soup_host_free: runtime check failed: (host->conns == NULL)

This happens because we increase the in use counter of the connection
when RST_STREAM message is sent, that is decreased when the frame is
actually sent. In case of IO error, like socket timeout, we fail to send
the RST_STREAM frame, and the in use counter of the connection is not
decreased. We now process all pending closed messages when a frame fails
to be sent due to session being closed.

Fixes #284

The connection thread owner might change, so the context where the idle
timeout source was attached might be destroyed while the connection is
still alive. So, better use the session context always, since
disconnecting at idle state is always safe from the session thread.

It's not thread safe and it's accessed by message IO from multiple
threads. Session features are not that many so iterating every time
should be fast enough.

GWeakRef is thread safe

We can use the same approach as http2 backend and call
soup_logger_log_request_data() from the body stream wrote data callback.

nghttp2 session can't be used by multiple threads at the same time, so
we need to ensure that only messages from the same thread share the
connection. Connections in idle state can be reused from other threads,
though but we need to ensure all the pending IO is completed before
switching to another thread. When the connection switches to IN_USE
state, the current thread becomes the owner of the connection IO. In the
case of HTTP/2 there might be session IO not related to a particular
message, in that case a thread with no default context is considered
synchronous and all IO that is not explicitly sync or async will be
sync.

Add blocking parameter to SoupBodyInputStreamHttp2::need-more-data and
only do sync IO when input stream read is blocking too.

Also use a condition for sync requests to wait until a connection is
available.

Ensure that queue items are only processed in the same thread they were
created.

Also reuse the host address for connections to the same host.

Otherwise we get a protocol error since Host header is replaced by :authority pseudo-header field in HTTP/2.

Fixes #278

Carlos Garcia Campos authored Jun 01, 2022 and Patrick Griffis committed Jun 02, 2022

In case of cancellation the SoupHTTP2MessageData might have already been
destroyed.

This is a leftover from the soup3 redesign. The plan was to move the
authenticate signal from Session and SoupAuthManager to SoupMessage, but
I forgot to remove the signal declaration from SoupAuthManager. There's
no actual API break because we never emitted the signal, so this can't
break anything.

Correct a typo in the property name, it should be 'authority' instead.

This API doesn't listen on both ipv4/ipv6 but other APIs do.

Michael Catanzaro authored May 04, 2022 and Michael Catanzaro committed May 06, 2022

Understanding that RFC 4559 exists would help anybody reading the API
docs, and also anybody working on this file.