mingw_execve(): Added argv[] quoting for all the arguments, not just argv[0].
node_handle(): fixed debugging message when getting OOB results.

We now flag whether the results are for an OOB-proxied query, and correctly
state whether they were received via the semi-reliable UDP layer.
Try to read the kernel RX UDP socket queue as quickly as possible.

When the RX queue is full, the kernel will start dropping new incoming UDP
datagrams, and we want to avoid that because this may cause us to lose an
important UDP reply, for instance.

Therefore, we allow read-ahead of messages from the UDP queue without
processing them in an attempt to leave enough room in the RX queue.  These
queued messages are then processed at a later time.
Plugged user-level handling of "old" UDP datagrams, dropping non-strategic ones.

When receiving "old" UDP datagrams, we're desperately trying to catch up with
incoming traffic.  Therefore, we can ignore non-strategic messages such as
pings, which are going to cause more outgoing traffic.

However, we always handle replies to queries (RPCs) we initiated, or strategic
messages such as OOB reply indications.
Added gnet_stats_max_general() to keep track of the maximum value.
Added UDP read-ahead statistics.
gtk_gnutella_atexit(): show where foreign exit() occurs.
mingw_execve(): use _exit() to avoid atexit() callbacks in the old process.
stack_print_decorated_to(): make sure to fflush() when writing stack via stdio.
node_handle(): fixed debugging message when getting OOB results.

We now flag whether the results are for an OOB-proxied query, and correctly
state whether they were received via the semi-reliable UDP layer.
node_infostr(): increased static buffer size.
Re-opening the "unstable" devel branch.
Do not send pongs at handshake time if remote node faked its vendor name.
node_udp_process(): forgot to re-plug RX traffic accounting for DHT messages.

DHT traffic accounting was broken when semi-reliable UDP was introduced and
we made DHT message leave the Gnutella processing path very early, factorizing
RX traffic accounting in node_handle() which is not called for DHT messages.

(Faulty commit was 46aebaa63e1aa8bc038b58aed48f1f31a6a9ff45)
Added UDP datagram read-ahead to minimize local kernel drops (RX queue full).

When a lot of UDP datagrams are received, we may not be able to process them
sufficiently quickly to drain the kernel RX queue attached to the UDP socket.
If that queue fills up, the kernel will drop further incoming messages that
do not fit.

To avoid losing datagrams (and especially replies to our RPCs or queries), we
now buffer pending datagrams in memory, at the application level, even if we
are not going to process them immediately.

These buffered datagrams are then processed asynchronously when we have some
time to spend handling incoming messages.  Should the buffered datagrams be
delayed too much (current setting is 5 seconds), then it is flagged as being
"old" when it is processed.  This allows the application to drop non-critical
datagrams that are now "old" to accelerate the catching up (e.g.: pings).
remove_orphan(): fixed inverted logic.

We were wrongly keeping orphan contacts and removing alive ones!
dbmw_sync(): added argument check.
Allow DHT keys/values to be persistent across sessions.

When not stored in memory, we can now reload un-expired values at startup.
Must funnel float formatting code since it is not thread-safe.

In case multiple threads would want to format floating point numbers, we
need to make sure that they will not enter the code simultaneously given
that it is using global variables to perform its computations.
Made random number generators thread-safe.