What are the WONTFIX bugs on GNU/Linux and how to work around them?

Question

Both Linux and the GNU userspace (glibc) seem to have a number of "WONTFIX" bugs, i.e. bugs which the responsible parties have declared their unwillingness to fix despite clearly violating the requirements of ISO C and/or POSIX, but I'm unaware of any resource for programmers which lists such bugs and suggestions for working around them.

Here are a few that come to mind:

• The Linux UDP select bug: select (and related interfaces) flag a UDP socket file descriptor ready for reading as soon as a packet has been received, without confirming the checksum. On subsequent recv/read/etc., if the checksum was invalid, the call will block. Working around this requires always setting UDP sockets to non-blocking mode and dealing with the EWOULDBLOCK condition. If I remember correctly, MaraDNS was the first notable project affected by this bug and the first to complain (unsuccessfully) to have it fixed. Note: As pointed out by Martin v. Löwis, apparently this bug has since been fixed. Workarounds are probably only necessary if you need to support really outdated versions of Linux.
• The printf family in the GNU C library wrongly treats arguments to %s as multibyte character strings instead of byte strings when a field precision (as in %.3s) is specified, potentially causing truncated output. I know of no workaround except replacing the whole printf subsystem (or simply not using the printf family of functions with non-multibyte-character byte strings, but this can be problematic if you want to process legacy-codepage strings using snprintf while in a UTF-8 locale).
• Wrong errno result codes for certain syscalls (can't remember which ones right off). Usually these are easy enough to check for if you just read the GNU/Linux man pages and compare them to the standard. (I cannot find the references for this and perhaps I am mistaken. The closest I can find is the issue of ENOTSUP and EOPNOTSUP having the same value; see PDTR 24715.

What are some more bugs and workarounds we can add to this list? My goals in asking this question are:

1. To build a more complete list of such bugs so that both new and experienced programmers can quickly become aware of potential issues that could arise when running an intended-to-be-portable program on GNU/Linux.
2. To leverage the SO collective brain to think up clever and unobtrusive standard workarounds for as many such bugs as possible, instead of everyone having to invent their own workarounds after getting stung, and possibly doing so in suboptimal, ugly, or hackish ways - or worse yet, in ways that break support for more-conformant systems.

Answer 1

I can't reproduce the printf issue that you claim. Running the program

#include <stdio.h>
#include <locale.h>

int main()
{
        setlocale(LC_ALL, "");
        printf("%.4s\n", "Löwis");
        return 0;
}

in a de_DE.UTF-8 locale prints "Löw", which looks right to me: I asked for 4 bytes, and got four bytes (ö is 2 bytes). Had the library counted multi-byte characters, the output should have been "Löwi". This is with glibc 2.11.2.

Edit: Changing the string to "%.2s\n" will just print "L", i.e. only one byte. However, this is conforming to the specification, which says

If the precision is specified, no more than that many bytes shall be written.

(emphasis mine), and then

In no case shall a partial character be written.

So since printing two bytes (i.e. the L, and the lead byte of ö) would result in a partial character being written, it would be non-conforming to print incomplete UTF-8.

Answer 2

I don't believe that the UDP issue actually exists. In the current Linux kernel, udp_poll reads

/**
 *      udp_poll - wait for a UDP event.
 *      @file - file struct
 *      @sock - socket
 *      @wait - poll table
 *
 *      This is same as datagram poll, except for the special case of
 *      blocking sockets. If application is using a blocking fd
 *      and a packet with checksum error is in the queue;
 *      then it could get return from select indicating data available
 *      but then block when reading it. Add special case code
 *      to work around these arguably broken applications.
 */
unsigned int udp_poll(struct file *file, struct socket *sock, poll_table *wait)
{
        unsigned int mask = datagram_poll(file, sock, wait);
        struct sock *sk = sock->sk;

        /* Check for false positives due to checksum errors */
        if ((mask & POLLRDNORM) && !(file->f_flags & O_NONBLOCK) &&
            !(sk->sk_shutdown & RCV_SHUTDOWN) && !first_packet_length(sk))
                mask &= ~(POLLIN | POLLRDNORM);

        return mask;

}

So it seems to me that it does hide UDP packets with bad checksums from being reported through select/poll. This version of the code is being used since revision 85584672 (2009). But even before (since at least 2005), the code apparently was doing the same kind of dropping bad packets in select/poll already.