tcp-bsd: Don't clear error that hasn't been set

agent: Don't return the socket to the app in any reliable case

No need to strdup foundation in new_selected_pair since we queue signal

pseudotcp: Also cause Writable callback to be emitted if can_send() says no

The GOutputStream based systems can sometimes call this, decide the stream is
not writable and then poll for it. We have to make sure that poll is woken up.

Fix TCP TURN for Google compatibility. Message length was sent uninitialized

Small cleaning of tcp-bsd.c

Fix possible segfault in stun_message_validate_buffer_length()

build: Check for [s]size_t before redefining them on MinGW

MinGW defines size_t and ssize_t for us, so we should not
unconditionally redefine them in stun/win32_common.h. Add an
AC_CHECK_TYPES configure check to avoid this.

agent: Define IN6_ARE_ADDR_EQUAL macro when building under MinGW

Older versions of MinGW don’t define IN6_ARE_ADDR_EQUAL, as normally
defined in netinet/in.h. Conditionally define it in address.c to fix the
build on MinGW.

MinGW has added support for the macro here:
https://github.com/mirror/mingw-w64/commit/0f4899473c4ba2e34fa447b1931a04e38c1f105e

Based on a patch originally by Luciana Fujii Pontello
<luciana@fujii.eti.br>.

pseudotcp: Validate option lengths

Remove all traces of compile time marshallers

agent: Use generic marshaller

Initialize variables to reduce unexpected behavior in case something goes wrong

Rename variables that shadow global definitions

stun: Use struct sockaddr_storage * for any pointer that we write to

Some platforms have a larger alignment requirement for struct sockaddr_* than
for plain struct sockaddr, in that case, we need to make sure that the incoming pointer
has the right alignement before taking it in.

stun tests: Fix a bunch of issues found by more aggressive GCC warnings

Don't mix gsize vs size_t, seems like they're not always the same size

candidate: Use explicit 64-bit constants to make 32-bit gcc happy

pseudotcp: Don't mix "long" and guint, one is signed, the other is unsigned

So use guint64 everywhere, this is never supposed to be negative.

tcp-turn: Don't access output message after freeing it

turn: Don't overwrite source, destroy it first

turn: Don't access list node after freeing it

component: Set dummy callback from cancellable GSource

agent: Make it possible to set the relays after gathering

This allows finding the relays asynchronously while trying to connect
with other methods.

agent: Prevent nice_agent_set_port_range() from being called after a gather

The port range is only used when gathering, print a critical if it is
called afterwards as it will have no effect.

agent: Prevent gather from being called multiple times

This can cause odd behaviors as it is not a idempotent function.

agent: Refactor nice_agent_set_relay_info()

No behavior change is introduced

turn: Put timeouts on the specific main context

turn: Don't try to process empty messages

agent: Bail out early on empty message

This can happen if a lower layer has consumed the message, bail out earlier in
that case.

agent: Don't overwrite the size of the GInputBuffer, only set the global size

pseudotcp: Also accept NiceInputMessage array with a single message

test-fullmode: Don't use gmainloop when not required

There are more than one callback that could stop it

test-fullmode: Do #if instead of #ifdef as we set it to 0

test-fullmode: Only wait for data on component 1

tcp-bsd: Use default main context if none specified

turn-tcp: Don't corrupt messages

agent: Free every parameter

Fixes off-by-one error

agent: Create a custom pointer GType to recognize the stream ids

agent: Improve documentation for NiceAgent::new-candidate

Note that it’s a new _local_ candidate.

NEWS: Remove superfluous empty lines

Version 0.1.5.1

Version 0.1.5

configure: Remove -Wunsafe-loop-optimizations, it causes false warnings

tests: Add private header to tarball

tests: Don't verify the message content with not in reliable mode, because its unreliable

agent: Enforce limits on the size buffers, because the retval is signed

doc: Update doc generation

iostream: De-gtkdoc the comments, as it's not public API

agent: Remove unused #include

net/if_arp.h doesn’t exist on OS X, and hence causes cross-compilation
to fail. It doesn’t appear to be needed for any of the functions
currently used in interfaces.c anyway.

agent: Ensure the pending signal queue is cleared on dispose

agent: Fix a potential re-entrancy situation

If we emit signals from component_io_cb() in the middle of a read, it’s
possible that one of those signals will be picked up by the client to
perform another read. A likely candidate (and what was triggering the
re-entrancy here) would be component-state-changed. Since signals are
emitted synchronously, the second read would being inside the first, and
trigger the anti-re-entrancy assertion.

tests: Use dynamically allocated port for test-new-dribble

tests: Fix horribly raciness in test-new-dribble

tests: Split racy "closing" into a test for stopping while reading or writing

We wan't to make sure not to have a race where a thread blocks in a blocking
receive or send while nice_agent_remove_stream() is called

test: Use a less racy way to know if the test is ready to start

Also, keep a pointer to the other structure for tests to use

outputstream: Add a cancellable to get out of blocking write if the stream is removed

component: Add a GCancellable to get of out blocking nice_agent_recv()

Otherwise, it may be stuck iterating the context forever if all of the
other sources are gone.

component: Keep its own context at all times

Don't re-create it.

Ignore .trs and .log file from newer automake

agent: Delay signal emission after the lock has been released

This way, there can be no annoying re-entrancy in our code.

agent: Replace recursive mutex with non-recursive

This should prevent us from re-adding re-entrancy in the future

agent: Delay signal emission after the lock has been released

This way, there can be no annoying re-entrancy in our code.

iostream: remove re-entrant call into NiceAgent

outputstream: If tcp, only check for space in the PseudoTCP queue

agent: Expand documentation for a couple of NiceAgent functions

Expand documentation for nice_agent_gather_candidates() and
nice_agent_set_remote_credentials().

agent: Fix inlining of nice_debug() if NDEBUG is defined

agent: Assert on re-entrant reads

Ensure the agent’s context doesn’t get iterated while in the middle of
reading a message, as that will corrupt the component->recv_messages
state.

agent: Improve debug output

agent: Add nice_input_message_iter_compare()

Use it instead of memcmp() to avoid comparing padding bytes.

docs: Remove NiceIOStream, nothing specific to document

agent: returning 0 valid messages is valid, it means EOF

iostream: iostreams are only for reliable streams, no need to check

agent: Use locally allocated memory if the application buffer is not big enough for one STUN packet

outputstream: Trigger the pollable source on error or removal

agent: Fix compiler warnings

configure: Add newline ignoring

Otherwise it ran the "yes" command

configure: Move -Werror=unsafe-loop-optimizations to the maximum level

It tends to cause false warnings

pseudotcp: Remove one duplicated call to g_get_monotonic_time()

agent: Remove weak pointers, they aren't thread safe anyway

And we get close to 10% perf boost

pseudotcp: Add list of unsent segment

Looping through the list of send segment was the only thing from libnice
showing up in my profiler. Keeping a list of segment that were never sent
has made it disappear.

agent: Avoid calling nice_address_to_string() when debugging is disabled

pseudotcp: Use GQueue for list that has stuff inserted in the end

pseudotcp: Don't change the receive buffer size if it hasnt changed

agent: Restore the ability nice_agent_send() to send partial buffers

This is very important for reliable mode.

Also use it in the GOutputStream so as to not get into the case where
there is still some space in the TCP buffer, but not enough for one message.
Also warn against this problem.

agent: Replace nice_agent_build_io_stream() with nice_agent_get_io_stream()

Also made the GIOStream into a singleton, it always returns the same one.
Also make it impossible to create a GIOStream for a non-existing stream/component

Remove the "length" parameter from NiceOutputMessage

It was used correctly only half the time anyway

Remove the "to" parameter from NiceOutputMessage

We never send multiple messages to separate targets in practice, so
this will simplify the code

agent: Attaching to a NULL context should attach to the default one

Otherwise it would have attached to a newly created context

socket: Add note that the packet dropping in tcp-bsd is broken behavior

tests: Fix test-restart to only quit on state changes

Previously, there was a race between receiving the data packets and
changing state to READY, which would cause one of the final assertions
to fail.

agent: Add support for vectored I/O for sends

Add one new public function, nice_agent_send_messages_nonblocking(),
which replaces nice_agent_send_full(). This isn’t an API break, because
nice_agent_send_full() hasn’t been in a release yet. The new API allows
sending multiple messages in a single call, and supports vectors of
buffers to transmit the messages from.

The existing nice_agent_send() API has been left untouched, although
it’s a bit of a bugbear because it’s non-blocking and doesn’t fit with
the new *_nonblocking() naming scheme. Oh well.

This doesn’t bring any notable changes to the number of memcpy()s on the
critical path: it remains at zero for the common cases and common socket
types. It introduces the possibility for future work to eliminate some
memcpy()s in more complex socket types, like tcp-turn and tcp-bsd, but
these optimisations have not been made yet. FIXME comments have been
added.

This includes modifications to the test-send-recv unit test to cover the
new API.

socket: Add vectored I/O support for sending on sockets

Replace the send() API with a send_messages() API, which supports
sending multiple messages, each with multiple buffers rather than a
single monolithic buffer.

This doesn’t break API, as the socket API is not exposed outside
libnice. It does introduce a new struct: NiceOutputMessage, which is
analogous to struct mmsghdr and NiceInputMessage.

This includes updates to the test-bsd test to cover the changed API.

The existing nice_socket_send() API has been retained as a thin wrapper
around nice_socket_send_messages(), for convenience only. It’s hoped
that internal usage of this API will decline to the point where it can
be removed.

agent: Move gtk-doc comments from agent.c to agent.h for new API

I completely disagree with this, and believe the C file is a much better
place for them, as then they’re:
 • easier to read while hacking on the functions, and
 • easier to modify once finished hacking on the functions.

I think the argument for putting them in the header files (so that the
documentation is available by the function declarations) is weak, as the
generated gtk-doc manual should be installed on the system alongside the
header files in any case.

tests: Update test-send-recv to support vectored I/O

agent: Add support for vectored I/O for receives

Add two new public functions:
 • nice_agent_recv_messages()
 • nice_agent_recv_messages_nonblocking()
which allow receiving multiple messages in a single call, and support
vectors of buffers to receive the messages into.

The existing nice_agent_recv[_nonblocking]() APIs have been left
untouched.

This tidies up a lot of the message handling code internally, and
eliminates a couple of memcpy()s. There are still a few more memcpy()s
on the critical path, which could be eliminated with further work.

In the reliable agent case, every message is memcpy()ed twice: once into
the pseudo-TCP receive buffer, and once out of it. The copy on input
could be eliminated (in the case of in-order delivery of packets) by
receiving directly into the receive buffer. The copy on output can’t be
eliminated except in the I/O callback case (when
nice_agent_attach_recv() has been used), in which case the callback
could be invoked with a pointer directly into the pseudo-TCP receive
buffer.

In the non-reliable agent case, zero memcpy()s are used.

A couple of the more complex socket implementations (TURN and HTTP) have
slow paths during setup, and partially also during normal use. These
could be optimised further, and FIXME comments have been added.

tests: Fix a shadowed function name in test-pseudotcp

The write() function already exists; we can’t re-define it as a
callback.

stun: Add a fast version of stun_message_validate_buffer_length()

stun_message_validate_buffer_length() is already fast, but requires the
entire message to be in a single monolithic buffer. For introducing
vectored I/O, this becomes impossible to guarantee.

Rather than rewriting the STUN code to natively support vectors of
buffers (which would be a huge undertaking, and would probably slow
the code down considerably), implement a fast check of whether a message
is likely to be a STUN packet which *does* support vectored I/O. This
can then be used to determine whether to compact the vector of buffers
to a single monolithic one in order to validate the message more
thoroughly.

socket: Fix the formal parameter types of nice_turn_socket_parse_recv()

gsize and guint8 are more obviously for binary data than gint and gchar.

Note the signedness of the return type has changed: the function never
returns negative values.

socket: Add vectored I/O support for receiving on sockets

Replace the recv() API with a recv_messages() API, which supports
receiving multiple messages, each with multiple buffers rather than a
single monolithic buffer.

This doesn’t break API, as the socket API is not exposed outside
libnice. It does introduce a new struct: NiceInputMessage, which is
analogous to struct mmsghdr.

This includes updates to the test-bsd test to cover the changed API.