Makefile fixes.
Documentation fixes
A template for a hierarchical key container.

Imlpements a thread-safe container that uses a hierarchical key.

A typical key would be, say std::list<std::string>.

You can search for a key, and if it does not exist, you'll find some other
key that matches the prefix of your key, if it exists. You'll find the closest
parent to the nonexisting key.
Reimplement base64
Homogenize all whitespace to SP when collecting a token value.
tolower complements toupper in this context.
Expose operator() to subclass. parsetokenheader callback is an rvalue ref.
Extract challenges from an HTTP response.

authentication_required() returns an indication if the HTTP response
is an authentication challenge.

Challenges() parses the challenge headers.
Make decode_octet() public. Implement decode_octets(), for convenience.
Template class for a generic tokenizer.

Initial instantiation for HTTP token classes.
http::response_exception inherits from responseimpl

This will allow more customized responses to be sent by throwing an error
exception.

Reimplement throw_unauthorized_exception() and
throw_proxy_authentication_required(), they now take variadic parameters that
build the authentication challenge, and add the authentication challenge
headers to the response.
Add an additional test for known valid base64 encodings.
Define the Authorization: and Proxy-Authorization: headers.
Client-side HTTP authorization cache.

Initial implementation that uses basic authorization scheme, but define
an abstract clientauthObj superclass for authorization scheme drivers, with
clientauth::base::create_basic() creating a basic scheme driver.

clientauth->add_header() invokes the driver to add authorization headers to
an HTTP request.

clientauthcacheObj implements the cache for proxy and www authorizations.

save_authorization() takes the original resp with authentication
challenges, and the original request URI, a constructed clientauth, and puts
it in the cache.

search_authorization() searches the cache for known authorizations for the
given request, and invokes add_header() for each found authorization.
Add an authorization cache to http useragent object.

Store the request URI in useragent::base::response.

Add discardbody() to useragent::base::response, that explicitly discards the
body of the response.

do_request() renamed to do_request_with_auth(). The replacement do_request()
handles authentication:

- If the request URI has an explicit authority userinfo, dummy up a fake
authentication-required response, and use it to cache a basic authentication
client for an empty realm. Remove the userinfo from the URI's authority.

- Search the authorization cache for any authorizations whose protection
space encompasses the request's URI, and add their headers to the request.

- Call do_request_with_auth(), then check if the response contained any
authentication challenges. If it had, check if those challenges can be
found in the authentication cache. If all of them were, discard the
first request's body, and try again.

- Store challenges that were not filled from the cache, challenges that
the caller must process, in convenient, parsed form, in the returned
response object.

Add set_authorization(): once the client responds to a challenge, save the
new authorization in the cache.

Implement all of this for basic authorization.
Update packaging list
Reimplement structured header parsing.

Replace tokenhdrparser class and parsetokenheader() with lambda callback-based
templates.

process() iterates over all headers of the given name, and invokes the
lambda callback template parameter, with the beginning and ending iterators
for the header's value.

parse_structured_header() encapsulates a generic parser for a structured
header, usually delimited by , and ; characters. One lambda callback tests if
the tharacter is a delimiter. The second lambda callback gets each delimited
word, and the delimiter that terminated it.

Reimplement the existing users.

Loosely use commas and whitespace as delimiters for HTTP challenge headers,
taking advance of RFC 2617's requirement that scheme methods do not have =
characters, but their parameters always do.

Minor changes to quoting rules. RFC 2616 does not specify any escaping to be
done for quoted values.
Interface for message digest libgcrypt API.
realm parameter in http auth challenges always quoted, as per RFC 2617.

On the server side, make scheme_parameters_t carry quoted values. Instead of
specifying parameters as literal strings, define formal parameter names,
responseimpl::auth_param_t, which specify whether the values should always
be quoted, and in response_exception, check it and either quoted the value
always, or quote only when necessary.
Add new_request() and stale() methods to clientauthimpl.

They'll be used by the digest authenticator.