Get rid of the non-portable Linux list library, part I.

The length of GREETING is known at compile time, don't use strlen().

We are going to migrate away from the concept of notifying the main
thread.  There should be events sent to it instead.  This patch starts
a series to implement that.

With the GLib main loop, the client manager can install its own event
in case a client is expired.  No need for main.c to call
client_manager_expire() manually.

Remove the event source from the GMainLoop object in
client_set_expired().

Other libraries may need to access the main_loop reference, to add or
remove events, or to call g_main_loop_quit().

This is a rather huge patch, which unfortunately cannot be splitted.

Instead of using our custom ioops.h library, convert everything to use
the GLib main loop.

On Windows, socket declarations reside in winsock.h and ws2tcpip.h.
The POSIX headers sys/socket.h etc. are not available.

When a response is very long (e.g. a large playlist > 100k songs),
most of it will end up in the deferred buffers.  Filling the deferred
queue is very expensive currently, because a new buffer is allocated
for every client_write() operation.  This may lead to long delays, and
the client might give up and disconnect meanwhile.  This patch makes
MPD attempt to flush the deferred queue as often as possible, to work
around this problem.  Due to the MPD 0.14 code freeze, we should not
optimize the buffering code now.

We want to remove gcc.h eventually. This takes care of all the G_GNUC_PRINTF
macros.

The client may provide the names of idle events as arguments to the
"idle" command to inform MPD that it is only interested in these
events.

Return bool instead of int.

After a partial write, chances are vanishing that another write() will
succeed.  Don't try immediately.

Another custom data structore converted to GLib.

Replace a custom data structure with a GLib one.

The list cache aims to save memory allocations, and complicates the
code a bit.  We should rather use GLib slices later, which are easy to
use.

Eliminate CamelCase in all public and static functions.

client->permission is a bit set, and should be unsigned.

Reduce two temporary variables to only one.

There is no sense in using the kernel's send buffer size (SO_SNDBUF)
for MPD's send buffer.  Convert it into a static buffer of 4 kB.

Use a literal in the struct declaration, and sizeof(client->buffer)
everywhere else.  Also shrink the buffer from 40 kB to 4 kB.  The
buffer must only be large enough to hold one line of input, and 4 kB
is still more than enough.

The buffer pointers must not exceed the buffer size.

Use ssize_t instead of int.

Commit 6eb62e47 didn't obey partial lines correctly: when a line
wasn't finished in one read, the first part was ignored when the rest
arrived.

Enable authentication over unix sockets.  Store the client's uid in
the client struct.

Use memchr() instead of manually traversing the input buffer.  Update
the client's properties after all commands have been processed.  Check
for buffer overflow once.

"idle" waits until something noteworthy happens on the server,
e.g. song change, playlist modified, database updated.  This allows
clients to keep up to date without polling.

When there are standardized headers, use these instead of the bloated
os_compat.h.

The assertion on "!client_is_expired(client)" was wrong, because
writing the command response may cause the client to become expired.
Replace that assertion with a check.

Remove one comparison by changing branch order.

Since the caller chain doesn't care about the return value (except for
COMMAND_RETURN_KILL, COMMAND_RETURN_CLOSE), just return 0 if there is
nothing special.  This saves one local variable initialization, and
one access to it.

Also remove one unreachable "return 1" from client_read().

Don't close the client within client_process_line(), return
COMMAND_RETURN_CLOSE instead.  This is the signal for the caller chain
to actually close it.  This makes dealing with the client pointer a
lot safer, since the caller always knows whether it is still valid.

It's easier to reuse the variable if it has a more generic name.

Don't update client data if it is going to be closed anyway.