35#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
41#ifdef MHD_LINUX_SOLARIS_SENDFILE
42#include <sys/sendfile.h>
44#if defined(HAVE_FREEBSD_SENDFILE) || defined(HAVE_DARWIN_SENDFILE)
46#include <sys/socket.h>
52#ifdef HAVE_SYS_PARAM_H
65#define MHD_ALLOW_BARE_LF_AS_CRLF_(discp_lvl) (0 >= discp_lvl)
75#define MHD_CHUNK_HEADER_REASONABLE_LEN 24
80#define HTTP_100_CONTINUE "HTTP/1.1 100 Continue\r\n\r\n"
87#define ERR_MSG_REQUEST_TOO_BIG \
89 "<head><title>Request too big</title></head>" \
90 "<body>Request HTTP header is too big for the memory constraints " \
91 "of this webserver.</body>" \
94#define ERR_MSG_REQUEST_TOO_BIG ""
101#define ERR_MSG_REQUEST_HEADER_TOO_BIG \
103 "<head><title>Request too big</title></head>" \
104 "<body><p>The total size of the request headers, which includes the " \
105 "request target and the request field lines, exceeds the memory " \
106 "constraints of this web server.</p>" \
107 "<p>The request could be re-tried with shorter field lines, a shorter " \
108 "request target or a shorter request method token.</p></body>" \
111#define ERR_MSG_REQUEST_HEADER_TOO_BIG ""
118#define ERR_MSG_REQUEST_HEADER_WITH_COOKIES_TOO_BIG \
120 "<head><title>Request too big</title></head>" \
121 "<body><p>The total size of the request headers, which includes the " \
122 "request target and the request field lines, exceeds the memory " \
123 "constraints of this web server.</p> " \
124 "<p>The request could be re-tried with smaller " \
125 "<b>"Cookie:"</b> field value, shorter other field lines, " \
126 "a shorter request target or a shorter request method token.</p></body> " \
129#define ERR_MSG_REQUEST_HEADER_WITH_COOKIES_TOO_BIG ""
137#define ERR_MSG_REQUEST_CHUNK_LINE_EXT_TOO_BIG \
139 "<head><title>Request too big</title></head>" \
140 "<body><p>The total size of the request target, the request field lines " \
141 "and the chunk size line exceeds the memory constraints of this web " \
143 "<p>The request could be re-tried without chunk extensions, with a smaller " \
144 "chunk size, shorter field lines, a shorter request target or a shorter " \
145 "request method token.</p></body>" \
148#define ERR_MSG_REQUEST_CHUNK_LINE_EXT_TOO_BIG ""
156#define ERR_MSG_REQUEST_CHUNK_LINE_TOO_BIG \
158 "<head><title>Request too big</title></head>" \
159 "<body><p>The total size of the request target, the request field lines " \
160 "and the chunk size line exceeds the memory constraints of this web " \
162 "<p>The request could be re-tried with a smaller " \
163 "chunk size, shorter field lines, a shorter request target or a shorter " \
164 "request method token.</p></body>" \
167#define ERR_MSG_REQUEST_CHUNK_LINE_TOO_BIG ""
174#define ERR_MSG_REQUEST_FOOTER_TOO_BIG \
176 "<head><title>Request too big</title></head>" \
177 "<body><p>The total size of the request headers, which includes the " \
178 "request target, the request field lines and the chunked trailer " \
179 "section exceeds the memory constraints of this web server.</p>" \
180 "<p>The request could be re-tried with a shorter chunked trailer " \
181 "section, shorter field lines, a shorter request target or " \
182 "a shorter request method token.</p></body>" \
185#define ERR_MSG_REQUEST_FOOTER_TOO_BIG ""
192#define RQ_LINE_TOO_MANY_WSP \
194 "<head><title>Request broken</title></head>" \
195 "<body>The request line has more then two whitespaces.</body>" \
198#define RQ_LINE_TOO_MANY_WSP ""
206#define BARE_CR_IN_HEADER \
208 "<head><title>Request broken</title></head>" \
209 "<body>Request HTTP header has bare CR character without " \
210 "following LF character.</body>" \
213#define BARE_CR_IN_HEADER ""
221#define BARE_CR_IN_FOOTER \
223 "<head><title>Request broken</title></head>" \
224 "<body>Request HTTP footer has bare CR character without " \
225 "following LF character.</body>" \
228#define BARE_CR_IN_FOOTER ""
236#define BARE_LF_IN_HEADER \
238 "<head><title>Request broken</title></head>" \
239 "<body>Request HTTP header has bare LF character without " \
240 "preceding CR character.</body>" \
243#define BARE_LF_IN_HEADER ""
251#define BARE_LF_IN_FOOTER \
253 "<head><title>Request broken</title></head>" \
254 "<body>Request HTTP footer has bare LF character without " \
255 "preceding CR character.</body>" \
258#define BARE_LF_IN_FOOTER ""
265#define RQ_TARGET_INVALID_CHAR \
267 "<head><title>Request broken</title></head>" \
268 "<body>HTTP request has invalid characters in " \
269 "the request-target.</body>" \
272#define RQ_TARGET_INVALID_CHAR ""
279#define ERR_RSP_OBS_FOLD \
281 "<head><title>Request broken</title></head>" \
282 "<body>Obsolete line folding is used in HTTP request header.</body>" \
285#define ERR_RSP_OBS_FOLD ""
292#define ERR_RSP_OBS_FOLD_FOOTER \
294 "<head><title>Request broken</title></head>" \
295 "<body>Obsolete line folding is used in HTTP request footer.</body>" \
298#define ERR_RSP_OBS_FOLD_FOOTER ""
306#define ERR_RSP_WSP_BEFORE_HEADER \
308 "<head><title>Request broken</title></head>" \
309 "<body>HTTP request has whitespace between the request line and " \
310 "the first header.</body>" \
313#define ERR_RSP_WSP_BEFORE_HEADER ""
321#define ERR_RSP_WSP_BEFORE_FOOTER \
323 "<head><title>Request broken</title></head>" \
324 "<body>First HTTP footer line has whitespace at the first " \
328#define ERR_RSP_WSP_BEFORE_FOOTER ""
336#define ERR_RSP_WSP_IN_HEADER_NAME \
338 "<head><title>Request broken</title></head>" \
339 "<body>HTTP request has whitespace before the first colon " \
340 "in header line.</body>" \
343#define ERR_RSP_WSP_IN_HEADER_NAME ""
351#define ERR_RSP_WSP_IN_FOOTER_NAME \
353 "<head><title>Request broken</title></head>" \
354 "<body>HTTP request has whitespace before the first colon " \
355 "in footer line.</body>" \
358#define ERR_RSP_WSP_IN_FOOTER_NAME ""
365#define ERR_RSP_INVALID_CHR_IN_HEADER \
367 "<head><title>Request broken</title></head>" \
368 "<body>HTTP request has invalid character in header.</body>" \
371#define ERR_RSP_INVALID_CHR_IN_HEADER ""
378#define ERR_RSP_INVALID_CHR_IN_FOOTER \
380 "<head><title>Request broken</title></head>" \
381 "<body>HTTP request has invalid character in footer.</body>" \
384#define ERR_RSP_INVALID_CHR_IN_HEADER ""
391#define ERR_RSP_HEADER_WITHOUT_COLON \
393 "<head><title>Request broken</title></head>" \
394 "<body>HTTP request header line has no colon character.</body>" \
397#define ERR_RSP_INVALID_CHR_IN_HEADER ""
404#define ERR_RSP_FOOTER_WITHOUT_COLON \
406 "<head><title>Request broken</title></head>" \
407 "<body>HTTP request footer line has no colon character.</body>" \
410#define ERR_RSP_FOOTER_WITHOUT_COLON ""
417#define ERR_RSP_EMPTY_HEADER_NAME \
419 "<head><title>Request broken</title></head>" \
420 "<body>HTTP request header has empty header name.</body>" \
423#define ERR_RSP_EMPTY_HEADER_NAME ""
430#define ERR_RSP_EMPTY_FOOTER_NAME \
432 "<head><title>Request broken</title></head>" \
433 "<body>HTTP request footer has empty footer name.</body>" \
436#define ERR_RSP_EMPTY_FOOTER_NAME ""
447#define REQUEST_LACKS_HOST \
449 "<head><title>"Host:" header required</title></head>" \
450 "<body>HTTP/1.1 request without <b>"Host:"</b>.</body>" \
454#define REQUEST_LACKS_HOST ""
461#define REQUEST_UNSUPPORTED_TR_ENCODING \
463 "<head><title>Unsupported Transfer-Encoding</title></head>" \
464 "<body>The Transfer-Encoding used in request is not supported.</body>" \
467#define REQUEST_UNSUPPORTED_TR_ENCODING ""
475#define REQUEST_LENGTH_WITH_TR_ENCODING \
477 "<head><title>Malformed request</title></head>" \
478 "<body>Wrong combination of the request headers: both Transfer-Encoding " \
479 "and Content-Length headers are used at the same time.</body>" \
482#define REQUEST_LENGTH_WITH_TR_ENCODING ""
493#define REQUEST_MALFORMED \
494 "<html><head><title>Request malformed</title></head>" \
495 "<body>HTTP request is syntactically incorrect.</body></html>"
497#define REQUEST_MALFORMED ""
505#define REQUEST_CHUNKED_MALFORMED \
506 "<html><head><title>Request malformed</title></head>" \
507 "<body>HTTP chunked encoding is syntactically incorrect.</body></html>"
509#define REQUEST_CHUNKED_MALFORMED ""
516#define REQUEST_CHUNK_TOO_LARGE \
517 "<html><head><title>Request content too large</title></head>" \
518 "<body>The chunk size used in HTTP chunked encoded " \
519 "request is too large.</body></html>"
521#define REQUEST_CHUNK_TOO_LARGE ""
528#define REQUEST_CONTENTLENGTH_TOOLARGE \
529 "<html><head><title>Request content too large</title></head>" \
530 "<body>HTTP request has too large value for " \
531 "<b>Content-Length</b> header.</body></html>"
533#define REQUEST_CONTENTLENGTH_TOOLARGE ""
541#define REQUEST_CONTENTLENGTH_MALFORMED \
542 "<html><head><title>Request malformed</title></head>" \
543 "<body>HTTP request has wrong value for " \
544 "<b>Content-Length</b> header.</body></html>"
546#define REQUEST_CONTENTLENGTH_MALFORMED ""
556#define ERROR_MSG_DATA_NOT_HANDLED_BY_APP \
557 "<html><head><title>Internal server error</title></head>" \
558 "<body>Please ask the developer of this Web server to carefully " \
559 "read the GNU libmicrohttpd documentation about connection " \
560 "management and blocking.</body></html>"
562#define ERROR_MSG_DATA_NOT_HANDLED_BY_APP ""
569#define REQ_HTTP_VER_IS_TOO_OLD \
570 "<html><head><title>Requested HTTP version is not supported</title></head>" \
571 "<body>Requested HTTP version is too old and not " \
572 "supported.</body></html>"
574#define REQ_HTTP_VER_IS_TOO_OLD ""
581#define REQ_HTTP_VER_IS_NOT_SUPPORTED \
582 "<html><head><title>Requested HTTP version is not supported</title></head>" \
583 "<body>Requested HTTP version is not supported.</body></html>"
585#define REQ_HTTP_VER_IS_NOT_SUPPORTED ""
592#define MHD_SENFILE_CHUNK_ (0x20000)
597#define MHD_SENFILE_CHUNK_THR_P_C_ (0x200000)
606str_conn_error_ (ssize_t mhd_err_code)
608 switch (mhd_err_code)
611 return _ (
"The operation would block, retry later");
613 return _ (
"The connection was forcibly closed by remote peer");
615 return _ (
"The socket is not connected");
617 return _ (
"Not enough system resources to serve the request");
619 return _ (
"Bad FD value");
621 return _ (
"Argument value is invalid");
623 return _ (
"Argument value is not supported");
625 return _ (
"The socket is no longer available for sending");
627 return _ (
"TLS encryption or decryption error");
631 if (0 <= mhd_err_code)
632 return _ (
"Not an error code");
635 return _ (
"Wrong error code value");
655 struct MemoryPool *
const pool = c->
pool;
656 size_t need_to_be_freed = 0;
749 connection->epoll_state &=
772 else if (i > (
size_t) ret)
773 connection->epoll_state &=
801 if (
NULL == connection)
808 if ( (
NULL != iterator) &&
809 (
MHD_NO == iterator (iterator_cls,
840 if (
NULL == connection)
844 if (
NULL == iterator)
855 if (
MHD_NO == iterator (iterator_cls,
953 ( ((key ? strlen (key) : 0) != key_size) ||
1031 (
NULL == key) ? 0 : strlen (key),
1062 const char **value_ptr,
1063 size_t *value_size_ptr)
1067 if (
NULL == connection)
1085 ( (key == pos->
header) ||
1096 if (
NULL != value_ptr)
1097 *value_ptr = pos->
value;
1099 if (
NULL != value_size_ptr)
1131 (
NULL == token) || (0 == token[0]))
1160#define MHD_lookup_header_s_token_ci(c,h,tkn) \
1161 MHD_lookup_header_token_ci ((c),(h),MHD_STATICSTR_LEN_ (h), \
1162 (tkn),MHD_STATICSTR_LEN_ (tkn))
1253#ifdef MHD_USE_THREADS
1279#if defined(HTTPS_SUPPORT) && defined(UPGRADE_SUPPORT)
1294 struct MHD_UpgradeResponseHandle *urh = connection->urh;
1296#ifdef MHD_USE_THREADS
1311 (0 != epoll_ctl (daemon->epoll_upgrade_fd,
1316 MHD_PANIC (
_ (
"Failed to remove FD from epoll set.\n"));
1318 if (urh->in_eready_list)
1321 daemon->eready_urh_tail,
1323 urh->in_eready_list =
false;
1330 (0 != epoll_ctl (daemon->epoll_upgrade_fd,
1335 MHD_PANIC (
_ (
"Failed to remove FD from epoll set.\n"));
1340 shutdown (urh->mhd.socket, SHUT_RDWR);
1368 MHD_DLOG (connection->
daemon,
1384#define CONNECTION_CLOSE_ERROR(c, emsg) connection_close_error (c, emsg)
1386#define CONNECTION_CLOSE_ERROR(c, emsg) connection_close_error (c, NULL)
1429 _ (
"Closing connection (out of memory)."));
1446#if defined(_MHD_HAVE_SENDFILE)
1447 if (MHD_resp_sender_sendfile == connection->
rp.resp_sender)
1456 (
char *) response->
data,
1466#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
1474 _ (
"Closing connection (application reported " \
1475 "error generating data)."));
1483#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
1510 static const size_t max_chunk = 0xFFFFFF;
1513 static const size_t max_chunk_hdr_len =
sizeof(chunk_hdr) + 2;
1515 static const size_t max_chunk_overhead =
sizeof(chunk_hdr) + 2 + 2;
1516 size_t chunk_hdr_len;
1517 uint64_t left_to_send;
1518 size_t size_to_fill;
1533#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
1538 _ (
"Closing connection (out of memory)."));
1542 if ( (max_chunk + max_chunk_overhead) < size)
1543 size = max_chunk + max_chunk_overhead;
1556 mhd_assert (max_chunk_overhead < connection->write_buffer_size);
1566 if (max_chunk < size_to_fill)
1567 size_to_fill = max_chunk;
1568 if (left_to_send < size_to_fill)
1569 size_to_fill = (size_t) left_to_send;
1571 if (0 == left_to_send)
1581 const size_t data_write_offset
1587 ret = (ssize_t) (response->
data_size - data_write_offset);
1588 if ( ((
size_t) ret) > size_to_fill)
1589 ret = (ssize_t) size_to_fill;
1591 &response->
data[data_write_offset],
1598#if defined(MHD_USE_THREADS)
1602 _ (
"No callback for the chunked data."));
1615#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
1619 _ (
"Closing connection (application error " \
1620 "generating response)."));
1633#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
1638 if (size_to_fill < (
size_t) ret)
1640#if defined(MHD_USE_THREADS)
1644 _ (
"Closing connection (application returned " \
1645 "more data than requested)."));
1651 mhd_assert (chunk_hdr_len <
sizeof(chunk_hdr));
1652 *p_finished =
false;
1654 (max_chunk_hdr_len - (chunk_hdr_len + 2));
1658 connection->
write_buffer[max_chunk_hdr_len - 2] =
'\r';
1659 connection->
write_buffer[max_chunk_hdr_len - 1] =
'\n';
1660 connection->
write_buffer[max_chunk_hdr_len + (size_t) ret] =
'\r';
1661 connection->
write_buffer[max_chunk_hdr_len + (size_t) ret + 1] =
'\n';
1700#ifdef UPGRADE_SUPPORT
1703 if (
NULL != r->upgrade_handler)
1761 static const char *
const days[] = {
1762 "Sun",
"Mon",
"Tue",
"Wed",
"Thu",
"Fri",
"Sat"
1764 static const char *
const mons[] = {
1765 "Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
1766 "Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec"
1768 static const size_t buf_len = 29;
1772#if ! defined(HAVE_C11_GMTIME_S) && ! defined(HAVE_W32_GMTIME_S) && \
1773 ! defined(HAVE_GMTIME_R)
1777 if ((time_t) -1 == time (&t))
1779#if defined(HAVE_C11_GMTIME_S)
1780 if (
NULL == gmtime_s (&t,
1783#elif defined(HAVE_W32_GMTIME_S)
1784 if (0 != gmtime_s (&now,
1787#elif defined(HAVE_GMTIME_R)
1788 if (
NULL == gmtime_r (&t,
1799 src = days[now.tm_wday % 7];
1807 date + 5, buf_len - 5))
1811 src = mons[now.tm_mon % 12];
1886 if (0 == avail_size)
1889 new_size = avail_size / 2;
1894 grow_size = avail_size / 8;
1895 if (def_grow_size > grow_size)
1897 const size_t left_free =
1901 if ((def_grow_size <= grow_size + left_free)
1902 && (left_free < def_grow_size))
1903 grow_size = def_grow_size - left_free;
1904 else if (! required)
1909 const size_t small_inc =
1912 if (small_inc < avail_size)
1913 grow_size = small_inc;
1915 grow_size = avail_size;
2000 struct MemoryPool *
const pool = connection->
pool;
2049connection_shrink_write_buffer (
struct MHD_Connection *connection)
2052 struct MemoryPool *
const pool = connection->
pool;
2156#ifdef UPGRADE_SUPPORT
2167 (2 == rcode / 100) )
2212#ifdef UPGRADE_SUPPORT
2224 use_chunked =
false;
2228 use_chunked =
false;
2238 use_chunked =
false;
2247 use_chunked =
false;
2271 _ (
"This reply with response code %u cannot use reply body. "
2272 "Non-empty response body is ignored and not used.\n"),
2279 _ (
"This reply with response code %u cannot use reply body. "
2280 "Application defined \"Content-Length\" header violates"
2281 "HTTP specification.\n"),
2310 if (buf_size < *ppos + append_size)
2312 memcpy (buf + *ppos, append, append_size);
2313 *ppos += append_size;
2328#define buffer_append_s(buf,ppos,buf_size,str) \
2329 buffer_append (buf,ppos,buf_size,str, MHD_STATICSTR_LEN_ (str))
2356 bool filter_transf_enc,
2357 bool filter_content_len,
2359 bool add_keep_alive)
2365 mhd_assert (! add_close || ! add_keep_alive);
2368 filter_transf_enc =
false;
2370 filter_content_len =
false;
2374 add_keep_alive =
false;
2381 size_t initial_pos = *ppos;
2384 if (filter_transf_enc)
2391 filter_transf_enc =
false;
2395 if (filter_content_len)
2411 if (buf_size < *ppos + el_size)
2415 buf[(*ppos)++] =
':';
2416 buf[(*ppos)++] =
' ';
2417 if (add_close || add_keep_alive)
2427 if (buf_size < initial_pos + el_size)
2429 memcpy (buf + *ppos,
"close, ",
2436 if (buf_size < initial_pos + el_size)
2438 memcpy (buf + *ppos,
"Keep-Alive, ",
2443 add_keep_alive =
false;
2448 buf[(*ppos)++] =
'\r';
2449 buf[(*ppos)++] =
'\n';
2450 mhd_assert (initial_pos + el_size == (*ppos));
2474 bool use_conn_close;
2475 bool use_conn_k_alive;
2487#ifdef UPGRADE_SUPPORT
2496#ifdef UPGRADE_SUPPORT
2508 use_conn_close =
true;
2509 use_conn_k_alive =
false;
2513 use_conn_close =
false;
2521 use_conn_k_alive =
true;
2523 use_conn_k_alive =
false;
2527 use_conn_close =
false;
2528 use_conn_k_alive =
false;
2567 if (buf_size < pos + 5)
2587 if (buf_size < pos + 2)
2601 if (buf_size < pos + 38)
2607 mhd_assert (! use_conn_close || ! use_conn_k_alive);
2608 mhd_assert (! use_conn_k_alive || ! use_conn_close);
2617 else if (use_conn_k_alive)
2668 if (buf_size < pos + 2)
2678 if (buf_size < pos + 2)
2720 buf[used_size++] =
'0';
2721 buf[used_size++] =
'\r';
2722 buf[used_size++] =
'\n';
2728 size_t new_used_size;
2731 if (new_used_size > buf_size)
2735 buf[used_size++] =
':';
2736 buf[used_size++] =
' ';
2739 buf[used_size++] =
'\r';
2740 buf[used_size++] =
'\n';
2744 if (used_size + 2 > buf_size)
2746 buf[used_size++] =
'\r';
2747 buf[used_size++] =
'\n';
2774 unsigned int status_code,
2775 const char *message,
2778 size_t header_name_len,
2780 size_t header_value_len)
2791 free (header_value);
2797 MHD_DLOG (connection->
daemon,
2798 _ (
"Error processing request (HTTP response code is %u ('%s')). " \
2799 "Closing connection.\n"),
2806 MHD_DLOG (connection->
daemon,
2807 _ (
"Too late to send an error response, " \
2808 "response is being sent already.\n"),
2813 _ (
"Too late for error response."));
2815 free (header_value);
2838 if (
NULL == response)
2841 MHD_DLOG (connection->
daemon,
2842 _ (
"Failed to create error response.\n"),
2849 free (header_value);
2858 if (
NULL != header_name)
2862 header_name, header_name_len,
2863 header_value, header_value_len);
2867 free (header_value);
2889 _ (
"Closing connection " \
2890 "(failed to queue error response)."));
2920 _ (
"Closing connection " \
2921 "(failed to create error response header)."));
2932#define transmit_error_response_static(c, code, msg) \
2933 transmit_error_response_len (c, code, \
2934 msg, MHD_STATICSTR_LEN_ (msg), \
2940#define transmit_error_response_header(c, code, m, hd_n, hd_n_l, hd_v, hd_v_l) \
2941 transmit_error_response_len (c, code, \
2942 m, MHD_STATICSTR_LEN_ (m), \
2994#ifndef MHD_MAX_REASONABLE_HEADERS_SIZE_
3004# define MHD_MAX_REASONABLE_HEADERS_SIZE_ (6 * 1024)
3007#ifndef MHD_MAX_REASONABLE_REQ_TARGET_SIZE_
3018# define MHD_MAX_REASONABLE_REQ_TARGET_SIZE_ 8000
3021#ifndef MHD_MIN_REASONABLE_HEADERS_SIZE_
3029# define MHD_MIN_REASONABLE_HEADERS_SIZE_ 26
3032#ifndef MHD_MIN_REASONABLE_REQ_TARGET_SIZE_
3040# define MHD_MIN_REASONABLE_REQ_TARGET_SIZE_ 40
3043#ifndef MHD_MIN_REASONABLE_REQ_METHOD_SIZE_
3051# define MHD_MIN_REASONABLE_REQ_METHOD_SIZE_ 16
3054#ifndef MHD_MIN_REASONABLE_REQ_CHUNK_LINE_LENGTH_
3060# define MHD_MIN_REASONABLE_REQ_CHUNK_LINE_LENGTH_ 4
3078 const char *add_element,
3079 size_t add_element_size)
3083 size_t opt_headers_size;
3084 size_t host_field_line_size;
3112 host_field_line_size = 0;
3117 && (0 != add_element_size))
3119 static const size_t header_host_key_len =
3121 const bool is_host_header =
3122 (header_host_key_len + 1 <= add_element_size)
3123 && ( (0 == add_element[header_host_key_len])
3124 || (
':' == add_element[header_host_key_len]) )
3127 header_host_key_len);
3130 const bool is_parsed = ! (
3134 size_t actual_element_size;
3136 mhd_assert (! is_parsed || (0 == add_element[header_host_key_len]));
3142 actual_element_size = add_element_size + 1;
3144 actual_element_size = add_element_size;
3146 host_field_line_size = actual_element_size;
3147 mhd_assert (opt_headers_size >= actual_element_size);
3148 opt_headers_size -= actual_element_size;
3151 if (0 == host_field_line_size)
3153 static const size_t host_field_name_len =
3155 size_t host_field_name_value_len;
3159 host_field_name_len,
3161 &host_field_name_value_len))
3165 host_field_line_size =
3166 host_field_name_len + host_field_name_value_len + 2;
3169 if (opt_headers_size >= host_field_line_size)
3171 opt_headers_size -= host_field_line_size;
3173 if (opt_headers_size >= 2)
3174 opt_headers_size -= 2;
3177 host_field_line_size = 0;
3187 method_size = strlen (c->
rq.
method);
3194 if (opt_headers_size > (uri_size / 8))
3196 if ((opt_headers_size / 2) > method_size)
3203 if ((uri_size / 16) > method_size)
3213 if ((uri_size / 16) > method_size)
3224 if ((opt_headers_size * 4) > uri_size)
3226 if (opt_headers_size > method_size)
3233 if (uri_size > method_size * 4)
3242 if (uri_size > method_size * 4)
3261 if ((1 < opt_headers_size) || (1 < uri_size))
3263 if (opt_headers_size >= uri_size)
3271 if (0 != host_field_line_size)
3290 const char *add_header,
3291 size_t add_header_size)
3293 unsigned int err_code;
3305#ifdef COOKIE_SUPPORT
3314 unsigned int err_code;
3341 const char *chunk_size_line,
3342 size_t chunk_size_line_size)
3344 unsigned int err_code;
3346 if (
NULL != chunk_size_line)
3348 const char *semicol;
3350 semicol = memchr (chunk_size_line,
';', chunk_size_line_size);
3351 if (
NULL != semicol)
3362 chunk_size_line_size);
3381 const char *add_footer,
3382 size_t add_footer_size)
3384 (void) add_footer; (void) add_footer_size;
3439 _ (
"No space left in the read buffer when " \
3440 "receiving the initial part of " \
3441 "the request line."));
3459 _ (
"No space left in the read buffer when " \
3460 "receiving the URI in " \
3461 "the request line. " \
3462 "The request uses non-standard HTTP request " \
3561 bool rbuff_grow_desired;
3565 bool rbuff_grow_required;
3571 if (rbuff_grow_required)
3572 rbuff_grow_desired =
true;
3578 if ((rbuff_grow_desired) &&
3586 rbuff_grow_desired =
3593 rbuff_grow_desired =
3598 const uint64_t cur_chunk_left =
3603 rbuff_grow_desired =
3610 if (! rbuff_grow_desired)
3616 if (! rbuff_grow_required)
3682#ifdef UPGRADE_SUPPORT
3683 case MHD_CONNECTION_UPGRADE:
3713 switch (connection->tls_state)
3720 if (0 == gnutls_record_get_direction (connection->tls_session))
3736 MHD_PANIC (
_ (
"Invalid TLS state value.\n"));
3743 MHD_DLOG (connection->
daemon,
3744 _ (
"In function %s handling connection at state: %s\n"),
3746 MHD_state_to_string (connection->
state));
3748 switch (connection->
state)
3840#ifdef UPGRADE_SUPPORT
3841 case MHD_CONNECTION_UPGRADE:
3893 MHD_DLOG (connection->
daemon,
3894 _ (
"Not enough memory in pool to allocate header record!\n"));
3905#ifdef COOKIE_SUPPORT
3910enum _MHD_ParseCookie
3912 MHD_PARSE_COOKIE_OK =
MHD_YES,
3913 MHD_PARSE_COOKIE_OK_LAX = 2,
3914 MHD_PARSE_COOKIE_MALFORMED = -1,
3915 MHD_PARSE_COOKIE_NO_MEMORY =
MHD_NO
3931static enum _MHD_ParseCookie
3932parse_cookies_string (
char *str,
3933 const size_t str_len,
3959 while (
' ' == str[i] ||
'\t' == str[i] ||
';' == str[i])
3961 if (! allow_wsp_empty)
3962 return MHD_PARSE_COOKIE_MALFORMED;
3966 return non_strict? MHD_PARSE_COOKIE_OK_LAX : MHD_PARSE_COOKIE_OK;
3973 const char l = str[i];
3974 if ((
'=' == l) || (
' ' == l) || (
'\t' == l) || (
'"' == l) || (
',' == l) ||
3975 (
';' == l) || (0 == l))
3977 }
while (str_len > ++i);
3978 name_len = i - name_start;
3980 while (str_len > i && (
' ' == str[i] ||
'\t' == str[i]))
3982 if (! wsp_around_eq)
3983 return MHD_PARSE_COOKIE_MALFORMED;
3987 if ((str_len == i) || (
'=' != str[i]) || (0 == name_len))
3988 return MHD_PARSE_COOKIE_MALFORMED;
3993 while (str_len > i && (
' ' == str[i] ||
'\t' == str[i]))
3995 if (! wsp_around_eq)
3996 return MHD_PARSE_COOKIE_MALFORMED;
4012 val_quoted = (
'"' == str[i]);
4019 const char l = str[i];
4020 if ((
';' == l) || (
'"' == l) || (
',' == l) || (
';' == l) ||
4021 (
'\\' == l) || (0 == l))
4023 if ((
' ' == l) || (
'\t' == l))
4027 if (! wsp_in_quoted)
4028 return MHD_PARSE_COOKIE_MALFORMED;
4033 value_len = i - value_start;
4036 if ((str_len == i) || (
'"' != str[i]))
4037 return MHD_PARSE_COOKIE_MALFORMED;
4041 if ((str_len > i) && ((
' ' == str[i]) || (
'\t' == str[i])))
4046 }
while (str_len > i && (
' ' == str[i] ||
'\t' == str[i]));
4050 if (! allow_wsp_empty)
4051 return MHD_PARSE_COOKIE_MALFORMED;
4056 valid_cookie =
true;
4057 else if (
';' == str[i])
4058 valid_cookie =
true;
4060 valid_cookie =
false;
4063 return MHD_PARSE_COOKIE_MALFORMED;
4066 str[name_start + name_len] = 0;
4069 mhd_assert (value_start + value_len <= str_len);
4070 str[value_start + value_len] = 0;
4078 return MHD_PARSE_COOKIE_NO_MEMORY;
4089 return MHD_PARSE_COOKIE_NO_MEMORY;
4095 mhd_assert (
';' != str[i] || val_quoted || non_strict || 0 == value_len);
4099 if (! allow_wsp_empty)
4100 return MHD_PARSE_COOKIE_MALFORMED;
4103 else if (
' ' != str[i])
4105 if ((
'\t' == str[i]) && tab_as_sp)
4107 else if (! allow_no_space)
4108 return MHD_PARSE_COOKIE_MALFORMED;
4116 if (! allow_wsp_empty)
4117 return MHD_PARSE_COOKIE_MALFORMED;
4123 return non_strict? MHD_PARSE_COOKIE_OK_LAX : MHD_PARSE_COOKIE_OK;
4133static enum _MHD_ParseCookie
4140 enum _MHD_ParseCookie parse_res;
4143 const bool allow_partially_correct_cookie =
4154 return MHD_PARSE_COOKIE_OK;
4156 return MHD_PARSE_COOKIE_OK;
4161 parse_res = MHD_PARSE_COOKIE_NO_MEMORY;
4167 cpy[hdr_len] =
'\0';
4171 while (i < hdr_len && (
' ' == cpy[i] ||
'\t' == cpy[i]))
4174 parse_res = parse_cookies_string (cpy + i, hdr_len - i, connection);
4179 case MHD_PARSE_COOKIE_OK:
4181 case MHD_PARSE_COOKIE_OK_LAX:
4184 MHD_DLOG (connection->
daemon,
4185 _ (
"The Cookie header has been parsed, but it is not fully "
4186 "compliant with the standard.\n"));
4189 case MHD_PARSE_COOKIE_MALFORMED:
4193 if (allow_partially_correct_cookie)
4194 MHD_DLOG (connection->
daemon,
4195 _ (
"The Cookie header has been only partially parsed as it "
4196 "contains malformed data.\n"));
4203 MHD_DLOG (connection->
daemon,
4204 _ (
"The Cookie header has been ignored as it contains "
4205 "malformed data.\n"));
4209 MHD_DLOG (connection->
daemon,
4210 _ (
"The Cookie header has malformed data.\n"));
4213 case MHD_PARSE_COOKIE_NO_MEMORY:
4215 MHD_DLOG (connection->
daemon,
4216 _ (
"Not enough memory in the connection pool to "
4217 "parse client cookies!\n"));
4224#ifndef HAVE_MESSAGES
4238#define HTTP_VER_LEN (MHD_STATICSTR_LEN_ (MHD_HTTP_VERSION_1_1))
4251 const char *http_string,
4254 const char *
const h = http_string;
4260 (
'H' != h[0]) || (
'T' != h[1]) || (
'T' != h[2]) || (
'P' != h[3]) ||
4263 ((
'0' > h[5]) || (
'9' < h[5])) ||
4264 ((
'0' > h[7]) || (
'9' < h[7])))
4272 if (1 == h[5] -
'0')
4275 if (1 == h[7] -
'0')
4277 else if (0 == h[7] -
'0')
4285 if (0 == h[5] -
'0')
4315 const char *
const m = method;
4379 _ (
"Application reported internal error, " \
4380 "closing connection."));
4409 const bool allow_bws = (2 < discp_lvl);
4417 size_t to_be_processed;
4418 size_t left_unprocessed;
4419 size_t processed_size;
4421 instant_retry =
false;
4433 if ( (2 <= available) &&
4434 (
'\r' == buffer_head[0]) &&
4435 (
'\n' == buffer_head[1]) )
4437 else if (bare_lf_as_crlf && (
'\n' == buffer_head[0]))
4439 else if (2 > available)
4458 uint64_t cur_chunk_left;
4467 if (cur_chunk_left > available)
4468 to_be_processed = available;
4471 to_be_processed = (size_t) cur_chunk_left;
4472 if (available > to_be_processed)
4473 instant_retry =
true;
4480 uint64_t chunk_size;
4494 if (num_dig == available)
4497 broken = (0 == num_dig);
4500 overflow = (((
'0' <= buffer_head[0]) && (
'9' >= buffer_head[0])) ||
4501 ((
'A' <= buffer_head[0]) && (
'F' >= buffer_head[0])) ||
4502 ((
'a' <= buffer_head[0]) && (
'f' >= buffer_head[0])));
4509 size_t chunk_size_line_len;
4511 chunk_size_line_len = 0;
4512 if ((
';' == buffer_head[num_dig]) ||
4514 ((
' ' == buffer_head[num_dig]) ||
4515 (
'\t' == buffer_head[num_dig]))))
4520 for (i = num_dig; i < available; ++i)
4522 if ((
' ' != buffer_head[i]) && (
'\t' != buffer_head[i]))
4527 if (
';' == buffer_head[i])
4529 for (++i; i < available; ++i)
4531 if (
'\n' == buffer_head[i])
4539 if (bare_lf_as_crlf)
4540 chunk_size_line_len = i;
4541 else if (
'\r' == buffer_head[i - 1])
4542 chunk_size_line_len = i;
4553 if ((2 <= (available - num_dig)) &&
4554 (
'\r' == buffer_head[num_dig]) &&
4555 (
'\n' == buffer_head[num_dig + 1]))
4556 chunk_size_line_len = num_dig + 2;
4557 else if (bare_lf_as_crlf &&
4558 (
'\n' == buffer_head[num_dig]))
4559 chunk_size_line_len = num_dig + 1;
4560 else if (2 > (available - num_dig))
4564 if (0 != chunk_size_line_len)
4566 mhd_assert (chunk_size_line_len <= available);
4571 available -= chunk_size_line_len;
4572 buffer_head += chunk_size_line_len;
4574 if (0 == chunk_size)
4580 instant_retry =
true;
4605 to_be_processed = available;
4607 left_unprocessed = to_be_processed;
4623 _ (
"Application reported internal error, " \
4624 "closing connection."));
4629 if (left_unprocessed > to_be_processed)
4630 MHD_PANIC (
_ (
"libmicrohttpd API violation.\n"));
4633 (left_unprocessed != to_be_processed);
4635 if (0 != left_unprocessed)
4637 instant_retry =
false;
4647 _ (
"WARNING: Access Handler Callback has not processed " \
4648 "any upload data and connection is not suspended. " \
4649 "This may result in hung connection.\n"));
4653 processed_size = to_be_processed - left_unprocessed;
4655 buffer_head += processed_size;
4656 available -= processed_size;
4667 }
while (instant_retry);
4669 if ( (available > 0) &&
4700 connection->
state = next_state;
4719#ifdef COOKIE_SUPPORT
4722 handle_req_cookie_no_space (connection);
4738 MHD_DLOG (connection->
daemon,
4739 _ (
"Received HTTP/1.1 request without `Host' header.\n"));
4791 MHD_DLOG (connection->
daemon,
4792 _ (
"The 'Content-Length' request header is ignored "
4793 "as chunked Transfer-Encoding is used "
4794 "for this request.\n"));
4816 if (((0 == num_digits) &&
4818 (
'0' <= clen[0]) && (
'9' >= clen[0]))
4823 MHD_DLOG (connection->
daemon,
4824 _ (
"Too large value of 'Content-Length' header. " \
4825 "Closing connection.\n"));
4831 else if ((val_len != num_digits) ||
4836 MHD_DLOG (connection->
daemon,
4837 _ (
"Failed to parse 'Content-Length' header. " \
4838 "Closing connection.\n"));
4855_MHD_static_inline
void
4866_MHD_static_inline
void
4875#ifndef MHD_MAX_EMPTY_LINES_SKIP
4880#define MHD_MAX_EMPTY_LINES_SKIP 1024
4897 const bool skip_empty_lines = (1 >= discp_lvl);
4900 const bool skip_several_empty_lines = (skip_empty_lines && (0 >= discp_lvl));
4903 const bool skip_unlimited_empty_lines =
4904 (skip_empty_lines && (-3 >= discp_lvl));
4910 const bool tab_as_wsp = (0 >= discp_lvl);
4913 const bool other_wsp_as_wsp = (-1 >= discp_lvl);
4916 const bool wsp_blocks = (-1 >= discp_lvl);
4919 const bool wsp_in_uri = (0 >= discp_lvl);
4923 const bool wsp_in_uri_keep = (-2 >= discp_lvl);
4926 const bool bare_cr_keep = (wsp_in_uri_keep && (-3 >= discp_lvl));
4929 const bool bare_cr_as_sp = ((! bare_cr_keep) && (-1 >= discp_lvl));
4951 && (skip_empty_lines))
4965 is_empty_line =
false;
4972 is_empty_line =
true;
4982 is_empty_line =
true;
4990 if ((! skip_unlimited_empty_lines) &&
4991 (((
unsigned int) ((skip_several_empty_lines) ?
4996 _ (
"Too many meaningless extra empty lines " \
4997 "received before the request"));
5003 }
while (is_empty_line);
5011 while (p < c->read_buffer_offset)
5030 end_of_line =
false;
5059 else if (! bare_cr_keep)
5071 _ (
"Bare CR characters are not allowed " \
5072 "in the request line.\n"));
5077 else if (
'\n' == chr)
5081 if (bare_lf_as_crlf)
5098 _ (
"Bare LF characters are not allowed " \
5099 "in the request line.\n"));
5223 _ (
"The request line is malformed.\n"));
5229 if ((! wsp_blocks) &&
5266 || ((
'\t' == chr) && (tab_as_wsp))
5267 || ((other_wsp_as_wsp) && ((0xb == chr) || (0xc == chr))))
5286 _ (
"The request line starts with "
5287 "a whitespace.\n"));
5324 _ (
"The request line has more than "
5325 "two whitespaces.\n"));
5400 else if ((0xb == chr) || (0xc == chr))
5413 _ (
"Invalid character is in the "
5414 "request line.\n"));
5422 _ (
"The NUL character is in the "
5423 "request line.\n"));
5436#ifndef MHD_MAX_FIXED_URI_LEN
5440#define MHD_MAX_FIXED_URI_LEN (64 * 1024)
5454 size_t fixed_uri_len;
5458 size_t hdr_name_len;
5468 (
NULL == (b = malloc (fixed_uri_len + 1))) )
5471 _ (
"The request has whitespace character is " \
5472 "in the URI and the URI is too large to " \
5473 "send automatic redirect to fixed URI.\n"));
5512 }
while (i < c->rq.req_target_len);
5517 hdr_name = malloc (hdr_name_len + 1);
5518 if (
NULL != hdr_name)
5535 _ (
"The request has whitespace character is in the " \
5623 const bool wsp_in_uri = (0 >= discp_lvl);
5626 const bool wsp_in_uri_keep = (-2 >= discp_lvl);
5661 if (! wsp_in_uri_keep)
5712 bool process_footers,
5724 const bool bare_cr_keep = (-3 >= discp_lvl);
5727 const bool bare_cr_as_sp = ((! bare_cr_keep) && (-1 >= discp_lvl));
5730 const bool nul_as_sp = (-1 >= discp_lvl);
5733 const bool allow_folded = (0 >= discp_lvl);
5739 const bool allow_wsp_at_start = allow_folded && (-1 >= discp_lvl);
5742 const bool allow_wsp_in_name = (-2 >= discp_lvl);
5745 const bool allow_empty_name = (-2 >= discp_lvl);
5748 const bool allow_wsp_before_colon = (-3 >= discp_lvl);
5752 const bool allow_line_without_colon = (-2 >= discp_lvl);
5756#if ! defined (HAVE_MESSAGES) && ! defined(_DEBUG)
5757 (void) process_footers;
5767 while (p < c->read_buffer_offset)
5816 else if (! bare_cr_keep)
5818 if (! process_footers)
5828 end_of_line =
false;
5831 else if (
'\n' == chr)
5835 if (bare_lf_as_crlf)
5847 if (! process_footers)
5859 end_of_line =
false;
5867 const size_t line_len = p + ((
'\r' == chr) ? 2 : 1);
5868 char next_line_char;
5869 mhd_assert (line_len <= c->read_buffer_offset);
5888 mhd_assert (line_len < c->read_buffer_offset);
5892 if ((
' ' == next_line_char) ||
5893 (
'\t' == next_line_char))
5898 if (! process_footers)
5919 bool skip_line =
false;
5929 _ (
"Whitespace-prefixed first header line " \
5930 "has been skipped.\n"));
5936 if (! allow_line_without_colon)
5938 if (! process_footers)
5941 ERR_RSP_HEADER_WITHOUT_COLON);
5995 hdr_value->
len = value_len;
6005 else if ((
' ' == chr) || (
'\t' == chr))
6009 if (! allow_wsp_at_start)
6011 if (! process_footers)
6027 if (allow_wsp_in_name || allow_wsp_before_colon)
6034 if (! process_footers)
6057 if (! process_footers)
6064 ERR_RSP_INVALID_CHR_IN_FOOTER);
6087 mhd_assert (allow_wsp_in_name || allow_wsp_before_colon);
6088 if (! allow_wsp_before_colon)
6090 if (! process_footers)
6101#ifndef MHD_FAVOR_SMALL_CODE
6107 if (! process_footers)
6125 mhd_assert (allow_wsp_in_name || allow_wsp_before_colon);
6126 if (! allow_wsp_in_name)
6128 if (! process_footers)
6139#ifndef MHD_FAVOR_SMALL_CODE
6150#ifndef MHD_FAVOR_SMALL_CODE
6154#ifdef MHD_FAVOR_SMALL_CODE
6192 res =
get_req_header (c, process_footers, &hdr_name, &hdr_value);
6207 (hdr_name.
str[hdr_name.
len - 1] !=
' '));
6209 (hdr_name.
str[hdr_name.
len - 1] !=
'\t'));
6213 (hdr_value.
str[hdr_value.
len - 1] !=
' '));
6215 (hdr_value.
str[hdr_value.
len - 1] !=
'\t'));
6219 (! process_footers) ?
6222 hdr_name.
str, hdr_name.
len,
6223 hdr_value.
str, hdr_value.
len))
6225 size_t add_element_size;
6231 _ (
"Failed to allocate memory in the connection memory " \
6232 "pool to store %s.\n"),
6233 (! process_footers) ?
_ (
"header") :
_ (
"footer"));
6236 add_element_size = hdr_value.
len
6237 + (size_t) (hdr_value.
str - hdr_name.
str);
6239 if (! process_footers)
6279 _ (
"One bare CR character has been replaced with space " \
6281 (! process_footers) ?
6282 _ (
"the request line or in the request headers") :
6283 _ (
"the request footers"));
6288 _ (
"%" PRIu64 " bare CR characters have been replaced with " \
6289 "spaces in the request line and/or in the request %s.\n"),
6291 (! process_footers) ?
_ (
"headers") :
_ (
"footers"));
6296 _ (
"One %s line without colon has been skipped.\n"),
6297 (! process_footers) ?
_ (
"header") :
_ (
"footer"));
6302 _ (
"%" PRIu64 " %s lines without colons has been skipped.\n"),
6304 (! process_footers) ?
_ (
"header") :
_ (
"footer"));
6309 if (! process_footers)
6328 const char *last_elmnt_end;
6329 size_t shift_back_size;
6337 shift_back_size = (size_t) (c->
read_buffer - (last_elmnt_end + 1));
6364#if defined(MHD_USE_THREADS)
6380#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
6390#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
6429 bytes_read = connection->
recv_cls (connection,
6434 if ((bytes_read < 0) || socket_error)
6438 if ((bytes_read > 0) && connection->
sk_nonblck)
6441 bytes_read = connection->
recv_cls (connection, &dummy,
sizeof (dummy));
6449 MHD_DLOG (connection->
daemon,
6450 _ (
"Socket has been disconnected when reading request.\n"));
6461 MHD_DLOG (connection->
daemon,
6462 _ (
"Connection socket is closed when reading " \
6463 "request due to the error: %s\n"),
6464 (bytes_read < 0) ? str_conn_error_ (bytes_read) :
6465 "detected connection closure");
6472 if (0 == bytes_read)
6479 MHD_DLOG (connection->
daemon,
6480 _ (
"Connection was closed by remote side with incomplete "
6500 MHD_DLOG (connection->
daemon,
6501 _ (
"In function %s handling connection at state: %s\n"),
6503 MHD_state_to_string (connection->
state));
6506 switch (connection->
state)
6524#ifdef UPGRADE_SUPPORT
6525 case MHD_CONNECTION_UPGRADE:
6598 MHD_DLOG (connection->
daemon,
6599 _ (
"In function %s handling connection at state: %s\n"),
6601 MHD_state_to_string (connection->
state));
6603 switch (connection->
state)
6625 MHD_DLOG (connection->
daemon,
6626 _ (
"Failed to send data in request for %s.\n"),
6627 connection->
rq.
url);
6633#if _MHD_DEBUG_SEND_DATA
6635 _ (
"Sent 100 continue response: `%.*s'\n"),
6711 MHD_DLOG (connection->
daemon,
6712 _ (
"Failed to send the response headers for the " \
6713 "request for `%s'. Error: %s\n"),
6715 str_conn_error_ (ret));
6722 if (((
size_t) ret) > wb_ready)
6748 uint64_t data_write_offset;
6750#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
6759#if defined(_MHD_HAVE_SENDFILE)
6760 if (MHD_resp_sender_sendfile == connection->
rp.resp_sender)
6763 ret = MHD_send_sendfile_ (connection);
6777 if (data_write_offset > (uint64_t)
SIZE_MAX)
6778 MHD_PANIC (
_ (
"Data offset exceeds limit.\n"));
6781 [(
size_t) data_write_offset],
6783 - (
size_t) data_write_offset,
6785#if _MHD_DEBUG_SEND_DATA
6788 _ (
"Sent %d-byte DATA response: `%.*s'\n"),
6792 - rp.response->data_start]);
6795#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
6804 MHD_DLOG (connection->
daemon,
6805 _ (
"Failed to send the response body for the " \
6806 "request for `%s'. Error: %s\n"),
6808 str_conn_error_ (ret));
6836 MHD_DLOG (connection->
daemon,
6837 _ (
"Failed to send the chunked response body for the " \
6838 "request for `%s'. Error: %s\n"),
6840 str_conn_error_ (ret));
6872 MHD_DLOG (connection->
daemon,
6873 _ (
"Failed to send the footers for the " \
6874 "request for `%s'. Error: %s\n"),
6876 str_conn_error_ (ret));
6894#ifdef UPGRADE_SUPPORT
6895 case MHD_CONNECTION_UPGRADE:
6902 _ (
"Internal error.\n"));
6920 uint64_t since_actv;
6930 if (timeout < since_actv)
6937 if (5000 >= jump_back)
6941 _ (
"Detected system clock %u milliseconds jump back.\n"),
6942 (
unsigned int) jump_back);
6948 _ (
"Detected too large system clock %" PRIu64 " milliseconds "
6971#ifdef MHD_USE_THREADS
6985#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
7017#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
7025 if ( (MHD_ITC_IS_VALID_ (daemon->
itc)) &&
7026 (! MHD_itc_activate_ (daemon->
itc,
"c")) )
7030 _ (
"Failed to signal end of connection via inter-thread " \
7031 "communication channel.\n"));
7046 size_t read_buf_size;
7059 memset (&c->
rq, 0,
sizeof(c->
rq));
7060 memset (&c->
rp, 0,
sizeof(c->
rp));
7111 size_t new_read_buf_size;
7133 memset (&c->
rq, 0,
sizeof(c->
rq));
7136 memset (&c->
rp, 0,
sizeof(c->
rp));
7178#ifdef MHD_USE_THREADS
7198 _ (
"In function %s handling connection at state: %s\n"),
7200 MHD_state_to_string (connection->
state));
7202 switch (connection->
state)
7344 _ (
"Closing connection (failed to create "
7345 "response header).\n"));
7355#ifdef UPGRADE_SUPPORT
7358 connection->
state = MHD_CONNECTION_UPGRADE;
7399#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
7405#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
7417#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
7437#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
7445#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
7457#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
7478 _ (
"Closing connection (failed to create " \
7479 "response footer)."));
7511#ifdef UPGRADE_SUPPORT
7512 case MHD_CONNECTION_UPGRADE:
7535 ret = MHD_connection_epoll_update_ (connection);
7564 daemon->eready_tail,
7577 struct epoll_event event;
7579 event.events = EPOLLIN | EPOLLOUT | EPOLLPRI | EPOLLET;
7580 event.data.ptr = connection;
7581 if (0 != epoll_ctl (daemon->epoll_fd,
7589 _ (
"Call to epoll_ctl failed: %s\n"),
7638 if (
NULL == connection->tls_session)
7642 gnutls_cipher_algorithm_t res;
7643 res = gnutls_cipher_get (connection->tls_session);
7648 if (
NULL == connection->tls_session)
7652 gnutls_protocol_t res;
7653 res = gnutls_protocol_get_version (connection->tls_session);
7658 if (
NULL == connection->tls_session)
7676 sizeof(connection->
addr));
7696#if SIZEOF_UNSIGNED_INT <= (SIZEOF_UINT64_T - 2)
7737 unsigned int ui_val;
7739 daemon = connection->
daemon;
7745 va_start (ap, option);
7746 ui_val = va_arg (ap,
unsigned int);
7748#if (SIZEOF_UINT64_T - 2) <= SIZEOF_UNSIGNED_INT
7752 MHD_DLOG (connection->
daemon,
7753 _ (
"The specified connection timeout (%u) is too " \
7754 "large. Maximum allowed value (%" PRIu64 ") will be used " \
7764#if defined(MHD_USE_THREADS)
7787#if defined(MHD_USE_THREADS)
7845 unsigned int status_code,
7851 if ((
NULL == connection) || (
NULL == response))
7854 daemon = connection->
daemon;
7860 status_code &= ~MHD_ICY_FLAG;
7862#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
7869 _ (
"Attempted to queue response on wrong thread!\n"));
7886#ifdef UPGRADE_SUPPORT
7887 if (
NULL != response->upgrade_handler)
7894 _ (
"Attempted 'upgrade' connection on daemon without" \
7895 " MHD_ALLOW_UPGRADE option!\n"));
7903 _ (
"Application used invalid status code for" \
7904 " 'upgrade' response!\n"));
7912 _ (
"Application used invalid response" \
7913 " without \"Connection\" header!\n"));
7926 _ (
"Application used invalid response" \
7927 " without \"upgrade\" token in" \
7928 " \"Connection\" header!\n"));
7936 _ (
"Connection \"Upgrade\" can be used only " \
7937 "with HTTP/1.1 connections!\n"));
7945#ifdef UPGRADE_SUPPORT
7946 if (
NULL == response->upgrade_handler)
7950 _ (
"Application used status code 101 \"Switching Protocols\" " \
7951 "with non-'upgrade' response!\n"));
7958 _ (
"Application used status code 101 \"Switching Protocols\", " \
7959 "but this MHD was built without \"Upgrade\" support!\n"));
7964 if ( (100 > status_code) ||
7965 (999 < status_code) )
7969 _ (
"Refused wrong status code (%u). " \
7970 "HTTP requires three digits status code!\n"),
7975 if (200 > status_code)
7981 _ (
"Wrong status code (%u) refused. " \
7982 "HTTP/1.0 clients do not support 1xx status codes!\n"),
7992 _ (
"Wrong status code (%u) refused. " \
7993 "HTTP/1.0 reply mode does not support 1xx status codes!\n"),
8000 (2 == status_code / 100) )
8004 _ (
"Successful (%u) response code cannot be used to answer " \
8005 "\"CONNECT\" request!\n"),
8016 _ (
"HEAD-only response cannot be used when the request requires "
8017 "reply body to be sent!\n"));
8027 _ (
"The response has application-defined \"Content-Length\" " \
8028 "header. The reply to the request will be not " \
8029 "HTTP-compliant and may result in hung connection or " \
8030 "other problems!\n"));
8038#if defined(_MHD_HAVE_SENDFILE)
8039 if ( (response->
fd == -1) ||
8043 defined(MHD_SEND_SPIPE_SUPPRESS_POSSIBLE)
8048 connection->
rp.resp_sender = MHD_resp_sender_std;
8050 connection->
rp.resp_sender = MHD_resp_sender_sendfile;
#define ERR_MSG_REQUEST_CHUNK_LINE_TOO_BIG
#define REQUEST_CONTENTLENGTH_TOOLARGE
static enum MHD_Result build_connection_chunked_response_footer(struct MHD_Connection *connection)
static ssize_t recv_param_adapter(struct MHD_Connection *connection, void *other, size_t i)
#define ERR_RSP_EMPTY_FOOTER_NAME
static enum MHD_Result build_header_response(struct MHD_Connection *connection)
static void connection_close_error(struct MHD_Connection *connection, const char *emsg)
static bool process_request_target(struct MHD_Connection *c)
void MHD_connection_set_initial_state_(struct MHD_Connection *c)
#define MHD_CHUNK_HEADER_REASONABLE_LEN
#define MHD_lookup_header_s_token_ci(c, h, tkn)
@ MHD_PROC_RECV_BODY_CHUNKED
@ MHD_PROC_RECV_BODY_NORMAL
#define REQUEST_CHUNK_TOO_LARGE
void MHD_connection_handle_write(struct MHD_Connection *connection)
static void MHD_connection_update_event_loop_info(struct MHD_Connection *connection)
#define buffer_append_s(buf, ppos, buf_size, str)
void * MHD_connection_alloc_memory_(struct MHD_Connection *connection, size_t size)
#define MHD_MAX_FIXED_URI_LEN
static enum MHD_Result try_ready_normal_body(struct MHD_Connection *connection)
#define REQUEST_CHUNKED_MALFORMED
#define REQ_HTTP_VER_IS_NOT_SUPPORTED
#define MHD_MAX_REASONABLE_HEADERS_SIZE_
#define RQ_LINE_TOO_MANY_WSP
static void call_connection_handler(struct MHD_Connection *connection)
static enum MHD_Result connection_add_header(void *cls, const char *key, size_t key_size, const char *value, size_t value_size, enum MHD_ValueKind kind)
static void process_request_body(struct MHD_Connection *connection)
static void setup_reply_properties(struct MHD_Connection *connection)
#define HTTP_100_CONTINUE
static void send_redirect_fixed_rq_target(struct MHD_Connection *c)
static void handle_recv_no_space(struct MHD_Connection *c, enum MHD_ProcRecvDataStage stage)
#define transmit_error_response_static(c, code, msg)
#define REQUEST_MALFORMED
static bool get_request_line(struct MHD_Connection *c)
@ MHD_HDR_LINE_READING_NEED_MORE_DATA
@ MHD_HDR_LINE_READING_GOT_END_OF_HEADER
@ MHD_HDR_LINE_READING_GOT_HEADER
@ MHD_HDR_LINE_READING_DATA_ERROR
_MHD_static_inline void reset_rq_header_processing_state(struct MHD_Connection *c)
static void connection_shrink_read_buffer(struct MHD_Connection *connection)
#define ERR_RSP_WSP_IN_FOOTER_NAME
#define MHD_ALLOW_BARE_LF_AS_CRLF_(discp_lvl)
static enum replyBodyUse is_reply_body_needed(struct MHD_Connection *connection, unsigned int rcode)
void MHD_set_http_callbacks_(struct MHD_Connection *connection)
static void transmit_error_response_len(struct MHD_Connection *connection, unsigned int status_code, const char *message, size_t message_len, char *header_name, size_t header_name_len, char *header_value, size_t header_value_len)
#define REQ_HTTP_VER_IS_TOO_OLD
#define ERR_MSG_REQUEST_TOO_BIG
#define MHD_MAX_REASONABLE_REQ_TARGET_SIZE_
#define ERR_MSG_REQUEST_FOOTER_TOO_BIG
#define ERR_MSG_REQUEST_CHUNK_LINE_EXT_TOO_BIG
static bool connection_check_timedout(struct MHD_Connection *c)
static enum MHD_ConnKeepAlive keepalive_possible(struct MHD_Connection *connection)
static void handle_req_chunk_size_line_no_space(struct MHD_Connection *c, const char *chunk_size_line, size_t chunk_size_line_size)
#define REQUEST_LACKS_HOST
#define BARE_CR_IN_FOOTER
static bool try_grow_read_buffer(struct MHD_Connection *connection, bool required)
static bool parse_http_version(struct MHD_Connection *connection, const char *http_string, size_t len)
#define BARE_LF_IN_HEADER
#define ERR_RSP_EMPTY_HEADER_NAME
static bool need_100_continue(struct MHD_Connection *connection)
#define ERR_RSP_WSP_IN_HEADER_NAME
static bool get_req_headers(struct MHD_Connection *c, bool process_footers)
#define ERROR_MSG_DATA_NOT_HANDLED_BY_APP
#define MHD_MIN_REASONABLE_REQ_METHOD_SIZE_
static unsigned int get_no_space_err_status_code(struct MHD_Connection *c, enum MHD_ProcRecvDataStage stage, const char *add_element, size_t add_element_size)
#define REQUEST_UNSUPPORTED_TR_ENCODING
enum MHD_Result MHD_connection_handle_idle(struct MHD_Connection *connection)
static void cleanup_connection(struct MHD_Connection *connection)
#define ERR_RSP_OBS_FOLD_FOOTER
static void parse_http_std_method(struct MHD_Connection *connection, const char *method, size_t len)
static bool check_and_grow_read_buffer_space(struct MHD_Connection *c)
static enum MHD_Result try_ready_chunked_body(struct MHD_Connection *connection, bool *p_finished)
static bool get_date_str(char *date)
#define BARE_LF_IN_FOOTER
static void connection_reset(struct MHD_Connection *connection, bool reuse)
#define REQUEST_LENGTH_WITH_TR_ENCODING
#define MHD_MIN_REASONABLE_REQ_TARGET_SIZE_
#define RQ_TARGET_INVALID_CHAR
static bool get_request_line_inner(struct MHD_Connection *c)
static void handle_req_footers_no_space(struct MHD_Connection *c, const char *add_footer, size_t add_footer_size)
void MHD_connection_handle_read(struct MHD_Connection *connection, bool socket_error)
static void connection_switch_from_recv_to_send(struct MHD_Connection *connection)
#define ERR_RSP_WSP_BEFORE_FOOTER
static void parse_connection_headers(struct MHD_Connection *connection)
#define ERR_RSP_INVALID_CHR_IN_HEADER
void MHD_update_last_activity_(struct MHD_Connection *connection)
#define MHD_MAX_EMPTY_LINES_SKIP
#define MHD_MIN_REASONABLE_HEADERS_SIZE_
#define BARE_CR_IN_HEADER
#define ERR_MSG_REQUEST_HEADER_TOO_BIG
static bool add_user_headers(char *buf, size_t *ppos, size_t buf_size, struct MHD_Response *response, bool filter_transf_enc, bool filter_content_len, bool add_close, bool add_keep_alive)
#define REQUEST_CONTENTLENGTH_MALFORMED
static enum MHD_HdrLineReadRes_ get_req_header(struct MHD_Connection *c, bool process_footers, struct _MHD_str_w_len *hdr_name, struct _MHD_str_w_len *hdr_value)
static void check_connection_reply(struct MHD_Connection *connection)
static void handle_req_headers_no_space(struct MHD_Connection *c, const char *add_header, size_t add_header_size)
void MHD_connection_close_(struct MHD_Connection *connection, enum MHD_RequestTerminationCode termination_code)
static size_t connection_maximize_write_buffer(struct MHD_Connection *connection)
static bool has_unprocessed_upload_body_data_in_buffer(struct MHD_Connection *c)
void MHD_connection_mark_closed_(struct MHD_Connection *connection)
#define CONNECTION_CLOSE_ERROR(c, emsg)
#define transmit_error_response_header(c, code, m, hd_n, hd_n_l, hd_v, hd_v_l)
static bool buffer_append(char *buf, size_t *ppos, size_t buf_size, const char *append, size_t append_size)
static enum MHD_Result check_write_done(struct MHD_Connection *connection, enum MHD_CONNECTION_STATE next_state)
#define ERR_RSP_WSP_BEFORE_HEADER
#define ERR_MSG_REQUEST_HEADER_WITH_COOKIES_TOO_BIG
_MHD_static_inline void switch_to_rq_headers_processing(struct MHD_Connection *c)
static bool get_date_header(char *header)
static bool MHD_lookup_header_token_ci(const struct MHD_Connection *connection, const char *header, size_t header_len, const char *token, size_t token_len)
#define ERR_RSP_FOOTER_WITHOUT_COLON
#define MHD_MIN_REASONABLE_REQ_CHUNK_LINE_LENGTH_
Methods for managing connections.
#define MHD_connection_finish_forward_(conn)
#define MHD_ERR_OPNOTSUPP_
static int parse_cookie_header(struct MHD_Request *request)
bool MHD_tls_connection_shutdown(struct MHD_Connection *connection)
bool MHD_run_tls_handshake_(struct MHD_Connection *connection)
Methods for managing connections.
#define MHD_HTTP_INTERNAL_SERVER_ERROR
#define MHD_HTTP_MOVED_PERMANENTLY
#define MHD_HTTP_URI_TOO_LONG
#define MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE
#define MHD_HTTP_PROCESSING
#define MHD_HTTP_NOT_IMPLEMENTED
#define MHD_HTTP_SWITCHING_PROTOCOLS
#define MHD_HTTP_HTTP_VERSION_NOT_SUPPORTED
#define MHD_HTTP_CONTENT_TOO_LARGE
#define MHD_HTTP_NOT_MODIFIED
#define MHD_HTTP_NO_CONTENT
#define MHD_HTTP_BAD_REQUEST
#define MHD_HTTP_METHOD_TRACE
#define MHD_HTTP_METHOD_OPTIONS
#define MHD_HTTP_METHOD_GET
#define MHD_HTTP_METHOD_HEAD
#define MHD_HTTP_METHOD_POST
#define MHD_HTTP_METHOD_PUT
#define MHD_HTTP_METHOD_CONNECT
#define MHD_HTTP_METHOD_DELETE
_MHD_EXTERN enum MHD_Result MHD_set_connection_value(struct MHD_Connection *connection, enum MHD_ValueKind kind, const char *key, const char *value)
enum MHD_Result(* MHD_KeyValueIterator)(void *cls, enum MHD_ValueKind kind, const char *key, const char *value)
_MHD_EXTERN const char * MHD_lookup_connection_value(struct MHD_Connection *connection, enum MHD_ValueKind kind, const char *key)
enum MHD_Result(* MHD_KeyValueIteratorN)(void *cls, enum MHD_ValueKind kind, const char *key, size_t key_size, const char *value, size_t value_size)
_MHD_EXTERN int MHD_get_connection_values_n(struct MHD_Connection *connection, enum MHD_ValueKind kind, MHD_KeyValueIteratorN iterator, void *iterator_cls)
_MHD_EXTERN int MHD_get_connection_values(struct MHD_Connection *connection, enum MHD_ValueKind kind, MHD_KeyValueIterator iterator, void *iterator_cls)
static enum MHD_Result MHD_set_connection_value_n_nocheck_(struct MHD_Connection *connection, enum MHD_ValueKind kind, const char *key, size_t key_size, const char *value, size_t value_size)
_MHD_EXTERN enum MHD_Result MHD_set_connection_value_n(struct MHD_Connection *connection, enum MHD_ValueKind kind, const char *key, size_t key_size, const char *value, size_t value_size)
_MHD_EXTERN enum MHD_Result MHD_lookup_connection_value_n(struct MHD_Connection *connection, enum MHD_ValueKind kind, const char *key, size_t key_size, const char **value_ptr, size_t *value_size_ptr)
MHD_RequestTerminationCode
@ MHD_CONNECTION_INFO_CONNECTION_TIMEOUT
@ MHD_CONNECTION_INFO_SOCKET_CONTEXT
@ MHD_CONNECTION_INFO_GNUTLS_SESSION
@ MHD_CONNECTION_INFO_REQUEST_HEADER_SIZE
@ MHD_CONNECTION_INFO_CIPHER_ALGO
@ MHD_CONNECTION_INFO_CONNECTION_SUSPENDED
@ MHD_CONNECTION_INFO_CLIENT_ADDRESS
@ MHD_CONNECTION_INFO_DAEMON
@ MHD_CONNECTION_INFO_GNUTLS_CLIENT_CERT
@ MHD_CONNECTION_INFO_HTTP_STATUS
@ MHD_CONNECTION_INFO_CONNECTION_FD
@ MHD_CONNECTION_INFO_PROTOCOL
@ MHD_REQUEST_TERMINATED_TIMEOUT_REACHED
@ MHD_REQUEST_TERMINATED_COMPLETED_OK
@ MHD_REQUEST_TERMINATED_WITH_ERROR
@ MHD_REQUEST_TERMINATED_READ_ERROR
@ MHD_REQUEST_TERMINATED_CLIENT_ABORT
_MHD_EXTERN enum MHD_Result MHD_queue_response(struct MHD_Connection *connection, unsigned int status_code, struct MHD_Response *response)
_MHD_EXTERN void MHD_destroy_response(struct MHD_Response *response)
enum MHD_HdrLineReadRes_ _MHD_FIXED_ENUM
_MHD_EXTERN struct MHD_Response * MHD_create_response_from_buffer_static(size_t size, const void *buffer)
_MHD_EXTERN enum MHD_Result MHD_set_connection_option(struct MHD_Connection *connection, enum MHD_CONNECTION_OPTION option,...)
_MHD_EXTERN const union MHD_ConnectionInfo * MHD_get_connection_info(struct MHD_Connection *connection, enum MHD_ConnectionInfoType info_type,...)
#define MHD_HTTP_VERSION_1_0
#define MHD_HTTP_VERSION_1_1
bool MHD_parse_arguments_(struct MHD_Request *request, enum MHD_ValueKind kind, char *args, MHD_ArgumentIterator_ cb, unsigned int *num_headers)
#define MHD_ERR_CONNRESET_
#define XDLL_insert(head, tail, element)
@ MHD_EPOLL_STATE_SUSPENDED
@ MHD_EPOLL_STATE_IN_EREADY_EDLL
@ MHD_EPOLL_STATE_READ_READY
@ MHD_EPOLL_STATE_IN_EPOLL_SET
@ MHD_EPOLL_STATE_WRITE_READY
#define DLL_insert(head, tail, element)
#define EDLL_insert(head, tail, element)
@ MHD_CONN_KEEPALIVE_UNKOWN
#define EDLL_remove(head, tail, element)
#define XDLL_remove(head, tail, element)
#define DLL_remove(head, tail, element)
void * MHD_pool_reallocate(struct MemoryPool *pool, void *old, size_t old_size, size_t new_size)
void MHD_pool_destroy(struct MemoryPool *pool)
size_t MHD_pool_get_free(struct MemoryPool *pool)
void * MHD_pool_reset(struct MemoryPool *pool, void *keep, size_t copy_bytes, size_t new_size)
void * MHD_pool_allocate(struct MemoryPool *pool, size_t size, int from_end)
#define MHD_mutex_unlock_chk_(pmutex)
#define MHD_mutex_lock_chk_(pmutex)
#define MHD_SCKT_ERR_IS_(err, code)
#define MHD_SCKT_ERR_IS_EAGAIN_(err)
#define MHD_SCKT_ERR_IS_LOW_RESOURCES_(err)
#define MHD_socket_last_strerr_()
#define MHD_SCKT_EOPNOTSUPP_
#define MHD_socket_get_error_()
#define MHD_SCKT_ERR_IS_REMOTE_DISCNN_(err)
#define MHD_SCKT_ERR_IS_EINTR_(err)
#define MHD_SCKT_SEND_MAX_SIZE_
#define MHD_SCKT_ENOTCONN_
#define MHD_recv_(s, b, l)
int MHD_str_equal_caseless_(const char *str1, const char *str2)
size_t MHD_str_to_uint64_n_(const char *str, size_t maxlen, uint64_t *out_val)
size_t MHD_strx_to_uint64_n_(const char *str, size_t maxlen, uint64_t *out_val)
int MHD_str_equal_caseless_n_(const char *const str1, const char *const str2, size_t maxlen)
bool MHD_str_has_token_caseless_(const char *str, const char *const token, size_t token_len)
#define MHD_str_has_s_token_caseless_(str, tkn)
#define MHD_STATICSTR_LEN_(macro)
ssize_t MHD_send_hdr_and_body_(struct MHD_Connection *connection, const char *header, size_t header_size, bool never_push_hdr, const char *body, size_t body_size, bool complete_response)
ssize_t MHD_send_iovec_(struct MHD_Connection *connection, struct MHD_iovec_track_ *const r_iov, bool push_data)
ssize_t MHD_send_data_(struct MHD_Connection *connection, const char *buffer, size_t buffer_size, bool push_data)
Declarations of send() wrappers.
MHD internal shared structures.
@ MHD_CONNECTION_BODY_RECEIVED
@ MHD_CONNECTION_CHUNKED_BODY_SENT
@ MHD_CONNECTION_REQ_HEADERS_RECEIVING
@ MHD_CONNECTION_BODY_RECEIVING
@ MHD_CONNECTION_HEADERS_SENDING
@ MHD_CONNECTION_FOOTERS_SENDING
@ MHD_CONNECTION_FOOTERS_RECEIVED
@ MHD_CONNECTION_FULL_REPLY_SENT
@ MHD_CONNECTION_HEADERS_SENT
@ MHD_CONNECTION_HEADERS_PROCESSED
@ MHD_CONNECTION_REQ_LINE_RECEIVED
@ MHD_CONNECTION_NORMAL_BODY_UNREADY
@ MHD_CONNECTION_HEADERS_RECEIVED
@ MHD_CONNECTION_NORMAL_BODY_READY
@ MHD_CONNECTION_START_REPLY
@ MHD_CONNECTION_FOOTERS_RECEIVING
@ MHD_CONNECTION_CHUNKED_BODY_READY
@ MHD_CONNECTION_FULL_REQ_RECEIVED
@ MHD_CONNECTION_CHUNKED_BODY_UNREADY
@ MHD_CONNECTION_CONTINUE_SENDING
@ MHD_CONNECTION_REQ_LINE_RECEIVING
@ MHD_TLS_CONN_TLS_CLOSING
@ MHD_TLS_CONN_WR_CLOSING
@ MHD_TLS_CONN_INVALID_STATE
@ MHD_TLS_CONN_TLS_CLOSED
@ MHD_TLS_CONN_TLS_FAILED
@ MHD_TLS_CONN_HANDSHAKING
@ MHD_EVENT_LOOP_INFO_PROCESS_READ
@ MHD_EVENT_LOOP_INFO_PROCESS
@ MHD_EVENT_LOOP_INFO_READ
@ MHD_EVENT_LOOP_INFO_WRITE
@ MHD_EVENT_LOOP_INFO_CLEANUP
struct MHD_IoVec MHD_iovec_
#define MHD_IS_HTTP_VER_SUPPORTED(ver)
_MHD_static_inline struct MHD_Daemon * MHD_get_master(struct MHD_Daemon *const daemon)
@ MHD_RAF_HAS_CONTENT_LENGTH
@ MHD_RAF_HAS_CONNECTION_CLOSE
@ MHD_RAF_HAS_TRANS_ENC_CHUNKED
@ MHD_RAF_HAS_CONNECTION_HDR
#define MHD_IS_HTTP_VER_1_1_COMPAT(ver)
@ MHD_HTTP_MTHD_NO_METHOD
#define MHD_D_IS_USING_THREAD_PER_CONN_(d)
#define MHD_D_IS_USING_THREADS_(d)
#define MHD_D_IS_USING_EPOLL_(d)
bool MHD_pool_is_resizable_inplace(struct MemoryPool *pool, void *block, size_t block_size)
void MHD_pool_deallocate(struct MemoryPool *pool, void *block, size_t block_size)
void * MHD_pool_try_alloc(struct MemoryPool *pool, size_t size, size_t *required_bytes)
memory pool; mostly used for efficient (de)allocation for each connection and bounding memory use for...
Header for platform missing functions.
Header for platform-independent inter-thread communication.
limits values definitions
Header for platform-independent locks abstraction.
uint64_t MHD_monotonic_msec_counter(void)
internal monotonic clock functions implementations
#define MHD_SEND_SPIPE_SUPPRESS_NEEDED
size_t MHD_uint8_to_str_pad(uint8_t val, uint8_t min_digits, char *buf, size_t buf_size)
size_t MHD_uint16_to_str(uint16_t val, char *buf, size_t buf_size)
size_t MHD_uint64_to_str(uint64_t val, char *buf, size_t buf_size)
bool MHD_str_equal_caseless_bin_n_(const char *const str1, const char *const str2, size_t len)
size_t MHD_uint32_to_strx(uint32_t val, char *buf, size_t buf_size)
Header for string manipulating helpers.
#define MHD_thread_handle_ID_is_current_thread_(hndl_id)
bool MHD_add_response_entry_no_alloc_(struct MHD_Response *response, enum MHD_ValueKind kind, char *header, size_t header_len, char *content, size_t content_len)
void MHD_increment_response_rc(struct MHD_Response *response)
#define MHD_CONTENT_READER_END_OF_STREAM
_MHD_EXTERN size_t MHD_get_reason_phrase_len_for(unsigned int code)
#define MHD_INVALID_SOCKET
_MHD_EXTERN const char * MHD_get_reason_phrase_for(unsigned int code)
#define MHD_CONTENT_READER_END_WITH_ERROR
@ MHD_USE_SUPPRESS_DATE_NO_CLOCK
@ MHD_RF_SEND_KEEP_ALIVE_HEADER
@ MHD_RF_HEAD_ONLY_RESPONSE
@ MHD_RF_HTTP_1_0_COMPATIBLE_STRICT
@ MHD_RF_INSANITY_HEADER_CONTENT_LENGTH
@ MHD_CONNECTION_OPTION_TIMEOUT
Methods for managing response objects.
enum MHD_Result MHD_response_execute_upgrade_(struct MHD_Response *response, struct MHD_Connection *connection)
size_t write_buffer_send_offset
enum MHD_ConnectionEventLoopInfo event_loop_info
size_t write_buffer_append_offset
enum MHD_ConnKeepAlive keepalive
union MHD_ConnectionInfo connection_info_dummy
size_t continue_message_write_offset
struct sockaddr_storage addr
size_t read_buffer_offset
enum MHD_CONNECTION_STATE state
struct MHD_Daemon * daemon
uint64_t connection_timeout_ms
MHD_AccessHandlerCallback default_handler
LogCallback uri_log_callback
void * unescape_callback_cls
MHD_mutex_ cleanup_connection_mutex
struct MHD_Connection * connections_head
MHD_RequestCompletedCallback notify_completed
uint64_t connection_timeout_ms
struct MHD_Connection * manual_timeout_tail
UnescapeCallback unescape_callback
void * notify_completed_cls
struct MHD_Connection * cleanup_tail
struct MHD_Daemon * worker_pool
struct MHD_Connection * manual_timeout_head
void * default_handler_cls
struct MHD_Connection * suspended_connections_tail
struct MHD_Connection * cleanup_head
struct MHD_Connection * normal_timeout_head
struct MHD_Connection * normal_timeout_tail
void * uri_log_callback_cls
struct MHD_Connection * suspended_connections_head
struct MHD_Connection * connections_tail
bool use_reply_body_headers
uint64_t rsp_write_position
struct MHD_iovec_track_ resp_iov
struct MHD_Response * response
unsigned int responseCode
struct MHD_Reply_Properties props
unsigned int skipped_empty_lines
union MHD_HeadersProcessing hdrs
uint64_t current_chunk_size
uint64_t current_chunk_offset
struct MHD_HTTP_Header * headers_received
struct MHD_HTTP_Header * headers_received_tail
bool some_payload_processed
size_t skipped_broken_lines
size_t num_cr_sp_replaced
enum MHD_HTTP_Version http_ver
union MHD_StartOrSize field_lines
enum MHD_HTTP_Method http_mthd
uint64_t remaining_upload_size
enum MHD_HTTP_StatusCode status_code
MHD_ContentReaderCallback crc
enum MHD_ResponseAutoFlags flags_auto
enum MHD_ResponseFlags flags
struct MHD_HTTP_Header * first_header
unsigned int connection_timeout
struct MHD_Daemon * daemon
struct sockaddr * client_addr