GitLab

Instead, keep the closed object around. This allows differentiation
between the states: TCP support was never initialised; and TCP support
was initialised but is now closed.

Both state changes need some follow-up code executed immediately after,
which was duplicated in a number of places. Factor that out. This
introduces no behavioural changes.

This clarifies the code a little, and does not introduce functional
changes.

This removes some hard-coded offsets. It does not introduce any
functional changes.

Rather than reconstructing the flag state when sending a segment, just
store the flags explicitly. This does not introduce any behavioural
changes.

This is needed for the upcoming new test suite for pseudo-TCP. It
shouldn’t be used in normal code — only in tests.

Ideally, the pseudo-TCP code should originally never have called
g_get_monotonic_time() itself, and should have always taken a time
parameter from the caller; then it would be more testable.
Unfortunately, API guarantees prevent this from being changed now.

This should make debugging a little clearer.

The on-the-wire flags (FIN, RST, ACK, etc.) should be in an enum to
clarify the code a little. This introduces no functional changes.

This tidies things up a little. No functional changes.

This ensures UTF-8 output is printed correctly.

This clarifies the log output a little.

When freeing candidates (component_free_socket_sources()), the sockets
which back Component.selected_pair.[local|remote] are closed and their
addresses destroyed. Component.selected_pair should be cleared as well
to allow calling code to condition on (Component.selected_pair == NULL)
to see if it’s invalid.

This introduces no functional changes.

This simplifies the code a little. No functional changes.

Previously, an EWOULDBLOCK return value from the low-level socket calls
(including PseudoTcpSocket) would be represented by a zero number of
bytes (or messages) read by the agent. This conflicts with the use of
zero to represent end of stream (EOS) for pseudo-TCP connections, where
the sender has indicated that they are not going to send any more bytes.

So, now use GError (G_IO_ERROR_WOULD_BLOCK) to represent EWOULDBLOCK,
just like the GSocket functions. Zero is reserved exclusively for if:
 • the number of requested bytes/messages is zero; or
 • reliable mode is enabled and EOS is reached.

This does change the documented behaviour of the NiceAgent send/recv
API, but only by allowing a new behaviour (returning zero) rather than
by changing an existing one, so it should be OK.

We’re dealing with unsigned bytes here, not chars. This will become
important when adding new TcpOptions numbered from 254 downwards.

New convenience API to check if the remote end of a pseudo-TCP socket
has been closed (but not necessarily the local end). This is currently a
stub implementation, but will be used fully once pseudo-TCP FIN–ACK
support lands.

New convenience API to check if the socket is in state TCP_CLOSED.

By validating state changes, we can verify that the implementation
conforms to the RFC 793 state machine at runtime. This will become more
important when FIN–ACK support is added, adding more states.

This is to use keepalives to check if the connection is still ongoing. If
they don't get a reply, then we can assume that the connection has died.

This needs to not happen in the case of ICE-TCP.

The signal is only connected when setting an agent, if no agent
has been set, there will be no signal.

ssize_t should definitely be signed, not unsigned.

As spotted by B Andrei on the mailing list.

At that point, (len > 0), since there are conditions above handling the
(len == 0) and (len < 0) cases, both of which break from the loop.

Coverity issue: #29325

Otherwise, it claimed it was connected when the component was in the FAILED
state, when it should really have gone to connecting.

Set candidate pairs from discovered peer-reflx tcp-passive candidates into DISCOVERED state so it doesn't fail if the other side doesn't reply to our binding request

The retransmissions would timeout after 600ms which caused the TCP connections
to timeout before it's able to connect. TCP sockets need to timeout
after 8 seconds instead.

This reverts commit 18e5dff4.

The pseudo_tcp_socket_get_next_clock returns the next clock in terms
of g_get_monotonic_clock / 1000, however, it gets cropped to guint32.
When we try to find the interval, by substracting the current time as
a guint64, it will return a negative value, which prevents an integer
overflow by setting the timeout to 0. This causes the notify_clock
timeout to be called all the time by the mainloop, taking 100% of CPU.

This way all the debug can be controlled from one place.

Also disable -Wsuggest-attribute=format with -Werror because gcc 4.8.3
erroneously suggested it.