Add a dynamic receiver class for more flexible packet handling

It's useful for middleware libraries which may not know all packet types
at compile time, or if different packets need to be routed to different
receivers.

Remove function overloads for manually specifying packet IDs

Since the IDs can be transposed when sending and receiving, this isn't
terribly useful anymore.  For Communicator's multi-protocol support
having abnormally high packet IDs is detrimental.

Redesign Communicator to support multiple protocols

This makes it easier for a library to provide a base protocol and allow
applications to add their own protocols on top.  It's also used for the
Communicator's internal handshake protocol.

Provide access to packet IDs in Protcool

Add a base id parameter to Protocol's serialization functions

This allows multiplexing protocols on a single connection by externally
adjusting their packet ID.

Add some useful factory functions to InetAddr and Inet6Addr

Decorate things which constitute the public API

Fix processing of IPv6 addresses in HTTP server

Mark sockets as close-on-exec upon creation on Linux

Use the append function from string utilities

Adjust copyability of classes

In most cases the use of std::unique_ptr already makes classes move-only
where necessary.

Don't create the WinSock helper until the first socket is created

Check for EOF return before checking for errors

The check_sys_error function converts errors from non-blocking operations
which would block into a zero return, making them indistinguishable from
a zero return due to the other end closing the connection.

Move the address family enum into sockaddr.h

Include the matching header first in .cpp files

This avoids accidentally using transitively included headers.

Use std::unique_ptr for owning pointers

Refactor the API for defining packets in Protocol

A variadic template function provides a nicer interface than chained call
operators.  Required C++ standard version is now C++14 due to deduced
automatic return types.

Add missing override specifiers

Fix an incorrect multiple inclusion guard

Use nullptr instead of 0 for pointers

Further simplify the protocol serializers

Add unit tests for some classes

Fix a length calculation bug in Protocol::dispatch

The packet header was not being included in the returned length.

Simplify the inner workings of Protocol

The CompoundDef hierarchy was basically just a polymorphic wrapper for
Serializer.  Might as well make Serializer itself polymorphic.

Use default member initializers where possible

Rework protocol hash calculation

Instead of creating a string and hashing it, just build the hash
directly.

Reserve space for strings before appending characters

Use the auto type to shorten long declarations

Prefer range-based for loops where possible

Use the override specifier when overriding

Mark special member functions as defaulted where appropriate

Use a static local variable for assigning packet IDs

This avoids the need of a definition for the static member variable of
a template class.

Use deque instead of list for resolver task queue

Add a function to close all HTTP connections

This can be useful for graceful shutdown at program exit.

Don't allow duplicate listen calls

Also add a function to check if the socket is already listening

Adjust exception classes and messages

Remove unnecessary destructors from exception classes

Reject HTTP messages starting with a linefeed

It would make str[lf-1] invalid.  Also ignore the carriage return at the
end of the first line when parsing a response.

Emit signal_end_of_file after clearing events

This ensures that the state remains consistent even if a slot throws.

Use standard fixed-width integer types

Update getopt usage with positional arguments

Update hash function call

Use size_t to represent sizes

Bump the library version and C++ standard

Allow creating an Http::Server without immediately listening

Use an IPv6 socket for Http::Server

Fix several errors in FormData parsing

It was terminating early if a part happened to be of certain length.
Extra whitespace was included at the end of parts and there was also an
out-of-bounds memory access.

Improve error handling

Particularly of asynchronous operations

Add parsing for different styles of HTTP headers

Support serializing bool fields in Protocol

Allow the query part of a URL to be empty

This can happen when submitting an empty form with the GET method.

Prevent serializing packets without an ID

An attempt at such may arise from sending a structure intended to be used
as part of other packets, but not a packet on its own.

Fix the polarity of O_CLOEXEC for Socket

Provide more information about exceptions in Http::Server

Remove name from an unused variable

Update a deprecated header

Add method to query bound status of a socket

Implement the required virtual functions in Socket

Fix a flag handling bug in Socket::Private::set_block

Move the definition of PacketTypeDef<T>::class_id to a separate header

Defining it in protocol.h may cause multiple definitions to appear across
the program and there are cases where they don't get collapsed to one.
DLLs on Windows are one such case.  The _impl header is to be included in
files that add packet definitions to a protocol and nowhere else.

Increase Communicator buffer size to 64k

This is the current maximum size for a packet, and there isn't really
any need to use a smaller buffer.

Some largely cosmetic touch-up

Support compound types in network packets

Fill in a missing parameter for check_sys_error

This was supposed to be in b069cfc but somehow didn't make it into the
commit.

Acutally implement Protocol::get_hash

Also trigger an error in Communicator if the hashes don't match

Refactor most of Communicator::send to be in the .cpp file

Massive overhaul of the Protocol class

Makes the serialization machinery more flexible and reduces the number of
virtual function calls when de/serializing packets.

Add error check to accept

Move most platform-specific code into overlay directories

Unix socket addresses can now be constructed on Windows, but can't be
actually used with sockets.

Minor cleanup

Use the correct #ifdef for Windows

Support asynchronous name resolution in Http::Client

Implement an asynchronous name resolver class

Fix header name normalization logic

If the name begins with a hyphen, the following letter shall be
uppercased.

Use string::size_type to store string offsets

Add a class for parsing submitted form data

parse_query in utils.h already did it for query strings, but not for
POST requests.

Add a utility struct for parsing complex header values

It's not used to store headers in Message since not all headers follow
the same syntax.  User-Agent in particular may have semicolons which are
not parameters separators.

Add the most common redirection statuses

Provide a method for the application to cancel connection keep-alive

Adhere to the spec with connection keep-alive

Recognize it case-insensitively and add the header on the response.

Use connection keepalive on async responses too

Hide Http::Server destructor in the library

Otherwise sigc::signal destructor will be emitted in the including file,
requiring explicit linking with libsigc++.

Use a typecast to avoid a signedness mismatch warning

Set event types on Windows if connect finished immediately

Include winsock2.h first

It wants to get included before windows.h

Reject requests with a relative path

As per the HTTP specification

Correct a typo in a multiple inclusion guard

Provide a signal to handle errors from Communicator

Since Communicator is typically used with an EventDispatcher, it can be
inconvenient to just throw exceptions out.  Handling them would require
wrapping the EventDispatcher's tick call in a try block, and the exact
source of the exception would be lost.

Implement connection keep-alive in HttpServer

Make Request API consistent with itself and others

Request::from_url was incorrectly creating requests with unencoded URLs.

Add 405 (method not allowed) status

Since the HttpServer class allows either GET or POST and returns 501 (not
implemented) for others, programs using it may wish to further limit
processing to GET requests only.

Add shutdown support for client sockets

Fix 64-bit compilation

Add the target type to a lexical_cast invocation

Update Build and .gitignore files

Add support for AF_UNIX

Hide the set_option and get_option functions in socket_private.h

These depend on a system-specific type, so they can't be in a public
header.

Fix some compilation problems

Don't crash on errors without verbose mode

Fix some header names