+++ /dev/null
---- libmicrohttpd-0.9.16/doc/chapters/sessions.inc.orig 1970-01-01 01:00:00.000000000 +0100
-+++ libmicrohttpd-0.9.16/doc/chapters/sessions.inc 2011-11-06 06:41:40.346690352 +0100
-@@ -0,0 +1,71 @@
-+This chapter discusses how one should manage sessions, that is, share state between multiple
-+HTTP requests from the same user. We use a simple example where the user submits multiple
-+forms and the server is supposed to accumulate state from all of these forms. Naturally, as
-+this is a network protocol, our session mechanism must support having many users with
-+many concurrent sessions at the same time.
-+
-+In order to track users, we use a simple session cookie. A session cookie expires when the
-+user closes the browser. Changing from session cookies to persistent cookies only requires
-+adding an expiration time to the cookie. The server creates a fresh session cookie whenever
-+a request without a cookie is received, or if the supplied session cookie is not known to
-+the server.
-+
-+@heading Looking up the cookie
-+
-+Since MHD parses the HTTP cookie header for us, looking up an existing cookie
-+is straightforward:
-+
-+@verbatim
-+FIXME.
-+@end verbatim
-+
-+Here, FIXME is the name we chose for our session cookie.
-+
-+
-+@heading Setting the cookie header
-+
-+MHD requires the user to provide the full cookie format string in order to set
-+cookies. In order to generate a unique cookie, our example creates a random
-+64-character text string to be used as the value of the cookie:
-+
-+@verbatim
-+FIXME.
-+@end verbatim
-+
-+Given this cookie value, we can then set the cookie header in our HTTP response
-+as follows:
-+
-+@verbatim
-+FIXME.
-+@end verbatim
-+
-+
-+@heading Remark: Session expiration
-+
-+It is of course possible that clients stop their interaction with the
-+server at any time. In order to avoid using too much storage, the
-+server must thus discard inactive sessions at some point. Our example
-+implements this by discarding inactive sessions after a certain amount
-+of time. Alternatively, the implementation may limit the total number
-+of active sessions. Which bounds are used for idle sessions or the
-+total number of sessions obviously depends largely on the type of
-+the application and available server resources.
-+
-+@heading Example code
-+
-+A sample application implementing a website with multiple
-+forms (which are dynamically created using values from previous
-+POST requests from the same session) is available
-+as the example @code{sessions.c}.
-+
-+Note that the example uses a simple, $O(n)$ linked list traversal to
-+look up sessions and to expire old sessions. Using a hash table and a
-+heap would be more appropriate if a large number of concurrent
-+sessions is expected.
-+
-+@heading Remarks
-+
-+Naturally, it is quite conceivable to store session data in a database
-+instead of in memory. Still, having mechanisms to expire data
-+associated with long-time idle sessions (where the business process
-+has still not finished) is likely a good idea.
---- libmicrohttpd-0.9.16/doc/examples/sessions.c.orig 1970-01-01 01:00:00.000000000 +0100
-+++ libmicrohttpd-0.9.16/doc/examples/sessions.c 2011-11-06 06:41:35.430023520 +0100
-@@ -0,0 +1,748 @@
-+/*
-+ This file is part of libmicrohttpd
-+ (C) 2011 Christian Grothoff (and other contributing authors)
-+
-+ This library is free software; you can redistribute it and/or
-+ modify it under the terms of the GNU Lesser General Public
-+ License as published by the Free Software Foundation; either
-+ version 2.1 of the License, or (at your option) any later version.
-+
-+ This library is distributed in the hope that it will be useful,
-+ but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-+ Lesser General Public License for more details.
-+
-+ You should have received a copy of the GNU Lesser General Public
-+ License along with this library; if not, write to the Free Software
-+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-+*/
-+/**
-+ * @file post_example.c
-+ * @brief example for processing POST requests using libmicrohttpd
-+ * @author Christian Grothoff
-+ */
-+
-+/* needed for asprintf */
-+#define _GNU_SOURCE
-+
-+
-+#include <stdlib.h>
-+#include <string.h>
-+#include <stdio.h>
-+#include <errno.h>
-+#include <time.h>
-+#include <microhttpd.h>
-+
-+/**
-+ * Invalid method page.
-+ */
-+#define METHOD_ERROR "<html><head><title>Illegal request</title></head><body>Go away.</body></html>"
-+
-+/**
-+ * Invalid URL page.
-+ */
-+#define NOT_FOUND_ERROR "<html><head><title>Not found</title></head><body>Go away.</body></html>"
-+
-+/**
-+ * Front page. (/)
-+ */
-+#define MAIN_PAGE "<html><head><title>Welcome</title></head><body><form action=\"/2\" method=\"post\">What is your name? <input type=\"text\" name=\"v1\" value=\"%s\" /><input type=\"submit\" value=\"Next\" /></body></html>"
-+
-+/**
-+ * Second page. (/2)
-+ */
-+#define SECOND_PAGE "<html><head><title>Tell me more</title></head><body><a href=\"/\">previous</a> <form action=\"/S\" method=\"post\">%s, what is your job? <input type=\"text\" name=\"v2\" value=\"%s\" /><input type=\"submit\" value=\"Next\" /></body></html>"
-+
-+/**
-+ * Second page (/S)
-+ */
-+#define SUBMIT_PAGE "<html><head><title>Ready to submit?</title></head><body><form action=\"/F\" method=\"post\"><a href=\"/2\">previous </a> <input type=\"hidden\" name=\"DONE\" value=\"yes\" /><input type=\"submit\" value=\"Submit\" /></body></html>"
-+
-+/**
-+ * Last page.
-+ */
-+#define LAST_PAGE "<html><head><title>Thank you</title></head><body>Thank you.</body></html>"
-+
-+/**
-+ * Name of our cookie.
-+ */
-+#define COOKIE_NAME "session"
-+
-+
-+/**
-+ * State we keep for each user/session/browser.
-+ */
-+struct Session
-+{
-+ /**
-+ * We keep all sessions in a linked list.
-+ */
-+ struct Session *next;
-+
-+ /**
-+ * Unique ID for this session.
-+ */
-+ char sid[33];
-+
-+ /**
-+ * Reference counter giving the number of connections
-+ * currently using this session.
-+ */
-+ unsigned int rc;
-+
-+ /**
-+ * Time when this session was last active.
-+ */
-+ time_t start;
-+
-+ /**
-+ * String submitted via form.
-+ */
-+ char value_1[64];
-+
-+ /**
-+ * Another value submitted via form.
-+ */
-+ char value_2[64];
-+
-+};
-+
-+
-+/**
-+ * Data kept per request.
-+ */
-+struct Request
-+{
-+
-+ /**
-+ * Associated session.
-+ */
-+ struct Session *session;
-+
-+ /**
-+ * Post processor handling form data (IF this is
-+ * a POST request).
-+ */
-+ struct MHD_PostProcessor *pp;
-+
-+ /**
-+ * URL to serve in response to this POST (if this request
-+ * was a 'POST')
-+ */
-+ const char *post_url;
-+
-+};
-+
-+
-+/**
-+ * Linked list of all active sessions. Yes, O(n) but a
-+ * hash table would be overkill for a simple example...
-+ */
-+static struct Session *sessions;
-+
-+
-+
-+
-+/**
-+ * Return the session handle for this connection, or
-+ * create one if this is a new user.
-+ */
-+static struct Session *
-+get_session (struct MHD_Connection *connection)
-+{
-+ struct Session *ret;
-+ const char *cookie;
-+
-+ cookie = MHD_lookup_connection_value (connection,
-+ MHD_COOKIE_KIND,
-+ COOKIE_NAME);
-+ if (cookie != NULL)
-+ {
-+ /* find existing session */
-+ ret = sessions;
-+ while (NULL != ret)
-+ {
-+ if (0 == strcmp (cookie, ret->sid))
-+ break;
-+ ret = ret->next;
-+ }
-+ if (NULL != ret)
-+ {
-+ ret->rc++;
-+ return ret;
-+ }
-+ }
-+ /* create fresh session */
-+ ret = calloc (1, sizeof (struct Session));
-+ if (NULL == ret)
-+ {
-+ fprintf (stderr, "calloc error: %s\n", strerror (errno));
-+ return NULL;
-+ }
-+ /* not a super-secure way to generate a random session ID,
-+ but should do for a simple example... */
-+ snprintf (ret->sid,
-+ sizeof (ret->sid),
-+ "%X%X%X%X",
-+ (unsigned int) random (),
-+ (unsigned int) random (),
-+ (unsigned int) random (),
-+ (unsigned int) random ());
-+ ret->rc++;
-+ ret->start = time (NULL);
-+ ret->next = sessions;
-+ sessions = ret;
-+ return ret;
-+}
-+
-+
-+/**
-+ * Type of handler that generates a reply.
-+ *
-+ * @param cls content for the page (handler-specific)
-+ * @param mime mime type to use
-+ * @param session session information
-+ * @param connection connection to process
-+ * @param MHD_YES on success, MHD_NO on failure
-+ */
-+typedef int (*PageHandler)(const void *cls,
-+ const char *mime,
-+ struct Session *session,
-+ struct MHD_Connection *connection);
-+
-+
-+/**
-+ * Entry we generate for each page served.
-+ */
-+struct Page
-+{
-+ /**
-+ * Acceptable URL for this page.
-+ */
-+ const char *url;
-+
-+ /**
-+ * Mime type to set for the page.
-+ */
-+ const char *mime;
-+
-+ /**
-+ * Handler to call to generate response.
-+ */
-+ PageHandler handler;
-+
-+ /**
-+ * Extra argument to handler.
-+ */
-+ const void *handler_cls;
-+};
-+
-+
-+/**
-+ * Add header to response to set a session cookie.
-+ *
-+ * @param session session to use
-+ * @param response response to modify
-+ */
-+static void
-+add_session_cookie (struct Session *session,
-+ struct MHD_Response *response)
-+{
-+ char cstr[256];
-+ snprintf (cstr,
-+ sizeof (cstr),
-+ "%s=%s",
-+ COOKIE_NAME,
-+ session->sid);
-+ if (MHD_NO ==
-+ MHD_add_response_header (response,
-+ MHD_HTTP_HEADER_SET_COOKIE,
-+ cstr))
-+ {
-+ fprintf (stderr,
-+ "Failed to set session cookie header!\n");
-+ }
-+}
-+
-+
-+/**
-+ * Handler that returns a simple static HTTP page that
-+ * is passed in via 'cls'.
-+ *
-+ * @param cls a 'const char *' with the HTML webpage to return
-+ * @param mime mime type to use
-+ * @param session session handle
-+ * @param connection connection to use
-+ */
-+static int
-+serve_simple_form (const void *cls,
-+ const char *mime,
-+ struct Session *session,
-+ struct MHD_Connection *connection)
-+{
-+ int ret;
-+ const char *form = cls;
-+ struct MHD_Response *response;
-+
-+ /* return static form */
-+ response = MHD_create_response_from_buffer (strlen (form),
-+ (void *) form,
-+ MHD_RESPMEM_PERSISTENT);
-+ add_session_cookie (session, response);
-+ MHD_add_response_header (response,
-+ MHD_HTTP_HEADER_CONTENT_ENCODING,
-+ mime);
-+ ret = MHD_queue_response (connection,
-+ MHD_HTTP_OK,
-+ response);
-+ MHD_destroy_response (response);
-+ return ret;
-+}
-+
-+
-+/**
-+ * Handler that adds the 'v1' value to the given HTML code.
-+ *
-+ * @param cls a 'const char *' with the HTML webpage to return
-+ * @param mime mime type to use
-+ * @param session session handle
-+ * @param connection connection to use
-+ */
-+static int
-+fill_v1_form (const void *cls,
-+ const char *mime,
-+ struct Session *session,
-+ struct MHD_Connection *connection)
-+{
-+ int ret;
-+ const char *form = cls;
-+ char *reply;
-+ struct MHD_Response *response;
-+
-+ if (-1 == asprintf (&reply,
-+ form,
-+ session->value_1))
-+ {
-+ /* oops */
-+ return MHD_NO;
-+ }
-+ /* return static form */
-+ response = MHD_create_response_from_buffer (strlen (reply),
-+ (void *) reply,
-+ MHD_RESPMEM_MUST_FREE);
-+ add_session_cookie (session, response);
-+ MHD_add_response_header (response,
-+ MHD_HTTP_HEADER_CONTENT_ENCODING,
-+ mime);
-+ ret = MHD_queue_response (connection,
-+ MHD_HTTP_OK,
-+ response);
-+ MHD_destroy_response (response);
-+ return ret;
-+}
-+
-+
-+/**
-+ * Handler that adds the 'v1' and 'v2' values to the given HTML code.
-+ *
-+ * @param cls a 'const char *' with the HTML webpage to return
-+ * @param mime mime type to use
-+ * @param session session handle
-+ * @param connection connection to use
-+ */
-+static int
-+fill_v1_v2_form (const void *cls,
-+ const char *mime,
-+ struct Session *session,
-+ struct MHD_Connection *connection)
-+{
-+ int ret;
-+ const char *form = cls;
-+ char *reply;
-+ struct MHD_Response *response;
-+
-+ if (-1 == asprintf (&reply,
-+ form,
-+ session->value_1,
-+ session->value_2))
-+ {
-+ /* oops */
-+ return MHD_NO;
-+ }
-+ /* return static form */
-+ response = MHD_create_response_from_buffer (strlen (reply),
-+ (void *) reply,
-+ MHD_RESPMEM_MUST_FREE);
-+ add_session_cookie (session, response);
-+ MHD_add_response_header (response,
-+ MHD_HTTP_HEADER_CONTENT_ENCODING,
-+ mime);
-+ ret = MHD_queue_response (connection,
-+ MHD_HTTP_OK,
-+ response);
-+ MHD_destroy_response (response);
-+ return ret;
-+}
-+
-+
-+/**
-+ * Handler used to generate a 404 reply.
-+ *
-+ * @param cls a 'const char *' with the HTML webpage to return
-+ * @param mime mime type to use
-+ * @param session session handle
-+ * @param connection connection to use
-+ */
-+static int
-+not_found_page (const void *cls,
-+ const char *mime,
-+ struct Session *session,
-+ struct MHD_Connection *connection)
-+{
-+ int ret;
-+ struct MHD_Response *response;
-+
-+ /* unsupported HTTP method */
-+ response = MHD_create_response_from_buffer (strlen (NOT_FOUND_ERROR),
-+ (void *) NOT_FOUND_ERROR,
-+ MHD_RESPMEM_PERSISTENT);
-+ ret = MHD_queue_response (connection,
-+ MHD_HTTP_NOT_FOUND,
-+ response);
-+ MHD_add_response_header (response,
-+ MHD_HTTP_HEADER_CONTENT_ENCODING,
-+ mime);
-+ MHD_destroy_response (response);
-+ return ret;
-+}
-+
-+
-+/**
-+ * List of all pages served by this HTTP server.
-+ */
-+static struct Page pages[] =
-+ {
-+ { "/", "text/html", &fill_v1_form, MAIN_PAGE },
-+ { "/2", "text/html", &fill_v1_v2_form, SECOND_PAGE },
-+ { "/S", "text/html", &serve_simple_form, SUBMIT_PAGE },
-+ { "/F", "text/html", &serve_simple_form, LAST_PAGE },
-+ { NULL, NULL, ¬_found_page, NULL } /* 404 */
-+ };
-+
-+
-+
-+/**
-+ * Iterator over key-value pairs where the value
-+ * maybe made available in increments and/or may
-+ * not be zero-terminated. Used for processing
-+ * POST data.
-+ *
-+ * @param cls user-specified closure
-+ * @param kind type of the value
-+ * @param key 0-terminated key for the value
-+ * @param filename name of the uploaded file, NULL if not known
-+ * @param content_type mime-type of the data, NULL if not known
-+ * @param transfer_encoding encoding of the data, NULL if not known
-+ * @param data pointer to size bytes of data at the
-+ * specified offset
-+ * @param off offset of data in the overall value
-+ * @param size number of bytes in data available
-+ * @return MHD_YES to continue iterating,
-+ * MHD_NO to abort the iteration
-+ */
-+static int
-+post_iterator (void *cls,
-+ enum MHD_ValueKind kind,
-+ const char *key,
-+ const char *filename,
-+ const char *content_type,
-+ const char *transfer_encoding,
-+ const char *data, uint64_t off, size_t size)
-+{
-+ struct Request *request = cls;
-+ struct Session *session = request->session;
-+
-+ if (0 == strcmp ("DONE", key))
-+ {
-+ fprintf (stdout,
-+ "Session `%s' submitted `%s', `%s'\n",
-+ session->sid,
-+ session->value_1,
-+ session->value_2);
-+ return MHD_YES;
-+ }
-+ if (0 == strcmp ("v1", key))
-+ {
-+ if (size + off > sizeof(session->value_1))
-+ size = sizeof (session->value_1) - off;
-+ memcpy (&session->value_1[off],
-+ data,
-+ size);
-+ if (size + off < sizeof (session->value_1))
-+ session->value_1[size+off] = '\0';
-+ return MHD_YES;
-+ }
-+ if (0 == strcmp ("v2", key))
-+ {
-+ if (size + off > sizeof(session->value_2))
-+ size = sizeof (session->value_2) - off;
-+ memcpy (&session->value_2[off],
-+ data,
-+ size);
-+ if (size + off < sizeof (session->value_2))
-+ session->value_2[size+off] = '\0';
-+ return MHD_YES;
-+ }
-+ fprintf (stderr, "Unsupported form value `%s'\n", key);
-+ return MHD_YES;
-+}
-+
-+
-+/**
-+ * Main MHD callback for handling requests.
-+ *
-+ *
-+ * @param cls argument given together with the function
-+ * pointer when the handler was registered with MHD
-+ * @param url the requested url
-+ * @param method the HTTP method used ("GET", "PUT", etc.)
-+ * @param version the HTTP version string (i.e. "HTTP/1.1")
-+ * @param upload_data the data being uploaded (excluding HEADERS,
-+ * for a POST that fits into memory and that is encoded
-+ * with a supported encoding, the POST data will NOT be
-+ * given in upload_data and is instead available as
-+ * part of MHD_get_connection_values; very large POST
-+ * data *will* be made available incrementally in
-+ * upload_data)
-+ * @param upload_data_size set initially to the size of the
-+ * upload_data provided; the method must update this
-+ * value to the number of bytes NOT processed;
-+ * @param con_cls pointer that the callback can set to some
-+ * address and that will be preserved by MHD for future
-+ * calls for this request; since the access handler may
-+ * be called many times (i.e., for a PUT/POST operation
-+ * with plenty of upload data) this allows the application
-+ * to easily associate some request-specific state.
-+ * If necessary, this state can be cleaned up in the
-+ * global "MHD_RequestCompleted" callback (which
-+ * can be set with the MHD_OPTION_NOTIFY_COMPLETED).
-+ * Initially, <tt>*con_cls</tt> will be NULL.
-+ * @return MHS_YES if the connection was handled successfully,
-+ * MHS_NO if the socket must be closed due to a serios
-+ * error while handling the request
-+ */
-+static int
-+create_response (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 **ptr)
-+{
-+ struct MHD_Response *response;
-+ struct Request *request;
-+ struct Session *session;
-+ int ret;
-+ unsigned int i;
-+
-+ request = *ptr;
-+ if (NULL == request)
-+ {
-+ request = calloc (1, sizeof (struct Request));
-+ if (NULL == request)
-+ {
-+ fprintf (stderr, "calloc error: %s\n", strerror (errno));
-+ return MHD_NO;
-+ }
-+ *ptr = request;
-+ if (0 == strcmp (method, MHD_HTTP_METHOD_POST))
-+ {
-+ request->pp = MHD_create_post_processor (connection, 1024,
-+ &post_iterator, request);
-+ if (NULL == request->pp)
-+ {
-+ fprintf (stderr, "Failed to setup post processor for `%s'\n",
-+ url);
-+ return MHD_NO; /* internal error */
-+ }
-+ }
-+ return MHD_YES;
-+ }
-+ if (NULL == request->session)
-+ {
-+ request->session = get_session (connection);
-+ if (NULL == request->session)
-+ {
-+ fprintf (stderr, "Failed to setup session for `%s'\n",
-+ url);
-+ return MHD_NO; /* internal error */
-+ }
-+ }
-+ session = request->session;
-+ session->start = time (NULL);
-+ if (0 == strcmp (method, MHD_HTTP_METHOD_POST))
-+ {
-+ /* evaluate POST data */
-+ MHD_post_process (request->pp,
-+ upload_data,
-+ *upload_data_size);
-+ if (0 != *upload_data_size)
-+ {
-+ *upload_data_size = 0;
-+ return MHD_YES;
-+ }
-+ /* done with POST data, serve response */
-+ MHD_destroy_post_processor (request->pp);
-+ request->pp = NULL;
-+ method = MHD_HTTP_METHOD_GET; /* fake 'GET' */
-+ if (NULL != request->post_url)
-+ url = request->post_url;
-+ }
-+
-+ if ( (0 == strcmp (method, MHD_HTTP_METHOD_GET)) ||
-+ (0 == strcmp (method, MHD_HTTP_METHOD_HEAD)) )
-+ {
-+ /* find out which page to serve */
-+ i=0;
-+ while ( (pages[i].url != NULL) &&
-+ (0 != strcmp (pages[i].url, url)) )
-+ i++;
-+ ret = pages[i].handler (pages[i].handler_cls,
-+ pages[i].mime,
-+ session, connection);
-+ if (ret != MHD_YES)
-+ fprintf (stderr, "Failed to create page for `%s'\n",
-+ url);
-+ return ret;
-+ }
-+ /* unsupported HTTP method */
-+ response = MHD_create_response_from_buffer (strlen (METHOD_ERROR),
-+ (void *) METHOD_ERROR,
-+ MHD_RESPMEM_PERSISTENT);
-+ ret = MHD_queue_response (connection,
-+ MHD_HTTP_METHOD_NOT_ACCEPTABLE,
-+ response);
-+ MHD_destroy_response (response);
-+ return ret;
-+}
-+
-+
-+/**
-+ * Callback called upon completion of a request.
-+ * Decrements session reference counter.
-+ *
-+ * @param cls not used
-+ * @param connection connection that completed
-+ * @param con_cls session handle
-+ * @param toe status code
-+ */
-+static void
-+request_completed_callback (void *cls,
-+ struct MHD_Connection *connection,
-+ void **con_cls,
-+ enum MHD_RequestTerminationCode toe)
-+{
-+ struct Request *request = *con_cls;
-+
-+ if (NULL == request)
-+ return;
-+ if (NULL != request->session)
-+ request->session->rc--;
-+ if (NULL != request->pp)
-+ MHD_destroy_post_processor (request->pp);
-+ free (request);
-+}
-+
-+
-+/**
-+ * Clean up handles of sessions that have been idle for
-+ * too long.
-+ */
-+static void
-+expire_sessions ()
-+{
-+ struct Session *pos;
-+ struct Session *prev;
-+ struct Session *next;
-+ time_t now;
-+
-+ now = time (NULL);
-+ prev = NULL;
-+ pos = sessions;
-+ while (NULL != pos)
-+ {
-+ next = pos->next;
-+ if (now - pos->start > 60 * 60)
-+ {
-+ /* expire sessions after 1h */
-+ if (NULL == prev)
-+ sessions = pos->next;
-+ else
-+ prev->next = next;
-+ free (pos);
-+ }
-+ else
-+ prev = pos;
-+ pos = next;
-+ }
-+}
-+
-+
-+/**
-+ * Call with the port number as the only argument.
-+ * Never terminates (other than by signals, such as CTRL-C).
-+ */
-+int
-+main (int argc, char *const *argv)
-+{
-+ struct MHD_Daemon *d;
-+ struct timeval tv;
-+ struct timeval *tvp;
-+ fd_set rs;
-+ fd_set ws;
-+ fd_set es;
-+ int max;
-+ unsigned MHD_LONG_LONG mhd_timeout;
-+
-+ if (argc != 2)
-+ {
-+ printf ("%s PORT\n", argv[0]);
-+ return 1;
-+ }
-+ /* initialize PRNG */
-+ srandom ((unsigned int) time (NULL));
-+ d = MHD_start_daemon (MHD_USE_DEBUG,
-+ atoi (argv[1]),
-+ NULL, NULL,
-+ &create_response, NULL,
-+ MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 15,
-+ MHD_OPTION_NOTIFY_COMPLETED, &request_completed_callback, NULL,
-+ MHD_OPTION_END);
-+ if (NULL == d)
-+ return 1;
-+ while (1)
-+ {
-+ expire_sessions ();
-+ max = 0;
-+ FD_ZERO (&rs);
-+ FD_ZERO (&ws);
-+ FD_ZERO (&es);
-+ if (MHD_YES != MHD_get_fdset (d, &rs, &ws, &es, &max))
-+ break; /* fatal internal error */
-+ if (MHD_get_timeout (d, &mhd_timeout) == MHD_YES)
-+ {
-+ tv.tv_sec = mhd_timeout / 1000;
-+ tv.tv_usec = (mhd_timeout - (tv.tv_sec * 1000)) * 1000;
-+ tvp = &tv;
-+ }
-+ else
-+ tvp = NULL;
-+ select (max + 1, &rs, &ws, &es, tvp);
-+ MHD_run (d);
-+ }
-+ MHD_stop_daemon (d);
-+ return 0;
-+}
-+
projects / packages / libmicrohttpd.git / commitdiff