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.

Don't pass a pointer to client->permission to processCommand(), better
let the code in command.c use the new permission getter/setter
functions.

The code in command.c shouldn't mess with a pointer to
client->permission.  Provide an API for accessing this value.

All callers of fdprintf() have been converted to client_printf() or
fprintf(); it is time to remove this clumsy hack now.  We can also
remove client_print() which took a file descriptor as parameter.

Now that we have removed all invocations of client_get_fd(), we can
safely remove this transitional function.  All access to the file
descriptor is now hidden behind the interface declared in client.h.

These two functions take a client struct instead of the file
descriptor.  We will now begin passing the client struct around
instead of a raw file descriptor (which needed a linear lookup in the
client list to be useful).

Based on client_puts(), client_printf() is the successor of
fdprintf().  As soon as all fdprintf() callers have been rewritten to
use client_printf(), we can remove fdprintf().

client_write() writes a buffer to the client and buffers it if
required.  client_puts() does the same for a C string.  The next patch
will add more tools which will replace fdprintf() later.

As usual, include only headers which are really needed.

client->fd becomes -1 when the client expires.  Don't use FD_ISSET()
with this expired client; doing so would cause a crash due to SIGBUS.

Since client->fd==-1 has become our "expired" flag, it may already be
-1 when client_close() is called.  Don't assert that it is still
non-negative, and call client_set_expired() instead.

Instead of passing the pointer to the "expired" flag to
processListOfCommands(), this function should use the client API to
check this flag.  We can now remove the "global_expired" hack
introduced recently.

Start exporting the client struct as an opaque struct.  For now, pass
it only to processCommand() and processListOfCommands(), and provide a
function to extract the socket handle.  Later, we will propagate the
pointer to all command implementations, and of course to
client_print() etc.

The old code tried to write a response to the client, without even
checking if it was already closed.  Now that we have added more
assertions, these may fail...  perform the "expired" check earlier.

Patch bdeb8e14 ("client: moved "expired" accesses into inline
function") was created under the wrong assumption that
processListOfCommands() could modify the expired flag, which is not
the case.  Although "expired" is a non-const pointer,
processListOfCommands() just reads it, using it as the break condition
in a "while" loop.  I will address this issue with a better overall
solution, but for now provide a pointer to a global "expired" flag.

client_defer_output() was modified so that it can create the
deferred_send list.  With this patch, the assertion on
"deferred_send!=NULL" has become invalid.  Remove it.

Why waste 4 bytes for a flag which we can hide in another variable.