This chapter will deal with the information which the client sends to the
server at every request. We are going to examine the most useful fields of such an request
and print them out in a readable manner. This could be useful for logging facilities.

The starting point is the @emph{hellobrowser} program with the former response removed.

This time, we just want to collect information in the callback function, thus we will
just return MHD_NO after we have probed the request. This way, the connection is closed
without much ado by the server.

@verbatim
static int 
answer_to_connection (void *cls, struct MHD_Connection *connection, 
                      const char *url, 
		      const char *method, const char *version, 
		      const char *upload_data, 
                      size_t *upload_data_size, void **req_cls)
{
  ...  
  return MHD_NO;
}
@end verbatim
@noindent
The ellipsis marks the position where the following instructions shall be inserted.


We begin with the most obvious information available to the server, the request line. You should
already have noted that a request consists of a command (or "HTTP method") and a URI (e.g. a filename).
It also contains a string for the version of the protocol which can be found in @code{version}.
To call it a "new request" is justified because we return only @code{MHD_NO}, thus ensuring the 
function will not be called again for this connection. 
@verbatim
printf ("New %s request for %s using version %s\n", method, url, version);
@end verbatim
@noindent

The rest of the information is a bit more hidden. Nevertheless, there is lot of it sent from common
Internet browsers. It is stored in "key-value" pairs and we want to list what we find in the header. 
As there is no mandatory set of keys a client has to send, each key-value pair is printed out one by
one until there are no more left. We do this by writing a separate function which will be called for
each pair just like the above function is called for each HTTP request. 
It can then print out the content of this pair.
@verbatim
int print_out_key (void *cls, enum MHD_ValueKind kind, 
                   const char *key, const char *value)
{
  printf ("%s: %s\n", key, value);
  return MHD_YES;
}
@end verbatim
@noindent

To start the iteration process that calls our new function for every key, the line
@verbatim
MHD_get_connection_values (connection, MHD_HEADER_KIND, &print_out_key, NULL);
@end verbatim
@noindent
needs to be inserted in the connection callback function too. The second parameter tells the function 
that we are only interested in keys from the general HTTP header of the request. Our iterating
function @code{print_out_key} does not rely on any additional information to fulfill its duties
so the last parameter can be NULL.

All in all, this constitutes the complete @code{logging.c} program for this chapter which can be 
found in the @code{examples} section.

Connecting with any modern Internet browser should yield a handful of keys. You should try to 
interpret them with the aid of @emph{RFC 2616}.
Especially worth mentioning is the "Host" key which is often used to serve several different websites
hosted under one single IP address but reachable by different domain names (this is called virtual hosting).

@heading Conclusion
The introduced capabilities to itemize the content of a simple GET request---especially the
URI---should already allow the server to satisfy clients' requests for small specific resources
(e.g. files) or even induce alteration of server state. However, the latter is not
recommended as the GET method (including its header data) is by convention considered a "safe"
operation, which should not change the server's state in a significant way.  By convention,
GET operations can thus be performed by crawlers and other automatic software.  Naturally
actions like searching for a passed string are fine.

Of course, no transmission can occur while the return value is still set to @code{MHD_NO} in the
callback function.

@heading Exercises
@itemize @bullet
@item
By parsing the @code{url} string and delivering responses accordingly, implement a small server for
"virtual" files. When asked for @code{/index.htm@{l@}}, let the response consist of a HTML page
containing a link to @code{/another.html} page which is also to be created "on the fly" in case of
being requested. If neither of these two pages are requested, @code{MHD_HTTP_NOT_FOUND} shall be
returned accompanied by an informative message.

@item
A very interesting information has still been ignored by our logger---the client's IP address. 
Implement a callback function 
@verbatim
static int on_client_connect (void *cls,
                              const struct sockaddr *addr,
			      socklen_t addrlen)
@end verbatim
@noindent
that prints out the IP address in an appropriate format. You might want to use the POSIX function
@code{inet_ntoa} but bear in mind that @code{addr} is actually just a structure containing other
substructures and is @emph{not} the variable this function expects. 
Make sure to return @code{MHD_YES} so that the library knows the client is allowed to connect
(and to then process the request). If one wanted to limit access basing on IP addresses, this would be the place
to do it. The address of your @code{on_client_connect} function must be passed as the third parameter to the
@code{MHD_start_daemon} call.

@end itemize