[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: [libmicrohttpd] [PATCH] code style: remove tabs from source code
|
From: |
Tim Rühsen |
|
Subject: |
Re: [libmicrohttpd] [PATCH] code style: remove tabs from source code |
|
Date: |
Wed, 24 Jan 2018 14:51:05 +0100 |
|
User-agent: |
Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.5.2 |
Currently, some indentation only works for a tab width of 8 - I
personally call this broken.
But your patch makes the situation not better. Now the function args are
not aligned any more. What about replacing those tabs with 8 spaces ?
With Best Regards, Tim
On 01/24/2018 02:23 PM, Moritz Warning wrote:
> Signed-off-by: Moritz Warning <address@hidden>
> ---
>
> The code contains a lot of lines with spaces mixed with tabs.
> This patch replaces all tabs with spaces in order to improve the code style.
>
> ---
> src/examples/authorization_example.c | 10 +-
> src/examples/benchmark.c | 32 +-
> src/examples/benchmark_https.c | 28 +-
> src/examples/chunked_example.c | 8 +-
> src/examples/demo.c | 396 +++----
> src/examples/demo_https.c | 398 +++----
> src/examples/digest_auth_example.c | 56 +-
> src/examples/dual_stack_example.c | 12 +-
> src/examples/fileserver_example.c | 14 +-
> src/examples/fileserver_example_dirs.c | 74 +-
> src/examples/fileserver_example_external_select.c | 16 +-
> src/examples/https_fileserver_example.c | 14 +-
> src/examples/minimal_example.c | 14 +-
> src/examples/msgs_i18n.c | 38 +-
> src/examples/post_example.c | 302 ++---
> src/examples/querystring_example.c | 2 +-
> src/examples/refuse_post_example.c | 8 +-
> src/examples/upgrade_example.c | 4 +-
> src/include/microhttpd.h | 130 +--
> src/include/microhttpd2.h | 198 ++--
> src/microhttpd/basicauth.c | 38 +-
> src/microhttpd/connection.c | 478 ++++----
> src/microhttpd/connection_https.c | 24 +-
> src/microhttpd/daemon.c | 1246
> ++++++++++-----------
> src/microhttpd/digestauth.c | 280 ++---
> src/microhttpd/internal.c | 152 +--
> src/microhttpd/internal.h | 16 +-
> src/microhttpd/md5.c | 36 +-
> src/microhttpd/md5.h | 14 +-
> src/microhttpd/memorypool.c | 12 +-
> src/microhttpd/memorypool.h | 12 +-
> src/microhttpd/postprocessor.c | 50 +-
> src/microhttpd/response.c | 66 +-
> src/microhttpd/test_upgrade.c | 18 +-
> src/microhttpd/tsearch.c | 60 +-
> src/microhttpd/tsearch.h | 8 +-
> src/testcurl/gauger.h | 10 +-
> src/testcurl/https/test_empty_response.c | 4 +-
> src/testcurl/https/test_https_get.c | 4 +-
> src/testcurl/https/test_https_get_select.c | 6 +-
> src/testcurl/https/test_https_multi_daemon.c | 6 +-
> src/testcurl/https/test_https_session_info.c | 8 +-
> src/testcurl/https/test_tls_authentication.c | 4 +-
> src/testcurl/https/test_tls_extensions.c | 6 +-
> src/testcurl/https/test_tls_options.c | 30 +-
> src/testcurl/https/tls_test_common.c | 30 +-
> src/testcurl/https/tls_test_common.h | 2 +-
> src/testcurl/perf_get.c | 246 ++--
> src/testcurl/perf_get_concurrent.c | 42 +-
> src/testcurl/test_callback.c | 96 +-
> src/testcurl/test_concurrent_stop.c | 8 +-
> src/testcurl/test_delete.c | 2 +-
> src/testcurl/test_digestauth.c | 30 +-
> src/testcurl/test_digestauth_with_arguments.c | 70 +-
> src/testcurl/test_get.c | 8 +-
> src/testcurl/test_get_response_cleanup.c | 18 +-
> src/testcurl/test_get_sendfile.c | 10 +-
> src/testcurl/test_iplimit.c | 6 +-
> src/testcurl/test_large_put.c | 12 +-
> src/testcurl/test_long_header.c | 12 +-
> src/testcurl/test_parse_cookies.c | 4 +-
> src/testcurl/test_post.c | 48 +-
> src/testcurl/test_post_loop.c | 74 +-
> src/testcurl/test_postform.c | 26 +-
> src/testcurl/test_process_arguments.c | 8 +-
> src/testcurl/test_process_headers.c | 4 +-
> src/testcurl/test_put.c | 2 +-
> src/testcurl/test_put_chunked.c | 4 +-
> src/testcurl/test_quiesce.c | 6 +-
> src/testcurl/test_termination.c | 2 +-
> src/testcurl/test_timeout.c | 36 +-
> src/testcurl/test_urlparse.c | 16 +-
> src/testzzuf/test_get.c | 4 +-
> src/testzzuf/test_long_header.c | 4 +-
> src/testzzuf/test_post.c | 22 +-
> src/testzzuf/test_post_form.c | 22 +-
> src/testzzuf/test_put.c | 4 +-
> src/testzzuf/test_put_chunked.c | 4 +-
> src/testzzuf/test_put_large.c | 8 +-
> 79 files changed, 2616 insertions(+), 2616 deletions(-)
>
> diff --git a/src/examples/authorization_example.c
> b/src/examples/authorization_example.c
> index d8a88203..e6496304 100644
> --- a/src/examples/authorization_example.c
> +++ b/src/examples/authorization_example.c
> @@ -78,15 +78,15 @@ ahc_echo (void *cls,
> if (fail)
> {
> response = MHD_create_response_from_buffer (strlen (DENIED),
> - (void *) DENIED,
> - MHD_RESPMEM_PERSISTENT);
> + (void *) DENIED,
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_basic_auth_fail_response
> (connection,"TestRealm",response);
> }
> else
> {
> response = MHD_create_response_from_buffer (strlen (me),
> - (void *) me,
> - MHD_RESPMEM_PERSISTENT);
> + (void *) me,
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> }
> if (NULL != user)
> @@ -109,7 +109,7 @@ main (int argc, char *const *argv)
> (UINT16_MAX < port) )
> {
> fprintf (stderr,
> - "%s PORT\n", argv[0]);
> + "%s PORT\n", argv[0]);
> return 1;
> }
>
> diff --git a/src/examples/benchmark.c b/src/examples/benchmark.c
> index 9512b9bf..fc80c4b9 100644
> --- a/src/examples/benchmark.c
> +++ b/src/examples/benchmark.c
> @@ -62,9 +62,9 @@ static struct MHD_Response *response;
> */
> static void
> completed_callback (void *cls,
> - struct MHD_Connection *connection,
> - void **con_cls,
> - enum MHD_RequestTerminationCode toe)
> + struct MHD_Connection *connection,
> + void **con_cls,
> + enum MHD_RequestTerminationCode toe)
> {
> struct timeval *tv = *con_cls;
> struct timeval tve;
> @@ -94,7 +94,7 @@ completed_callback (void *cls,
>
> static void *
> uri_logger_cb (void *cls,
> - const char *uri)
> + const char *uri)
> {
> struct timeval *tv = malloc (sizeof (struct timeval));
> (void)cls; /* Unused. Silent compiler warning. */
> @@ -139,26 +139,26 @@ main (int argc, char *const *argv)
> return 1;
> }
> response = MHD_create_response_from_buffer (strlen (PAGE),
> - (void *) PAGE,
> - MHD_RESPMEM_PERSISTENT);
> + (void *) PAGE,
> + MHD_RESPMEM_PERSISTENT);
> #if 0
> (void) MHD_add_response_header (response,
> - MHD_HTTP_HEADER_CONNECTION,
> - "close");
> + MHD_HTTP_HEADER_CONNECTION,
> + "close");
> #endif
> d = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD |
> MHD_USE_SUPPRESS_DATE_NO_CLOCK
> #ifdef EPOLL_SUPPORT
> - | MHD_USE_EPOLL | MHD_USE_TURBO
> + | MHD_USE_EPOLL | MHD_USE_TURBO
> #endif
> - ,
> + ,
> atoi (argv[1]),
> NULL, NULL, &ahc_echo, NULL,
> - MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 120,
> - MHD_OPTION_THREAD_POOL_SIZE, (unsigned int)
> NUMBER_OF_THREADS,
> - MHD_OPTION_URI_LOG_CALLBACK, &uri_logger_cb, NULL,
> - MHD_OPTION_NOTIFY_COMPLETED, &completed_callback, NULL,
> - MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 1000,
> - MHD_OPTION_END);
> + MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 120,
> + MHD_OPTION_THREAD_POOL_SIZE, (unsigned int) NUMBER_OF_THREADS,
> + MHD_OPTION_URI_LOG_CALLBACK, &uri_logger_cb, NULL,
> + MHD_OPTION_NOTIFY_COMPLETED, &completed_callback, NULL,
> + MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 1000,
> + MHD_OPTION_END);
> if (d == NULL)
> return 1;
> (void) getc (stdin);
> diff --git a/src/examples/benchmark_https.c b/src/examples/benchmark_https.c
> index 87a79717..dd684bf3 100644
> --- a/src/examples/benchmark_https.c
> +++ b/src/examples/benchmark_https.c
> @@ -62,9 +62,9 @@ static struct MHD_Response *response;
> */
> static void
> completed_callback (void *cls,
> - struct MHD_Connection *connection,
> - void **con_cls,
> - enum MHD_RequestTerminationCode toe)
> + struct MHD_Connection *connection,
> + void **con_cls,
> + enum MHD_RequestTerminationCode toe)
> {
> struct timeval *tv = *con_cls;
> struct timeval tve;
> @@ -94,7 +94,7 @@ completed_callback (void *cls,
>
> static void *
> uri_logger_cb (void *cls,
> - const char *uri)
> + const char *uri)
> {
> struct timeval *tv = malloc (sizeof (struct timeval));
> (void)cls; /* Unused. Silent compiler warning. */
> @@ -190,23 +190,23 @@ main (int argc, char *const *argv)
> return 1;
> }
> response = MHD_create_response_from_buffer (strlen (PAGE),
> - (void *) PAGE,
> - MHD_RESPMEM_PERSISTENT);
> + (void *) PAGE,
> + MHD_RESPMEM_PERSISTENT);
> d = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_TLS
> #ifdef EPOLL_SUPPORT
> - | MHD_USE_EPOLL | MHD_USE_TURBO
> + | MHD_USE_EPOLL | MHD_USE_TURBO
> #endif
> - ,
> + ,
> atoi (argv[1]),
> NULL, NULL, &ahc_echo, NULL,
> - MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 120,
> - MHD_OPTION_THREAD_POOL_SIZE, (unsigned int)
> NUMBER_OF_THREADS,
> - MHD_OPTION_URI_LOG_CALLBACK, &uri_logger_cb, NULL,
> - MHD_OPTION_NOTIFY_COMPLETED, &completed_callback, NULL,
> - MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 1000,
> + MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 120,
> + MHD_OPTION_THREAD_POOL_SIZE, (unsigned int) NUMBER_OF_THREADS,
> + MHD_OPTION_URI_LOG_CALLBACK, &uri_logger_cb, NULL,
> + MHD_OPTION_NOTIFY_COMPLETED, &completed_callback, NULL,
> + MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 1000,
> MHD_OPTION_HTTPS_MEM_KEY, srv_signed_key_pem,
> MHD_OPTION_HTTPS_MEM_CERT, srv_signed_cert_pem,
> - MHD_OPTION_END);
> + MHD_OPTION_END);
> if (d == NULL)
> return 1;
> (void) getc (stdin);
> diff --git a/src/examples/chunked_example.c b/src/examples/chunked_example.c
> index 26dacd3b..7bf46801 100644
> --- a/src/examples/chunked_example.c
> +++ b/src/examples/chunked_example.c
> @@ -165,13 +165,13 @@ main (int argc, char *const *argv)
> d = MHD_start_daemon (/* MHD_USE_INTERNAL_POLLING_THREAD |
> MHD_USE_ERROR_LOG, */
> MHD_USE_AUTO | MHD_USE_INTERNAL_POLLING_THREAD |
> MHD_USE_ERROR_LOG,
> /* MHD_USE_INTERNAL_POLLING_THREAD |
> MHD_USE_ERROR_LOG | MHD_USE_POLL, */
> - /* MHD_USE_THREAD_PER_CONNECTION |
> MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG | MHD_USE_POLL, */
> - /* MHD_USE_THREAD_PER_CONNECTION |
> MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG, */
> + /* MHD_USE_THREAD_PER_CONNECTION | MHD_USE_INTERNAL_POLLING_THREAD |
> MHD_USE_ERROR_LOG | MHD_USE_POLL, */
> + /* MHD_USE_THREAD_PER_CONNECTION | MHD_USE_INTERNAL_POLLING_THREAD |
> MHD_USE_ERROR_LOG, */
> (uint16_t) port,
> NULL, NULL,
> &ahc_echo, NULL,
> - MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 120,
> - MHD_OPTION_END);
> + MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 120,
> + MHD_OPTION_END);
> if (NULL == d)
> return 1;
> (void) getc (stdin);
> diff --git a/src/examples/demo.c b/src/examples/demo.c
> index 6c9ad049..80b33030 100644
> --- a/src/examples/demo.c
> +++ b/src/examples/demo.c
> @@ -204,8 +204,8 @@ static void
> mark_as_html (struct MHD_Response *response)
> {
> (void) MHD_add_response_header (response,
> - MHD_HTTP_HEADER_CONTENT_TYPE,
> - "text/html");
> + MHD_HTTP_HEADER_CONTENT_TYPE,
> + "text/html");
> }
>
>
> @@ -258,7 +258,7 @@ struct ResponseDataContext
> */
> static int
> list_directory (struct ResponseDataContext *rdc,
> - const char *dirname)
> + const char *dirname)
> {
> char fullname[PATH_MAX];
> struct stat sbuf;
> @@ -270,32 +270,32 @@ list_directory (struct ResponseDataContext *rdc,
> while (NULL != (de = readdir (dir)))
> {
> if ('.' == de->d_name[0])
> - continue;
> + continue;
> if (sizeof (fullname) <= (unsigned int)
> - snprintf (fullname, sizeof (fullname),
> - "%s/%s",
> - dirname, de->d_name))
> - continue; /* ugh, file too long? how can this be!? */
> + snprintf (fullname, sizeof (fullname),
> + "%s/%s",
> + dirname, de->d_name))
> + continue; /* ugh, file too long? how can this be!? */
> if (0 != stat (fullname, &sbuf))
> - continue; /* ugh, failed to 'stat' */
> + continue; /* ugh, failed to 'stat' */
> if (! S_ISREG (sbuf.st_mode))
> - continue; /* not a regular file, skip */
> + continue; /* not a regular file, skip */
> if (rdc->off + 1024 > rdc->buf_len)
> - {
> - void *r;
> -
> - if ( (2 * rdc->buf_len + 1024) < rdc->buf_len)
> - break; /* more than SIZE_T _index_ size? Too big for us */
> - rdc->buf_len = 2 * rdc->buf_len + 1024;
> - if (NULL == (r = realloc (rdc->buf, rdc->buf_len)))
> - break; /* out of memory */
> - rdc->buf = r;
> - }
> + {
> + void *r;
> +
> + if ( (2 * rdc->buf_len + 1024) < rdc->buf_len)
> + break; /* more than SIZE_T _index_ size? Too big for us */
> + rdc->buf_len = 2 * rdc->buf_len + 1024;
> + if (NULL == (r = realloc (rdc->buf, rdc->buf_len)))
> + break; /* out of memory */
> + rdc->buf = r;
> + }
> rdc->off += snprintf (&rdc->buf[rdc->off],
> - rdc->buf_len - rdc->off,
> - "<li><a href=\"/%s\">%s</a></li>\n",
> - fullname,
> - de->d_name);
> + rdc->buf_len - rdc->off,
> + "<li><a href=\"/%s\">%s</a></li>\n",
> + fullname,
> + de->d_name);
> }
> (void) closedir (dir);
> return MHD_YES;
> @@ -325,60 +325,60 @@ update_directory ()
> return;
> }
> rdc.off = snprintf (rdc.buf, rdc.buf_len,
> - "%s",
> - INDEX_PAGE_HEADER);
> + "%s",
> + INDEX_PAGE_HEADER);
> for (language_idx = 0; NULL != languages[language_idx].dirname;
> language_idx++)
> {
> language = &languages[language_idx];
>
> if (0 != stat (language->dirname, &sbuf))
> - continue; /* empty */
> + continue; /* empty */
> /* we ensured always +1k room, filenames are ~256 bytes,
> - so there is always still enough space for the header
> - without need for an additional reallocation check. */
> + so there is always still enough space for the header
> + without need for an additional reallocation check. */
> rdc.off += snprintf (&rdc.buf[rdc.off], rdc.buf_len - rdc.off,
> - "<h2>%s</h2>\n",
> - language->longname);
> + "<h2>%s</h2>\n",
> + language->longname);
> for (category_idx = 0; NULL != categories[category_idx];
> category_idx++)
> - {
> - category = categories[category_idx];
> - snprintf (dir_name, sizeof (dir_name),
> - "%s/%s",
> - language->dirname,
> - category);
> - if (0 != stat (dir_name, &sbuf))
> - continue; /* empty */
> -
> - /* we ensured always +1k room, filenames are ~256 bytes,
> - so there is always still enough space for the header
> - without need for an additional reallocation check. */
> - rdc.off += snprintf (&rdc.buf[rdc.off], rdc.buf_len - rdc.off,
> - "<h3>%s</h3>\n",
> - category);
> -
> - if (MHD_NO == list_directory (&rdc, dir_name))
> - {
> - free (rdc.buf);
> - update_cached_response (NULL);
> - return;
> - }
> - }
> + {
> + category = categories[category_idx];
> + snprintf (dir_name, sizeof (dir_name),
> + "%s/%s",
> + language->dirname,
> + category);
> + if (0 != stat (dir_name, &sbuf))
> + continue; /* empty */
> +
> + /* we ensured always +1k room, filenames are ~256 bytes,
> + so there is always still enough space for the header
> + without need for an additional reallocation check. */
> + rdc.off += snprintf (&rdc.buf[rdc.off], rdc.buf_len - rdc.off,
> + "<h3>%s</h3>\n",
> + category);
> +
> + if (MHD_NO == list_directory (&rdc, dir_name))
> + {
> + free (rdc.buf);
> + update_cached_response (NULL);
> + return;
> + }
> + }
> }
> /* we ensured always +1k room, filenames are ~256 bytes,
> so there is always still enough space for the footer
> without need for a final reallocation check. */
> rdc.off += snprintf (&rdc.buf[rdc.off], rdc.buf_len - rdc.off,
> - "%s",
> - INDEX_PAGE_FOOTER);
> + "%s",
> + INDEX_PAGE_FOOTER);
> initial_allocation = rdc.buf_len; /* remember for next time */
> response = MHD_create_response_from_buffer (rdc.off,
> - rdc.buf,
> - MHD_RESPMEM_MUST_FREE);
> + rdc.buf,
> + MHD_RESPMEM_MUST_FREE);
> mark_as_html (response);
> #if FORCE_CLOSE
> (void) MHD_add_response_header (response,
> - MHD_HTTP_HEADER_CONNECTION,
> - "close");
> + MHD_HTTP_HEADER_CONNECTION,
> + "close");
> #endif
> update_cached_response (response);
> }
> @@ -437,8 +437,8 @@ struct UploadContext
> */
> static int
> do_append (char **ret,
> - const char *data,
> - size_t size)
> + const char *data,
> + size_t size)
> {
> char *buf;
> size_t old_len;
> @@ -481,14 +481,14 @@ do_append (char **ret,
> */
> static int
> process_upload_data (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)
> + 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 UploadContext *uc = cls;
> int i;
> @@ -504,8 +504,8 @@ process_upload_data (void *cls,
> if (0 != strcmp (key, "upload"))
> {
> fprintf (stderr,
> - "Ignoring unexpected form value `%s'\n",
> - key);
> + "Ignoring unexpected form value `%s'\n",
> + key);
> return MHD_YES; /* ignore */
> }
> if (NULL == filename)
> @@ -517,8 +517,8 @@ process_upload_data (void *cls,
> (NULL == uc->language) )
> {
> fprintf (stderr,
> - "Missing form data for upload `%s'\n",
> - filename);
> + "Missing form data for upload `%s'\n",
> + filename);
> uc->response = request_refused_response;
> return MHD_NO;
> }
> @@ -527,12 +527,12 @@ process_upload_data (void *cls,
> char fn[PATH_MAX];
>
> if ( (NULL != strstr (filename, "..")) ||
> - (NULL != strchr (filename, '/')) ||
> - (NULL != strchr (filename, '\\')) )
> - {
> - uc->response = request_refused_response;
> - return MHD_NO;
> - }
> + (NULL != strchr (filename, '/')) ||
> + (NULL != strchr (filename, '\\')) )
> + {
> + uc->response = request_refused_response;
> + return MHD_NO;
> + }
> /* create directories -- if they don't exist already */
> #ifdef WINDOWS
> (void) mkdir (uc->language);
> @@ -540,9 +540,9 @@ process_upload_data (void *cls,
> (void) mkdir (uc->language, S_IRWXU);
> #endif
> snprintf (fn, sizeof (fn),
> - "%s/%s",
> - uc->language,
> - uc->category);
> + "%s/%s",
> + uc->language,
> + uc->category);
> #ifdef WINDOWS
> (void) mkdir (fn);
> #else
> @@ -550,29 +550,29 @@ process_upload_data (void *cls,
> #endif
> /* open file */
> snprintf (fn, sizeof (fn),
> - "%s/%s/%s",
> - uc->language,
> - uc->category,
> - filename);
> + "%s/%s/%s",
> + uc->language,
> + uc->category,
> + filename);
> for (i=strlen (fn)-1;i>=0;i--)
> - if (! isprint ((unsigned char) fn[i]))
> - fn[i] = '_';
> + if (! isprint ((unsigned char) fn[i]))
> + fn[i] = '_';
> uc->fd = open (fn,
> - O_CREAT | O_EXCL
> + O_CREAT | O_EXCL
> #if O_LARGEFILE
> - | O_LARGEFILE
> + | O_LARGEFILE
> #endif
> - | O_WRONLY,
> - S_IRUSR | S_IWUSR);
> + | O_WRONLY,
> + S_IRUSR | S_IWUSR);
> if (-1 == uc->fd)
> - {
> - fprintf (stderr,
> - "Error opening file `%s' for upload: %s\n",
> - fn,
> - strerror (errno));
> - uc->response = request_refused_response;
> - return MHD_NO;
> - }
> + {
> + fprintf (stderr,
> + "Error opening file `%s' for upload: %s\n",
> + fn,
> + strerror (errno));
> + uc->response = request_refused_response;
> + return MHD_NO;
> + }
> uc->filename = strdup (fn);
> }
> if ( (0 != size) &&
> @@ -580,18 +580,18 @@ process_upload_data (void *cls,
> {
> /* write failed; likely: disk full */
> fprintf (stderr,
> - "Error writing to file `%s': %s\n",
> - uc->filename,
> - strerror (errno));
> + "Error writing to file `%s': %s\n",
> + uc->filename,
> + strerror (errno));
> uc->response = internal_error_response;
> (void) close (uc->fd);
> uc->fd = -1;
> if (NULL != uc->filename)
> - {
> - unlink (uc->filename);
> - free (uc->filename);
> - uc->filename = NULL;
> - }
> + {
> + unlink (uc->filename);
> + free (uc->filename);
> + uc->filename = NULL;
> + }
> return MHD_NO;
> }
> return MHD_YES;
> @@ -611,9 +611,9 @@ process_upload_data (void *cls,
> */
> static void
> response_completed_callback (void *cls,
> - struct MHD_Connection *connection,
> - void **con_cls,
> - enum MHD_RequestTerminationCode toe)
> + struct MHD_Connection *connection,
> + void **con_cls,
> + enum MHD_RequestTerminationCode toe)
> {
> struct UploadContext *uc = *con_cls;
> (void)cls; /* Unused. Silent compiler warning. */
> @@ -632,10 +632,10 @@ response_completed_callback (void *cls,
> (void) close (uc->fd);
> if (NULL != uc->filename)
> {
> - fprintf (stderr,
> - "Upload of file `%s' failed (incomplete or aborted), removing
> file.\n",
> - uc->filename);
> - (void) unlink (uc->filename);
> + fprintf (stderr,
> + "Upload of file `%s' failed (incomplete or aborted), removing file.\n",
> + uc->filename);
> + (void) unlink (uc->filename);
> }
> }
> if (NULL != uc->filename)
> @@ -658,12 +658,12 @@ return_directory_response (struct MHD_Connection
> *connection)
> (void) pthread_mutex_lock (&mutex);
> if (NULL == cached_directory_response)
> ret = MHD_queue_response (connection,
> - MHD_HTTP_INTERNAL_SERVER_ERROR,
> - internal_error_response);
> + MHD_HTTP_INTERNAL_SERVER_ERROR,
> + internal_error_response);
> else
> ret = MHD_queue_response (connection,
> - MHD_HTTP_OK,
> - cached_directory_response);
> + MHD_HTTP_OK,
> + cached_directory_response);
> (void) pthread_mutex_unlock (&mutex);
> return ret;
> }
> @@ -684,12 +684,12 @@ return_directory_response (struct MHD_Connection
> *connection)
> */
> static int
> generate_page (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_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;
> int ret;
> @@ -712,7 +712,7 @@ generate_page (void *cls,
> return MHD_NO; /* unexpected method (we're not polite...) */
> fd = -1;
> if ( (NULL == strstr (&url[1], "..")) &&
> - ('/' != url[1]) )
> + ('/' != url[1]) )
> {
> fd = open (&url[1], O_RDONLY);
> if ( (-1 != fd) &&
> @@ -724,35 +724,35 @@ generate_page (void *cls,
> }
> }
> if (-1 == fd)
> - return MHD_queue_response (connection,
> - MHD_HTTP_NOT_FOUND,
> - file_not_found_response);
> + return MHD_queue_response (connection,
> + MHD_HTTP_NOT_FOUND,
> + file_not_found_response);
> #ifdef MHD_HAVE_LIBMAGIC
> /* read beginning of the file to determine mime type */
> got = read (fd, file_data, sizeof (file_data));
> (void) lseek (fd, 0, SEEK_SET);
> if (-1 != got)
> - mime = magic_buffer (magic, file_data, got);
> + mime = magic_buffer (magic, file_data, got);
> else
> #endif /* MHD_HAVE_LIBMAGIC */
> - mime = NULL;
> + mime = NULL;
>
> if (NULL == (response = MHD_create_response_from_fd (buf.st_size,
> - fd)))
> - {
> - /* internal error (i.e. out of memory) */
> - (void) close (fd);
> - return MHD_NO;
> - }
> + fd)))
> + {
> + /* internal error (i.e. out of memory) */
> + (void) close (fd);
> + return MHD_NO;
> + }
>
> /* add mime type if we had one */
> if (NULL != mime)
> - (void) MHD_add_response_header (response,
> - MHD_HTTP_HEADER_CONTENT_TYPE,
> - mime);
> + (void) MHD_add_response_header (response,
> + MHD_HTTP_HEADER_CONTENT_TYPE,
> + mime);
> ret = MHD_queue_response (connection,
> - MHD_HTTP_OK,
> - response);
> + MHD_HTTP_OK,
> + response);
> MHD_destroy_response (response);
> return ret;
> }
> @@ -763,52 +763,52 @@ generate_page (void *cls,
> struct UploadContext *uc = *ptr;
>
> if (NULL == uc)
> - {
> - if (NULL == (uc = malloc (sizeof (struct UploadContext))))
> - return MHD_NO; /* out of memory, close connection */
> - memset (uc, 0, sizeof (struct UploadContext));
> + {
> + if (NULL == (uc = malloc (sizeof (struct UploadContext))))
> + return MHD_NO; /* out of memory, close connection */
> + memset (uc, 0, sizeof (struct UploadContext));
> uc->fd = -1;
> - uc->connection = connection;
> - uc->pp = MHD_create_post_processor (connection,
> - 64 * 1024 /* buffer size */,
> - &process_upload_data, uc);
> - if (NULL == uc->pp)
> - {
> - /* out of memory, close connection */
> - free (uc);
> - return MHD_NO;
> - }
> - *ptr = uc;
> - return MHD_YES;
> - }
> + uc->connection = connection;
> + uc->pp = MHD_create_post_processor (connection,
> + 64 * 1024 /* buffer size */,
> + &process_upload_data, uc);
> + if (NULL == uc->pp)
> + {
> + /* out of memory, close connection */
> + free (uc);
> + return MHD_NO;
> + }
> + *ptr = uc;
> + return MHD_YES;
> + }
> if (0 != *upload_data_size)
> - {
> - if (NULL == uc->response)
> - (void) MHD_post_process (uc->pp,
> - upload_data,
> - *upload_data_size);
> - *upload_data_size = 0;
> - return MHD_YES;
> - }
> + {
> + if (NULL == uc->response)
> + (void) MHD_post_process (uc->pp,
> + upload_data,
> + *upload_data_size);
> + *upload_data_size = 0;
> + return MHD_YES;
> + }
> /* end of upload, finish it! */
> MHD_destroy_post_processor (uc->pp);
> uc->pp = NULL;
> if (-1 != uc->fd)
> - {
> - close (uc->fd);
> - uc->fd = -1;
> - }
> + {
> + close (uc->fd);
> + uc->fd = -1;
> + }
> if (NULL != uc->response)
> - {
> - return MHD_queue_response (connection,
> - MHD_HTTP_FORBIDDEN,
> - uc->response);
> - }
> + {
> + return MHD_queue_response (connection,
> + MHD_HTTP_FORBIDDEN,
> + uc->response);
> + }
> else
> - {
> - update_directory ();
> - return return_directory_response (connection);
> - }
> + {
> + update_directory ();
> + return return_directory_response (connection);
> + }
> }
> if ( (0 == strcmp (method, MHD_HTTP_METHOD_GET)) ||
> (0 == strcmp (method, MHD_HTTP_METHOD_HEAD)) )
> @@ -818,8 +818,8 @@ generate_page (void *cls,
>
> /* unexpected request, refuse */
> return MHD_queue_response (connection,
> - MHD_HTTP_FORBIDDEN,
> - request_refused_response);
> + MHD_HTTP_FORBIDDEN,
> + request_refused_response);
> }
>
>
> @@ -832,7 +832,7 @@ generate_page (void *cls,
> static void
> catcher (int sig)
> {
> - (void)sig; /* Unused. Silent compiler warning. */
> + (void)sig; /* Unused. Silent compiler warning. */
> /* do nothing */
> }
>
> @@ -880,7 +880,7 @@ main (int argc, char *const *argv)
> (UINT16_MAX < port) )
> {
> fprintf (stderr,
> - "%s PORT\n", argv[0]);
> + "%s PORT\n", argv[0]);
> return 1;
> }
> #ifndef MINGW
> @@ -893,30 +893,30 @@ main (int argc, char *const *argv)
>
> (void) pthread_mutex_init (&mutex, NULL);
> file_not_found_response = MHD_create_response_from_buffer (strlen
> (FILE_NOT_FOUND_PAGE),
> - (void *)
> FILE_NOT_FOUND_PAGE,
> -
> MHD_RESPMEM_PERSISTENT);
> + (void *) FILE_NOT_FOUND_PAGE,
> + MHD_RESPMEM_PERSISTENT);
> mark_as_html (file_not_found_response);
> request_refused_response = MHD_create_response_from_buffer (strlen
> (REQUEST_REFUSED_PAGE),
> - (void *)
> REQUEST_REFUSED_PAGE,
> -
> MHD_RESPMEM_PERSISTENT);
> + (void *) REQUEST_REFUSED_PAGE,
> + MHD_RESPMEM_PERSISTENT);
> mark_as_html (request_refused_response);
> internal_error_response = MHD_create_response_from_buffer (strlen
> (INTERNAL_ERROR_PAGE),
> - (void *)
> INTERNAL_ERROR_PAGE,
> -
> MHD_RESPMEM_PERSISTENT);
> + (void *) INTERNAL_ERROR_PAGE,
> + MHD_RESPMEM_PERSISTENT);
> mark_as_html (internal_error_response);
> update_directory ();
> d = MHD_start_daemon (MHD_USE_AUTO | MHD_USE_INTERNAL_POLLING_THREAD |
> MHD_USE_ERROR_LOG,
> port,
> NULL, NULL,
> - &generate_page, NULL,
> - MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (256 *
> 1024),
> + &generate_page, NULL,
> + MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (256 * 1024),
> #if PRODUCTION
> - MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned int) (64),
> + MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned int) (64),
> #endif
> - MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) (120 /*
> seconds */),
> - MHD_OPTION_THREAD_POOL_SIZE, (unsigned int)
> NUMBER_OF_THREADS,
> - MHD_OPTION_NOTIFY_COMPLETED,
> &response_completed_callback, NULL,
> - MHD_OPTION_END);
> + MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) (120 /* seconds */),
> + MHD_OPTION_THREAD_POOL_SIZE, (unsigned int) NUMBER_OF_THREADS,
> + MHD_OPTION_NOTIFY_COMPLETED, &response_completed_callback, NULL,
> + MHD_OPTION_END);
> if (NULL == d)
> return 1;
> fprintf (stderr, "HTTP server running. Press ENTER to stop the server\n");
> diff --git a/src/examples/demo_https.c b/src/examples/demo_https.c
> index 806464a2..46cd2d0e 100644
> --- a/src/examples/demo_https.c
> +++ b/src/examples/demo_https.c
> @@ -205,8 +205,8 @@ static void
> mark_as_html (struct MHD_Response *response)
> {
> (void) MHD_add_response_header (response,
> - MHD_HTTP_HEADER_CONTENT_TYPE,
> - "text/html");
> + MHD_HTTP_HEADER_CONTENT_TYPE,
> + "text/html");
> }
>
>
> @@ -259,7 +259,7 @@ struct ResponseDataContext
> */
> static int
> list_directory (struct ResponseDataContext *rdc,
> - const char *dirname)
> + const char *dirname)
> {
> char fullname[PATH_MAX];
> struct stat sbuf;
> @@ -271,32 +271,32 @@ list_directory (struct ResponseDataContext *rdc,
> while (NULL != (de = readdir (dir)))
> {
> if ('.' == de->d_name[0])
> - continue;
> + continue;
> if (sizeof (fullname) <= (size_t)
> - snprintf (fullname, sizeof (fullname),
> - "%s/%s",
> - dirname, de->d_name))
> - continue; /* ugh, file too long? how can this be!? */
> + snprintf (fullname, sizeof (fullname),
> + "%s/%s",
> + dirname, de->d_name))
> + continue; /* ugh, file too long? how can this be!? */
> if (0 != stat (fullname, &sbuf))
> - continue; /* ugh, failed to 'stat' */
> + continue; /* ugh, failed to 'stat' */
> if (! S_ISREG (sbuf.st_mode))
> - continue; /* not a regular file, skip */
> + continue; /* not a regular file, skip */
> if (rdc->off + 1024 > rdc->buf_len)
> - {
> - void *r;
> -
> - if ( (2 * rdc->buf_len + 1024) < rdc->buf_len)
> - break; /* more than SIZE_T _index_ size? Too big for us */
> - rdc->buf_len = 2 * rdc->buf_len + 1024;
> - if (NULL == (r = realloc (rdc->buf, rdc->buf_len)))
> - break; /* out of memory */
> - rdc->buf = r;
> - }
> + {
> + void *r;
> +
> + if ( (2 * rdc->buf_len + 1024) < rdc->buf_len)
> + break; /* more than SIZE_T _index_ size? Too big for us */
> + rdc->buf_len = 2 * rdc->buf_len + 1024;
> + if (NULL == (r = realloc (rdc->buf, rdc->buf_len)))
> + break; /* out of memory */
> + rdc->buf = r;
> + }
> rdc->off += snprintf (&rdc->buf[rdc->off],
> - rdc->buf_len - rdc->off,
> - "<li><a href=\"/%s\">%s</a></li>\n",
> - fullname,
> - de->d_name);
> + rdc->buf_len - rdc->off,
> + "<li><a href=\"/%s\">%s</a></li>\n",
> + fullname,
> + de->d_name);
> }
> (void) closedir (dir);
> return MHD_YES;
> @@ -326,60 +326,60 @@ update_directory ()
> return;
> }
> rdc.off = snprintf (rdc.buf, rdc.buf_len,
> - "%s",
> - INDEX_PAGE_HEADER);
> + "%s",
> + INDEX_PAGE_HEADER);
> for (language_idx = 0; NULL != languages[language_idx].dirname;
> language_idx++)
> {
> language = &languages[language_idx];
>
> if (0 != stat (language->dirname, &sbuf))
> - continue; /* empty */
> + continue; /* empty */
> /* we ensured always +1k room, filenames are ~256 bytes,
> - so there is always still enough space for the header
> - without need for an additional reallocation check. */
> + so there is always still enough space for the header
> + without need for an additional reallocation check. */
> rdc.off += snprintf (&rdc.buf[rdc.off], rdc.buf_len - rdc.off,
> - "<h2>%s</h2>\n",
> - language->longname);
> + "<h2>%s</h2>\n",
> + language->longname);
> for (category_idx = 0; NULL != categories[category_idx];
> category_idx++)
> - {
> - category = categories[category_idx];
> - snprintf (dir_name, sizeof (dir_name),
> - "%s/%s",
> - language->dirname,
> - category);
> - if (0 != stat (dir_name, &sbuf))
> - continue; /* empty */
> -
> - /* we ensured always +1k room, filenames are ~256 bytes,
> - so there is always still enough space for the header
> - without need for an additional reallocation check. */
> - rdc.off += snprintf (&rdc.buf[rdc.off], rdc.buf_len - rdc.off,
> - "<h3>%s</h3>\n",
> - category);
> -
> - if (MHD_NO == list_directory (&rdc, dir_name))
> - {
> - free (rdc.buf);
> - update_cached_response (NULL);
> - return;
> - }
> - }
> + {
> + category = categories[category_idx];
> + snprintf (dir_name, sizeof (dir_name),
> + "%s/%s",
> + language->dirname,
> + category);
> + if (0 != stat (dir_name, &sbuf))
> + continue; /* empty */
> +
> + /* we ensured always +1k room, filenames are ~256 bytes,
> + so there is always still enough space for the header
> + without need for an additional reallocation check. */
> + rdc.off += snprintf (&rdc.buf[rdc.off], rdc.buf_len - rdc.off,
> + "<h3>%s</h3>\n",
> + category);
> +
> + if (MHD_NO == list_directory (&rdc, dir_name))
> + {
> + free (rdc.buf);
> + update_cached_response (NULL);
> + return;
> + }
> + }
> }
> /* we ensured always +1k room, filenames are ~256 bytes,
> so there is always still enough space for the footer
> without need for a final reallocation check. */
> rdc.off += snprintf (&rdc.buf[rdc.off], rdc.buf_len - rdc.off,
> - "%s",
> - INDEX_PAGE_FOOTER);
> + "%s",
> + INDEX_PAGE_FOOTER);
> initial_allocation = rdc.buf_len; /* remember for next time */
> response = MHD_create_response_from_buffer (rdc.off,
> - rdc.buf,
> - MHD_RESPMEM_MUST_FREE);
> + rdc.buf,
> + MHD_RESPMEM_MUST_FREE);
> mark_as_html (response);
> #if FORCE_CLOSE
> (void) MHD_add_response_header (response,
> - MHD_HTTP_HEADER_CONNECTION,
> - "close");
> + MHD_HTTP_HEADER_CONNECTION,
> + "close");
> #endif
> update_cached_response (response);
> }
> @@ -438,8 +438,8 @@ struct UploadContext
> */
> static int
> do_append (char **ret,
> - const char *data,
> - size_t size)
> + const char *data,
> + size_t size)
> {
> char *buf;
> size_t old_len;
> @@ -482,14 +482,14 @@ do_append (char **ret,
> */
> static int
> process_upload_data (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)
> + 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 UploadContext *uc = cls;
> int i;
> @@ -505,8 +505,8 @@ process_upload_data (void *cls,
> if (0 != strcmp (key, "upload"))
> {
> fprintf (stderr,
> - "Ignoring unexpected form value `%s'\n",
> - key);
> + "Ignoring unexpected form value `%s'\n",
> + key);
> return MHD_YES; /* ignore */
> }
> if (NULL == filename)
> @@ -518,8 +518,8 @@ process_upload_data (void *cls,
> (NULL == uc->language) )
> {
> fprintf (stderr,
> - "Missing form data for upload `%s'\n",
> - filename);
> + "Missing form data for upload `%s'\n",
> + filename);
> uc->response = request_refused_response;
> return MHD_NO;
> }
> @@ -528,12 +528,12 @@ process_upload_data (void *cls,
> char fn[PATH_MAX];
>
> if ( (NULL != strstr (filename, "..")) ||
> - (NULL != strchr (filename, '/')) ||
> - (NULL != strchr (filename, '\\')) )
> - {
> - uc->response = request_refused_response;
> - return MHD_NO;
> - }
> + (NULL != strchr (filename, '/')) ||
> + (NULL != strchr (filename, '\\')) )
> + {
> + uc->response = request_refused_response;
> + return MHD_NO;
> + }
> /* create directories -- if they don't exist already */
> #ifdef WINDOWS
> (void) mkdir (uc->language);
> @@ -541,9 +541,9 @@ process_upload_data (void *cls,
> (void) mkdir (uc->language, S_IRWXU);
> #endif
> snprintf (fn, sizeof (fn),
> - "%s/%s",
> - uc->language,
> - uc->category);
> + "%s/%s",
> + uc->language,
> + uc->category);
> #ifdef WINDOWS
> (void) mkdir (fn);
> #else
> @@ -551,29 +551,29 @@ process_upload_data (void *cls,
> #endif
> /* open file */
> snprintf (fn, sizeof (fn),
> - "%s/%s/%s",
> - uc->language,
> - uc->category,
> - filename);
> + "%s/%s/%s",
> + uc->language,
> + uc->category,
> + filename);
> for (i=strlen (fn)-1;i>=0;i--)
> - if (! isprint ((int) fn[i]))
> - fn[i] = '_';
> + if (! isprint ((int) fn[i]))
> + fn[i] = '_';
> uc->fd = open (fn,
> - O_CREAT | O_EXCL
> + O_CREAT | O_EXCL
> #if O_LARGEFILE
> - | O_LARGEFILE
> + | O_LARGEFILE
> #endif
> - | O_WRONLY,
> - S_IRUSR | S_IWUSR);
> + | O_WRONLY,
> + S_IRUSR | S_IWUSR);
> if (-1 == uc->fd)
> - {
> - fprintf (stderr,
> - "Error opening file `%s' for upload: %s\n",
> - fn,
> - strerror (errno));
> - uc->response = request_refused_response;
> - return MHD_NO;
> - }
> + {
> + fprintf (stderr,
> + "Error opening file `%s' for upload: %s\n",
> + fn,
> + strerror (errno));
> + uc->response = request_refused_response;
> + return MHD_NO;
> + }
> uc->filename = strdup (fn);
> }
> if ( (0 != size) &&
> @@ -581,18 +581,18 @@ process_upload_data (void *cls,
> {
> /* write failed; likely: disk full */
> fprintf (stderr,
> - "Error writing to file `%s': %s\n",
> - uc->filename,
> - strerror (errno));
> + "Error writing to file `%s': %s\n",
> + uc->filename,
> + strerror (errno));
> uc->response = internal_error_response;
> close (uc->fd);
> uc->fd = -1;
> if (NULL != uc->filename)
> - {
> - unlink (uc->filename);
> - free (uc->filename);
> - uc->filename = NULL;
> - }
> + {
> + unlink (uc->filename);
> + free (uc->filename);
> + uc->filename = NULL;
> + }
> return MHD_NO;
> }
> return MHD_YES;
> @@ -612,9 +612,9 @@ process_upload_data (void *cls,
> */
> static void
> response_completed_callback (void *cls,
> - struct MHD_Connection *connection,
> - void **con_cls,
> - enum MHD_RequestTerminationCode toe)
> + struct MHD_Connection *connection,
> + void **con_cls,
> + enum MHD_RequestTerminationCode toe)
> {
> struct UploadContext *uc = *con_cls;
> (void)cls; /* Unused. Silent compiler warning. */
> @@ -633,10 +633,10 @@ response_completed_callback (void *cls,
> (void) close (uc->fd);
> if (NULL != uc->filename)
> {
> - fprintf (stderr,
> - "Upload of file `%s' failed (incomplete or aborted), removing
> file.\n",
> - uc->filename);
> - (void) unlink (uc->filename);
> + fprintf (stderr,
> + "Upload of file `%s' failed (incomplete or aborted), removing file.\n",
> + uc->filename);
> + (void) unlink (uc->filename);
> }
> }
> if (NULL != uc->filename)
> @@ -659,12 +659,12 @@ return_directory_response (struct MHD_Connection
> *connection)
> (void) pthread_mutex_lock (&mutex);
> if (NULL == cached_directory_response)
> ret = MHD_queue_response (connection,
> - MHD_HTTP_INTERNAL_SERVER_ERROR,
> - internal_error_response);
> + MHD_HTTP_INTERNAL_SERVER_ERROR,
> + internal_error_response);
> else
> ret = MHD_queue_response (connection,
> - MHD_HTTP_OK,
> - cached_directory_response);
> + MHD_HTTP_OK,
> + cached_directory_response);
> (void) pthread_mutex_unlock (&mutex);
> return ret;
> }
> @@ -685,12 +685,12 @@ return_directory_response (struct MHD_Connection
> *connection)
> */
> static int
> generate_page (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_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;
> int ret;
> @@ -709,10 +709,10 @@ generate_page (void *cls,
> const char *mime;
>
> if (0 != strcmp (method, MHD_HTTP_METHOD_GET))
> - return MHD_NO; /* unexpected method (we're not polite...) */
> + return MHD_NO; /* unexpected method (we're not polite...) */
> fd = -1;
> if ( (NULL == strstr (&url[1], "..")) &&
> - ('/' != url[1]) )
> + ('/' != url[1]) )
> {
> fd = open (&url[1], O_RDONLY);
> if ( (-1 != fd) &&
> @@ -724,35 +724,35 @@ generate_page (void *cls,
> }
> }
> if (-1 == fd)
> - return MHD_queue_response (connection,
> - MHD_HTTP_NOT_FOUND,
> - file_not_found_response);
> + return MHD_queue_response (connection,
> + MHD_HTTP_NOT_FOUND,
> + file_not_found_response);
> #ifdef MHD_HAVE_LIBMAGIC
> /* read beginning of the file to determine mime type */
> got = read (fd, file_data, sizeof (file_data));
> (void) lseek (fd, 0, SEEK_SET);
> if (-1 != got)
> - mime = magic_buffer (magic, file_data, got);
> + mime = magic_buffer (magic, file_data, got);
> else
> #endif /* MHD_HAVE_LIBMAGIC */
> - mime = NULL;
> + mime = NULL;
>
> if (NULL == (response = MHD_create_response_from_fd (buf.st_size,
> - fd)))
> - {
> - /* internal error (i.e. out of memory) */
> - (void) close (fd);
> - return MHD_NO;
> - }
> + fd)))
> + {
> + /* internal error (i.e. out of memory) */
> + (void) close (fd);
> + return MHD_NO;
> + }
>
> /* add mime type if we had one */
> if (NULL != mime)
> - (void) MHD_add_response_header (response,
> - MHD_HTTP_HEADER_CONTENT_TYPE,
> - mime);
> + (void) MHD_add_response_header (response,
> + MHD_HTTP_HEADER_CONTENT_TYPE,
> + mime);
> ret = MHD_queue_response (connection,
> - MHD_HTTP_OK,
> - response);
> + MHD_HTTP_OK,
> + response);
> MHD_destroy_response (response);
> return ret;
> }
> @@ -763,52 +763,52 @@ generate_page (void *cls,
> struct UploadContext *uc = *ptr;
>
> if (NULL == uc)
> - {
> - if (NULL == (uc = malloc (sizeof (struct UploadContext))))
> - return MHD_NO; /* out of memory, close connection */
> - memset (uc, 0, sizeof (struct UploadContext));
> + {
> + if (NULL == (uc = malloc (sizeof (struct UploadContext))))
> + return MHD_NO; /* out of memory, close connection */
> + memset (uc, 0, sizeof (struct UploadContext));
> uc->fd = -1;
> - uc->connection = connection;
> - uc->pp = MHD_create_post_processor (connection,
> - 64 * 1024 /* buffer size */,
> - &process_upload_data, uc);
> - if (NULL == uc->pp)
> - {
> - /* out of memory, close connection */
> - free (uc);
> - return MHD_NO;
> - }
> - *ptr = uc;
> - return MHD_YES;
> - }
> + uc->connection = connection;
> + uc->pp = MHD_create_post_processor (connection,
> + 64 * 1024 /* buffer size */,
> + &process_upload_data, uc);
> + if (NULL == uc->pp)
> + {
> + /* out of memory, close connection */
> + free (uc);
> + return MHD_NO;
> + }
> + *ptr = uc;
> + return MHD_YES;
> + }
> if (0 != *upload_data_size)
> - {
> - if (NULL == uc->response)
> - (void) MHD_post_process (uc->pp,
> - upload_data,
> - *upload_data_size);
> - *upload_data_size = 0;
> - return MHD_YES;
> - }
> + {
> + if (NULL == uc->response)
> + (void) MHD_post_process (uc->pp,
> + upload_data,
> + *upload_data_size);
> + *upload_data_size = 0;
> + return MHD_YES;
> + }
> /* end of upload, finish it! */
> MHD_destroy_post_processor (uc->pp);
> uc->pp = NULL;
> if (-1 != uc->fd)
> - {
> - close (uc->fd);
> - uc->fd = -1;
> - }
> + {
> + close (uc->fd);
> + uc->fd = -1;
> + }
> if (NULL != uc->response)
> - {
> - return MHD_queue_response (connection,
> - MHD_HTTP_FORBIDDEN,
> - uc->response);
> - }
> + {
> + return MHD_queue_response (connection,
> + MHD_HTTP_FORBIDDEN,
> + uc->response);
> + }
> else
> - {
> - update_directory ();
> - return return_directory_response (connection);
> - }
> + {
> + update_directory ();
> + return return_directory_response (connection);
> + }
> }
> if (0 == strcmp (method, MHD_HTTP_METHOD_GET))
> {
> @@ -817,8 +817,8 @@ generate_page (void *cls,
>
> /* unexpected request, refuse */
> return MHD_queue_response (connection,
> - MHD_HTTP_FORBIDDEN,
> - request_refused_response);
> + MHD_HTTP_FORBIDDEN,
> + request_refused_response);
> }
>
>
> @@ -831,7 +831,7 @@ generate_page (void *cls,
> static void
> catcher (int sig)
> {
> - (void)sig; /* Unused. Silent compiler warning. */
> + (void)sig; /* Unused. Silent compiler warning. */
> /* do nothing */
> }
>
> @@ -929,7 +929,7 @@ main (int argc, char *const *argv)
> (UINT16_MAX < port) )
> {
> fprintf (stderr,
> - "%s PORT\n", argv[0]);
> + "%s PORT\n", argv[0]);
> return 1;
> }
> #ifndef MINGW
> @@ -942,32 +942,32 @@ main (int argc, char *const *argv)
>
> (void) pthread_mutex_init (&mutex, NULL);
> file_not_found_response = MHD_create_response_from_buffer (strlen
> (FILE_NOT_FOUND_PAGE),
> - (void *)
> FILE_NOT_FOUND_PAGE,
> -
> MHD_RESPMEM_PERSISTENT);
> + (void *) FILE_NOT_FOUND_PAGE,
> + MHD_RESPMEM_PERSISTENT);
> mark_as_html (file_not_found_response);
> request_refused_response = MHD_create_response_from_buffer (strlen
> (REQUEST_REFUSED_PAGE),
> - (void *)
> REQUEST_REFUSED_PAGE,
> -
> MHD_RESPMEM_PERSISTENT);
> + (void *) REQUEST_REFUSED_PAGE,
> + MHD_RESPMEM_PERSISTENT);
> mark_as_html (request_refused_response);
> internal_error_response = MHD_create_response_from_buffer (strlen
> (INTERNAL_ERROR_PAGE),
> - (void *)
> INTERNAL_ERROR_PAGE,
> -
> MHD_RESPMEM_PERSISTENT);
> + (void *) INTERNAL_ERROR_PAGE,
> + MHD_RESPMEM_PERSISTENT);
> mark_as_html (internal_error_response);
> update_directory ();
> d = MHD_start_daemon (MHD_USE_AUTO | MHD_USE_INTERNAL_POLLING_THREAD |
> MHD_USE_ERROR_LOG | MHD_USE_TLS,
> port,
> NULL, NULL,
> - &generate_page, NULL,
> - MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (256 *
> 1024),
> + &generate_page, NULL,
> + MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (256 * 1024),
> #if PRODUCTION
> - MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned int) (64),
> + MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned int) (64),
> #endif
> - MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) (120 /*
> seconds */),
> - MHD_OPTION_THREAD_POOL_SIZE, (unsigned int)
> NUMBER_OF_THREADS,
> - MHD_OPTION_NOTIFY_COMPLETED,
> &response_completed_callback, NULL,
> + MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) (120 /* seconds */),
> + MHD_OPTION_THREAD_POOL_SIZE, (unsigned int) NUMBER_OF_THREADS,
> + MHD_OPTION_NOTIFY_COMPLETED, &response_completed_callback, NULL,
> MHD_OPTION_HTTPS_MEM_KEY, srv_signed_key_pem,
> MHD_OPTION_HTTPS_MEM_CERT, srv_signed_cert_pem,
> - MHD_OPTION_END);
> + MHD_OPTION_END);
> if (NULL == d)
> return 1;
> fprintf (stderr, "HTTP server running. Press ENTER to stop the server\n");
> diff --git a/src/examples/digest_auth_example.c
> b/src/examples/digest_auth_example.c
> index 889967fb..42dc66ae 100644
> --- a/src/examples/digest_auth_example.c
> +++ b/src/examples/digest_auth_example.c
> @@ -57,37 +57,37 @@ ahc_echo (void *cls,
> if (NULL == username)
> {
> response = MHD_create_response_from_buffer(strlen (DENIED),
> - DENIED,
> - MHD_RESPMEM_PERSISTENT);
> + DENIED,
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_auth_fail_response(connection, realm,
> - MY_OPAQUE_STR,
> - response,
> - MHD_NO);
> + MY_OPAQUE_STR,
> + response,
> + MHD_NO);
> MHD_destroy_response(response);
> return ret;
> }
> ret = MHD_digest_auth_check(connection, realm,
> - username,
> - password,
> - 300);
> + username,
> + password,
> + 300);
> MHD_free (username);
> if ( (ret == MHD_INVALID_NONCE) ||
> (ret == MHD_NO) )
> {
> response = MHD_create_response_from_buffer(strlen (DENIED),
> - DENIED,
> - MHD_RESPMEM_PERSISTENT);
> + DENIED,
> + MHD_RESPMEM_PERSISTENT);
> if (NULL == response)
> - return MHD_NO;
> + return MHD_NO;
> ret = MHD_queue_auth_fail_response(connection, realm,
> - MY_OPAQUE_STR,
> - response,
> - (ret == MHD_INVALID_NONCE) ? MHD_YES :
> MHD_NO);
> + MY_OPAQUE_STR,
> + response,
> + (ret == MHD_INVALID_NONCE) ? MHD_YES : MHD_NO);
> MHD_destroy_response(response);
> return ret;
> }
> response = MHD_create_response_from_buffer(strlen(PAGE), PAGE,
> - MHD_RESPMEM_PERSISTENT);
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_response(connection, MHD_HTTP_OK, response);
> MHD_destroy_response(response);
> return ret;
> @@ -112,8 +112,8 @@ main (int argc, char *const *argv)
> if (-1 == fd)
> {
> fprintf (stderr, "Failed to open `%s': %s\n",
> - "/dev/urandom",
> - strerror (errno));
> + "/dev/urandom",
> + strerror (errno));
> return 1;
> }
> off = 0;
> @@ -121,23 +121,23 @@ main (int argc, char *const *argv)
> {
> len = read(fd, rnd, 8);
> if (len == -1)
> - {
> - fprintf (stderr, "Failed to read `%s': %s\n",
> - "/dev/urandom",
> - strerror (errno));
> - (void) close (fd);
> - return 1;
> - }
> + {
> + fprintf (stderr, "Failed to read `%s': %s\n",
> + "/dev/urandom",
> + strerror (errno));
> + (void) close (fd);
> + return 1;
> + }
> off += len;
> }
> (void) close(fd);
> d = MHD_start_daemon (MHD_USE_THREAD_PER_CONNECTION |
> MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG,
> atoi (argv[1]),
> NULL, NULL, &ahc_echo, PAGE,
> - MHD_OPTION_DIGEST_AUTH_RANDOM, sizeof(rnd), rnd,
> - MHD_OPTION_NONCE_NC_SIZE, 300,
> - MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 120,
> - MHD_OPTION_END);
> + MHD_OPTION_DIGEST_AUTH_RANDOM, sizeof(rnd), rnd,
> + MHD_OPTION_NONCE_NC_SIZE, 300,
> + MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 120,
> + MHD_OPTION_END);
> if (d == NULL)
> return 1;
> (void) getc (stdin);
> diff --git a/src/examples/dual_stack_example.c
> b/src/examples/dual_stack_example.c
> index 31b25438..ba326dde 100644
> --- a/src/examples/dual_stack_example.c
> +++ b/src/examples/dual_stack_example.c
> @@ -54,8 +54,8 @@ ahc_echo (void *cls,
> }
> *ptr = NULL; /* reset when done */
> response = MHD_create_response_from_buffer (strlen (me),
> - (void *) me,
> - MHD_RESPMEM_PERSISTENT);
> + (void *) me,
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> return ret;
> @@ -73,10 +73,10 @@ main (int argc, char *const *argv)
> return 1;
> }
> d = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG
> | MHD_USE_DUAL_STACK,
> - atoi (argv[1]),
> - NULL, NULL, &ahc_echo, PAGE,
> - MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 120,
> - MHD_OPTION_END);
> + atoi (argv[1]),
> + NULL, NULL, &ahc_echo, PAGE,
> + MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 120,
> + MHD_OPTION_END);
> (void) getc (stdin);
> MHD_stop_daemon (d);
> return 0;
> diff --git a/src/examples/fileserver_example.c
> b/src/examples/fileserver_example.c
> index b8935fa1..f8bf5126 100644
> --- a/src/examples/fileserver_example.c
> +++ b/src/examples/fileserver_example.c
> @@ -47,7 +47,7 @@ ahc_echo (void *cls,
> const char *method,
> const char *version,
> const char *upload_data,
> - size_t *upload_data_size, void **ptr)
> + size_t *upload_data_size, void **ptr)
> {
> static int aptr;
> struct MHD_Response *response;
> @@ -91,8 +91,8 @@ ahc_echo (void *cls,
> if (-1 == fd)
> {
> response = MHD_create_response_from_buffer (strlen (PAGE),
> - (void *) PAGE,
> - MHD_RESPMEM_PERSISTENT);
> + (void *) PAGE,
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_response (connection, MHD_HTTP_NOT_FOUND, response);
> MHD_destroy_response (response);
> }
> @@ -100,11 +100,11 @@ ahc_echo (void *cls,
> {
> response = MHD_create_response_from_fd64 (buf.st_size, fd);
> if (NULL == response)
> - {
> - if (0 != close (fd))
> + {
> + if (0 != close (fd))
> abort ();
> - return MHD_NO;
> - }
> + return MHD_NO;
> + }
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> }
> diff --git a/src/examples/fileserver_example_dirs.c
> b/src/examples/fileserver_example_dirs.c
> index 8c37f219..37829380 100644
> --- a/src/examples/fileserver_example_dirs.c
> +++ b/src/examples/fileserver_example_dirs.c
> @@ -74,9 +74,9 @@ dir_reader (void *cls, uint64_t pos, char *buf, size_t max)
> return MHD_CONTENT_READER_END_OF_STREAM;
> } while (e->d_name[0] == '.');
> return snprintf (buf, max,
> - "<a href=\"/%s\">%s</a><br>",
> - e->d_name,
> - e->d_name);
> + "<a href=\"/%s\">%s</a><br>",
> + e->d_name,
> + e->d_name);
> }
>
>
> @@ -87,7 +87,7 @@ ahc_echo (void *cls,
> const char *method,
> const char *version,
> const char *upload_data,
> - size_t *upload_data_size, void **ptr)
> + size_t *upload_data_size, void **ptr)
> {
> static int aptr;
> struct MHD_Response *response;
> @@ -134,38 +134,38 @@ ahc_echo (void *cls,
> {
> dir = opendir (".");
> if (NULL == dir)
> - {
> - /* most likely cause: more concurrent requests than
> - available file descriptors / 2 */
> - snprintf (emsg,
> - sizeof (emsg),
> - "Failed to open directory `.': %s\n",
> - strerror (errno));
> - response = MHD_create_response_from_buffer (strlen (emsg),
> - emsg,
> - MHD_RESPMEM_MUST_COPY);
> - if (NULL == response)
> - return MHD_NO;
> - ret = MHD_queue_response (connection,
> + {
> + /* most likely cause: more concurrent requests than
> + available file descriptors / 2 */
> + snprintf (emsg,
> + sizeof (emsg),
> + "Failed to open directory `.': %s\n",
> + strerror (errno));
> + response = MHD_create_response_from_buffer (strlen (emsg),
> + emsg,
> + MHD_RESPMEM_MUST_COPY);
> + if (NULL == response)
> + return MHD_NO;
> + ret = MHD_queue_response (connection,
> MHD_HTTP_SERVICE_UNAVAILABLE,
> response);
> - MHD_destroy_response (response);
> - }
> + MHD_destroy_response (response);
> + }
> else
> - {
> - response = MHD_create_response_from_callback (MHD_SIZE_UNKNOWN,
> - 32 * 1024,
> - &dir_reader,
> - dir,
> - &dir_free_callback);
> - if (NULL == response)
> - {
> - closedir (dir);
> - return MHD_NO;
> - }
> - ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> - MHD_destroy_response (response);
> - }
> + {
> + response = MHD_create_response_from_callback (MHD_SIZE_UNKNOWN,
> + 32 * 1024,
> + &dir_reader,
> + dir,
> + &dir_free_callback);
> + if (NULL == response)
> + {
> + closedir (dir);
> + return MHD_NO;
> + }
> + ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> + MHD_destroy_response (response);
> + }
> }
> else
> {
> @@ -174,10 +174,10 @@ ahc_echo (void *cls,
> file,
> &file_free_callback);
> if (NULL == response)
> - {
> - fclose (file);
> - return MHD_NO;
> - }
> + {
> + fclose (file);
> + return MHD_NO;
> + }
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> }
> diff --git a/src/examples/fileserver_example_external_select.c
> b/src/examples/fileserver_example_external_select.c
> index 6aea6dbf..4fad9050 100644
> --- a/src/examples/fileserver_example_external_select.c
> +++ b/src/examples/fileserver_example_external_select.c
> @@ -54,7 +54,7 @@ ahc_echo (void *cls,
> const char *method,
> const char *version,
> const char *upload_data,
> - size_t *upload_data_size, void **ptr)
> + size_t *upload_data_size, void **ptr)
> {
> static int aptr;
> struct MHD_Response *response;
> @@ -98,8 +98,8 @@ ahc_echo (void *cls,
> if (NULL == file)
> {
> response = MHD_create_response_from_buffer (strlen (PAGE),
> - (void *) PAGE,
> - MHD_RESPMEM_PERSISTENT);
> + (void *) PAGE,
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_response (connection, MHD_HTTP_NOT_FOUND, response);
> MHD_destroy_response (response);
> }
> @@ -110,10 +110,10 @@ ahc_echo (void *cls,
> file,
> &free_callback);
> if (NULL == response)
> - {
> - fclose (file);
> - return MHD_NO;
> - }
> + {
> + fclose (file);
> + return MHD_NO;
> + }
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> }
> @@ -154,7 +154,7 @@ main (int argc, char *const *argv)
> FD_ZERO (&ws);
> FD_ZERO (&es);
> if (MHD_YES != MHD_get_fdset (d, &rs, &ws, &es, &max))
> - break; /* fatal internal error */
> + break; /* fatal internal error */
> if (MHD_get_timeout (d, &mhd_timeout) == MHD_YES)
> {
> if (((MHD_UNSIGNED_LONG_LONG)tv.tv_sec) < mhd_timeout / 1000LL)
> diff --git a/src/examples/https_fileserver_example.c
> b/src/examples/https_fileserver_example.c
> index e48a1502..3d4f9990 100644
> --- a/src/examples/https_fileserver_example.c
> +++ b/src/examples/https_fileserver_example.c
> @@ -117,7 +117,7 @@ http_ahc (void *cls,
> const char *method,
> const char *version,
> const char *upload_data,
> - size_t *upload_data_size, void **ptr)
> + size_t *upload_data_size, void **ptr)
> {
> static int aptr;
> struct MHD_Response *response;
> @@ -161,8 +161,8 @@ http_ahc (void *cls,
> if (NULL == file)
> {
> response = MHD_create_response_from_buffer (strlen (EMPTY_PAGE),
> - (void *) EMPTY_PAGE,
> - MHD_RESPMEM_PERSISTENT);
> + (void *) EMPTY_PAGE,
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_response (connection, MHD_HTTP_NOT_FOUND, response);
> MHD_destroy_response (response);
> }
> @@ -172,10 +172,10 @@ http_ahc (void *cls,
> &file_reader, file,
> &file_free_callback);
> if (NULL == response)
> - {
> - fclose (file);
> - return MHD_NO;
> - }
> + {
> + fclose (file);
> + return MHD_NO;
> + }
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> }
> diff --git a/src/examples/minimal_example.c b/src/examples/minimal_example.c
> index 4cf6401a..0beeb5d5 100644
> --- a/src/examples/minimal_example.c
> +++ b/src/examples/minimal_example.c
> @@ -54,8 +54,8 @@ ahc_echo (void *cls,
> }
> *ptr = NULL; /* reset when done */
> response = MHD_create_response_from_buffer (strlen (me),
> - (void *) me,
> - MHD_RESPMEM_PERSISTENT);
> + (void *) me,
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> return ret;
> @@ -74,13 +74,13 @@ main (int argc, char *const *argv)
> d = MHD_start_daemon (/* MHD_USE_INTERNAL_POLLING_THREAD |
> MHD_USE_ERROR_LOG, */
> MHD_USE_AUTO | MHD_USE_INTERNAL_POLLING_THREAD |
> MHD_USE_ERROR_LOG,
> /* MHD_USE_INTERNAL_POLLING_THREAD |
> MHD_USE_ERROR_LOG | MHD_USE_POLL, */
> - /* MHD_USE_THREAD_PER_CONNECTION |
> MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG | MHD_USE_POLL, */
> - /* MHD_USE_THREAD_PER_CONNECTION |
> MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG, */
> + /* MHD_USE_THREAD_PER_CONNECTION | MHD_USE_INTERNAL_POLLING_THREAD |
> MHD_USE_ERROR_LOG | MHD_USE_POLL, */
> + /* MHD_USE_THREAD_PER_CONNECTION | MHD_USE_INTERNAL_POLLING_THREAD |
> MHD_USE_ERROR_LOG, */
> atoi (argv[1]),
> NULL, NULL, &ahc_echo, PAGE,
> - MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 120,
> - MHD_OPTION_STRICT_FOR_CLIENT, (int) 1,
> - MHD_OPTION_END);
> + MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 120,
> + MHD_OPTION_STRICT_FOR_CLIENT, (int) 1,
> + MHD_OPTION_END);
> if (d == NULL)
> return 1;
> (void) getc (stdin);
> diff --git a/src/examples/msgs_i18n.c b/src/examples/msgs_i18n.c
> index 2d8eb566..35c22acf 100755
> --- a/src/examples/msgs_i18n.c
> +++ b/src/examples/msgs_i18n.c
> @@ -45,13 +45,13 @@
>
> static int
> ahc_echo (void *cls,
> - struct MHD_Connection *cnc,
> - const char *url,
> - const char *mt,
> - const char *ver,
> - const char *upd,
> - size_t *upsz,
> - void **ptr)
> + struct MHD_Connection *cnc,
> + const char *url,
> + const char *mt,
> + const char *ver,
> + const char *upd,
> + size_t *upsz,
> + void **ptr)
> {
> return MHD_NO;
> }
> @@ -59,15 +59,15 @@ ahc_echo (void *cls,
>
> static void
> error_handler (void *cls,
> - const char *fm,
> - va_list ap)
> + const char *fm,
> + va_list ap)
> {
> /* Here we do the translation using GNU gettext.
> As the error message is from libmicrohttpd, we specify
> "libmicrohttpd" as the translation domain here. */
> vprintf (dgettext ("libmicrohttpd",
> - fm),
> - ap);
> + fm),
> + ap);
> }
>
>
> @@ -82,14 +82,14 @@ main (int argc,
> needs to be adapted to match
> where the MHD PO files are installed. */
> bindtextdomain ("libmicrohttpd",
> - "locale");
> + "locale");
> MHD_start_daemon (MHD_USE_SELECT_INTERNALLY | MHD_FEATURE_MESSAGES |
> MHD_USE_ERROR_LOG,
> - 8080,
> - NULL, NULL,
> - &ahc_echo, NULL,
> - MHD_OPTION_EXTERNAL_LOGGER, &error_handler, NULL,
> - 99999 /* invalid option, to raise the error
> - "Invalid option ..." which we are going
> - to translate */);
> + 8080,
> + NULL, NULL,
> + &ahc_echo, NULL,
> + MHD_OPTION_EXTERNAL_LOGGER, &error_handler, NULL,
> + 99999 /* invalid option, to raise the error
> + "Invalid option ..." which we are going
> + to translate */);
> return 1; /* This program won't "succeed"... */
> }
> diff --git a/src/examples/post_example.c b/src/examples/post_example.c
> index 6c9a3f4b..6f5de41a 100644
> --- a/src/examples/post_example.c
> +++ b/src/examples/post_example.c
> @@ -150,23 +150,23 @@ get_session (struct MHD_Connection *connection)
> const char *cookie;
>
> cookie = MHD_lookup_connection_value (connection,
> - MHD_COOKIE_KIND,
> - COOKIE_NAME);
> + 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 (0 == strcmp (cookie, ret->sid))
> + break;
> + ret = ret->next;
> + }
> if (NULL != ret)
> - {
> - ret->rc++;
> - return ret;
> - }
> + {
> + ret->rc++;
> + return ret;
> + }
> }
> /* create fresh session */
> ret = calloc (1, sizeof (struct Session));
> @@ -178,12 +178,12 @@ get_session (struct MHD_Connection *connection)
> /* 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) rand (),
> - (unsigned int) rand (),
> - (unsigned int) rand (),
> - (unsigned int) rand ());
> + sizeof (ret->sid),
> + "%X%X%X%X",
> + (unsigned int) rand (),
> + (unsigned int) rand (),
> + (unsigned int) rand (),
> + (unsigned int) rand ());
> ret->rc++;
> ret->start = time (NULL);
> ret->next = sessions;
> @@ -202,9 +202,9 @@ get_session (struct MHD_Connection *connection)
> * @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);
> + const char *mime,
> + struct Session *session,
> + struct MHD_Connection *connection);
>
>
> /**
> @@ -242,21 +242,21 @@ struct Page
> */
> static void
> add_session_cookie (struct Session *session,
> - struct MHD_Response *response)
> + struct MHD_Response *response)
> {
> char cstr[256];
> snprintf (cstr,
> - sizeof (cstr),
> - "%s=%s",
> - COOKIE_NAME,
> - session->sid);
> + sizeof (cstr),
> + "%s=%s",
> + COOKIE_NAME,
> + session->sid);
> if (MHD_NO ==
> MHD_add_response_header (response,
> - MHD_HTTP_HEADER_SET_COOKIE,
> - cstr))
> + MHD_HTTP_HEADER_SET_COOKIE,
> + cstr))
> {
> fprintf (stderr,
> - "Failed to set session cookie header!\n");
> + "Failed to set session cookie header!\n");
> }
> }
>
> @@ -272,9 +272,9 @@ add_session_cookie (struct Session *session,
> */
> static int
> serve_simple_form (const void *cls,
> - const char *mime,
> - struct Session *session,
> - struct MHD_Connection *connection)
> + const char *mime,
> + struct Session *session,
> + struct MHD_Connection *connection)
> {
> int ret;
> const char *form = cls;
> @@ -282,17 +282,17 @@ serve_simple_form (const void *cls,
>
> /* return static form */
> response = MHD_create_response_from_buffer (strlen (form),
> - (void *) form,
> - MHD_RESPMEM_PERSISTENT);
> + (void *) form,
> + MHD_RESPMEM_PERSISTENT);
> if (NULL == response)
> return MHD_NO;
> add_session_cookie (session, response);
> MHD_add_response_header (response,
> - MHD_HTTP_HEADER_CONTENT_ENCODING,
> - mime);
> + MHD_HTTP_HEADER_CONTENT_ENCODING,
> + mime);
> ret = MHD_queue_response (connection,
> - MHD_HTTP_OK,
> - response);
> + MHD_HTTP_OK,
> + response);
> MHD_destroy_response (response);
> return ret;
> }
> @@ -308,9 +308,9 @@ serve_simple_form (const void *cls,
> */
> static int
> fill_v1_form (const void *cls,
> - const char *mime,
> - struct Session *session,
> - struct MHD_Connection *connection)
> + const char *mime,
> + struct Session *session,
> + struct MHD_Connection *connection)
> {
> int ret;
> size_t slen;
> @@ -323,13 +323,13 @@ fill_v1_form (const void *cls,
> if (NULL == reply)
> return MHD_NO;
> snprintf (reply,
> - slen + 1,
> - MAIN_PAGE,
> - session->value_1);
> + slen + 1,
> + MAIN_PAGE,
> + session->value_1);
> /* return static form */
> response = MHD_create_response_from_buffer (slen,
> - (void *) reply,
> - MHD_RESPMEM_MUST_FREE);
> + (void *) reply,
> + MHD_RESPMEM_MUST_FREE);
> if (NULL == response)
> {
> free (reply);
> @@ -337,11 +337,11 @@ fill_v1_form (const void *cls,
> }
> add_session_cookie (session, response);
> MHD_add_response_header (response,
> - MHD_HTTP_HEADER_CONTENT_ENCODING,
> - mime);
> + MHD_HTTP_HEADER_CONTENT_ENCODING,
> + mime);
> ret = MHD_queue_response (connection,
> - MHD_HTTP_OK,
> - response);
> + MHD_HTTP_OK,
> + response);
> MHD_destroy_response (response);
> return ret;
> }
> @@ -357,9 +357,9 @@ fill_v1_form (const void *cls,
> */
> static int
> fill_v1_v2_form (const void *cls,
> - const char *mime,
> - struct Session *session,
> - struct MHD_Connection *connection)
> + const char *mime,
> + struct Session *session,
> + struct MHD_Connection *connection)
> {
> int ret;
> char *reply;
> @@ -372,14 +372,14 @@ fill_v1_v2_form (const void *cls,
> if (NULL == reply)
> return MHD_NO;
> snprintf (reply,
> - slen + 1,
> - SECOND_PAGE,
> - session->value_1,
> + slen + 1,
> + SECOND_PAGE,
> + session->value_1,
> session->value_2);
> /* return static form */
> response = MHD_create_response_from_buffer (slen,
> - (void *) reply,
> - MHD_RESPMEM_MUST_FREE);
> + (void *) reply,
> + MHD_RESPMEM_MUST_FREE);
> if (NULL == response)
> {
> free (reply);
> @@ -387,11 +387,11 @@ fill_v1_v2_form (const void *cls,
> }
> add_session_cookie (session, response);
> MHD_add_response_header (response,
> - MHD_HTTP_HEADER_CONTENT_ENCODING,
> - mime);
> + MHD_HTTP_HEADER_CONTENT_ENCODING,
> + mime);
> ret = MHD_queue_response (connection,
> - MHD_HTTP_OK,
> - response);
> + MHD_HTTP_OK,
> + response);
> MHD_destroy_response (response);
> return ret;
> }
> @@ -407,9 +407,9 @@ fill_v1_v2_form (const void *cls,
> */
> static int
> not_found_page (const void *cls,
> - const char *mime,
> - struct Session *session,
> - struct MHD_Connection *connection)
> + const char *mime,
> + struct Session *session,
> + struct MHD_Connection *connection)
> {
> int ret;
> struct MHD_Response *response;
> @@ -418,16 +418,16 @@ not_found_page (const void *cls,
>
> /* unsupported HTTP method */
> response = MHD_create_response_from_buffer (strlen (NOT_FOUND_ERROR),
> - (void *) NOT_FOUND_ERROR,
> - MHD_RESPMEM_PERSISTENT);
> + (void *) NOT_FOUND_ERROR,
> + MHD_RESPMEM_PERSISTENT);
> if (NULL == response)
> return MHD_NO;
> ret = MHD_queue_response (connection,
> - MHD_HTTP_NOT_FOUND,
> - response);
> + MHD_HTTP_NOT_FOUND,
> + response);
> MHD_add_response_header (response,
> - MHD_HTTP_HEADER_CONTENT_ENCODING,
> - mime);
> + MHD_HTTP_HEADER_CONTENT_ENCODING,
> + mime);
> MHD_destroy_response (response);
> return ret;
> }
> @@ -468,12 +468,12 @@ static struct Page pages[] =
> */
> 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)
> + 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;
> @@ -485,29 +485,29 @@ post_iterator (void *cls,
> if (0 == strcmp ("DONE", key))
> {
> fprintf (stdout,
> - "Session `%s' submitted `%s', `%s'\n",
> - session->sid,
> - session->value_1,
> - session->value_2);
> + "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 - 1;
> + size = sizeof (session->value_1) - off - 1;
> memcpy (&session->value_1[off],
> - data,
> - size);
> + data,
> + size);
> 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 - 1;
> + size = sizeof (session->value_2) - off - 1;
> memcpy (&session->value_2[off],
> - data,
> - size);
> + data,
> + size);
> session->value_2[size+off] = '\0';
> return MHD_YES;
> }
> @@ -553,13 +553,13 @@ post_iterator (void *cls,
> */
> 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_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;
> @@ -574,33 +574,33 @@ create_response (void *cls,
> {
> request = calloc (1, sizeof (struct Request));
> if (NULL == request)
> - {
> - fprintf (stderr, "calloc error: %s\n", strerror (errno));
> - return MHD_NO;
> - }
> + {
> + 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 */
> - }
> - }
> + {
> + 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 */
> - }
> + {
> + fprintf (stderr, "Failed to setup session for `%s'\n",
> + url);
> + return MHD_NO; /* internal error */
> + }
> }
> session = request->session;
> session->start = time (NULL);
> @@ -608,19 +608,19 @@ create_response (void *cls,
> {
> /* evaluate POST data */
> MHD_post_process (request->pp,
> - upload_data,
> - *upload_data_size);
> + upload_data,
> + *upload_data_size);
> if (0 != *upload_data_size)
> - {
> - *upload_data_size = 0;
> - return MHD_YES;
> - }
> + {
> + *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;
> + url = request->post_url;
> }
>
> if ( (0 == strcmp (method, MHD_HTTP_METHOD_GET)) ||
> @@ -629,23 +629,23 @@ create_response (void *cls,
> /* find out which page to serve */
> i=0;
> while ( (pages[i].url != NULL) &&
> - (0 != strcmp (pages[i].url, url)) )
> - i++;
> + (0 != strcmp (pages[i].url, url)) )
> + i++;
> ret = pages[i].handler (pages[i].handler_cls,
> - pages[i].mime,
> - session, connection);
> + pages[i].mime,
> + session, connection);
> if (ret != MHD_YES)
> - fprintf (stderr, "Failed to create page for `%s'\n",
> - url);
> + 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);
> + (void *) METHOD_ERROR,
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_response (connection,
> - MHD_HTTP_NOT_ACCEPTABLE,
> - response);
> + MHD_HTTP_NOT_ACCEPTABLE,
> + response);
> MHD_destroy_response (response);
> return ret;
> }
> @@ -662,9 +662,9 @@ create_response (void *cls,
> */
> static void
> request_completed_callback (void *cls,
> - struct MHD_Connection *connection,
> - void **con_cls,
> - enum MHD_RequestTerminationCode toe)
> + struct MHD_Connection *connection,
> + void **con_cls,
> + enum MHD_RequestTerminationCode toe)
> {
> struct Request *request = *con_cls;
> (void)cls; /* Unused. Silent compiler warning. */
> @@ -700,14 +700,14 @@ expire_sessions ()
> {
> 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);
> - }
> + {
> + /* expire sessions after 1h */
> + if (NULL == prev)
> + sessions = pos->next;
> + else
> + prev->next = next;
> + free (pos);
> + }
> else
> prev = pos;
> pos = next;
> @@ -741,10 +741,10 @@ main (int argc, char *const *argv)
> d = MHD_start_daemon (MHD_USE_ERROR_LOG,
> 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);
> + &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)
> @@ -755,15 +755,15 @@ main (int argc, char *const *argv)
> FD_ZERO (&ws);
> FD_ZERO (&es);
> if (MHD_YES != MHD_get_fdset (d, &rs, &ws, &es, &max))
> - break; /* fatal internal error */
> + 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;
> - }
> + {
> + tv.tv_sec = mhd_timeout / 1000;
> + tv.tv_usec = (mhd_timeout - (tv.tv_sec * 1000)) * 1000;
> + tvp = &tv;
> + }
> else
> - tvp = NULL;
> + tvp = NULL;
> if (-1 == select (max + 1, &rs, &ws, &es, tvp))
> {
> if (EINTR != errno)
> diff --git a/src/examples/querystring_example.c
> b/src/examples/querystring_example.c
> index 3d91bcea..43872cb5 100644
> --- a/src/examples/querystring_example.c
> +++ b/src/examples/querystring_example.c
> @@ -62,7 +62,7 @@ ahc_echo (void *cls,
> return MHD_NO;
> sprintf (me, fmt, "q", val);
> response = MHD_create_response_from_buffer (strlen (me), me,
> - MHD_RESPMEM_MUST_FREE);
> + MHD_RESPMEM_MUST_FREE);
> if (response == NULL)
> {
> free (me);
> diff --git a/src/examples/refuse_post_example.c
> b/src/examples/refuse_post_example.c
> index dad3beb1..88432f0c 100644
> --- a/src/examples/refuse_post_example.c
> +++ b/src/examples/refuse_post_example.c
> @@ -62,8 +62,8 @@ ahc_echo (void *cls,
> if (0 == strcmp (method, "POST"))
> {
> response = MHD_create_response_from_buffer (strlen (BUSYPAGE),
> - (void *) BUSYPAGE,
> - MHD_RESPMEM_PERSISTENT);
> + (void *) BUSYPAGE,
> + MHD_RESPMEM_PERSISTENT);
> ret =
> MHD_queue_response (connection, MHD_HTTP_SERVICE_UNAVAILABLE,
> response);
> @@ -74,8 +74,8 @@ ahc_echo (void *cls,
>
> *ptr = NULL; /* reset when done */
> response = MHD_create_response_from_buffer (strlen (me),
> - (void *) me,
> - MHD_RESPMEM_PERSISTENT);
> + (void *) me,
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> return ret;
> diff --git a/src/examples/upgrade_example.c b/src/examples/upgrade_example.c
> index 73cfafb2..3572d663 100644
> --- a/src/examples/upgrade_example.c
> +++ b/src/examples/upgrade_example.c
> @@ -296,8 +296,8 @@ main (int argc,
> atoi (argv[1]),
> NULL, NULL,
> &ahc_echo, NULL,
> - MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 120,
> - MHD_OPTION_END);
> + MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 120,
> + MHD_OPTION_END);
> if (d == NULL)
> return 1;
> (void) getc (stdin);
> diff --git a/src/include/microhttpd.h b/src/include/microhttpd.h
> index 0ce62d42..a1b412d4 100644
> --- a/src/include/microhttpd.h
> +++ b/src/include/microhttpd.h
> @@ -212,8 +212,8 @@ typedef SOCKET MHD_socket;
> #elif defined(__clang__) || defined (__GNUC_PATCHLEVEL__)
> /* clang or GCC since 3.0 */
> #define _MHD_GCC_PRAG(x) _Pragma (#x)
> -#if (defined(__clang__) && (__clang_major__+0 >= 5 ||
> \
> - (!defined(__apple_build_version__) &&
> (__clang_major__+0 > 3 || (__clang_major__+0 == 3 && __clang_minor__ >=
> 3))))) || \
> +#if (defined(__clang__) && (__clang_major__+0 >= 5 || \
> + (!defined(__apple_build_version__) && (__clang_major__+0 > 3 ||
> (__clang_major__+0 == 3 && __clang_minor__ >= 3))))) || \
> __GNUC__+0 > 4 || (__GNUC__+0 == 4 && __GNUC_MINOR__+0 >= 8)
> /* clang >= 3.3 (or XCode's clang >= 5.0) or
> GCC >= 4.8 */
> @@ -2118,10 +2118,10 @@ typedef int
> */
> _MHD_EXTERN struct MHD_Daemon *
> MHD_start_daemon_va (unsigned int flags,
> - uint16_t port,
> - MHD_AcceptPolicyCallback apc, void *apc_cls,
> - MHD_AccessHandlerCallback dh, void *dh_cls,
> - va_list ap);
> + uint16_t port,
> + MHD_AcceptPolicyCallback apc, void *apc_cls,
> + MHD_AccessHandlerCallback dh, void *dh_cls,
> + va_list ap);
>
>
> /**
> @@ -2146,10 +2146,10 @@ MHD_start_daemon_va (unsigned int flags,
> */
> _MHD_EXTERN struct MHD_Daemon *
> MHD_start_daemon (unsigned int flags,
> - uint16_t port,
> - MHD_AcceptPolicyCallback apc, void *apc_cls,
> - MHD_AccessHandlerCallback dh, void *dh_cls,
> - ...);
> + uint16_t port,
> + MHD_AcceptPolicyCallback apc, void *apc_cls,
> + MHD_AccessHandlerCallback dh, void *dh_cls,
> + ...);
>
>
> /**
> @@ -2214,9 +2214,9 @@ MHD_stop_daemon (struct MHD_Daemon *daemon);
> */
> _MHD_EXTERN int
> MHD_add_connection (struct MHD_Daemon *daemon,
> - MHD_socket client_socket,
> - const struct sockaddr *addr,
> - socklen_t addrlen);
> + MHD_socket client_socket,
> + const struct sockaddr *addr,
> + socklen_t addrlen);
>
>
> /**
> @@ -2252,8 +2252,8 @@ _MHD_EXTERN int
> MHD_get_fdset (struct MHD_Daemon *daemon,
> fd_set *read_fd_set,
> fd_set *write_fd_set,
> - fd_set *except_fd_set,
> - MHD_socket *max_fd);
> + fd_set *except_fd_set,
> + MHD_socket *max_fd);
>
>
> /**
> @@ -2290,11 +2290,11 @@ MHD_get_fdset (struct MHD_Daemon *daemon,
> */
> _MHD_EXTERN int
> MHD_get_fdset2 (struct MHD_Daemon *daemon,
> - fd_set *read_fd_set,
> - fd_set *write_fd_set,
> - fd_set *except_fd_set,
> - MHD_socket *max_fd,
> - unsigned int fd_setsize);
> + fd_set *read_fd_set,
> + fd_set *write_fd_set,
> + fd_set *except_fd_set,
> + MHD_socket *max_fd,
> + unsigned int fd_setsize);
>
>
> /**
> @@ -2345,7 +2345,7 @@ MHD_get_fdset2 (struct MHD_Daemon *daemon,
> */
> _MHD_EXTERN int
> MHD_get_timeout (struct MHD_Daemon *daemon,
> - MHD_UNSIGNED_LONG_LONG *timeout);
> + MHD_UNSIGNED_LONG_LONG *timeout);
>
>
> /**
> @@ -2396,9 +2396,9 @@ MHD_run (struct MHD_Daemon *daemon);
> */
> _MHD_EXTERN int
> MHD_run_from_select (struct MHD_Daemon *daemon,
> - const fd_set *read_fd_set,
> - const fd_set *write_fd_set,
> - const fd_set *except_fd_set);
> + const fd_set *read_fd_set,
> + const fd_set *write_fd_set,
> + const fd_set *except_fd_set);
>
>
>
> @@ -2453,7 +2453,7 @@ _MHD_EXTERN int
> MHD_set_connection_value (struct MHD_Connection *connection,
> enum MHD_ValueKind kind,
> const char *key,
> - const char *value);
> + const char *value);
>
>
> /**
> @@ -2501,8 +2501,8 @@ MHD_http_unescape (char *val);
> */
> _MHD_EXTERN const char *
> MHD_lookup_connection_value (struct MHD_Connection *connection,
> - enum MHD_ValueKind kind,
> - const char *key);
> + enum MHD_ValueKind kind,
> + const char *key);
>
>
> /**
> @@ -2519,7 +2519,7 @@ MHD_lookup_connection_value (struct MHD_Connection
> *connection,
> _MHD_EXTERN int
> MHD_queue_response (struct MHD_Connection *connection,
> unsigned int status_code,
> - struct MHD_Response *response);
> + struct MHD_Response *response);
>
>
> /**
> @@ -2636,9 +2636,9 @@ MHD_set_response_options (struct MHD_Response *response,
> */
> _MHD_EXTERN struct MHD_Response *
> MHD_create_response_from_callback (uint64_t size,
> - size_t block_size,
> - MHD_ContentReaderCallback crc, void *crc_cls,
> - MHD_ContentReaderFreeCallback crfc);
> + size_t block_size,
> + MHD_ContentReaderCallback crc, void *crc_cls,
> + MHD_ContentReaderFreeCallback crfc);
>
>
> /**
> @@ -2658,9 +2658,9 @@ MHD_create_response_from_callback (uint64_t size,
> _MHD_DEPR_FUNC("MHD_create_response_from_data() is deprecated, use
> MHD_create_response_from_buffer()") \
> _MHD_EXTERN struct MHD_Response *
> MHD_create_response_from_data (size_t size,
> - void *data,
> - int must_free,
> - int must_copy);
> + void *data,
> + int must_free,
> + int must_copy);
>
>
> /**
> @@ -2711,8 +2711,8 @@ enum MHD_ResponseMemoryMode
> */
> _MHD_EXTERN struct MHD_Response *
> MHD_create_response_from_buffer (size_t size,
> - void *buffer,
> - enum MHD_ResponseMemoryMode mode);
> + void *buffer,
> + enum MHD_ResponseMemoryMode mode);
>
>
> /**
> @@ -2935,7 +2935,7 @@ typedef void
> */
> _MHD_EXTERN struct MHD_Response *
> MHD_create_response_for_upgrade (MHD_UpgradeHandler upgrade_handler,
> - void *upgrade_handler_cls);
> + void *upgrade_handler_cls);
>
>
> /**
> @@ -2964,7 +2964,7 @@ MHD_destroy_response (struct MHD_Response *response);
> _MHD_EXTERN int
> MHD_add_response_header (struct MHD_Response *response,
> const char *header,
> - const char *content);
> + const char *content);
>
>
> /**
> @@ -2979,7 +2979,7 @@ MHD_add_response_header (struct MHD_Response *response,
> _MHD_EXTERN int
> MHD_add_response_footer (struct MHD_Response *response,
> const char *footer,
> - const char *content);
> + const char *content);
>
>
> /**
> @@ -2994,7 +2994,7 @@ MHD_add_response_footer (struct MHD_Response *response,
> _MHD_EXTERN int
> MHD_del_response_header (struct MHD_Response *response,
> const char *header,
> - const char *content);
> + const char *content);
>
>
> /**
> @@ -3022,7 +3022,7 @@ MHD_get_response_headers (struct MHD_Response *response,
> */
> _MHD_EXTERN const char *
> MHD_get_response_header (struct MHD_Response *response,
> - const char *key);
> + const char *key);
>
>
> /* ********************** PostProcessor functions ********************** */
> @@ -3054,8 +3054,8 @@ MHD_get_response_header (struct MHD_Response *response,
> */
> _MHD_EXTERN struct MHD_PostProcessor *
> MHD_create_post_processor (struct MHD_Connection *connection,
> - size_t buffer_size,
> - MHD_PostDataIterator iter, void *iter_cls);
> + size_t buffer_size,
> + MHD_PostDataIterator iter, void *iter_cls);
>
>
> /**
> @@ -3106,7 +3106,7 @@ MHD_destroy_post_processor (struct MHD_PostProcessor
> *pp);
> *
> * @param connection The MHD connection structure
> * @return NULL if no username could be found, a pointer
> - * to the username if found, free using #MHD_free().
> + * to the username if found, free using #MHD_free().
> * @ingroup authentication
> */
> _MHD_EXTERN char *
> @@ -3133,17 +3133,17 @@ MHD_free (void *ptr);
> * @param username The username needs to be authenticated
> * @param password The password used in the authentication
> * @param nonce_timeout The amount of time for a nonce to be
> - * invalid in seconds
> + * invalid in seconds
> * @return #MHD_YES if authenticated, #MHD_NO if not,
> - * #MHD_INVALID_NONCE if nonce is invalid
> + * #MHD_INVALID_NONCE if nonce is invalid
> * @ingroup authentication
> */
> _MHD_EXTERN int
> MHD_digest_auth_check (struct MHD_Connection *connection,
> - const char *realm,
> - const char *username,
> - const char *password,
> - unsigned int nonce_timeout);
> + const char *realm,
> + const char *username,
> + const char *password,
> + unsigned int nonce_timeout);
>
>
> /**
> @@ -3156,16 +3156,16 @@ MHD_digest_auth_check (struct MHD_Connection
> *connection,
> * body; note that this function will set the "WWW Authenticate"
> * header and that the caller should not do this
> * @param signal_stale #MHD_YES if the nonce is invalid to add
> - * 'stale=true' to the authentication header
> + * 'stale=true' to the authentication header
> * @return #MHD_YES on success, #MHD_NO otherwise
> * @ingroup authentication
> */
> _MHD_EXTERN int
> MHD_queue_auth_fail_response (struct MHD_Connection *connection,
> - const char *realm,
> - const char *opaque,
> - struct MHD_Response *response,
> - int signal_stale);
> + const char *realm,
> + const char *opaque,
> + struct MHD_Response *response,
> + int signal_stale);
>
>
> /**
> @@ -3174,12 +3174,12 @@ MHD_queue_auth_fail_response (struct MHD_Connection
> *connection,
> * @param connection The MHD connection structure
> * @param[out] password a pointer for the password, free using #MHD_free().
> * @return NULL if no username could be found, a pointer
> - * to the username if found, free using #MHD_free().
> + * to the username if found, free using #MHD_free().
> * @ingroup authentication
> */
> _MHD_EXTERN char *
> MHD_basic_auth_get_username_password (struct MHD_Connection *connection,
> - char** password);
> + char** password);
>
>
> /**
> @@ -3196,8 +3196,8 @@ MHD_basic_auth_get_username_password (struct
> MHD_Connection *connection,
> */
> _MHD_EXTERN int
> MHD_queue_basic_auth_fail_response (struct MHD_Connection *connection,
> - const char *realm,
> - struct MHD_Response *response);
> + const char *realm,
> + struct MHD_Response *response);
>
> /* ********************** generic query functions ********************** */
>
> @@ -3214,8 +3214,8 @@ MHD_queue_basic_auth_fail_response (struct
> MHD_Connection *connection,
> */
> _MHD_EXTERN const union MHD_ConnectionInfo *
> MHD_get_connection_info (struct MHD_Connection *connection,
> - enum MHD_ConnectionInfoType info_type,
> - ...);
> + enum MHD_ConnectionInfoType info_type,
> + ...);
>
>
> /**
> @@ -3248,8 +3248,8 @@ enum MHD_CONNECTION_OPTION
> */
> _MHD_EXTERN int
> MHD_set_connection_option (struct MHD_Connection *connection,
> - enum MHD_CONNECTION_OPTION option,
> - ...);
> + enum MHD_CONNECTION_OPTION option,
> + ...);
>
>
> /**
> @@ -3312,8 +3312,8 @@ union MHD_DaemonInfo
> */
> _MHD_EXTERN const union MHD_DaemonInfo *
> MHD_get_daemon_info (struct MHD_Daemon *daemon,
> - enum MHD_DaemonInfoType info_type,
> - ...);
> + enum MHD_DaemonInfoType info_type,
> + ...);
>
>
> /**
> diff --git a/src/include/microhttpd2.h b/src/include/microhttpd2.h
> index d4330c32..eb1a86ae 100644
> --- a/src/include/microhttpd2.h
> +++ b/src/include/microhttpd2.h
> @@ -391,9 +391,9 @@ enum MHD_Method
> */
> typedef struct MHD_Action *
> (*MHD_RequestCallback) (void *cls,
> - struct MHD_Request *request,
> - const char *url,
> - enum MHD_Method method);
> + struct MHD_Request *request,
> + const char *url,
> + enum MHD_Method method);
>
>
> /**
> @@ -406,7 +406,7 @@ typedef struct MHD_Action *
> */
> struct MHD_Daemon *
> MHD_daemon_create (MHD_RequestCallback cb,
> - void *cb_cls);
> + void *cb_cls);
>
>
> /**
> @@ -469,9 +469,9 @@ MHD_daemon_destroy (struct MHD_Daemon *daemon);
> */
> typedef void
> (*MHD_LoggingCallback)(void *cls,
> - enum MHD_StatusCode sc,
> - const char *fm,
> - va_list ap);
> + enum MHD_StatusCode sc,
> + const char *fm,
> + va_list ap);
>
>
> /**
> @@ -485,8 +485,8 @@ typedef void
> */
> _MHD_EXTERN void
> MHD_daemon_set_logger (struct MHD_Daemon *daemon,
> - MHD_LoggingCallback logger,
> - void *logger_cls);
> + MHD_LoggingCallback logger,
> + void *logger_cls);
>
>
> /**
> @@ -609,8 +609,8 @@ enum MHD_FastOpenMethod
> */
> _MHD_EXTERN enum MHD_Bool
> MHD_daemon_tcp_fastopen (struct MHD_Daemon *daemon,
> - enum MHD_FastOpenMethod fom,
> - unsigned int queue_length);
> + enum MHD_FastOpenMethod fom,
> + unsigned int queue_length);
>
>
> /**
> @@ -656,8 +656,8 @@ enum MHD_AddressFamily
> */
> _MHD_EXTERN void
> MHD_daemon_bind_port (struct MHD_Daemon *daemon,
> - enum MHD_AddressFamily af,
> - uint16_t port);
> + enum MHD_AddressFamily af,
> + uint16_t port);
>
>
> /**
> @@ -671,8 +671,8 @@ MHD_daemon_bind_port (struct MHD_Daemon *daemon,
> */
> _MHD_EXTERN void
> MHD_daemon_bind_socket_address (struct MHD_Daemon *daemon,
> - const struct sockaddr *sa,
> - size_t sa_lem);
> + const struct sockaddr *sa,
> + size_t sa_lem);
>
>
> /**
> @@ -684,7 +684,7 @@ MHD_daemon_bind_socket_address (struct MHD_Daemon *daemon,
> */
> _MHD_EXTERN void
> MHD_daemon_listen_queue (struct MHD_Daemon *daemon,
> - int listen_backlog);
> + int listen_backlog);
>
>
> /**
> @@ -717,7 +717,7 @@ MHD_daemon_listen_allow_address_reuse (struct MHD_Daemon
> *daemon);
> */
> _MHD_EXTERN void
> MHD_daemon_listen_socket (struct MHD_Daemon *daemon,
> - MHD_socket listen_socket);
> + MHD_socket listen_socket);
>
>
> /**
> @@ -757,7 +757,7 @@ enum MHD_EventLoopSyscall
> */
> _MHD_EXTERN enum MHD_Bool
> MHD_daemon_event_loop (struct MHD_Daemon *daemon,
> - enum MHD_EventLoopSyscall els);
> + enum MHD_EventLoopSyscall els);
>
>
> /**
> @@ -801,7 +801,7 @@ enum MHD_ProtocolStrictLevel
> */
> _MHD_EXTERN void
> MHD_daemon_protocol_strict_level (struct MHD_Daemon *daemon,
> - enum MHD_ProtocolStrictLevel sl);
> + enum MHD_ProtocolStrictLevel sl);
>
>
> /**
> @@ -821,8 +821,8 @@ MHD_daemon_protocol_strict_level (struct MHD_Daemon
> *daemon,
> */
> _MHD_EXTERN enum MHD_StatusCode
> MHD_daemon_set_tls_backend (struct MHD_Daemon *daemon,
> - const char *tls_backend,
> - const char *ciphers);
> + const char *tls_backend,
> + const char *ciphers);
>
>
> /**
> @@ -839,9 +839,9 @@ MHD_daemon_set_tls_backend (struct MHD_Daemon *daemon,
> */
> _MHD_EXTERN enum MHD_StatusCode
> MHD_daemon_tls_key_and_cert_from_memory (struct MHD_Daemon *daemon,
> - const char *mem_key,
> - const char *mem_cert,
> - const char *pass);
> + const char *mem_key,
> + const char *mem_cert,
> + const char *pass);
>
>
> /**
> @@ -854,7 +854,7 @@ MHD_daemon_tls_key_and_cert_from_memory (struct
> MHD_Daemon *daemon,
> */
> _MHD_EXTERN enum MHD_StatusCode
> MHD_daemon_tls_mem_dhparams (struct MHD_Daemon *daemon,
> - const char *dh);
> + const char *dh);
>
>
> /**
> @@ -867,7 +867,7 @@ _MHD_EXTERN enum MHD_StatusCode
> */
> _MHD_EXTERN enum MHD_StatusCode
> MHD_daemon_tls_mem_trust (struct MHD_Daemon *daemon,
> - const char *mem_trust);
> + const char *mem_trust);
>
>
> /**
> @@ -879,7 +879,7 @@ MHD_daemon_tls_mem_trust (struct MHD_Daemon *daemon,
> */
> _MHD_EXTERN enum MHD_StatusCode
> MHD_daemon_gnutls_credentials (struct MHD_Daemon *daemon,
> - int gnutls_credentials);
> + int gnutls_credentials);
>
>
> /**
> @@ -900,7 +900,7 @@ MHD_daemon_gnutls_credentials (struct MHD_Daemon *daemon,
> */
> _MHD_EXTERN void
> MHD_daemon_gnutls_key_and_cert_from_callback (struct MHD_Daemon *daemon,
> - void *cb);
> + void *cb);
>
>
> /**
> @@ -958,7 +958,7 @@ enum MHD_ThreadingModel
> */
> _MHD_EXTERN void
> MHD_daemon_threading_model (struct MHD_Daemon *daemon,
> - enum MHD_ThreadingModel tm);
> + enum MHD_ThreadingModel tm);
>
>
> /**
> @@ -987,8 +987,8 @@ typedef enum MHD_Bool
> */
> _MHD_EXTERN void
> MHD_daemon_accept_policy (struct MHD_Daemon *daemon,
> - MHD_AcceptPolicyCallback apc,
> - void *apc_cls);
> + MHD_AcceptPolicyCallback apc,
> + void *apc_cls);
>
>
> /**
> @@ -1003,8 +1003,8 @@ MHD_daemon_accept_policy (struct MHD_Daemon *daemon,
> */
> typedef void *
> (MHD_EarlyUriLogCallback)(void *cls,
> - const char *uri,
> - struct MHD_Request *request);
> + const char *uri,
> + struct MHD_Request *request);
>
>
> /**
> @@ -1018,8 +1018,8 @@ typedef void *
> */
> _MHD_EXTERN void
> MHD_daemon_set_early_uri_logger (struct MHD_Daemon *daemon,
> - MHD_EarlyUriLogCallback cb,
> - void *cb_cls);
> + MHD_EarlyUriLogCallback cb,
> + void *cb_cls);
>
>
> /**
> @@ -1043,8 +1043,8 @@ MHD_daemon_set_early_uri_logger (struct MHD_Daemon
> *daemon,
> */
> typedef void
> (*MHD_ConnectionCompletedCallback) (void *cls,
> - struct MHD_Connection *connection,
> - enum MHD_ConnectionNotificationCode toe);
> + struct MHD_Connection *connection,
> + enum MHD_ConnectionNotificationCode toe);
>
>
> /**
> @@ -1059,8 +1059,8 @@ typedef void
> */
> _MHD_EXTERN void
> MHD_daemon_set_notify_connection (struct MHD_Daemon *daemon,
> - MHD_NotifyConnectionCallback ncc,
> - void *ncc_cls);
> + MHD_NotifyConnectionCallback ncc,
> + void *ncc_cls);
>
>
> /**
> @@ -1076,8 +1076,8 @@ MHD_daemon_set_notify_connection (struct MHD_Daemon
> *daemon,
> */
> _MHD_EXTERN void
> MHD_daemon_connection_memory_limit (struct MHD_Daemon *daemon,
> - size_t memory_limit_b,
> - size_t memory_increment_b);
> + size_t memory_limit_b,
> + size_t memory_increment_b);
>
>
> /**
> @@ -1090,7 +1090,7 @@ MHD_daemon_connection_memory_limit (struct MHD_Daemon
> *daemon,
> */
> _MHD_EXTERN void
> MHD_daemon_thread_stack_size (struct MHD_Daemon *daemon,
> - size_t stack_limit_b);
> + size_t stack_limit_b);
>
>
> /**
> @@ -1110,8 +1110,8 @@ MHD_daemon_thread_stack_size (struct MHD_Daemon *daemon,
> */
> _MHD_EXTERN void
> MHD_daemon_connection_limits (struct MHD_Daemon *daemon,
> - unsigned int global_connection_limit,
> - unsigned int ip_connection_limit);
> + unsigned int global_connection_limit,
> + unsigned int ip_connection_limit);
>
>
> /**
> @@ -1124,7 +1124,7 @@ MHD_daemon_connection_limits (struct MHD_Daemon *daemon,
> */
> _MHD_EXTERN void
> MHD_daemon_connection_default_timeout (struct MHD_Daemon *daemon,
> - unsigned int timeout_s);
> + unsigned int timeout_s);
>
>
> /**
> @@ -1141,8 +1141,8 @@ MHD_daemon_connection_default_timeout (struct
> MHD_Daemon *daemon,
> */
> typedef size_t
> MHD_UnescapeCallback (void *cls,
> - struct MHD_Request *req,
> - char *s);
> + struct MHD_Request *req,
> + char *s);
>
>
> /**
> @@ -1158,8 +1158,8 @@ MHD_UnescapeCallback (void *cls,
> */
> _MHD_EXTERN void
> MHD_daemon_unescape_cb (struct MHD_Daemon *daemon,
> - MHD_UnescapeCallback unescape_cb,
> - void *unescape_cb_cls);
> + MHD_UnescapeCallback unescape_cb,
> + void *unescape_cb_cls);
>
>
> /**
> @@ -1173,8 +1173,8 @@ MHD_daemon_unescape_cb (struct MHD_Daemon *daemon,
> */
> _MHD_EXTERN void
> MHD_daemon_digest_auth_random (struct MHD_Daemon *daemon,
> - size_t buf_size,
> - const void *buf);
> + size_t buf_size,
> + const void *buf);
>
>
> /**
> @@ -1186,7 +1186,7 @@ MHD_daemon_digest_auth_random (struct MHD_Daemon
> *daemon,
> */
> _MHD_EXTERN void
> MHD_daemon_digest_auth_nc_size (struct MHD_Daemon *daemon,
> - size_t stack_limit_b);
> + size_t stack_limit_b);
>
>
> /* ********************* connection options ************** */
> @@ -1203,7 +1203,7 @@ MHD_daemon_digest_auth_nc_size (struct MHD_Daemon
> *daemon,
> */
> struct MHD_ConnectionOption
> MHD_connection_timeout (struct MHD_Connection *connection,
> - unsigned int timeout_s);
> + unsigned int timeout_s);
>
>
> /* **************** Request handling functions ***************** */
> @@ -1221,9 +1221,9 @@ MHD_connection_timeout (struct MHD_Connection
> *connection,
> */
> _MHD_EXTERN unsigned int
> MHD_request_get_values (struct MHD_Request *request,
> - enum MHD_ValueKind kind,
> - MHD_KeyValueIterator iterator,
> - void *iterator_cls);
> + enum MHD_ValueKind kind,
> + MHD_KeyValueIterator iterator,
> + void *iterator_cls);
>
>
> /**
> @@ -1253,9 +1253,9 @@ MHD_request_get_values (struct MHD_Request *request,
> */
> _MHD_EXTERN enum MHD_Bool
> MHD_request_set_value (struct MHD_Request *request,
> - enum MHD_ValueKind kind,
> - const char *key,
> - const char *value);
> + enum MHD_ValueKind kind,
> + const char *key,
> + const char *value);
>
>
> /**
> @@ -1270,8 +1270,8 @@ MHD_request_set_value (struct MHD_Request *request,
> */
> _MHD_EXTERN const char *
> MHD_request_lookup_value (struct MHD_Request *request,
> - enum MHD_ValueKind kind,
> - const char *key);
> + enum MHD_ValueKind kind,
> + const char *key);
>
>
>
> @@ -1445,7 +1445,7 @@ MHD_request_resume (struct MHD_Request *request);
> */
> struct MHD_Action *
> MHD_action_from_response (struct MHD_Response *response,
> - enum MHD_bool destroy_after_use);
> + enum MHD_bool destroy_after_use);
>
>
> /**
> @@ -1472,8 +1472,8 @@ MHD_response_option_v10_only (struct MHD_Response
> *response);
> */
> typedef void
> (*MHD_RequestTerminationCallback) (void *cls,
> - enum MHD_RequestTerminationCode toe,
> - void *request_context);
> + enum MHD_RequestTerminationCode toe,
> + void *request_context);
>
>
> /**
> @@ -1486,8 +1486,8 @@ typedef void
> */
> void
> MHD_response_option_termination_callback (struct MHD_Response *response,
> - MHD_RequestTerminationCallback
> termination_cb,
> - void *termination_cb_cls);
> + MHD_RequestTerminationCallback termination_cb,
> + void *termination_cb_cls);
>
>
> /**
> @@ -1509,11 +1509,11 @@ MHD_response_option_termination_callback (struct
> MHD_Response *response,
> */
> _MHD_EXTERN struct MHD_Response *
> MHD_response_from_callback (enum MHD_HTTP_StatusCode sc,
> - uint64_t size,
> - size_t block_size,
> - MHD_ContentReaderCallback crc,
> - void *crc_cls,
> - MHD_ContentReaderFreeCallback crfc);
> + uint64_t size,
> + size_t block_size,
> + MHD_ContentReaderCallback crc,
> + void *crc_cls,
> + MHD_ContentReaderFreeCallback crfc);
>
>
> /**
> @@ -1566,9 +1566,9 @@ enum MHD_ResponseMemoryMode
> */
> _MHD_EXTERN struct MHD_Response *
> MHD_response_from_buffer (enum MHD_HTTP_StatusCode sc,
> - size_t size,
> - void *buffer,
> - enum MHD_ResponseMemoryMode mode);
> + size_t size,
> + void *buffer,
> + enum MHD_ResponseMemoryMode mode);
>
>
> /**
> @@ -1591,9 +1591,9 @@ MHD_response_from_buffer (enum MHD_HTTP_StatusCode sc,
> */
> _MHD_EXTERN struct MHD_Response *
> MHD_response_from_fd (enum MHD_HTTP_StatusCode sc,
> - int fd,
> - uint64_t offset,
> - uint64_t size);
> + int fd,
> + uint64_t offset,
> + uint64_t size);
>
>
> /**
> @@ -1637,8 +1637,8 @@ struct MHD_UpgradeResponseHandle;
> */
> _MHD_EXTERN enum MHD_Bool
> MHD_upgrade_operation (struct MHD_UpgradeResponseHandle *urh,
> - enum MHD_UpgradeOperation operation,
> - ...);
> + enum MHD_UpgradeOperation operation,
> + ...);
>
>
> /**
> @@ -1730,7 +1730,7 @@ typedef void
> */
> _MHD_EXTERN struct MHD_Response *
> MHD_response_for_upgrade (MHD_UpgradeHandler upgrade_handler,
> - void *upgrade_handler_cls);
> + void *upgrade_handler_cls);
>
>
> /**
> @@ -1759,7 +1759,7 @@ MHD_response_queue_for_destroy (struct MHD_Response
> *response);
> _MHD_EXTERN enum MHD_Bool
> MHD_response_add_header (struct MHD_Response *response,
> const char *header,
> - const char *content);
> + const char *content);
>
>
> /**
> @@ -1790,7 +1790,7 @@ MHD_response_add_trailer (struct MHD_Response *response,
> _MHD_EXTERN enum MHD_Bool
> MHD_response_del_header (struct MHD_Response *response,
> const char *header,
> - const char *content);
> + const char *content);
>
>
> /**
> @@ -1806,7 +1806,7 @@ MHD_response_del_header (struct MHD_Response *response,
> _MHD_EXTERN unsigned int
> MHD_response_get_headers (struct MHD_Response *response,
> MHD_KeyValueIterator iterator,
> - void *iterator_cls);
> + void *iterator_cls);
>
>
> /**
> @@ -1819,7 +1819,7 @@ MHD_response_get_headers (struct MHD_Response *response,
> */
> _MHD_EXTERN const char *
> MHD_response_get_header (struct MHD_Response *response,
> - const char *key);
> + const char *key);
>
>
> /* ************Upload and PostProcessor functions ********************** */
> @@ -1853,8 +1853,8 @@ MHD_action_continue (void);
> */
> typedef struct MHD_Action *
> (*MHD_UploadCallback) (void *cls,
> - const char *upload_data,
> - size_t *upload_data_size);
> + const char *upload_data,
> + size_t *upload_data_size);
>
>
> /**
> @@ -1867,7 +1867,7 @@ typedef struct MHD_Action *
> */
> _MHD_EXTERN struct MHD_Action *
> MHD_action_process_upload (MHD_UploadCallback uc,
> - void *uc_cls);
> + void *uc_cls);
>
>
> /**
> @@ -1931,8 +1931,8 @@ typedef struct MHD_Action *
> */
> _MHD_EXTERN struct MHD_Action *
> MHD_action_parse_post (size_t buffer_size,
> - MHD_PostDataIterator iter,
> - void *iter_cls);
> + MHD_PostDataIterator iter,
> + void *iter_cls);
>
>
>
> @@ -2088,9 +2088,9 @@ union MHD_ConnectionInformation
> */
> _MHD_EXTERN enum MHD_Bool
> MHD_connection_get_information_sz (struct MHD_Connection *connection,
> - enum MHD_ConnectionInformationType info_type,
> - union MHD_ConnectionInformation
> *return_value,
> - size_t return_value_size);
> + enum MHD_ConnectionInformationType info_type,
> + union MHD_ConnectionInformation *return_value,
> + size_t return_value_size);
>
>
> /**
> @@ -2205,9 +2205,9 @@ enum MHD_RequestInformationType
> */
> _MHD_EXTERN enum MHD_Bool
> MHD_request_get_information_sz (struct MHD_Request *request,
> - enum MHD_RequestInformationType info_type,
> - union MHD_RequestInformation *return_value,
> - size_t return_value_size);
> + enum MHD_RequestInformationType info_type,
> + union MHD_RequestInformation *return_value,
> + size_t return_value_size);
>
>
> /**
> @@ -2311,9 +2311,9 @@ union MHD_DaemonInformation
> */
> _MHD_EXTERN enum MHD_Bool
> MHD_daemon_get_information_sz (struct MHD_Daemon *daemon,
> - enum MHD_DaemonInformationType info_type,
> - union MHD_DaemonInformation *return_value,
> - size_t return_value_size);
> + enum MHD_DaemonInformationType info_type,
> + union MHD_DaemonInformation *return_value,
> + size_t return_value_size);
>
> /**
> * Obtain information about the given daemon.
> @@ -2329,4 +2329,4 @@ MHD_daemon_get_information_sz (struct MHD_Daemon
> *daemon,
> #define MHD_daemon_get_information(daemon, \
> info_type, \
> return_value) \
> - MHD_daemon_get_information_sz((daemon), (info_type), (return_value),
> sizeof(union MHD_DaemonInformation));
> + MHD_daemon_get_information_sz((daemon), (info_type), (return_value),
> sizeof(union MHD_DaemonInformation));
> diff --git a/src/microhttpd/basicauth.c b/src/microhttpd/basicauth.c
> index 4cb671e4..4906e627 100644
> --- a/src/microhttpd/basicauth.c
> +++ b/src/microhttpd/basicauth.c
> @@ -31,7 +31,7 @@
> /**
> * Beginning string for any valid Basic authentication header.
> */
> -#define _BASIC_BASE "Basic "
> +#define _BASIC_BASE "Basic "
>
>
> /**
> @@ -40,12 +40,12 @@
> * @param connection The MHD connection structure
> * @param password a pointer for the password
> * @return NULL if no username could be found, a pointer
> - * to the username if found
> + * to the username if found
> * @ingroup authentication
> */
> char *
> MHD_basic_auth_get_username_password (struct MHD_Connection *connection,
> - char** password)
> + char** password)
> {
> const char *header;
> char *decode;
> @@ -53,8 +53,8 @@ MHD_basic_auth_get_username_password (struct MHD_Connection
> *connection,
> char *user;
>
> if ( (NULL == (header = MHD_lookup_connection_value (connection,
> - MHD_HEADER_KIND,
> -
> MHD_HTTP_HEADER_AUTHORIZATION))) ||
> + MHD_HEADER_KIND,
> + MHD_HTTP_HEADER_AUTHORIZATION))) ||
> (0 != strncmp (header,
> _BASIC_BASE,
> MHD_STATICSTR_LEN_ (_BASIC_BASE))) )
> @@ -64,7 +64,7 @@ MHD_basic_auth_get_username_password (struct MHD_Connection
> *connection,
> {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (connection->daemon,
> - _("Error decoding basic authentication\n"));
> + _("Error decoding basic authentication\n"));
> #endif
> return NULL;
> }
> @@ -74,7 +74,7 @@ MHD_basic_auth_get_username_password (struct MHD_Connection
> *connection,
> {
> #ifdef HAVE_MESSAGES
> MHD_DLOG(connection->daemon,
> - _("Basic authentication doesn't contain ':' separator\n"));
> + _("Basic authentication doesn't contain ':' separator\n"));
> #endif
> free (decode);
> return NULL;
> @@ -89,15 +89,15 @@ MHD_basic_auth_get_username_password (struct
> MHD_Connection *connection,
> {
> *password = strdup (separator + 1);
> if (NULL == *password)
> - {
> + {
> #ifdef HAVE_MESSAGES
> - MHD_DLOG(connection->daemon,
> - _("Failed to allocate memory for password\n"));
> + MHD_DLOG(connection->daemon,
> + _("Failed to allocate memory for password\n"));
> #endif
> - free (decode);
> - free (user);
> - return NULL;
> - }
> + free (decode);
> + free (user);
> + return NULL;
> + }
> }
> free (decode);
> return user;
> @@ -118,8 +118,8 @@ MHD_basic_auth_get_username_password (struct
> MHD_Connection *connection,
> */
> int
> MHD_queue_basic_auth_fail_response (struct MHD_Connection *connection,
> - const char *realm,
> - struct MHD_Response *response)
> + const char *realm,
> + struct MHD_Response *response)
> {
> int ret;
> int res;
> @@ -131,7 +131,7 @@ MHD_queue_basic_auth_fail_response (struct MHD_Connection
> *connection,
> {
> #ifdef HAVE_MESSAGES
> MHD_DLOG(connection->daemon,
> - "Failed to allocate memory for auth header\n");
> + "Failed to allocate memory for auth header\n");
> #endif /* HAVE_MESSAGES */
> return MHD_NO;
> }
> @@ -149,8 +149,8 @@ MHD_queue_basic_auth_fail_response (struct MHD_Connection
> *connection,
> free(header);
> if (MHD_YES == ret)
> ret = MHD_queue_response (connection,
> - MHD_HTTP_UNAUTHORIZED,
> - response);
> + MHD_HTTP_UNAUTHORIZED,
> + response);
> else
> {
> #ifdef HAVE_MESSAGES
> diff --git a/src/microhttpd/connection.c b/src/microhttpd/connection.c
> index a85e56ef..98ea8918 100644
> --- a/src/microhttpd/connection.c
> +++ b/src/microhttpd/connection.c
> @@ -711,13 +711,13 @@ MHD_get_connection_values (struct MHD_Connection
> *connection,
> for (pos = connection->headers_received; NULL != pos; pos = pos->next)
> if (0 != (pos->kind & kind))
> {
> - ret++;
> - if ( (NULL != iterator) &&
> + ret++;
> + if ( (NULL != iterator) &&
> (MHD_YES != iterator (iterator_cls,
> pos->kind,
> pos->header,
> pos->value)) )
> - return ret;
> + return ret;
> }
> return ret;
> }
> @@ -801,9 +801,9 @@ MHD_lookup_connection_value (struct MHD_Connection
> *connection,
> return NULL;
> for (pos = connection->headers_received; NULL != pos; pos = pos->next)
> if ((0 != (pos->kind & kind)) &&
> - ( (key == pos->header) ||
> - ( (NULL != pos->header) &&
> - (NULL != key) &&
> + ( (key == pos->header) ||
> + ( (NULL != pos->header) &&
> + (NULL != key) &&
> (MHD_str_equal_caseless_(key,
> pos->header)))))
> return pos->value;
> @@ -875,16 +875,16 @@ need_100_continue (struct MHD_Connection *connection)
> const char *expect;
>
> return ( (NULL == connection->response) &&
> - (NULL != connection->version) &&
> + (NULL != connection->version) &&
> (MHD_str_equal_caseless_(connection->version,
> - MHD_HTTP_VERSION_1_1)) &&
> - (NULL != (expect = MHD_lookup_connection_value (connection,
> - MHD_HEADER_KIND,
> -
> MHD_HTTP_HEADER_EXPECT))) &&
> - (MHD_str_equal_caseless_(expect,
> + MHD_HTTP_VERSION_1_1)) &&
> + (NULL != (expect = MHD_lookup_connection_value (connection,
> + MHD_HEADER_KIND,
> + MHD_HTTP_HEADER_EXPECT))) &&
> + (MHD_str_equal_caseless_(expect,
> "100-continue")) &&
> - (connection->continue_message_write_offset <
> - MHD_STATICSTR_LEN_ (HTTP_100_CONTINUE)) );
> + (connection->continue_message_write_offset <
> + MHD_STATICSTR_LEN_ (HTTP_100_CONTINUE)) );
> }
>
>
> @@ -948,9 +948,9 @@ MHD_connection_close_ (struct MHD_Connection *connection,
> if ( (NULL != daemon->notify_completed) &&
> (connection->client_aware) )
> daemon->notify_completed (daemon->notify_completed_cls,
> - connection,
> - &connection->client_context,
> - termination_code);
> + connection,
> + &connection->client_context,
> + termination_code);
> connection->client_aware = false;
> }
>
> @@ -991,8 +991,8 @@ MHD_connection_finish_forward_ (struct MHD_Connection
> *connection)
> if (urh->in_eready_list)
> {
> EDLL_remove (daemon->eready_urh_head,
> - daemon->eready_urh_tail,
> - urh);
> + daemon->eready_urh_tail,
> + urh);
> urh->in_eready_list = false;
> }
> #endif /* EPOLL_SUPPORT */
> @@ -1030,7 +1030,7 @@ MHD_connection_finish_forward_ (struct MHD_Connection
> *connection)
> */
> static void
> connection_close_error (struct MHD_Connection *connection,
> - const char *emsg)
> + const char *emsg)
> {
> #ifdef HAVE_MESSAGES
> if (NULL != emsg)
> @@ -1080,9 +1080,9 @@ try_ready_normal_body (struct MHD_Connection
> *connection)
> (connection->response_write_position == response->total_size) )
> return MHD_YES; /* 0-byte response is always ready */
> if ( (response->data_start <=
> - connection->response_write_position) &&
> + connection->response_write_position) &&
> (response->data_size + response->data_start >
> - connection->response_write_position) )
> + connection->response_write_position) )
> return MHD_YES; /* response already ready */
> #if defined(_MHD_HAVE_SENDFILE)
> if (MHD_resp_sender_sendfile == connection->resp_sender)
> @@ -1105,11 +1105,11 @@ try_ready_normal_body (struct MHD_Connection
> *connection)
> response->total_size = connection->response_write_position;
> MHD_mutex_unlock_chk_ (&response->mutex);
> if ( ((ssize_t)MHD_CONTENT_READER_END_OF_STREAM) == ret)
> - MHD_connection_close_ (connection,
> + MHD_connection_close_ (connection,
> MHD_REQUEST_TERMINATED_COMPLETED_OK);
> else
> - CONNECTION_CLOSE_ERROR (connection,
> - _("Closing connection (application reported
> error generating data)\n"));
> + CONNECTION_CLOSE_ERROR (connection,
> + _("Closing connection (application reported error generating
> data)\n"));
> return MHD_NO;
> }
> response->data_start = connection->response_write_position;
> @@ -1157,7 +1157,7 @@ try_ready_chunked_body (struct MHD_Connection
> *connection)
> {
> /* not enough memory */
> CONNECTION_CLOSE_ERROR (connection,
> - _("Closing connection (out of
> memory)\n"));
> + _("Closing connection (out of memory)\n"));
> return MHD_NO;
> }
> buf = MHD_pool_allocate (connection->pool,
> @@ -1172,9 +1172,9 @@ try_ready_chunked_body (struct MHD_Connection
> *connection)
> if (0 == response->total_size)
> ret = 0; /* response must be empty, don't bother calling crc */
> else if ( (response->data_start <=
> - connection->response_write_position) &&
> + connection->response_write_position) &&
> (response->data_start + response->data_size >
> - connection->response_write_position) )
> + connection->response_write_position) )
> {
> /* difference between response_write_position and data_start is less
> than data_size which is size_t type, no need to check for overflow
> */
> @@ -1183,7 +1183,7 @@ try_ready_chunked_body (struct MHD_Connection
> *connection)
> /* buffer already ready, use what is there for the chunk */
> ret = response->data_size - data_write_offset;
> if ( ((size_t) ret) > connection->write_buffer_size - sizeof (cbuf) -
> 2 )
> - ret = connection->write_buffer_size - sizeof (cbuf) - 2;
> + ret = connection->write_buffer_size - sizeof (cbuf) - 2;
> memcpy (&connection->write_buffer[sizeof (cbuf)],
> &response->data[data_write_offset],
> ret);
> @@ -1201,7 +1201,7 @@ try_ready_chunked_body (struct MHD_Connection
> *connection)
> /* error, close socket! */
> response->total_size = connection->response_write_position;
> CONNECTION_CLOSE_ERROR (connection,
> - _("Closing connection (application error
> generating response)\n"));
> + _("Closing connection (application error generating
> response)\n"));
> return MHD_NO;
> }
> if ( (((ssize_t) MHD_CONTENT_READER_END_OF_STREAM) == ret) ||
> @@ -1306,7 +1306,7 @@ keepalive_possible (struct MHD_Connection *connection)
> */
> static void
> get_date_string (char *date,
> - size_t date_len)
> + size_t date_len)
> {
> static const char *const days[] = {
> "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
> @@ -1342,15 +1342,15 @@ get_date_string (char *date,
> now = *pNow;
> #endif
> MHD_snprintf_ (date,
> - date_len,
> - "Date: %3s, %02u %3s %04u %02u:%02u:%02u GMT\r\n",
> - days[now.tm_wday % 7],
> - (unsigned int) now.tm_mday,
> - mons[now.tm_mon % 12],
> - (unsigned int) (1900 + now.tm_year),
> - (unsigned int) now.tm_hour,
> - (unsigned int) now.tm_min,
> - (unsigned int) now.tm_sec);
> + date_len,
> + "Date: %3s, %02u %3s %04u %02u:%02u:%02u GMT\r\n",
> + days[now.tm_wday % 7],
> + (unsigned int) now.tm_mday,
> + mons[now.tm_mon % 12],
> + (unsigned int) (1900 + now.tm_year),
> + (unsigned int) now.tm_hour,
> + (unsigned int) now.tm_min,
> + (unsigned int) now.tm_sec);
> }
>
>
> @@ -1437,25 +1437,25 @@ build_header_response (struct MHD_Connection
> *connection)
> {
> reason_phrase = MHD_get_reason_phrase_for (rc);
> MHD_snprintf_ (code,
> - sizeof (code),
> - "%s %u %s\r\n",
> - (0 != (connection->responseCode & MHD_ICY_FLAG))
> - ? "ICY"
> - : ( (MHD_str_equal_caseless_ (MHD_HTTP_VERSION_1_0,
> - connection->version))
> - ? MHD_HTTP_VERSION_1_0
> - : MHD_HTTP_VERSION_1_1),
> - rc,
> - reason_phrase);
> + sizeof (code),
> + "%s %u %s\r\n",
> + (0 != (connection->responseCode & MHD_ICY_FLAG))
> + ? "ICY"
> + : ( (MHD_str_equal_caseless_ (MHD_HTTP_VERSION_1_0,
> + connection->version))
> + ? MHD_HTTP_VERSION_1_0
> + : MHD_HTTP_VERSION_1_1),
> + rc,
> + reason_phrase);
> off = strlen (code);
> /* estimate size */
> size = off + 2; /* +2 for extra "\r\n" at the end */
> kind = MHD_HEADER_KIND;
> if ( (0 == (connection->daemon->options &
> MHD_USE_SUPPRESS_DATE_NO_CLOCK)) &&
> - (NULL == MHD_get_response_header (connection->response,
> - MHD_HTTP_HEADER_DATE)) )
> + (NULL == MHD_get_response_header (connection->response,
> + MHD_HTTP_HEADER_DATE)) )
> get_date_string (date,
> - sizeof (date));
> + sizeof (date));
> else
> date[0] = '\0';
> size += strlen (date);
> @@ -1587,9 +1587,9 @@ build_header_response (struct MHD_Connection
> *connection)
> */
> content_length_len
> = MHD_snprintf_ (content_length_buf,
> - sizeof (content_length_buf),
> - MHD_HTTP_HEADER_CONTENT_LENGTH ": "
> MHD_UNSIGNED_LONG_LONG_PRINTF "\r\n",
> - (MHD_UNSIGNED_LONG_LONG)
> connection->response->total_size);
> + sizeof (content_length_buf),
> + MHD_HTTP_HEADER_CONTENT_LENGTH ": " MHD_UNSIGNED_LONG_LONG_PRINTF
> "\r\n",
> + (MHD_UNSIGNED_LONG_LONG) connection->response->total_size);
> must_add_content_length = MHD_YES;
> }
>
> @@ -1689,7 +1689,7 @@ build_header_response (struct MHD_Connection
> *connection)
> /* we must add the 'Content-Length' header */
> memcpy (&data[off],
> content_length_buf,
> - content_length_len);
> + content_length_len);
> off += content_length_len;
> }
> for (pos = connection->response->first_header; NULL != pos; pos =
> pos->next)
> @@ -1744,14 +1744,14 @@ build_header_response (struct MHD_Connection
> *connection)
> static void
> transmit_error_response (struct MHD_Connection *connection,
> unsigned int status_code,
> - const char *message)
> + const char *message)
> {
> struct MHD_Response *response;
>
> if (NULL == connection->version)
> {
> /* we were unable to process the full header line, so we don't
> - really know what version the client speaks; assume 1.0 */
> + really know what version the client speaks; assume 1.0 */
> connection->version = MHD_HTTP_VERSION_1_0;
> }
> connection->state = MHD_CONNECTION_FOOTERS_RECEIVED;
> @@ -1768,8 +1768,8 @@ transmit_error_response (struct MHD_Connection
> *connection,
> connection->response = NULL;
> }
> response = MHD_create_response_from_buffer (strlen (message),
> - (void *) message,
> - MHD_RESPMEM_PERSISTENT);
> + (void *) message,
> + MHD_RESPMEM_PERSISTENT);
> MHD_queue_response (connection,
> status_code,
> response);
> @@ -1781,7 +1781,7 @@ transmit_error_response (struct MHD_Connection
> *connection,
> {
> /* oops - close! */
> CONNECTION_CLOSE_ERROR (connection,
> - _("Closing connection (failed to create response
> header)\n"));
> + _("Closing connection (failed to create response header)\n"));
> }
> else
> {
> @@ -1839,7 +1839,7 @@ MHD_connection_update_event_loop_info (struct
> MHD_Connection *connection)
> /* while reading headers, we always grow the
> read buffer if needed, no size-check required */
> if ( (connection->read_buffer_offset ==
> connection->read_buffer_size) &&
> - (MHD_NO == try_grow_read_buffer (connection)) )
> + (MHD_NO == try_grow_read_buffer (connection)) )
> {
> transmit_error_response (connection,
> (connection->url != NULL)
> @@ -1848,10 +1848,10 @@ MHD_connection_update_event_loop_info (struct
> MHD_Connection *connection)
> REQUEST_TOO_BIG);
> continue;
> }
> - if (! connection->read_closed)
> - connection->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
> - else
> - connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
> + if (! connection->read_closed)
> + connection->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
> + else
> + connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
> break;
> case MHD_CONNECTION_HEADERS_RECEIVED:
> mhd_assert (0);
> @@ -1887,10 +1887,10 @@ MHD_connection_update_event_loop_info (struct
> MHD_Connection *connection)
> }
> }
> if ( (connection->read_buffer_offset <
> connection->read_buffer_size) &&
> - (! connection->read_closed) )
> - connection->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
> - else
> - connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
> + (! connection->read_closed) )
> + connection->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
> + else
> + connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
> break;
> case MHD_CONNECTION_BODY_RECEIVED:
> case MHD_CONNECTION_FOOTER_PART_RECEIVED:
> @@ -1898,47 +1898,47 @@ MHD_connection_update_event_loop_info (struct
> MHD_Connection *connection)
> read buffer if needed, no size-check required */
> if (connection->read_closed)
> {
> - CONNECTION_CLOSE_ERROR (connection,
> - NULL);
> + CONNECTION_CLOSE_ERROR (connection,
> + NULL);
> continue;
> }
> - connection->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
> + connection->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
> /* transition to FOOTERS_RECEIVED
> happens in read handler */
> break;
> case MHD_CONNECTION_FOOTERS_RECEIVED:
> - connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
> + connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
> break;
> case MHD_CONNECTION_HEADERS_SENDING:
> /* headers in buffer, keep writing */
> - connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
> + connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
> break;
> case MHD_CONNECTION_HEADERS_SENT:
> mhd_assert (0);
> break;
> case MHD_CONNECTION_NORMAL_BODY_READY:
> - connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
> + connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
> break;
> case MHD_CONNECTION_NORMAL_BODY_UNREADY:
> - connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
> + connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
> break;
> case MHD_CONNECTION_CHUNKED_BODY_READY:
> - connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
> + connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
> break;
> case MHD_CONNECTION_CHUNKED_BODY_UNREADY:
> - connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
> + connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
> break;
> case MHD_CONNECTION_BODY_SENT:
> mhd_assert (0);
> break;
> case MHD_CONNECTION_FOOTERS_SENDING:
> - connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
> + connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
> break;
> case MHD_CONNECTION_FOOTERS_SENT:
> mhd_assert (0);
> break;
> case MHD_CONNECTION_CLOSED:
> - connection->event_loop_info = MHD_EVENT_LOOP_INFO_CLEANUP;
> + connection->event_loop_info = MHD_EVENT_LOOP_INFO_CLEANUP;
> return; /* do nothing, not even reading */
> case MHD_CONNECTION_IN_CLEANUP:
> mhd_assert (0);
> @@ -1989,15 +1989,15 @@ get_next_header_line (struct MHD_Connection
> *connection,
> {
> /* not found, consider growing... */
> if ( (connection->read_buffer_offset == connection->read_buffer_size)
> &&
> - (MHD_NO ==
> - try_grow_read_buffer (connection)) )
> - {
> - transmit_error_response (connection,
> - (NULL != connection->url)
> - ? MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE
> - : MHD_HTTP_URI_TOO_LONG,
> - REQUEST_TOO_BIG);
> - }
> + (MHD_NO ==
> + try_grow_read_buffer (connection)) )
> + {
> + transmit_error_response (connection,
> + (NULL != connection->url)
> + ? MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE
> + : MHD_HTTP_URI_TOO_LONG,
> + REQUEST_TOO_BIG);
> + }
> if (line_len)
> *line_len = 0;
> return NULL;
> @@ -2031,14 +2031,14 @@ get_next_header_line (struct MHD_Connection
> *connection,
> static int
> connection_add_header (struct MHD_Connection *connection,
> const char *key,
> - const char *value,
> - enum MHD_ValueKind kind)
> + const char *value,
> + enum MHD_ValueKind kind)
> {
> if (MHD_NO ==
> MHD_set_connection_value (connection,
> - kind,
> - key,
> - value))
> + kind,
> + key,
> + value))
> {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (connection->daemon,
> @@ -2073,8 +2073,8 @@ parse_cookie_header (struct MHD_Connection *connection)
> int quotes;
>
> hdr = MHD_lookup_connection_value (connection,
> - MHD_HEADER_KIND,
> - MHD_HTTP_HEADER_COOKIE);
> + MHD_HEADER_KIND,
> + MHD_HTTP_HEADER_COOKIE);
> if (NULL == hdr)
> return MHD_YES;
> cpy = MHD_pool_allocate (connection->pool,
> @@ -2154,10 +2154,10 @@ parse_cookie_header (struct MHD_Connection
> *connection)
> equals++;
> }
> if (MHD_NO ==
> - connection_add_header (connection,
> - pos,
> - equals,
> - MHD_COOKIE_KIND))
> + connection_add_header (connection,
> + pos,
> + equals,
> + MHD_COOKIE_KIND))
> return MHD_NO;
> pos = semicolon;
> }
> @@ -2238,7 +2238,7 @@ parse_initial_message_line (struct MHD_Connection
> *connection,
> connection->client_aware = true;
> connection->client_context
> = daemon->uri_log_callback (daemon->uri_log_callback_cls,
> - curi,
> + curi,
> connection);
> }
> if (NULL != args)
> @@ -2247,10 +2247,10 @@ parse_initial_message_line (struct MHD_Connection
> *connection,
> args++;
> /* note that this call clobbers 'args' */
> MHD_parse_arguments_ (connection,
> - MHD_GET_ARGUMENT_KIND,
> - args,
> - &connection_add_header,
> - &unused_num_headers);
> + MHD_GET_ARGUMENT_KIND,
> + args,
> + &connection_add_header,
> + &unused_num_headers);
> }
> if (NULL != uri)
> daemon->unescape_callback (daemon->unescape_callback_cls,
> @@ -2279,17 +2279,17 @@ call_connection_handler (struct MHD_Connection
> *connection)
> connection->client_aware = true;
> if (MHD_NO ==
> connection->daemon->default_handler
> (connection->daemon->default_handler_cls,
> - connection,
> + connection,
> connection->url,
> - connection->method,
> - connection->version,
> - NULL,
> + connection->method,
> + connection->version,
> + NULL,
> &processed,
> - &connection->client_context))
> + &connection->client_context))
> {
> /* serious internal error, close connection */
> CONNECTION_CLOSE_ERROR (connection,
> - _("Application reported internal error, closing
> connection.\n"));
> + _("Application reported internal error, closing connection.\n"));
> return;
> }
> }
> @@ -2342,7 +2342,7 @@ process_request_body (struct MHD_Connection *connection)
> {
> /* malformed encoding */
> CONNECTION_CLOSE_ERROR (connection,
> - _("Received malformed HTTP request
> (bad chunked encoding). Closing connection.\n"));
> + _("Received malformed HTTP request (bad chunked encoding).
> Closing connection.\n"));
> return;
> }
> available -= i;
> @@ -2380,24 +2380,24 @@ process_request_body (struct MHD_Connection
> *connection)
> {
> if ( ('\r' == buffer_head[i]) ||
> ('\n' == buffer_head[i]) ||
> - (';' == buffer_head[i]) )
> + (';' == buffer_head[i]) )
> break;
> i++;
> if (i >= 16)
> break;
> }
> - end_size = i;
> - /* find beginning of CRLF (skip over chunk extensions) */
> - if (';' == buffer_head[i])
> - {
> - while (i < available)
> - {
> - if ( ('\r' == buffer_head[i]) ||
> - ('\n' == buffer_head[i]) )
> - break;
> - i++;
> - }
> - }
> + end_size = i;
> + /* find beginning of CRLF (skip over chunk extensions) */
> + if (';' == buffer_head[i])
> + {
> + while (i < available)
> + {
> + if ( ('\r' == buffer_head[i]) ||
> + ('\n' == buffer_head[i]) )
> + break;
> + i++;
> + }
> + }
> /* take '\n' into account; if '\n' is the unavailable
> character, we will need to wait until we have it
> before going further */
> @@ -2406,23 +2406,23 @@ process_request_body (struct MHD_Connection
> *connection)
> (2 == available) &&
> ('0' == buffer_head[0]) ) )
> break; /* need more data... */
> - i++;
> + i++;
> malformed = (end_size >= 16);
> if (! malformed)
> {
> size_t num_dig = MHD_strx_to_uint64_n_ (buffer_head,
> - end_size,
> -
> &connection->current_chunk_size);
> + end_size,
> + &connection->current_chunk_size);
> malformed = (end_size != num_dig);
> }
> if (malformed)
> {
> /* malformed encoding */
> CONNECTION_CLOSE_ERROR (connection,
> - _("Received malformed HTTP request
> (bad chunked encoding). Closing connection.\n"));
> + _("Received malformed HTTP request (bad chunked encoding).
> Closing connection.\n"));
> return;
> }
> - /* skip 2nd part of line feed */
> + /* skip 2nd part of line feed */
> if ( (i < available) &&
> ( ('\r' == buffer_head[i]) ||
> ('\n' == buffer_head[i]) ) )
> @@ -2446,19 +2446,19 @@ process_request_body (struct MHD_Connection
> *connection)
> {
> /* no chunked encoding, give all to the client */
> if ( (0 != connection->remaining_upload_size) &&
> - (MHD_SIZE_UNKNOWN != connection->remaining_upload_size) &&
> - (connection->remaining_upload_size < available) )
> - {
> + (MHD_SIZE_UNKNOWN != connection->remaining_upload_size) &&
> + (connection->remaining_upload_size < available) )
> + {
> to_be_processed = (size_t)connection->remaining_upload_size;
> - }
> + }
> else
> - {
> + {
> /**
> * 1. no chunked encoding, give all to the client
> * 2. client may send large chunked data, but only a smaller
> part is available at one time.
> */
> to_be_processed = available;
> - }
> + }
> }
> left_unprocessed = to_be_processed;
> connection->client_aware = true;
> @@ -2482,24 +2482,24 @@ process_request_body (struct MHD_Connection
> *connection)
> __FILE__,
> __LINE__
> #ifdef HAVE_MESSAGES
> - , _("libmicrohttpd API violation")
> + , _("libmicrohttpd API violation")
> #else
> - , NULL
> + , NULL
> #endif
> - );
> + );
> if (0 != left_unprocessed)
> - {
> - instant_retry = MHD_NO; /* client did not process everything */
> + {
> + instant_retry = MHD_NO; /* client did not process everything */
> #ifdef HAVE_MESSAGES
> - /* client did not process all upload data, complain if
> - the setup was incorrect, which may prevent us from
> - handling the rest of the request */
> - if ( (0 != (connection->daemon->options &
> MHD_USE_INTERNAL_POLLING_THREAD)) &&
> - (! connection->suspended) )
> - MHD_DLOG (connection->daemon,
> - _("WARNING: incomplete upload processing and connection
> not suspended may result in hung connection.\n"));
> + /* client did not process all upload data, complain if
> + the setup was incorrect, which may prevent us from
> + handling the rest of the request */
> + if ( (0 != (connection->daemon->options &
> MHD_USE_INTERNAL_POLLING_THREAD)) &&
> + (! connection->suspended) )
> + MHD_DLOG (connection->daemon,
> + _("WARNING: incomplete upload processing and connection not
> suspended may result in hung connection.\n"));
> #endif
> - }
> + }
> processed_size = to_be_processed - left_unprocessed;
> if (connection->have_chunked_upload)
> connection->current_chunk_offset += processed_size;
> @@ -2537,7 +2537,7 @@ check_write_done (struct MHD_Connection *connection,
> connection->write_buffer_send_offset = 0;
> connection->state = next_state;
> MHD_pool_reallocate (connection->pool,
> - connection->write_buffer,
> + connection->write_buffer,
> connection->write_buffer_size,
> 0);
> connection->write_buffer = NULL;
> @@ -2567,24 +2567,24 @@ process_header_line (struct MHD_Connection
> *connection,
> {
> /* error in header line, die hard */
> CONNECTION_CLOSE_ERROR (connection,
> - _("Received malformed line (no colon). Closing
> connection.\n"));
> + _("Received malformed line (no colon). Closing connection.\n"));
> return MHD_NO;
> }
> if (-1 >= connection->daemon->strict_for_client)
> {
> /* check for whitespace before colon, which is not allowed
> - by RFC 7230 section 3.2.4; we count space ' ' and
> - tab '\t', but not '\r\n' as those would have ended the line. */
> + by RFC 7230 section 3.2.4; we count space ' ' and
> + tab '\t', but not '\r\n' as those would have ended the line. */
> const char *white;
>
> white = strchr (line, ' ');
> if ( (NULL != white) &&
> - (white < colon) )
> - return MHD_NO;
> + (white < colon) )
> + return MHD_NO;
> white = strchr (line, '\t');
> if ( (NULL != white) &&
> - (white < colon) )
> - return MHD_NO;
> + (white < colon) )
> + return MHD_NO;
> }
> /* zero-terminate header */
> colon[0] = '\0';
> @@ -2638,14 +2638,14 @@ process_broken_line (struct MHD_Connection
> *connection,
> tmp++;
> tmp_len = strlen (tmp);
> /* FIXME: we might be able to do this better (faster!), as most
> - likely 'last' and 'line' should already be adjacent in
> - memory; however, doing this right gets tricky if we have a
> - value continued over multiple lines (in which case we need to
> - record how often we have done this so we can check for
> - adjacency); also, in the case where these are not adjacent
> - (not sure how it can happen!), we would want to allocate from
> - the end of the pool, so as to not destroy the read-buffer's
> - ability to grow nicely. */
> + likely 'last' and 'line' should already be adjacent in
> + memory; however, doing this right gets tricky if we have a
> + value continued over multiple lines (in which case we need to
> + record how often we have done this so we can check for
> + adjacency); also, in the case where these are not adjacent
> + (not sure how it can happen!), we would want to allocate from
> + the end of the pool, so as to not destroy the read-buffer's
> + ability to grow nicely. */
> last = MHD_pool_reallocate (connection->pool,
> last,
> last_len + 1,
> @@ -2665,8 +2665,8 @@ process_broken_line (struct MHD_Connection *connection,
> (NULL != connection->colon) );
> if ((MHD_NO == connection_add_header (connection,
> last,
> - connection->colon,
> - kind)))
> + connection->colon,
> + kind)))
> {
> transmit_error_response (connection,
> MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE,
> @@ -2724,8 +2724,8 @@ parse_connection_headers (struct MHD_Connection
> *connection)
> mhd_assert (NULL == connection->response);
> response =
> MHD_create_response_from_buffer (MHD_STATICSTR_LEN_
> (REQUEST_LACKS_HOST),
> - REQUEST_LACKS_HOST,
> - MHD_RESPMEM_PERSISTENT);
> + REQUEST_LACKS_HOST,
> + MHD_RESPMEM_PERSISTENT);
> MHD_queue_response (connection,
> MHD_HTTP_BAD_REQUEST,
> response);
> @@ -2735,8 +2735,8 @@ parse_connection_headers (struct MHD_Connection
> *connection)
>
> connection->remaining_upload_size = 0;
> enc = MHD_lookup_connection_value (connection,
> - MHD_HEADER_KIND,
> - MHD_HTTP_HEADER_TRANSFER_ENCODING);
> + MHD_HEADER_KIND,
> + MHD_HTTP_HEADER_TRANSFER_ENCODING);
> if (NULL != enc)
> {
> connection->remaining_upload_size = MHD_SIZE_UNKNOWN;
> @@ -2747,8 +2747,8 @@ parse_connection_headers (struct MHD_Connection
> *connection)
> else
> {
> clen = MHD_lookup_connection_value (connection,
> - MHD_HEADER_KIND,
> - MHD_HTTP_HEADER_CONTENT_LENGTH);
> + MHD_HEADER_KIND,
> + MHD_HTTP_HEADER_CONTENT_LENGTH);
> if (NULL != clen)
> {
> end = clen + MHD_str_to_uint64_ (clen,
> @@ -2761,7 +2761,7 @@ parse_connection_headers (struct MHD_Connection
> *connection)
> MHD_DLOG (connection->daemon,
> "Failed to parse `Content-Length' header. Closing
> connection.\n");
> #endif
> - CONNECTION_CLOSE_ERROR (connection,
> + CONNECTION_CLOSE_ERROR (connection,
> NULL);
> return;
> }
> @@ -2798,11 +2798,11 @@ MHD_update_last_activity_ (struct MHD_Connection
> *connection)
> MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
> /* move connection to head of timeout list (by remove + add operation) */
> XDLL_remove (daemon->normal_timeout_head,
> - daemon->normal_timeout_tail,
> - connection);
> + daemon->normal_timeout_tail,
> + connection);
> XDLL_insert (daemon->normal_timeout_head,
> - daemon->normal_timeout_tail,
> - connection);
> + daemon->normal_timeout_tail,
> + connection);
> MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
> }
>
> @@ -3201,8 +3201,8 @@ cleanup_connection (struct MHD_Connection *connection)
> connection);
> }
> DLL_insert (daemon->cleanup_head,
> - daemon->cleanup_tail,
> - connection);
> + daemon->cleanup_tail,
> + connection);
> connection->resuming = false;
> connection->in_idle = false;
> MHD_mutex_unlock_chk_(&daemon->cleanup_connection_mutex);
> @@ -3274,8 +3274,8 @@ MHD_connection_handle_idle (struct MHD_Connection
> *connection)
> continue;
> if (connection->read_closed)
> {
> - CONNECTION_CLOSE_ERROR (connection,
> - NULL);
> + CONNECTION_CLOSE_ERROR (connection,
> + NULL);
> continue;
> }
> break;
> @@ -3297,8 +3297,8 @@ MHD_connection_handle_idle (struct MHD_Connection
> *connection)
> continue;
> if (connection->read_closed)
> {
> - CONNECTION_CLOSE_ERROR (connection,
> - NULL);
> + CONNECTION_CLOSE_ERROR (connection,
> + NULL);
> continue;
> }
> break;
> @@ -3328,8 +3328,8 @@ MHD_connection_handle_idle (struct MHD_Connection
> *connection)
> continue;
> if (connection->read_closed)
> {
> - CONNECTION_CLOSE_ERROR (connection,
> - NULL);
> + CONNECTION_CLOSE_ERROR (connection,
> + NULL);
> continue;
> }
> break;
> @@ -3369,9 +3369,9 @@ MHD_connection_handle_idle (struct MHD_Connection
> *connection)
> break;
> }
> if ( (NULL != connection->response) &&
> - ( (MHD_str_equal_caseless_ (connection->method,
> + ( (MHD_str_equal_caseless_ (connection->method,
> MHD_HTTP_METHOD_POST)) ||
> - (MHD_str_equal_caseless_ (connection->method,
> + (MHD_str_equal_caseless_ (connection->method,
> MHD_HTTP_METHOD_PUT))) )
> {
> /* we refused (no upload allowed!) */
> @@ -3428,8 +3428,8 @@ MHD_connection_handle_idle (struct MHD_Connection
> *connection)
> continue;
> if (connection->read_closed)
> {
> - CONNECTION_CLOSE_ERROR (connection,
> - NULL);
> + CONNECTION_CLOSE_ERROR (connection,
> + NULL);
> continue;
> }
> break;
> @@ -3460,8 +3460,8 @@ MHD_connection_handle_idle (struct MHD_Connection
> *connection)
> continue;
> if (connection->read_closed)
> {
> - CONNECTION_CLOSE_ERROR (connection,
> - NULL);
> + CONNECTION_CLOSE_ERROR (connection,
> + NULL);
> continue;
> }
> break;
> @@ -3488,8 +3488,8 @@ MHD_connection_handle_idle (struct MHD_Connection
> *connection)
> if (MHD_NO == build_header_response (connection))
> {
> /* oops - close! */
> - CONNECTION_CLOSE_ERROR (connection,
> - _("Closing connection (failed to create
> response header)\n"));
> + CONNECTION_CLOSE_ERROR (connection,
> + _("Closing connection (failed to create response header)\n"));
> continue;
> }
> connection->state = MHD_CONNECTION_HEADERS_SENDING;
> @@ -3557,8 +3557,8 @@ MHD_connection_handle_idle (struct MHD_Connection
> *connection)
> }
> if (MHD_YES == try_ready_normal_body (connection))
> {
> - if (NULL != connection->response->crc)
> - MHD_mutex_unlock_chk_ (&connection->response->mutex);
> + if (NULL != connection->response->crc)
> + MHD_mutex_unlock_chk_ (&connection->response->mutex);
> connection->state = MHD_CONNECTION_NORMAL_BODY_READY;
> /* Buffering for flushable socket was already enabled*/
> if (MHD_NO == socket_flush_possible (connection))
> @@ -3599,8 +3599,8 @@ MHD_connection_handle_idle (struct MHD_Connection
> *connection)
> if (MHD_NO == build_header_response (connection))
> {
> /* oops - close! */
> - CONNECTION_CLOSE_ERROR (connection,
> - _("Closing connection (failed to create
> response header)\n"));
> + CONNECTION_CLOSE_ERROR (connection,
> + _("Closing connection (failed to create response header)\n"));
> continue;
> }
> if ( (! connection->have_chunked_upload) ||
> @@ -3614,15 +3614,15 @@ MHD_connection_handle_idle (struct MHD_Connection
> *connection)
> /* no default action */
> break;
> case MHD_CONNECTION_FOOTERS_SENT:
> - if (MHD_HTTP_PROCESSING == connection->responseCode)
> - {
> - /* After this type of response, we allow sending another! */
> - connection->state = MHD_CONNECTION_HEADERS_PROCESSED;
> - MHD_destroy_response (connection->response);
> - connection->response = NULL;
> - /* FIXME: maybe partially reset memory pool? */
> - continue;
> - }
> + if (MHD_HTTP_PROCESSING == connection->responseCode)
> + {
> + /* After this type of response, we allow sending another! */
> + connection->state = MHD_CONNECTION_HEADERS_PROCESSED;
> + MHD_destroy_response (connection->response);
> + connection->response = NULL;
> + /* FIXME: maybe partially reset memory pool? */
> + continue;
> + }
> if (MHD_NO != socket_flush_possible (connection))
> socket_start_no_buffering_flush (connection);
> else
> @@ -3634,10 +3634,10 @@ MHD_connection_handle_idle (struct MHD_Connection
> *connection)
> (connection->client_aware) )
> {
> connection->client_aware = false;
> - daemon->notify_completed (daemon->notify_completed_cls,
> - connection,
> - &connection->client_context,
> - MHD_REQUEST_TERMINATED_COMPLETED_OK);
> + daemon->notify_completed (daemon->notify_completed_cls,
> + connection,
> + &connection->client_context,
> + MHD_REQUEST_TERMINATED_COMPLETED_OK);
> }
> if ( (MHD_CONN_USE_KEEPALIVE != connection->keepalive) ||
> (connection->read_closed) )
> @@ -3672,12 +3672,12 @@ MHD_connection_handle_idle (struct MHD_Connection
> *connection)
> connection->read_buffer_size
> = connection->daemon->pool_size / 2;
> }
> - connection->client_aware = false;
> + connection->client_aware = false;
> connection->client_context = NULL;
> connection->continue_message_write_offset = 0;
> connection->responseCode = 0;
> connection->headers_received = NULL;
> - connection->headers_received_tail = NULL;
> + connection->headers_received_tail = NULL;
> connection->response_write_position = 0;
> connection->have_chunked_upload = false;
> connection->current_chunk_size = 0;
> @@ -3690,11 +3690,11 @@ MHD_connection_handle_idle (struct MHD_Connection
> *connection)
> connection->write_buffer_append_offset = 0;
> continue;
> case MHD_CONNECTION_CLOSED:
> - cleanup_connection (connection);
> + cleanup_connection (connection);
> connection->in_idle = false;
> - return MHD_NO;
> + return MHD_NO;
> #ifdef UPGRADE_SUPPORT
> - case MHD_CONNECTION_UPGRADE:
> + case MHD_CONNECTION_UPGRADE:
> connection->in_idle = false;
> return MHD_YES; /* keep open */
> #endif /* UPGRADE_SUPPORT */
> @@ -3750,8 +3750,8 @@ MHD_connection_epoll_update_ (struct MHD_Connection
> *connection)
> (0 == (connection->epoll_state & MHD_EPOLL_STATE_SUSPENDED)) &&
> ( ( (MHD_EVENT_LOOP_INFO_WRITE == connection->event_loop_info) &&
> (0 == (connection->epoll_state & MHD_EPOLL_STATE_WRITE_READY))) ||
> - ( (MHD_EVENT_LOOP_INFO_READ == connection->event_loop_info) &&
> - (0 == (connection->epoll_state & MHD_EPOLL_STATE_READ_READY)) ) ) )
> + ( (MHD_EVENT_LOOP_INFO_READ == connection->event_loop_info) &&
> + (0 == (connection->epoll_state & MHD_EPOLL_STATE_READ_READY)) ) ) )
> {
> /* add to epoll set */
> struct epoll_event event;
> @@ -3759,20 +3759,20 @@ MHD_connection_epoll_update_ (struct MHD_Connection
> *connection)
> event.events = EPOLLIN | EPOLLOUT | EPOLLPRI | EPOLLET;
> event.data.ptr = connection;
> if (0 != epoll_ctl (daemon->epoll_fd,
> - EPOLL_CTL_ADD,
> - connection->socket_fd,
> - &event))
> - {
> + EPOLL_CTL_ADD,
> + connection->socket_fd,
> + &event))
> + {
> #ifdef HAVE_MESSAGES
> - if (0 != (daemon->options & MHD_USE_ERROR_LOG))
> - MHD_DLOG (daemon,
> - _("Call to epoll_ctl failed: %s\n"),
> - MHD_socket_last_strerr_ ());
> + if (0 != (daemon->options & MHD_USE_ERROR_LOG))
> + MHD_DLOG (daemon,
> + _("Call to epoll_ctl failed: %s\n"),
> + MHD_socket_last_strerr_ ());
> #endif
> - connection->state = MHD_CONNECTION_CLOSED;
> - cleanup_connection (connection);
> - return MHD_NO;
> - }
> + connection->state = MHD_CONNECTION_CLOSED;
> + cleanup_connection (connection);
> + return MHD_NO;
> + }
> connection->epoll_state |= MHD_EPOLL_STATE_IN_EPOLL_SET;
> }
> return MHD_YES;
> @@ -3813,17 +3813,17 @@ MHD_get_connection_info (struct MHD_Connection
> *connection,
> #ifdef HTTPS_SUPPORT
> case MHD_CONNECTION_INFO_CIPHER_ALGO:
> if (NULL == connection->tls_session)
> - return NULL;
> + return NULL;
> connection->cipher = gnutls_cipher_get (connection->tls_session);
> return (const union MHD_ConnectionInfo *) &connection->cipher;
> case MHD_CONNECTION_INFO_PROTOCOL:
> if (NULL == connection->tls_session)
> - return NULL;
> + return NULL;
> connection->protocol = gnutls_protocol_get_version
> (connection->tls_session);
> return (const union MHD_ConnectionInfo *) &connection->protocol;
> case MHD_CONNECTION_INFO_GNUTLS_SESSION:
> if (NULL == connection->tls_session)
> - return NULL;
> + return NULL;
> return (const union MHD_ConnectionInfo *) &connection->tls_session;
> #endif /* HTTPS_SUPPORT */
> case MHD_CONNECTION_INFO_CLIENT_ADDRESS:
> @@ -3863,8 +3863,8 @@ MHD_get_connection_info (struct MHD_Connection
> *connection,
> */
> int
> MHD_set_connection_option (struct MHD_Connection *connection,
> - enum MHD_CONNECTION_OPTION option,
> - ...)
> + enum MHD_CONNECTION_OPTION option,
> + ...)
> {
> va_list ap;
> struct MHD_Daemon *daemon;
> @@ -3935,7 +3935,7 @@ MHD_queue_response (struct MHD_Connection *connection,
> (NULL == response) ||
> (NULL != connection->response) ||
> ( (MHD_CONNECTION_HEADERS_PROCESSED != connection->state) &&
> - (MHD_CONNECTION_FOOTERS_RECEIVED != connection->state) ) )
> + (MHD_CONNECTION_FOOTERS_RECEIVED != connection->state) ) )
> return MHD_NO;
> daemon = connection->daemon;
>
> @@ -4000,7 +4000,7 @@ MHD_queue_response (struct MHD_Connection *connection,
> (NULL != connection->method) &&
> ( (MHD_str_equal_caseless_ (connection->method,
> MHD_HTTP_METHOD_POST)) ||
> - (MHD_str_equal_caseless_ (connection->method,
> + (MHD_str_equal_caseless_ (connection->method,
> MHD_HTTP_METHOD_PUT))) )
> {
> /* response was queued "early", refuse to read body / footers or
> diff --git a/src/microhttpd/connection_https.c
> b/src/microhttpd/connection_https.c
> index 63623138..2d1f4844 100644
> --- a/src/microhttpd/connection_https.c
> +++ b/src/microhttpd/connection_https.c
> @@ -154,24 +154,24 @@ MHD_run_tls_handshake_ (struct MHD_Connection
> *connection)
> {
> ret = gnutls_handshake (connection->tls_session);
> if (ret == GNUTLS_E_SUCCESS)
> - {
> - /* set connection TLS state to enable HTTP processing */
> - connection->tls_state = MHD_TLS_CONN_CONNECTED;
> - MHD_update_last_activity_ (connection);
> - return true;
> - }
> + {
> + /* set connection TLS state to enable HTTP processing */
> + connection->tls_state = MHD_TLS_CONN_CONNECTED;
> + MHD_update_last_activity_ (connection);
> + return true;
> + }
> if ( (GNUTLS_E_AGAIN == ret) ||
> - (GNUTLS_E_INTERRUPTED == ret) )
> - {
> + (GNUTLS_E_INTERRUPTED == ret) )
> + {
> connection->tls_state = MHD_TLS_CONN_HANDSHAKING;
> - /* handshake not done */
> - return false;
> - }
> + /* handshake not done */
> + return false;
> + }
> /* handshake failed */
> connection->tls_state = MHD_TLS_CONN_TLS_FAILED;
> #ifdef HAVE_MESSAGES
> MHD_DLOG (connection->daemon,
> - _("Error: received handshake message out of context\n"));
> + _("Error: received handshake message out of context\n"));
> #endif
> MHD_connection_close_ (connection,
> MHD_REQUEST_TERMINATED_WITH_ERROR);
> diff --git a/src/microhttpd/daemon.c b/src/microhttpd/daemon.c
> index 56cd4538..e8e7e0e9 100644
> --- a/src/microhttpd/daemon.c
> +++ b/src/microhttpd/daemon.c
> @@ -111,7 +111,7 @@ close_all_connections (struct MHD_Daemon *daemon);
> */
> static int
> MHD_epoll (struct MHD_Daemon *daemon,
> - int may_block);
> + int may_block);
>
> #endif /* EPOLL_SUPPORT */
>
> @@ -126,15 +126,15 @@ MHD_epoll (struct MHD_Daemon *daemon,
> */
> static void
> mhd_panic_std (void *cls,
> - const char *file,
> - unsigned int line,
> - const char *reason)
> + const char *file,
> + unsigned int line,
> + const char *reason)
> {
> (void)cls; /* Mute compiler warning. */
> #ifdef HAVE_MESSAGES
> fprintf (stderr,
> _("Fatal error in GNU libmicrohttpd %s:%u: %s\n"),
> - file,
> + file,
> line,
> reason);
> #else /* ! HAVE_MESSAGES */
> @@ -309,8 +309,8 @@ MHD_ip_addr_compare (const void *a1,
> */
> static int
> MHD_ip_addr_to_key (const struct sockaddr *addr,
> - socklen_t addrlen,
> - struct MHD_IPCount *key)
> + socklen_t addrlen,
> + struct MHD_IPCount *key)
> {
> memset(key,
> 0,
> @@ -360,8 +360,8 @@ MHD_ip_addr_to_key (const struct sockaddr *addr,
> */
> static int
> MHD_ip_limit_add (struct MHD_Daemon *daemon,
> - const struct sockaddr *addr,
> - socklen_t addrlen)
> + const struct sockaddr *addr,
> + socklen_t addrlen)
> {
> struct MHD_IPCount *key;
> void **nodep;
> @@ -389,12 +389,12 @@ MHD_ip_limit_add (struct MHD_Daemon *daemon,
>
> /* Search for the IP address */
> if (NULL == (nodep = tsearch (key,
> - &daemon->per_ip_connection_count,
> - &MHD_ip_addr_compare)))
> + &daemon->per_ip_connection_count,
> + &MHD_ip_addr_compare)))
> {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> - _("Failed to add IP connection count node\n"));
> + _("Failed to add IP connection count node\n"));
> #endif
> MHD_ip_count_unlock (daemon);
> free (key);
> @@ -426,8 +426,8 @@ MHD_ip_limit_add (struct MHD_Daemon *daemon,
> */
> static void
> MHD_ip_limit_del (struct MHD_Daemon *daemon,
> - const struct sockaddr *addr,
> - socklen_t addrlen)
> + const struct sockaddr *addr,
> + socklen_t addrlen)
> {
> struct MHD_IPCount search_key;
> struct MHD_IPCount *found_key;
> @@ -447,8 +447,8 @@ MHD_ip_limit_del (struct MHD_Daemon *daemon,
>
> /* Search for the IP address */
> if (NULL == (nodep = tfind (&search_key,
> - &daemon->per_ip_connection_count,
> - &MHD_ip_addr_compare)))
> + &daemon->per_ip_connection_count,
> + &MHD_ip_addr_compare)))
> {
> /* Something's wrong if we couldn't find an IP address
> * that was previously added */
> @@ -464,8 +464,8 @@ MHD_ip_limit_del (struct MHD_Daemon *daemon,
> if (0 == --found_key->count)
> {
> tdelete (found_key,
> - &daemon->per_ip_connection_count,
> - &MHD_ip_addr_compare);
> + &daemon->per_ip_connection_count,
> + &MHD_ip_addr_compare);
> free (found_key);
> }
>
> @@ -500,14 +500,14 @@ MHD_init_daemon_certificate (struct MHD_Daemon *daemon)
> cert.size = strlen (daemon->https_mem_trust);
> if (gnutls_certificate_set_x509_trust_mem (daemon->x509_cred,
> &cert,
> - GNUTLS_X509_FMT_PEM) < 0)
> - {
> + GNUTLS_X509_FMT_PEM) < 0)
> + {
> #ifdef HAVE_MESSAGES
> - MHD_DLOG(daemon,
> - "Bad trust certificate format\n");
> + MHD_DLOG(daemon,
> + "Bad trust certificate format\n");
> #endif
> - return -1;
> - }
> + return -1;
> + }
> }
>
> if (daemon->have_dhparams)
> @@ -534,11 +534,11 @@ MHD_init_daemon_certificate (struct MHD_Daemon *daemon)
> 0);
> #else
> #ifdef HAVE_MESSAGES
> - MHD_DLOG (daemon,
> + MHD_DLOG (daemon,
> _("Failed to setup x509 certificate/key: pre 3.X.X version
> " \
> "of GnuTLS does not support setting key password"));
> #endif
> - return -1;
> + return -1;
> #endif
> }
> else
> @@ -629,8 +629,8 @@ int
> MHD_get_fdset (struct MHD_Daemon *daemon,
> fd_set *read_fd_set,
> fd_set *write_fd_set,
> - fd_set *except_fd_set,
> - MHD_socket *max_fd)
> + fd_set *except_fd_set,
> + MHD_socket *max_fd)
> {
> return MHD_get_fdset2 (daemon,
> read_fd_set,
> @@ -909,45 +909,45 @@ internal_get_fdset2 (struct MHD_Daemon *daemon,
> posn = pos->prev;
>
> switch (pos->event_loop_info)
> - {
> - case MHD_EVENT_LOOP_INFO_READ:
> - if (! MHD_add_to_fd_set_ (pos->socket_fd,
> + {
> + case MHD_EVENT_LOOP_INFO_READ:
> + if (! MHD_add_to_fd_set_ (pos->socket_fd,
> read_fd_set,
> max_fd,
> fd_setsize))
> - result = MHD_NO;
> + result = MHD_NO;
> #ifdef MHD_POSIX_SOCKETS
> MHD_add_to_fd_set_ (pos->socket_fd,
> except_fd_set,
> max_fd,
> fd_setsize);
> #endif /* MHD_POSIX_SOCKETS */
> - break;
> - case MHD_EVENT_LOOP_INFO_WRITE:
> - if (! MHD_add_to_fd_set_ (pos->socket_fd,
> + break;
> + case MHD_EVENT_LOOP_INFO_WRITE:
> + if (! MHD_add_to_fd_set_ (pos->socket_fd,
> write_fd_set,
> max_fd,
> fd_setsize))
> - result = MHD_NO;
> + result = MHD_NO;
> #ifdef MHD_POSIX_SOCKETS
> MHD_add_to_fd_set_ (pos->socket_fd,
> except_fd_set,
> max_fd,
> fd_setsize);
> #endif /* MHD_POSIX_SOCKETS */
> - break;
> - case MHD_EVENT_LOOP_INFO_BLOCK:
> - if ( (NULL == except_fd_set) ||
> - ! MHD_add_to_fd_set_ (pos->socket_fd,
> - except_fd_set,
> + break;
> + case MHD_EVENT_LOOP_INFO_BLOCK:
> + if ( (NULL == except_fd_set) ||
> + ! MHD_add_to_fd_set_ (pos->socket_fd,
> + except_fd_set,
> max_fd,
> fd_setsize))
> result = MHD_NO;
> - break;
> - case MHD_EVENT_LOOP_INFO_CLEANUP:
> - /* this should never happen */
> - break;
> - }
> + break;
> + case MHD_EVENT_LOOP_INFO_CLEANUP:
> + /* this should never happen */
> + break;
> + }
> }
> #ifdef MHD_WINSOCK_SOCKETS
> /* W32 use limited array for fd_set so add INFO_READ/INFO_WRITE sockets
> @@ -1068,11 +1068,11 @@ MHD_get_fdset2 (struct MHD_Daemon *daemon,
> #endif
>
> return internal_get_fdset2 (daemon,
> - read_fd_set,
> + read_fd_set,
> write_fd_set,
> - except_fd_set,
> + except_fd_set,
> max_fd,
> - fd_setsize);
> + fd_setsize);
> }
>
>
> @@ -1107,7 +1107,7 @@ call_handlers (struct MHD_Connection *con,
> if (!force_close)
> {
> if ( (MHD_EVENT_LOOP_INFO_READ == con->event_loop_info) &&
> - read_ready)
> + read_ready)
> {
> MHD_connection_handle_read (con);
> ret = MHD_connection_handle_idle (con);
> @@ -1116,7 +1116,7 @@ call_handlers (struct MHD_Connection *con,
> /* No need to check value of 'ret' here as closed connection
> * cannot be in MHD_EVENT_LOOP_INFO_WRITE state. */
> if ( (MHD_EVENT_LOOP_INFO_WRITE == con->event_loop_info) &&
> - write_ready)
> + write_ready)
> {
> MHD_connection_handle_write (con);
> ret = MHD_connection_handle_idle (con);
> @@ -1763,7 +1763,7 @@ thread_main_handle_connection (void *data)
> MHD_thread_init_(&(con->pid));
>
> while ( (! daemon->shutdown) &&
> - (MHD_CONNECTION_CLOSED != con->state) )
> + (MHD_CONNECTION_CLOSED != con->state) )
> {
> const time_t timeout = daemon->connection_timeout;
> #ifdef UPGRADE_SUPPORT
> @@ -1851,19 +1851,19 @@ thread_main_handle_connection (void *data)
> (MHD_EVENT_LOOP_INFO_READ == con->event_loop_info) )
> #endif /* HTTPS_SUPPORT */
> )
> - {
> - /* do not block: more data may be inside of TLS buffers waiting or
> - * application must provide response data */
> - tv.tv_sec = 0;
> - tv.tv_usec = 0;
> - tvp = &tv;
> - }
> + {
> + /* do not block: more data may be inside of TLS buffers waiting or
> + * application must provide response data */
> + tv.tv_sec = 0;
> + tv.tv_usec = 0;
> + tvp = &tv;
> + }
> if ( (NULL == tvp) &&
> (timeout > 0) )
> - {
> - now = MHD_monotonic_sec_counter();
> - if (now - con->last_activity > timeout)
> - tv.tv_sec = 0;
> + {
> + now = MHD_monotonic_sec_counter();
> + if (now - con->last_activity > timeout)
> + tv.tv_sec = 0;
> else
> {
> const time_t seconds_left = timeout - (now -
> con->last_activity);
> @@ -1876,45 +1876,45 @@ thread_main_handle_connection (void *data)
> tv.tv_sec = (_MHD_TIMEVAL_TV_SEC_TYPE) seconds_left;
> #endif /* _WIN32 && ! __CYGWIN__ */
> }
> - tv.tv_usec = 0;
> - tvp = &tv;
> - }
> + tv.tv_usec = 0;
> + tvp = &tv;
> + }
> if (! use_poll)
> - {
> - /* use select */
> - bool err_state = false;
> + {
> + /* use select */
> + bool err_state = false;
>
> - FD_ZERO (&rs);
> - FD_ZERO (&ws);
> + FD_ZERO (&rs);
> + FD_ZERO (&ws);
> FD_ZERO (&es);
> - maxsock = MHD_INVALID_SOCKET;
> - switch (con->event_loop_info)
> - {
> - case MHD_EVENT_LOOP_INFO_READ:
> - if (! MHD_add_to_fd_set_ (con->socket_fd,
> + maxsock = MHD_INVALID_SOCKET;
> + switch (con->event_loop_info)
> + {
> + case MHD_EVENT_LOOP_INFO_READ:
> + if (! MHD_add_to_fd_set_ (con->socket_fd,
> &rs,
> &maxsock,
> FD_SETSIZE))
> - err_state = true;
> - break;
> - case MHD_EVENT_LOOP_INFO_WRITE:
> - if (! MHD_add_to_fd_set_ (con->socket_fd,
> + err_state = true;
> + break;
> + case MHD_EVENT_LOOP_INFO_WRITE:
> + if (! MHD_add_to_fd_set_ (con->socket_fd,
> &ws,
> &maxsock,
> FD_SETSIZE))
> err_state = true;
> - break;
> - case MHD_EVENT_LOOP_INFO_BLOCK:
> - if (! MHD_add_to_fd_set_ (con->socket_fd,
> + break;
> + case MHD_EVENT_LOOP_INFO_BLOCK:
> + if (! MHD_add_to_fd_set_ (con->socket_fd,
> &es,
> &maxsock,
> FD_SETSIZE))
> - err_state = true;
> - break;
> - case MHD_EVENT_LOOP_INFO_CLEANUP:
> - /* how did we get here!? */
> - goto exit;
> - }
> + err_state = true;
> + break;
> + case MHD_EVENT_LOOP_INFO_CLEANUP:
> + /* how did we get here!? */
> + goto exit;
> + }
> #if WINDOWS
> if (MHD_ITC_IS_VALID_(daemon->itc) )
> {
> @@ -1934,25 +1934,25 @@ thread_main_handle_connection (void *data)
> goto exit;
> }
>
> - num_ready = MHD_SYS_select_ (maxsock + 1,
> + num_ready = MHD_SYS_select_ (maxsock + 1,
> &rs,
> &ws,
> NULL,
> tvp);
> - if (num_ready < 0)
> - {
> - const int err = MHD_socket_get_error_();
> + if (num_ready < 0)
> + {
> + const int err = MHD_socket_get_error_();
>
> - if (MHD_SCKT_ERR_IS_EINTR_(err))
> - continue;
> + if (MHD_SCKT_ERR_IS_EINTR_(err))
> + continue;
> #ifdef HAVE_MESSAGES
> - MHD_DLOG (con->daemon,
> - _("Error during select (%d): `%s'\n"),
> - err,
> - MHD_socket_strerr_ (err));
> + MHD_DLOG (con->daemon,
> + _("Error during select (%d): `%s'\n"),
> + err,
> + MHD_socket_strerr_ (err));
> #endif
> - break;
> - }
> + break;
> + }
> #if WINDOWS
> /* Clear ITC before other processing so additional
> * signals will trigger select() again */
> @@ -1970,30 +1970,30 @@ thread_main_handle_connection (void *data)
> FD_ISSET (con->socket_fd,
> &es)) )
> goto exit;
> - }
> + }
> #ifdef HAVE_POLL
> else
> - {
> - /* use poll */
> - memset (&p,
> + {
> + /* use poll */
> + memset (&p,
> 0,
> sizeof (p));
> - p[0].fd = con->socket_fd;
> - switch (con->event_loop_info)
> - {
> - case MHD_EVENT_LOOP_INFO_READ:
> - p[0].events |= POLLIN | MHD_POLL_EVENTS_ERR_DISC;
> - break;
> - case MHD_EVENT_LOOP_INFO_WRITE:
> - p[0].events |= POLLOUT | MHD_POLL_EVENTS_ERR_DISC;
> - break;
> - case MHD_EVENT_LOOP_INFO_BLOCK:
> - p[0].events |= MHD_POLL_EVENTS_ERR_DISC;
> - break;
> - case MHD_EVENT_LOOP_INFO_CLEANUP:
> - /* how did we get here!? */
> - goto exit;
> - }
> + p[0].fd = con->socket_fd;
> + switch (con->event_loop_info)
> + {
> + case MHD_EVENT_LOOP_INFO_READ:
> + p[0].events |= POLLIN | MHD_POLL_EVENTS_ERR_DISC;
> + break;
> + case MHD_EVENT_LOOP_INFO_WRITE:
> + p[0].events |= POLLOUT | MHD_POLL_EVENTS_ERR_DISC;
> + break;
> + case MHD_EVENT_LOOP_INFO_BLOCK:
> + p[0].events |= MHD_POLL_EVENTS_ERR_DISC;
> + break;
> + case MHD_EVENT_LOOP_INFO_CLEANUP:
> + /* how did we get here!? */
> + goto exit;
> + }
> #if WINDOWS
> extra_slot = 0;
> if (MHD_ITC_IS_VALID_(daemon->itc))
> @@ -2004,23 +2004,23 @@ thread_main_handle_connection (void *data)
> extra_slot = 1;
> }
> #endif
> - if (MHD_sys_poll_ (p,
> + if (MHD_sys_poll_ (p,
> #if WINDOWS
> 1 + extra_slot,
> #else
> 1,
> #endif
> (NULL == tvp) ? -1 : tv.tv_sec * 1000) < 0)
> - {
> - if (MHD_SCKT_LAST_ERR_IS_(MHD_SCKT_EINTR_))
> - continue;
> + {
> + if (MHD_SCKT_LAST_ERR_IS_(MHD_SCKT_EINTR_))
> + continue;
> #ifdef HAVE_MESSAGES
> - MHD_DLOG (con->daemon,
> + MHD_DLOG (con->daemon,
> _("Error during poll: `%s'\n"),
> - MHD_socket_last_strerr_ ());
> + MHD_socket_last_strerr_ ());
> #endif
> - break;
> - }
> + break;
> + }
> #if WINDOWS
> /* Clear ITC before other processing so additional
> * signals will trigger poll() again */
> @@ -2034,7 +2034,7 @@ thread_main_handle_connection (void *data)
> 0 != (p[0].revents & POLLOUT),
> 0 != (p[0].revents & (POLLERR |
> MHD_POLL_REVENTS_ERR_DISC))))
> goto exit;
> - }
> + }
> #endif
> #ifdef UPGRADE_SUPPORT
> if (MHD_CONNECTION_UPGRADE == con->state)
> @@ -2074,7 +2074,7 @@ thread_main_handle_connection (void *data)
> #endif
> #endif
> if (MHD_CONNECTION_CLOSED != con->state)
> - MHD_connection_close_ (con,
> + MHD_connection_close_ (con,
> (daemon->shutdown) ?
> MHD_REQUEST_TERMINATED_DAEMON_SHUTDOWN:
> MHD_REQUEST_TERMINATED_WITH_ERROR);
> @@ -2166,11 +2166,11 @@ MHD_tls_push_func_(gnutls_transport_ptr_t trnsp,
> */
> static int
> internal_add_connection (struct MHD_Daemon *daemon,
> - MHD_socket client_socket,
> - const struct sockaddr *addr,
> - socklen_t addrlen,
> - bool external_add,
> - bool non_blck)
> + MHD_socket client_socket,
> + const struct sockaddr *addr,
> + socklen_t addrlen,
> + bool external_add,
> + bool non_blck)
> {
> struct MHD_Connection *connection;
> unsigned int i;
> @@ -2181,8 +2181,8 @@ internal_add_connection (struct MHD_Daemon *daemon,
> if ((external_add) && (NULL != daemon->worker_pool))
> {
> /* have a pool, try to find a pool with capacity; we use the
> - socket as the initial offset into the pool for load
> - balancing */
> + socket as the initial offset into the pool for load
> + balancing */
> for (i = 0; i < daemon->worker_pool_size; ++i)
> {
> struct MHD_Daemon * const worker =
> @@ -2209,9 +2209,9 @@ internal_add_connection (struct MHD_Daemon *daemon,
> {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> - _("Socket descriptor larger than FD_SETSIZE: %d > %d\n"),
> - (int) client_socket,
> - (int) FD_SETSIZE);
> + _("Socket descriptor larger than FD_SETSIZE: %d > %d\n"),
> + (int) client_socket,
> + (int) FD_SETSIZE);
> #endif
> MHD_socket_close_chk_ (client_socket);
> #if EINVAL
> @@ -2266,7 +2266,7 @@ internal_add_connection (struct MHD_Daemon *daemon,
> /* apply connection acceptance policy if present */
> if ( (NULL != daemon->apc) &&
> (MHD_NO == daemon->apc (daemon->apc_cls,
> - addr,
> + addr,
> addrlen)) )
> {
> #if DEBUG_CLOSE
> @@ -2290,8 +2290,8 @@ internal_add_connection (struct MHD_Daemon *daemon,
> eno = errno;
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> - "Error allocating memory: %s\n",
> - MHD_strerror_ (errno));
> + "Error allocating memory: %s\n",
> + MHD_strerror_ (errno));
> #endif
> MHD_socket_close_chk_ (client_socket);
> MHD_ip_limit_del (daemon,
> @@ -2305,8 +2305,8 @@ internal_add_connection (struct MHD_Daemon *daemon,
> {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> - _("Error allocating memory: %s\n"),
> - MHD_strerror_ (errno));
> + _("Error allocating memory: %s\n"),
> + MHD_strerror_ (errno));
> #endif
> MHD_socket_close_chk_ (client_socket);
> MHD_ip_limit_del (daemon,
> @@ -2325,8 +2325,8 @@ internal_add_connection (struct MHD_Daemon *daemon,
> eno = errno;
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> - _("Error allocating memory: %s\n"),
> - MHD_strerror_ (errno));
> + _("Error allocating memory: %s\n"),
> + MHD_strerror_ (errno));
> #endif
> MHD_socket_close_chk_ (client_socket);
> MHD_ip_limit_del (daemon,
> @@ -2366,14 +2366,14 @@ internal_add_connection (struct MHD_Daemon *daemon,
> #endif /* GNUTLS_VERSION_MAJOR >= 3*/
> );
> gnutls_priority_set (connection->tls_session,
> - daemon->priority_cache);
> + daemon->priority_cache);
> switch (daemon->cred_type)
> {
> /* set needed credentials for certificate authentication. */
> case GNUTLS_CRD_CERTIFICATE:
> gnutls_credentials_set (connection->tls_session,
> - GNUTLS_CRD_CERTIFICATE,
> - daemon->x509_cred);
> + GNUTLS_CRD_CERTIFICATE,
> + daemon->x509_cred);
> break;
> default:
> #ifdef HAVE_MESSAGES
> @@ -2389,9 +2389,9 @@ internal_add_connection (struct MHD_Daemon *daemon,
> free (connection);
> MHD_PANIC (_("Unknown credential type"));
> #if EINVAL
> - errno = EINVAL;
> + errno = EINVAL;
> #endif
> - return MHD_NO;
> + return MHD_NO;
> }
> #if (GNUTLS_VERSION_NUMBER+0 >= 0x030109) && !defined(_WIN64)
> gnutls_transport_set_int (connection->tls_session,
> (int)(client_socket));
> @@ -2402,8 +2402,8 @@ internal_add_connection (struct MHD_Daemon *daemon,
> gnutls_transport_set_push_function (connection->tls_session,
> MHD_tls_push_func_);
> #endif /* MHD_TLSLIB_NEED_PUSH_FUNC */
> if (daemon->https_mem_trust)
> - gnutls_certificate_server_set_request (connection->tls_session,
> - GNUTLS_CERT_REQUEST);
> + gnutls_certificate_server_set_request (connection->tls_session,
> + GNUTLS_CERT_REQUEST);
> #else /* ! HTTPS_SUPPORT */
> eno = EINVAL;
> goto cleanup;
> @@ -2434,8 +2434,8 @@ internal_add_connection (struct MHD_Daemon *daemon,
> connection);
> }
> DLL_insert (daemon->connections_head,
> - daemon->connections_tail,
> - connection);
> + daemon->connections_tail,
> + connection);
> MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
>
> if (NULL != daemon->notify_connection)
> @@ -2453,13 +2453,13 @@ internal_add_connection (struct MHD_Daemon *daemon,
> &thread_main_handle_connection,
> connection))
> {
> - eno = errno;
> + eno = errno;
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> "Failed to create a thread: %s\n",
> MHD_strerror_ (eno));
> #endif
> - goto cleanup;
> + goto cleanup;
> }
> }
> else
> @@ -2468,34 +2468,34 @@ internal_add_connection (struct MHD_Daemon *daemon,
> if (0 != (daemon->options & MHD_USE_EPOLL))
> {
> if ((0 == (daemon->options & MHD_USE_TURBO)) || (external_add))
> - { /* Do not manipulate EReady DL-list in 'external_add' mode. */
> - struct epoll_event event;
> -
> - event.events = EPOLLIN | EPOLLOUT | EPOLLPRI | EPOLLET;
> - event.data.ptr = connection;
> - if (0 != epoll_ctl (daemon->epoll_fd,
> - EPOLL_CTL_ADD,
> - client_socket,
> - &event))
> - {
> - eno = errno;
> + { /* Do not manipulate EReady DL-list in 'external_add' mode. */
> + struct epoll_event event;
> +
> + event.events = EPOLLIN | EPOLLOUT | EPOLLPRI | EPOLLET;
> + event.data.ptr = connection;
> + if (0 != epoll_ctl (daemon->epoll_fd,
> + EPOLL_CTL_ADD,
> + client_socket,
> + &event))
> + {
> + eno = errno;
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> _("Call to epoll_ctl failed: %s\n"),
> MHD_socket_last_strerr_ ());
> #endif
> - goto cleanup;
> - }
> - connection->epoll_state |= MHD_EPOLL_STATE_IN_EPOLL_SET;
> - }
> + goto cleanup;
> + }
> + connection->epoll_state |= MHD_EPOLL_STATE_IN_EPOLL_SET;
> + }
> else
> - {
> - connection->epoll_state |= MHD_EPOLL_STATE_READ_READY |
> MHD_EPOLL_STATE_WRITE_READY
> - | MHD_EPOLL_STATE_IN_EREADY_EDLL;
> - EDLL_insert (daemon->eready_head,
> - daemon->eready_tail,
> - connection);
> - }
> + {
> + connection->epoll_state |= MHD_EPOLL_STATE_READ_READY |
> MHD_EPOLL_STATE_WRITE_READY
> + | MHD_EPOLL_STATE_IN_EREADY_EDLL;
> + EDLL_insert (daemon->eready_head,
> + daemon->eready_tail,
> + connection);
> + }
> }
> else /* This 'else' is combined with next 'if'. */
> #endif
> @@ -2532,8 +2532,8 @@ internal_add_connection (struct MHD_Daemon *daemon,
> connection);
> }
> DLL_remove (daemon->connections_head,
> - daemon->connections_tail,
> - connection);
> + daemon->connections_tail,
> + connection);
> MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
> MHD_pool_destroy (connection->pool);
> free (connection->addr);
> @@ -2804,12 +2804,12 @@ resume_suspended_connections (struct MHD_Daemon
> *daemon)
> { /* Wake up suspended connections. */
> if (! MHD_itc_activate_(daemon->itc,
> "w"))
> - {
> + {
> #ifdef HAVE_MESSAGES
> - MHD_DLOG (daemon,
> - _("Failed to signal resume of connection via inter-thread
> communication channel."));
> + MHD_DLOG (daemon,
> + _("Failed to signal resume of connection via inter-thread
> communication channel."));
> #endif
> - }
> + }
> }
> return ret;
> }
> @@ -2844,9 +2844,9 @@ resume_suspended_connections (struct MHD_Daemon *daemon)
> */
> int
> MHD_add_connection (struct MHD_Daemon *daemon,
> - MHD_socket client_socket,
> - const struct sockaddr *addr,
> - socklen_t addrlen)
> + MHD_socket client_socket,
> + const struct sockaddr *addr,
> + socklen_t addrlen)
> {
> bool sk_nonbl;
> if (! MHD_socket_nonblocking_ (client_socket))
> @@ -2870,11 +2870,11 @@ MHD_add_connection (struct MHD_Daemon *daemon,
> #endif
> }
> return internal_add_connection (daemon,
> - client_socket,
> - addr,
> + client_socket,
> + addr,
> addrlen,
> - true,
> - sk_nonbl);
> + true,
> + sk_nonbl);
> }
>
>
> @@ -2939,8 +2939,8 @@ MHD_accept_connection (struct MHD_Daemon *daemon)
> #ifdef HAVE_MESSAGES
> if (! MHD_SCKT_ERR_IS_EAGAIN_ (err) )
> MHD_DLOG (daemon,
> - _("Error accepting connection: %s\n"),
> - MHD_socket_strerr_(err));
> + _("Error accepting connection: %s\n"),
> + MHD_socket_strerr_(err));
> #endif
> if (MHD_INVALID_SOCKET != s)
> {
> @@ -3003,9 +3003,9 @@ MHD_accept_connection (struct MHD_Daemon *daemon)
> #endif
> (void) internal_add_connection (daemon,
> s,
> - addr,
> + addr,
> addrlen,
> - false,
> + false,
> sk_nonbl);
> return MHD_YES;
> }
> @@ -3029,12 +3029,12 @@ MHD_cleanup_connections (struct MHD_Daemon *daemon)
> while (NULL != (pos = daemon->cleanup_tail))
> {
> DLL_remove (daemon->cleanup_head,
> - daemon->cleanup_tail,
> - pos);
> + daemon->cleanup_tail,
> + pos);
> MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
>
> if ( (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
> - (! pos->thread_joined) &&
> + (! pos->thread_joined) &&
> (! MHD_join_thread_ (pos->pid.handle)) )
> MHD_PANIC (_("Failed to join a thread\n"));
> #ifdef UPGRADE_SUPPORT
> @@ -3043,7 +3043,7 @@ MHD_cleanup_connections (struct MHD_Daemon *daemon)
> MHD_pool_destroy (pos->pool);
> #ifdef HTTPS_SUPPORT
> if (NULL != pos->tls_session)
> - gnutls_deinit (pos->tls_session);
> + gnutls_deinit (pos->tls_session);
> #endif /* HTTPS_SUPPORT */
>
> /* clean up the connection */
> @@ -3084,14 +3084,14 @@ MHD_cleanup_connections (struct MHD_Daemon *daemon)
> }
> #endif
> if (NULL != pos->response)
> - {
> - MHD_destroy_response (pos->response);
> - pos->response = NULL;
> - }
> + {
> + MHD_destroy_response (pos->response);
> + pos->response = NULL;
> + }
> if (MHD_INVALID_SOCKET != pos->socket_fd)
> MHD_socket_close_chk_ (pos->socket_fd);
> if (NULL != pos->addr)
> - free (pos->addr);
> + free (pos->addr);
> free (pos);
>
> MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
> @@ -3124,7 +3124,7 @@ MHD_cleanup_connections (struct MHD_Daemon *daemon)
> */
> int
> MHD_get_timeout (struct MHD_Daemon *daemon,
> - MHD_UNSIGNED_LONG_LONG *timeout)
> + MHD_UNSIGNED_LONG_LONG *timeout)
> {
> time_t earliest_deadline;
> time_t now;
> @@ -3151,11 +3151,11 @@ MHD_get_timeout (struct MHD_Daemon *daemon,
> if ( (0 != (daemon->options & MHD_USE_EPOLL)) &&
> ((NULL != daemon->eready_head)
> #if defined(UPGRADE_SUPPORT) && defined(HTTPS_SUPPORT)
> - || (NULL != daemon->eready_urh_head)
> + || (NULL != daemon->eready_urh_head)
> #endif /* UPGRADE_SUPPORT && HTTPS_SUPPORT */
> - ) )
> + ) )
> {
> - /* Some connection(s) already have some data pending. */
> + /* Some connection(s) already have some data pending. */
> *timeout = 0;
> return MHD_YES;
> }
> @@ -3166,12 +3166,12 @@ MHD_get_timeout (struct MHD_Daemon *daemon,
> for (pos = daemon->manual_timeout_tail; NULL != pos; pos = pos->prevX)
> {
> if (0 != pos->connection_timeout)
> - {
> - if ( (! have_timeout) ||
> - (earliest_deadline - pos->last_activity >
> pos->connection_timeout) )
> - earliest_deadline = pos->last_activity + pos->connection_timeout;
> - have_timeout = true;
> - }
> + {
> + if ( (! have_timeout) ||
> + (earliest_deadline - pos->last_activity > pos->connection_timeout) )
> + earliest_deadline = pos->last_activity + pos->connection_timeout;
> + have_timeout = true;
> + }
> }
> /* normal timeouts are sorted, so we only need to look at the 'tail'
> (oldest) */
> pos = daemon->normal_timeout_tail;
> @@ -3179,8 +3179,8 @@ MHD_get_timeout (struct MHD_Daemon *daemon,
> (0 != pos->connection_timeout) )
> {
> if ( (! have_timeout) ||
> - (earliest_deadline - pos->connection_timeout > pos->last_activity) )
> - earliest_deadline = pos->last_activity + pos->connection_timeout;
> + (earliest_deadline - pos->connection_timeout > pos->last_activity) )
> + earliest_deadline = pos->last_activity + pos->connection_timeout;
> have_timeout = true;
> }
>
> @@ -3249,10 +3249,10 @@ internal_run_from_select (struct MHD_Daemon *daemon,
> prev = daemon->connections_tail;
> while (NULL != (pos = prev))
> {
> - prev = pos->prev;
> + prev = pos->prev;
> ds = pos->socket_fd;
> if (MHD_INVALID_SOCKET == ds)
> - continue;
> + continue;
> call_handlers (pos,
> FD_ISSET (ds,
> read_fd_set),
> @@ -3368,7 +3368,7 @@ MHD_run_from_select (struct MHD_Daemon *daemon,
> */
> static int
> MHD_select (struct MHD_Daemon *daemon,
> - int may_block)
> + int may_block)
> {
> int num_ready;
> fd_set rs;
> @@ -3485,7 +3485,7 @@ MHD_select (struct MHD_Daemon *daemon,
> tv = &timeout;
> }
> else if ( (0 == (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
> - (MHD_YES == MHD_get_timeout (daemon, <imeout)) )
> + (MHD_YES == MHD_get_timeout (daemon, <imeout)) )
> {
> /* ltimeout is in ms */
> timeout.tv_usec = (ltimeout % 1000) * 1000;
> @@ -3534,7 +3534,7 @@ MHD_select (struct MHD_Daemon *daemon,
> */
> static int
> MHD_poll_all (struct MHD_Daemon *daemon,
> - int may_block)
> + int may_block)
> {
> unsigned int num_connections;
> struct MHD_Connection *pos;
> @@ -3580,29 +3580,29 @@ MHD_poll_all (struct MHD_Daemon *daemon,
> poll_listen = -1;
> if ( (MHD_INVALID_SOCKET != (ls = daemon->listen_fd)) &&
> (! daemon->was_quiesced) &&
> - (daemon->connections < daemon->connection_limit) &&
> + (daemon->connections < daemon->connection_limit) &&
> (! daemon->at_limit) )
> {
> - /* only listen if we are not at the connection limit */
> - p[poll_server].fd = ls;
> - p[poll_server].events = POLLIN;
> - p[poll_server].revents = 0;
> - poll_listen = (int) poll_server;
> - poll_server++;
> + /* only listen if we are not at the connection limit */
> + p[poll_server].fd = ls;
> + p[poll_server].events = POLLIN;
> + p[poll_server].revents = 0;
> + poll_listen = (int) poll_server;
> + poll_server++;
> }
> poll_itc_idx = -1;
> if (MHD_ITC_IS_VALID_(daemon->itc))
> {
> - p[poll_server].fd = MHD_itc_r_fd_ (daemon->itc);
> - p[poll_server].events = POLLIN;
> - p[poll_server].revents = 0;
> + p[poll_server].fd = MHD_itc_r_fd_ (daemon->itc);
> + p[poll_server].events = POLLIN;
> + p[poll_server].revents = 0;
> poll_itc_idx = (int) poll_server;
> - poll_server++;
> + poll_server++;
> }
> if (may_block == MHD_NO)
> timeout = 0;
> else if ( (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) ||
> - (MHD_YES != MHD_get_timeout (daemon,
> + (MHD_YES != MHD_get_timeout (daemon,
> <imeout)) )
> timeout = -1;
> else
> @@ -3611,23 +3611,23 @@ MHD_poll_all (struct MHD_Daemon *daemon,
> i = 0;
> for (pos = daemon->connections_tail; NULL != pos; pos = pos->prev)
> {
> - p[poll_server+i].fd = pos->socket_fd;
> - switch (pos->event_loop_info)
> - {
> - case MHD_EVENT_LOOP_INFO_READ:
> - p[poll_server+i].events |= POLLIN | MHD_POLL_EVENTS_ERR_DISC;
> - break;
> - case MHD_EVENT_LOOP_INFO_WRITE:
> - p[poll_server+i].events |= POLLOUT | MHD_POLL_EVENTS_ERR_DISC;
> - break;
> - case MHD_EVENT_LOOP_INFO_BLOCK:
> - p[poll_server+i].events |= MHD_POLL_EVENTS_ERR_DISC;
> - break;
> - case MHD_EVENT_LOOP_INFO_CLEANUP:
> - timeout = 0; /* clean up "pos" immediately */
> - break;
> - }
> - i++;
> + p[poll_server+i].fd = pos->socket_fd;
> + switch (pos->event_loop_info)
> + {
> + case MHD_EVENT_LOOP_INFO_READ:
> + p[poll_server+i].events |= POLLIN | MHD_POLL_EVENTS_ERR_DISC;
> + break;
> + case MHD_EVENT_LOOP_INFO_WRITE:
> + p[poll_server+i].events |= POLLOUT | MHD_POLL_EVENTS_ERR_DISC;
> + break;
> + case MHD_EVENT_LOOP_INFO_BLOCK:
> + p[poll_server+i].events |= MHD_POLL_EVENTS_ERR_DISC;
> + break;
> + case MHD_EVENT_LOOP_INFO_CLEANUP:
> + timeout = 0; /* clean up "pos" immediately */
> + break;
> + }
> + i++;
> }
> #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
> for (urh = daemon->urh_tail; NULL != urh; urh = urh->prev)
> @@ -3646,18 +3646,18 @@ MHD_poll_all (struct MHD_Daemon *daemon,
> timeout) < 0)
> {
> const int err = MHD_socket_get_error_ ();
> - if (MHD_SCKT_ERR_IS_EINTR_ (err))
> + if (MHD_SCKT_ERR_IS_EINTR_ (err))
> {
> free(p);
> return MHD_YES;
> }
> #ifdef HAVE_MESSAGES
> - MHD_DLOG (daemon,
> - _("poll failed: %s\n"),
> - MHD_socket_strerr_ (err));
> + MHD_DLOG (daemon,
> + _("poll failed: %s\n"),
> + MHD_socket_strerr_ (err));
> #endif
> free(p);
> - return MHD_NO;
> + return MHD_NO;
> }
>
> /* Reset. New value will be set when connections are processed. */
> @@ -3680,7 +3680,7 @@ MHD_poll_all (struct MHD_Daemon *daemon,
> prev = daemon->connections_tail;
> while (NULL != (pos = prev))
> {
> - prev = pos->prev;
> + prev = pos->prev;
> /* first, sanity checks */
> if (i >= num_connections)
> break; /* connection list changed somehow, retry later ... */
> @@ -3728,7 +3728,7 @@ MHD_poll_all (struct MHD_Daemon *daemon,
> #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
> /* handle 'listen' FD */
> if ( (-1 != poll_listen) &&
> - (0 != (p[poll_listen].revents & POLLIN)) )
> + (0 != (p[poll_listen].revents & POLLIN)) )
> (void) MHD_accept_connection (daemon);
>
> free(p);
> @@ -3746,7 +3746,7 @@ MHD_poll_all (struct MHD_Daemon *daemon,
> */
> static int
> MHD_poll_listen_socket (struct MHD_Daemon *daemon,
> - int may_block)
> + int may_block)
> {
> struct pollfd p[2];
> int timeout;
> @@ -3796,7 +3796,7 @@ MHD_poll_listen_socket (struct MHD_Daemon *daemon,
> const int err = MHD_socket_get_error_ ();
>
> if (MHD_SCKT_ERR_IS_EINTR_ (err))
> - return MHD_YES;
> + return MHD_YES;
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> _("poll failed: %s\n"),
> @@ -3828,7 +3828,7 @@ MHD_poll_listen_socket (struct MHD_Daemon *daemon,
> */
> static int
> MHD_poll (struct MHD_Daemon *daemon,
> - int may_block)
> + int may_block)
> {
> #ifdef HAVE_POLL
> if (daemon->shutdown)
> @@ -3922,23 +3922,23 @@ run_epoll_for_upgrade (struct MHD_Daemon *daemon)
> unsigned int i;
> /* update event masks */
> num_events = epoll_wait (daemon->epoll_upgrade_fd,
> - events,
> + events,
> MAX_EVENTS,
> 0);
> if (-1 == num_events)
> - {
> + {
> const int err = MHD_socket_get_error_ ();
> if (MHD_SCKT_ERR_IS_EINTR_ (err))
> - return MHD_YES;
> + return MHD_YES;
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> _("Call to epoll_wait failed: %s\n"),
> MHD_socket_strerr_ (err));
> #endif
> - return MHD_NO;
> - }
> + return MHD_NO;
> + }
> for (i = 0; i < (unsigned int) num_events; i++)
> - {
> + {
> struct UpgradeEpollHandle * const ueh = events[i].data.ptr;
> struct MHD_UpgradeResponseHandle * const urh = ueh->urh;
> bool new_err_state = false;
> @@ -3956,24 +3956,24 @@ run_epoll_for_upgrade (struct MHD_Daemon *daemon)
>
> if ( (0 == (ueh->celi & MHD_EPOLL_STATE_ERROR)) &&
> (0 != (events[i].events & (EPOLLERR | EPOLLPRI))) )
> - {
> + {
> /* Process new error state only one time
> * and avoid continuously marking this connection
> * as 'ready'. */
> ueh->celi |= MHD_EPOLL_STATE_ERROR;
> new_err_state = true;
> - }
> + }
>
> if (! urh->in_eready_list)
> {
> if (new_err_state ||
> - is_urh_ready(urh))
> - {
> - EDLL_insert (daemon->eready_urh_head,
> - daemon->eready_urh_tail,
> - urh);
> - urh->in_eready_list = true;
> - }
> + is_urh_ready(urh))
> + {
> + EDLL_insert (daemon->eready_urh_head,
> + daemon->eready_urh_tail,
> + urh);
> + urh->in_eready_list = true;
> + }
> }
> }
> }
> @@ -3983,12 +3983,12 @@ run_epoll_for_upgrade (struct MHD_Daemon *daemon)
> prev = pos->prevE;
> process_urh (pos);
> if (! is_urh_ready(pos))
> - {
> - EDLL_remove (daemon->eready_urh_head,
> - daemon->eready_urh_tail,
> - pos);
> - pos->in_eready_list = false;
> - }
> + {
> + EDLL_remove (daemon->eready_urh_head,
> + daemon->eready_urh_tail,
> + pos);
> + pos->in_eready_list = false;
> + }
> /* Finished forwarding? */
> if ( (0 == pos->in_buffer_size) &&
> (0 == pos->out_buffer_size) &&
> @@ -4024,7 +4024,7 @@ static const char * const epoll_itc_marker =
> "itc_marker";
> */
> static int
> MHD_epoll (struct MHD_Daemon *daemon,
> - int may_block)
> + int may_block)
> {
> #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
> static const char * const upgrade_marker = "upgrade_ptr";
> @@ -4055,17 +4055,17 @@ MHD_epoll (struct MHD_Daemon *daemon,
> event.events = EPOLLIN;
> event.data.ptr = daemon;
> if (0 != epoll_ctl (daemon->epoll_fd,
> - EPOLL_CTL_ADD,
> - ls,
> - &event))
> - {
> + EPOLL_CTL_ADD,
> + ls,
> + &event))
> + {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> _("Call to epoll_ctl failed: %s\n"),
> MHD_socket_last_strerr_ ());
> #endif
> - return MHD_NO;
> - }
> + return MHD_NO;
> + }
> daemon->listen_socket_in_epoll = true;
> }
> if ( (daemon->was_quiesced) &&
> @@ -4086,17 +4086,17 @@ MHD_epoll (struct MHD_Daemon *daemon,
> event.events = EPOLLIN | EPOLLOUT;
> event.data.ptr = (void *) upgrade_marker;
> if (0 != epoll_ctl (daemon->epoll_fd,
> - EPOLL_CTL_ADD,
> - daemon->epoll_upgrade_fd,
> - &event))
> - {
> + EPOLL_CTL_ADD,
> + daemon->epoll_upgrade_fd,
> + &event))
> + {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> _("Call to epoll_ctl failed: %s\n"),
> MHD_socket_last_strerr_ ());
> #endif
> - return MHD_NO;
> - }
> + return MHD_NO;
> + }
> daemon->upgrade_fd_in_epoll = true;
> }
> #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
> @@ -4106,12 +4106,12 @@ MHD_epoll (struct MHD_Daemon *daemon,
> (daemon->was_quiesced) ) )
> {
> /* we're at the connection limit, disable listen socket
> - for event loop for now */
> + for event loop for now */
> if (0 != epoll_ctl (daemon->epoll_fd,
> - EPOLL_CTL_DEL,
> - ls,
> - NULL))
> - MHD_PANIC (_("Failed to remove listen FD from epoll set\n"));
> + EPOLL_CTL_DEL,
> + ls,
> + NULL))
> + MHD_PANIC (_("Failed to remove listen FD from epoll set\n"));
> daemon->listen_socket_in_epoll = false;
> }
>
> @@ -4122,15 +4122,15 @@ MHD_epoll (struct MHD_Daemon *daemon,
> if (MHD_YES == may_block)
> {
> if (MHD_YES == MHD_get_timeout (daemon,
> - &timeout_ll))
> - {
> - if (timeout_ll >= (MHD_UNSIGNED_LONG_LONG) INT_MAX)
> - timeout_ms = INT_MAX;
> - else
> - timeout_ms = (int) timeout_ll;
> - }
> + &timeout_ll))
> + {
> + if (timeout_ll >= (MHD_UNSIGNED_LONG_LONG) INT_MAX)
> + timeout_ms = INT_MAX;
> + else
> + timeout_ms = (int) timeout_ll;
> + }
> else
> - timeout_ms = -1;
> + timeout_ms = -1;
> }
> else
> timeout_ms = 0;
> @@ -4149,27 +4149,27 @@ MHD_epoll (struct MHD_Daemon *daemon,
> {
> /* update event masks */
> num_events = epoll_wait (daemon->epoll_fd,
> - events,
> + events,
> MAX_EVENTS,
> timeout_ms);
> if (-1 == num_events)
> - {
> + {
> const int err = MHD_socket_get_error_ ();
> if (MHD_SCKT_ERR_IS_EINTR_ (err))
> - return MHD_YES;
> + return MHD_YES;
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> _("Call to epoll_wait failed: %s\n"),
> MHD_socket_strerr_ (err));
> #endif
> - return MHD_NO;
> - }
> + return MHD_NO;
> + }
> for (i=0;i<(unsigned int) num_events;i++)
> - {
> + {
> /* First, check for the values of `ptr` that would indicate
> that this event is not about a normal connection. */
> - if (NULL == events[i].data.ptr)
> - continue; /* shutdown signal! */
> + if (NULL == events[i].data.ptr)
> + continue; /* shutdown signal! */
> #if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
> if (upgrade_marker == events[i].data.ptr)
> {
> @@ -4186,8 +4186,8 @@ MHD_epoll (struct MHD_Daemon *daemon,
> MHD_itc_clear_ (daemon->itc);
> continue;
> }
> - if (daemon == events[i].data.ptr)
> - {
> + if (daemon == events[i].data.ptr)
> + {
> /* Check for error conditions on listen socket. */
> /* FIXME: Initiate MHD_quiesce_daemon() to prevent busy
> waiting? */
> if (0 == (events[i].events & (EPOLLERR | EPOLLHUP)))
> @@ -4202,9 +4202,9 @@ MHD_epoll (struct MHD_Daemon *daemon,
> (daemon->connections < daemon->connection_limit) &&
> (! daemon->at_limit) )
> series_length++;
> - }
> + }
> continue;
> - }
> + }
> /* this is an event relating to a 'normal' connection,
> remember the event and if appropriate mark the
> connection as 'eready'. */
> @@ -4261,7 +4261,7 @@ MHD_epoll (struct MHD_Daemon *daemon,
> prev = daemon->eready_tail;
> while (NULL != (pos = prev))
> {
> - prev = pos->prevE;
> + prev = pos->prevE;
> call_handlers (pos,
> 0 != (pos->epoll_state & MHD_EPOLL_STATE_READ_READY),
> 0 != (pos->epoll_state & MHD_EPOLL_STATE_WRITE_READY),
> @@ -4307,7 +4307,7 @@ MHD_epoll (struct MHD_Daemon *daemon,
> prev = pos->prevX;
> MHD_connection_handle_idle (pos);
> if (MHD_CONNECTION_CLOSED != pos->state)
> - break; /* sorted by timeout, no need to visit the rest! */
> + break; /* sorted by timeout, no need to visit the rest! */
> }
> return MHD_YES;
> }
> @@ -4388,18 +4388,18 @@ close_connection (struct MHD_Connection *pos)
> mhd_assert (! pos->resuming);
> if (pos->connection_timeout == pos->daemon->connection_timeout)
> XDLL_remove (daemon->normal_timeout_head,
> - daemon->normal_timeout_tail,
> - pos);
> + daemon->normal_timeout_tail,
> + pos);
> else
> XDLL_remove (daemon->manual_timeout_head,
> - daemon->manual_timeout_tail,
> - pos);
> + daemon->manual_timeout_tail,
> + pos);
> DLL_remove (daemon->connections_head,
> - daemon->connections_tail,
> - pos);
> + daemon->connections_tail,
> + pos);
> DLL_insert (daemon->cleanup_head,
> - daemon->cleanup_tail,
> - pos);
> + daemon->cleanup_tail,
> + pos);
>
> MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
> }
> @@ -4421,13 +4421,13 @@ MHD_polling_thread (void *cls)
> while (! daemon->shutdown)
> {
> if (0 != (daemon->options & MHD_USE_POLL))
> - MHD_poll (daemon, MHD_YES);
> + MHD_poll (daemon, MHD_YES);
> #ifdef EPOLL_SUPPORT
> else if (0 != (daemon->options & MHD_USE_EPOLL))
> - MHD_epoll (daemon, MHD_YES);
> + MHD_epoll (daemon, MHD_YES);
> #endif
> else
> - MHD_select (daemon, MHD_YES);
> + MHD_select (daemon, MHD_YES);
> MHD_cleanup_connections (daemon);
> }
>
> @@ -4541,7 +4541,7 @@ MHD_quiesce_daemon (struct MHD_Daemon *daemon)
> {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> - "Using MHD_quiesce_daemon in this mode requires MHD_USE_ITC\n");
> + "Using MHD_quiesce_daemon in this mode requires MHD_USE_ITC\n");
> #endif
> return MHD_INVALID_SOCKET;
> }
> @@ -4549,19 +4549,19 @@ MHD_quiesce_daemon (struct MHD_Daemon *daemon)
> if (NULL != daemon->worker_pool)
> for (i = 0; i < daemon->worker_pool_size; i++)
> {
> - daemon->worker_pool[i].was_quiesced = true;
> + daemon->worker_pool[i].was_quiesced = true;
> #ifdef EPOLL_SUPPORT
> - if ( (0 != (daemon->options & MHD_USE_EPOLL)) &&
> - (-1 != daemon->worker_pool[i].epoll_fd) &&
> - (daemon->worker_pool[i].listen_socket_in_epoll) )
> - {
> - if (0 != epoll_ctl (daemon->worker_pool[i].epoll_fd,
> - EPOLL_CTL_DEL,
> - ret,
> - NULL))
> - MHD_PANIC (_("Failed to remove listen FD from epoll set\n"));
> - daemon->worker_pool[i].listen_socket_in_epoll = false;
> - }
> + if ( (0 != (daemon->options & MHD_USE_EPOLL)) &&
> + (-1 != daemon->worker_pool[i].epoll_fd) &&
> + (daemon->worker_pool[i].listen_socket_in_epoll) )
> + {
> + if (0 != epoll_ctl (daemon->worker_pool[i].epoll_fd,
> + EPOLL_CTL_DEL,
> + ret,
> + NULL))
> + MHD_PANIC (_("Failed to remove listen FD from epoll set\n"));
> + daemon->worker_pool[i].listen_socket_in_epoll = false;
> + }
> else
> #endif
> if (MHD_ITC_IS_VALID_(daemon->worker_pool[i].itc))
> @@ -4577,10 +4577,10 @@ MHD_quiesce_daemon (struct MHD_Daemon *daemon)
> (daemon->listen_socket_in_epoll) )
> {
> if (0 != epoll_ctl (daemon->epoll_fd,
> - EPOLL_CTL_DEL,
> - ret,
> - NULL))
> - MHD_PANIC ("Failed to remove listen FD from epoll set\n");
> + EPOLL_CTL_DEL,
> + ret,
> + NULL))
> + MHD_PANIC ("Failed to remove listen FD from epoll set\n");
> daemon->listen_socket_in_epoll = false;
> }
> #endif
> @@ -4614,8 +4614,8 @@ typedef void
> */
> static int
> parse_options_va (struct MHD_Daemon *daemon,
> - const struct sockaddr **servaddr,
> - va_list ap);
> + const struct sockaddr **servaddr,
> + va_list ap);
>
>
> /**
> @@ -4628,8 +4628,8 @@ parse_options_va (struct MHD_Daemon *daemon,
> */
> static int
> parse_options (struct MHD_Daemon *daemon,
> - const struct sockaddr **servaddr,
> - ...)
> + const struct sockaddr **servaddr,
> + ...)
> {
> va_list ap;
> int ret;
> @@ -4653,8 +4653,8 @@ parse_options (struct MHD_Daemon *daemon,
> */
> static int
> parse_options_va (struct MHD_Daemon *daemon,
> - const struct sockaddr **servaddr,
> - va_list ap)
> + const struct sockaddr **servaddr,
> + va_list ap)
> {
> enum MHD_OPTION opt;
> struct MHD_OptionItem *oa;
> @@ -4748,85 +4748,85 @@ parse_options_va (struct MHD_Daemon *daemon,
> * be optimized out on those platforms. On others it will be
> compiled into real
> * check. */
> else if (daemon->worker_pool_size >= (SIZE_MAX / sizeof (struct
> MHD_Daemon))) /* Compiler may warn on some platforms, ignore warning. */
> - {
> + {
> #ifdef HAVE_MESSAGES
> - MHD_DLOG (daemon,
> - _("Specified thread pool size (%u) too big\n"),
> - daemon->worker_pool_size);
> -#endif
> - return MHD_NO;
> - }
> - else
> - {
> - if (0 == (daemon->options & MHD_USE_INTERNAL_POLLING_THREAD))
> - {
> + MHD_DLOG (daemon,
> + _("Specified thread pool size (%u) too big\n"),
> + daemon->worker_pool_size);
> +#endif
> + return MHD_NO;
> + }
> + else
> + {
> + if (0 == (daemon->options & MHD_USE_INTERNAL_POLLING_THREAD))
> + {
> #ifdef HAVE_MESSAGES
> - MHD_DLOG (daemon,
> - _("MHD_OPTION_THREAD_POOL_SIZE option is specified
> but "
> - "MHD_USE_INTERNAL_POLLING_THREAD flag is not
> specified.\n"));
> -#endif
> - return MHD_NO;
> - }
> - if (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION))
> - {
> + MHD_DLOG (daemon,
> + _("MHD_OPTION_THREAD_POOL_SIZE option is specified but "
> + "MHD_USE_INTERNAL_POLLING_THREAD flag is not specified.\n"));
> +#endif
> + return MHD_NO;
> + }
> + if (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION))
> + {
> #ifdef HAVE_MESSAGES
> - MHD_DLOG (daemon,
> - _("Both MHD_OPTION_THREAD_POOL_SIZE option and "
> - "MHD_USE_THREAD_PER_CONNECTION flag are
> specified.\n"));
> + MHD_DLOG (daemon,
> + _("Both MHD_OPTION_THREAD_POOL_SIZE option and "
> + "MHD_USE_THREAD_PER_CONNECTION flag are specified.\n"));
> #endif
> - return MHD_NO;
> - }
> - }
> + return MHD_NO;
> + }
> + }
> break;
> #ifdef HTTPS_SUPPORT
> case MHD_OPTION_HTTPS_MEM_KEY:
> - if (0 != (daemon->options & MHD_USE_TLS))
> - daemon->https_mem_key = va_arg (ap,
> + if (0 != (daemon->options & MHD_USE_TLS))
> + daemon->https_mem_key = va_arg (ap,
> const char *);
> #ifdef HAVE_MESSAGES
> - else
> - MHD_DLOG (daemon,
> - _("MHD HTTPS option %d passed to MHD but MHD_USE_TLS not
> set\n"),
> - opt);
> + else
> + MHD_DLOG (daemon,
> + _("MHD HTTPS option %d passed to MHD but MHD_USE_TLS not set\n"),
> + opt);
> #endif
> break;
> case MHD_OPTION_HTTPS_KEY_PASSWORD:
> - if (0 != (daemon->options & MHD_USE_TLS))
> - daemon->https_key_password = va_arg (ap,
> + if (0 != (daemon->options & MHD_USE_TLS))
> + daemon->https_key_password = va_arg (ap,
> const char *);
> #ifdef HAVE_MESSAGES
> - else
> - MHD_DLOG (daemon,
> - _("MHD HTTPS option %d passed to MHD but MHD_USE_TLS not
> set\n"),
> - opt);
> + else
> + MHD_DLOG (daemon,
> + _("MHD HTTPS option %d passed to MHD but MHD_USE_TLS not set\n"),
> + opt);
> #endif
> break;
> case MHD_OPTION_HTTPS_MEM_CERT:
> - if (0 != (daemon->options & MHD_USE_TLS))
> - daemon->https_mem_cert = va_arg (ap,
> + if (0 != (daemon->options & MHD_USE_TLS))
> + daemon->https_mem_cert = va_arg (ap,
> const char *);
> #ifdef HAVE_MESSAGES
> - else
> - MHD_DLOG (daemon,
> - _("MHD HTTPS option %d passed to MHD but MHD_USE_TLS not
> set\n"),
> - opt);
> + else
> + MHD_DLOG (daemon,
> + _("MHD HTTPS option %d passed to MHD but MHD_USE_TLS not set\n"),
> + opt);
> #endif
> break;
> case MHD_OPTION_HTTPS_MEM_TRUST:
> - if (0 != (daemon->options & MHD_USE_TLS))
> - daemon->https_mem_trust = va_arg (ap,
> + if (0 != (daemon->options & MHD_USE_TLS))
> + daemon->https_mem_trust = va_arg (ap,
> const char *);
> #ifdef HAVE_MESSAGES
> - else
> - MHD_DLOG (daemon,
> - _("MHD HTTPS option %d passed to MHD but MHD_USE_TLS not
> set\n"),
> - opt);
> + else
> + MHD_DLOG (daemon,
> + _("MHD HTTPS option %d passed to MHD but MHD_USE_TLS not set\n"),
> + opt);
> #endif
> break;
> - case MHD_OPTION_HTTPS_CRED_TYPE:
> - daemon->cred_type = (gnutls_credentials_type_t) va_arg (ap,
> + case MHD_OPTION_HTTPS_CRED_TYPE:
> + daemon->cred_type = (gnutls_credentials_type_t) va_arg (ap,
> int);
> - break;
> + break;
> case MHD_OPTION_HTTPS_MEM_DHPARAMS:
> if (0 != (daemon->options & MHD_USE_TLS))
> {
> @@ -4868,24 +4868,24 @@ parse_options_va (struct MHD_Daemon *daemon,
> }
> break;
> case MHD_OPTION_HTTPS_PRIORITIES:
> - if (0 != (daemon->options & MHD_USE_TLS))
> - {
> - gnutls_priority_deinit (daemon->priority_cache);
> - ret = gnutls_priority_init (&daemon->priority_cache,
> - pstr = va_arg (ap, const char*),
> - NULL);
> - if (GNUTLS_E_SUCCESS != ret)
> - {
> + if (0 != (daemon->options & MHD_USE_TLS))
> + {
> + gnutls_priority_deinit (daemon->priority_cache);
> + ret = gnutls_priority_init (&daemon->priority_cache,
> + pstr = va_arg (ap, const char*),
> + NULL);
> + if (GNUTLS_E_SUCCESS != ret)
> + {
> #ifdef HAVE_MESSAGES
> - MHD_DLOG (daemon,
> - _("Setting priorities to `%s' failed: %s\n"),
> - pstr,
> - gnutls_strerror (ret));
> -#endif
> - daemon->priority_cache = NULL;
> - return MHD_NO;
> - }
> - }
> + MHD_DLOG (daemon,
> + _("Setting priorities to `%s' failed: %s\n"),
> + pstr,
> + gnutls_strerror (ret));
> +#endif
> + daemon->priority_cache = NULL;
> + return MHD_NO;
> + }
> + }
> break;
> case MHD_OPTION_HTTPS_CERT_CALLBACK:
> #if GNUTLS_VERSION_MAJOR < 3
> @@ -4902,18 +4902,18 @@ parse_options_va (struct MHD_Daemon *daemon,
> #endif
> #endif /* HTTPS_SUPPORT */
> #ifdef DAUTH_SUPPORT
> - case MHD_OPTION_DIGEST_AUTH_RANDOM:
> - daemon->digest_auth_rand_size = va_arg (ap,
> + case MHD_OPTION_DIGEST_AUTH_RANDOM:
> + daemon->digest_auth_rand_size = va_arg (ap,
> size_t);
> - daemon->digest_auth_random = va_arg (ap,
> + daemon->digest_auth_random = va_arg (ap,
> const char *);
> - break;
> - case MHD_OPTION_NONCE_NC_SIZE:
> - daemon->nonce_nc_size = va_arg (ap,
> + break;
> + case MHD_OPTION_NONCE_NC_SIZE:
> + daemon->nonce_nc_size = va_arg (ap,
> unsigned int);
> - break;
> + break;
> #endif
> - case MHD_OPTION_LISTEN_SOCKET:
> + case MHD_OPTION_LISTEN_SOCKET:
> if (0 != (daemon->options & MHD_USE_NO_LISTEN_SOCKET))
> {
> #ifdef HAVE_MESSAGES
> @@ -4926,7 +4926,7 @@ parse_options_va (struct MHD_Daemon *daemon,
> else
> daemon->listen_fd = va_arg (ap,
> MHD_socket);
> - break;
> + break;
> case MHD_OPTION_EXTERNAL_LOGGER:
> #ifdef HAVE_MESSAGES
> daemon->custom_error_log = va_arg (ap,
> @@ -4950,70 +4950,70 @@ parse_options_va (struct MHD_Daemon *daemon,
> unsigned int);
> break;
> #endif
> - case MHD_OPTION_LISTENING_ADDRESS_REUSE:
> - daemon->listening_address_reuse = va_arg (ap,
> + case MHD_OPTION_LISTENING_ADDRESS_REUSE:
> + daemon->listening_address_reuse = va_arg (ap,
> unsigned int) ? 1 : -1;
> - break;
> - case MHD_OPTION_LISTEN_BACKLOG_SIZE:
> - daemon->listen_backlog_size = va_arg (ap,
> + break;
> + case MHD_OPTION_LISTEN_BACKLOG_SIZE:
> + daemon->listen_backlog_size = va_arg (ap,
> unsigned int);
> - break;
> - case MHD_OPTION_STRICT_FOR_CLIENT:
> + break;
> + case MHD_OPTION_STRICT_FOR_CLIENT:
> daemon->strict_for_client = va_arg (ap, int);;
> #ifdef HAVE_MESSAGES
> - if ( (0 != (daemon->options & MHD_USE_PEDANTIC_CHECKS)) &&
> - (1 != daemon->strict_for_client) )
> + if ( (0 != (daemon->options & MHD_USE_PEDANTIC_CHECKS)) &&
> + (1 != daemon->strict_for_client) )
> {
> MHD_DLOG (daemon,
> _("Flag MHD_USE_PEDANTIC_CHECKS is ignored because "
> "another behavior is specified by
> MHD_OPTION_STRICT_CLIENT.\n"));
> }
> #endif /* HAVE_MESSAGES */
> - break;
> - case MHD_OPTION_ARRAY:
> - oa = va_arg (ap, struct MHD_OptionItem*);
> - i = 0;
> - while (MHD_OPTION_END != (opt = oa[i].option))
> - {
> - switch (opt)
> - {
> - /* all options taking 'size_t' */
> - case MHD_OPTION_CONNECTION_MEMORY_LIMIT:
> - case MHD_OPTION_CONNECTION_MEMORY_INCREMENT:
> - case MHD_OPTION_THREAD_STACK_SIZE:
> - if (MHD_YES != parse_options (daemon,
> - servaddr,
> - opt,
> - (size_t) oa[i].value,
> - MHD_OPTION_END))
> - return MHD_NO;
> - break;
> - /* all options taking 'unsigned int' */
> - case MHD_OPTION_NONCE_NC_SIZE:
> - case MHD_OPTION_CONNECTION_LIMIT:
> - case MHD_OPTION_CONNECTION_TIMEOUT:
> - case MHD_OPTION_PER_IP_CONNECTION_LIMIT:
> - case MHD_OPTION_THREAD_POOL_SIZE:
> + break;
> + case MHD_OPTION_ARRAY:
> + oa = va_arg (ap, struct MHD_OptionItem*);
> + i = 0;
> + while (MHD_OPTION_END != (opt = oa[i].option))
> + {
> + switch (opt)
> + {
> + /* all options taking 'size_t' */
> + case MHD_OPTION_CONNECTION_MEMORY_LIMIT:
> + case MHD_OPTION_CONNECTION_MEMORY_INCREMENT:
> + case MHD_OPTION_THREAD_STACK_SIZE:
> + if (MHD_YES != parse_options (daemon,
> + servaddr,
> + opt,
> + (size_t) oa[i].value,
> + MHD_OPTION_END))
> + return MHD_NO;
> + break;
> + /* all options taking 'unsigned int' */
> + case MHD_OPTION_NONCE_NC_SIZE:
> + case MHD_OPTION_CONNECTION_LIMIT:
> + case MHD_OPTION_CONNECTION_TIMEOUT:
> + case MHD_OPTION_PER_IP_CONNECTION_LIMIT:
> + case MHD_OPTION_THREAD_POOL_SIZE:
> case MHD_OPTION_TCP_FASTOPEN_QUEUE_SIZE:
> - case MHD_OPTION_LISTENING_ADDRESS_REUSE:
> - case MHD_OPTION_LISTEN_BACKLOG_SIZE:
> - if (MHD_YES != parse_options (daemon,
> - servaddr,
> - opt,
> - (unsigned int) oa[i].value,
> - MHD_OPTION_END))
> - return MHD_NO;
> - break;
> - /* all options taking 'enum' */
> + case MHD_OPTION_LISTENING_ADDRESS_REUSE:
> + case MHD_OPTION_LISTEN_BACKLOG_SIZE:
> + if (MHD_YES != parse_options (daemon,
> + servaddr,
> + opt,
> + (unsigned int) oa[i].value,
> + MHD_OPTION_END))
> + return MHD_NO;
> + break;
> + /* all options taking 'enum' */
> #ifdef HTTPS_SUPPORT
> - case MHD_OPTION_HTTPS_CRED_TYPE:
> - if (MHD_YES != parse_options (daemon,
> - servaddr,
> - opt,
> - (gnutls_credentials_type_t)
> oa[i].value,
> - MHD_OPTION_END))
> - return MHD_NO;
> - break;
> + case MHD_OPTION_HTTPS_CRED_TYPE:
> + if (MHD_YES != parse_options (daemon,
> + servaddr,
> + opt,
> + (gnutls_credentials_type_t) oa[i].value,
> + MHD_OPTION_END))
> + return MHD_NO;
> + break;
> #endif /* HTTPS_SUPPORT */
> /* all options taking 'MHD_socket' */
> case MHD_OPTION_LISTEN_SOCKET:
> @@ -5033,53 +5033,53 @@ parse_options_va (struct MHD_Daemon *daemon,
> MHD_OPTION_END))
> return MHD_NO;
> break;
> - /* all options taking one pointer */
> - case MHD_OPTION_SOCK_ADDR:
> - case MHD_OPTION_HTTPS_MEM_KEY:
> - case MHD_OPTION_HTTPS_KEY_PASSWORD:
> - case MHD_OPTION_HTTPS_MEM_CERT:
> - case MHD_OPTION_HTTPS_MEM_TRUST:
> - case MHD_OPTION_HTTPS_MEM_DHPARAMS:
> - case MHD_OPTION_HTTPS_PRIORITIES:
> - case MHD_OPTION_ARRAY:
> + /* all options taking one pointer */
> + case MHD_OPTION_SOCK_ADDR:
> + case MHD_OPTION_HTTPS_MEM_KEY:
> + case MHD_OPTION_HTTPS_KEY_PASSWORD:
> + case MHD_OPTION_HTTPS_MEM_CERT:
> + case MHD_OPTION_HTTPS_MEM_TRUST:
> + case MHD_OPTION_HTTPS_MEM_DHPARAMS:
> + case MHD_OPTION_HTTPS_PRIORITIES:
> + case MHD_OPTION_ARRAY:
> case MHD_OPTION_HTTPS_CERT_CALLBACK:
> - if (MHD_YES != parse_options (daemon,
> - servaddr,
> - opt,
> - oa[i].ptr_value,
> - MHD_OPTION_END))
> - return MHD_NO;
> - break;
> - /* all options taking two pointers */
> - case MHD_OPTION_NOTIFY_COMPLETED:
> - case MHD_OPTION_NOTIFY_CONNECTION:
> - case MHD_OPTION_URI_LOG_CALLBACK:
> - case MHD_OPTION_EXTERNAL_LOGGER:
> - case MHD_OPTION_UNESCAPE_CALLBACK:
> - if (MHD_YES != parse_options (daemon,
> - servaddr,
> - opt,
> - (void *) oa[i].value,
> - oa[i].ptr_value,
> - MHD_OPTION_END))
> - return MHD_NO;
> - break;
> - /* options taking size_t-number followed by pointer */
> - case MHD_OPTION_DIGEST_AUTH_RANDOM:
> - if (MHD_YES != parse_options (daemon,
> - servaddr,
> - opt,
> - (size_t) oa[i].value,
> - oa[i].ptr_value,
> - MHD_OPTION_END))
> - return MHD_NO;
> - break;
> - default:
> - return MHD_NO;
> - }
> - i++;
> - }
> - break;
> + if (MHD_YES != parse_options (daemon,
> + servaddr,
> + opt,
> + oa[i].ptr_value,
> + MHD_OPTION_END))
> + return MHD_NO;
> + break;
> + /* all options taking two pointers */
> + case MHD_OPTION_NOTIFY_COMPLETED:
> + case MHD_OPTION_NOTIFY_CONNECTION:
> + case MHD_OPTION_URI_LOG_CALLBACK:
> + case MHD_OPTION_EXTERNAL_LOGGER:
> + case MHD_OPTION_UNESCAPE_CALLBACK:
> + if (MHD_YES != parse_options (daemon,
> + servaddr,
> + opt,
> + (void *) oa[i].value,
> + oa[i].ptr_value,
> + MHD_OPTION_END))
> + return MHD_NO;
> + break;
> + /* options taking size_t-number followed by pointer */
> + case MHD_OPTION_DIGEST_AUTH_RANDOM:
> + if (MHD_YES != parse_options (daemon,
> + servaddr,
> + opt,
> + (size_t) oa[i].value,
> + oa[i].ptr_value,
> + MHD_OPTION_END))
> + return MHD_NO;
> + break;
> + default:
> + return MHD_NO;
> + }
> + i++;
> + }
> + break;
> case MHD_OPTION_UNESCAPE_CALLBACK:
> daemon->unescape_callback = va_arg (ap,
> UnescapeCallback);
> @@ -5093,17 +5093,17 @@ parse_options_va (struct MHD_Daemon *daemon,
> (opt == MHD_OPTION_HTTPS_MEM_TRUST))
> {
> MHD_DLOG (daemon,
> - _("MHD HTTPS option %d passed to MHD compiled without
> HTTPS support\n"),
> - opt);
> + _("MHD HTTPS option %d passed to MHD compiled without HTTPS
> support\n"),
> + opt);
> }
> else
> {
> MHD_DLOG (daemon,
> - _("Invalid option %d! (Did you terminate the list with
> MHD_OPTION_END?)\n"),
> - opt);
> + _("Invalid option %d! (Did you terminate the list with
> MHD_OPTION_END?)\n"),
> + opt);
> }
> #endif
> - return MHD_NO;
> + return MHD_NO;
> }
> }
> return MHD_YES;
> @@ -5179,9 +5179,9 @@ setup_epoll_to_listen (struct MHD_Daemon *daemon)
> event.events = EPOLLIN;
> event.data.ptr = daemon;
> if (0 != epoll_ctl (daemon->epoll_fd,
> - EPOLL_CTL_ADD,
> - ls,
> - &event))
> + EPOLL_CTL_ADD,
> + ls,
> + &event))
> {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> @@ -5241,7 +5241,7 @@ MHD_start_daemon_va (unsigned int flags,
> void *apc_cls,
> MHD_AccessHandlerCallback dh,
> void *dh_cls,
> - va_list ap)
> + va_list ap)
> {
> const MHD_SCKT_OPT_BOOL_ on = 1;
> struct MHD_Daemon *daemon;
> @@ -5345,8 +5345,8 @@ MHD_start_daemon_va (unsigned int flags,
> if (0 != (*pflags & MHD_USE_TLS))
> {
> gnutls_priority_init (&daemon->priority_cache,
> - "NORMAL",
> - NULL);
> + "NORMAL",
> + NULL);
> }
> #endif /* HTTPS_SUPPORT */
> daemon->listen_fd = MHD_INVALID_SOCKET;
> @@ -5414,8 +5414,8 @@ MHD_start_daemon_va (unsigned int flags,
> {
> #ifdef HTTPS_SUPPORT
> if ( (0 != (*pflags & MHD_USE_TLS)) &&
> - (NULL != daemon->priority_cache) )
> - gnutls_priority_deinit (daemon->priority_cache);
> + (NULL != daemon->priority_cache) )
> + gnutls_priority_deinit (daemon->priority_cache);
> #endif /* HTTPS_SUPPORT */
> free (daemon);
> return NULL;
> @@ -5464,45 +5464,45 @@ MHD_start_daemon_va (unsigned int flags,
> if (daemon->nonce_nc_size > 0)
> {
> if ( ( (size_t) (daemon->nonce_nc_size * sizeof (struct MHD_NonceNc)))
> /
> - sizeof(struct MHD_NonceNc) != daemon->nonce_nc_size)
> - {
> + sizeof(struct MHD_NonceNc) != daemon->nonce_nc_size)
> + {
> #ifdef HAVE_MESSAGES
> - MHD_DLOG (daemon,
> - _("Specified value for NC_SIZE too large\n"));
> + MHD_DLOG (daemon,
> + _("Specified value for NC_SIZE too large\n"));
> #endif
> #ifdef HTTPS_SUPPORT
> - if (0 != (*pflags & MHD_USE_TLS))
> - gnutls_priority_deinit (daemon->priority_cache);
> + if (0 != (*pflags & MHD_USE_TLS))
> + gnutls_priority_deinit (daemon->priority_cache);
> #endif /* HTTPS_SUPPORT */
> - free (daemon);
> - return NULL;
> - }
> + free (daemon);
> + return NULL;
> + }
> daemon->nnc = malloc (daemon->nonce_nc_size * sizeof (struct
> MHD_NonceNc));
> if (NULL == daemon->nnc)
> - {
> + {
> #ifdef HAVE_MESSAGES
> - MHD_DLOG (daemon,
> - _("Failed to allocate memory for nonce-nc map: %s\n"),
> - MHD_strerror_ (errno));
> + MHD_DLOG (daemon,
> + _("Failed to allocate memory for nonce-nc map: %s\n"),
> + MHD_strerror_ (errno));
> #endif
> #ifdef HTTPS_SUPPORT
> - if (0 != (*pflags & MHD_USE_TLS))
> - gnutls_priority_deinit (daemon->priority_cache);
> + if (0 != (*pflags & MHD_USE_TLS))
> + gnutls_priority_deinit (daemon->priority_cache);
> #endif /* HTTPS_SUPPORT */
> - free (daemon);
> - return NULL;
> - }
> + free (daemon);
> + return NULL;
> + }
> }
>
> if (! MHD_mutex_init_ (&daemon->nnc_lock))
> {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> - _("MHD failed to initialize nonce-nc mutex\n"));
> + _("MHD failed to initialize nonce-nc mutex\n"));
> #endif
> #ifdef HTTPS_SUPPORT
> if (0 != (*pflags & MHD_USE_TLS))
> - gnutls_priority_deinit (daemon->priority_cache);
> + gnutls_priority_deinit (daemon->priority_cache);
> #endif /* HTTPS_SUPPORT */
> free (daemon->nnc);
> free (daemon);
> @@ -5516,7 +5516,7 @@ MHD_start_daemon_va (unsigned int flags,
> {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> - _("MHD thread pooling only works with
> MHD_USE_INTERNAL_POLLING_THREAD\n"));
> + _("MHD thread pooling only works with
> MHD_USE_INTERNAL_POLLING_THREAD\n"));
> #endif
> goto free_and_fail;
> }
> @@ -5527,14 +5527,14 @@ MHD_start_daemon_va (unsigned int flags,
> /* try to open listen socket */
> listen_fd = MHD_socket_create_listen_(*pflags & MHD_USE_IPv6);
> if (MHD_INVALID_SOCKET == listen_fd)
> - {
> + {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> _("Failed to create socket for listening: %s\n"),
> MHD_socket_last_strerr_ ());
> #endif
> - goto free_and_fail;
> - }
> + goto free_and_fail;
> + }
>
> /* Apply the socket options according to listening_address_reuse. */
> if (0 == daemon->listening_address_reuse)
> @@ -5647,60 +5647,60 @@ MHD_start_daemon_va (unsigned int flags,
> /* check for user supplied sockaddr */
> #if HAVE_INET6
> if (0 != (*pflags & MHD_USE_IPv6))
> - addrlen = sizeof (struct sockaddr_in6);
> + addrlen = sizeof (struct sockaddr_in6);
> else
> #endif
> - addrlen = sizeof (struct sockaddr_in);
> + addrlen = sizeof (struct sockaddr_in);
> if (NULL == servaddr)
> - {
> + {
> #if HAVE_INET6
> - if (0 != (*pflags & MHD_USE_IPv6))
> - {
> + if (0 != (*pflags & MHD_USE_IPv6))
> + {
> #ifdef IN6ADDR_ANY_INIT
> - static const struct in6_addr static_in6any = IN6ADDR_ANY_INIT;
> + static const struct in6_addr static_in6any = IN6ADDR_ANY_INIT;
> #endif
> memset (&servaddr6,
> 0,
> sizeof (struct sockaddr_in6));
> - servaddr6.sin6_family = AF_INET6;
> - servaddr6.sin6_port = htons (port);
> + servaddr6.sin6_family = AF_INET6;
> + servaddr6.sin6_port = htons (port);
> #ifdef IN6ADDR_ANY_INIT
> - servaddr6.sin6_addr = static_in6any;
> + servaddr6.sin6_addr = static_in6any;
> #endif
> #if HAVE_SOCKADDR_IN_SIN_LEN
> - servaddr6.sin6_len = sizeof (struct sockaddr_in6);
> + servaddr6.sin6_len = sizeof (struct sockaddr_in6);
> #endif
> - servaddr = (struct sockaddr *) &servaddr6;
> - }
> - else
> + servaddr = (struct sockaddr *) &servaddr6;
> + }
> + else
> #endif
> - {
> - memset (&servaddr4,
> + {
> + memset (&servaddr4,
> 0,
> sizeof (struct sockaddr_in));
> - servaddr4.sin_family = AF_INET;
> - servaddr4.sin_port = htons (port);
> - if (0 != INADDR_ANY)
> - servaddr4.sin_addr.s_addr = htonl (INADDR_ANY);
> + servaddr4.sin_family = AF_INET;
> + servaddr4.sin_port = htons (port);
> + if (0 != INADDR_ANY)
> + servaddr4.sin_addr.s_addr = htonl (INADDR_ANY);
> #if HAVE_SOCKADDR_IN_SIN_LEN
> - servaddr4.sin_len = sizeof (struct sockaddr_in);
> + servaddr4.sin_len = sizeof (struct sockaddr_in);
> #endif
> - servaddr = (struct sockaddr *) &servaddr4;
> - }
> - }
> + servaddr = (struct sockaddr *) &servaddr4;
> + }
> + }
> daemon->listen_fd = listen_fd;
>
> if (0 != (*pflags & MHD_USE_IPv6))
> - {
> + {
> #ifdef IPPROTO_IPV6
> #ifdef IPV6_V6ONLY
> - /* Note: "IPV6_V6ONLY" is declared by Windows Vista ff., see
> "IPPROTO_IPV6 Socket Options"
> -
> (http://msdn.microsoft.com/en-us/library/ms738574%28v=VS.85%29.aspx);
> - and may also be missing on older POSIX systems; good luck if you
> have any of those,
> - your IPv6 socket may then also bind against IPv4 anyway... */
> - const MHD_SCKT_OPT_BOOL_ v6_only =
> + /* Note: "IPV6_V6ONLY" is declared by Windows Vista ff., see
> "IPPROTO_IPV6 Socket Options"
> + (http://msdn.microsoft.com/en-us/library/ms738574%28v=VS.85%29.aspx);
> + and may also be missing on older POSIX systems; good luck if you have
> any of those,
> + your IPv6 socket may then also bind against IPv4 anyway... */
> + const MHD_SCKT_OPT_BOOL_ v6_only =
> (MHD_USE_DUAL_STACK != (*pflags & MHD_USE_DUAL_STACK));
> - if (0 > setsockopt (listen_fd,
> + if (0 > setsockopt (listen_fd,
> IPPROTO_IPV6, IPV6_V6ONLY,
> (const void *) &v6_only,
> sizeof (v6_only)))
> @@ -5713,18 +5713,18 @@ MHD_start_daemon_va (unsigned int flags,
> }
> #endif
> #endif
> - }
> + }
> if (-1 == bind (listen_fd, servaddr, addrlen))
> - {
> + {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> _("Failed to bind to port %u: %s\n"),
> (unsigned int) port,
> MHD_socket_last_strerr_ ());
> #endif
> - MHD_socket_close_chk_ (listen_fd);
> - goto free_and_fail;
> - }
> + MHD_socket_close_chk_ (listen_fd);
> + goto free_and_fail;
> + }
> #ifdef TCP_FASTOPEN
> if (0 != (*pflags & MHD_USE_TCP_FASTOPEN))
> {
> @@ -5746,15 +5746,15 @@ MHD_start_daemon_va (unsigned int flags,
> #endif
> if (listen (listen_fd,
> daemon->listen_backlog_size) < 0)
> - {
> + {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> _("Failed to listen for connections: %s\n"),
> MHD_socket_last_strerr_ ());
> #endif
> - MHD_socket_close_chk_ (listen_fd);
> - goto free_and_fail;
> - }
> + MHD_socket_close_chk_ (listen_fd);
> + goto free_and_fail;
> + }
> }
> else
> {
> @@ -5866,15 +5866,15 @@ MHD_start_daemon_va (unsigned int flags,
> (0 == (*pflags & MHD_USE_NO_LISTEN_SOCKET)) )
> {
> if (0 != (*pflags & MHD_USE_THREAD_PER_CONNECTION))
> - {
> + {
> #ifdef HAVE_MESSAGES
> - MHD_DLOG (daemon,
> - _("Combining MHD_USE_THREAD_PER_CONNECTION and
> MHD_USE_EPOLL is not supported.\n"));
> + MHD_DLOG (daemon,
> + _("Combining MHD_USE_THREAD_PER_CONNECTION and MHD_USE_EPOLL is not
> supported.\n"));
> #endif
> - goto free_and_fail;
> - }
> + goto free_and_fail;
> + }
> if (MHD_YES != setup_epoll_to_listen (daemon))
> - goto free_and_fail;
> + goto free_and_fail;
> }
> #endif /* EPOLL_SUPPORT */
>
> @@ -5911,7 +5911,7 @@ MHD_start_daemon_va (unsigned int flags,
> {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> - _("Failed to initialize TLS support\n"));
> + _("Failed to initialize TLS support\n"));
> #endif
> if (MHD_INVALID_SOCKET != listen_fd)
> MHD_socket_close_chk_ (listen_fd);
> @@ -6083,10 +6083,10 @@ thread_failed:
> if (daemon->upgrade_fd_in_epoll)
> {
> if (0 != epoll_ctl (daemon->epoll_fd,
> - EPOLL_CTL_DEL,
> - daemon->epoll_upgrade_fd,
> - NULL))
> - MHD_PANIC (_("Failed to remove FD from epoll set\n"));
> + EPOLL_CTL_DEL,
> + daemon->epoll_upgrade_fd,
> + NULL))
> + MHD_PANIC (_("Failed to remove FD from epoll set\n"));
> daemon->upgrade_fd_in_epoll = false;
> }
> #endif /* HTTPS_SUPPORT && UPGRADE_SUPPORT */
> @@ -6425,8 +6425,8 @@ MHD_stop_daemon (struct MHD_Daemon *daemon)
> */
> const union MHD_DaemonInfo *
> MHD_get_daemon_info (struct MHD_Daemon *daemon,
> - enum MHD_DaemonInfoType info_type,
> - ...)
> + enum MHD_DaemonInfoType info_type,
> + ...)
> {
> if (NULL == daemon)
> return NULL;
> diff --git a/src/microhttpd/digestauth.c b/src/microhttpd/digestauth.c
> index 7226becf..7edf280a 100644
> --- a/src/microhttpd/digestauth.c
> +++ b/src/microhttpd/digestauth.c
> @@ -48,7 +48,7 @@
> /**
> * Beginning string for any valid Digest authentication header.
> */
> -#define _BASE "Digest "
> +#define _BASE "Digest "
>
> /**
> * Maximum length of a username for digest authentication.
> @@ -75,8 +75,8 @@
> */
> static void
> cvthex (const unsigned char *bin,
> - size_t len,
> - char *hex)
> + size_t len,
> + char *hex)
> {
> size_t i;
> unsigned int j;
> @@ -106,12 +106,12 @@ cvthex (const unsigned char *bin,
> */
> static void
> digest_calc_ha1 (const char *alg,
> - const char *username,
> - const char *realm,
> - const char *password,
> - const char *nonce,
> - const char *cnonce,
> - char sessionkey[HASH_MD5_HEX_LEN + 1])
> + const char *username,
> + const char *realm,
> + const char *password,
> + const char *nonce,
> + const char *cnonce,
> + char sessionkey[HASH_MD5_HEX_LEN + 1])
> {
> struct MD5Context md5;
> unsigned char ha1[MD5_DIGEST_SIZE];
> @@ -177,14 +177,14 @@ digest_calc_ha1 (const char *alg,
> */
> static void
> digest_calc_response (const char ha1[HASH_MD5_HEX_LEN + 1],
> - const char *nonce,
> - const char *noncecount,
> - const char *cnonce,
> - const char *qop,
> - const char *method,
> - const char *uri,
> - const char *hentity,
> - char response[HASH_MD5_HEX_LEN + 1])
> + const char *nonce,
> + const char *noncecount,
> + const char *cnonce,
> + const char *qop,
> + const char *method,
> + const char *uri,
> + const char *hentity,
> + char response[HASH_MD5_HEX_LEN + 1])
> {
> struct MD5Context md5;
> unsigned char ha2[MD5_DIGEST_SIZE];
> @@ -207,12 +207,12 @@ digest_calc_response (const char ha1[HASH_MD5_HEX_LEN +
> 1],
> "auth-int"))
> {
> /* This is dead code since the rest of this module does
> - not support auth-int. */
> + not support auth-int. */
> MD5Update (&md5,
> ":",
> 1);
> if (NULL != hentity)
> - MD5Update (&md5,
> + MD5Update (&md5,
> hentity,
> strlen (hentity));
> }
> @@ -284,9 +284,9 @@ digest_calc_response (const char ha1[HASH_MD5_HEX_LEN +
> 1],
> */
> static size_t
> lookup_sub_value (char *dest,
> - size_t size,
> - const char *data,
> - const char *key)
> + size_t size,
> + const char *data,
> + const char *key)
> {
> size_t keylen;
> size_t len;
> @@ -304,63 +304,63 @@ lookup_sub_value (char *dest,
> {
> if (NULL == (eq = strchr (ptr,
> '=')))
> - return 0;
> + return 0;
> q1 = eq + 1;
> while (' ' == *q1)
> - q1++;
> + q1++;
> if ('\"' != *q1)
> - {
> - q2 = strchr (q1,
> + {
> + q2 = strchr (q1,
> ',');
> - qn = q2;
> - }
> + qn = q2;
> + }
> else
> - {
> - q1++;
> - q2 = strchr (q1,
> + {
> + q1++;
> + q2 = strchr (q1,
> '\"');
> - if (NULL == q2)
> - return 0; /* end quote not found */
> - qn = q2 + 1;
> - }
> + if (NULL == q2)
> + return 0; /* end quote not found */
> + qn = q2 + 1;
> + }
> if ( (MHD_str_equal_caseless_n_(ptr,
> key,
> keylen)) &&
> - (eq == &ptr[keylen]) )
> - {
> - if (NULL == q2)
> - {
> - len = strlen (q1) + 1;
> - if (size > len)
> - size = len;
> - size--;
> - strncpy (dest,
> - q1,
> - size);
> - dest[size] = '\0';
> - return size;
> - }
> - else
> - {
> - if (size > (size_t) ((q2 - q1) + 1))
> - size = (q2 - q1) + 1;
> - size--;
> - memcpy (dest,
> - q1,
> - size);
> - dest[size] = '\0';
> - return size;
> - }
> - }
> + (eq == &ptr[keylen]) )
> + {
> + if (NULL == q2)
> + {
> + len = strlen (q1) + 1;
> + if (size > len)
> + size = len;
> + size--;
> + strncpy (dest,
> + q1,
> + size);
> + dest[size] = '\0';
> + return size;
> + }
> + else
> + {
> + if (size > (size_t) ((q2 - q1) + 1))
> + size = (q2 - q1) + 1;
> + size--;
> + memcpy (dest,
> + q1,
> + size);
> + dest[size] = '\0';
> + return size;
> + }
> + }
> if (NULL == qn)
> - return 0;
> + return 0;
> ptr = strchr (qn,
> ',');
> if (NULL == ptr)
> - return 0;
> + return 0;
> ptr++;
> while (' ' == *ptr)
> - ptr++;
> + ptr++;
> }
> return 0;
> }
> @@ -377,8 +377,8 @@ lookup_sub_value (char *dest,
> */
> static int
> check_nonce_nc (struct MHD_Connection *connection,
> - const char *nonce,
> - uint64_t nc)
> + const char *nonce,
> + uint64_t nc)
> {
> struct MHD_Daemon *daemon = connection->daemon;
> struct MHD_NonceNc *nn;
> @@ -414,7 +414,7 @@ check_nonce_nc (struct MHD_Connection *connection,
> {
> /* Fresh nonce, reinitialize array */
> strcpy (nn->nonce,
> - nonce);
> + nonce);
> nn->nc = 0;
> nn->nmask = 0;
> MHD_mutex_unlock_chk_ (&daemon->nnc_lock);
> @@ -441,7 +441,7 @@ check_nonce_nc (struct MHD_Connection *connection,
> MHD_mutex_unlock_chk_ (&daemon->nnc_lock);
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> - _("Stale nonce received. If this happens a lot, you should
> probably increase the size of the nonce array.\n"));
> + _("Stale nonce received. If this happens a lot, you should probably
> increase the size of the nonce array.\n"));
> #endif
> return MHD_NO;
> }
> @@ -461,7 +461,7 @@ check_nonce_nc (struct MHD_Connection *connection,
> *
> * @param connection The MHD connection structure
> * @return NULL if no username could be found, a pointer
> - * to the username if found
> + * to the username if found
> * @warning Returned value must be freed by #MHD_free().
> * @ingroup authentication
> */
> @@ -483,9 +483,9 @@ MHD_digest_auth_get_username(struct MHD_Connection
> *connection)
> return NULL;
> header += MHD_STATICSTR_LEN_ (_BASE);
> if (0 == (len = lookup_sub_value (user,
> - sizeof (user),
> - header,
> - "username")))
> + sizeof (user),
> + header,
> + "username")))
> return NULL;
> return strdup (user);
> }
> @@ -506,12 +506,12 @@ MHD_digest_auth_get_username(struct MHD_Connection
> *connection)
> */
> static void
> calculate_nonce (uint32_t nonce_time,
> - const char *method,
> - const char *rnd,
> - size_t rnd_size,
> - const char *uri,
> - const char *realm,
> - char nonce[NONCE_STD_LEN + 1])
> + const char *method,
> + const char *rnd,
> + size_t rnd_size,
> + const char *uri,
> + const char *realm,
> + char nonce[NONCE_STD_LEN + 1])
> {
> struct MD5Context md5;
> unsigned char timestamp[TIMESTAMP_BIN_SIZE];
> @@ -578,27 +578,27 @@ calculate_nonce (uint32_t nonce_time,
> */
> static int
> test_header (struct MHD_Connection *connection,
> - const char *key,
> - const char *value,
> - enum MHD_ValueKind kind)
> + const char *key,
> + const char *value,
> + enum MHD_ValueKind kind)
> {
> struct MHD_HTTP_Header *pos;
>
> for (pos = connection->headers_received; NULL != pos; pos = pos->next)
> {
> if (kind != pos->kind)
> - continue;
> + continue;
> if (0 != strcmp (key,
> pos->header))
> - continue;
> + continue;
> if ( (NULL == value) &&
> - (NULL == pos->value) )
> - return MHD_YES;
> + (NULL == pos->value) )
> + return MHD_YES;
> if ( (NULL == value) ||
> - (NULL == pos->value) ||
> - (0 != strcmp (value,
> + (NULL == pos->value) ||
> + (0 != strcmp (value,
> pos->value)) )
> - continue;
> + continue;
> return MHD_YES;
> }
> return MHD_NO;
> @@ -617,7 +617,7 @@ test_header (struct MHD_Connection *connection,
> */
> static int
> check_argument_match (struct MHD_Connection *connection,
> - const char *args)
> + const char *args)
> {
> struct MHD_HTTP_Header *pos;
> char *argb;
> @@ -629,15 +629,15 @@ check_argument_match (struct MHD_Connection *connection,
> {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (connection->daemon,
> - _("Failed to allocate memory for copy of URI arguments\n"));
> + _("Failed to allocate memory for copy of URI arguments\n"));
> #endif /* HAVE_MESSAGES */
> return MHD_NO;
> }
> ret = MHD_parse_arguments_ (connection,
> - MHD_GET_ARGUMENT_KIND,
> - argb,
> - &test_header,
> - &num_headers);
> + MHD_GET_ARGUMENT_KIND,
> + argb,
> + &test_header,
> + &num_headers);
> free (argb);
> if (MHD_YES != ret)
> return MHD_NO;
> @@ -645,7 +645,7 @@ check_argument_match (struct MHD_Connection *connection,
> for (pos = connection->headers_received; NULL != pos; pos = pos->next)
> {
> if (MHD_GET_ARGUMENT_KIND != pos->kind)
> - continue;
> + continue;
> num_headers--;
> }
> if (0 != num_headers)
> @@ -665,17 +665,17 @@ check_argument_match (struct MHD_Connection *connection,
> * @param username The username needs to be authenticated
> * @param password The password used in the authentication
> * @param nonce_timeout The amount of time for a nonce to be
> - * invalid in seconds
> + * invalid in seconds
> * @return #MHD_YES if authenticated, #MHD_NO if not,
> - * #MHD_INVALID_NONCE if nonce is invalid
> + * #MHD_INVALID_NONCE if nonce is invalid
> * @ingroup authentication
> */
> int
> MHD_digest_auth_check (struct MHD_Connection *connection,
> - const char *realm,
> - const char *username,
> - const char *password,
> - unsigned int nonce_timeout)
> + const char *realm,
> + const char *username,
> + const char *password,
> + unsigned int nonce_timeout)
> {
> struct MHD_Daemon *daemon = connection->daemon;
> size_t len;
> @@ -695,8 +695,8 @@ MHD_digest_auth_check (struct MHD_Connection *connection,
> uint64_t nci;
>
> header = MHD_lookup_connection_value (connection,
> - MHD_HEADER_KIND,
> - MHD_HTTP_HEADER_AUTHORIZATION);
> + MHD_HEADER_KIND,
> + MHD_HTTP_HEADER_AUTHORIZATION);
> if (NULL == header)
> return MHD_NO;
> if (0 != strncmp (header,
> @@ -710,11 +710,11 @@ MHD_digest_auth_check (struct MHD_Connection
> *connection,
> char un[MAX_USERNAME_LENGTH];
>
> len = lookup_sub_value (un,
> - sizeof (un),
> - header,
> + sizeof (un),
> + header,
> "username");
> if ( (0 == len) ||
> - (0 != strcmp (username,
> + (0 != strcmp (username,
> un)) )
> return MHD_NO;
> left -= strlen ("username") + len;
> @@ -728,15 +728,15 @@ MHD_digest_auth_check (struct MHD_Connection
> *connection,
> header,
> "realm");
> if ( (0 == len) ||
> - (0 != strcmp (realm,
> + (0 != strcmp (realm,
> r)) )
> return MHD_NO;
> left -= strlen ("realm") + len;
> }
>
> if (0 == (len = lookup_sub_value (nonce,
> - sizeof (nonce),
> - header,
> + sizeof (nonce),
> + header,
> "nonce")))
> return MHD_NO;
> left -= strlen ("nonce") + len;
> @@ -819,7 +819,7 @@ MHD_digest_auth_check (struct MHD_Connection *connection,
> {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> - _("Authentication failed, invalid format.\n"));
> + _("Authentication failed, invalid format.\n"));
> #endif
> return MHD_NO;
> }
> @@ -829,7 +829,7 @@ MHD_digest_auth_check (struct MHD_Connection *connection,
> {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> - _("Authentication failed, invalid nc format.\n"));
> + _("Authentication failed, invalid nc format.\n"));
> #endif
> return MHD_NO; /* invalid nonce format */
> }
> @@ -876,26 +876,26 @@ MHD_digest_auth_check (struct MHD_Connection
> *connection,
> cnonce,
> ha1);
> digest_calc_response (ha1,
> - nonce,
> - nc,
> - cnonce,
> - qop,
> - connection->method,
> - uri,
> - hentity,
> - respexp);
> + nonce,
> + nc,
> + cnonce,
> + qop,
> + connection->method,
> + uri,
> + hentity,
> + respexp);
>
> /* Need to unescape URI before comparing with connection->url */
> daemon->unescape_callback (daemon->unescape_callback_cls,
> connection,
> uri);
> if (0 != strncmp (uri,
> - connection->url,
> - strlen (connection->url)))
> + connection->url,
> + strlen (connection->url)))
> {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> - _("Authentication failed, URI does not match.\n"));
> + _("Authentication failed, URI does not match.\n"));
> #endif
> free (uri);
> return MHD_NO;
> @@ -906,16 +906,16 @@ MHD_digest_auth_check (struct MHD_Connection
> *connection,
> '?');
>
> if (NULL == args)
> - args = "";
> + args = "";
> else
> - args++;
> + args++;
> if (MHD_YES !=
> - check_argument_match (connection,
> - args) )
> + check_argument_match (connection,
> + args) )
> {
> #ifdef HAVE_MESSAGES
> - MHD_DLOG (daemon,
> - _("Authentication failed, arguments do not match.\n"));
> + MHD_DLOG (daemon,
> + _("Authentication failed, arguments do not match.\n"));
> #endif
> free (uri);
> return MHD_NO;
> @@ -940,16 +940,16 @@ MHD_digest_auth_check (struct MHD_Connection
> *connection,
> * body; note that this function will set the "WWW Authenticate"
> * header and that the caller should not do this
> * @param signal_stale #MHD_YES if the nonce is invalid to add
> - * 'stale=true' to the authentication header
> + * 'stale=true' to the authentication header
> * @return #MHD_YES on success, #MHD_NO otherwise
> * @ingroup authentication
> */
> int
> MHD_queue_auth_fail_response (struct MHD_Connection *connection,
> - const char *realm,
> - const char *opaque,
> - struct MHD_Response *response,
> - int signal_stale)
> + const char *realm,
> + const char *opaque,
> + struct MHD_Response *response,
> + int signal_stale)
> {
> int ret;
> int hlen;
> @@ -957,12 +957,12 @@ MHD_queue_auth_fail_response (struct MHD_Connection
> *connection,
>
> /* Generating the server nonce */
> calculate_nonce ((uint32_t) MHD_monotonic_sec_counter(),
> - connection->method,
> - connection->daemon->digest_auth_random,
> - connection->daemon->digest_auth_rand_size,
> - connection->url,
> - realm,
> - nonce);
> + connection->method,
> + connection->daemon->digest_auth_random,
> + connection->daemon->digest_auth_rand_size,
> + connection->url,
> + realm,
> + nonce);
> if (MHD_YES !=
> check_nonce_nc (connection,
> nonce,
> @@ -970,7 +970,7 @@ MHD_queue_auth_fail_response (struct MHD_Connection
> *connection,
> {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (connection->daemon,
> - _("Could not register nonce (is the nonce array size
> zero?).\n"));
> + _("Could not register nonce (is the nonce array size zero?).\n"));
> #endif
> return MHD_NO;
> }
> diff --git a/src/microhttpd/internal.c b/src/microhttpd/internal.c
> index d2532c54..23b14faa 100644
> --- a/src/microhttpd/internal.c
> +++ b/src/microhttpd/internal.c
> @@ -142,24 +142,24 @@ MHD_http_unescape (char *val)
> {
> uint32_t num;
> switch (*rpos)
> - {
> - case '%':
> + {
> + case '%':
> if (2 == MHD_strx_to_uint32_n_ (rpos + 1,
> 2,
> &num))
> - {
> - *wpos = (char)((unsigned char) num);
> - wpos++;
> - rpos += 3;
> - break;
> - }
> + {
> + *wpos = (char)((unsigned char) num);
> + wpos++;
> + rpos += 3;
> + break;
> + }
> /* TODO: add bad sequence handling */
> - /* intentional fall through! */
> - default:
> - *wpos = *rpos;
> - wpos++;
> - rpos++;
> - }
> + /* intentional fall through! */
> + default:
> + *wpos = *rpos;
> + wpos++;
> + rpos++;
> + }
> }
> *wpos = '\0'; /* add 0-terminator */
> return wpos - val; /* = strlen(val) */
> @@ -182,10 +182,10 @@ MHD_http_unescape (char *val)
> */
> int
> MHD_parse_arguments_ (struct MHD_Connection *connection,
> - enum MHD_ValueKind kind,
> - char *args,
> - MHD_ArgumentIterator_ cb,
> - unsigned int *num_headers)
> + enum MHD_ValueKind kind,
> + char *args,
> + MHD_ArgumentIterator_ cb,
> + unsigned int *num_headers)
> {
> struct MHD_Daemon *daemon = connection->daemon;
> char *equals;
> @@ -193,84 +193,84 @@ MHD_parse_arguments_ (struct MHD_Connection *connection,
>
> *num_headers = 0;
> while ( (NULL != args) &&
> - ('\0' != args[0]) )
> + ('\0' != args[0]) )
> {
> equals = strchr (args, '=');
> amper = strchr (args, '&');
> if (NULL == amper)
> - {
> - /* last argument */
> - if (NULL == equals)
> - {
> - /* last argument, without '=' */
> + {
> + /* last argument */
> + if (NULL == equals)
> + {
> + /* last argument, without '=' */
> MHD_unescape_plus (args);
> - daemon->unescape_callback (daemon->unescape_callback_cls,
> - connection,
> - args);
> - if (MHD_YES != cb (connection,
> - args,
> - NULL,
> - kind))
> - return MHD_NO;
> - (*num_headers)++;
> - break;
> - }
> - /* got 'foo=bar' */
> - equals[0] = '\0';
> - equals++;
> + daemon->unescape_callback (daemon->unescape_callback_cls,
> + connection,
> + args);
> + if (MHD_YES != cb (connection,
> + args,
> + NULL,
> + kind))
> + return MHD_NO;
> + (*num_headers)++;
> + break;
> + }
> + /* got 'foo=bar' */
> + equals[0] = '\0';
> + equals++;
> MHD_unescape_plus (args);
> - daemon->unescape_callback (daemon->unescape_callback_cls,
> - connection,
> - args);
> + daemon->unescape_callback (daemon->unescape_callback_cls,
> + connection,
> + args);
> MHD_unescape_plus (equals);
> - daemon->unescape_callback (daemon->unescape_callback_cls,
> - connection,
> - equals);
> - if (MHD_YES != cb (connection,
> - args,
> - equals,
> - kind))
> - return MHD_NO;
> - (*num_headers)++;
> - break;
> - }
> + daemon->unescape_callback (daemon->unescape_callback_cls,
> + connection,
> + equals);
> + if (MHD_YES != cb (connection,
> + args,
> + equals,
> + kind))
> + return MHD_NO;
> + (*num_headers)++;
> + break;
> + }
> /* amper is non-NULL here */
> amper[0] = '\0';
> amper++;
> if ( (NULL == equals) ||
> - (equals >= amper) )
> - {
> - /* got 'foo&bar' or 'foo&bar=val', add key 'foo' with NULL for value
> */
> + (equals >= amper) )
> + {
> + /* got 'foo&bar' or 'foo&bar=val', add key 'foo' with NULL for value */
> MHD_unescape_plus (args);
> - daemon->unescape_callback (daemon->unescape_callback_cls,
> - connection,
> - args);
> - if (MHD_YES != cb (connection,
> - args,
> - NULL,
> - kind))
> - return MHD_NO;
> - /* continue with 'bar' */
> - (*num_headers)++;
> - args = amper;
> - continue;
> - }
> + daemon->unescape_callback (daemon->unescape_callback_cls,
> + connection,
> + args);
> + if (MHD_YES != cb (connection,
> + args,
> + NULL,
> + kind))
> + return MHD_NO;
> + /* continue with 'bar' */
> + (*num_headers)++;
> + args = amper;
> + continue;
> + }
> /* equals and amper are non-NULL here, and equals < amper,
> - so we got regular 'foo=value&bar...'-kind of argument */
> + so we got regular 'foo=value&bar...'-kind of argument */
> equals[0] = '\0';
> equals++;
> MHD_unescape_plus (args);
> daemon->unescape_callback (daemon->unescape_callback_cls,
> - connection,
> - args);
> + connection,
> + args);
> MHD_unescape_plus (equals);
> daemon->unescape_callback (daemon->unescape_callback_cls,
> - connection,
> - equals);
> + connection,
> + equals);
> if (MHD_YES != cb (connection,
> - args,
> - equals,
> - kind))
> + args,
> + equals,
> + kind))
> return MHD_NO;
> (*num_headers)++;
> args = amper;
> diff --git a/src/microhttpd/internal.h b/src/microhttpd/internal.h
> index 5668a8f8..1064fb21 100644
> --- a/src/microhttpd/internal.h
> +++ b/src/microhttpd/internal.h
> @@ -248,7 +248,7 @@ struct MHD_NonceNc
> */
> void
> MHD_DLOG (const struct MHD_Daemon *daemon,
> - const char *format,
> + const char *format,
> ...);
> #endif
>
> @@ -1850,9 +1850,9 @@ MHD_unescape_plus (char *arg);
> */
> typedef int
> (*MHD_ArgumentIterator_)(struct MHD_Connection *connection,
> - const char *key,
> - const char *value,
> - enum MHD_ValueKind kind);
> + const char *key,
> + const char *value,
> + enum MHD_ValueKind kind);
>
>
> /**
> @@ -1871,10 +1871,10 @@ typedef int
> */
> int
> MHD_parse_arguments_ (struct MHD_Connection *connection,
> - enum MHD_ValueKind kind,
> - char *args,
> - MHD_ArgumentIterator_ cb,
> - unsigned int *num_headers);
> + enum MHD_ValueKind kind,
> + char *args,
> + MHD_ArgumentIterator_ cb,
> + unsigned int *num_headers);
>
>
> /**
> diff --git a/src/microhttpd/md5.c b/src/microhttpd/md5.c
> index d92a42ee..370b11ef 100644
> --- a/src/microhttpd/md5.c
> +++ b/src/microhttpd/md5.c
> @@ -1,6 +1,6 @@
> /*
> * This code implements the MD5 message-digest algorithm.
> - * The algorithm is due to Ron Rivest. This code was
> + * The algorithm is due to Ron Rivest. This code was
> * written by Colin Plumb in 1993, no copyright is claimed.
> * This code is in the public domain; do with it what you wish.
> *
> @@ -20,21 +20,21 @@
> #include "md5.h"
> #include "mhd_byteorder.h"
>
> -#define PUT_64BIT_LE(cp, value) do { \
> - (cp)[7] = (uint8_t)((value) >> 56); \
> - (cp)[6] = (uint8_t)((value) >> 48); \
> - (cp)[5] = (uint8_t)((value) >> 40); \
> - (cp)[4] = (uint8_t)((value) >> 32); \
> - (cp)[3] = (uint8_t)((value) >> 24); \
> - (cp)[2] = (uint8_t)((value) >> 16); \
> - (cp)[1] = (uint8_t)((value) >> 8); \
> - (cp)[0] = (uint8_t)((value)); } while (0)
> -
> -#define PUT_32BIT_LE(cp, value) do { \
> - (cp)[3] = (uint8_t)((value) >> 24); \
> - (cp)[2] = (uint8_t)((value) >> 16); \
> - (cp)[1] = (uint8_t)((value) >> 8); \
> - (cp)[0] = (uint8_t)((value)); } while (0)
> +#define PUT_64BIT_LE(cp, value) do { \
> + (cp)[7] = (uint8_t)((value) >> 56); \
> + (cp)[6] = (uint8_t)((value) >> 48); \
> + (cp)[5] = (uint8_t)((value) >> 40); \
> + (cp)[4] = (uint8_t)((value) >> 32); \
> + (cp)[3] = (uint8_t)((value) >> 24); \
> + (cp)[2] = (uint8_t)((value) >> 16); \
> + (cp)[1] = (uint8_t)((value) >> 8); \
> + (cp)[0] = (uint8_t)((value)); } while (0)
> +
> +#define PUT_32BIT_LE(cp, value) do { \
> + (cp)[3] = (uint8_t)((value) >> 24); \
> + (cp)[2] = (uint8_t)((value) >> 16); \
> + (cp)[1] = (uint8_t)((value) >> 8); \
> + (cp)[0] = (uint8_t)((value)); } while (0)
>
> static uint8_t PADDING[MD5_BLOCK_SIZE] = {
> 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
> @@ -124,7 +124,7 @@ MD5Pad(struct MD5Context *ctx)
> ((ctx->count >> 3) & (MD5_BLOCK_SIZE - 1));
> if (padlen < 1 + 8)
> padlen += MD5_BLOCK_SIZE;
> - MD5Update(ctx, PADDING, padlen - 8); /* padlen - 8 <= 64 */
> + MD5Update(ctx, PADDING, padlen - 8); /* padlen - 8 <= 64 */
> MD5Update(ctx, count, 8);
> }
>
> @@ -157,7 +157,7 @@ MD5Final(unsigned char digest[MD5_DIGEST_SIZE], struct
> MD5Context *ctx)
>
> /* This is the central step in the MD5 algorithm. */
> #define MD5STEP(f, w, x, y, z, data, s) \
> - ( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
> + ( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
>
> /*
> * The core of the MD5 algorithm, this alters an existing MD5 hash to
> diff --git a/src/microhttpd/md5.h b/src/microhttpd/md5.h
> index ad1151e9..5d39a3b4 100644
> --- a/src/microhttpd/md5.h
> +++ b/src/microhttpd/md5.h
> @@ -1,6 +1,6 @@
> /*
> * This code implements the MD5 message-digest algorithm.
> - * The algorithm is due to Ron Rivest. This code was
> + * The algorithm is due to Ron Rivest. This code was
> * written by Colin Plumb in 1993, no copyright is claimed.
> * This code is in the public domain; do with it what you wish.
> *
> @@ -20,15 +20,15 @@
>
> #include "platform.h"
>
> -#define MD5_BLOCK_SIZE 64
> -#define MD5_DIGEST_SIZE 16
> -#define MD5_DIGEST_STRING_LENGTH (MD5_DIGEST_SIZE * 2 + 1)
> +#define MD5_BLOCK_SIZE 64
> +#define MD5_DIGEST_SIZE 16
> +#define MD5_DIGEST_STRING_LENGTH (MD5_DIGEST_SIZE * 2 + 1)
>
> struct MD5Context
> {
> - uint32_t state[4]; /* state */
> - uint64_t count; /* number of bits, mod 2^64 */
> - uint8_t buffer[MD5_BLOCK_SIZE]; /* input buffer */
> + uint32_t state[4]; /* state */
> + uint64_t count; /* number of bits, mod 2^64 */
> + uint8_t buffer[MD5_BLOCK_SIZE]; /* input buffer */
> };
>
> /*
> diff --git a/src/microhttpd/memorypool.c b/src/microhttpd/memorypool.c
> index bda45e1e..0996f795 100644
> --- a/src/microhttpd/memorypool.c
> +++ b/src/microhttpd/memorypool.c
> @@ -114,7 +114,7 @@ MHD_pool_create (size_t max)
> pool->memory = mmap (NULL,
> max,
> PROT_READ | PROT_WRITE,
> - MAP_PRIVATE | MAP_ANONYMOUS,
> + MAP_PRIVATE | MAP_ANONYMOUS,
> -1,
> 0);
> #elif defined(_WIN32)
> @@ -201,7 +201,7 @@ MHD_pool_get_free (struct MemoryPool *pool)
> */
> void *
> MHD_pool_allocate (struct MemoryPool *pool,
> - size_t size,
> + size_t size,
> int from_end)
> {
> void *ret;
> @@ -247,8 +247,8 @@ MHD_pool_allocate (struct MemoryPool *pool,
> void *
> MHD_pool_reallocate (struct MemoryPool *pool,
> void *old,
> - size_t old_size,
> - size_t new_size)
> + size_t old_size,
> + size_t new_size)
> {
> void *ret;
> size_t asize;
> @@ -312,8 +312,8 @@ MHD_pool_reallocate (struct MemoryPool *pool,
> */
> void *
> MHD_pool_reset (struct MemoryPool *pool,
> - void *keep,
> - size_t copy_bytes,
> + void *keep,
> + size_t copy_bytes,
> size_t new_size)
> {
> if ( (NULL != keep) &&
> diff --git a/src/microhttpd/memorypool.h b/src/microhttpd/memorypool.h
> index 36136af8..cdc81799 100644
> --- a/src/microhttpd/memorypool.h
> +++ b/src/microhttpd/memorypool.h
> @@ -70,7 +70,7 @@ MHD_pool_destroy (struct MemoryPool *pool);
> */
> void *
> MHD_pool_allocate (struct MemoryPool *pool,
> - size_t size,
> + size_t size,
> int from_end);
>
>
> @@ -93,9 +93,9 @@ MHD_pool_allocate (struct MemoryPool *pool,
> */
> void *
> MHD_pool_reallocate (struct MemoryPool *pool,
> - void *old,
> - size_t old_size,
> - size_t new_size);
> + void *old,
> + size_t old_size,
> + size_t new_size);
>
>
> /**
> @@ -123,8 +123,8 @@ MHD_pool_get_free (struct MemoryPool *pool);
> */
> void *
> MHD_pool_reset (struct MemoryPool *pool,
> - void *keep,
> - size_t copy_bytes,
> + void *keep,
> + size_t copy_bytes,
> size_t new_size);
>
> #endif
> diff --git a/src/microhttpd/postprocessor.c b/src/microhttpd/postprocessor.c
> index 8b710ea1..3a1c0da1 100644
> --- a/src/microhttpd/postprocessor.c
> +++ b/src/microhttpd/postprocessor.c
> @@ -307,7 +307,7 @@ MHD_create_post_processor (struct MHD_Connection
> *connection,
> /* Q: should this be "strcasestr"? */
> boundary = strstr (boundary, "boundary=");
> if (NULL == boundary)
> - return NULL; /* failed to determine boundary */
> + return NULL; /* failed to determine boundary */
> boundary += MHD_STATICSTR_LEN_ ("boundary=");
> blen = strlen (boundary);
> if ( (blen == 0) ||
> @@ -315,11 +315,11 @@ MHD_create_post_processor (struct MHD_Connection
> *connection,
> return NULL; /* (will be) out of memory or invalid
> boundary */
> if ( (boundary[0] == '"') &&
> (boundary[blen - 1] == '"') )
> - {
> - /* remove enclosing quotes */
> - ++boundary;
> - blen -= 2;
> - }
> + {
> + /* remove enclosing quotes */
> + ++boundary;
> + blen -= 2;
> + }
> }
> else
> blen = 0;
> @@ -352,7 +352,7 @@ MHD_create_post_processor (struct MHD_Connection
> *connection,
> static int
> post_process_urlencoded (struct MHD_PostProcessor *pp,
> const char *post_data,
> - size_t post_data_len)
> + size_t post_data_len)
> {
> size_t equals;
> size_t amper;
> @@ -391,7 +391,7 @@ post_process_urlencoded (struct MHD_PostProcessor *pp,
> return MHD_YES; /* no '=' yet */
> buf[pp->buffer_pos] = '\0'; /* 0-terminate key */
> pp->buffer_pos = 0; /* reset for next key */
> - MHD_unescape_plus (buf);
> + MHD_unescape_plus (buf);
> MHD_http_unescape (buf);
> poff += equals + 1;
> pp->state = PP_ProcessValue;
> @@ -457,10 +457,10 @@ post_process_urlencoded (struct MHD_PostProcessor *pp,
>
> /* unescape */
> xbuf[xoff] = '\0'; /* 0-terminate in preparation */
> - MHD_unescape_plus (xbuf);
> + MHD_unescape_plus (xbuf);
> xoff = MHD_http_unescape (xbuf);
> /* finally: call application! */
> - pp->must_ikvi = MHD_NO;
> + pp->must_ikvi = MHD_NO;
> if (MHD_NO == pp->ikvi (pp->cls,
> MHD_POSTDATA_KIND,
> (const char *) &pp[1], /* key */
> @@ -621,8 +621,8 @@ find_boundary (struct MHD_PostProcessor *pp,
> */
> static void
> try_get_value (const char *buf,
> - const char *key,
> - char **destination)
> + const char *key,
> + char **destination)
> {
> const char *spos;
> const char *bpos;
> @@ -824,14 +824,14 @@ process_value_to_boundary (struct MHD_PostProcessor *pp,
> at least at the last character that we are sure
> is not part of the boundary */
> if ( ( (MHD_YES == pp->must_ikvi) ||
> - (0 != newline) ) &&
> + (0 != newline) ) &&
> (MHD_NO == pp->ikvi (pp->cls,
> - MHD_POSTDATA_KIND,
> - pp->content_name,
> - pp->content_filename,
> - pp->content_type,
> - pp->content_transfer_encoding,
> - buf,
> + MHD_POSTDATA_KIND,
> + pp->content_name,
> + pp->content_filename,
> + pp->content_type,
> + pp->content_transfer_encoding,
> + buf,
> pp->value_offset,
> newline)) )
> {
> @@ -890,7 +890,7 @@ free_unmarked (struct MHD_PostProcessor *pp)
> static int
> post_process_multipart (struct MHD_PostProcessor *pp,
> const char *post_data,
> - size_t post_data_len)
> + size_t post_data_len)
> {
> char *buf;
> size_t max;
> @@ -1006,10 +1006,10 @@ post_process_multipart (struct MHD_PostProcessor *pp,
> * > line or after the last one.
> */
> (void) find_boundary (pp,
> - pp->boundary,
> - pp->blen,
> - &ioff,
> - PP_ProcessEntryHeaders,
> + pp->boundary,
> + pp->blen,
> + &ioff,
> + PP_ProcessEntryHeaders,
> PP_Done);
> break;
> case PP_NextBoundary:
> @@ -1026,7 +1026,7 @@ post_process_multipart (struct MHD_PostProcessor *pp,
> }
> break;
> case PP_ProcessEntryHeaders:
> - pp->must_ikvi = MHD_YES;
> + pp->must_ikvi = MHD_YES;
> if (MHD_NO ==
> process_multipart_headers (pp,
> &ioff,
> diff --git a/src/microhttpd/response.c b/src/microhttpd/response.c
> index d677cf62..003043ae 100644
> --- a/src/microhttpd/response.c
> +++ b/src/microhttpd/response.c
> @@ -67,9 +67,9 @@
> */
> static int
> add_response_entry (struct MHD_Response *response,
> - enum MHD_ValueKind kind,
> - const char *header,
> - const char *content)
> + enum MHD_ValueKind kind,
> + const char *header,
> + const char *content)
> {
> struct MHD_HTTP_Header *hdr;
>
> @@ -120,9 +120,9 @@ MHD_add_response_header (struct MHD_Response *response,
> const char *content)
> {
> return add_response_entry (response,
> - MHD_HEADER_KIND,
> - header,
> - content);
> + MHD_HEADER_KIND,
> + header,
> + content);
> }
>
>
> @@ -141,9 +141,9 @@ MHD_add_response_footer (struct MHD_Response *response,
> const char *content)
> {
> return add_response_entry (response,
> - MHD_FOOTER_KIND,
> - footer,
> - content);
> + MHD_FOOTER_KIND,
> + footer,
> + content);
> }
>
>
> @@ -159,7 +159,7 @@ MHD_add_response_footer (struct MHD_Response *response,
> int
> MHD_del_response_header (struct MHD_Response *response,
> const char *header,
> - const char *content)
> + const char *content)
> {
> struct MHD_HTTP_Header *pos;
> struct MHD_HTTP_Header *prev;
> @@ -236,7 +236,7 @@ MHD_get_response_headers (struct MHD_Response *response,
> */
> const char *
> MHD_get_response_header (struct MHD_Response *response,
> - const char *key)
> + const char *key)
> {
> struct MHD_HTTP_Header *pos;
>
> @@ -499,8 +499,8 @@ free_callback (void *cls)
> */
> struct MHD_Response *
> MHD_create_response_from_fd_at_offset (size_t size,
> - int fd,
> - off_t offset)
> + int fd,
> + off_t offset)
> {
> return MHD_create_response_from_fd_at_offset64 (size,
> fd,
> @@ -544,10 +544,10 @@ MHD_create_response_from_fd_at_offset64 (uint64_t size,
> return NULL;
>
> response = MHD_create_response_from_callback (size,
> - 4 * 1024,
> - &file_reader,
> - NULL,
> - &free_callback);
> + 4 * 1024,
> + &file_reader,
> + NULL,
> + &free_callback);
> if (NULL == response)
> return NULL;
> response->fd = fd;
> @@ -568,7 +568,7 @@ MHD_create_response_from_fd_at_offset64 (uint64_t size,
> */
> struct MHD_Response *
> MHD_create_response_from_fd (size_t size,
> - int fd)
> + int fd)
> {
> return MHD_create_response_from_fd_at_offset64 (size,
> fd,
> @@ -669,13 +669,13 @@ MHD_create_response_from_data (size_t size,
> */
> struct MHD_Response *
> MHD_create_response_from_buffer (size_t size,
> - void *buffer,
> - enum MHD_ResponseMemoryMode mode)
> + void *buffer,
> + enum MHD_ResponseMemoryMode mode)
> {
> return MHD_create_response_from_data (size,
> - buffer,
> - mode == MHD_RESPMEM_MUST_FREE,
> - mode == MHD_RESPMEM_MUST_COPY);
> + buffer,
> + mode == MHD_RESPMEM_MUST_FREE,
> + mode == MHD_RESPMEM_MUST_COPY);
> }
>
>
> @@ -812,7 +812,7 @@ MHD_response_execute_upgrade_ (struct MHD_Response
> *response,
> {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> - _("Failed to make loopback sockets non-blocking.\n"));
> + _("Failed to make loopback sockets non-blocking.\n"));
> #endif
> if (! res2)
> {
> @@ -906,7 +906,7 @@ MHD_response_execute_upgrade_ (struct MHD_Response
> *response,
> EPOLL_CTL_ADD,
> connection->socket_fd,
> &event))
> - {
> + {
> #ifdef HAVE_MESSAGES
> MHD_DLOG (daemon,
> _("Call to epoll_ctl failed: %s\n"),
> @@ -916,7 +916,7 @@ MHD_response_execute_upgrade_ (struct MHD_Response
> *response,
> MHD_socket_close_chk_ (sv[1]);
> free (urh);
> return MHD_NO;
> - }
> + }
>
> /* Second, add our end of the UNIX socketpair() */
> event.events = EPOLLIN | EPOLLOUT | EPOLLPRI | EPOLLET;
> @@ -925,7 +925,7 @@ MHD_response_execute_upgrade_ (struct MHD_Response
> *response,
> EPOLL_CTL_ADD,
> urh->mhd.socket,
> &event))
> - {
> + {
> event.events = EPOLLIN | EPOLLOUT | EPOLLPRI;
> event.data.ptr = &urh->app;
> if (0 != epoll_ctl (daemon->epoll_upgrade_fd,
> @@ -942,11 +942,11 @@ MHD_response_execute_upgrade_ (struct MHD_Response
> *response,
> MHD_socket_close_chk_ (sv[1]);
> free (urh);
> return MHD_NO;
> - }
> - EDLL_insert (daemon->eready_urh_head,
> - daemon->eready_urh_tail,
> - urh);
> - urh->in_eready_list = true;
> + }
> + EDLL_insert (daemon->eready_urh_head,
> + daemon->eready_urh_tail,
> + urh);
> + urh->in_eready_list = true;
> }
> #endif /* EPOLL_SUPPORT */
> if (0 == (daemon->options & MHD_USE_THREAD_PER_CONNECTION) )
> @@ -1025,7 +1025,7 @@ MHD_response_execute_upgrade_ (struct MHD_Response
> *response,
> */
> _MHD_EXTERN struct MHD_Response *
> MHD_create_response_for_upgrade (MHD_UpgradeHandler upgrade_handler,
> - void *upgrade_handler_cls)
> + void *upgrade_handler_cls)
> {
> struct MHD_Response *response;
>
> diff --git a/src/microhttpd/test_upgrade.c b/src/microhttpd/test_upgrade.c
> index 62d4afbd..3517c49b 100644
> --- a/src/microhttpd/test_upgrade.c
> +++ b/src/microhttpd/test_upgrade.c
> @@ -1004,15 +1004,15 @@ test_upgrade (int flags,
>
> if (!test_tls)
> d = MHD_start_daemon (flags | MHD_USE_ERROR_LOG | MHD_ALLOW_UPGRADE,
> -
> MHD_is_feature_supported(MHD_FEATURE_AUTODETECT_BIND_PORT) ?
> - 0 : 1090,
> - NULL, NULL,
> - &ahc_upgrade, NULL,
> - MHD_OPTION_URI_LOG_CALLBACK, &log_cb, NULL,
> - MHD_OPTION_NOTIFY_COMPLETED, ¬ify_completed_cb,
> NULL,
> - MHD_OPTION_NOTIFY_CONNECTION, ¬ify_connection_cb,
> NULL,
> - MHD_OPTION_THREAD_POOL_SIZE, pool,
> - MHD_OPTION_END);
> + MHD_is_feature_supported(MHD_FEATURE_AUTODETECT_BIND_PORT) ?
> + 0 : 1090,
> + NULL, NULL,
> + &ahc_upgrade, NULL,
> + MHD_OPTION_URI_LOG_CALLBACK, &log_cb, NULL,
> + MHD_OPTION_NOTIFY_COMPLETED, ¬ify_completed_cb, NULL,
> + MHD_OPTION_NOTIFY_CONNECTION, ¬ify_connection_cb, NULL,
> + MHD_OPTION_THREAD_POOL_SIZE, pool,
> + MHD_OPTION_END);
> #ifdef HTTPS_SUPPORT
> else
> d = MHD_start_daemon (flags | MHD_USE_ERROR_LOG | MHD_ALLOW_UPGRADE |
> MHD_USE_TLS,
> diff --git a/src/microhttpd/tsearch.c b/src/microhttpd/tsearch.c
> index fe5fcd5b..b274023f 100644
> --- a/src/microhttpd/tsearch.c
> +++ b/src/microhttpd/tsearch.c
> @@ -13,7 +13,7 @@
> #include <stdlib.h>
>
>
> -typedef struct node
> +typedef struct node
> {
> const void *key;
> struct node *llink;
> @@ -21,11 +21,11 @@ typedef struct node
> } node_t;
>
>
> -/* $NetBSD: tsearch.c,v 1.5 2005/11/29 03:12:00 christos Exp $ */
> +/* $NetBSD: tsearch.c,v 1.5 2005/11/29 03:12:00 christos Exp $ */
> /* find or insert datum into search tree */
> void *
> -tsearch (const void *vkey, /* key to be located */
> - void **vrootp, /* address of tree root */
> +tsearch (const void *vkey, /* key to be located */
> + void **vrootp, /* address of tree root */
> int (*compar)(const void *, const void *))
> {
> node_t *q;
> @@ -35,29 +35,29 @@ tsearch (const void *vkey, /* key to be
> located */
> return NULL;
>
> while (*rootp != NULL)
> - { /* Knuth's T1: */
> + { /* Knuth's T1: */
> int r;
>
> - if ((r = (*compar)(vkey, (*rootp)->key)) == 0) /* T2: */
> - return *rootp; /* we found it! */
> + if ((r = (*compar)(vkey, (*rootp)->key)) == 0) /* T2: */
> + return *rootp; /* we found it! */
>
> rootp = (r < 0) ?
> - &(*rootp)->llink : /* T3: follow left branch */
> - &(*rootp)->rlink; /* T4: follow right branch */
> + &(*rootp)->llink : /* T3: follow left branch */
> + &(*rootp)->rlink; /* T4: follow right branch */
> }
>
> - q = malloc (sizeof(node_t)); /* T5: key not found */
> + q = malloc (sizeof(node_t)); /* T5: key not found */
> if (q)
> - { /* make new node */
> - *rootp = q; /* link new node to old */
> - q->key = vkey; /* initialize new node */
> + { /* make new node */
> + *rootp = q; /* link new node to old */
> + q->key = vkey; /* initialize new node */
> q->llink = q->rlink = NULL;
> }
> return q;
> }
>
>
> -/* $NetBSD: tfind.c,v 1.5 2005/03/23 08:16:53 kleink Exp $ */
> +/* $NetBSD: tfind.c,v 1.5 2005/03/23 08:16:53 kleink Exp $ */
> /* find a node, or return NULL */
> void *
> tfind (const void *vkey, /* key to be found */
> @@ -70,20 +70,20 @@ tfind (const void *vkey, /* key to be found */
> return NULL;
>
> while (*rootp != NULL)
> - { /* T1: */
> + { /* T1: */
> int r;
>
> - if ((r = (*compar)(vkey, (*rootp)->key)) == 0) /* T2: */
> - return *rootp; /* key found */
> + if ((r = (*compar)(vkey, (*rootp)->key)) == 0) /* T2: */
> + return *rootp; /* key found */
> rootp = (r < 0) ?
> - &(*rootp)->llink : /* T3: follow left branch */
> - &(*rootp)->rlink; /* T4: follow right branch */
> + &(*rootp)->llink : /* T3: follow left branch */
> + &(*rootp)->rlink; /* T4: follow right branch */
> }
> return NULL;
> }
>
>
> -/* $NetBSD: tdelete.c,v 1.2 1999/09/16 11:45:37 lukem Exp $ */
> +/* $NetBSD: tdelete.c,v 1.2 1999/09/16 11:45:37 lukem Exp $ */
> /*
> * delete node with given key
> *
> @@ -109,25 +109,25 @@ tdelete (const void * __restrict vkey,
> {
> p = *rootp;
> rootp = (cmp < 0) ?
> - &(*rootp)->llink : /* follow llink branch */
> - &(*rootp)->rlink; /* follow rlink branch */
> + &(*rootp)->llink : /* follow llink branch */
> + &(*rootp)->rlink; /* follow rlink branch */
> if (*rootp == NULL)
> - return NULL; /* key not found */
> + return NULL; /* key not found */
> }
> - r = (*rootp)->rlink; /* D1: */
> - if ((q = (*rootp)->llink) == NULL) /* Left NULL? */
> + r = (*rootp)->rlink; /* D1: */
> + if ((q = (*rootp)->llink) == NULL) /* Left NULL? */
> {
> q = r;
> }
> else if (r != NULL)
> - { /* Right link is NULL? */
> + { /* Right link is NULL? */
> if (r->llink == NULL)
> - { /* D2: Find successor */
> + { /* D2: Find successor */
> r->llink = q;
> q = r;
> }
> else
> - { /* D3: Find NULL link */
> + { /* D3: Find NULL link */
> for (q = r->llink; q->llink != NULL; q = r->llink)
> r = q;
> r->llink = q->rlink;
> @@ -135,8 +135,8 @@ tdelete (const void * __restrict vkey,
> q->rlink = (*rootp)->rlink;
> }
> }
> - free(*rootp); /* D4: Free node */
> - *rootp = q; /* link parent to new node */
> + free(*rootp); /* D4: Free node */
> + *rootp = q; /* link parent to new node */
> return p;
> }
>
> diff --git a/src/microhttpd/tsearch.h b/src/microhttpd/tsearch.h
> index aa186495..e5bb8bb4 100644
> --- a/src/microhttpd/tsearch.h
> +++ b/src/microhttpd/tsearch.h
> @@ -2,7 +2,7 @@
> * Written by J.T. Conklin <address@hidden>
> * Public domain.
> *
> - * $NetBSD: search.h,v 1.12 1999/02/22 10:34:28 christos Exp $
> + * $NetBSD: search.h,v 1.12 1999/02/22 10:34:28 christos Exp $
> * $FreeBSD: release/9.0.0/include/search.h 105250 2002-10-16 14:29:23Z
> robert $
> */
>
> @@ -14,19 +14,19 @@ extern "C" {
> #endif /* __cplusplus */
>
>
> -void *
> +void *
> tdelete (const void * __restrict,
> void ** __restrict,
> int (*)(const void *, const void *));
>
>
> -void *
> +void *
> tfind (const void *,
> void * const *,
> int (*)(const void *, const void *));
>
>
> -void *
> +void *
> tsearch (const void *,
> void **,
> int (*)(const void *, const void *));
> diff --git a/src/testcurl/gauger.h b/src/testcurl/gauger.h
> index 6698f5d5..405b7d19 100644
> --- a/src/testcurl/gauger.h
> +++ b/src/testcurl/gauger.h
> @@ -19,7 +19,7 @@
>
> #define GAUGER(category, counter, value, unit)\
> {\
> - const char * __gauger_v[10]; \
> + const char * __gauger_v[10]; \
> char __gauger_s[32];\
> pid_t __gauger_p;\
> if(!(__gauger_p=fork())){\
> @@ -27,15 +27,15 @@
> sprintf(__gauger_s,"%Lf", (long double) (value));\
> __gauger_v[0] = "gauger";\
> __gauger_v[1] = "-n";\
> - __gauger_v[2] = counter; \
> + __gauger_v[2] = counter; \
> __gauger_v[3] = "-d";\
> __gauger_v[4] = __gauger_s;\
> __gauger_v[5] = "-u";\
> - __gauger_v[6] = unit; \
> + __gauger_v[6] = unit; \
> __gauger_v[7] = "-c";\
> - __gauger_v[8] = category; \
> + __gauger_v[8] = category; \
> __gauger_v[9] = (char *)NULL;\
> - execvp("gauger", (char*const*) __gauger_v); \
> + execvp("gauger", (char*const*) __gauger_v); \
> _exit(1);\
> }else{\
> _exit(0);\
> diff --git a/src/testcurl/https/test_empty_response.c
> b/src/testcurl/https/test_empty_response.c
> index 27cb1e31..94eea518 100644
> --- a/src/testcurl/https/test_empty_response.c
> +++ b/src/testcurl/https/test_empty_response.c
> @@ -53,7 +53,7 @@ ahc_echo (void *cls,
> (void)upload_data;(void)upload_data_size;(void)unused; /* Unused.
> Silent compiler warning. */
>
> response = MHD_create_response_from_buffer (0, NULL,
> - MHD_RESPMEM_PERSISTENT);
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> return ret;
> @@ -92,7 +92,7 @@ testInternalSelectGet ()
> port, NULL, NULL, &ahc_echo, "GET",
> MHD_OPTION_HTTPS_MEM_KEY, srv_key_pem,
> MHD_OPTION_HTTPS_MEM_CERT, srv_self_signed_cert_pem,
> - MHD_OPTION_END);
> + MHD_OPTION_END);
> if (d == NULL)
> return 256;
>
> diff --git a/src/testcurl/https/test_https_get.c
> b/src/testcurl/https/test_https_get.c
> index 61c25643..72b231ac 100644
> --- a/src/testcurl/https/test_https_get.c
> +++ b/src/testcurl/https/test_https_get.c
> @@ -40,8 +40,8 @@ extern const char srv_signed_key_pem[];
> /* perform a HTTP GET request via SSL/TLS */
> static int
> test_secure_get (FILE * test_fd,
> - const char *cipher_suite,
> - int proto_version)
> + const char *cipher_suite,
> + int proto_version)
> {
> int ret;
> struct MHD_Daemon *d;
> diff --git a/src/testcurl/https/test_https_get_select.c
> b/src/testcurl/https/test_https_get_select.c
> index 64be861a..dc8ecf52 100644
> --- a/src/testcurl/https/test_https_get_select.c
> +++ b/src/testcurl/https/test_https_get_select.c
> @@ -63,8 +63,8 @@ ahc_echo (void *cls,
> }
> *unused = NULL;
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> if (ret == MHD_NO)
> @@ -111,7 +111,7 @@ testExternalGet (int flags)
> port, NULL, NULL, &ahc_echo, "GET",
> MHD_OPTION_HTTPS_MEM_KEY, srv_key_pem,
> MHD_OPTION_HTTPS_MEM_CERT, srv_self_signed_cert_pem,
> - MHD_OPTION_END);
> + MHD_OPTION_END);
> if (d == NULL)
> return 256;
> if (0 == port)
> diff --git a/src/testcurl/https/test_https_multi_daemon.c
> b/src/testcurl/https/test_https_multi_daemon.c
> index 130fa9df..16e0fb23 100644
> --- a/src/testcurl/https/test_https_multi_daemon.c
> +++ b/src/testcurl/https/test_https_multi_daemon.c
> @@ -43,7 +43,7 @@ extern const char srv_self_signed_cert_pem[];
> */
> static int
> test_concurent_daemon_pair (void *cls,
> - const char *cipher_suite,
> + const char *cipher_suite,
> int proto_version)
> {
> int ret;
> @@ -165,7 +165,7 @@ main (int argc, char *const *argv)
> fclose (cert);
> if (0 != remove (ca_cert_file_name))
> fprintf (stderr,
> - "Failed to remove `%s'\n",
> - ca_cert_file_name);
> + "Failed to remove `%s'\n",
> + ca_cert_file_name);
> return errorCount != 0 ? 1 : 0;
> }
> diff --git a/src/testcurl/https/test_https_session_info.c
> b/src/testcurl/https/test_https_session_info.c
> index a58c7f7b..64ccfb7c 100644
> --- a/src/testcurl/https/test_https_session_info.c
> +++ b/src/testcurl/https/test_https_session_info.c
> @@ -61,7 +61,7 @@ query_session_ahc (void *cls, struct MHD_Connection
> *connection,
> if (GNUTLS_TLS1_1 !=
> (ret = MHD_get_connection_info
> (connection,
> - MHD_CONNECTION_INFO_PROTOCOL)->protocol))
> + MHD_CONNECTION_INFO_PROTOCOL)->protocol))
> {
> if (GNUTLS_TLS1_2 == ret)
> {
> @@ -82,8 +82,8 @@ query_session_ahc (void *cls, struct MHD_Connection
> *connection,
> }
>
> response = MHD_create_response_from_buffer (strlen (EMPTY_PAGE),
> - (void *) EMPTY_PAGE,
> - MHD_RESPMEM_PERSISTENT);
> + (void *) EMPTY_PAGE,
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> return ret;
> @@ -117,7 +117,7 @@ test_query_session ()
> d = MHD_start_daemon (MHD_USE_THREAD_PER_CONNECTION |
> MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_TLS |
> MHD_USE_ERROR_LOG, port,
> NULL, NULL, &query_session_ahc, NULL,
> - MHD_OPTION_HTTPS_PRIORITIES, "NORMAL:+ARCFOUR-128",
> + MHD_OPTION_HTTPS_PRIORITIES, "NORMAL:+ARCFOUR-128",
> MHD_OPTION_HTTPS_MEM_KEY, srv_key_pem,
> MHD_OPTION_HTTPS_MEM_CERT, srv_self_signed_cert_pem,
> MHD_OPTION_END);
> diff --git a/src/testcurl/https/test_tls_authentication.c
> b/src/testcurl/https/test_tls_authentication.c
> index 7a6cd9a4..479b3ad5 100644
> --- a/src/testcurl/https/test_tls_authentication.c
> +++ b/src/testcurl/https/test_tls_authentication.c
> @@ -123,7 +123,7 @@ main (int argc, char *const *argv)
> curl_global_cleanup ();
> if (0 != remove (ca_cert_file_name))
> fprintf (stderr,
> - "Failed to remove `%s'\n",
> - ca_cert_file_name);
> + "Failed to remove `%s'\n",
> + ca_cert_file_name);
> return errorCount != 0 ? 1 : 0;
> }
> diff --git a/src/testcurl/https/test_tls_extensions.c
> b/src/testcurl/https/test_tls_extensions.c
> index 08cde939..5d6931ca 100644
> --- a/src/testcurl/https/test_tls_extensions.c
> +++ b/src/testcurl/https/test_tls_extensions.c
> @@ -102,8 +102,8 @@ test_hello_extension (gnutls_session_t session, int port,
> extensions_t exten_t,
> data = MHD_gnutls_malloc (datalen);
> if (data == NULL)
> {
> - free (cbc.buf);
> - return -1;
> + free (cbc.buf);
> + return -1;
> }
> hver = MHD_gtls_version_max (session);
> data[pos++] = MHD_gtls_version_get_major (hver);
> @@ -178,7 +178,7 @@ test_hello_extension (gnutls_session_t session, int port,
> extensions_t exten_t,
>
> /* this should crash the server */
> ret = gnutls_send_handshake (session, data, datalen,
> - GNUTLS_HANDSHAKE_CLIENT_HELLO);
> + GNUTLS_HANDSHAKE_CLIENT_HELLO);
>
> /* advance to STATE2 */
> session->internals.handshake_state = STATE2;
> diff --git a/src/testcurl/https/test_tls_options.c
> b/src/testcurl/https/test_tls_options.c
> index e3b427d9..111facee 100644
> --- a/src/testcurl/https/test_tls_options.c
> +++ b/src/testcurl/https/test_tls_options.c
> @@ -135,28 +135,28 @@ main (int argc, char *const *argv)
>
> if (0 !=
> test_wrap ("TLS1.0-AES-SHA1",
> - &test_https_transfer, NULL, port, daemon_flags,
> - aes128_sha,
> - CURL_SSLVERSION_TLSv1,
> - MHD_OPTION_HTTPS_MEM_KEY, srv_key_pem,
> - MHD_OPTION_HTTPS_MEM_CERT, srv_self_signed_cert_pem,
> - MHD_OPTION_HTTPS_PRIORITIES,
> "NONE:+VERS-TLS1.0:+AES-128-CBC:+SHA1:+RSA:+COMP-NULL",
> - MHD_OPTION_END))
> + &test_https_transfer, NULL, port, daemon_flags,
> + aes128_sha,
> + CURL_SSLVERSION_TLSv1,
> + MHD_OPTION_HTTPS_MEM_KEY, srv_key_pem,
> + MHD_OPTION_HTTPS_MEM_CERT, srv_self_signed_cert_pem,
> + MHD_OPTION_HTTPS_PRIORITIES,
> "NONE:+VERS-TLS1.0:+AES-128-CBC:+SHA1:+RSA:+COMP-NULL",
> + MHD_OPTION_END))
> {
> fprintf (stderr, "TLS1.0-AES-SHA1 test failed\n");
> errorCount++;
> }
> fprintf (stderr,
> - "The following handshake should fail (and print an error
> message)...\n");
> + "The following handshake should fail (and print an error
> message)...\n");
> if (0 !=
> test_wrap ("TLS1.0 vs SSL3",
> - &test_unmatching_ssl_version, NULL, port, daemon_flags,
> - aes256_sha,
> - CURL_SSLVERSION_SSLv3,
> - MHD_OPTION_HTTPS_MEM_KEY, srv_key_pem,
> - MHD_OPTION_HTTPS_MEM_CERT, srv_self_signed_cert_pem,
> - MHD_OPTION_HTTPS_PRIORITIES,
> "NONE:+VERS-TLS1.0:+AES-256-CBC:+SHA1:+RSA:+COMP-NULL",
> - MHD_OPTION_END))
> + &test_unmatching_ssl_version, NULL, port, daemon_flags,
> + aes256_sha,
> + CURL_SSLVERSION_SSLv3,
> + MHD_OPTION_HTTPS_MEM_KEY, srv_key_pem,
> + MHD_OPTION_HTTPS_MEM_CERT, srv_self_signed_cert_pem,
> + MHD_OPTION_HTTPS_PRIORITIES,
> "NONE:+VERS-TLS1.0:+AES-256-CBC:+SHA1:+RSA:+COMP-NULL",
> + MHD_OPTION_END))
> {
> fprintf (stderr, "TLS1.0 vs SSL3 test failed\n");
> errorCount++;
> diff --git a/src/testcurl/https/tls_test_common.c
> b/src/testcurl/https/tls_test_common.c
> index a3a7df24..fb7e93a8 100644
> --- a/src/testcurl/https/tls_test_common.c
> +++ b/src/testcurl/https/tls_test_common.c
> @@ -62,9 +62,9 @@ setup_ca_cert ()
> */
> int
> test_daemon_get (void *cls,
> - const char *cipher_suite, int proto_version,
> - int port,
> - int ver_peer)
> + const char *cipher_suite, int proto_version,
> + int port,
> + int ver_peer)
> {
> CURL *c;
> struct CBC cbc;
> @@ -184,8 +184,8 @@ http_ahc (void *cls, struct MHD_Connection *connection,
> }
> *ptr = NULL; /* reset when done */
> response = MHD_create_response_from_buffer (strlen (test_data),
> - (void *) test_data,
> - MHD_RESPMEM_PERSISTENT);
> + (void *) test_data,
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> return ret;
> @@ -372,8 +372,8 @@ test_https_transfer (void *cls,
> /* compare test file & daemon responce */
> if ( (len != strlen (test_data)) ||
> (memcmp (cbc.buf,
> - test_data,
> - len) != 0) )
> + test_data,
> + len) != 0) )
> {
> fprintf (stderr, "Error: local file & received file differ.\n");
> ret = -1;
> @@ -428,7 +428,7 @@ int
> setup_session (gnutls_session_t * session,
> gnutls_datum_t * key,
> gnutls_datum_t * cert,
> - gnutls_certificate_credentials_t * xcred)
> + gnutls_certificate_credentials_t * xcred)
> {
> int ret;
> const char *err_pos;
> @@ -439,7 +439,7 @@ setup_session (gnutls_session_t * session,
> if (NULL == key->data)
> {
> gnutls_certificate_free_credentials (*xcred);
> - return -1;
> + return -1;
> }
> memcpy (key->data, srv_key_pem, key->size);
> cert->size = strlen (srv_self_signed_cert_pem) + 1;
> @@ -447,15 +447,15 @@ setup_session (gnutls_session_t * session,
> if (NULL == cert->data)
> {
> gnutls_certificate_free_credentials (*xcred);
> - free (key->data);
> - return -1;
> + free (key->data);
> + return -1;
> }
> memcpy (cert->data, srv_self_signed_cert_pem, cert->size);
> gnutls_certificate_set_x509_key_mem (*xcred, cert, key,
> - GNUTLS_X509_FMT_PEM);
> + GNUTLS_X509_FMT_PEM);
> gnutls_init (session, GNUTLS_CLIENT);
> ret = gnutls_priority_set_direct (*session,
> - "NORMAL", &err_pos);
> + "NORMAL", &err_pos);
> if (ret < 0)
> {
> gnutls_deinit (*session);
> @@ -464,8 +464,8 @@ setup_session (gnutls_session_t * session,
> return -1;
> }
> gnutls_credentials_set (*session,
> - GNUTLS_CRD_CERTIFICATE,
> - *xcred);
> + GNUTLS_CRD_CERTIFICATE,
> + *xcred);
> return 0;
> }
>
> diff --git a/src/testcurl/https/tls_test_common.h
> b/src/testcurl/https/tls_test_common.h
> index 490239ef..e4c70145 100644
> --- a/src/testcurl/https/tls_test_common.h
> +++ b/src/testcurl/https/tls_test_common.h
> @@ -83,7 +83,7 @@ setup_ca_cert (void);
> */
> int
> test_daemon_get (void * cls,
> - const char *cipher_suite, int proto_version,
> + const char *cipher_suite, int proto_version,
> int port, int ver_peer);
>
> void
> diff --git a/src/testcurl/perf_get.c b/src/testcurl/perf_get.c
> index 98578173..af64519a 100644
> --- a/src/testcurl/perf_get.c
> +++ b/src/testcurl/perf_get.c
> @@ -91,7 +91,7 @@ now ()
>
> gettimeofday (&tv, NULL);
> return (((unsigned long long) tv.tv_sec * 1000LL) +
> - ((unsigned long long) tv.tv_usec / 1000LL));
> + ((unsigned long long) tv.tv_usec / 1000LL));
> }
>
>
> @@ -116,14 +116,14 @@ stop (const char *desc)
> double rps = ((double) (ROUNDS * 1000)) / ((double) (now() - start_time));
>
> fprintf (stderr,
> - "Sequential GETs using %s: %f %s\n",
> - desc,
> - rps,
> - "requests/s");
> + "Sequential GETs using %s: %f %s\n",
> + desc,
> + rps,
> + "requests/s");
> GAUGER (desc,
> - "Sequential GETs",
> - rps,
> - "requests/s");
> + "Sequential GETs",
> + rps,
> + "requests/s");
> }
>
>
> @@ -137,8 +137,8 @@ struct CBC
>
> static size_t
> copyBuffer (void *ptr,
> - size_t size, size_t nmemb,
> - void *ctx)
> + size_t size, size_t nmemb,
> + void *ctx)
> {
> struct CBC *cbc = ctx;
>
> @@ -220,27 +220,27 @@ testInternalGet (int port, int poll_flag)
> curl_easy_setopt (c, CURLOPT_TIMEOUT, 150L);
> curl_easy_setopt (c, CURLOPT_CONNECTTIMEOUT, 150L);
> if (oneone)
> - curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
> + curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
> else
> - curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
> + curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
> /* NOTE: use of CONNECTTIMEOUT without also
> - setting NOSIGNAL results in really weird
> - crashes on my system!*/
> + setting NOSIGNAL results in really weird
> + crashes on my system!*/
> curl_easy_setopt (c, CURLOPT_NOSIGNAL, 1);
> if (CURLE_OK != (errornum = curl_easy_perform (c)))
> - {
> - fprintf (stderr,
> - "curl_easy_perform failed: `%s'\n",
> - curl_easy_strerror (errornum));
> - curl_easy_cleanup (c);
> - MHD_stop_daemon (d);
> - return 2;
> - }
> + {
> + fprintf (stderr,
> + "curl_easy_perform failed: `%s'\n",
> + curl_easy_strerror (errornum));
> + curl_easy_cleanup (c);
> + MHD_stop_daemon (d);
> + return 2;
> + }
> curl_easy_cleanup (c);
> }
> stop (poll_flag == MHD_USE_AUTO ? "internal thread with 'auto'" :
> poll_flag == MHD_USE_POLL ? "internal thread with poll()" :
> - poll_flag == MHD_USE_EPOLL ? "internal thread with epoll" : "internal
> thread with select()");
> + poll_flag == MHD_USE_EPOLL ? "internal thread with epoll" : "internal
> thread with select()");
> MHD_stop_daemon (d);
> if (cbc.pos != strlen ("/hello_world"))
> return 4;
> @@ -290,29 +290,29 @@ testMultithreadedGet (int port, int poll_flag)
> curl_easy_setopt (c, CURLOPT_FAILONERROR, 1);
> curl_easy_setopt (c, CURLOPT_TIMEOUT, 150L);
> if (oneone)
> - curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
> + curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
> else
> - curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
> + curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
> curl_easy_setopt (c, CURLOPT_CONNECTTIMEOUT, 150L);
> /* NOTE: use of CONNECTTIMEOUT without also
> - setting NOSIGNAL results in really weird
> - crashes on my system! */
> + setting NOSIGNAL results in really weird
> + crashes on my system! */
> curl_easy_setopt (c, CURLOPT_NOSIGNAL, 1);
> if (CURLE_OK != (errornum = curl_easy_perform (c)))
> - {
> - fprintf (stderr,
> - "curl_easy_perform failed: `%s'\n",
> - curl_easy_strerror (errornum));
> - curl_easy_cleanup (c);
> - MHD_stop_daemon (d);
> - return 32;
> - }
> + {
> + fprintf (stderr,
> + "curl_easy_perform failed: `%s'\n",
> + curl_easy_strerror (errornum));
> + curl_easy_cleanup (c);
> + MHD_stop_daemon (d);
> + return 32;
> + }
> curl_easy_cleanup (c);
> }
> stop ((poll_flag & MHD_USE_AUTO) ? "internal thread with 'auto' and thread
> per connection" :
> (poll_flag & MHD_USE_POLL) ? "internal thread with poll() and thread
> per connection" :
> - (poll_flag & MHD_USE_EPOLL) ? "internal thread with epoll and thread
> per connection" :
> - "internal thread with select() and thread per connection");
> + (poll_flag & MHD_USE_EPOLL) ? "internal thread with epoll and thread per
> connection" :
> + "internal thread with select() and thread per connection");
> MHD_stop_daemon (d);
> if (cbc.pos != strlen ("/hello_world"))
> return 64;
> @@ -362,28 +362,28 @@ testMultithreadedPoolGet (int port, int poll_flag)
> curl_easy_setopt (c, CURLOPT_FAILONERROR, 1);
> curl_easy_setopt (c, CURLOPT_TIMEOUT, 150L);
> if (oneone)
> - curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
> + curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
> else
> - curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
> + curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
> curl_easy_setopt (c, CURLOPT_CONNECTTIMEOUT, 150L);
> /* NOTE: use of CONNECTTIMEOUT without also
> - setting NOSIGNAL results in really weird
> - crashes on my system!*/
> + setting NOSIGNAL results in really weird
> + crashes on my system!*/
> curl_easy_setopt (c, CURLOPT_NOSIGNAL, 1);
> if (CURLE_OK != (errornum = curl_easy_perform (c)))
> - {
> - fprintf (stderr,
> - "curl_easy_perform failed: `%s'\n",
> - curl_easy_strerror (errornum));
> - curl_easy_cleanup (c);
> - MHD_stop_daemon (d);
> - return 32;
> - }
> + {
> + fprintf (stderr,
> + "curl_easy_perform failed: `%s'\n",
> + curl_easy_strerror (errornum));
> + curl_easy_cleanup (c);
> + MHD_stop_daemon (d);
> + return 32;
> + }
> curl_easy_cleanup (c);
> }
> stop (0 != (poll_flag & MHD_USE_AUTO) ? "internal thread pool with 'auto'"
> :
> 0 != (poll_flag & MHD_USE_POLL) ? "internal thread pool with poll()"
> :
> - 0 != (poll_flag & MHD_USE_EPOLL) ? "internal thread pool with epoll" :
> "internal thread pool with select()");
> + 0 != (poll_flag & MHD_USE_EPOLL) ? "internal thread pool with epoll" :
> "internal thread pool with select()");
> MHD_stop_daemon (d);
> if (cbc.pos != strlen ("/hello_world"))
> return 64;
> @@ -452,52 +452,52 @@ testExternalGet (int port)
> curl_easy_setopt (c, CURLOPT_WRITEDATA, &cbc);
> curl_easy_setopt (c, CURLOPT_FAILONERROR, 1);
> if (oneone)
> - curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
> + curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
> else
> - curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
> + curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
> curl_easy_setopt (c, CURLOPT_TIMEOUT, 150L);
> curl_easy_setopt (c, CURLOPT_CONNECTTIMEOUT, 150L);
> /* NOTE: use of CONNECTTIMEOUT without also
> - setting NOSIGNAL results in really weird
> - crashes on my system! */
> + setting NOSIGNAL results in really weird
> + crashes on my system! */
> curl_easy_setopt (c, CURLOPT_NOSIGNAL, 1);
> mret = curl_multi_add_handle (multi, c);
> if (mret != CURLM_OK)
> - {
> - curl_multi_cleanup (multi);
> - curl_easy_cleanup (c);
> - MHD_stop_daemon (d);
> - return 1024;
> - }
> + {
> + curl_multi_cleanup (multi);
> + curl_easy_cleanup (c);
> + MHD_stop_daemon (d);
> + return 1024;
> + }
> start = time (NULL);
> while ((time (NULL) - start < 5) && (c != NULL))
> - {
> - maxsock = MHD_INVALID_SOCKET;
> - maxposixs = -1;
> - FD_ZERO (&rs);
> - FD_ZERO (&ws);
> - FD_ZERO (&es);
> - curl_multi_perform (multi, &running);
> - mret = curl_multi_fdset (multi, &rs, &ws, &es, &maxposixs);
> - if (mret != CURLM_OK)
> - {
> - curl_multi_remove_handle (multi, c);
> - curl_multi_cleanup (multi);
> - curl_easy_cleanup (c);
> - MHD_stop_daemon (d);
> - return 2048;
> - }
> - if (MHD_YES != MHD_get_fdset (d, &rs, &ws, &es, &maxsock))
> - {
> - curl_multi_remove_handle (multi, c);
> - curl_multi_cleanup (multi);
> - curl_easy_cleanup (c);
> - MHD_stop_daemon (d);
> - return 4096;
> - }
> - tv.tv_sec = 0;
> - tv.tv_usec = 1000;
> - if (-1 == select (maxposixs + 1, &rs, &ws, &es, &tv))
> + {
> + maxsock = MHD_INVALID_SOCKET;
> + maxposixs = -1;
> + FD_ZERO (&rs);
> + FD_ZERO (&ws);
> + FD_ZERO (&es);
> + curl_multi_perform (multi, &running);
> + mret = curl_multi_fdset (multi, &rs, &ws, &es, &maxposixs);
> + if (mret != CURLM_OK)
> + {
> + curl_multi_remove_handle (multi, c);
> + curl_multi_cleanup (multi);
> + curl_easy_cleanup (c);
> + MHD_stop_daemon (d);
> + return 2048;
> + }
> + if (MHD_YES != MHD_get_fdset (d, &rs, &ws, &es, &maxsock))
> + {
> + curl_multi_remove_handle (multi, c);
> + curl_multi_cleanup (multi);
> + curl_easy_cleanup (c);
> + MHD_stop_daemon (d);
> + return 4096;
> + }
> + tv.tv_sec = 0;
> + tv.tv_usec = 1000;
> + if (-1 == select (maxposixs + 1, &rs, &ws, &es, &tv))
> {
> #ifdef MHD_POSIX_SOCKETS
> if (EINTR != errno)
> @@ -508,41 +508,41 @@ testExternalGet (int port)
> Sleep (1000);
> #endif
> }
> - curl_multi_perform (multi, &running);
> - if (running == 0)
> - {
> - msg = curl_multi_info_read (multi, &running);
> - if (msg == NULL)
> - break;
> - if (msg->msg == CURLMSG_DONE)
> - {
> - if (msg->data.result != CURLE_OK)
> - printf ("%s failed at %s:%d: `%s'\n",
> - "curl_multi_perform",
> - __FILE__,
> - __LINE__, curl_easy_strerror (msg->data.result));
> - curl_multi_remove_handle (multi, c);
> - curl_easy_cleanup (c);
> - c = NULL;
> - }
> - }
> - /* two possibilities here; as select sets are
> - tiny, this makes virtually no difference
> - in actual runtime right now, even though the
> - number of select calls is virtually cut in half
> - (and 'select' is the most expensive of our system
> - calls according to 'strace') */
> - if (0)
> - MHD_run (d);
> - else
> - MHD_run_from_select (d, &rs, &ws, &es);
> - }
> + curl_multi_perform (multi, &running);
> + if (running == 0)
> + {
> + msg = curl_multi_info_read (multi, &running);
> + if (msg == NULL)
> + break;
> + if (msg->msg == CURLMSG_DONE)
> + {
> + if (msg->data.result != CURLE_OK)
> + printf ("%s failed at %s:%d: `%s'\n",
> + "curl_multi_perform",
> + __FILE__,
> + __LINE__, curl_easy_strerror (msg->data.result));
> + curl_multi_remove_handle (multi, c);
> + curl_easy_cleanup (c);
> + c = NULL;
> + }
> + }
> + /* two possibilities here; as select sets are
> + tiny, this makes virtually no difference
> + in actual runtime right now, even though the
> + number of select calls is virtually cut in half
> + (and 'select' is the most expensive of our system
> + calls according to 'strace') */
> + if (0)
> + MHD_run (d);
> + else
> + MHD_run_from_select (d, &rs, &ws, &es);
> + }
> if (NULL != c)
> - {
> - curl_multi_remove_handle (multi, c);
> - curl_easy_cleanup (c);
> - fprintf (stderr, "Timeout!?\n");
> - }
> + {
> + curl_multi_remove_handle (multi, c);
> + curl_easy_cleanup (c);
> + fprintf (stderr, "Timeout!?\n");
> + }
> }
> stop ("external select");
> if (multi != NULL)
> @@ -572,8 +572,8 @@ main (int argc, char *const *argv)
> if (0 != curl_global_init (CURL_GLOBAL_WIN32))
> return 2;
> response = MHD_create_response_from_buffer (strlen ("/hello_world"),
> - "/hello_world",
> - MHD_RESPMEM_MUST_COPY);
> + "/hello_world",
> + MHD_RESPMEM_MUST_COPY);
> errorCount += testExternalGet (port++);
> errorCount += testInternalGet (port++, MHD_USE_AUTO);
> errorCount += testMultithreadedGet (port++, MHD_USE_AUTO);
> diff --git a/src/testcurl/perf_get_concurrent.c
> b/src/testcurl/perf_get_concurrent.c
> index 49ed1ba4..5c5fea42 100644
> --- a/src/testcurl/perf_get_concurrent.c
> +++ b/src/testcurl/perf_get_concurrent.c
> @@ -93,7 +93,7 @@ now ()
>
> gettimeofday (&tv, NULL);
> return (((unsigned long long) tv.tv_sec * 1000LL) +
> - ((unsigned long long) tv.tv_usec / 1000LL));
> + ((unsigned long long) tv.tv_usec / 1000LL));
> }
>
>
> @@ -118,21 +118,21 @@ stop (const char *desc)
> double rps = ((double) (PAR * ROUNDS * 1000)) / ((double) (now() -
> start_time));
>
> fprintf (stderr,
> - "Parallel GETs using %s: %f %s\n",
> - desc,
> - rps,
> - "requests/s");
> + "Parallel GETs using %s: %f %s\n",
> + desc,
> + rps,
> + "requests/s");
> GAUGER (desc,
> - "Parallel GETs",
> - rps,
> - "requests/s");
> + "Parallel GETs",
> + rps,
> + "requests/s");
> }
>
>
> static size_t
> copyBuffer (void *ptr,
> - size_t size, size_t nmemb,
> - void *ctx)
> + size_t size, size_t nmemb,
> + void *ctx)
> {
> (void)ptr;(void)ctx; /* Unused. Silent compiler warning. */
> return size * nmemb;
> @@ -395,7 +395,7 @@ testExternalGet (int port)
> port = (int)dinfo->port;
> }
> if (0 != pthread_create (&pid, NULL,
> - &do_gets, (void*)(intptr_t)port))
> + &do_gets, (void*)(intptr_t)port))
> {
> MHD_stop_daemon(d);
> return 512;
> @@ -409,16 +409,16 @@ testExternalGet (int port)
> FD_ZERO (&ws);
> FD_ZERO (&es);
> if (MHD_YES != MHD_get_fdset (d, &rs, &ws, &es, &max))
> - {
> - MHD_stop_daemon (d);
> - return 4096;
> - }
> + {
> + MHD_stop_daemon (d);
> + return 4096;
> + }
> tret = MHD_get_timeout (d, &tt);
> if (MHD_YES != tret) tt = 1;
> tv.tv_sec = tt / 1000;
> tv.tv_usec = 1000 * (tt % 1000);
> if (-1 == select (max + 1, &rs, &ws, &es, &tv))
> - {
> + {
> #ifdef MHD_POSIX_SOCKETS
> if (EINTR == errno)
> continue;
> @@ -432,9 +432,9 @@ testExternalGet (int port)
> continue;
> }
> #endif
> - ret |= 1024;
> - break;
> - }
> + ret |= 1024;
> + break;
> + }
> MHD_run_from_select(d, &rs, &ws, &es);
> }
>
> @@ -467,8 +467,8 @@ main (int argc, char *const *argv)
> if (0 != curl_global_init (CURL_GLOBAL_WIN32))
> return 2;
> response = MHD_create_response_from_buffer (strlen ("/hello_world"),
> - "/hello_world",
> - MHD_RESPMEM_MUST_COPY);
> + "/hello_world",
> + MHD_RESPMEM_MUST_COPY);
> errorCount += testInternalGet (port++, 0);
> errorCount += testMultithreadedGet (port++, 0);
> errorCount += testMultithreadedPoolGet (port++, 0);
> diff --git a/src/testcurl/test_callback.c b/src/testcurl/test_callback.c
> index 5b9daf0f..234177a4 100644
> --- a/src/testcurl/test_callback.c
> +++ b/src/testcurl/test_callback.c
> @@ -53,7 +53,7 @@ called_twice(void *cls, uint64_t pos, char *buf, size_t max)
> return MHD_CONTENT_READER_END_OF_STREAM;
> }
> fprintf(stderr,
> - "Handler called after returning END_OF_STREAM!\n");
> + "Handler called after returning END_OF_STREAM!\n");
> return MHD_CONTENT_READER_END_WITH_ERROR;
> }
>
> @@ -62,10 +62,10 @@ static int
> callback(void *cls,
> struct MHD_Connection *connection,
> const char *url,
> - const char *method,
> + const char *method,
> const char *version,
> const char *upload_data,
> - size_t *upload_data_size,
> + size_t *upload_data_size,
> void **con_cls)
> {
> struct callback_closure *cbc = calloc(1, sizeof(struct callback_closure));
> @@ -76,8 +76,8 @@ callback(void *cls,
> (void)upload_data_size;(void)con_cls; /* Unused. Silent compiler
> warning. */
>
> r = MHD_create_response_from_callback (MHD_SIZE_UNKNOWN, 1024,
> - &called_twice, cbc,
> - &free);
> + &called_twice, cbc,
> + &free);
> if (NULL == r)
> {
> free (cbc);
> @@ -131,12 +131,12 @@ main(int argc, char **argv)
> port = 1140;
>
> d = MHD_start_daemon(0,
> - port,
> - NULL,
> - NULL,
> - &callback,
> - NULL,
> - MHD_OPTION_END);
> + port,
> + NULL,
> + NULL,
> + &callback,
> + NULL,
> + MHD_OPTION_END);
> if (d == NULL)
> return 32;
> if (0 == port)
> @@ -181,26 +181,26 @@ main(int argc, char **argv)
> FD_ZERO(&es);
> curl_multi_perform (multi, &running);
> if (NULL != multi)
> - {
> - mret = curl_multi_fdset (multi, &rs, &ws, &es, &maxposixs);
> - if (mret != CURLM_OK)
> - {
> - curl_multi_remove_handle (multi, c);
> - curl_multi_cleanup (multi);
> - curl_easy_cleanup (c);
> - MHD_stop_daemon (d);
> - return 3;
> - }
> - }
> + {
> + mret = curl_multi_fdset (multi, &rs, &ws, &es, &maxposixs);
> + if (mret != CURLM_OK)
> + {
> + curl_multi_remove_handle (multi, c);
> + curl_multi_cleanup (multi);
> + curl_easy_cleanup (c);
> + MHD_stop_daemon (d);
> + return 3;
> + }
> + }
> if (MHD_YES !=
> - MHD_get_fdset(d, &rs, &ws, &es, &maxsock))
> - {
> + MHD_get_fdset(d, &rs, &ws, &es, &maxsock))
> + {
> curl_multi_remove_handle (multi, c);
> curl_multi_cleanup (multi);
> curl_easy_cleanup (c);
> MHD_stop_daemon (d);
> - return 4;
> - }
> + return 4;
> + }
> tv.tv_sec = 0;
> tv.tv_usec = 1000;
> if (-1 == select (maxposixs + 1, &rs, &ws, &es, &tv))
> @@ -215,28 +215,28 @@ main(int argc, char **argv)
> #endif
> }
> if (NULL != multi)
> - {
> - curl_multi_perform (multi, &running);
> - if (running == 0)
> - {
> - msg = curl_multi_info_read (multi, &running);
> - if (msg == NULL)
> - break;
> - if (msg->msg == CURLMSG_DONE)
> - {
> - if (msg->data.result != CURLE_OK)
> - printf ("%s failed at %s:%d: `%s'\n",
> - "curl_multi_perform",
> - __FILE__,
> - __LINE__, curl_easy_strerror (msg->data.result));
> - curl_multi_remove_handle (multi, c);
> - curl_multi_cleanup (multi);
> - curl_easy_cleanup (c);
> - c = NULL;
> - multi = NULL;
> - }
> - }
> - }
> + {
> + curl_multi_perform (multi, &running);
> + if (running == 0)
> + {
> + msg = curl_multi_info_read (multi, &running);
> + if (msg == NULL)
> + break;
> + if (msg->msg == CURLMSG_DONE)
> + {
> + if (msg->data.result != CURLE_OK)
> + printf ("%s failed at %s:%d: `%s'\n",
> + "curl_multi_perform",
> + __FILE__,
> + __LINE__, curl_easy_strerror (msg->data.result));
> + curl_multi_remove_handle (multi, c);
> + curl_multi_cleanup (multi);
> + curl_easy_cleanup (c);
> + c = NULL;
> + multi = NULL;
> + }
> + }
> + }
> MHD_run(d);
> }
> MHD_stop_daemon(d);
> diff --git a/src/testcurl/test_concurrent_stop.c
> b/src/testcurl/test_concurrent_stop.c
> index 3409d472..3436591e 100644
> --- a/src/testcurl/test_concurrent_stop.c
> +++ b/src/testcurl/test_concurrent_stop.c
> @@ -63,8 +63,8 @@ static struct MHD_Response *response;
>
> static size_t
> copyBuffer (void *ptr,
> - size_t size, size_t nmemb,
> - void *ctx)
> + size_t size, size_t nmemb,
> + void *ctx)
> {
> (void)ptr;(void)ctx; /* Unused. Silent compiler warning. */
> return size * nmemb;
> @@ -286,8 +286,8 @@ main (int argc, char *const *argv)
> if (0 != curl_global_init (CURL_GLOBAL_WIN32))
> return 2;
> response = MHD_create_response_from_buffer (strlen ("/hello_world"),
> - "/hello_world",
> - MHD_RESPMEM_MUST_COPY);
> + "/hello_world",
> + MHD_RESPMEM_MUST_COPY);
> errorCount += testMultithreadedGet (port, 0);
> if (0 != port) port++;
> errorCount += testMultithreadedPoolGet (port, 0);
> diff --git a/src/testcurl/test_delete.c b/src/testcurl/test_delete.c
> index 70f0f509..92fc9752 100644
> --- a/src/testcurl/test_delete.c
> +++ b/src/testcurl/test_delete.c
> @@ -111,7 +111,7 @@ ahc_echo (void *cls,
> return MHD_YES;
> }
> response = MHD_create_response_from_buffer (strlen (url), (void*) url,
> - MHD_RESPMEM_MUST_COPY);
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> return ret;
> diff --git a/src/testcurl/test_digestauth.c b/src/testcurl/test_digestauth.c
> index 48c7a87a..d0476688 100644
> --- a/src/testcurl/test_digestauth.c
> +++ b/src/testcurl/test_digestauth.c
> @@ -96,29 +96,29 @@ ahc_echo (void *cls,
> DENIED,
> MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_auth_fail_response(connection, realm,
> - MY_OPAQUE,
> - response,
> - MHD_NO);
> + MY_OPAQUE,
> + response,
> + MHD_NO);
> MHD_destroy_response(response);
> return ret;
> }
> ret = MHD_digest_auth_check(connection, realm,
> - username,
> - password,
> - 300);
> + username,
> + password,
> + 300);
> free(username);
> if ( (ret == MHD_INVALID_NONCE) ||
> (ret == MHD_NO) )
> {
> response = MHD_create_response_from_buffer(strlen (DENIED),
> - DENIED,
> - MHD_RESPMEM_PERSISTENT);
> + DENIED,
> + MHD_RESPMEM_PERSISTENT);
> if (NULL == response)
> - return MHD_NO;
> + return MHD_NO;
> ret = MHD_queue_auth_fail_response(connection, realm,
> - MY_OPAQUE,
> - response,
> - (ret == MHD_INVALID_NONCE) ? MHD_YES :
> MHD_NO);
> + MY_OPAQUE,
> + response,
> + (ret == MHD_INVALID_NONCE) ? MHD_YES : MHD_NO);
> MHD_destroy_response(response);
> return ret;
> }
> @@ -205,9 +205,9 @@ testDigestAuth ()
> #endif
> d = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG,
> port, NULL, NULL, &ahc_echo, PAGE,
> - MHD_OPTION_DIGEST_AUTH_RANDOM, sizeof (rnd), rnd,
> - MHD_OPTION_NONCE_NC_SIZE, 300,
> - MHD_OPTION_END);
> + MHD_OPTION_DIGEST_AUTH_RANDOM, sizeof (rnd), rnd,
> + MHD_OPTION_NONCE_NC_SIZE, 300,
> + MHD_OPTION_END);
> if (d == NULL)
> return 1;
> if (0 == port)
> diff --git a/src/testcurl/test_digestauth_with_arguments.c
> b/src/testcurl/test_digestauth_with_arguments.c
> index 107d2256..0529627e 100644
> --- a/src/testcurl/test_digestauth_with_arguments.c
> +++ b/src/testcurl/test_digestauth_with_arguments.c
> @@ -91,37 +91,37 @@ ahc_echo (void *cls,
> (0 != strcmp (username, "testuser")) )
> {
> response = MHD_create_response_from_buffer(strlen (DENIED),
> - DENIED,
> - MHD_RESPMEM_PERSISTENT);
> + DENIED,
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_auth_fail_response(connection, realm,
> - MY_OPAQUE,
> - response,
> - MHD_NO);
> + MY_OPAQUE,
> + response,
> + MHD_NO);
> MHD_destroy_response(response);
> return ret;
> }
> ret = MHD_digest_auth_check(connection, realm,
> - username,
> - password,
> - 300);
> + username,
> + password,
> + 300);
> free(username);
> if ( (ret == MHD_INVALID_NONCE) ||
> (ret == MHD_NO) )
> {
> response = MHD_create_response_from_buffer(strlen (DENIED),
> - DENIED,
> - MHD_RESPMEM_PERSISTENT);
> + DENIED,
> + MHD_RESPMEM_PERSISTENT);
> if (NULL == response)
> - return MHD_NO;
> + return MHD_NO;
> ret = MHD_queue_auth_fail_response(connection, realm,
> - MY_OPAQUE,
> - response,
> - (ret == MHD_INVALID_NONCE) ? MHD_YES :
> MHD_NO);
> + MY_OPAQUE,
> + response,
> + (ret == MHD_INVALID_NONCE) ? MHD_YES : MHD_NO);
> MHD_destroy_response(response);
> return ret;
> }
> response = MHD_create_response_from_buffer(strlen(PAGE), PAGE,
> - MHD_RESPMEM_PERSISTENT);
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_response(connection, MHD_HTTP_OK, response);
> MHD_destroy_response(response);
> return ret;
> @@ -157,24 +157,24 @@ testDigestAuth ()
> fd = open("/dev/urandom", O_RDONLY);
> if (-1 == fd)
> {
> - fprintf(stderr, "Failed to open `%s': %s\n",
> - "/dev/urandom",
> - strerror(errno));
> - return 1;
> - }
> + fprintf(stderr, "Failed to open `%s': %s\n",
> + "/dev/urandom",
> + strerror(errno));
> + return 1;
> + }
> while (off < 8)
> - {
> - len = read(fd, rnd, 8);
> - if (len == (size_t)-1)
> - {
> - fprintf(stderr, "Failed to read `%s': %s\n",
> - "/dev/urandom",
> - strerror(errno));
> - (void) close(fd);
> - return 1;
> - }
> - off += len;
> - }
> + {
> + len = read(fd, rnd, 8);
> + if (len == (size_t)-1)
> + {
> + fprintf(stderr, "Failed to read `%s': %s\n",
> + "/dev/urandom",
> + strerror(errno));
> + (void) close(fd);
> + return 1;
> + }
> + off += len;
> + }
> (void) close(fd);
> #else
> {
> @@ -200,9 +200,9 @@ testDigestAuth ()
> #endif
> d = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG,
> port, NULL, NULL, &ahc_echo, PAGE,
> - MHD_OPTION_DIGEST_AUTH_RANDOM, sizeof (rnd), rnd,
> - MHD_OPTION_NONCE_NC_SIZE, 300,
> - MHD_OPTION_END);
> + MHD_OPTION_DIGEST_AUTH_RANDOM, sizeof (rnd), rnd,
> + MHD_OPTION_NONCE_NC_SIZE, 300,
> + MHD_OPTION_END);
> if (d == NULL)
> return 1;
> if (0 == port)
> diff --git a/src/testcurl/test_get.c b/src/testcurl/test_get.c
> index 081859f7..86a4de60 100644
> --- a/src/testcurl/test_get.c
> +++ b/src/testcurl/test_get.c
> @@ -100,8 +100,8 @@ ahc_echo (void *cls,
> }
> *unused = NULL;
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> if (ret == MHD_NO)
> @@ -637,8 +637,8 @@ ahc_empty (void *cls,
> }
> *unused = NULL;
> response = MHD_create_response_from_buffer (0,
> - NULL,
> - MHD_RESPMEM_PERSISTENT);
> + NULL,
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> if (ret == MHD_NO)
> diff --git a/src/testcurl/test_get_response_cleanup.c
> b/src/testcurl/test_get_response_cleanup.c
> index 8cb4f4a7..aa97ef8a 100644
> --- a/src/testcurl/test_get_response_cleanup.c
> +++ b/src/testcurl/test_get_response_cleanup.c
> @@ -75,8 +75,8 @@ fork_curl (const char *url)
> return ret;
> execlp ("curl", "curl", "-s", "-N", "-o", "/dev/null", "-GET", url, NULL);
> fprintf (stderr,
> - "Failed to exec curl: %s\n",
> - strerror (errno));
> + "Failed to exec curl: %s\n",
> + strerror (errno));
> _exit (-1);
> }
>
> @@ -95,7 +95,7 @@ kill_curl (pid_t pid)
> static ssize_t
> push_callback (void *cls, uint64_t pos, char *buf, size_t max)
> {
> - (void)cls;(void)pos; /* Unused. Silent compiler warning. */
> + (void)cls;(void)pos; /* Unused. Silent compiler warning. */
>
> if (max == 0)
> return 0;
> @@ -140,10 +140,10 @@ ahc_echo (void *cls,
> }
> *unused = NULL;
> response = MHD_create_response_from_callback (MHD_SIZE_UNKNOWN,
> - 32 * 1024,
> - &push_callback,
> - &ok,
> - &push_free_callback);
> + 32 * 1024,
> + &push_callback,
> + &ok,
> + &push_free_callback);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> if (ret == MHD_NO)
> @@ -215,8 +215,8 @@ testMultithreadedGet ()
> ok = 1;
> d = MHD_start_daemon (MHD_USE_THREAD_PER_CONNECTION |
> MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG,
> port, NULL, NULL, &ahc_echo, "GET",
> - MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 2,
> - MHD_OPTION_END);
> + MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 2,
> + MHD_OPTION_END);
> if (d == NULL)
> return 16;
> if (0 == port)
> diff --git a/src/testcurl/test_get_sendfile.c
> b/src/testcurl/test_get_sendfile.c
> index 6718106d..dec08a75 100644
> --- a/src/testcurl/test_get_sendfile.c
> +++ b/src/testcurl/test_get_sendfile.c
> @@ -102,8 +102,8 @@ ahc_echo (void *cls,
> if (fd == -1)
> {
> fprintf (stderr, "Failed to open `%s': %s\n",
> - sourcefile,
> - strerror (errno));
> + sourcefile,
> + strerror (errno));
> exit (1);
> }
> response = MHD_create_response_from_fd (strlen (TESTSTR), fd);
> @@ -582,9 +582,9 @@ main (int argc, char *const *argv)
> tmp = "/tmp";
> sourcefile = malloc (strlen (tmp) + 32);
> sprintf (sourcefile,
> - "%s/%s",
> - tmp,
> - "test-mhd-sendfile");
> + "%s/%s",
> + tmp,
> + "test-mhd-sendfile");
> f = fopen (sourcefile, "w");
> if (NULL == f)
> {
> diff --git a/src/testcurl/test_iplimit.c b/src/testcurl/test_iplimit.c
> index 32f7e36a..e83dd8f7 100644
> --- a/src/testcurl/test_iplimit.c
> +++ b/src/testcurl/test_iplimit.c
> @@ -96,8 +96,8 @@ ahc_echo (void *cls,
> }
> *unused = NULL;
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> if (ret == MHD_NO)
> @@ -285,7 +285,7 @@ testMultithreadedPoolGet ()
>
> errornum = curl_easy_perform (c);
> if ( ( (CURLE_OK != errornum) && (i < 2) ) ||
> - ( (CURLE_OK == errornum) && (i == 2) ) )
> + ( (CURLE_OK == errornum) && (i == 2) ) )
> {
> int j;
>
> diff --git a/src/testcurl/test_large_put.c b/src/testcurl/test_large_put.c
> index b7a87c8f..c35e7c6c 100644
> --- a/src/testcurl/test_large_put.c
> +++ b/src/testcurl/test_large_put.c
> @@ -165,8 +165,8 @@ ahc_echo (void *cls,
> return MHD_YES;
> }
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> return ret;
> @@ -202,8 +202,8 @@ testPutInternalThread (unsigned int add_flag)
> d = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG
> | add_flag,
> port,
> NULL, NULL, &ahc_echo, &done_flag,
> - MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t)(incr_read
> ? 1024 : (PUT_SIZE * 4)),
> - MHD_OPTION_END);
> + MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t)(incr_read ? 1024 :
> (PUT_SIZE * 4)),
> + MHD_OPTION_END);
> if (d == NULL)
> return 1;
> if (0 == port)
> @@ -283,7 +283,7 @@ testPutThreadPerConn (unsigned int add_flag)
> port,
> NULL, NULL, &ahc_echo, &done_flag,
> MHD_OPTION_CONNECTION_MEMORY_LIMIT,
> (size_t)(incr_read ? 1024 : (PUT_SIZE * 4)),
> - MHD_OPTION_END);
> + MHD_OPTION_END);
> if (d == NULL)
> return 16;
> if (0 == port)
> @@ -366,7 +366,7 @@ testPutThreadPool (unsigned int add_flag)
> NULL, NULL, &ahc_echo, &done_flag,
> MHD_OPTION_THREAD_POOL_SIZE, CPU_COUNT,
> MHD_OPTION_CONNECTION_MEMORY_LIMIT,
> (size_t)(incr_read ? 1024 : (PUT_SIZE * 4)),
> - MHD_OPTION_END);
> + MHD_OPTION_END);
> if (d == NULL)
> return 16;
> if (0 == port)
> diff --git a/src/testcurl/test_long_header.c b/src/testcurl/test_long_header.c
> index 49b183dc..e3581b6a 100644
> --- a/src/testcurl/test_long_header.c
> +++ b/src/testcurl/test_long_header.c
> @@ -84,8 +84,8 @@ ahc_echo (void *cls,
> if (0 != strcmp (me, method))
> return MHD_NO; /* unexpected method */
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> return ret;
> @@ -136,8 +136,8 @@ testLongUrlGet ()
> url = malloc (VERY_LONG);
> if (url == NULL)
> {
> - MHD_stop_daemon (d);
> - return 1;
> + MHD_stop_daemon (d);
> + return 1;
> }
> memset (url, 'a', VERY_LONG);
> url[VERY_LONG - 1] = '\0';
> @@ -226,8 +226,8 @@ testLongHeaderGet ()
> url = malloc (VERY_LONG);
> if (url == NULL)
> {
> - MHD_stop_daemon (d);
> - return 16;
> + MHD_stop_daemon (d);
> + return 16;
> }
> memset (url, 'a', VERY_LONG);
> url[VERY_LONG - 1] = '\0';
> diff --git a/src/testcurl/test_parse_cookies.c
> b/src/testcurl/test_parse_cookies.c
> index 3e2c181e..a10ac218 100644
> --- a/src/testcurl/test_parse_cookies.c
> +++ b/src/testcurl/test_parse_cookies.c
> @@ -96,8 +96,8 @@ ahc_echo (void *cls,
> if ((hdr == NULL) || (0 != strcmp (hdr, "var4 with spaces")))
> abort ();
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_PERSISTENT);
> + (void *) url,
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> if (ret == MHD_NO)
> diff --git a/src/testcurl/test_post.c b/src/testcurl/test_post.c
> index 6b91b9cc..da4199c4 100644
> --- a/src/testcurl/test_post.c
> +++ b/src/testcurl/test_post.c
> @@ -64,9 +64,9 @@ struct CBC
>
> static void
> completed_cb (void *cls,
> - struct MHD_Connection *connection,
> - void **con_cls,
> - enum MHD_RequestTerminationCode toe)
> + struct MHD_Connection *connection,
> + void **con_cls,
> + enum MHD_RequestTerminationCode toe)
> {
> struct MHD_PostProcessor *pp = *con_cls;
> (void)cls;(void)connection;(void)toe; /* Unused. Silent compiler warning.
> */
> @@ -149,8 +149,8 @@ ahc_echo (void *cls,
> if ((eok == 3) && (0 == *upload_data_size))
> {
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> MHD_destroy_post_processor (pp);
> @@ -186,8 +186,8 @@ testInternalPost ()
> cbc.pos = 0;
> d = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG,
> port, NULL, NULL, &ahc_echo, NULL,
> - MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> - MHD_OPTION_END);
> + MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> + MHD_OPTION_END);
> if (d == NULL)
> return 1;
> if (0 == port)
> @@ -259,8 +259,8 @@ testMultithreadedPost ()
> cbc.pos = 0;
> d = MHD_start_daemon (MHD_USE_THREAD_PER_CONNECTION |
> MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG,
> port, NULL, NULL, &ahc_echo, NULL,
> - MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> - MHD_OPTION_END);
> + MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> + MHD_OPTION_END);
> if (d == NULL)
> return 16;
> if (0 == port)
> @@ -333,8 +333,8 @@ testMultithreadedPoolPost ()
> d = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG,
> port, NULL, NULL, &ahc_echo, NULL,
> MHD_OPTION_THREAD_POOL_SIZE, CPU_COUNT,
> - MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> - MHD_OPTION_END);
> + MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> + MHD_OPTION_END);
> if (d == NULL)
> return 16;
> if (0 == port)
> @@ -421,8 +421,8 @@ testExternalPost ()
> cbc.pos = 0;
> d = MHD_start_daemon (MHD_USE_ERROR_LOG,
> port, NULL, NULL, &ahc_echo, NULL,
> - MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> - MHD_OPTION_END);
> + MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> + MHD_OPTION_END);
> if (d == NULL)
> return 256;
> if (0 == port)
> @@ -546,12 +546,12 @@ testExternalPost ()
>
> static int
> ahc_cancel (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 **unused)
> + struct MHD_Connection *connection,
> + const char *url,
> + const char *method,
> + const char *version,
> + const char *upload_data, size_t *upload_data_size,
> + void **unused)
> {
> struct MHD_Response *response;
> int ret;
> @@ -561,7 +561,7 @@ ahc_cancel (void *cls,
> if (0 != strcasecmp ("POST", method))
> {
> fprintf (stderr,
> - "Unexpected method `%s'\n", method);
> + "Unexpected method `%s'\n", method);
> return MHD_NO;
> }
>
> @@ -570,17 +570,17 @@ ahc_cancel (void *cls,
> *unused = "wibble";
> /* We don't want the body. Send a 500. */
> response = MHD_create_response_from_buffer (0, NULL,
> - MHD_RESPMEM_PERSISTENT);
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_response(connection, 500, response);
> if (ret != MHD_YES)
> - fprintf(stderr, "Failed to queue response\n");
> + fprintf(stderr, "Failed to queue response\n");
> MHD_destroy_response(response);
> return ret;
> }
> else
> {
> fprintf(stderr,
> - "In ahc_cancel again. This should not happen.\n");
> + "In ahc_cancel again. This should not happen.\n");
> return MHD_NO;
> }
> }
> @@ -659,7 +659,7 @@ testMultithreadedPostCancelPart(int flags)
> cbc.pos = 0;
> d = MHD_start_daemon (MHD_USE_THREAD_PER_CONNECTION |
> MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG,
> port, NULL, NULL, &ahc_cancel, NULL,
> - MHD_OPTION_END);
> + MHD_OPTION_END);
> if (d == NULL)
> return 32768;
> if (0 == port)
> diff --git a/src/testcurl/test_post_loop.c b/src/testcurl/test_post_loop.c
> index 5ed57431..6d3a81e8 100644
> --- a/src/testcurl/test_post_loop.c
> +++ b/src/testcurl/test_post_loop.c
> @@ -94,7 +94,7 @@ ahc_echo (void *cls,
> if (*mptr != &marker)
> abort ();
> response = MHD_create_response_from_buffer (2, "OK",
> - MHD_RESPMEM_PERSISTENT);
> + MHD_RESPMEM_PERSISTENT);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> *mptr = NULL;
> @@ -417,7 +417,7 @@ testExternalPost ()
> for (i = 0; i < LOOPCOUNT; i++)
> {
> if (99 == i % 100)
> - fprintf (stderr, ".");
> + fprintf (stderr, ".");
> c = curl_easy_init ();
> cbc.pos = 0;
> buf[0] = '\0';
> @@ -479,19 +479,19 @@ testExternalPost ()
> if ((CURLM_OK == curl_multi_timeout (multi, &ctimeout)) &&
> (ctimeout < (long long)timeout) && (ctimeout >= 0))
> timeout = ctimeout;
> - if ( (c == NULL) || (running == 0) )
> - timeout = 0; /* terminate quickly... */
> + if ( (c == NULL) || (running == 0) )
> + timeout = 0; /* terminate quickly... */
> tv.tv_sec = timeout / 1000;
> tv.tv_usec = (timeout % 1000) * 1000;
> if (-1 == select (maxposixs + 1, &rs, &ws, &es, &tv))
> - {
> - if (EINTR == errno)
> - continue;
> - fprintf (stderr,
> - "select failed: %s\n",
> - strerror (errno));
> - break;
> - }
> + {
> + if (EINTR == errno)
> + continue;
> + fprintf (stderr,
> + "select failed: %s\n",
> + strerror (errno));
> + break;
> + }
> while (CURLM_CALL_MULTI_PERFORM ==
> curl_multi_perform (multi, &running));
> if (running == 0)
> @@ -551,7 +551,7 @@ now ()
>
> gettimeofday (&tv, NULL);
> return (((unsigned long long) tv.tv_sec * 1000LL) +
> - ((unsigned long long) tv.tv_usec / 1000LL));
> + ((unsigned long long) tv.tv_usec / 1000LL));
> }
>
>
> @@ -568,43 +568,43 @@ main (int argc, char *const *argv)
> start_time = now();
> errorCount += testInternalPost ();
> fprintf (stderr,
> - oneone ? "%s: Sequential POSTs (http/1.1) %f/s\n" : "%s: Sequential
> POSTs (http/1.0) %f/s\n",
> - "internal select",
> - (double) 1000 * LOOPCOUNT / (now() - start_time + 1.0));
> + oneone ? "%s: Sequential POSTs (http/1.1) %f/s\n" : "%s: Sequential
> POSTs (http/1.0) %f/s\n",
> + "internal select",
> + (double) 1000 * LOOPCOUNT / (now() - start_time + 1.0));
> GAUGER ("internal select",
> - oneone ? "Sequential POSTs (http/1.1)" : "Sequential POSTs
> (http/1.0)",
> - (double) 1000 * LOOPCOUNT / (now() - start_time + 1.0),
> - "requests/s");
> + oneone ? "Sequential POSTs (http/1.1)" : "Sequential POSTs (http/1.0)",
> + (double) 1000 * LOOPCOUNT / (now() - start_time + 1.0),
> + "requests/s");
> start_time = now();
> errorCount += testMultithreadedPost ();
> fprintf (stderr,
> - oneone ? "%s: Sequential POSTs (http/1.1) %f/s\n" : "%s: Sequential
> POSTs (http/1.0) %f/s\n",
> - "multithreaded post",
> - (double) 1000 * LOOPCOUNT / (now() - start_time + 1.0));
> + oneone ? "%s: Sequential POSTs (http/1.1) %f/s\n" : "%s: Sequential
> POSTs (http/1.0) %f/s\n",
> + "multithreaded post",
> + (double) 1000 * LOOPCOUNT / (now() - start_time + 1.0));
> GAUGER ("Multithreaded select",
> - oneone ? "Sequential POSTs (http/1.1)" : "Sequential POSTs
> (http/1.0)",
> - (double) 1000 * LOOPCOUNT / (now() - start_time + 1.0),
> - "requests/s");
> + oneone ? "Sequential POSTs (http/1.1)" : "Sequential POSTs (http/1.0)",
> + (double) 1000 * LOOPCOUNT / (now() - start_time + 1.0),
> + "requests/s");
> start_time = now();
> errorCount += testMultithreadedPoolPost ();
> fprintf (stderr,
> - oneone ? "%s: Sequential POSTs (http/1.1) %f/s\n" : "%s: Sequential
> POSTs (http/1.0) %f/s\n",
> - "thread with pool",
> - (double) 1000 * LOOPCOUNT / (now() - start_time + 1.0));
> + oneone ? "%s: Sequential POSTs (http/1.1) %f/s\n" : "%s: Sequential
> POSTs (http/1.0) %f/s\n",
> + "thread with pool",
> + (double) 1000 * LOOPCOUNT / (now() - start_time + 1.0));
> GAUGER ("thread with pool",
> - oneone ? "Sequential POSTs (http/1.1)" : "Sequential POSTs
> (http/1.0)",
> - (double) 1000 * LOOPCOUNT / (now() - start_time + 1.0),
> - "requests/s");
> + oneone ? "Sequential POSTs (http/1.1)" : "Sequential POSTs (http/1.0)",
> + (double) 1000 * LOOPCOUNT / (now() - start_time + 1.0),
> + "requests/s");
> start_time = now();
> errorCount += testExternalPost ();
> fprintf (stderr,
> - oneone ? "%s: Sequential POSTs (http/1.1) %f/s\n" : "%s: Sequential
> POSTs (http/1.0) %f/s\n",
> - "external select",
> - (double) 1000 * LOOPCOUNT / (now() - start_time + 1.0));
> + oneone ? "%s: Sequential POSTs (http/1.1) %f/s\n" : "%s: Sequential
> POSTs (http/1.0) %f/s\n",
> + "external select",
> + (double) 1000 * LOOPCOUNT / (now() - start_time + 1.0));
> GAUGER ("external select",
> - oneone ? "Sequential POSTs (http/1.1)" : "Sequential POSTs
> (http/1.0)",
> - (double) 1000 * LOOPCOUNT / (now() - start_time + 1.0),
> - "requests/s");
> + oneone ? "Sequential POSTs (http/1.1)" : "Sequential POSTs (http/1.0)",
> + (double) 1000 * LOOPCOUNT / (now() - start_time + 1.0),
> + "requests/s");
> if (errorCount != 0)
> fprintf (stderr, "Error (code: %u)\n", errorCount);
> curl_global_cleanup ();
> diff --git a/src/testcurl/test_postform.c b/src/testcurl/test_postform.c
> index f94ed1f8..403c0a77 100644
> --- a/src/testcurl/test_postform.c
> +++ b/src/testcurl/test_postform.c
> @@ -60,9 +60,9 @@ struct CBC
>
> static void
> completed_cb (void *cls,
> - struct MHD_Connection *connection,
> - void **con_cls,
> - enum MHD_RequestTerminationCode toe)
> + struct MHD_Connection *connection,
> + void **con_cls,
> + enum MHD_RequestTerminationCode toe)
> {
> struct MHD_PostProcessor *pp = *con_cls;
> (void)cls;(void)connection;(void)toe; /* Unused. Silent
> compiler warning. */
> @@ -150,8 +150,8 @@ ahc_echo (void *cls,
> if ((eok == 3) && (0 == *upload_data_size))
> {
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> MHD_destroy_post_processor (pp);
> @@ -201,8 +201,8 @@ testInternalPost ()
> cbc.pos = 0;
> d = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG,
> port, NULL, NULL, &ahc_echo, NULL,
> - MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> - MHD_OPTION_END);
> + MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> + MHD_OPTION_END);
> if (d == NULL)
> return 1;
> if (0 == port)
> @@ -276,8 +276,8 @@ testMultithreadedPost ()
> cbc.pos = 0;
> d = MHD_start_daemon (MHD_USE_THREAD_PER_CONNECTION |
> MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG,
> port, NULL, NULL, &ahc_echo, NULL,
> - MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> - MHD_OPTION_END);
> + MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> + MHD_OPTION_END);
> if (d == NULL)
> return 16;
> if (0 == port)
> @@ -352,8 +352,8 @@ testMultithreadedPoolPost ()
> d = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG,
> port, NULL, NULL, &ahc_echo, NULL,
> MHD_OPTION_THREAD_POOL_SIZE, CPU_COUNT,
> - MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> - MHD_OPTION_END);
> + MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> + MHD_OPTION_END);
> if (d == NULL)
> return 16;
> if (0 == port)
> @@ -442,8 +442,8 @@ testExternalPost ()
> cbc.pos = 0;
> d = MHD_start_daemon (MHD_USE_ERROR_LOG,
> port, NULL, NULL, &ahc_echo, NULL,
> - MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> - MHD_OPTION_END);
> + MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> + MHD_OPTION_END);
> if (d == NULL)
> return 256;
> if (0 == port)
> diff --git a/src/testcurl/test_process_arguments.c
> b/src/testcurl/test_process_arguments.c
> index 4f29574d..49e3eef5 100644
> --- a/src/testcurl/test_process_arguments.c
> +++ b/src/testcurl/test_process_arguments.c
> @@ -95,12 +95,12 @@ ahc_echo (void *cls,
> if ((hdr == NULL) || (0 != strcmp (hdr, "\240bar")))
> abort ();
> if (3 != MHD_get_connection_values (connection,
> - MHD_GET_ARGUMENT_KIND,
> - NULL, NULL))
> + MHD_GET_ARGUMENT_KIND,
> + NULL, NULL))
> abort ();
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> if (ret == MHD_NO)
> diff --git a/src/testcurl/test_process_headers.c
> b/src/testcurl/test_process_headers.c
> index d123c441..bf19781e 100644
> --- a/src/testcurl/test_process_headers.c
> +++ b/src/testcurl/test_process_headers.c
> @@ -124,8 +124,8 @@ ahc_echo (void *cls,
> abort ();
>
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> if (NULL == response)
> abort ();
> MHD_add_response_header (response, "MyHeader", "MyValue");
> diff --git a/src/testcurl/test_put.c b/src/testcurl/test_put.c
> index 83c4a124..b47358bf 100644
> --- a/src/testcurl/test_put.c
> +++ b/src/testcurl/test_put.c
> @@ -111,7 +111,7 @@ ahc_echo (void *cls,
> return MHD_YES;
> }
> response = MHD_create_response_from_buffer (strlen (url), (void*) url,
> - MHD_RESPMEM_MUST_COPY);
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> return ret;
> diff --git a/src/testcurl/test_put_chunked.c b/src/testcurl/test_put_chunked.c
> index 479079fb..4d5c6d47 100644
> --- a/src/testcurl/test_put_chunked.c
> +++ b/src/testcurl/test_put_chunked.c
> @@ -120,8 +120,8 @@ ahc_echo (void *cls,
> return MHD_YES;
> }
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> return ret;
> diff --git a/src/testcurl/test_quiesce.c b/src/testcurl/test_quiesce.c
> index f9fd9690..8bee7fd5 100644
> --- a/src/testcurl/test_quiesce.c
> +++ b/src/testcurl/test_quiesce.c
> @@ -94,8 +94,8 @@ ahc_echo (void *cls,
> }
> *unused = NULL;
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> if (ret == MHD_NO)
> @@ -106,7 +106,7 @@ ahc_echo (void *cls,
>
> static void
> request_completed (void *cls, struct MHD_Connection *connection,
> - void **con_cls, enum MHD_RequestTerminationCode code)
> + void **con_cls, enum MHD_RequestTerminationCode code)
> {
> (void)connection;(void)con_cls;(void)code; /* Unused. Silent compiler
> warning. */
> int *done = (int *)cls;
> diff --git a/src/testcurl/test_termination.c b/src/testcurl/test_termination.c
> index 6f633c84..ff660fc5 100644
> --- a/src/testcurl/test_termination.c
> +++ b/src/testcurl/test_termination.c
> @@ -75,7 +75,7 @@ connection_handler (void *cls,
>
> struct MHD_Response *response =
> MHD_create_response_from_buffer (strlen ("Response"), "Response",
> - MHD_RESPMEM_PERSISTENT);
> + MHD_RESPMEM_PERSISTENT);
> int ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
>
> diff --git a/src/testcurl/test_timeout.c b/src/testcurl/test_timeout.c
> index 7621cfd1..e4d918af 100644
> --- a/src/testcurl/test_timeout.c
> +++ b/src/testcurl/test_timeout.c
> @@ -52,9 +52,9 @@ struct CBC
>
> static void
> termination_cb (void *cls,
> - struct MHD_Connection *connection,
> - void **con_cls,
> - enum MHD_RequestTerminationCode toe)
> + struct MHD_Connection *connection,
> + void **con_cls,
> + enum MHD_RequestTerminationCode toe)
> {
> int *test = cls;
> (void)connection;(void)con_cls; /* Unused. Silent compiler warning.
> */
> @@ -63,18 +63,18 @@ termination_cb (void *cls,
> {
> case MHD_REQUEST_TERMINATED_COMPLETED_OK :
> if (test == &withoutTimeout)
> - {
> - withoutTimeout = 0;
> - }
> + {
> + withoutTimeout = 0;
> + }
> break;
> case MHD_REQUEST_TERMINATED_WITH_ERROR :
> case MHD_REQUEST_TERMINATED_READ_ERROR :
> break;
> case MHD_REQUEST_TERMINATED_TIMEOUT_REACHED :
> if (test == &withTimeout)
> - {
> - withTimeout = 0;
> - }
> + {
> + withTimeout = 0;
> + }
> break;
> case MHD_REQUEST_TERMINATED_DAEMON_SHUTDOWN:
> break;
> @@ -92,7 +92,7 @@ putBuffer (void *stream, size_t size, size_t nmemb, void
> *ptr)
>
> wrt = size * nmemb;
> if (wrt > 8 - (*pos))
> - wrt = 8 - (*pos);
> + wrt = 8 - (*pos);
> memcpy (stream, &("Hello123"[*pos]), wrt);
> (*pos) += wrt;
> return wrt;
> @@ -153,8 +153,8 @@ ahc_echo (void *cls,
> return MHD_YES;
> }
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> return ret;
> @@ -300,11 +300,11 @@ testWithTimeout ()
> curl_easy_cleanup (c);
> MHD_stop_daemon (d);
> if (errornum == CURLE_GOT_NOTHING)
> - /* mhd had the timeout */
> - return 0;
> + /* mhd had the timeout */
> + return 0;
> else
> - /* curl had the timeout first */
> - return 32;
> + /* curl had the timeout first */
> + return 32;
> }
> curl_easy_cleanup (c);
> MHD_stop_daemon (d);
> @@ -326,8 +326,8 @@ main (int argc, char *const *argv)
> errorCount += testWithTimeout ();
> if (errorCount != 0)
> fprintf (stderr,
> - "Error during test execution (code: %u)\n",
> - errorCount);
> + "Error during test execution (code: %u)\n",
> + errorCount);
> curl_global_cleanup ();
> if ((withTimeout == 0) && (withoutTimeout == 0))
> return 0;
> diff --git a/src/testcurl/test_urlparse.c b/src/testcurl/test_urlparse.c
> index 8675f19c..ad2dcf8c 100644
> --- a/src/testcurl/test_urlparse.c
> +++ b/src/testcurl/test_urlparse.c
> @@ -69,9 +69,9 @@ copyBuffer (void *ptr, size_t size, size_t nmemb, void *ctx)
>
> static int
> test_values (void *cls,
> - enum MHD_ValueKind kind,
> - const char *key,
> - const char *value)
> + enum MHD_ValueKind kind,
> + const char *key,
> + const char *value)
> {
> (void)cls;(void)kind; /* Unused. Silent compiler warning. */
> if ( (0 == strcmp (key, "a")) &&
> @@ -109,13 +109,13 @@ ahc_echo (void *cls,
> return MHD_YES;
> }
> MHD_get_connection_values (connection,
> - MHD_GET_ARGUMENT_KIND,
> - &test_values,
> - NULL);
> + MHD_GET_ARGUMENT_KIND,
> + &test_values,
> + NULL);
> *unused = NULL;
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> if (ret == MHD_NO)
> diff --git a/src/testzzuf/test_get.c b/src/testzzuf/test_get.c
> index 7e116d09..7975e2aa 100644
> --- a/src/testzzuf/test_get.c
> +++ b/src/testzzuf/test_get.c
> @@ -83,8 +83,8 @@ ahc_echo (void *cls,
> }
> *unused = NULL;
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> if (ret == MHD_NO)
> diff --git a/src/testzzuf/test_long_header.c b/src/testzzuf/test_long_header.c
> index c4e5cf81..6e3c8817 100644
> --- a/src/testzzuf/test_long_header.c
> +++ b/src/testzzuf/test_long_header.c
> @@ -86,8 +86,8 @@ ahc_echo (void *cls,
> if (0 != strcmp (me, method))
> return MHD_NO; /* unexpected method */
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> return ret;
> diff --git a/src/testzzuf/test_post.c b/src/testzzuf/test_post.c
> index 9a4a8e9c..8327276c 100644
> --- a/src/testzzuf/test_post.c
> +++ b/src/testzzuf/test_post.c
> @@ -53,9 +53,9 @@ struct CBC
>
> static void
> completed_cb (void *cls,
> - struct MHD_Connection *connection,
> - void **con_cls,
> - enum MHD_RequestTerminationCode toe)
> + struct MHD_Connection *connection,
> + void **con_cls,
> + enum MHD_RequestTerminationCode toe)
> {
> struct MHD_PostProcessor *pp = *con_cls;
> (void)cls;(void)connection;(void)toe; /* Unused. Silent compiler warning.
> */
> @@ -136,8 +136,8 @@ ahc_echo (void *cls,
> if ((eok == 3) && (0 == *upload_data_size))
> {
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> MHD_destroy_post_processor (pp);
> @@ -163,8 +163,8 @@ testInternalPost ()
> cbc.pos = 0;
> d = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD /* |
> MHD_USE_ERROR_LOG */ ,
> 11080, NULL, NULL, &ahc_echo, NULL,
> - MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
>
> - MHD_OPTION_END);
> + MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> + MHD_OPTION_END);
> if (d == NULL)
> return 1;
> zzuf_socat_start ();
> @@ -214,8 +214,8 @@ testMultithreadedPost ()
> cbc.pos = 0;
> d = MHD_start_daemon (MHD_USE_THREAD_PER_CONNECTION |
> MHD_USE_INTERNAL_POLLING_THREAD /* | MHD_USE_ERROR_LOG */ ,
> 11080, NULL, NULL, &ahc_echo, NULL,
> - MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> - MHD_OPTION_END);
> + MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> + MHD_OPTION_END);
> if (d == NULL)
> return 16;
>
> @@ -277,8 +277,8 @@ testExternalPost ()
> cbc.pos = 0;
> d = MHD_start_daemon (MHD_NO_FLAG /* | MHD_USE_ERROR_LOG */ ,
> 1082, NULL, NULL, &ahc_echo, NULL,
> - MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> - MHD_OPTION_END);
> + MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> + MHD_OPTION_END);
> if (d == NULL)
> return 256;
> multi = curl_multi_init ();
> diff --git a/src/testzzuf/test_post_form.c b/src/testzzuf/test_post_form.c
> index fe248d47..7363eac8 100644
> --- a/src/testzzuf/test_post_form.c
> +++ b/src/testzzuf/test_post_form.c
> @@ -51,9 +51,9 @@ struct CBC
>
> static void
> completed_cb (void *cls,
> - struct MHD_Connection *connection,
> - void **con_cls,
> - enum MHD_RequestTerminationCode toe)
> + struct MHD_Connection *connection,
> + void **con_cls,
> + enum MHD_RequestTerminationCode toe)
> {
> struct MHD_PostProcessor *pp = *con_cls;
> (void)cls;(void)connection;(void)toe; /* Unused. Silent
> compiler warning. */
> @@ -141,8 +141,8 @@ ahc_echo (void *cls,
> if ((eok == 3) && (0 == *upload_data_size))
> {
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> MHD_destroy_post_processor (pp);
> @@ -182,8 +182,8 @@ testInternalPost ()
> cbc.pos = 0;
> d = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD /* |
> MHD_USE_ERROR_LOG */ ,
> 11080, NULL, NULL, &ahc_echo, NULL,
> - MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> - MHD_OPTION_END);
> + MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> + MHD_OPTION_END);
> if (d == NULL)
> return 1;
> zzuf_socat_start ();
> @@ -233,8 +233,8 @@ testMultithreadedPost ()
> cbc.pos = 0;
> d = MHD_start_daemon (MHD_USE_THREAD_PER_CONNECTION |
> MHD_USE_INTERNAL_POLLING_THREAD /* | MHD_USE_ERROR_LOG */ ,
> 11080, NULL, NULL, &ahc_echo, NULL,
> - MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> - MHD_OPTION_END);
> + MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> + MHD_OPTION_END);
> if (d == NULL)
> return 16;
> zzuf_socat_start ();
> @@ -294,8 +294,8 @@ testExternalPost ()
> cbc.pos = 0;
> d = MHD_start_daemon (MHD_NO_FLAG /* | MHD_USE_ERROR_LOG */ ,
> 1082, NULL, NULL, &ahc_echo, NULL,
> - MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
>
> - MHD_OPTION_END);
> + MHD_OPTION_NOTIFY_COMPLETED, &completed_cb, NULL,
> + MHD_OPTION_END);
> if (d == NULL)
> return 256;
> multi = curl_multi_init ();
> diff --git a/src/testzzuf/test_put.c b/src/testzzuf/test_put.c
> index cfe12dee..a51d32f7 100644
> --- a/src/testzzuf/test_put.c
> +++ b/src/testzzuf/test_put.c
> @@ -107,8 +107,8 @@ ahc_echo (void *cls,
> return MHD_YES;
> }
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> return ret;
> diff --git a/src/testzzuf/test_put_chunked.c b/src/testzzuf/test_put_chunked.c
> index 72a9f316..67029945 100644
> --- a/src/testzzuf/test_put_chunked.c
> +++ b/src/testzzuf/test_put_chunked.c
> @@ -113,8 +113,8 @@ ahc_echo (void *cls,
> return MHD_YES;
> }
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> return ret;
> diff --git a/src/testzzuf/test_put_large.c b/src/testzzuf/test_put_large.c
> index 540c37f9..915689f8 100644
> --- a/src/testzzuf/test_put_large.c
> +++ b/src/testzzuf/test_put_large.c
> @@ -94,7 +94,7 @@ ahc_echo (void *cls,
> int *done = cls;
> struct MHD_Response *response;
> int ret;
> - (void)version;(void)unused; /* Unused. Silent compiler warning. */
> + (void)version;(void)unused; /* Unused. Silent compiler warning. */
>
> if (0 != strcmp ("PUT", method))
> return MHD_NO; /* unexpected method */
> @@ -121,8 +121,8 @@ ahc_echo (void *cls,
> return MHD_YES;
> }
> response = MHD_create_response_from_buffer (strlen (url),
> - (void *) url,
> - MHD_RESPMEM_MUST_COPY);
> + (void *) url,
> + MHD_RESPMEM_MUST_COPY);
> ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
> MHD_destroy_response (response);
> return ret;
> @@ -365,7 +365,7 @@ int
> main (int argc, char *const *argv)
> {
> unsigned int errorCount = 0;
> - (void)argc; /* Unused. Silent compiler warning. */
> + (void)argc; /* Unused. Silent compiler warning. */
>
> oneone = (NULL != strrchr (argv[0], (int) '/')) ?
> (NULL != strstr (strrchr (argv[0], (int) '/'), "11")) : 0;
>
signature.asc
Description: OpenPGP digital signature