discovery: add the agent pointer to turn debug messages

conncheck: drop some excessively verbose comment

conncheck: wait for a pair until all stun requests are completed

Only the newest stun request may need to be retransmitted, according to
the pair retransmit flag. This is the first element of the
stun_transactions list. Older stun requests are just kept around until
their timeout expires, without retransmission.

The newest stun request is usually the last one that will timeout.
Current code was based on that assumption, causing the pair to fail when
the newest stun request timeout expires. This is not always true, and some
older stun requests may have a greater timeout delay.

So, we should wait until *all* stun requests of a given pair have
reached their timeout.

We also refactor this part of the code, to handle the first stun and the
other stun requests in the same loop.

discovery: use different port numbers for every local host candidates

This constraint is added to handle the situation where the agent runs on
a box doing SNAT on one of its outgoing network interface. The NAT does
usually its best to ensure that source port number is preserved on the
external NAT address and port. This is called "port preservation" in RFC
4787.

When two local host candidates are allowed to have the same source port
number, we increase the risk that a first local host candidate *is* the
NAT mapping address and port of a second local host candidate, because
of the "port preservation" effect. When it happens, a server reflexive
candidate and a host candidate will have the same address and port.

For that situation to happen, a stun request must be emitted from the
internal address first, the NAT mapping doing the port preservation will
be created for the internal address, and when a stun request is sent
from the external address thereafter, a new NAT mapping will be created,
but without port preservation, because the previous mapping already took
that reservation.

The problem will occur on the remote agent, when receiving a stun request
from this address and port, that has no way to know wheather it comes from
the host or the server reflexive candidate, if both have been advertised
remotely, resulting in pair type mislabelling.

This case may happen more easily when a source port range is reduced.

agent: stay in aggressive mode after conncheck has started

When remote tcp candidates are received late after the conncheck has
started, RFC 6554 suggests that we switch the nomination mode back from
aggressive to regular. The problem is that some stun requests may
already be inflight with the use-candidate stun flag set, and reverting
to regular mode in that case is too late, because these inflight
requests may nominate a pair on the remote agent, and not on the local
agent. We prefer to just ignore remote tcp candidates that are received
after the component state has reached state CONNECTING.

agent: warn when reaching max number of turn and local addresses

agent: fix boundary test of max turn servers and local addresses

We can accept up to 8 turn servers, with turn preference value
starting at zero. Also fix the error message.

discovery: add a unique local preference value per turn server

This value is built from the position in the component turn servers
list, and from the base address network interface position in the list
of network interfaces. This value is used to ensure a unique candidate
priority for each one. Also ensure that the fields that compose the
local preference don't overlap, by checking their maximum value.  See
RFC-8445, section 5.1.2.2 "Guidelines for Choosing Type and Local
Preferences".

conncheck: rename peer-reflexive priority to stun-priority

candidate: ensuring stun priority uniqueness no more needed

The uniqueness of candidate priorities is achieved by the iteration on
the ip local addresses for local host candidates, and also on their base
address for reflexive and relay candidates. Helper function checking
its uniqueness at allocation time is not required anyore.

The priority of the stun request (prflx_priority) is built from the
priority of the local candidate of the pair, according the RFC 5245,
section 7.1.2.1. This priority must be identical to a virtual "local
candidate of type peer-reflexive that would be learned as a consequence
of a check from this local candidate."

Outgoing stun requests will come from local candidates of type host or
type relayed. The priority uniqueness of local candidates of type host
implies the uniqueness of the computed peer-reflexive priority.  And
relay local candidates cannot produce a peer-reflexive local candidate
by design, so we can safely use their unique local priority too in
the stun request.

subprojects: bump glib wrap to latest stable branch for msys build

Should fix build failures with latest mingw compiler in msys.

ci: update windows image

The old one (v8) was removed from the gstreamer registry it seems.

conncheck: refactor local and remote candidates validation

The same code to get and validate local and remote candidates from an
incoming stun is shared between regular inbound stun, early checks
replay, and partially in the local peer-reflexive discovery function.

The selection of the matching local and remote candidate from an
incoming stun sometimes requires more information than just the local
socket, and the sender address and port. It happens more frequently when
the port range is reduced, and when the conncheck handles both tcp and
udp candidates.

To help to disambiguate such situations, we add supplementary checks
when two candidates in the list have the same address and and port
number:

 * the type of the socket must compatible with the candidate transport.
   A socket for a tcp candidate may be active of passive, but also
   of type "tcp-bsd" when the parent active or passive socket is
   replaced after a bind() or accept(). It gives several cases.

 * the remote candidate transport and the local candidate transport must
   be compatible

conncheck: match remote candidates on the socket reliability

When the couple (address, port) is identical between two remote
candidates, we may have to match a remote candidate based on its socket
reliability.

conncheck: match transport of peer-reflexive local candidates

Another some rare case, but we may have two local candidates with
the same couple (address, port) and a different transport.

tests: add a unit test for private addresses ranges

This is a unix-only test

interfaces: fix network to host conversion for private addresses

tests: fix local preference based on interface rank in list

The local preference of UDP candidates is (now) determined by the
position of the IP address in the list returned by
nice_interfaces_get_local_ips().

candidate: fix local preferences of udp candidates

udp candidates failed to call nice_candidate_ip_local_preferences()
and were all given the same local preference priority.

agent: enforce turn deallocate stun pacing

In a way similar to other stun packets, we add a delay of Timer TA
(default is 20 ms) between each refresh candidate processing.

conncheck: enforce keepalives stun requests pacing

Keepalives STUN requests should not be sent for each local host
candidate or each selected candidate in the single loop, but with a pacing
of at least Timer TA (default is 20 ms) between each request. It remains
compatible with a pause of Timer TR (default is 20 seconds) between each
keepalives batch.

discovery: enforce stun requests pacing

Only a single STUN request should be sent per discovery tick to enforce
an overall pacing of 20ms per default between two STUN requests.

interfaces: ignore only interfaces we really want to (II)

This improves commit bd4b47813844aa0e68e9074b3ac516c383ca8bab

There is a second place where this fix is needed.

gitlab-ci: Disable trigger for now

gitlab-ci: Make the documentation acceptable for the website

conncheck: Connection check reply must have a remote candidate

Ensure that a conncheck reply is coming from an address and port of a
known remote candidate and that the type of incoming socket matches that
candidate's transport.

Attemps to fix a Coverity issue in which no matching remote_candidate
gets found for a connectivity reply in conn_check_handle_inbound_stun()
(apparently due to transport mismatch), yet
priv_map_reply_to_conn_check_request() still successfully matches it
with a previous request.

conncheck: Typo fix

conncheck: display priorities in debug by spliting their values

We display 32-bit candidate priorities in hexadecimal to identify each
8-bit-aligned field more easily: type preference, local preference, and
component id. We display 64-bit pair priority by splitting their local
and remote part. See RFC-8445, section 5.1.2.1.  "Recommended Formula",
and section 6.1.2.3. "Computing Pair Priority and Ordering Pairs".

candidate: strip link-local ipv6 scope in local preference

This patch makes IPv6 link-local addresses obtain a unique ice
local preference when computing their priority, by stripping the
"%<interfacename>" added to them by getnameinfo(). Previously, all
these addresses obtained the same preference value, since the whole
local ips list was checked without finding a match.

gitlab: Also push to coverity on manual builds

stun usage turn: Check return value as is done elsewhere

udp-bsd: Check all return value

Errors found by coverity

stun test: Check return value as is done elsewhere

conncheck: Pass arguments in the right order

The order of the passed arguments doesn't match the prototype of the
function. We exchange the local and remote candidates.

udp-udp: Make coverity happy by giving it the whole union

gitlab-ci: Build coverity using meson

agent: refactor conncheck update_selected_pair

agent: update the selected pair priority when foundation changes

The component selected pair priority may have its priority modified
if the foundation of its remote candidate changes. This update needs
to be recorded, even if its not signalled, since this value is used
in the conncheck in priv_update_selected_pair().

agent: make code indentation a bit more homogeneous

agent: verify the best nominated pair after priorities recalculation

When we get a set_remote_candidate late after the start of the
conncheck, some remote candidates type may change from peer-reflexive
to server-reflexive. This required a recalculation of the foundations
and of the priorities of the related pairs.

This recalculation may change the pairs ordering in the conncheck list:
a srflx:prflx pair becoming a srflx:srflx pair will have a lower
priority (RFC 8445, section 5.1.2.1 "Recommended Formula", "the type
preference for peer-reflexive candidates MUST be higher than that of
server-reflexive candidates.")

This recalculation is required to maintain the same pairs ordering in
both agent.

But in some cases, in aggressive nomination mode, this may also change
the selected pair, if this recalculation changed the highest priority
pair with the nominated flag.

conncheck: send keepalive for candidates until connected state

We can start sending keepalive stun request for the selected pair, and
stop sending keepalive for candidates as soon as the conncheck reaches
state connected and not ready.

conncheck: fix peer-reflexive priority in discovered pair

The peer-reflexive priority used in the STUN request is copied from the
parent succeeded pair to the discovered pair. This value is not required
for discovered pair, that won't emit stun requests themselves, but may
be used when such pair becomes the selected pair, and when keepalive
stun are emitted, using the sockptr and prflx_priority values from the
succeeded pair.

conncheck: update peer-reflexive priority of the selected pair

conncheck: do not create a pair from peer-reflexive local candidate

The usual case when forming the initial conncheck list from local and
remote candidates is to discard server-reflexive local candidates, since
the agent can not send requests directly from these candidates. But it
also may happen, when the remote candidates are received late after the
beginning of the conncheck, that we also have discovered peer-reflexive
local candidates, that must be discarded as well. See RFC 8445, section
6.1.2.4 "Pruning the Pairs".

conncheck: prune oversized conncheck list based on pair state

Removing lower-priority pairs to keep the conncheck list under a fixed
size (RFC 8445, sect 6.1.2.5) may accidently remove pairs that we want
to preserve, like succeeded and discovered pairs. We choose to only
remove pairs that are not engaged yet in the connection check
processing, those in frozen state.

Fixes #95

interfaces: use fallback if getifaddrs failed

fix #99

test-thread: Increase timeout

test-io-stream-common: Remove io_stream pointer when removing stream

gitlab-ci: No longer allow meson test failures

test-send-recv: Change timeout to 150s

tests: Make iostream test termination more reliable

test-io-common: Abort on error

gitlab-ci: Run meson tests in debug setup

This setup stores more debug info

test-send-recv: Write in a loop until blocked

We're not sure that our callback will be called again if
we haven't filled the pipe.

conncheck: print a supplementary pair flag in the debug dump

conncheck: fix timer remainder return value

We show the timer remainder in milliseconds.

Fix building doc when libnice is a subproject

When passing strings to 'src_dir', they are assumed to be relative to
the root source dir of main project. That's possibly a Meson bug, it
should be relative to current source dir. In any case, it's better to
use include_directories() to avoid any confusion.

Remove GTimeVal as it is deprecated in GLib

gitlab-ci: Replace dependencies with needs for parallel running

gitlab-ci: Add workaround for missing msys in Docker image

gitlab-ci: Move CI to Windows 1809 builder

Also upgrade to Windows image v8 as the image needs to match the host

conncheck: fix long time to connect if conncheck list gets filled late

When a stream's conncheck list is empty during
priv_conn_check_unfreeze_related() and the check pairs get added only
afterwards, the whole list may remain in frozen state for tens of
seconds until the lists of all other streams are completed.

If a connection check list missed the opportunity to be unfrozen
according to the process in RFC 5245 Section 7.1.3.2.3 because it was
empty at the time, unfreeze it immediately once some check pair gets
added.

meson: fix build with Meson 0.49.2

The parser didn't seem to handle line continuations properly back then.

gitlab-ci: Add MSVC builds

Uses a wrap file to download a prebuilt OpenSSL from our git as a
subproject.
Builds for both amd64 & x86

tests: Don't use GSubprocessLauncher

It crashes on Windows

test-fullmode-with-stun: Use portable g_usleep() for MSVC

meson.build: Simplify shell based test checks

meson: Add non-pkgconfig test for OpenSSL

This makes it work with Windows MSVC builds of OpenSSL which
don't include a pkg-config file.

CI: add basic msys2 build

For now it uses the gstreamer docker image and shared runner, based
on windows server 1607. The runner will migrate to windows 1807
soonish hopefully.

This commit also adds a glib wrap file needed to build
libnice.

tests: Port test-fullmode-with-stun wrapper to C

Shell scripts don't work well on Windows and Python doesn't work with valgrind.

stund: Add win32 support

conncheck: fix a wrong transport value in debug

dockerfiles: Add buildah format export to make gitlab happy

tests: Pass GST env with valgrind too

libnice.supp: Add RHEL 7 suppressions

gitlab-ci: Add valgrind autotools test too

dockerfiles: Add valgrind to docker files

gitlab-ci: Use extends to reduce size of script

gitlab-ci: Add valgrind meson test

meson: Add valgrind setup

libnice.supp: Add GStreamer suppressions

test-gstreamer: fix buffer leak

conncheck: Drop valid STUN for which we can't find a request

It's most likely caused by a retransmission received after the initial
request already had a reply.

test-tcp: Only free passive socket after child

The child now calls into the parent..

test-turn: Initialize variable earlier to avoid race

test-udp-turn-fragmentation: Avoid leaking test socket

test-different-number-streams: Avoid leaking NiceAddress

conncheck: ignore selected pairs for nomination that failed

When evaluating the stopping criterion, failed pairs from other streams
having the "use_candidate_on_next_check" flag set should be
ignored.

This should normally not happen, because a pair selected for nomination
has no reason to fail when being rechecked, since it previously
worked... but it may happen with Skype for Business, when libnice
selects a tcp pair for component 1, the peer seems to have no interest
in the second component and lets it fail in the middle of the conncheck.

conncheck: make the stopping criterion a bit more clear

This patch doesn't change the logic of the selection of the pair for
nomination, it makes the code a bit more simple to read.

agent: fix a regression when updating foundations

A previous commit c1fb6f2 introduced a regression in the way the
foundation of a selected pair is updated and signaled, when the
foundation of its remote candidate changes. The previous comparison was
made on *always* identical strings, so the update of the selected pair
was *never* signaled.

conncheck: update a misleading debug statement

We may not have received remote candidates yet, but we may have
discovered remote candidates from the early incoming checks. Only
having stream credentials is required to react to these checks.

udp-bsd: Use sockaddr_storage union to ensure big enough socket

The IPv6 struct sockaddr variant is bigger than the IPv4 one,
so use the storage struct to ensure that the size is big enough.

discovery: Don't start STUN/TURN disco on errorneous socket

If the initial attempt at sending discovery message returns a socket
error, don't start the retransmit timer and immediately mark such
discovery item as done. This is to quickly eliminate clearly
non-functioning items from the discovery process.

Particularly improves times to finish discovery on Windows, where
sending data from a link-local (169.254.0.0/16) IP to a destination not
on the same subnet leads to "A socket operation was attempted to an
unreachable network" error. Pointless retransmissions on those sockets
prolonged discovery in the order of seconds.

udp-bsd: log source and destination addresses on GSocket send error

agent: fix server-reflexive candidates with oc2007r2

The nomination of a pair having such a local candidate breaks SfB when
the libnice agent is behind a nat that does not do port mapping
randomization. In that case a server reflexive local candidate usually
lead to a nominated pair.

The guess made here from observing this behavior is that, it is valid to
discover and signal these local server reflexive candidates to our peer,
but they should be removed from our local candidates list thereafter, so
they do not contribute to build a valid and *even worse* a nominated
pair with the type server-reflexive. They do not appear in the conncheck
list per design anyway.

Instead, the same candidate is discovered again later during the
conncheck, with a peer-reflexive type this time, and with that type, it
just works.

Closes #90

conncheck: avoid transport association mismatch

In some rare cases, the same address and port number may match two
remotes candidates, a tcp and an udp one, and lead to buggy pair
construction with incompatible transport. This supplementary check
prevents this problem. The matching test is not aimed to be exhaustive
but just a way to discard obviously broken associations, and fallback to
accept everything else (because socket type has a great diversity, with
socket types based on other sockets types).

It should fix #81, where such bogus transport association has been
reported (tcp-pass:udp).

interfaces: ignore only interfaces we really want to

Once an interface got ignored, ALL interfaces coming after it were
dropped too.

candidate: replace uint8_t -> guint8

Fixes MSVC build.

debug: fix verbose mode

Since g_parse_debug_string() was looking only at the first 4 items in
GDebugKey arrays, "libnice-verbose" couldn't get activated.

examples: fix compiler extra warnings