aboutsummaryrefslogtreecommitdiff
path: root/src/microhttpd/connection.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/microhttpd/connection.c')
-rw-r--r--src/microhttpd/connection.c4273
1 files changed, 2156 insertions, 2117 deletions
diff --git a/src/microhttpd/connection.c b/src/microhttpd/connection.c
index ab760e4a..77fcd849 100644
--- a/src/microhttpd/connection.c
+++ b/src/microhttpd/connection.c
@@ -68,7 +68,8 @@
68 * minimal. 68 * minimal.
69 */ 69 */
70#ifdef HAVE_MESSAGES 70#ifdef HAVE_MESSAGES
71#define REQUEST_TOO_BIG "<html><head><title>Request too big</title></head><body>Your HTTP header was too big for the memory constraints of this webserver.</body></html>" 71#define REQUEST_TOO_BIG \
72 "<html><head><title>Request too big</title></head><body>Your HTTP header was too big for the memory constraints of this webserver.</body></html>"
72#else 73#else
73#define REQUEST_TOO_BIG "" 74#define REQUEST_TOO_BIG ""
74#endif 75#endif
@@ -81,7 +82,8 @@
81 * minimal. 82 * minimal.
82 */ 83 */
83#ifdef HAVE_MESSAGES 84#ifdef HAVE_MESSAGES
84#define REQUEST_LACKS_HOST "<html><head><title>&quot;Host:&quot; header required</title></head><body>In HTTP 1.1, requests must include a &quot;Host:&quot; header, and your HTTP 1.1 request lacked such a header.</body></html>" 85#define REQUEST_LACKS_HOST \
86 "<html><head><title>&quot;Host:&quot; header required</title></head><body>In HTTP 1.1, requests must include a &quot;Host:&quot; header, and your HTTP 1.1 request lacked such a header.</body></html>"
85#else 87#else
86#define REQUEST_LACKS_HOST "" 88#define REQUEST_LACKS_HOST ""
87#endif 89#endif
@@ -94,7 +96,8 @@
94 * minimal. 96 * minimal.
95 */ 97 */
96#ifdef HAVE_MESSAGES 98#ifdef HAVE_MESSAGES
97#define REQUEST_MALFORMED "<html><head><title>Request malformed</title></head><body>Your HTTP request was syntactically incorrect.</body></html>" 99#define REQUEST_MALFORMED \
100 "<html><head><title>Request malformed</title></head><body>Your HTTP request was syntactically incorrect.</body></html>"
98#else 101#else
99#define REQUEST_MALFORMED "" 102#define REQUEST_MALFORMED ""
100#endif 103#endif
@@ -106,7 +109,8 @@
106 * minimal. 109 * minimal.
107 */ 110 */
108#ifdef HAVE_MESSAGES 111#ifdef HAVE_MESSAGES
109#define INTERNAL_ERROR "<html><head><title>Internal server error</title></head><body>Please ask the developer of this Web server to carefully read the GNU libmicrohttpd documentation about connection management and blocking.</body></html>" 112#define INTERNAL_ERROR \
113 "<html><head><title>Internal server error</title></head><body>Please ask the developer of this Web server to carefully read the GNU libmicrohttpd documentation about connection management and blocking.</body></html>"
110#else 114#else
111#define INTERNAL_ERROR "" 115#define INTERNAL_ERROR ""
112#endif 116#endif
@@ -157,17 +161,18 @@ MHD_conn_init_static_ (void)
157#ifdef SF_FLAGS 161#ifdef SF_FLAGS
158 long sys_page_size = sysconf (_SC_PAGESIZE); 162 long sys_page_size = sysconf (_SC_PAGESIZE);
159 if (0 > sys_page_size) 163 if (0 > sys_page_size)
160 { /* Failed to get page size. */ 164 { /* Failed to get page size. */
161 freebsd_sendfile_flags_ = SF_NODISKIO; 165 freebsd_sendfile_flags_ = SF_NODISKIO;
162 freebsd_sendfile_flags_thd_p_c_ = SF_NODISKIO; 166 freebsd_sendfile_flags_thd_p_c_ = SF_NODISKIO;
163 } 167 }
164 else 168 else
165 { 169 {
166 freebsd_sendfile_flags_ = 170 freebsd_sendfile_flags_ =
167 SF_FLAGS((uint16_t)(MHD_SENFILE_CHUNK_ / sys_page_size), SF_NODISKIO); 171 SF_FLAGS ((uint16_t) (MHD_SENFILE_CHUNK_ / sys_page_size), SF_NODISKIO);
168 freebsd_sendfile_flags_thd_p_c_ = 172 freebsd_sendfile_flags_thd_p_c_ =
169 SF_FLAGS((uint16_t)(MHD_SENFILE_CHUNK_THR_P_C_ / sys_page_size), SF_NODISKIO); 173 SF_FLAGS ((uint16_t) (MHD_SENFILE_CHUNK_THR_P_C_ / sys_page_size),
170 } 174 SF_NODISKIO);
175 }
171#endif /* SF_FLAGS */ 176#endif /* SF_FLAGS */
172} 177}
173#endif /* HAVE_FREEBSD_SENDFILE */ 178#endif /* HAVE_FREEBSD_SENDFILE */
@@ -189,9 +194,9 @@ recv_param_adapter (struct MHD_Connection *connection,
189 194
190 if ( (MHD_INVALID_SOCKET == connection->socket_fd) || 195 if ( (MHD_INVALID_SOCKET == connection->socket_fd) ||
191 (MHD_CONNECTION_CLOSED == connection->state) ) 196 (MHD_CONNECTION_CLOSED == connection->state) )
192 { 197 {
193 return MHD_ERR_NOTCONN_; 198 return MHD_ERR_NOTCONN_;
194 } 199 }
195 if (i > MHD_SCKT_SEND_MAX_SIZE_) 200 if (i > MHD_SCKT_SEND_MAX_SIZE_)
196 i = MHD_SCKT_SEND_MAX_SIZE_; /* return value limit */ 201 i = MHD_SCKT_SEND_MAX_SIZE_; /* return value limit */
197 202
@@ -199,25 +204,25 @@ recv_param_adapter (struct MHD_Connection *connection,
199 other, 204 other,
200 i); 205 i);
201 if (0 > ret) 206 if (0 > ret)
207 {
208 const int err = MHD_socket_get_error_ ();
209 if (MHD_SCKT_ERR_IS_EAGAIN_ (err))
202 { 210 {
203 const int err = MHD_socket_get_error_ ();
204 if (MHD_SCKT_ERR_IS_EAGAIN_ (err))
205 {
206#ifdef EPOLL_SUPPORT 211#ifdef EPOLL_SUPPORT
207 /* Got EAGAIN --- no longer read-ready */ 212 /* Got EAGAIN --- no longer read-ready */
208 connection->epoll_state &= ~MHD_EPOLL_STATE_READ_READY; 213 connection->epoll_state &= ~MHD_EPOLL_STATE_READ_READY;
209#endif /* EPOLL_SUPPORT */ 214#endif /* EPOLL_SUPPORT */
210 return MHD_ERR_AGAIN_; 215 return MHD_ERR_AGAIN_;
211 }
212 if (MHD_SCKT_ERR_IS_EINTR_ (err))
213 return MHD_ERR_AGAIN_;
214 if (MHD_SCKT_ERR_IS_ (err, MHD_SCKT_ECONNRESET_))
215 return MHD_ERR_CONNRESET_;
216 /* Treat any other error as hard error. */
217 return MHD_ERR_NOTCONN_;
218 } 216 }
217 if (MHD_SCKT_ERR_IS_EINTR_ (err))
218 return MHD_ERR_AGAIN_;
219 if (MHD_SCKT_ERR_IS_ (err, MHD_SCKT_ECONNRESET_))
220 return MHD_ERR_CONNRESET_;
221 /* Treat any other error as hard error. */
222 return MHD_ERR_NOTCONN_;
223 }
219#ifdef EPOLL_SUPPORT 224#ifdef EPOLL_SUPPORT
220 else if (i > (size_t)ret) 225 else if (i > (size_t) ret)
221 connection->epoll_state &= ~MHD_EPOLL_STATE_READ_READY; 226 connection->epoll_state &= ~MHD_EPOLL_STATE_READ_READY;
222#endif /* EPOLL_SUPPORT */ 227#endif /* EPOLL_SUPPORT */
223 return ret; 228 return ret;
@@ -242,9 +247,9 @@ send_param_adapter (struct MHD_Connection *connection,
242 247
243 if ( (MHD_INVALID_SOCKET == connection->socket_fd) || 248 if ( (MHD_INVALID_SOCKET == connection->socket_fd) ||
244 (MHD_CONNECTION_CLOSED == connection->state) ) 249 (MHD_CONNECTION_CLOSED == connection->state) )
245 { 250 {
246 return MHD_ERR_NOTCONN_; 251 return MHD_ERR_NOTCONN_;
247 } 252 }
248 if (i > MHD_SCKT_SEND_MAX_SIZE_) 253 if (i > MHD_SCKT_SEND_MAX_SIZE_)
249 i = MHD_SCKT_SEND_MAX_SIZE_; /* return value limit */ 254 i = MHD_SCKT_SEND_MAX_SIZE_; /* return value limit */
250 255
@@ -252,26 +257,26 @@ send_param_adapter (struct MHD_Connection *connection,
252 other, 257 other,
253 i); 258 i);
254 if (0 > ret) 259 if (0 > ret)
255 { 260 {
256 const int err = MHD_socket_get_error_(); 261 const int err = MHD_socket_get_error_ ();
257 262
258 if (MHD_SCKT_ERR_IS_EAGAIN_(err)) 263 if (MHD_SCKT_ERR_IS_EAGAIN_ (err))
259 { 264 {
260#ifdef EPOLL_SUPPORT 265#ifdef EPOLL_SUPPORT
261 /* EAGAIN --- no longer write-ready */ 266 /* EAGAIN --- no longer write-ready */
262 connection->epoll_state &= ~MHD_EPOLL_STATE_WRITE_READY; 267 connection->epoll_state &= ~MHD_EPOLL_STATE_WRITE_READY;
263#endif /* EPOLL_SUPPORT */ 268#endif /* EPOLL_SUPPORT */
264 return MHD_ERR_AGAIN_; 269 return MHD_ERR_AGAIN_;
265 }
266 if (MHD_SCKT_ERR_IS_EINTR_ (err))
267 return MHD_ERR_AGAIN_;
268 if (MHD_SCKT_ERR_IS_ (err, MHD_SCKT_ECONNRESET_))
269 return MHD_ERR_CONNRESET_;
270 /* Treat any other error as hard error. */
271 return MHD_ERR_NOTCONN_;
272 } 270 }
271 if (MHD_SCKT_ERR_IS_EINTR_ (err))
272 return MHD_ERR_AGAIN_;
273 if (MHD_SCKT_ERR_IS_ (err, MHD_SCKT_ECONNRESET_))
274 return MHD_ERR_CONNRESET_;
275 /* Treat any other error as hard error. */
276 return MHD_ERR_NOTCONN_;
277 }
273#ifdef EPOLL_SUPPORT 278#ifdef EPOLL_SUPPORT
274 else if (i > (size_t)ret) 279 else if (i > (size_t) ret)
275 connection->epoll_state &= ~MHD_EPOLL_STATE_WRITE_READY; 280 connection->epoll_state &= ~MHD_EPOLL_STATE_WRITE_READY;
276#endif /* EPOLL_SUPPORT */ 281#endif /* EPOLL_SUPPORT */
277 return ret; 282 return ret;
@@ -298,9 +303,9 @@ send_param_adapter (struct MHD_Connection *connection,
298 * @return true if force push is possible, false otherwise 303 * @return true if force push is possible, false otherwise
299 */ 304 */
300_MHD_static_inline bool 305_MHD_static_inline bool
301socket_flush_possible(struct MHD_Connection *connection) 306socket_flush_possible (struct MHD_Connection *connection)
302{ 307{
303 (void)connection; /* Mute compiler warning. */ 308 (void) connection; /* Mute compiler warning. */
304#if defined(TCP_CORK) || defined(TCP_PUSH) 309#if defined(TCP_CORK) || defined(TCP_PUSH)
305 return true; 310 return true;
306#else /* !TCP_CORK && !TCP_PUSH */ 311#else /* !TCP_CORK && !TCP_PUSH */
@@ -310,20 +315,6 @@ socket_flush_possible(struct MHD_Connection *connection)
310 315
311 316
312/** 317/**
313 * Activate extra buffering mode on connection socket to prevent
314 * sending of partial packets.
315 *
316 * @param connection connection to be processed
317 * @return true on success, false otherwise
318 */
319_MHD_static_inline bool
320socket_start_extra_buffering (struct MHD_Connection *connection)
321{
322 mhd_assert(NULL != connection);
323}
324
325
326/**
327 * Activate no buffering mode (no delay sending) on connection socket 318 * Activate no buffering mode (no delay sending) on connection socket
328 * and push to client data pending in socket buffer. 319 * and push to client data pending in socket buffer.
329 * 320 *
@@ -333,20 +324,20 @@ socket_start_extra_buffering (struct MHD_Connection *connection)
333_MHD_static_inline bool 324_MHD_static_inline bool
334socket_start_no_buffering_flush (struct MHD_Connection *connection) 325socket_start_no_buffering_flush (struct MHD_Connection *connection)
335{ 326{
336 bool res; 327 bool res = false;
337#if defined(TCP_NOPUSH) && !defined(TCP_CORK) 328#if defined(TCP_NOPUSH) && ! defined(TCP_CORK)
338 const int dummy = 0; 329 const int dummy = 0;
339#endif /* !TCP_CORK */ 330#endif /* !TCP_CORK */
340 331
341#if defined(__FreeBSD__) && __FreeBSD__+0 >= 9 332#if defined(__FreeBSD__) && __FreeBSD__ + 0 >= 9
342 /* FreeBSD do not need zero-send for flushing starting from version 9 */ 333 /* FreeBSD do not need zero-send for flushing starting from version 9 */
343#elif defined(TCP_NOPUSH) && !defined(TCP_CORK) 334#elif defined(TCP_NOPUSH) && ! defined(TCP_CORK)
344 /* Force flush data with zero send otherwise Darwin and some BSD systems 335 /* Force flush data with zero send otherwise Darwin and some BSD systems
345 will add 5 seconds delay. Not required with TCP_CORK as switching off 336 will add 5 seconds delay. Not required with TCP_CORK as switching off
346 TCP_CORK always flushes socket buffer. */ 337 TCP_CORK always flushes socket buffer. */
347 res = (0 <= MHD_send_ (connection->socket_fd, 338 res = (0 <= MHD_send_ (connection->socket_fd,
348 &dummy, 339 &dummy,
349 0)) && res; 340 0)) && res;
350#endif /* TCP_NOPUSH && !TCP_CORK*/ 341#endif /* TCP_NOPUSH && !TCP_CORK*/
351 return res; 342 return res;
352} 343}
@@ -378,15 +369,15 @@ MHD_get_connection_values (struct MHD_Connection *connection,
378 ret = 0; 369 ret = 0;
379 for (pos = connection->headers_received; NULL != pos; pos = pos->next) 370 for (pos = connection->headers_received; NULL != pos; pos = pos->next)
380 if (0 != (pos->kind & kind)) 371 if (0 != (pos->kind & kind))
381 { 372 {
382 ret++; 373 ret++;
383 if ( (NULL != iterator) && 374 if ( (NULL != iterator) &&
384 (MHD_YES != iterator (iterator_cls, 375 (MHD_YES != iterator (iterator_cls,
385 pos->kind, 376 pos->kind,
386 pos->header, 377 pos->header,
387 pos->value)) ) 378 pos->value)) )
388 return ret; 379 return ret;
389 } 380 }
390 return ret; 381 return ret;
391} 382}
392 383
@@ -418,23 +409,23 @@ MHD_get_connection_values_n (struct MHD_Connection *connection,
418 409
419 if (NULL == iterator) 410 if (NULL == iterator)
420 for (pos = connection->headers_received; NULL != pos; pos = pos->next) 411 for (pos = connection->headers_received; NULL != pos; pos = pos->next)
421 { 412 {
422 if (kind == pos->kind) 413 if (kind == pos->kind)
423 ret++; 414 ret++;
424 } 415 }
425 else 416 else
426 for (pos = connection->headers_received; NULL != pos; pos = pos->next) 417 for (pos = connection->headers_received; NULL != pos; pos = pos->next)
427 if (kind == pos->kind) 418 if (kind == pos->kind)
428 { 419 {
429 ret++; 420 ret++;
430 if (MHD_NO == iterator (iterator_cls, 421 if (MHD_NO == iterator (iterator_cls,
431 pos->kind, 422 pos->kind,
432 pos->header, 423 pos->header,
433 pos->header_size, 424 pos->header_size,
434 pos->value, 425 pos->value,
435 pos->value_size)) 426 pos->value_size))
436 return ret; 427 return ret;
437 } 428 }
438 return ret; 429 return ret;
439} 430}
440 431
@@ -479,15 +470,15 @@ MHD_set_connection_value_n_nocheck_ (struct MHD_Connection *connection,
479 pos->next = NULL; 470 pos->next = NULL;
480 /* append 'pos' to the linked list of headers */ 471 /* append 'pos' to the linked list of headers */
481 if (NULL == connection->headers_received_tail) 472 if (NULL == connection->headers_received_tail)
482 { 473 {
483 connection->headers_received = pos; 474 connection->headers_received = pos;
484 connection->headers_received_tail = pos; 475 connection->headers_received_tail = pos;
485 } 476 }
486 else 477 else
487 { 478 {
488 connection->headers_received_tail->next = pos; 479 connection->headers_received_tail->next = pos;
489 connection->headers_received_tail = pos; 480 connection->headers_received_tail = pos;
490 } 481 }
491 return MHD_YES; 482 return MHD_YES;
492} 483}
493 484
@@ -526,8 +517,8 @@ MHD_set_connection_value_n (struct MHD_Connection *connection,
526 size_t value_size) 517 size_t value_size)
527{ 518{
528 if ( (MHD_GET_ARGUMENT_KIND != kind) && 519 if ( (MHD_GET_ARGUMENT_KIND != kind) &&
529 ( ((key ? strlen(key) : 0) != key_size) || 520 ( ((key ? strlen (key) : 0) != key_size) ||
530 ((value ? strlen(value) : 0) != value_size) ) ) 521 ((value ? strlen (value) : 0) != value_size) ) )
531 return MHD_NO; /* binary zero is allowed only in GET arguments */ 522 return MHD_NO; /* binary zero is allowed only in GET arguments */
532 523
533 return MHD_set_connection_value_n_nocheck_ (connection, 524 return MHD_set_connection_value_n_nocheck_ (connection,
@@ -604,7 +595,7 @@ MHD_lookup_connection_value (struct MHD_Connection *connection,
604 (void) MHD_lookup_connection_value_n (connection, 595 (void) MHD_lookup_connection_value_n (connection,
605 kind, 596 kind,
606 key, 597 key,
607 (NULL == key) ? 0 : strlen(key), 598 (NULL == key) ? 0 : strlen (key),
608 &value, 599 &value,
609 NULL); 600 NULL);
610 return value; 601 return value;
@@ -644,27 +635,27 @@ MHD_lookup_connection_value_n (struct MHD_Connection *connection,
644 return MHD_NO; 635 return MHD_NO;
645 636
646 if (NULL == key) 637 if (NULL == key)
638 {
639 for (pos = connection->headers_received; NULL != pos; pos = pos->next)
647 { 640 {
648 for (pos = connection->headers_received; NULL != pos; pos = pos->next) 641 if ( (0 != (kind & pos->kind)) &&
649 { 642 (NULL == pos->header) )
650 if ( (0 != (kind & pos->kind)) && 643 break;
651 (NULL == pos->header) )
652 break;
653 }
654 } 644 }
645 }
655 else 646 else
647 {
648 for (pos = connection->headers_received; NULL != pos; pos = pos->next)
656 { 649 {
657 for (pos = connection->headers_received; NULL != pos; pos = pos->next) 650 if ( (0 != (kind & pos->kind)) &&
658 { 651 (key_size == pos->header_size) &&
659 if ( (0 != (kind & pos->kind)) && 652 ( (key == pos->header) ||
660 (key_size == pos->header_size) && 653 (MHD_str_equal_caseless_bin_n_ (key,
661 ( (key == pos->header) || 654 pos->header,
662 (MHD_str_equal_caseless_bin_n_ (key, 655 key_size) ) ) )
663 pos->header, 656 break;
664 key_size) ) ) )
665 break;
666 }
667 } 657 }
658 }
668 659
669 if (NULL == pos) 660 if (NULL == pos)
670 return MHD_NO; 661 return MHD_NO;
@@ -696,27 +687,30 @@ MHD_lookup_connection_value_n (struct MHD_Connection *connection,
696 */ 687 */
697static bool 688static bool
698MHD_lookup_header_token_ci (const struct MHD_Connection *connection, 689MHD_lookup_header_token_ci (const struct MHD_Connection *connection,
699 const char *header, 690 const char *header,
700 size_t header_len, 691 size_t header_len,
701 const char *token, 692 const char *token,
702 size_t token_len) 693 size_t token_len)
703{ 694{
704 struct MHD_HTTP_Header *pos; 695 struct MHD_HTTP_Header *pos;
705 696
706 if (NULL == connection || NULL == header || 0 == header[0] || NULL == token || 0 == token[0]) 697 if ((NULL == connection)||(NULL == header)||(0 == header[0])||(NULL ==
698 token) ||(0 ==
699 token
700 [0]) )
707 return false; 701 return false;
708 702
709 for (pos = connection->headers_received; NULL != pos; pos = pos->next) 703 for (pos = connection->headers_received; NULL != pos; pos = pos->next)
710 { 704 {
711 if ((0 != (pos->kind & MHD_HEADER_KIND)) && 705 if ((0 != (pos->kind & MHD_HEADER_KIND)) &&
712 (header_len == pos->header_size) && 706 (header_len == pos->header_size) &&
713 ( (header == pos->header) || 707 ( (header == pos->header) ||
714 (MHD_str_equal_caseless_bin_n_(header, 708 (MHD_str_equal_caseless_bin_n_ (header,
715 pos->header, 709 pos->header,
716 header_len)) ) && 710 header_len)) ) &&
717 (MHD_str_has_token_caseless_ (pos->value, token, token_len))) 711 (MHD_str_has_token_caseless_ (pos->value, token, token_len)))
718 return true; 712 return true;
719 } 713 }
720 return false; 714 return false;
721} 715}
722 716
@@ -733,8 +727,8 @@ MHD_lookup_header_token_ci (const struct MHD_Connection *connection,
733 * false otherwise 727 * false otherwise
734 */ 728 */
735#define MHD_lookup_header_s_token_ci(c,h,tkn) \ 729#define MHD_lookup_header_s_token_ci(c,h,tkn) \
736 MHD_lookup_header_token_ci((c),(h),MHD_STATICSTR_LEN_(h),\ 730 MHD_lookup_header_token_ci ((c),(h),MHD_STATICSTR_LEN_ (h), \
737 (tkn),MHD_STATICSTR_LEN_(tkn)) 731 (tkn),MHD_STATICSTR_LEN_ (tkn))
738 732
739 733
740/** 734/**
@@ -750,19 +744,20 @@ need_100_continue (struct MHD_Connection *connection)
750 const char *expect; 744 const char *expect;
751 745
752 return ( (NULL == connection->response) && 746 return ( (NULL == connection->response) &&
753 (NULL != connection->version) && 747 (NULL != connection->version) &&
754 (MHD_str_equal_caseless_(connection->version, 748 (MHD_str_equal_caseless_ (connection->version,
755 MHD_HTTP_VERSION_1_1)) && 749 MHD_HTTP_VERSION_1_1)) &&
756 (MHD_NO != MHD_lookup_connection_value_n (connection, 750 (MHD_NO != MHD_lookup_connection_value_n (connection,
757 MHD_HEADER_KIND, 751 MHD_HEADER_KIND,
758 MHD_HTTP_HEADER_EXPECT, 752 MHD_HTTP_HEADER_EXPECT,
759 MHD_STATICSTR_LEN_(MHD_HTTP_HEADER_EXPECT), 753 MHD_STATICSTR_LEN_ (
754 MHD_HTTP_HEADER_EXPECT),
760 &expect, 755 &expect,
761 NULL)) && 756 NULL)) &&
762 (MHD_str_equal_caseless_(expect, 757 (MHD_str_equal_caseless_ (expect,
763 "100-continue")) && 758 "100-continue")) &&
764 (connection->continue_message_write_offset < 759 (connection->continue_message_write_offset <
765 MHD_STATICSTR_LEN_ (HTTP_100_CONTINUE)) ); 760 MHD_STATICSTR_LEN_ (HTTP_100_CONTINUE)) );
766} 761}
767 762
768 763
@@ -780,24 +775,24 @@ MHD_connection_mark_closed_ (struct MHD_Connection *connection)
780 connection->state = MHD_CONNECTION_CLOSED; 775 connection->state = MHD_CONNECTION_CLOSED;
781 connection->event_loop_info = MHD_EVENT_LOOP_INFO_CLEANUP; 776 connection->event_loop_info = MHD_EVENT_LOOP_INFO_CLEANUP;
782 if (0 == (daemon->options & MHD_USE_TURBO)) 777 if (0 == (daemon->options & MHD_USE_TURBO))
783 { 778 {
784#ifdef HTTPS_SUPPORT 779#ifdef HTTPS_SUPPORT
785 /* For TLS connection use shutdown of TLS layer 780 /* For TLS connection use shutdown of TLS layer
786 * and do not shutdown TCP socket. This give more 781 * and do not shutdown TCP socket. This give more
787 * chances to send TLS closure data to remote side. 782 * chances to send TLS closure data to remote side.
788 * Closure of TLS layer will be interpreted by 783 * Closure of TLS layer will be interpreted by
789 * remote side as end of transmission. */ 784 * remote side as end of transmission. */
790 if (0 != (daemon->options & MHD_USE_TLS)) 785 if (0 != (daemon->options & MHD_USE_TLS))
791 { 786 {
792 if (! MHD_tls_connection_shutdown(connection)) 787 if (! MHD_tls_connection_shutdown (connection))
793 shutdown (connection->socket_fd, 788 shutdown (connection->socket_fd,
794 SHUT_WR); 789 SHUT_WR);
795 }
796 else /* Combined with next 'shutdown()'. */
797#endif /* HTTPS_SUPPORT */
798 shutdown (connection->socket_fd,
799 SHUT_WR);
800 } 790 }
791 else /* Combined with next 'shutdown()'. */
792#endif /* HTTPS_SUPPORT */
793 shutdown (connection->socket_fd,
794 SHUT_WR);
795 }
801} 796}
802 797
803 798
@@ -819,16 +814,16 @@ MHD_connection_close_ (struct MHD_Connection *connection,
819 814
820 MHD_connection_mark_closed_ (connection); 815 MHD_connection_mark_closed_ (connection);
821 if (NULL != resp) 816 if (NULL != resp)
822 { 817 {
823 connection->response = NULL; 818 connection->response = NULL;
824 MHD_destroy_response (resp); 819 MHD_destroy_response (resp);
825 } 820 }
826 if ( (NULL != daemon->notify_completed) && 821 if ( (NULL != daemon->notify_completed) &&
827 (connection->client_aware) ) 822 (connection->client_aware) )
828 daemon->notify_completed (daemon->notify_completed_cls, 823 daemon->notify_completed (daemon->notify_completed_cls,
829 connection, 824 connection,
830 &connection->client_context, 825 &connection->client_context,
831 termination_code); 826 termination_code);
832 connection->client_aware = false; 827 connection->client_aware = false;
833} 828}
834 829
@@ -863,33 +858,33 @@ MHD_connection_finish_forward_ (struct MHD_Connection *connection)
863 EPOLL_CTL_DEL, 858 EPOLL_CTL_DEL,
864 connection->socket_fd, 859 connection->socket_fd,
865 NULL)) ) 860 NULL)) )
866 { 861 {
867 MHD_PANIC (_("Failed to remove FD from epoll set\n")); 862 MHD_PANIC (_ ("Failed to remove FD from epoll set\n"));
868 } 863 }
869 if (urh->in_eready_list) 864 if (urh->in_eready_list)
870 { 865 {
871 EDLL_remove (daemon->eready_urh_head, 866 EDLL_remove (daemon->eready_urh_head,
872 daemon->eready_urh_tail, 867 daemon->eready_urh_tail,
873 urh); 868 urh);
874 urh->in_eready_list = false; 869 urh->in_eready_list = false;
875 } 870 }
876#endif /* EPOLL_SUPPORT */ 871#endif /* EPOLL_SUPPORT */
877 if (MHD_INVALID_SOCKET != urh->mhd.socket) 872 if (MHD_INVALID_SOCKET != urh->mhd.socket)
878 { 873 {
879#if EPOLL_SUPPORT 874#if EPOLL_SUPPORT
880 if ( (0 != (daemon->options & MHD_USE_EPOLL)) && 875 if ( (0 != (daemon->options & MHD_USE_EPOLL)) &&
881 (0 != epoll_ctl (daemon->epoll_upgrade_fd, 876 (0 != epoll_ctl (daemon->epoll_upgrade_fd,
882 EPOLL_CTL_DEL, 877 EPOLL_CTL_DEL,
883 urh->mhd.socket, 878 urh->mhd.socket,
884 NULL)) ) 879 NULL)) )
885 { 880 {
886 MHD_PANIC (_("Failed to remove FD from epoll set\n")); 881 MHD_PANIC (_ ("Failed to remove FD from epoll set\n"));
887 }
888#endif /* EPOLL_SUPPORT */
889 /* Reflect remote disconnect to application by breaking
890 * socketpair connection. */
891 shutdown (urh->mhd.socket, SHUT_RDWR);
892 } 882 }
883#endif /* EPOLL_SUPPORT */
884 /* Reflect remote disconnect to application by breaking
885 * socketpair connection. */
886 shutdown (urh->mhd.socket, SHUT_RDWR);
887 }
893 /* Socketpair sockets will remain open as they will be 888 /* Socketpair sockets will remain open as they will be
894 * used with MHD_UPGRADE_ACTION_CLOSE. They will be 889 * used with MHD_UPGRADE_ACTION_CLOSE. They will be
895 * closed by MHD_cleanup_upgraded_connection_() during 890 * closed by MHD_cleanup_upgraded_connection_() during
@@ -908,14 +903,14 @@ MHD_connection_finish_forward_ (struct MHD_Connection *connection)
908 */ 903 */
909static void 904static void
910connection_close_error (struct MHD_Connection *connection, 905connection_close_error (struct MHD_Connection *connection,
911 const char *emsg) 906 const char *emsg)
912{ 907{
913#ifdef HAVE_MESSAGES 908#ifdef HAVE_MESSAGES
914 if (NULL != emsg) 909 if (NULL != emsg)
915 MHD_DLOG (connection->daemon, 910 MHD_DLOG (connection->daemon,
916 emsg); 911 emsg);
917#else /* ! HAVE_MESSAGES */ 912#else /* ! HAVE_MESSAGES */
918 (void)emsg; /* Mute compiler warning. */ 913 (void) emsg; /* Mute compiler warning. */
919#endif /* ! HAVE_MESSAGES */ 914#endif /* ! HAVE_MESSAGES */
920 MHD_connection_close_ (connection, 915 MHD_connection_close_ (connection,
921 MHD_REQUEST_TERMINATED_WITH_ERROR); 916 MHD_REQUEST_TERMINATED_WITH_ERROR);
@@ -958,50 +953,51 @@ try_ready_normal_body (struct MHD_Connection *connection)
958 (connection->response_write_position == response->total_size) ) 953 (connection->response_write_position == response->total_size) )
959 return MHD_YES; /* 0-byte response is always ready */ 954 return MHD_YES; /* 0-byte response is always ready */
960 if ( (response->data_start <= 955 if ( (response->data_start <=
961 connection->response_write_position) && 956 connection->response_write_position) &&
962 (response->data_size + response->data_start > 957 (response->data_size + response->data_start >
963 connection->response_write_position) ) 958 connection->response_write_position) )
964 return MHD_YES; /* response already ready */ 959 return MHD_YES; /* response already ready */
965#if defined(_MHD_HAVE_SENDFILE) 960#if defined(_MHD_HAVE_SENDFILE)
966 if (MHD_resp_sender_sendfile == connection->resp_sender) 961 if (MHD_resp_sender_sendfile == connection->resp_sender)
967 { 962 {
968 /* will use sendfile, no need to bother response crc */ 963 /* will use sendfile, no need to bother response crc */
969 return MHD_YES; 964 return MHD_YES;
970 } 965 }
971#endif /* _MHD_HAVE_SENDFILE */ 966#endif /* _MHD_HAVE_SENDFILE */
972 967
973 ret = response->crc (response->crc_cls, 968 ret = response->crc (response->crc_cls,
974 connection->response_write_position, 969 connection->response_write_position,
975 response->data, 970 response->data,
976 (size_t) MHD_MIN ((uint64_t)response->data_buffer_size, 971 (size_t) MHD_MIN ((uint64_t) response->data_buffer_size,
977 response->total_size - 972 response->total_size
978 connection->response_write_position)); 973 - connection->response_write_position));
979 if ( (((ssize_t) MHD_CONTENT_READER_END_OF_STREAM) == ret) || 974 if ( (((ssize_t) MHD_CONTENT_READER_END_OF_STREAM) == ret) ||
980 (((ssize_t) MHD_CONTENT_READER_END_WITH_ERROR) == ret) ) 975 (((ssize_t) MHD_CONTENT_READER_END_WITH_ERROR) == ret) )
981 { 976 {
982 /* either error or http 1.0 transfer, close socket! */ 977 /* either error or http 1.0 transfer, close socket! */
983 response->total_size = connection->response_write_position; 978 response->total_size = connection->response_write_position;
984#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 979#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
985 MHD_mutex_unlock_chk_ (&response->mutex); 980 MHD_mutex_unlock_chk_ (&response->mutex);
986#endif 981#endif
987 if ( ((ssize_t)MHD_CONTENT_READER_END_OF_STREAM) == ret) 982 if ( ((ssize_t) MHD_CONTENT_READER_END_OF_STREAM) == ret)
988 MHD_connection_close_ (connection, 983 MHD_connection_close_ (connection,
989 MHD_REQUEST_TERMINATED_COMPLETED_OK); 984 MHD_REQUEST_TERMINATED_COMPLETED_OK);
990 else 985 else
991 CONNECTION_CLOSE_ERROR (connection, 986 CONNECTION_CLOSE_ERROR (connection,
992 _("Closing connection (application reported error generating data)\n")); 987 _ (
993 return MHD_NO; 988 "Closing connection (application reported error generating data)\n"));
994 } 989 return MHD_NO;
990 }
995 response->data_start = connection->response_write_position; 991 response->data_start = connection->response_write_position;
996 response->data_size = ret; 992 response->data_size = ret;
997 if (0 == ret) 993 if (0 == ret)
998 { 994 {
999 connection->state = MHD_CONNECTION_NORMAL_BODY_UNREADY; 995 connection->state = MHD_CONNECTION_NORMAL_BODY_UNREADY;
1000#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 996#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
1001 MHD_mutex_unlock_chk_ (&response->mutex); 997 MHD_mutex_unlock_chk_ (&response->mutex);
1002#endif 998#endif
1003 return MHD_NO; 999 return MHD_NO;
1004 } 1000 }
1005 return MHD_YES; 1001 return MHD_YES;
1006} 1002}
1007 1003
@@ -1027,95 +1023,96 @@ try_ready_chunked_body (struct MHD_Connection *connection)
1027 if (NULL == response->crc) 1023 if (NULL == response->crc)
1028 return MHD_YES; 1024 return MHD_YES;
1029 if (0 == connection->write_buffer_size) 1025 if (0 == connection->write_buffer_size)
1030 { 1026 {
1031 size_t size; 1027 size_t size;
1032 1028
1033 size = MHD_pool_get_free (connection->pool); 1029 size = MHD_pool_get_free (connection->pool);
1034 if (size < 128) 1030 if (size < 128)
1035 { 1031 {
1036#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 1032#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
1037 MHD_mutex_unlock_chk_ (&response->mutex); 1033 MHD_mutex_unlock_chk_ (&response->mutex);
1038#endif 1034#endif
1039 /* not enough memory */ 1035 /* not enough memory */
1040 CONNECTION_CLOSE_ERROR (connection, 1036 CONNECTION_CLOSE_ERROR (connection,
1041 _("Closing connection (out of memory)\n")); 1037 _ ("Closing connection (out of memory)\n"));
1042 return MHD_NO; 1038 return MHD_NO;
1043 }
1044 if ( (2 * (0xFFFFFF + sizeof(cbuf) + 2)) < size)
1045 size = 2 * (0xFFFFFF + sizeof(cbuf) + 2);
1046 connection->write_buffer = MHD_pool_allocate (connection->pool,
1047 size,
1048 false);
1049 mhd_assert (NULL != connection->write_buffer);
1050 connection->write_buffer_size = size;
1051 } 1039 }
1040 if ( (2 * (0xFFFFFF + sizeof(cbuf) + 2)) < size)
1041 size = 2 * (0xFFFFFF + sizeof(cbuf) + 2);
1042 connection->write_buffer = MHD_pool_allocate (connection->pool,
1043 size,
1044 false);
1045 mhd_assert (NULL != connection->write_buffer);
1046 connection->write_buffer_size = size;
1047 }
1052 1048
1053 if (0 == response->total_size) 1049 if (0 == response->total_size)
1054 ret = 0; /* response must be empty, don't bother calling crc */ 1050 ret = 0; /* response must be empty, don't bother calling crc */
1055 else if ( (response->data_start <= 1051 else if ( (response->data_start <=
1056 connection->response_write_position) && 1052 connection->response_write_position) &&
1057 (response->data_start + response->data_size > 1053 (response->data_start + response->data_size >
1058 connection->response_write_position) ) 1054 connection->response_write_position) )
1059 { 1055 {
1060 /* difference between response_write_position and data_start is less 1056 /* difference between response_write_position and data_start is less
1061 than data_size which is size_t type, no need to check for overflow */ 1057 than data_size which is size_t type, no need to check for overflow */
1062 const size_t data_write_offset 1058 const size_t data_write_offset
1063 = (size_t)(connection->response_write_position - response->data_start); 1059 = (size_t) (connection->response_write_position - response->data_start);
1064 /* buffer already ready, use what is there for the chunk */ 1060 /* buffer already ready, use what is there for the chunk */
1065 ret = response->data_size - data_write_offset; 1061 ret = response->data_size - data_write_offset;
1066 if ( ((size_t) ret) > connection->write_buffer_size - sizeof (cbuf) - 2 ) 1062 if ( ((size_t) ret) > connection->write_buffer_size - sizeof (cbuf) - 2 )
1067 ret = connection->write_buffer_size - sizeof (cbuf) - 2; 1063 ret = connection->write_buffer_size - sizeof (cbuf) - 2;
1068 memcpy (&connection->write_buffer[sizeof (cbuf)], 1064 memcpy (&connection->write_buffer[sizeof (cbuf)],
1069 &response->data[data_write_offset], 1065 &response->data[data_write_offset],
1070 ret); 1066 ret);
1071 } 1067 }
1072 else 1068 else
1073 { 1069 {
1074 /* buffer not in range, try to fill it */ 1070 /* buffer not in range, try to fill it */
1075 ret = response->crc (response->crc_cls, 1071 ret = response->crc (response->crc_cls,
1076 connection->response_write_position, 1072 connection->response_write_position,
1077 &connection->write_buffer[sizeof (cbuf)], 1073 &connection->write_buffer[sizeof (cbuf)],
1078 connection->write_buffer_size - sizeof (cbuf) - 2); 1074 connection->write_buffer_size - sizeof (cbuf) - 2);
1079 } 1075 }
1080 if ( ((ssize_t) MHD_CONTENT_READER_END_WITH_ERROR) == ret) 1076 if ( ((ssize_t) MHD_CONTENT_READER_END_WITH_ERROR) == ret)
1081 { 1077 {
1082 /* error, close socket! */ 1078 /* error, close socket! */
1083 response->total_size = connection->response_write_position; 1079 response->total_size = connection->response_write_position;
1084#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 1080#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
1085 MHD_mutex_unlock_chk_ (&response->mutex); 1081 MHD_mutex_unlock_chk_ (&response->mutex);
1086#endif 1082#endif
1087 CONNECTION_CLOSE_ERROR (connection, 1083 CONNECTION_CLOSE_ERROR (connection,
1088 _("Closing connection (application error generating response)\n")); 1084 _ (
1089 return MHD_NO; 1085 "Closing connection (application error generating response)\n"));
1090 } 1086 return MHD_NO;
1087 }
1091 if ( (((ssize_t) MHD_CONTENT_READER_END_OF_STREAM) == ret) || 1088 if ( (((ssize_t) MHD_CONTENT_READER_END_OF_STREAM) == ret) ||
1092 (0 == response->total_size) ) 1089 (0 == response->total_size) )
1093 { 1090 {
1094 /* end of message, signal other side! */ 1091 /* end of message, signal other side! */
1095 memcpy (connection->write_buffer, 1092 memcpy (connection->write_buffer,
1096 "0\r\n", 1093 "0\r\n",
1097 3); 1094 3);
1098 connection->write_buffer_append_offset = 3; 1095 connection->write_buffer_append_offset = 3;
1099 connection->write_buffer_send_offset = 0; 1096 connection->write_buffer_send_offset = 0;
1100 response->total_size = connection->response_write_position; 1097 response->total_size = connection->response_write_position;
1101 return MHD_YES; 1098 return MHD_YES;
1102 } 1099 }
1103 if (0 == ret) 1100 if (0 == ret)
1104 { 1101 {
1105 connection->state = MHD_CONNECTION_CHUNKED_BODY_UNREADY; 1102 connection->state = MHD_CONNECTION_CHUNKED_BODY_UNREADY;
1106#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 1103#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
1107 MHD_mutex_unlock_chk_ (&response->mutex); 1104 MHD_mutex_unlock_chk_ (&response->mutex);
1108#endif 1105#endif
1109 return MHD_NO; 1106 return MHD_NO;
1110 } 1107 }
1111 if (ret > 0xFFFFFF) 1108 if (ret > 0xFFFFFF)
1112 ret = 0xFFFFFF; 1109 ret = 0xFFFFFF;
1113 cblen = MHD_snprintf_(cbuf, 1110 cblen = MHD_snprintf_ (cbuf,
1114 sizeof (cbuf), 1111 sizeof (cbuf),
1115 "%X\r\n", 1112 "%X\r\n",
1116 (unsigned int) ret); 1113 (unsigned int) ret);
1117 mhd_assert(cblen > 0); 1114 mhd_assert (cblen > 0);
1118 mhd_assert((size_t)cblen < sizeof(cbuf)); 1115 mhd_assert ((size_t) cblen < sizeof(cbuf));
1119 memcpy (&connection->write_buffer[sizeof (cbuf) - cblen], 1116 memcpy (&connection->write_buffer[sizeof (cbuf) - cblen],
1120 cbuf, 1117 cbuf,
1121 cblen); 1118 cblen);
@@ -1156,33 +1153,34 @@ keepalive_possible (struct MHD_Connection *connection)
1156 (0 != (connection->response->flags & MHD_RF_HTTP_VERSION_1_0_ONLY) ) ) 1153 (0 != (connection->response->flags & MHD_RF_HTTP_VERSION_1_0_ONLY) ) )
1157 return MHD_NO; 1154 return MHD_NO;
1158 1155
1159 if (MHD_str_equal_caseless_(connection->version, 1156 if (MHD_str_equal_caseless_ (connection->version,
1160 MHD_HTTP_VERSION_1_1) && 1157 MHD_HTTP_VERSION_1_1) &&
1161 ( (NULL == connection->response) || 1158 ( (NULL == connection->response) ||
1162 (0 == (connection->response->flags & MHD_RF_HTTP_VERSION_1_0_RESPONSE) ) ) ) 1159 (0 == (connection->response->flags
1163 { 1160 & MHD_RF_HTTP_VERSION_1_0_RESPONSE) ) ) )
1164 if (MHD_lookup_header_s_token_ci (connection, 1161 {
1165 MHD_HTTP_HEADER_CONNECTION, 1162 if (MHD_lookup_header_s_token_ci (connection,
1166 "upgrade")) 1163 MHD_HTTP_HEADER_CONNECTION,
1167 return MHD_NO; 1164 "upgrade"))
1165 return MHD_NO;
1168 1166
1169 if (MHD_lookup_header_s_token_ci (connection, 1167 if (MHD_lookup_header_s_token_ci (connection,
1170 MHD_HTTP_HEADER_CONNECTION, 1168 MHD_HTTP_HEADER_CONNECTION,
1171 "close")) 1169 "close"))
1172 return MHD_NO; 1170 return MHD_NO;
1173 1171
1172 return MHD_YES;
1173 }
1174 if (MHD_str_equal_caseless_ (connection->version,
1175 MHD_HTTP_VERSION_1_0))
1176 {
1177 if (MHD_lookup_header_s_token_ci (connection,
1178 MHD_HTTP_HEADER_CONNECTION,
1179 "Keep-Alive"))
1174 return MHD_YES; 1180 return MHD_YES;
1175 }
1176 if (MHD_str_equal_caseless_(connection->version,
1177 MHD_HTTP_VERSION_1_0))
1178 {
1179 if (MHD_lookup_header_s_token_ci (connection,
1180 MHD_HTTP_HEADER_CONNECTION,
1181 "Keep-Alive"))
1182 return MHD_YES;
1183 1181
1184 return MHD_NO; 1182 return MHD_NO;
1185 } 1183 }
1186 return MHD_NO; 1184 return MHD_NO;
1187} 1185}
1188 1186
@@ -1196,7 +1194,7 @@ keepalive_possible (struct MHD_Connection *connection)
1196 */ 1194 */
1197static void 1195static void
1198get_date_string (char *date, 1196get_date_string (char *date,
1199 size_t date_len) 1197 size_t date_len)
1200{ 1198{
1201 static const char *const days[] = { 1199 static const char *const days[] = {
1202 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" 1200 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
@@ -1207,8 +1205,9 @@ get_date_string (char *date,
1207 }; 1205 };
1208 struct tm now; 1206 struct tm now;
1209 time_t t; 1207 time_t t;
1210#if !defined(HAVE_C11_GMTIME_S) && !defined(HAVE_W32_GMTIME_S) && !defined(HAVE_GMTIME_R) 1208#if ! defined(HAVE_C11_GMTIME_S) && ! defined(HAVE_W32_GMTIME_S) && \
1211 struct tm* pNow; 1209 ! defined(HAVE_GMTIME_R)
1210 struct tm*pNow;
1212#endif 1211#endif
1213 1212
1214 date[0] = 0; 1213 date[0] = 0;
@@ -1222,25 +1221,25 @@ get_date_string (char *date,
1222 &t)) 1221 &t))
1223 return; 1222 return;
1224#elif defined(HAVE_GMTIME_R) 1223#elif defined(HAVE_GMTIME_R)
1225 if (NULL == gmtime_r(&t, 1224 if (NULL == gmtime_r (&t,
1226 &now)) 1225 &now))
1227 return; 1226 return;
1228#else 1227#else
1229 pNow = gmtime(&t); 1228 pNow = gmtime (&t);
1230 if (NULL == pNow) 1229 if (NULL == pNow)
1231 return; 1230 return;
1232 now = *pNow; 1231 now = *pNow;
1233#endif 1232#endif
1234 MHD_snprintf_ (date, 1233 MHD_snprintf_ (date,
1235 date_len, 1234 date_len,
1236 "Date: %3s, %02u %3s %04u %02u:%02u:%02u GMT\r\n", 1235 "Date: %3s, %02u %3s %04u %02u:%02u:%02u GMT\r\n",
1237 days[now.tm_wday % 7], 1236 days[now.tm_wday % 7],
1238 (unsigned int) now.tm_mday, 1237 (unsigned int) now.tm_mday,
1239 mons[now.tm_mon % 12], 1238 mons[now.tm_mon % 12],
1240 (unsigned int) (1900 + now.tm_year), 1239 (unsigned int) (1900 + now.tm_year),
1241 (unsigned int) now.tm_hour, 1240 (unsigned int) now.tm_hour,
1242 (unsigned int) now.tm_min, 1241 (unsigned int) now.tm_min,
1243 (unsigned int) now.tm_sec); 1242 (unsigned int) now.tm_sec);
1244} 1243}
1245 1244
1246 1245
@@ -1269,26 +1268,26 @@ try_grow_read_buffer (struct MHD_Connection *connection,
1269 if (0 == connection->read_buffer_size) 1268 if (0 == connection->read_buffer_size)
1270 new_size = avail_size / 2; /* Use half of available buffer for reading */ 1269 new_size = avail_size / 2; /* Use half of available buffer for reading */
1271 else 1270 else
1272 { 1271 {
1273 size_t grow_size; 1272 size_t grow_size;
1274 1273
1275 grow_size = avail_size / 8; 1274 grow_size = avail_size / 8;
1276 if (MHD_BUF_INC_SIZE > grow_size) 1275 if (MHD_BUF_INC_SIZE > grow_size)
1277 { /* Shortage of space */ 1276 { /* Shortage of space */
1278 if (!required) 1277 if (! required)
1279 return false; /* Grow is not mandatory, leave some space in pool */ 1278 return false; /* Grow is not mandatory, leave some space in pool */
1280 else 1279 else
1281 { 1280 {
1282 /* Shortage of space, but grow is mandatory */ 1281 /* Shortage of space, but grow is mandatory */
1283 static const size_t small_inc = MHD_BUF_INC_SIZE / 8; 1282 static const size_t small_inc = MHD_BUF_INC_SIZE / 8;
1284 if (small_inc < avail_size) 1283 if (small_inc < avail_size)
1285 grow_size = small_inc; 1284 grow_size = small_inc;
1286 else 1285 else
1287 grow_size = avail_size; 1286 grow_size = avail_size;
1288 } 1287 }
1289 }
1290 new_size = connection->read_buffer_size + grow_size;
1291 } 1288 }
1289 new_size = connection->read_buffer_size + grow_size;
1290 }
1292 /* we can actually grow the buffer, do it! */ 1291 /* we can actually grow the buffer, do it! */
1293 connection->read_buffer = MHD_pool_reallocate (connection->pool, 1292 connection->read_buffer = MHD_pool_reallocate (connection->pool,
1294 connection->read_buffer, 1293 connection->read_buffer,
@@ -1337,53 +1336,55 @@ build_header_response (struct MHD_Connection *connection)
1337 1336
1338 mhd_assert (NULL != connection->version); 1337 mhd_assert (NULL != connection->version);
1339 if (0 == connection->version[0]) 1338 if (0 == connection->version[0])
1340 { 1339 {
1341 data = MHD_pool_allocate (connection->pool, 1340 data = MHD_pool_allocate (connection->pool,
1342 0, 1341 0,
1343 true); 1342 true);
1344 connection->write_buffer = data; 1343 connection->write_buffer = data;
1345 connection->write_buffer_append_offset = 0; 1344 connection->write_buffer_append_offset = 0;
1346 connection->write_buffer_send_offset = 0; 1345 connection->write_buffer_send_offset = 0;
1347 connection->write_buffer_size = 0; 1346 connection->write_buffer_size = 0;
1348 return MHD_YES; 1347 return MHD_YES;
1349 } 1348 }
1350 rc = connection->responseCode & (~MHD_ICY_FLAG); 1349 rc = connection->responseCode & (~MHD_ICY_FLAG);
1351 if (MHD_CONNECTION_FOOTERS_RECEIVED == connection->state) 1350 if (MHD_CONNECTION_FOOTERS_RECEIVED == connection->state)
1352 { 1351 {
1353 reason_phrase = MHD_get_reason_phrase_for (rc); 1352 reason_phrase = MHD_get_reason_phrase_for (rc);
1354 off = MHD_snprintf_ (code, 1353 off = MHD_snprintf_ (code,
1355 sizeof (code), 1354 sizeof (code),
1356 "%s %u %s\r\n", 1355 "%s %u %s\r\n",
1357 (0 != (connection->responseCode & MHD_ICY_FLAG)) 1356 (0 != (connection->responseCode & MHD_ICY_FLAG))
1358 ? "ICY" 1357 ? "ICY"
1359 : ( (MHD_str_equal_caseless_ (MHD_HTTP_VERSION_1_0, 1358 : ( (MHD_str_equal_caseless_ (MHD_HTTP_VERSION_1_0,
1360 connection->version) || 1359 connection->version) ||
1361 (0 != (connection->response->flags & MHD_RF_HTTP_VERSION_1_0_RESPONSE)) ) 1360 (0 != (connection->response->flags
1362 ? MHD_HTTP_VERSION_1_0 1361 & MHD_RF_HTTP_VERSION_1_0_RESPONSE)) )
1363 : MHD_HTTP_VERSION_1_1), 1362 ? MHD_HTTP_VERSION_1_0
1364 rc, 1363 : MHD_HTTP_VERSION_1_1),
1365 reason_phrase); 1364 rc,
1366 /* estimate size */ 1365 reason_phrase);
1367 size = off + 2; /* +2 for extra "\r\n" at the end */ 1366 /* estimate size */
1368 kind = MHD_HEADER_KIND; 1367 size = off + 2; /* +2 for extra "\r\n" at the end */
1369 if ( (0 == (connection->daemon->options & MHD_USE_SUPPRESS_DATE_NO_CLOCK)) && 1368 kind = MHD_HEADER_KIND;
1370 (NULL == MHD_get_response_header (response, 1369 if ( (0 == (connection->daemon->options
1371 MHD_HTTP_HEADER_DATE)) ) 1370 & MHD_USE_SUPPRESS_DATE_NO_CLOCK)) &&
1372 get_date_string (date, 1371 (NULL == MHD_get_response_header (response,
1373 sizeof (date)); 1372 MHD_HTTP_HEADER_DATE)) )
1374 else 1373 get_date_string (date,
1375 date[0] = '\0'; 1374 sizeof (date));
1376 datelen = strlen (date); 1375 else
1377 size += datelen; 1376 date[0] = '\0';
1378 } 1377 datelen = strlen (date);
1378 size += datelen;
1379 }
1379 else 1380 else
1380 { 1381 {
1381 /* 2 bytes for final CRLF of a Chunked-Body */ 1382 /* 2 bytes for final CRLF of a Chunked-Body */
1382 size = 2; 1383 size = 2;
1383 kind = MHD_FOOTER_KIND; 1384 kind = MHD_FOOTER_KIND;
1384 off = 0; 1385 off = 0;
1385 datelen = 0; 1386 datelen = 0;
1386 } 1387 }
1387 1388
1388 /* calculate extra headers we need to add, such as 'Connection: close', 1389 /* calculate extra headers we need to add, such as 'Connection: close',
1389 first see what was explicitly requested by the application */ 1390 first see what was explicitly requested by the application */
@@ -1393,160 +1394,161 @@ build_header_response (struct MHD_Connection *connection)
1393 must_add_content_length = MHD_NO; 1394 must_add_content_length = MHD_NO;
1394 response_has_close = false; 1395 response_has_close = false;
1395 switch (connection->state) 1396 switch (connection->state)
1396 { 1397 {
1397 case MHD_CONNECTION_FOOTERS_RECEIVED: 1398 case MHD_CONNECTION_FOOTERS_RECEIVED:
1398 response_has_close = MHD_check_response_header_s_token_ci (response, 1399 response_has_close = MHD_check_response_header_s_token_ci (response,
1399 MHD_HTTP_HEADER_CONNECTION, 1400 MHD_HTTP_HEADER_CONNECTION,
1400 "close"); 1401 "close");
1401 response_has_keepalive = MHD_check_response_header_s_token_ci (response, 1402 response_has_keepalive = MHD_check_response_header_s_token_ci (response,
1402 MHD_HTTP_HEADER_CONNECTION, 1403 MHD_HTTP_HEADER_CONNECTION,
1403 "Keep-Alive"); 1404 "Keep-Alive");
1404 client_requested_close = MHD_lookup_header_s_token_ci (connection, 1405 client_requested_close = MHD_lookup_header_s_token_ci (connection,
1405 MHD_HTTP_HEADER_CONNECTION, 1406 MHD_HTTP_HEADER_CONNECTION,
1406 "close"); 1407 "close");
1407 1408
1408 if (0 != (response->flags & MHD_RF_HTTP_VERSION_1_0_ONLY)) 1409 if (0 != (response->flags & MHD_RF_HTTP_VERSION_1_0_ONLY))
1409 connection->keepalive = MHD_CONN_MUST_CLOSE; 1410 connection->keepalive = MHD_CONN_MUST_CLOSE;
1410#ifdef UPGRADE_SUPPORT 1411#ifdef UPGRADE_SUPPORT
1411 else if (NULL != response->upgrade_handler) 1412 else if (NULL != response->upgrade_handler)
1412 /* If this connection will not be "upgraded", it must be closed. */ 1413 /* If this connection will not be "upgraded", it must be closed. */
1413 connection->keepalive = MHD_CONN_MUST_CLOSE; 1414 connection->keepalive = MHD_CONN_MUST_CLOSE;
1414#endif /* UPGRADE_SUPPORT */ 1415#endif /* UPGRADE_SUPPORT */
1415 1416
1416 /* now analyze chunked encoding situation */ 1417 /* now analyze chunked encoding situation */
1417 connection->have_chunked_upload = false; 1418 connection->have_chunked_upload = false;
1418 have_encoding = MHD_get_response_header (response, 1419 have_encoding = MHD_get_response_header (response,
1419 MHD_HTTP_HEADER_TRANSFER_ENCODING); 1420 MHD_HTTP_HEADER_TRANSFER_ENCODING);
1420 if (NULL == have_encoding) 1421 if (NULL == have_encoding)
1421 may_add_content_length = MHD_YES; 1422 may_add_content_length = MHD_YES;
1422 else 1423 else
1423 may_add_content_length = MHD_NO; /* RFC 7230, Section 3.3.2 forbids header */ 1424 may_add_content_length = MHD_NO; /* RFC 7230, Section 3.3.2 forbids header */
1424 if ( (MHD_SIZE_UNKNOWN == response->total_size) && 1425 if ( (MHD_SIZE_UNKNOWN == response->total_size) &&
1425#ifdef UPGRADE_SUPPORT 1426#ifdef UPGRADE_SUPPORT
1426 (NULL == response->upgrade_handler) && 1427 (NULL == response->upgrade_handler) &&
1427#endif /* UPGRADE_SUPPORT */ 1428#endif /* UPGRADE_SUPPORT */
1428 (! response_has_close) && 1429 (! response_has_close) &&
1429 (! client_requested_close) ) 1430 (! client_requested_close) )
1431 {
1432 /* size is unknown, and close was not explicitly requested;
1433 need to either to HTTP 1.1 chunked encoding or
1434 close the connection */
1435 /* 'close' header doesn't exist yet, see if we need to add one;
1436 if the client asked for a close, no need to start chunk'ing */
1437 if ( (MHD_YES == keepalive_possible (connection)) &&
1438 (MHD_str_equal_caseless_ (MHD_HTTP_VERSION_1_1,
1439 connection->version) ) )
1440 {
1441 if (NULL == have_encoding)
1442 {
1443 must_add_chunked_encoding = MHD_YES;
1444 connection->have_chunked_upload = true;
1445 }
1446 else
1430 { 1447 {
1431 /* size is unknown, and close was not explicitly requested; 1448 if (MHD_str_equal_caseless_ (have_encoding,
1432 need to either to HTTP 1.1 chunked encoding or 1449 "identity"))
1433 close the connection */ 1450 {
1434 /* 'close' header doesn't exist yet, see if we need to add one; 1451 /* application forced identity encoding, can't do 'chunked' */
1435 if the client asked for a close, no need to start chunk'ing */ 1452 must_add_close = MHD_YES;
1436 if ( (MHD_YES == keepalive_possible (connection)) && 1453 }
1437 (MHD_str_equal_caseless_ (MHD_HTTP_VERSION_1_1,
1438 connection->version) ) )
1439 {
1440 if (NULL == have_encoding)
1441 {
1442 must_add_chunked_encoding = MHD_YES;
1443 connection->have_chunked_upload = true;
1444 }
1445 else
1446 {
1447 if (MHD_str_equal_caseless_ (have_encoding,
1448 "identity"))
1449 {
1450 /* application forced identity encoding, can't do 'chunked' */
1451 must_add_close = MHD_YES;
1452 }
1453 else
1454 {
1455 connection->have_chunked_upload = true;
1456 }
1457 }
1458 }
1459 else 1454 else
1460 { 1455 {
1461 /* Keep alive or chunking not possible 1456 connection->have_chunked_upload = true;
1462 => set close header if not present */ 1457 }
1463 if (! response_has_close)
1464 must_add_close = MHD_YES;
1465 }
1466 } 1458 }
1459 }
1460 else
1461 {
1462 /* Keep alive or chunking not possible
1463 => set close header if not present */
1464 if (! response_has_close)
1465 must_add_close = MHD_YES;
1466 }
1467 }
1467 1468
1468 /* check for other reasons to add 'close' header */ 1469 /* check for other reasons to add 'close' header */
1469 if ( ( (client_requested_close) || 1470 if ( ( (client_requested_close) ||
1470 (connection->read_closed) || 1471 (connection->read_closed) ||
1471 (MHD_CONN_MUST_CLOSE == connection->keepalive)) && 1472 (MHD_CONN_MUST_CLOSE == connection->keepalive)) &&
1472 (! response_has_close) && 1473 (! response_has_close) &&
1473#ifdef UPGRADE_SUPPORT 1474#ifdef UPGRADE_SUPPORT
1474 (NULL == response->upgrade_handler) && 1475 (NULL == response->upgrade_handler) &&
1475#endif /* UPGRADE_SUPPORT */ 1476#endif /* UPGRADE_SUPPORT */
1476 (0 == (response->flags & MHD_RF_HTTP_VERSION_1_0_ONLY) ) ) 1477 (0 == (response->flags & MHD_RF_HTTP_VERSION_1_0_ONLY) ) )
1477 must_add_close = MHD_YES; 1478 must_add_close = MHD_YES;
1478 1479
1479 /* check if we must add 'close' header because we cannot add content-length 1480 /* check if we must add 'close' header because we cannot add content-length
1480 because it is forbidden AND we don't have a 'chunked' encoding */ 1481 because it is forbidden AND we don't have a 'chunked' encoding */
1481 if ( (! may_add_content_length) && 1482 if ( (! may_add_content_length) &&
1482 (! connection->have_chunked_upload) && 1483 (! connection->have_chunked_upload) &&
1483 (! response_has_close) ) 1484 (! response_has_close) )
1484 must_add_close = MHD_YES; 1485 must_add_close = MHD_YES;
1485 /* #MHD_HTTP_NO_CONTENT, #MHD_HTTP_NOT_MODIFIED and 1xx-status 1486 /* #MHD_HTTP_NO_CONTENT, #MHD_HTTP_NOT_MODIFIED and 1xx-status
1486 codes SHOULD NOT have a Content-Length according to spec; 1487 codes SHOULD NOT have a Content-Length according to spec;
1487 also chunked encoding / unknown length or CONNECT... */ 1488 also chunked encoding / unknown length or CONNECT... */
1488 if ( (MHD_SIZE_UNKNOWN != response->total_size) && 1489 if ( (MHD_SIZE_UNKNOWN != response->total_size) &&
1489 (MHD_HTTP_NO_CONTENT != rc) && 1490 (MHD_HTTP_NO_CONTENT != rc) &&
1490 (MHD_HTTP_NOT_MODIFIED != rc) && 1491 (MHD_HTTP_NOT_MODIFIED != rc) &&
1491 (MHD_HTTP_OK <= rc) && 1492 (MHD_HTTP_OK <= rc) &&
1492 (NULL == /* this should always succeed due to check in 1493 (NULL == /* this should always succeed due to check in
1493 MHD_add_response_header() */ 1494 MHD_add_response_header() */
1494 MHD_get_response_header (response, 1495 MHD_get_response_header (response,
1495 MHD_HTTP_HEADER_CONTENT_LENGTH)) && 1496 MHD_HTTP_HEADER_CONTENT_LENGTH)) &&
1496 (may_add_content_length) && 1497 (may_add_content_length) &&
1497 ( (NULL == connection->method) || 1498 ( (NULL == connection->method) ||
1498 (! MHD_str_equal_caseless_ (connection->method, 1499 (! MHD_str_equal_caseless_ (connection->method,
1499 MHD_HTTP_METHOD_CONNECT)) ) ) 1500 MHD_HTTP_METHOD_CONNECT)) ) )
1500 { 1501 {
1501 /* 1502 /*
1502 Here we add a content-length if one is missing; however, 1503 Here we add a content-length if one is missing; however,
1503 for 'connect' methods, the responses MUST NOT include a 1504 for 'connect' methods, the responses MUST NOT include a
1504 content-length header *if* the response code is 2xx (in 1505 content-length header *if* the response code is 2xx (in
1505 which case we expect there to be no body). Still, 1506 which case we expect there to be no body). Still,
1506 as we don't know the response code here in some cases, we 1507 as we don't know the response code here in some cases, we
1507 simply only force adding a content-length header if this 1508 simply only force adding a content-length header if this
1508 is not a 'connect' or if the response is not empty 1509 is not a 'connect' or if the response is not empty
1509 (which is kind of more sane, because if some crazy 1510 (which is kind of more sane, because if some crazy
1510 application did return content with a 2xx status code, 1511 application did return content with a 2xx status code,
1511 then having a content-length might again be a good idea). 1512 then having a content-length might again be a good idea).
1512 1513
1513 Note that the change from 'SHOULD NOT' to 'MUST NOT' is 1514 Note that the change from 'SHOULD NOT' to 'MUST NOT' is
1514 a recent development of the HTTP 1.1 specification. 1515 a recent development of the HTTP 1.1 specification.
1515 */ 1516 */
1516 content_length_len 1517 content_length_len
1517 = MHD_snprintf_ (content_length_buf, 1518 = MHD_snprintf_ (content_length_buf,
1518 sizeof (content_length_buf), 1519 sizeof (content_length_buf),
1519 MHD_HTTP_HEADER_CONTENT_LENGTH ": " MHD_UNSIGNED_LONG_LONG_PRINTF "\r\n", 1520 MHD_HTTP_HEADER_CONTENT_LENGTH ": "
1520 (MHD_UNSIGNED_LONG_LONG) response->total_size); 1521 MHD_UNSIGNED_LONG_LONG_PRINTF "\r\n",
1521 must_add_content_length = MHD_YES; 1522 (MHD_UNSIGNED_LONG_LONG) response->total_size);
1522 } 1523 must_add_content_length = MHD_YES;
1524 }
1523 1525
1524 /* check for adding keep alive */ 1526 /* check for adding keep alive */
1525 if ( (! response_has_keepalive) && 1527 if ( (! response_has_keepalive) &&
1526 (! response_has_close) && 1528 (! response_has_close) &&
1527 (MHD_NO == must_add_close) && 1529 (MHD_NO == must_add_close) &&
1528 (MHD_CONN_MUST_CLOSE != connection->keepalive) && 1530 (MHD_CONN_MUST_CLOSE != connection->keepalive) &&
1529#ifdef UPGRADE_SUPPORT 1531#ifdef UPGRADE_SUPPORT
1530 (NULL == response->upgrade_handler) && 1532 (NULL == response->upgrade_handler) &&
1531#endif /* UPGRADE_SUPPORT */ 1533#endif /* UPGRADE_SUPPORT */
1532 (MHD_YES == keepalive_possible (connection)) ) 1534 (MHD_YES == keepalive_possible (connection)) )
1533 must_add_keep_alive = MHD_YES; 1535 must_add_keep_alive = MHD_YES;
1534 break; 1536 break;
1535 case MHD_CONNECTION_BODY_SENT: 1537 case MHD_CONNECTION_BODY_SENT:
1536 response_has_keepalive = false; 1538 response_has_keepalive = false;
1537 break; 1539 break;
1538 default: 1540 default:
1539 mhd_assert (0); 1541 mhd_assert (0);
1540 return MHD_NO; 1542 return MHD_NO;
1541 } 1543 }
1542 1544
1543 if (MHD_CONN_MUST_CLOSE != connection->keepalive) 1545 if (MHD_CONN_MUST_CLOSE != connection->keepalive)
1544 { 1546 {
1545 if ( (must_add_close) || (response_has_close) ) 1547 if ( (must_add_close) || (response_has_close) )
1546 connection->keepalive = MHD_CONN_MUST_CLOSE; 1548 connection->keepalive = MHD_CONN_MUST_CLOSE;
1547 else if ( (must_add_keep_alive) || (response_has_keepalive) ) 1549 else if ( (must_add_keep_alive) || (response_has_keepalive) )
1548 connection->keepalive = MHD_CONN_USE_KEEPALIVE; 1550 connection->keepalive = MHD_CONN_USE_KEEPALIVE;
1549 } 1551 }
1550 1552
1551 if (must_add_close) 1553 if (must_add_close)
1552 size += MHD_STATICSTR_LEN_ ("Connection: close\r\n"); 1554 size += MHD_STATICSTR_LEN_ ("Connection: close\r\n");
@@ -1560,94 +1562,98 @@ build_header_response (struct MHD_Connection *connection)
1560 mhd_assert (! (must_add_chunked_encoding && must_add_content_length) ); 1562 mhd_assert (! (must_add_chunked_encoding && must_add_content_length) );
1561 1563
1562 for (pos = response->first_header; NULL != pos; pos = pos->next) 1564 for (pos = response->first_header; NULL != pos; pos = pos->next)
1563 { 1565 {
1564 /* TODO: add proper support for excluding "Keep-Alive" token. */ 1566 /* TODO: add proper support for excluding "Keep-Alive" token. */
1565 if ( (pos->kind == kind) && 1567 if ( (pos->kind == kind) &&
1566 (! ( (MHD_YES == must_add_close) && 1568 (! ( (MHD_YES == must_add_close) &&
1567 (response_has_keepalive) && 1569 (response_has_keepalive) &&
1568 (pos->header_size == MHD_STATICSTR_LEN_(MHD_HTTP_HEADER_CONNECTION)) && 1570 (pos->header_size == MHD_STATICSTR_LEN_ (
1569 (MHD_str_equal_caseless_bin_n_(pos->header, 1571 MHD_HTTP_HEADER_CONNECTION)) &&
1570 MHD_HTTP_HEADER_CONNECTION, 1572 (MHD_str_equal_caseless_bin_n_ (pos->header,
1571 MHD_STATICSTR_LEN_(MHD_HTTP_HEADER_CONNECTION))) && 1573 MHD_HTTP_HEADER_CONNECTION,
1572 (MHD_str_equal_caseless_(pos->value, 1574 MHD_STATICSTR_LEN_ (
1573 "Keep-Alive")) ) ) ) 1575 MHD_HTTP_HEADER_CONNECTION))) &&
1574 size += pos->header_size + pos->value_size + 4; /* colon, space, linefeeds */ 1576 (MHD_str_equal_caseless_ (pos->value,
1575 } 1577 "Keep-Alive")) ) ) )
1578 size += pos->header_size + pos->value_size + 4; /* colon, space, linefeeds */
1579 }
1576 /* produce data */ 1580 /* produce data */
1577 data = MHD_pool_allocate (connection->pool, 1581 data = MHD_pool_allocate (connection->pool,
1578 size + 1, 1582 size + 1,
1579 false); 1583 false);
1580 if (NULL == data) 1584 if (NULL == data)
1581 { 1585 {
1582#ifdef HAVE_MESSAGES 1586#ifdef HAVE_MESSAGES
1583 MHD_DLOG (connection->daemon, 1587 MHD_DLOG (connection->daemon,
1584 "Not enough memory for write!\n"); 1588 "Not enough memory for write!\n");
1585#endif 1589#endif
1586 return MHD_NO; 1590 return MHD_NO;
1587 } 1591 }
1588 if (MHD_CONNECTION_FOOTERS_RECEIVED == connection->state) 1592 if (MHD_CONNECTION_FOOTERS_RECEIVED == connection->state)
1589 { 1593 {
1590 memcpy (data, 1594 memcpy (data,
1591 code, 1595 code,
1592 off); 1596 off);
1593 } 1597 }
1594 if (must_add_close) 1598 if (must_add_close)
1595 { 1599 {
1596 /* we must add the 'Connection: close' header */ 1600 /* we must add the 'Connection: close' header */
1597 memcpy (&data[off], 1601 memcpy (&data[off],
1598 "Connection: close\r\n", 1602 "Connection: close\r\n",
1599 MHD_STATICSTR_LEN_ ("Connection: close\r\n")); 1603 MHD_STATICSTR_LEN_ ("Connection: close\r\n"));
1600 off += MHD_STATICSTR_LEN_ ("Connection: close\r\n"); 1604 off += MHD_STATICSTR_LEN_ ("Connection: close\r\n");
1601 } 1605 }
1602 if (must_add_keep_alive) 1606 if (must_add_keep_alive)
1603 { 1607 {
1604 /* we must add the 'Connection: Keep-Alive' header */ 1608 /* we must add the 'Connection: Keep-Alive' header */
1605 memcpy (&data[off], 1609 memcpy (&data[off],
1606 "Connection: Keep-Alive\r\n", 1610 "Connection: Keep-Alive\r\n",
1607 MHD_STATICSTR_LEN_ ("Connection: Keep-Alive\r\n")); 1611 MHD_STATICSTR_LEN_ ("Connection: Keep-Alive\r\n"));
1608 off += MHD_STATICSTR_LEN_ ("Connection: Keep-Alive\r\n"); 1612 off += MHD_STATICSTR_LEN_ ("Connection: Keep-Alive\r\n");
1609 } 1613 }
1610 if (must_add_chunked_encoding) 1614 if (must_add_chunked_encoding)
1611 { 1615 {
1612 /* we must add the 'Transfer-Encoding: chunked' header */ 1616 /* we must add the 'Transfer-Encoding: chunked' header */
1613 memcpy (&data[off], 1617 memcpy (&data[off],
1614 "Transfer-Encoding: chunked\r\n", 1618 "Transfer-Encoding: chunked\r\n",
1615 MHD_STATICSTR_LEN_ ("Transfer-Encoding: chunked\r\n")); 1619 MHD_STATICSTR_LEN_ ("Transfer-Encoding: chunked\r\n"));
1616 off += MHD_STATICSTR_LEN_ ("Transfer-Encoding: chunked\r\n"); 1620 off += MHD_STATICSTR_LEN_ ("Transfer-Encoding: chunked\r\n");
1617 } 1621 }
1618 if (must_add_content_length) 1622 if (must_add_content_length)
1619 { 1623 {
1620 /* we must add the 'Content-Length' header */ 1624 /* we must add the 'Content-Length' header */
1621 memcpy (&data[off], 1625 memcpy (&data[off],
1622 content_length_buf, 1626 content_length_buf,
1623 content_length_len); 1627 content_length_len);
1624 off += content_length_len; 1628 off += content_length_len;
1625 } 1629 }
1626 for (pos = response->first_header; NULL != pos; pos = pos->next) 1630 for (pos = response->first_header; NULL != pos; pos = pos->next)
1627 { 1631 {
1628 /* TODO: add proper support for excluding "Keep-Alive" token. */ 1632 /* TODO: add proper support for excluding "Keep-Alive" token. */
1629 if ( (pos->kind == kind) && 1633 if ( (pos->kind == kind) &&
1630 (! ( (MHD_YES == must_add_close) && 1634 (! ( (MHD_YES == must_add_close) &&
1631 (response_has_keepalive) && 1635 (response_has_keepalive) &&
1632 (pos->header_size == MHD_STATICSTR_LEN_(MHD_HTTP_HEADER_CONNECTION)) && 1636 (pos->header_size == MHD_STATICSTR_LEN_ (
1633 (MHD_str_equal_caseless_bin_n_(pos->header, 1637 MHD_HTTP_HEADER_CONNECTION)) &&
1634 MHD_HTTP_HEADER_CONNECTION, 1638 (MHD_str_equal_caseless_bin_n_ (pos->header,
1635 MHD_STATICSTR_LEN_(MHD_HTTP_HEADER_CONNECTION))) && 1639 MHD_HTTP_HEADER_CONNECTION,
1636 (MHD_str_equal_caseless_(pos->value, 1640 MHD_STATICSTR_LEN_ (
1637 "Keep-Alive")) ) ) ) 1641 MHD_HTTP_HEADER_CONNECTION))) &&
1638 off += MHD_snprintf_ (&data[off], 1642 (MHD_str_equal_caseless_ (pos->value,
1639 size - off, 1643 "Keep-Alive")) ) ) )
1640 "%s: %s\r\n", 1644 off += MHD_snprintf_ (&data[off],
1641 pos->header, 1645 size - off,
1642 pos->value); 1646 "%s: %s\r\n",
1643 } 1647 pos->header,
1648 pos->value);
1649 }
1644 if (MHD_CONNECTION_FOOTERS_RECEIVED == connection->state) 1650 if (MHD_CONNECTION_FOOTERS_RECEIVED == connection->state)
1645 { 1651 {
1646 memcpy (&data[off], 1652 memcpy (&data[off],
1647 date, 1653 date,
1648 datelen); 1654 datelen);
1649 off += datelen; 1655 off += datelen;
1650 } 1656 }
1651 memcpy (&data[off], 1657 memcpy (&data[off],
1652 "\r\n", 1658 "\r\n",
1653 2); 1659 2);
@@ -1678,73 +1684,76 @@ build_header_response (struct MHD_Connection *connection)
1678static void 1684static void
1679transmit_error_response (struct MHD_Connection *connection, 1685transmit_error_response (struct MHD_Connection *connection,
1680 unsigned int status_code, 1686 unsigned int status_code,
1681 const char *message) 1687 const char *message)
1682{ 1688{
1683 struct MHD_Response *response; 1689 struct MHD_Response *response;
1684 int iret; 1690 int iret;
1685 1691
1686 if (NULL == connection->version) 1692 if (NULL == connection->version)
1687 { 1693 {
1688 /* we were unable to process the full header line, so we don't 1694 /* we were unable to process the full header line, so we don't
1689 really know what version the client speaks; assume 1.0 */ 1695 really know what version the client speaks; assume 1.0 */
1690 connection->version = MHD_HTTP_VERSION_1_0; 1696 connection->version = MHD_HTTP_VERSION_1_0;
1691 } 1697 }
1692 connection->state = MHD_CONNECTION_FOOTERS_RECEIVED; 1698 connection->state = MHD_CONNECTION_FOOTERS_RECEIVED;
1693 connection->read_closed = true; 1699 connection->read_closed = true;
1694 if (0 != connection->read_buffer_size) 1700 if (0 != connection->read_buffer_size)
1695 { 1701 {
1696 /* Read buffer is not needed anymore, discard it 1702 /* Read buffer is not needed anymore, discard it
1697 * to free some space for error response. */ 1703 * to free some space for error response. */
1698 connection->read_buffer = MHD_pool_reallocate(connection->pool, 1704 connection->read_buffer = MHD_pool_reallocate (connection->pool,
1699 connection->read_buffer, 1705 connection->read_buffer,
1700 connection->read_buffer_size, 1706 connection->read_buffer_size,
1701 0); 1707 0);
1702 connection->read_buffer_size = 0; 1708 connection->read_buffer_size = 0;
1703 } 1709 }
1704#ifdef HAVE_MESSAGES 1710#ifdef HAVE_MESSAGES
1705 MHD_DLOG (connection->daemon, 1711 MHD_DLOG (connection->daemon,
1706 _("Error processing request (HTTP response code is %u (`%s')). Closing connection.\n"), 1712 _ (
1713 "Error processing request (HTTP response code is %u (`%s')). Closing connection.\n"),
1707 status_code, 1714 status_code,
1708 message); 1715 message);
1709#endif 1716#endif
1710 if (NULL != connection->response) 1717 if (NULL != connection->response)
1711 { 1718 {
1712 MHD_destroy_response (connection->response); 1719 MHD_destroy_response (connection->response);
1713 connection->response = NULL; 1720 connection->response = NULL;
1714 } 1721 }
1715 response = MHD_create_response_from_buffer (strlen (message), 1722 response = MHD_create_response_from_buffer (strlen (message),
1716 (void *) message, 1723 (void *) message,
1717 MHD_RESPMEM_PERSISTENT); 1724 MHD_RESPMEM_PERSISTENT);
1718 if (NULL == response) 1725 if (NULL == response)
1719 { 1726 {
1720 /* can't even send a reply, at least close the connection */ 1727 /* can't even send a reply, at least close the connection */
1721 connection->state = MHD_CONNECTION_CLOSED; 1728 connection->state = MHD_CONNECTION_CLOSED;
1722 return; 1729 return;
1723 } 1730 }
1724 iret = MHD_queue_response (connection, 1731 iret = MHD_queue_response (connection,
1725 status_code, 1732 status_code,
1726 response); 1733 response);
1727 MHD_destroy_response (response); 1734 MHD_destroy_response (response);
1728 if (MHD_YES != iret) 1735 if (MHD_YES != iret)
1729 { 1736 {
1730 /* can't even send a reply, at least close the connection */ 1737 /* can't even send a reply, at least close the connection */
1731 CONNECTION_CLOSE_ERROR (connection, 1738 CONNECTION_CLOSE_ERROR (connection,
1732 _("Closing connection (failed to queue response)\n")); 1739 _ (
1733 return; 1740 "Closing connection (failed to queue response)\n"));
1734 } 1741 return;
1742 }
1735 mhd_assert (NULL != connection->response); 1743 mhd_assert (NULL != connection->response);
1736 /* Do not reuse this connection. */ 1744 /* Do not reuse this connection. */
1737 connection->keepalive = MHD_CONN_MUST_CLOSE; 1745 connection->keepalive = MHD_CONN_MUST_CLOSE;
1738 if (MHD_NO == build_header_response (connection)) 1746 if (MHD_NO == build_header_response (connection))
1739 { 1747 {
1740 /* oops - close! */ 1748 /* oops - close! */
1741 CONNECTION_CLOSE_ERROR (connection, 1749 CONNECTION_CLOSE_ERROR (connection,
1742 _("Closing connection (failed to create response header)\n")); 1750 _ (
1743 } 1751 "Closing connection (failed to create response header)\n"));
1752 }
1744 else 1753 else
1745 { 1754 {
1746 connection->state = MHD_CONNECTION_HEADERS_SENDING; 1755 connection->state = MHD_CONNECTION_HEADERS_SENDING;
1747 } 1756 }
1748} 1757}
1749 1758
1750 1759
@@ -1764,151 +1773,151 @@ MHD_connection_update_event_loop_info (struct MHD_Connection *connection)
1764 return; /* States will be updated after resume. */ 1773 return; /* States will be updated after resume. */
1765#ifdef HTTPS_SUPPORT 1774#ifdef HTTPS_SUPPORT
1766 if (MHD_TLS_CONN_NO_TLS != connection->tls_state) 1775 if (MHD_TLS_CONN_NO_TLS != connection->tls_state)
1767 { /* HTTPS connection. */ 1776 { /* HTTPS connection. */
1768 switch (connection->tls_state) 1777 switch (connection->tls_state)
1769 { 1778 {
1770 case MHD_TLS_CONN_INIT: 1779 case MHD_TLS_CONN_INIT:
1771 connection->event_loop_info = MHD_EVENT_LOOP_INFO_READ; 1780 connection->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
1772 return; 1781 return;
1773 case MHD_TLS_CONN_HANDSHAKING: 1782 case MHD_TLS_CONN_HANDSHAKING:
1774 if (0 == gnutls_record_get_direction (connection->tls_session)) 1783 if (0 == gnutls_record_get_direction (connection->tls_session))
1775 connection->event_loop_info = MHD_EVENT_LOOP_INFO_READ; 1784 connection->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
1776 else 1785 else
1777 connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE; 1786 connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
1778 return; 1787 return;
1779 default: 1788 default:
1780 break; 1789 break;
1781 }
1782 } 1790 }
1791 }
1783#endif /* HTTPS_SUPPORT */ 1792#endif /* HTTPS_SUPPORT */
1784 while (1) 1793 while (1)
1785 { 1794 {
1786#if DEBUG_STATES 1795#if DEBUG_STATES
1787 MHD_DLOG (connection->daemon, 1796 MHD_DLOG (connection->daemon,
1788 _("In function %s handling connection at state: %s\n"), 1797 _ ("In function %s handling connection at state: %s\n"),
1789 __FUNCTION__, 1798 __FUNCTION__,
1790 MHD_state_to_string (connection->state)); 1799 MHD_state_to_string (connection->state));
1791#endif 1800#endif
1792 switch (connection->state) 1801 switch (connection->state)
1802 {
1803 case MHD_CONNECTION_INIT:
1804 case MHD_CONNECTION_URL_RECEIVED:
1805 case MHD_CONNECTION_HEADER_PART_RECEIVED:
1806 /* while reading headers, we always grow the
1807 read buffer if needed, no size-check required */
1808 if ( (connection->read_buffer_offset == connection->read_buffer_size) &&
1809 (! try_grow_read_buffer (connection, true)) )
1810 {
1811 transmit_error_response (connection,
1812 (connection->url != NULL)
1813 ? MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE
1814 : MHD_HTTP_URI_TOO_LONG,
1815 REQUEST_TOO_BIG);
1816 continue;
1817 }
1818 if (! connection->read_closed)
1819 connection->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
1820 else
1821 connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
1822 break;
1823 case MHD_CONNECTION_HEADERS_RECEIVED:
1824 mhd_assert (0);
1825 break;
1826 case MHD_CONNECTION_HEADERS_PROCESSED:
1827 mhd_assert (0);
1828 break;
1829 case MHD_CONNECTION_CONTINUE_SENDING:
1830 connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
1831 break;
1832 case MHD_CONNECTION_CONTINUE_SENT:
1833 if (connection->read_buffer_offset == connection->read_buffer_size)
1834 {
1835 const bool internal_poll = (0 != (connection->daemon->options
1836 & MHD_USE_INTERNAL_POLLING_THREAD));
1837 if ( (! try_grow_read_buffer (connection, true)) &&
1838 internal_poll)
1793 { 1839 {
1794 case MHD_CONNECTION_INIT: 1840 /* failed to grow the read buffer, and the
1795 case MHD_CONNECTION_URL_RECEIVED: 1841 client which is supposed to handle the
1796 case MHD_CONNECTION_HEADER_PART_RECEIVED: 1842 received data in a *blocking* fashion
1797 /* while reading headers, we always grow the 1843 (in this mode) did not handle the data as
1798 read buffer if needed, no size-check required */ 1844 it was supposed to!
1799 if ( (connection->read_buffer_offset == connection->read_buffer_size) && 1845 => we would either have to do busy-waiting
1800 (!try_grow_read_buffer (connection, true)) ) 1846 (on the client, which would likely fail),
1801 { 1847 or if we do nothing, we would just timeout
1802 transmit_error_response (connection, 1848 on the connection (if a timeout is even
1803 (connection->url != NULL) 1849 set!).
1804 ? MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE 1850 Solution: we kill the connection with an error */
1805 : MHD_HTTP_URI_TOO_LONG, 1851 transmit_error_response (connection,
1806 REQUEST_TOO_BIG); 1852 MHD_HTTP_INTERNAL_SERVER_ERROR,
1807 continue; 1853 INTERNAL_ERROR);
1808 } 1854 continue;
1809 if (! connection->read_closed)
1810 connection->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
1811 else
1812 connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
1813 break;
1814 case MHD_CONNECTION_HEADERS_RECEIVED:
1815 mhd_assert (0);
1816 break;
1817 case MHD_CONNECTION_HEADERS_PROCESSED:
1818 mhd_assert (0);
1819 break;
1820 case MHD_CONNECTION_CONTINUE_SENDING:
1821 connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
1822 break;
1823 case MHD_CONNECTION_CONTINUE_SENT:
1824 if (connection->read_buffer_offset == connection->read_buffer_size)
1825 {
1826 const bool internal_poll = (0 != (connection->daemon->options &
1827 MHD_USE_INTERNAL_POLLING_THREAD));
1828 if ( (!try_grow_read_buffer (connection, true)) &&
1829 internal_poll)
1830 {
1831 /* failed to grow the read buffer, and the
1832 client which is supposed to handle the
1833 received data in a *blocking* fashion
1834 (in this mode) did not handle the data as
1835 it was supposed to!
1836 => we would either have to do busy-waiting
1837 (on the client, which would likely fail),
1838 or if we do nothing, we would just timeout
1839 on the connection (if a timeout is even
1840 set!).
1841 Solution: we kill the connection with an error */
1842 transmit_error_response (connection,
1843 MHD_HTTP_INTERNAL_SERVER_ERROR,
1844 INTERNAL_ERROR);
1845 continue;
1846 }
1847 }
1848 if ( (connection->read_buffer_offset < connection->read_buffer_size) &&
1849 (! connection->read_closed) )
1850 connection->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
1851 else
1852 connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
1853 break;
1854 case MHD_CONNECTION_BODY_RECEIVED:
1855 case MHD_CONNECTION_FOOTER_PART_RECEIVED:
1856 /* while reading footers, we always grow the
1857 read buffer if needed, no size-check required */
1858 if (connection->read_closed)
1859 {
1860 CONNECTION_CLOSE_ERROR (connection,
1861 NULL);
1862 continue;
1863 }
1864 connection->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
1865 /* transition to FOOTERS_RECEIVED
1866 happens in read handler */
1867 break;
1868 case MHD_CONNECTION_FOOTERS_RECEIVED:
1869 connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
1870 break;
1871 case MHD_CONNECTION_HEADERS_SENDING:
1872 /* headers in buffer, keep writing */
1873 connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
1874 break;
1875 case MHD_CONNECTION_HEADERS_SENT:
1876 mhd_assert (0);
1877 break;
1878 case MHD_CONNECTION_NORMAL_BODY_READY:
1879 connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
1880 break;
1881 case MHD_CONNECTION_NORMAL_BODY_UNREADY:
1882 connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
1883 break;
1884 case MHD_CONNECTION_CHUNKED_BODY_READY:
1885 connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
1886 break;
1887 case MHD_CONNECTION_CHUNKED_BODY_UNREADY:
1888 connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
1889 break;
1890 case MHD_CONNECTION_BODY_SENT:
1891 mhd_assert (0);
1892 break;
1893 case MHD_CONNECTION_FOOTERS_SENDING:
1894 connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
1895 break;
1896 case MHD_CONNECTION_FOOTERS_SENT:
1897 mhd_assert (0);
1898 break;
1899 case MHD_CONNECTION_CLOSED:
1900 connection->event_loop_info = MHD_EVENT_LOOP_INFO_CLEANUP;
1901 return; /* do nothing, not even reading */
1902#ifdef UPGRADE_SUPPORT
1903 case MHD_CONNECTION_UPGRADE:
1904 mhd_assert (0);
1905 break;
1906#endif /* UPGRADE_SUPPORT */
1907 default:
1908 mhd_assert (0);
1909 } 1855 }
1856 }
1857 if ( (connection->read_buffer_offset < connection->read_buffer_size) &&
1858 (! connection->read_closed) )
1859 connection->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
1860 else
1861 connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
1910 break; 1862 break;
1863 case MHD_CONNECTION_BODY_RECEIVED:
1864 case MHD_CONNECTION_FOOTER_PART_RECEIVED:
1865 /* while reading footers, we always grow the
1866 read buffer if needed, no size-check required */
1867 if (connection->read_closed)
1868 {
1869 CONNECTION_CLOSE_ERROR (connection,
1870 NULL);
1871 continue;
1872 }
1873 connection->event_loop_info = MHD_EVENT_LOOP_INFO_READ;
1874 /* transition to FOOTERS_RECEIVED
1875 happens in read handler */
1876 break;
1877 case MHD_CONNECTION_FOOTERS_RECEIVED:
1878 connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
1879 break;
1880 case MHD_CONNECTION_HEADERS_SENDING:
1881 /* headers in buffer, keep writing */
1882 connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
1883 break;
1884 case MHD_CONNECTION_HEADERS_SENT:
1885 mhd_assert (0);
1886 break;
1887 case MHD_CONNECTION_NORMAL_BODY_READY:
1888 connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
1889 break;
1890 case MHD_CONNECTION_NORMAL_BODY_UNREADY:
1891 connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
1892 break;
1893 case MHD_CONNECTION_CHUNKED_BODY_READY:
1894 connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
1895 break;
1896 case MHD_CONNECTION_CHUNKED_BODY_UNREADY:
1897 connection->event_loop_info = MHD_EVENT_LOOP_INFO_BLOCK;
1898 break;
1899 case MHD_CONNECTION_BODY_SENT:
1900 mhd_assert (0);
1901 break;
1902 case MHD_CONNECTION_FOOTERS_SENDING:
1903 connection->event_loop_info = MHD_EVENT_LOOP_INFO_WRITE;
1904 break;
1905 case MHD_CONNECTION_FOOTERS_SENT:
1906 mhd_assert (0);
1907 break;
1908 case MHD_CONNECTION_CLOSED:
1909 connection->event_loop_info = MHD_EVENT_LOOP_INFO_CLEANUP;
1910 return; /* do nothing, not even reading */
1911#ifdef UPGRADE_SUPPORT
1912 case MHD_CONNECTION_UPGRADE:
1913 mhd_assert (0);
1914 break;
1915#endif /* UPGRADE_SUPPORT */
1916 default:
1917 mhd_assert (0);
1911 } 1918 }
1919 break;
1920 }
1912} 1921}
1913 1922
1914 1923
@@ -1942,21 +1951,21 @@ get_next_header_line (struct MHD_Connection *connection,
1942 pos++; 1951 pos++;
1943 if ( (pos == connection->read_buffer_offset - 1) && 1952 if ( (pos == connection->read_buffer_offset - 1) &&
1944 ('\n' != rbuf[pos]) ) 1953 ('\n' != rbuf[pos]) )
1954 {
1955 /* not found, consider growing... */
1956 if ( (connection->read_buffer_offset == connection->read_buffer_size) &&
1957 (! try_grow_read_buffer (connection, true)) )
1945 { 1958 {
1946 /* not found, consider growing... */ 1959 transmit_error_response (connection,
1947 if ( (connection->read_buffer_offset == connection->read_buffer_size) && 1960 (NULL != connection->url)
1948 (!try_grow_read_buffer (connection, true)) ) 1961 ? MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE
1949 { 1962 : MHD_HTTP_URI_TOO_LONG,
1950 transmit_error_response (connection, 1963 REQUEST_TOO_BIG);
1951 (NULL != connection->url)
1952 ? MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE
1953 : MHD_HTTP_URI_TOO_LONG,
1954 REQUEST_TOO_BIG);
1955 }
1956 if (line_len)
1957 *line_len = 0;
1958 return NULL;
1959 } 1964 }
1965 if (line_len)
1966 *line_len = 0;
1967 return NULL;
1968 }
1960 1969
1961 if (line_len) 1970 if (line_len)
1962 *line_len = pos; 1971 *line_len = pos;
@@ -1989,27 +1998,27 @@ static int
1989connection_add_header (struct MHD_Connection *connection, 1998connection_add_header (struct MHD_Connection *connection,
1990 const char *key, 1999 const char *key,
1991 size_t key_size, 2000 size_t key_size,
1992 const char *value, 2001 const char *value,
1993 size_t value_size, 2002 size_t value_size,
1994 enum MHD_ValueKind kind) 2003 enum MHD_ValueKind kind)
1995{ 2004{
1996 if (MHD_NO == 2005 if (MHD_NO ==
1997 MHD_set_connection_value_n (connection, 2006 MHD_set_connection_value_n (connection,
1998 kind, 2007 kind,
1999 key, 2008 key,
2000 key_size, 2009 key_size,
2001 value, 2010 value,
2002 value_size)) 2011 value_size))
2003 { 2012 {
2004#ifdef HAVE_MESSAGES 2013#ifdef HAVE_MESSAGES
2005 MHD_DLOG (connection->daemon, 2014 MHD_DLOG (connection->daemon,
2006 _("Not enough memory in pool to allocate header record!\n")); 2015 _ ("Not enough memory in pool to allocate header record!\n"));
2007#endif 2016#endif
2008 transmit_error_response (connection, 2017 transmit_error_response (connection,
2009 MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE, 2018 MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE,
2010 REQUEST_TOO_BIG); 2019 REQUEST_TOO_BIG);
2011 return MHD_NO; 2020 return MHD_NO;
2012 } 2021 }
2013 return MHD_YES; 2022 return MHD_YES;
2014} 2023}
2015 2024
@@ -2038,7 +2047,8 @@ parse_cookie_header (struct MHD_Connection *connection)
2038 if (MHD_NO == MHD_lookup_connection_value_n (connection, 2047 if (MHD_NO == MHD_lookup_connection_value_n (connection,
2039 MHD_HEADER_KIND, 2048 MHD_HEADER_KIND,
2040 MHD_HTTP_HEADER_COOKIE, 2049 MHD_HTTP_HEADER_COOKIE,
2041 MHD_STATICSTR_LEN_(MHD_HTTP_HEADER_COOKIE), 2050 MHD_STATICSTR_LEN_ (
2051 MHD_HTTP_HEADER_COOKIE),
2042 &hdr, 2052 &hdr,
2043 &hdr_len)) 2053 &hdr_len))
2044 return MHD_YES; 2054 return MHD_YES;
@@ -2046,93 +2056,93 @@ parse_cookie_header (struct MHD_Connection *connection)
2046 hdr_len + 1, 2056 hdr_len + 1,
2047 true); 2057 true);
2048 if (NULL == cpy) 2058 if (NULL == cpy)
2049 { 2059 {
2050#ifdef HAVE_MESSAGES 2060#ifdef HAVE_MESSAGES
2051 MHD_DLOG (connection->daemon, 2061 MHD_DLOG (connection->daemon,
2052 _("Not enough memory in pool to parse cookies!\n")); 2062 _ ("Not enough memory in pool to parse cookies!\n"));
2053#endif 2063#endif
2054 transmit_error_response (connection, 2064 transmit_error_response (connection,
2055 MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE, 2065 MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE,
2056 REQUEST_TOO_BIG); 2066 REQUEST_TOO_BIG);
2057 return MHD_NO; 2067 return MHD_NO;
2058 } 2068 }
2059 memcpy (cpy, 2069 memcpy (cpy,
2060 hdr, 2070 hdr,
2061 hdr_len); 2071 hdr_len);
2062 cpy[hdr_len] = '\0'; 2072 cpy[hdr_len] = '\0';
2063 pos = cpy; 2073 pos = cpy;
2064 while (NULL != pos) 2074 while (NULL != pos)
2075 {
2076 while (' ' == *pos)
2077 pos++; /* skip spaces */
2078
2079 sce = pos;
2080 while ( ((*sce) != '\0') &&
2081 ((*sce) != ',') &&
2082 ((*sce) != ';') &&
2083 ((*sce) != '=') )
2084 sce++;
2085 /* remove tailing whitespace (if any) from key */
2086 ekill = sce - 1;
2087 while ( (*ekill == ' ') &&
2088 (ekill >= pos) )
2089 *(ekill--) = '\0';
2090 old = *sce;
2091 *sce = '\0';
2092 if (old != '=')
2065 { 2093 {
2066 while (' ' == *pos) 2094 /* value part omitted, use empty string... */
2067 pos++; /* skip spaces */
2068
2069 sce = pos;
2070 while ( ((*sce) != '\0') &&
2071 ((*sce) != ',') &&
2072 ((*sce) != ';') &&
2073 ((*sce) != '=') )
2074 sce++;
2075 /* remove tailing whitespace (if any) from key */
2076 ekill = sce - 1;
2077 while ( (*ekill == ' ') &&
2078 (ekill >= pos) )
2079 *(ekill--) = '\0';
2080 old = *sce;
2081 *sce = '\0';
2082 if (old != '=')
2083 {
2084 /* value part omitted, use empty string... */
2085 if (MHD_NO ==
2086 connection_add_header (connection,
2087 pos,
2088 ekill - pos + 1,
2089 "",
2090 0,
2091 MHD_COOKIE_KIND))
2092 return MHD_NO;
2093 if (old == '\0')
2094 break;
2095 pos = sce + 1;
2096 continue;
2097 }
2098 equals = sce + 1;
2099 quotes = 0;
2100 semicolon = equals;
2101 while ( ('\0' != semicolon[0]) &&
2102 ( (0 != quotes) ||
2103 ( (';' != semicolon[0]) &&
2104 (',' != semicolon[0]) ) ) )
2105 {
2106 if ('"' == semicolon[0])
2107 quotes = (quotes + 1) & 1;
2108 semicolon++;
2109 }
2110 end = semicolon;
2111 if ('\0' == semicolon[0])
2112 semicolon = NULL;
2113 if (NULL != semicolon)
2114 {
2115 semicolon[0] = '\0';
2116 semicolon++;
2117 }
2118 /* remove quotes */
2119 if ( ('"' == equals[0]) &&
2120 ('"' == end[-1]) )
2121 {
2122 equals++;
2123 end--;
2124 *end = '\0';
2125 }
2126 if (MHD_NO == 2095 if (MHD_NO ==
2127 connection_add_header (connection, 2096 connection_add_header (connection,
2128 pos, 2097 pos,
2129 ekill - pos + 1, 2098 ekill - pos + 1,
2130 equals, 2099 "",
2131 end - equals, 2100 0,
2132 MHD_COOKIE_KIND)) 2101 MHD_COOKIE_KIND))
2133 return MHD_NO; 2102 return MHD_NO;
2134 pos = semicolon; 2103 if (old == '\0')
2104 break;
2105 pos = sce + 1;
2106 continue;
2107 }
2108 equals = sce + 1;
2109 quotes = 0;
2110 semicolon = equals;
2111 while ( ('\0' != semicolon[0]) &&
2112 ( (0 != quotes) ||
2113 ( (';' != semicolon[0]) &&
2114 (',' != semicolon[0]) ) ) )
2115 {
2116 if ('"' == semicolon[0])
2117 quotes = (quotes + 1) & 1;
2118 semicolon++;
2119 }
2120 end = semicolon;
2121 if ('\0' == semicolon[0])
2122 semicolon = NULL;
2123 if (NULL != semicolon)
2124 {
2125 semicolon[0] = '\0';
2126 semicolon++;
2127 }
2128 /* remove quotes */
2129 if ( ('"' == equals[0]) &&
2130 ('"' == end[-1]) )
2131 {
2132 equals++;
2133 end--;
2134 *end = '\0';
2135 } 2135 }
2136 if (MHD_NO ==
2137 connection_add_header (connection,
2138 pos,
2139 ekill - pos + 1,
2140 equals,
2141 end - equals,
2142 MHD_COOKIE_KIND))
2143 return MHD_NO;
2144 pos = semicolon;
2145 }
2136 return MHD_YES; 2146 return MHD_YES;
2137} 2147}
2138 2148
@@ -2167,84 +2177,84 @@ parse_initial_message_line (struct MHD_Connection *connection,
2167 /* Skip any spaces. Not required by standard but allow 2177 /* Skip any spaces. Not required by standard but allow
2168 to be more tolerant. */ 2178 to be more tolerant. */
2169 while ( (' ' == uri[0]) && 2179 while ( (' ' == uri[0]) &&
2170 ( (size_t)(uri - line) < line_len) ) 2180 ( (size_t) (uri - line) < line_len) )
2171 uri++; 2181 uri++;
2172 if ((size_t)(uri - line) == line_len) 2182 if ((size_t) (uri - line) == line_len)
2183 {
2184 /* No URI and no http version given */
2185 curi = "";
2186 uri = NULL;
2187 connection->version = "";
2188 args = NULL;
2189 }
2190 else
2191 {
2192 size_t uri_len;
2193 curi = uri;
2194 /* Search from back to accept misformed URI with space */
2195 http_version = line + line_len - 1;
2196 /* Skip any trailing spaces */
2197 while ( (' ' == http_version[0]) &&
2198 (http_version > uri) )
2199 http_version--;
2200 /* Find first space in reverse direction */
2201 while ( (' ' != http_version[0]) &&
2202 (http_version > uri) )
2203 http_version--;
2204 if (http_version > uri)
2205 {
2206 /* http_version points to character before HTTP version string */
2207 http_version[0] = '\0';
2208 connection->version = http_version + 1;
2209 uri_len = http_version - uri;
2210 }
2211 else
2173 { 2212 {
2174 /* No URI and no http version given */
2175 curi = "";
2176 uri = NULL;
2177 connection->version = ""; 2213 connection->version = "";
2178 args = NULL; 2214 uri_len = line_len - (uri - line);
2179 } 2215 }
2180 else 2216 /* check for spaces in URI if we are "strict" */
2217 if ( (1 <= daemon->strict_for_client) &&
2218 (NULL != memchr (uri,
2219 ' ',
2220 uri_len)) )
2181 { 2221 {
2182 size_t uri_len; 2222 /* space exists in URI and we are supposed to be strict, reject */
2183 curi = uri; 2223 return MHD_NO;
2184 /* Search from back to accept misformed URI with space */
2185 http_version = line + line_len - 1;
2186 /* Skip any trailing spaces */
2187 while ( (' ' == http_version[0]) &&
2188 (http_version > uri) )
2189 http_version--;
2190 /* Find first space in reverse direction */
2191 while ( (' ' != http_version[0]) &&
2192 (http_version > uri) )
2193 http_version--;
2194 if (http_version > uri)
2195 {
2196 /* http_version points to character before HTTP version string */
2197 http_version[0] = '\0';
2198 connection->version = http_version + 1;
2199 uri_len = http_version - uri;
2200 }
2201 else
2202 {
2203 connection->version = "";
2204 uri_len = line_len - (uri - line);
2205 }
2206 /* check for spaces in URI if we are "strict" */
2207 if ( (1 <= daemon->strict_for_client) &&
2208 (NULL != memchr (uri,
2209 ' ',
2210 uri_len)) )
2211 {
2212 /* space exists in URI and we are supposed to be strict, reject */
2213 return MHD_NO;
2214 }
2215
2216 args = memchr (uri,
2217 '?',
2218 uri_len);
2219 } 2224 }
2220 2225
2226 args = memchr (uri,
2227 '?',
2228 uri_len);
2229 }
2230
2221 /* log callback before we modify URI *or* args */ 2231 /* log callback before we modify URI *or* args */
2222 if (NULL != daemon->uri_log_callback) 2232 if (NULL != daemon->uri_log_callback)
2223 { 2233 {
2224 connection->client_aware = true; 2234 connection->client_aware = true;
2225 connection->client_context 2235 connection->client_context
2226 = daemon->uri_log_callback (daemon->uri_log_callback_cls, 2236 = daemon->uri_log_callback (daemon->uri_log_callback_cls,
2227 uri, 2237 uri,
2228 connection); 2238 connection);
2229 } 2239 }
2230 2240
2231 if (NULL != args) 2241 if (NULL != args)
2232 { 2242 {
2233 args[0] = '\0'; 2243 args[0] = '\0';
2234 args++; 2244 args++;
2235 /* note that this call clobbers 'args' */ 2245 /* note that this call clobbers 'args' */
2236 MHD_parse_arguments_ (connection, 2246 MHD_parse_arguments_ (connection,
2237 MHD_GET_ARGUMENT_KIND, 2247 MHD_GET_ARGUMENT_KIND,
2238 args, 2248 args,
2239 &connection_add_header, 2249 &connection_add_header,
2240 &unused_num_headers); 2250 &unused_num_headers);
2241 } 2251 }
2242 2252
2243 /* unescape URI *after* searching for arguments and log callback */ 2253 /* unescape URI *after* searching for arguments and log callback */
2244 if (NULL != uri) 2254 if (NULL != uri)
2245 daemon->unescape_callback (daemon->unescape_callback_cls, 2255 daemon->unescape_callback (daemon->unescape_callback_cls,
2246 connection, 2256 connection,
2247 uri); 2257 uri);
2248 connection->url = curi; 2258 connection->url = curi;
2249 return MHD_YES; 2259 return MHD_YES;
2250} 2260}
@@ -2276,12 +2286,13 @@ call_connection_handler (struct MHD_Connection *connection)
2276 NULL, 2286 NULL,
2277 &processed, 2287 &processed,
2278 &connection->client_context)) 2288 &connection->client_context))
2279 { 2289 {
2280 /* serious internal error, close connection */ 2290 /* serious internal error, close connection */
2281 CONNECTION_CLOSE_ERROR (connection, 2291 CONNECTION_CLOSE_ERROR (connection,
2282 _("Application reported internal error, closing connection.\n")); 2292 _ (
2283 return; 2293 "Application reported internal error, closing connection.\n"));
2284 } 2294 return;
2295 }
2285} 2296}
2286 2297
2287 2298
@@ -2318,199 +2329,205 @@ process_request_body (struct MHD_Connection *connection)
2318 buffer_head = connection->read_buffer; 2329 buffer_head = connection->read_buffer;
2319 available = connection->read_buffer_offset; 2330 available = connection->read_buffer_offset;
2320 do 2331 do
2321 { 2332 {
2322 size_t to_be_processed; 2333 size_t to_be_processed;
2323 size_t left_unprocessed; 2334 size_t left_unprocessed;
2324 size_t processed_size; 2335 size_t processed_size;
2325 2336
2326 instant_retry = MHD_NO; 2337 instant_retry = MHD_NO;
2327 if ( (connection->have_chunked_upload) && 2338 if ( (connection->have_chunked_upload) &&
2328 (MHD_SIZE_UNKNOWN == connection->remaining_upload_size) ) 2339 (MHD_SIZE_UNKNOWN == connection->remaining_upload_size) )
2340 {
2341 if ( (connection->current_chunk_offset ==
2342 connection->current_chunk_size) &&
2343 (0LLU != connection->current_chunk_offset) &&
2344 (available >= 2) )
2345 {
2346 size_t i;
2347 /* skip new line at the *end* of a chunk */
2348 i = 0;
2349 if ( ('\r' == buffer_head[i]) ||
2350 ('\n' == buffer_head[i]) )
2351 i++; /* skip 1st part of line feed */
2352 if ( ('\r' == buffer_head[i]) ||
2353 ('\n' == buffer_head[i]) )
2354 i++; /* skip 2nd part of line feed */
2355 if (0 == i)
2329 { 2356 {
2330 if ( (connection->current_chunk_offset == connection->current_chunk_size) && 2357 /* malformed encoding */
2331 (0LLU != connection->current_chunk_offset) && 2358 CONNECTION_CLOSE_ERROR (connection,
2332 (available >= 2) ) 2359 _ (
2333 { 2360 "Received malformed HTTP request (bad chunked encoding). Closing connection.\n"));
2334 size_t i; 2361 return;
2335 /* skip new line at the *end* of a chunk */
2336 i = 0;
2337 if ( ('\r' == buffer_head[i]) ||
2338 ('\n' == buffer_head[i]) )
2339 i++; /* skip 1st part of line feed */
2340 if ( ('\r' == buffer_head[i]) ||
2341 ('\n' == buffer_head[i]) )
2342 i++; /* skip 2nd part of line feed */
2343 if (0 == i)
2344 {
2345 /* malformed encoding */
2346 CONNECTION_CLOSE_ERROR (connection,
2347 _("Received malformed HTTP request (bad chunked encoding). Closing connection.\n"));
2348 return;
2349 }
2350 available -= i;
2351 buffer_head += i;
2352 connection->current_chunk_offset = 0;
2353 connection->current_chunk_size = 0;
2354 }
2355 if (connection->current_chunk_offset <
2356 connection->current_chunk_size)
2357 {
2358 uint64_t cur_chunk_left;
2359 /* we are in the middle of a chunk, give
2360 as much as possible to the client (without
2361 crossing chunk boundaries) */
2362 cur_chunk_left
2363 = connection->current_chunk_size - connection->current_chunk_offset;
2364 if (cur_chunk_left > available)
2365 to_be_processed = available;
2366 else
2367 { /* cur_chunk_left <= (size_t)available */
2368 to_be_processed = (size_t)cur_chunk_left;
2369 if (available > to_be_processed)
2370 instant_retry = MHD_YES;
2371 }
2372 }
2373 else
2374 {
2375 size_t i;
2376 size_t end_size;
2377 bool malformed;
2378
2379 /* we need to read chunk boundaries */
2380 i = 0;
2381 while (i < available)
2382 {
2383 if ( ('\r' == buffer_head[i]) ||
2384 ('\n' == buffer_head[i]) ||
2385 (';' == buffer_head[i]) )
2386 break;
2387 i++;
2388 if (i >= 16)
2389 break;
2390 }
2391 end_size = i;
2392 /* find beginning of CRLF (skip over chunk extensions) */
2393 if (';' == buffer_head[i])
2394 {
2395 while (i < available)
2396 {
2397 if ( ('\r' == buffer_head[i]) ||
2398 ('\n' == buffer_head[i]) )
2399 break;
2400 i++;
2401 }
2402 }
2403 /* take '\n' into account; if '\n' is the unavailable
2404 character, we will need to wait until we have it
2405 before going further */
2406 if ( (i + 1 >= available) &&
2407 ! ( (1 == i) &&
2408 (2 == available) &&
2409 ('0' == buffer_head[0]) ) )
2410 break; /* need more data... */
2411 i++;
2412 malformed = (end_size >= 16);
2413 if (! malformed)
2414 {
2415 size_t num_dig = MHD_strx_to_uint64_n_ (buffer_head,
2416 end_size,
2417 &connection->current_chunk_size);
2418 malformed = (end_size != num_dig);
2419 }
2420 if (malformed)
2421 {
2422 /* malformed encoding */
2423 CONNECTION_CLOSE_ERROR (connection,
2424 _("Received malformed HTTP request (bad chunked encoding). Closing connection.\n"));
2425 return;
2426 }
2427 /* skip 2nd part of line feed */
2428 if ( (i < available) &&
2429 ( ('\r' == buffer_head[i]) ||
2430 ('\n' == buffer_head[i]) ) )
2431 i++;
2432
2433 buffer_head += i;
2434 available -= i;
2435 connection->current_chunk_offset = 0;
2436
2437 if (available > 0)
2438 instant_retry = MHD_YES;
2439 if (0LLU == connection->current_chunk_size)
2440 {
2441 connection->remaining_upload_size = 0;
2442 break;
2443 }
2444 continue;
2445 }
2446 } 2362 }
2363 available -= i;
2364 buffer_head += i;
2365 connection->current_chunk_offset = 0;
2366 connection->current_chunk_size = 0;
2367 }
2368 if (connection->current_chunk_offset <
2369 connection->current_chunk_size)
2370 {
2371 uint64_t cur_chunk_left;
2372 /* we are in the middle of a chunk, give
2373 as much as possible to the client (without
2374 crossing chunk boundaries) */
2375 cur_chunk_left
2376 = connection->current_chunk_size - connection->current_chunk_offset;
2377 if (cur_chunk_left > available)
2378 to_be_processed = available;
2379 else
2380 { /* cur_chunk_left <= (size_t)available */
2381 to_be_processed = (size_t) cur_chunk_left;
2382 if (available > to_be_processed)
2383 instant_retry = MHD_YES;
2384 }
2385 }
2447 else 2386 else
2387 {
2388 size_t i;
2389 size_t end_size;
2390 bool malformed;
2391
2392 /* we need to read chunk boundaries */
2393 i = 0;
2394 while (i < available)
2448 { 2395 {
2449 /* no chunked encoding, give all to the client */ 2396 if ( ('\r' == buffer_head[i]) ||
2450 if ( (0 != connection->remaining_upload_size) && 2397 ('\n' == buffer_head[i]) ||
2451 (MHD_SIZE_UNKNOWN != connection->remaining_upload_size) && 2398 (';' == buffer_head[i]) )
2452 (connection->remaining_upload_size < available) ) 2399 break;
2453 { 2400 i++;
2454 to_be_processed = (size_t)connection->remaining_upload_size; 2401 if (i >= 16)
2455 } 2402 break;
2456 else
2457 {
2458 /**
2459 * 1. no chunked encoding, give all to the client
2460 * 2. client may send large chunked data, but only a smaller part is available at one time.
2461 */
2462 to_be_processed = available;
2463 }
2464 } 2403 }
2465 left_unprocessed = to_be_processed; 2404 end_size = i;
2466 connection->client_aware = true; 2405 /* find beginning of CRLF (skip over chunk extensions) */
2467 if (MHD_NO == 2406 if (';' == buffer_head[i])
2468 daemon->default_handler (daemon->default_handler_cls,
2469 connection,
2470 connection->url,
2471 connection->method,
2472 connection->version,
2473 buffer_head,
2474 &left_unprocessed,
2475 &connection->client_context))
2476 { 2407 {
2477 /* serious internal error, close connection */ 2408 while (i < available)
2409 {
2410 if ( ('\r' == buffer_head[i]) ||
2411 ('\n' == buffer_head[i]) )
2412 break;
2413 i++;
2414 }
2415 }
2416 /* take '\n' into account; if '\n' is the unavailable
2417 character, we will need to wait until we have it
2418 before going further */
2419 if ( (i + 1 >= available) &&
2420 ! ( (1 == i) &&
2421 (2 == available) &&
2422 ('0' == buffer_head[0]) ) )
2423 break; /* need more data... */
2424 i++;
2425 malformed = (end_size >= 16);
2426 if (! malformed)
2427 {
2428 size_t num_dig = MHD_strx_to_uint64_n_ (buffer_head,
2429 end_size,
2430 &connection->
2431 current_chunk_size);
2432 malformed = (end_size != num_dig);
2433 }
2434 if (malformed)
2435 {
2436 /* malformed encoding */
2478 CONNECTION_CLOSE_ERROR (connection, 2437 CONNECTION_CLOSE_ERROR (connection,
2479 _("Application reported internal error, closing connection.\n")); 2438 _ (
2439 "Received malformed HTTP request (bad chunked encoding). Closing connection.\n"));
2480 return; 2440 return;
2481 } 2441 }
2482 if (left_unprocessed > to_be_processed) 2442 /* skip 2nd part of line feed */
2483 mhd_panic (mhd_panic_cls, 2443 if ( (i < available) &&
2484 __FILE__, 2444 ( ('\r' == buffer_head[i]) ||
2485 __LINE__ 2445 ('\n' == buffer_head[i]) ) )
2446 i++;
2447
2448 buffer_head += i;
2449 available -= i;
2450 connection->current_chunk_offset = 0;
2451
2452 if (available > 0)
2453 instant_retry = MHD_YES;
2454 if (0LLU == connection->current_chunk_size)
2455 {
2456 connection->remaining_upload_size = 0;
2457 break;
2458 }
2459 continue;
2460 }
2461 }
2462 else
2463 {
2464 /* no chunked encoding, give all to the client */
2465 if ( (0 != connection->remaining_upload_size) &&
2466 (MHD_SIZE_UNKNOWN != connection->remaining_upload_size) &&
2467 (connection->remaining_upload_size < available) )
2468 {
2469 to_be_processed = (size_t) connection->remaining_upload_size;
2470 }
2471 else
2472 {
2473 /**
2474 * 1. no chunked encoding, give all to the client
2475 * 2. client may send large chunked data, but only a smaller part is available at one time.
2476 */
2477 to_be_processed = available;
2478 }
2479 }
2480 left_unprocessed = to_be_processed;
2481 connection->client_aware = true;
2482 if (MHD_NO ==
2483 daemon->default_handler (daemon->default_handler_cls,
2484 connection,
2485 connection->url,
2486 connection->method,
2487 connection->version,
2488 buffer_head,
2489 &left_unprocessed,
2490 &connection->client_context))
2491 {
2492 /* serious internal error, close connection */
2493 CONNECTION_CLOSE_ERROR (connection,
2494 _ (
2495 "Application reported internal error, closing connection.\n"));
2496 return;
2497 }
2498 if (left_unprocessed > to_be_processed)
2499 mhd_panic (mhd_panic_cls,
2500 __FILE__,
2501 __LINE__
2486#ifdef HAVE_MESSAGES 2502#ifdef HAVE_MESSAGES
2487 , _("libmicrohttpd API violation") 2503 , _ ("libmicrohttpd API violation")
2488#else 2504#else
2489 , NULL 2505 , NULL
2490#endif 2506#endif
2491 ); 2507 );
2492 if (0 != left_unprocessed) 2508 if (0 != left_unprocessed)
2493 { 2509 {
2494 instant_retry = MHD_NO; /* client did not process everything */ 2510 instant_retry = MHD_NO; /* client did not process everything */
2495#ifdef HAVE_MESSAGES 2511#ifdef HAVE_MESSAGES
2496 /* client did not process all upload data, complain if 2512 /* client did not process all upload data, complain if
2497 the setup was incorrect, which may prevent us from 2513 the setup was incorrect, which may prevent us from
2498 handling the rest of the request */ 2514 handling the rest of the request */
2499 if ( (0 != (daemon->options & MHD_USE_INTERNAL_POLLING_THREAD)) && 2515 if ( (0 != (daemon->options & MHD_USE_INTERNAL_POLLING_THREAD)) &&
2500 (! connection->suspended) ) 2516 (! connection->suspended) )
2501 MHD_DLOG (daemon, 2517 MHD_DLOG (daemon,
2502 _("WARNING: incomplete upload processing and connection not suspended may result in hung connection.\n")); 2518 _ (
2519 "WARNING: incomplete upload processing and connection not suspended may result in hung connection.\n"));
2503#endif 2520#endif
2504 }
2505 processed_size = to_be_processed - left_unprocessed;
2506 if (connection->have_chunked_upload)
2507 connection->current_chunk_offset += processed_size;
2508 /* dh left "processed" bytes in buffer for next time... */
2509 buffer_head += processed_size;
2510 available -= processed_size;
2511 if (MHD_SIZE_UNKNOWN != connection->remaining_upload_size)
2512 connection->remaining_upload_size -= processed_size;
2513 } 2521 }
2522 processed_size = to_be_processed - left_unprocessed;
2523 if (connection->have_chunked_upload)
2524 connection->current_chunk_offset += processed_size;
2525 /* dh left "processed" bytes in buffer for next time... */
2526 buffer_head += processed_size;
2527 available -= processed_size;
2528 if (MHD_SIZE_UNKNOWN != connection->remaining_upload_size)
2529 connection->remaining_upload_size -= processed_size;
2530 }
2514 while (MHD_YES == instant_retry); 2531 while (MHD_YES == instant_retry);
2515 if ( (available > 0) && 2532 if ( (available > 0) &&
2516 (buffer_head != connection->read_buffer) ) 2533 (buffer_head != connection->read_buffer) )
@@ -2540,7 +2557,7 @@ check_write_done (struct MHD_Connection *connection,
2540 connection->write_buffer_send_offset = 0; 2557 connection->write_buffer_send_offset = 0;
2541 connection->state = next_state; 2558 connection->state = next_state;
2542 MHD_pool_reallocate (connection->pool, 2559 MHD_pool_reallocate (connection->pool,
2543 connection->write_buffer, 2560 connection->write_buffer,
2544 connection->write_buffer_size, 2561 connection->write_buffer_size,
2545 0); 2562 0);
2546 connection->write_buffer = NULL; 2563 connection->write_buffer = NULL;
@@ -2567,28 +2584,29 @@ process_header_line (struct MHD_Connection *connection,
2567 /* line should be normal header line, find colon */ 2584 /* line should be normal header line, find colon */
2568 colon = strchr (line, ':'); 2585 colon = strchr (line, ':');
2569 if (NULL == colon) 2586 if (NULL == colon)
2570 { 2587 {
2571 /* error in header line, die hard */ 2588 /* error in header line, die hard */
2572 CONNECTION_CLOSE_ERROR (connection, 2589 CONNECTION_CLOSE_ERROR (connection,
2573 _("Received malformed line (no colon). Closing connection.\n")); 2590 _ (
2574 return MHD_NO; 2591 "Received malformed line (no colon). Closing connection.\n"));
2575 } 2592 return MHD_NO;
2593 }
2576 if (-1 >= connection->daemon->strict_for_client) 2594 if (-1 >= connection->daemon->strict_for_client)
2577 { 2595 {
2578 /* check for whitespace before colon, which is not allowed 2596 /* check for whitespace before colon, which is not allowed
2579 by RFC 7230 section 3.2.4; we count space ' ' and 2597 by RFC 7230 section 3.2.4; we count space ' ' and
2580 tab '\t', but not '\r\n' as those would have ended the line. */ 2598 tab '\t', but not '\r\n' as those would have ended the line. */
2581 const char *white; 2599 const char *white;
2582 2600
2583 white = strchr (line, ' '); 2601 white = strchr (line, ' ');
2584 if ( (NULL != white) && 2602 if ( (NULL != white) &&
2585 (white < colon) ) 2603 (white < colon) )
2586 return MHD_NO; 2604 return MHD_NO;
2587 white = strchr (line, '\t'); 2605 white = strchr (line, '\t');
2588 if ( (NULL != white) && 2606 if ( (NULL != white) &&
2589 (white < colon) ) 2607 (white < colon) )
2590 return MHD_NO; 2608 return MHD_NO;
2591 } 2609 }
2592 /* zero-terminate header */ 2610 /* zero-terminate header */
2593 colon[0] = '\0'; 2611 colon[0] = '\0';
2594 colon++; /* advance to value */ 2612 colon++; /* advance to value */
@@ -2630,69 +2648,69 @@ process_broken_line (struct MHD_Connection *connection,
2630 last = connection->last; 2648 last = connection->last;
2631 if ( (' ' == line[0]) || 2649 if ( (' ' == line[0]) ||
2632 ('\t' == line[0]) ) 2650 ('\t' == line[0]) )
2633 { 2651 {
2634 /* value was continued on the next line, see 2652 /* value was continued on the next line, see
2635 http://www.jmarshall.com/easy/http/ */ 2653 http://www.jmarshall.com/easy/http/ */
2636 last_len = strlen (last); 2654 last_len = strlen (last);
2637 /* skip whitespace at start of 2nd line */ 2655 /* skip whitespace at start of 2nd line */
2638 tmp = line; 2656 tmp = line;
2639 while ( (' ' == tmp[0]) || 2657 while ( (' ' == tmp[0]) ||
2640 ('\t' == tmp[0]) ) 2658 ('\t' == tmp[0]) )
2641 tmp++; 2659 tmp++;
2642 tmp_len = strlen (tmp); 2660 tmp_len = strlen (tmp);
2643 /* FIXME: we might be able to do this better (faster!), as most 2661 /* FIXME: we might be able to do this better (faster!), as most
2644 likely 'last' and 'line' should already be adjacent in 2662 likely 'last' and 'line' should already be adjacent in
2645 memory; however, doing this right gets tricky if we have a 2663 memory; however, doing this right gets tricky if we have a
2646 value continued over multiple lines (in which case we need to 2664 value continued over multiple lines (in which case we need to
2647 record how often we have done this so we can check for 2665 record how often we have done this so we can check for
2648 adjacency); also, in the case where these are not adjacent 2666 adjacency); also, in the case where these are not adjacent
2649 (not sure how it can happen!), we would want to allocate from 2667 (not sure how it can happen!), we would want to allocate from
2650 the end of the pool, so as to not destroy the read-buffer's 2668 the end of the pool, so as to not destroy the read-buffer's
2651 ability to grow nicely. */ 2669 ability to grow nicely. */
2652 last = MHD_pool_reallocate (connection->pool, 2670 last = MHD_pool_reallocate (connection->pool,
2653 last, 2671 last,
2654 last_len + 1, 2672 last_len + 1,
2655 last_len + tmp_len + 1); 2673 last_len + tmp_len + 1);
2656 if (NULL == last) 2674 if (NULL == last)
2657 {
2658 transmit_error_response (connection,
2659 MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE,
2660 REQUEST_TOO_BIG);
2661 return MHD_NO;
2662 }
2663 memcpy (&last[last_len],
2664 tmp,
2665 tmp_len + 1);
2666 connection->last = last;
2667 return MHD_YES; /* possibly more than 2 lines... */
2668 }
2669 mhd_assert ( (NULL != last) &&
2670 (NULL != connection->colon) );
2671 if (MHD_NO ==
2672 connection_add_header (connection,
2673 last,
2674 strlen (last),
2675 connection->colon,
2676 strlen (connection->colon),
2677 kind))
2678 { 2675 {
2679 transmit_error_response (connection, 2676 transmit_error_response (connection,
2680 MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE, 2677 MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE,
2681 REQUEST_TOO_BIG); 2678 REQUEST_TOO_BIG);
2682 return MHD_NO; 2679 return MHD_NO;
2683 } 2680 }
2681 memcpy (&last[last_len],
2682 tmp,
2683 tmp_len + 1);
2684 connection->last = last;
2685 return MHD_YES; /* possibly more than 2 lines... */
2686 }
2687 mhd_assert ( (NULL != last) &&
2688 (NULL != connection->colon) );
2689 if (MHD_NO ==
2690 connection_add_header (connection,
2691 last,
2692 strlen (last),
2693 connection->colon,
2694 strlen (connection->colon),
2695 kind))
2696 {
2697 transmit_error_response (connection,
2698 MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE,
2699 REQUEST_TOO_BIG);
2700 return MHD_NO;
2701 }
2684 /* we still have the current line to deal with... */ 2702 /* we still have the current line to deal with... */
2685 if (0 != line[0]) 2703 if (0 != line[0])
2704 {
2705 if (MHD_NO == process_header_line (connection,
2706 line))
2686 { 2707 {
2687 if (MHD_NO == process_header_line (connection, 2708 transmit_error_response (connection,
2688 line)) 2709 MHD_HTTP_BAD_REQUEST,
2689 { 2710 REQUEST_MALFORMED);
2690 transmit_error_response (connection, 2711 return MHD_NO;
2691 MHD_HTTP_BAD_REQUEST,
2692 REQUEST_MALFORMED);
2693 return MHD_NO;
2694 }
2695 } 2712 }
2713 }
2696 return MHD_YES; 2714 return MHD_YES;
2697} 2715}
2698 2716
@@ -2715,88 +2733,93 @@ parse_connection_headers (struct MHD_Connection *connection)
2715 parse_cookie_header (connection); 2733 parse_cookie_header (connection);
2716 if ( (1 <= connection->daemon->strict_for_client) && 2734 if ( (1 <= connection->daemon->strict_for_client) &&
2717 (NULL != connection->version) && 2735 (NULL != connection->version) &&
2718 (MHD_str_equal_caseless_(MHD_HTTP_VERSION_1_1, 2736 (MHD_str_equal_caseless_ (MHD_HTTP_VERSION_1_1,
2719 connection->version)) && 2737 connection->version)) &&
2720 (MHD_NO == 2738 (MHD_NO ==
2721 MHD_lookup_connection_value_n (connection, 2739 MHD_lookup_connection_value_n (connection,
2722 MHD_HEADER_KIND, 2740 MHD_HEADER_KIND,
2723 MHD_HTTP_HEADER_HOST, 2741 MHD_HTTP_HEADER_HOST,
2724 MHD_STATICSTR_LEN_(MHD_HTTP_HEADER_HOST), 2742 MHD_STATICSTR_LEN_ (
2743 MHD_HTTP_HEADER_HOST),
2725 NULL, 2744 NULL,
2726 NULL)) ) 2745 NULL)) )
2727 { 2746 {
2728 int iret; 2747 int iret;
2729 2748
2730 /* die, http 1.1 request without host and we are pedantic */ 2749 /* die, http 1.1 request without host and we are pedantic */
2731 connection->state = MHD_CONNECTION_FOOTERS_RECEIVED; 2750 connection->state = MHD_CONNECTION_FOOTERS_RECEIVED;
2732 connection->read_closed = true; 2751 connection->read_closed = true;
2733#ifdef HAVE_MESSAGES 2752#ifdef HAVE_MESSAGES
2734 MHD_DLOG (connection->daemon, 2753 MHD_DLOG (connection->daemon,
2735 _("Received HTTP 1.1 request without `Host' header.\n")); 2754 _ ("Received HTTP 1.1 request without `Host' header.\n"));
2736#endif 2755#endif
2737 mhd_assert (NULL == connection->response); 2756 mhd_assert (NULL == connection->response);
2738 response = 2757 response =
2739 MHD_create_response_from_buffer (MHD_STATICSTR_LEN_ (REQUEST_LACKS_HOST), 2758 MHD_create_response_from_buffer (MHD_STATICSTR_LEN_ (REQUEST_LACKS_HOST),
2740 REQUEST_LACKS_HOST, 2759 REQUEST_LACKS_HOST,
2741 MHD_RESPMEM_PERSISTENT); 2760 MHD_RESPMEM_PERSISTENT);
2742 if (NULL == response) 2761 if (NULL == response)
2743 { 2762 {
2744 /* can't even send a reply, at least close the connection */ 2763 /* can't even send a reply, at least close the connection */
2745 CONNECTION_CLOSE_ERROR (connection, 2764 CONNECTION_CLOSE_ERROR (connection,
2746 _("Closing connection (failed to create response)\n")); 2765 _ (
2747 return; 2766 "Closing connection (failed to create response)\n"));
2748 }
2749 iret = MHD_queue_response (connection,
2750 MHD_HTTP_BAD_REQUEST,
2751 response);
2752 MHD_destroy_response (response);
2753 if (MHD_YES != iret)
2754 {
2755 /* can't even send a reply, at least close the connection */
2756 CONNECTION_CLOSE_ERROR (connection,
2757 _("Closing connection (failed to queue response)\n"));
2758 }
2759 return; 2767 return;
2760 } 2768 }
2769 iret = MHD_queue_response (connection,
2770 MHD_HTTP_BAD_REQUEST,
2771 response);
2772 MHD_destroy_response (response);
2773 if (MHD_YES != iret)
2774 {
2775 /* can't even send a reply, at least close the connection */
2776 CONNECTION_CLOSE_ERROR (connection,
2777 _ (
2778 "Closing connection (failed to queue response)\n"));
2779 }
2780 return;
2781 }
2761 2782
2762 connection->remaining_upload_size = 0; 2783 connection->remaining_upload_size = 0;
2763 if (MHD_NO != MHD_lookup_connection_value_n (connection, 2784 if (MHD_NO != MHD_lookup_connection_value_n (connection,
2764 MHD_HEADER_KIND, 2785 MHD_HEADER_KIND,
2765 MHD_HTTP_HEADER_TRANSFER_ENCODING, 2786 MHD_HTTP_HEADER_TRANSFER_ENCODING,
2766 MHD_STATICSTR_LEN_(MHD_HTTP_HEADER_TRANSFER_ENCODING), 2787 MHD_STATICSTR_LEN_ (
2788 MHD_HTTP_HEADER_TRANSFER_ENCODING),
2767 &enc, 2789 &enc,
2768 NULL)) 2790 NULL))
2769 { 2791 {
2770 connection->remaining_upload_size = MHD_SIZE_UNKNOWN; 2792 connection->remaining_upload_size = MHD_SIZE_UNKNOWN;
2771 if (MHD_str_equal_caseless_(enc, 2793 if (MHD_str_equal_caseless_ (enc,
2772 "chunked")) 2794 "chunked"))
2773 connection->have_chunked_upload = true; 2795 connection->have_chunked_upload = true;
2774 } 2796 }
2775 else 2797 else
2798 {
2799 if (MHD_NO != MHD_lookup_connection_value_n (connection,
2800 MHD_HEADER_KIND,
2801 MHD_HTTP_HEADER_CONTENT_LENGTH,
2802 MHD_STATICSTR_LEN_ (
2803 MHD_HTTP_HEADER_CONTENT_LENGTH),
2804 &clen,
2805 NULL))
2776 { 2806 {
2777 if (MHD_NO != MHD_lookup_connection_value_n (connection, 2807 end = clen + MHD_str_to_uint64_ (clen,
2778 MHD_HEADER_KIND, 2808 &connection->remaining_upload_size);
2779 MHD_HTTP_HEADER_CONTENT_LENGTH, 2809 if ( (clen == end) ||
2780 MHD_STATICSTR_LEN_(MHD_HTTP_HEADER_CONTENT_LENGTH), 2810 ('\0' != *end) )
2781 &clen, 2811 {
2782 NULL)) 2812 connection->remaining_upload_size = 0;
2783 {
2784 end = clen + MHD_str_to_uint64_ (clen,
2785 &connection->remaining_upload_size);
2786 if ( (clen == end) ||
2787 ('\0' != *end) )
2788 {
2789 connection->remaining_upload_size = 0;
2790#ifdef HAVE_MESSAGES 2813#ifdef HAVE_MESSAGES
2791 MHD_DLOG (connection->daemon, 2814 MHD_DLOG (connection->daemon,
2792 "Failed to parse `Content-Length' header. Closing connection.\n"); 2815 "Failed to parse `Content-Length' header. Closing connection.\n");
2793#endif 2816#endif
2794 CONNECTION_CLOSE_ERROR (connection, 2817 CONNECTION_CLOSE_ERROR (connection,
2795 NULL); 2818 NULL);
2796 return; 2819 return;
2797 } 2820 }
2798 }
2799 } 2821 }
2822 }
2800} 2823}
2801 2824
2802 2825
@@ -2818,7 +2841,7 @@ MHD_update_last_activity_ (struct MHD_Connection *connection)
2818 if (connection->suspended) 2841 if (connection->suspended)
2819 return; /* no activity on suspended connections */ 2842 return; /* no activity on suspended connections */
2820 2843
2821 connection->last_activity = MHD_monotonic_sec_counter(); 2844 connection->last_activity = MHD_monotonic_sec_counter ();
2822 if (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) 2845 if (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION))
2823 return; /* each connection has personal timeout */ 2846 return; /* each connection has personal timeout */
2824 2847
@@ -2829,11 +2852,11 @@ MHD_update_last_activity_ (struct MHD_Connection *connection)
2829#endif 2852#endif
2830 /* move connection to head of timeout list (by remove + add operation) */ 2853 /* move connection to head of timeout list (by remove + add operation) */
2831 XDLL_remove (daemon->normal_timeout_head, 2854 XDLL_remove (daemon->normal_timeout_head,
2832 daemon->normal_timeout_tail, 2855 daemon->normal_timeout_tail,
2833 connection); 2856 connection);
2834 XDLL_insert (daemon->normal_timeout_head, 2857 XDLL_insert (daemon->normal_timeout_head,
2835 daemon->normal_timeout_tail, 2858 daemon->normal_timeout_tail,
2836 connection); 2859 connection);
2837#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 2860#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
2838 MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex); 2861 MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
2839#endif 2862#endif
@@ -2856,13 +2879,13 @@ MHD_connection_handle_read (struct MHD_Connection *connection)
2856 return; 2879 return;
2857#ifdef HTTPS_SUPPORT 2880#ifdef HTTPS_SUPPORT
2858 if (MHD_TLS_CONN_NO_TLS != connection->tls_state) 2881 if (MHD_TLS_CONN_NO_TLS != connection->tls_state)
2859 { /* HTTPS connection. */ 2882 { /* HTTPS connection. */
2860 if (MHD_TLS_CONN_CONNECTED > connection->tls_state) 2883 if (MHD_TLS_CONN_CONNECTED > connection->tls_state)
2861 { 2884 {
2862 if (!MHD_run_tls_handshake_ (connection)) 2885 if (! MHD_run_tls_handshake_ (connection))
2863 return; 2886 return;
2864 }
2865 } 2887 }
2888 }
2866#endif /* HTTPS_SUPPORT */ 2889#endif /* HTTPS_SUPPORT */
2867 2890
2868 /* make sure "read" has a reasonable number of bytes 2891 /* make sure "read" has a reasonable number of bytes
@@ -2870,82 +2893,85 @@ MHD_connection_handle_read (struct MHD_Connection *connection)
2870 if (connection->read_buffer_offset + connection->daemon->pool_increment > 2893 if (connection->read_buffer_offset + connection->daemon->pool_increment >
2871 connection->read_buffer_size) 2894 connection->read_buffer_size)
2872 try_grow_read_buffer (connection, 2895 try_grow_read_buffer (connection,
2873 (connection->read_buffer_size == connection->read_buffer_offset)); 2896 (connection->read_buffer_size ==
2897 connection->read_buffer_offset));
2874 2898
2875 if (connection->read_buffer_size == connection->read_buffer_offset) 2899 if (connection->read_buffer_size == connection->read_buffer_offset)
2876 return; /* No space for receiving data. */ 2900 return; /* No space for receiving data. */
2877 bytes_read = connection->recv_cls (connection, 2901 bytes_read = connection->recv_cls (connection,
2878 &connection->read_buffer 2902 &connection->read_buffer
2879 [connection->read_buffer_offset], 2903 [connection->read_buffer_offset],
2880 connection->read_buffer_size - 2904 connection->read_buffer_size
2881 connection->read_buffer_offset); 2905 - connection->read_buffer_offset);
2882 if (bytes_read < 0) 2906 if (bytes_read < 0)
2907 {
2908 if (MHD_ERR_AGAIN_ == bytes_read)
2909 return; /* No new data to process. */
2910 if (MHD_ERR_CONNRESET_ == bytes_read)
2883 { 2911 {
2884 if (MHD_ERR_AGAIN_ == bytes_read)
2885 return; /* No new data to process. */
2886 if (MHD_ERR_CONNRESET_ == bytes_read)
2887 {
2888 CONNECTION_CLOSE_ERROR (connection,
2889 (MHD_CONNECTION_INIT == connection->state) ?
2890 NULL :
2891 _("Socket disconnected while reading request.\n"));
2892 return;
2893 }
2894 CONNECTION_CLOSE_ERROR (connection, 2912 CONNECTION_CLOSE_ERROR (connection,
2895 (MHD_CONNECTION_INIT == connection->state) ? 2913 (MHD_CONNECTION_INIT == connection->state) ?
2896 NULL : 2914 NULL :
2897 _("Connection socket is closed due to error when reading request.\n")); 2915 _ (
2916 "Socket disconnected while reading request.\n"));
2898 return; 2917 return;
2899 } 2918 }
2919 CONNECTION_CLOSE_ERROR (connection,
2920 (MHD_CONNECTION_INIT == connection->state) ?
2921 NULL :
2922 _ (
2923 "Connection socket is closed due to error when reading request.\n"));
2924 return;
2925 }
2900 2926
2901 if (0 == bytes_read) 2927 if (0 == bytes_read)
2902 { /* Remote side closed connection. */ 2928 { /* Remote side closed connection. */
2903 connection->read_closed = true; 2929 connection->read_closed = true;
2904 MHD_connection_close_ (connection, 2930 MHD_connection_close_ (connection,
2905 MHD_REQUEST_TERMINATED_CLIENT_ABORT); 2931 MHD_REQUEST_TERMINATED_CLIENT_ABORT);
2906 return; 2932 return;
2907 } 2933 }
2908 connection->read_buffer_offset += bytes_read; 2934 connection->read_buffer_offset += bytes_read;
2909 MHD_update_last_activity_ (connection); 2935 MHD_update_last_activity_ (connection);
2910#if DEBUG_STATES 2936#if DEBUG_STATES
2911 MHD_DLOG (connection->daemon, 2937 MHD_DLOG (connection->daemon,
2912 _("In function %s handling connection at state: %s\n"), 2938 _ ("In function %s handling connection at state: %s\n"),
2913 __FUNCTION__, 2939 __FUNCTION__,
2914 MHD_state_to_string (connection->state)); 2940 MHD_state_to_string (connection->state));
2915#endif 2941#endif
2916 switch (connection->state) 2942 switch (connection->state)
2943 {
2944 case MHD_CONNECTION_INIT:
2945 case MHD_CONNECTION_URL_RECEIVED:
2946 case MHD_CONNECTION_HEADER_PART_RECEIVED:
2947 case MHD_CONNECTION_HEADERS_RECEIVED:
2948 case MHD_CONNECTION_HEADERS_PROCESSED:
2949 case MHD_CONNECTION_CONTINUE_SENDING:
2950 case MHD_CONNECTION_CONTINUE_SENT:
2951 case MHD_CONNECTION_BODY_RECEIVED:
2952 case MHD_CONNECTION_FOOTER_PART_RECEIVED:
2953 /* nothing to do but default action */
2954 if (connection->read_closed)
2917 { 2955 {
2918 case MHD_CONNECTION_INIT: 2956 MHD_connection_close_ (connection,
2919 case MHD_CONNECTION_URL_RECEIVED: 2957 MHD_REQUEST_TERMINATED_READ_ERROR);
2920 case MHD_CONNECTION_HEADER_PART_RECEIVED: 2958 }
2921 case MHD_CONNECTION_HEADERS_RECEIVED: 2959 return;
2922 case MHD_CONNECTION_HEADERS_PROCESSED: 2960 case MHD_CONNECTION_CLOSED:
2923 case MHD_CONNECTION_CONTINUE_SENDING: 2961 return;
2924 case MHD_CONNECTION_CONTINUE_SENT:
2925 case MHD_CONNECTION_BODY_RECEIVED:
2926 case MHD_CONNECTION_FOOTER_PART_RECEIVED:
2927 /* nothing to do but default action */
2928 if (connection->read_closed)
2929 {
2930 MHD_connection_close_ (connection,
2931 MHD_REQUEST_TERMINATED_READ_ERROR);
2932 }
2933 return;
2934 case MHD_CONNECTION_CLOSED:
2935 return;
2936#ifdef UPGRADE_SUPPORT 2962#ifdef UPGRADE_SUPPORT
2937 case MHD_CONNECTION_UPGRADE: 2963 case MHD_CONNECTION_UPGRADE:
2938 mhd_assert (0); 2964 mhd_assert (0);
2939 return; 2965 return;
2940#endif /* UPGRADE_SUPPORT */ 2966#endif /* UPGRADE_SUPPORT */
2941 default: 2967 default:
2942 /* shrink read buffer to how much is actually used */ 2968 /* shrink read buffer to how much is actually used */
2943 MHD_pool_reallocate (connection->pool, 2969 MHD_pool_reallocate (connection->pool,
2944 connection->read_buffer, 2970 connection->read_buffer,
2945 connection->read_buffer_size + 1, 2971 connection->read_buffer_size + 1,
2946 connection->read_buffer_offset); 2972 connection->read_buffer_offset);
2947 break; 2973 break;
2948 } 2974 }
2949 return; 2975 return;
2950} 2976}
2951 2977
@@ -2966,258 +2992,261 @@ MHD_connection_handle_write (struct MHD_Connection *connection)
2966 2992
2967#ifdef HTTPS_SUPPORT 2993#ifdef HTTPS_SUPPORT
2968 if (MHD_TLS_CONN_NO_TLS != connection->tls_state) 2994 if (MHD_TLS_CONN_NO_TLS != connection->tls_state)
2969 { /* HTTPS connection. */ 2995 { /* HTTPS connection. */
2970 if (MHD_TLS_CONN_CONNECTED > connection->tls_state) 2996 if (MHD_TLS_CONN_CONNECTED > connection->tls_state)
2971 { 2997 {
2972 if (!MHD_run_tls_handshake_ (connection)) 2998 if (! MHD_run_tls_handshake_ (connection))
2973 return; 2999 return;
2974 }
2975 } 3000 }
3001 }
2976#endif /* HTTPS_SUPPORT */ 3002#endif /* HTTPS_SUPPORT */
2977 3003
2978#if DEBUG_STATES 3004#if DEBUG_STATES
2979 MHD_DLOG (connection->daemon, 3005 MHD_DLOG (connection->daemon,
2980 _("In function %s handling connection at state: %s\n"), 3006 _ ("In function %s handling connection at state: %s\n"),
2981 __FUNCTION__, 3007 __FUNCTION__,
2982 MHD_state_to_string (connection->state)); 3008 MHD_state_to_string (connection->state));
2983#endif 3009#endif
2984 switch (connection->state) 3010 switch (connection->state)
3011 {
3012 case MHD_CONNECTION_INIT:
3013 case MHD_CONNECTION_URL_RECEIVED:
3014 case MHD_CONNECTION_HEADER_PART_RECEIVED:
3015 case MHD_CONNECTION_HEADERS_RECEIVED:
3016 mhd_assert (0);
3017 return;
3018 case MHD_CONNECTION_HEADERS_PROCESSED:
3019 return;
3020 case MHD_CONNECTION_CONTINUE_SENDING:
3021 ret = MHD_send_on_connection_ (connection,
3022 &HTTP_100_CONTINUE
3023 [connection->continue_message_write_offset],
3024 MHD_STATICSTR_LEN_ (HTTP_100_CONTINUE)
3025 - connection->continue_message_write_offset,
3026 MHD_SSO_NO_CORK);
3027 if (ret < 0)
2985 { 3028 {
2986 case MHD_CONNECTION_INIT: 3029 if (MHD_ERR_AGAIN_ == ret)
2987 case MHD_CONNECTION_URL_RECEIVED: 3030 return;
2988 case MHD_CONNECTION_HEADER_PART_RECEIVED:
2989 case MHD_CONNECTION_HEADERS_RECEIVED:
2990 mhd_assert (0);
2991 return;
2992 case MHD_CONNECTION_HEADERS_PROCESSED:
2993 return;
2994 case MHD_CONNECTION_CONTINUE_SENDING:
2995 ret = MHD_send_on_connection_ (connection,
2996 &HTTP_100_CONTINUE
2997 [connection->continue_message_write_offset],
2998 MHD_STATICSTR_LEN_ (HTTP_100_CONTINUE) -
2999 connection->continue_message_write_offset,
3000 MHD_SSO_NO_CORK);
3001 if (ret < 0)
3002 {
3003 if (MHD_ERR_AGAIN_ == ret)
3004 return;
3005#ifdef HAVE_MESSAGES 3031#ifdef HAVE_MESSAGES
3006 MHD_DLOG (connection->daemon, 3032 MHD_DLOG (connection->daemon,
3007 _("Failed to send data in request for %s.\n"), 3033 _ ("Failed to send data in request for %s.\n"),
3008 connection->url); 3034 connection->url);
3009#endif 3035#endif
3010 CONNECTION_CLOSE_ERROR (connection, 3036 CONNECTION_CLOSE_ERROR (connection,
3011 NULL); 3037 NULL);
3012 return; 3038 return;
3013 } 3039 }
3014#if DEBUG_SEND_DATA 3040#if DEBUG_SEND_DATA
3015 fprintf (stderr, 3041 fprintf (stderr,
3016 _("Sent 100 continue response: `%.*s'\n"), 3042 _ ("Sent 100 continue response: `%.*s'\n"),
3017 (int) ret, 3043 (int) ret,
3018 &HTTP_100_CONTINUE[connection->continue_message_write_offset]); 3044 &HTTP_100_CONTINUE[connection->continue_message_write_offset]);
3019#endif 3045#endif
3020 connection->continue_message_write_offset += ret; 3046 connection->continue_message_write_offset += ret;
3021 MHD_update_last_activity_ (connection); 3047 MHD_update_last_activity_ (connection);
3022 return; 3048 return;
3023 case MHD_CONNECTION_CONTINUE_SENT: 3049 case MHD_CONNECTION_CONTINUE_SENT:
3024 case MHD_CONNECTION_BODY_RECEIVED: 3050 case MHD_CONNECTION_BODY_RECEIVED:
3025 case MHD_CONNECTION_FOOTER_PART_RECEIVED: 3051 case MHD_CONNECTION_FOOTER_PART_RECEIVED:
3026 case MHD_CONNECTION_FOOTERS_RECEIVED: 3052 case MHD_CONNECTION_FOOTERS_RECEIVED:
3027 mhd_assert (0); 3053 mhd_assert (0);
3028 return; 3054 return;
3029 case MHD_CONNECTION_HEADERS_SENDING: 3055 case MHD_CONNECTION_HEADERS_SENDING:
3030 { 3056 {
3031 const size_t wb_ready = connection->write_buffer_append_offset - 3057 const size_t wb_ready = connection->write_buffer_append_offset
3032 connection->write_buffer_send_offset; 3058 - connection->write_buffer_send_offset;
3033 3059
3034 /* if the response body is not available, we use MHD_send_on_connection_() */ 3060 /* if the response body is not available, we use MHD_send_on_connection_() */
3035 if (NULL != connection->response->crc) 3061 if (NULL != connection->response->crc)
3036 { 3062 {
3037 ret = MHD_send_on_connection_ (connection, 3063 ret = MHD_send_on_connection_ (connection,
3038 &connection->write_buffer 3064 &connection->write_buffer
3039 [connection->write_buffer_send_offset], 3065 [connection->write_buffer_send_offset],
3040 wb_ready, 3066 wb_ready,
3041 MHD_SSO_MAY_CORK); 3067 MHD_SSO_MAY_CORK);
3042 } 3068 }
3043 else 3069 else
3044 { 3070 {
3045 ret = MHD_send_on_connection2_ (connection, 3071 ret = MHD_send_on_connection2_ (connection,
3046 &connection->write_buffer 3072 &connection->write_buffer
3047 [connection->write_buffer_send_offset], 3073 [connection->write_buffer_send_offset],
3048 wb_ready, 3074 wb_ready,
3049 connection->response->data, 3075 connection->response->data,
3050 connection->response->data_buffer_size); 3076 connection->response->data_buffer_size);
3051 } 3077 }
3052 3078
3053 if (ret < 0) 3079 if (ret < 0)
3054 { 3080 {
3055 if (MHD_ERR_AGAIN_ == ret) 3081 if (MHD_ERR_AGAIN_ == ret)
3056 return;
3057 CONNECTION_CLOSE_ERROR (connection,
3058 _("Connection was closed while sending response headers.\n"));
3059 return;
3060 }
3061 if (ret > wb_ready)
3062 {
3063 mhd_assert (NULL == connection->repsonse->crc);
3064 /* We sent not just header data but also some response data,
3065 update both offsets! */
3066 connection->write_buffer_send_offset += wb_ready;
3067 ret -= wb_ready;
3068 connection->response_write_position += ret;
3069 }
3070 else
3071 connection->write_buffer_send_offset += ret;
3072 MHD_update_last_activity_ (connection);
3073 if (MHD_CONNECTION_HEADERS_SENDING != connection->state)
3074 return; 3082 return;
3075 check_write_done (connection, 3083 CONNECTION_CLOSE_ERROR (connection,
3076 MHD_CONNECTION_HEADERS_SENT); 3084 _ (
3085 "Connection was closed while sending response headers.\n"));
3077 return; 3086 return;
3078 } 3087 }
3079 case MHD_CONNECTION_HEADERS_SENT: 3088 if (ret > wb_ready)
3089 {
3090 mhd_assert (NULL == connection->repsonse->crc);
3091 /* We sent not just header data but also some response data,
3092 update both offsets! */
3093 connection->write_buffer_send_offset += wb_ready;
3094 ret -= wb_ready;
3095 connection->response_write_position += ret;
3096 }
3097 else
3098 connection->write_buffer_send_offset += ret;
3099 MHD_update_last_activity_ (connection);
3100 if (MHD_CONNECTION_HEADERS_SENDING != connection->state)
3101 return;
3102 check_write_done (connection,
3103 MHD_CONNECTION_HEADERS_SENT);
3080 return; 3104 return;
3081 case MHD_CONNECTION_NORMAL_BODY_READY: 3105 }
3082 response = connection->response; 3106 case MHD_CONNECTION_HEADERS_SENT:
3083 if (connection->response_write_position < 3107 return;
3084 connection->response->total_size) 3108 case MHD_CONNECTION_NORMAL_BODY_READY:
3085 { 3109 response = connection->response;
3086 uint64_t data_write_offset; 3110 if (connection->response_write_position <
3111 connection->response->total_size)
3112 {
3113 uint64_t data_write_offset;
3087 3114
3088#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 3115#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
3089 if (NULL != response->crc) 3116 if (NULL != response->crc)
3090 MHD_mutex_lock_chk_ (&response->mutex); 3117 MHD_mutex_lock_chk_ (&response->mutex);
3091#endif 3118#endif
3092 if (MHD_YES != try_ready_normal_body (connection)) 3119 if (MHD_YES != try_ready_normal_body (connection))
3093 { 3120 {
3094 /* mutex was already unlocked by try_ready_normal_body */ 3121 /* mutex was already unlocked by try_ready_normal_body */
3095 return; 3122 return;
3096 } 3123 }
3097#if defined(_MHD_HAVE_SENDFILE) 3124#if defined(_MHD_HAVE_SENDFILE)
3098 if (MHD_resp_sender_sendfile == connection->resp_sender) 3125 if (MHD_resp_sender_sendfile == connection->resp_sender)
3099 { 3126 {
3100 ret = MHD_send_sendfile_ (connection); 3127 ret = MHD_send_sendfile_ (connection);
3101 } 3128 }
3102 else 3129 else
3103#else /* ! _MHD_HAVE_SENDFILE */ 3130#else /* ! _MHD_HAVE_SENDFILE */
3104 if (1) 3131 if (1)
3105#endif /* ! _MHD_HAVE_SENDFILE */ 3132#endif /* ! _MHD_HAVE_SENDFILE */
3106 { 3133 {
3107 data_write_offset = connection->response_write_position 3134 data_write_offset = connection->response_write_position
3108 - response->data_start; 3135 - response->data_start;
3109 if (data_write_offset > (uint64_t)SIZE_MAX) 3136 if (data_write_offset > (uint64_t) SIZE_MAX)
3110 MHD_PANIC (_("Data offset exceeds limit")); 3137 MHD_PANIC (_ ("Data offset exceeds limit"));
3111 ret = MHD_send_on_connection_ (connection, 3138 ret = MHD_send_on_connection_ (connection,
3112 &response->data 3139 &response->data
3113 [(size_t)data_write_offset], 3140 [(size_t) data_write_offset],
3114 response->data_size - 3141 response->data_size
3115 (size_t)data_write_offset, 3142 - (size_t) data_write_offset,
3116 MHD_SSO_NO_CORK); 3143 MHD_SSO_NO_CORK);
3117#if DEBUG_SEND_DATA 3144#if DEBUG_SEND_DATA
3118 if (ret > 0) 3145 if (ret > 0)
3119 fprintf (stderr, 3146 fprintf (stderr,
3120 _("Sent %d-byte DATA response: `%.*s'\n"), 3147 _ ("Sent %d-byte DATA response: `%.*s'\n"),
3121 (int) ret, 3148 (int) ret,
3122 (int) ret, 3149 (int) ret,
3123 &response->data[connection->response_write_position - 3150 &response->data[connection->response_write_position
3124 response->data_start]); 3151 - response->data_start]);
3125#endif 3152#endif
3126 } 3153 }
3127#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 3154#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
3128 if (NULL != response->crc) 3155 if (NULL != response->crc)
3129 MHD_mutex_unlock_chk_ (&response->mutex); 3156 MHD_mutex_unlock_chk_ (&response->mutex);
3130#endif
3131 if (ret < 0)
3132 {
3133 if (MHD_ERR_AGAIN_ == ret)
3134 return;
3135#ifdef HAVE_MESSAGES
3136 MHD_DLOG (connection->daemon,
3137 _("Failed to send data in request for `%s'.\n"),
3138 connection->url);
3139#endif 3157#endif
3140 CONNECTION_CLOSE_ERROR (connection,
3141 NULL);
3142 return;
3143 }
3144 connection->response_write_position += ret;
3145 MHD_update_last_activity_ (connection);
3146 }
3147 if (connection->response_write_position ==
3148 connection->response->total_size)
3149 connection->state = MHD_CONNECTION_FOOTERS_SENT; /* have no footers */
3150 return;
3151 case MHD_CONNECTION_NORMAL_BODY_UNREADY:
3152 mhd_assert (0);
3153 return;
3154 case MHD_CONNECTION_CHUNKED_BODY_READY:
3155 ret = MHD_send_on_connection_ (connection,
3156 &connection->write_buffer
3157 [connection->write_buffer_send_offset],
3158 connection->write_buffer_append_offset -
3159 connection->write_buffer_send_offset,
3160 MHD_SSO_NO_CORK);
3161 if (ret < 0) 3158 if (ret < 0)
3162 { 3159 {
3163 if (MHD_ERR_AGAIN_ == ret) 3160 if (MHD_ERR_AGAIN_ == ret)
3164 return;
3165 CONNECTION_CLOSE_ERROR (connection,
3166 _("Connection was closed while sending response body.\n"));
3167 return; 3161 return;
3168 } 3162#ifdef HAVE_MESSAGES
3169 connection->write_buffer_send_offset += ret; 3163 MHD_DLOG (connection->daemon,
3164 _ ("Failed to send data in request for `%s'.\n"),
3165 connection->url);
3166#endif
3167 CONNECTION_CLOSE_ERROR (connection,
3168 NULL);
3169 return;
3170 }
3171 connection->response_write_position += ret;
3170 MHD_update_last_activity_ (connection); 3172 MHD_update_last_activity_ (connection);
3171 if (MHD_CONNECTION_CHUNKED_BODY_READY != connection->state) 3173 }
3174 if (connection->response_write_position ==
3175 connection->response->total_size)
3176 connection->state = MHD_CONNECTION_FOOTERS_SENT; /* have no footers */
3177 return;
3178 case MHD_CONNECTION_NORMAL_BODY_UNREADY:
3179 mhd_assert (0);
3180 return;
3181 case MHD_CONNECTION_CHUNKED_BODY_READY:
3182 ret = MHD_send_on_connection_ (connection,
3183 &connection->write_buffer
3184 [connection->write_buffer_send_offset],
3185 connection->write_buffer_append_offset
3186 - connection->write_buffer_send_offset,
3187 MHD_SSO_NO_CORK);
3188 if (ret < 0)
3189 {
3190 if (MHD_ERR_AGAIN_ == ret)
3172 return; 3191 return;
3173 check_write_done (connection, 3192 CONNECTION_CLOSE_ERROR (connection,
3174 (connection->response->total_size == 3193 _ (
3175 connection->response_write_position) ? 3194 "Connection was closed while sending response body.\n"));
3176 MHD_CONNECTION_BODY_SENT :
3177 MHD_CONNECTION_CHUNKED_BODY_UNREADY);
3178 return; 3195 return;
3179 case MHD_CONNECTION_CHUNKED_BODY_UNREADY: 3196 }
3180 case MHD_CONNECTION_BODY_SENT: 3197 connection->write_buffer_send_offset += ret;
3181 mhd_assert (0); 3198 MHD_update_last_activity_ (connection);
3199 if (MHD_CONNECTION_CHUNKED_BODY_READY != connection->state)
3182 return; 3200 return;
3183 case MHD_CONNECTION_FOOTERS_SENDING: 3201 check_write_done (connection,
3184 ret = MHD_send_on_connection_ (connection, 3202 (connection->response->total_size ==
3185 &connection->write_buffer 3203 connection->response_write_position) ?
3186 [connection->write_buffer_send_offset], 3204 MHD_CONNECTION_BODY_SENT :
3187 connection->write_buffer_append_offset - 3205 MHD_CONNECTION_CHUNKED_BODY_UNREADY);
3188 connection->write_buffer_send_offset, 3206 return;
3189 MHD_SSO_HDR_CORK); 3207 case MHD_CONNECTION_CHUNKED_BODY_UNREADY:
3190 if (ret < 0) 3208 case MHD_CONNECTION_BODY_SENT:
3191 { 3209 mhd_assert (0);
3192 if (MHD_ERR_AGAIN_ == ret) 3210 return;
3193 return; 3211 case MHD_CONNECTION_FOOTERS_SENDING:
3194 CONNECTION_CLOSE_ERROR (connection, 3212 ret = MHD_send_on_connection_ (connection,
3195 _("Connection was closed while sending response body.\n")); 3213 &connection->write_buffer
3196 return; 3214 [connection->write_buffer_send_offset],
3197 } 3215 connection->write_buffer_append_offset
3198 connection->write_buffer_send_offset += ret; 3216 - connection->write_buffer_send_offset,
3199 MHD_update_last_activity_ (connection); 3217 MHD_SSO_HDR_CORK);
3200 if (MHD_CONNECTION_FOOTERS_SENDING != connection->state) 3218 if (ret < 0)
3219 {
3220 if (MHD_ERR_AGAIN_ == ret)
3201 return; 3221 return;
3202 check_write_done (connection, 3222 CONNECTION_CLOSE_ERROR (connection,
3203 MHD_CONNECTION_FOOTERS_SENT); 3223 _ (
3204 return; 3224 "Connection was closed while sending response body.\n"));
3205 case MHD_CONNECTION_FOOTERS_SENT:
3206 mhd_assert (0);
3207 return; 3225 return;
3208 case MHD_CONNECTION_CLOSED: 3226 }
3227 connection->write_buffer_send_offset += ret;
3228 MHD_update_last_activity_ (connection);
3229 if (MHD_CONNECTION_FOOTERS_SENDING != connection->state)
3209 return; 3230 return;
3231 check_write_done (connection,
3232 MHD_CONNECTION_FOOTERS_SENT);
3233 return;
3234 case MHD_CONNECTION_FOOTERS_SENT:
3235 mhd_assert (0);
3236 return;
3237 case MHD_CONNECTION_CLOSED:
3238 return;
3210#ifdef UPGRADE_SUPPORT 3239#ifdef UPGRADE_SUPPORT
3211 case MHD_CONNECTION_UPGRADE: 3240 case MHD_CONNECTION_UPGRADE:
3212 mhd_assert (0); 3241 mhd_assert (0);
3213 return; 3242 return;
3214#endif /* UPGRADE_SUPPORT */ 3243#endif /* UPGRADE_SUPPORT */
3215 default: 3244 default:
3216 mhd_assert (0); 3245 mhd_assert (0);
3217 CONNECTION_CLOSE_ERROR (connection, 3246 CONNECTION_CLOSE_ERROR (connection,
3218 _("Internal error\n")); 3247 _ ("Internal error\n"));
3219 break; 3248 break;
3220 } 3249 }
3221 return; 3250 return;
3222} 3251}
3223 3252
@@ -3239,59 +3268,60 @@ cleanup_connection (struct MHD_Connection *connection)
3239 return; /* Prevent double cleanup. */ 3268 return; /* Prevent double cleanup. */
3240 connection->in_cleanup = true; 3269 connection->in_cleanup = true;
3241 if (NULL != connection->response) 3270 if (NULL != connection->response)
3242 { 3271 {
3243 MHD_destroy_response (connection->response); 3272 MHD_destroy_response (connection->response);
3244 connection->response = NULL; 3273 connection->response = NULL;
3245 } 3274 }
3246#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 3275#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
3247 MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex); 3276 MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
3248#endif 3277#endif
3249 if (connection->suspended) 3278 if (connection->suspended)
3250 { 3279 {
3251 DLL_remove (daemon->suspended_connections_head, 3280 DLL_remove (daemon->suspended_connections_head,
3252 daemon->suspended_connections_tail, 3281 daemon->suspended_connections_tail,
3253 connection); 3282 connection);
3254 connection->suspended = false; 3283 connection->suspended = false;
3255 } 3284 }
3256 else 3285 else
3286 {
3287 if (0 == (daemon->options & MHD_USE_THREAD_PER_CONNECTION))
3257 { 3288 {
3258 if (0 == (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) 3289 if (connection->connection_timeout == daemon->connection_timeout)
3259 { 3290 XDLL_remove (daemon->normal_timeout_head,
3260 if (connection->connection_timeout == daemon->connection_timeout) 3291 daemon->normal_timeout_tail,
3261 XDLL_remove (daemon->normal_timeout_head, 3292 connection);
3262 daemon->normal_timeout_tail, 3293 else
3263 connection); 3294 XDLL_remove (daemon->manual_timeout_head,
3264 else 3295 daemon->manual_timeout_tail,
3265 XDLL_remove (daemon->manual_timeout_head, 3296 connection);
3266 daemon->manual_timeout_tail,
3267 connection);
3268 }
3269 DLL_remove (daemon->connections_head,
3270 daemon->connections_tail,
3271 connection);
3272 } 3297 }
3298 DLL_remove (daemon->connections_head,
3299 daemon->connections_tail,
3300 connection);
3301 }
3273 DLL_insert (daemon->cleanup_head, 3302 DLL_insert (daemon->cleanup_head,
3274 daemon->cleanup_tail, 3303 daemon->cleanup_tail,
3275 connection); 3304 connection);
3276 connection->resuming = false; 3305 connection->resuming = false;
3277 connection->in_idle = false; 3306 connection->in_idle = false;
3278#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 3307#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
3279 MHD_mutex_unlock_chk_(&daemon->cleanup_connection_mutex); 3308 MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
3280#endif 3309#endif
3281 if (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) 3310 if (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION))
3311 {
3312 /* if we were at the connection limit before and are in
3313 thread-per-connection mode, signal the main thread
3314 to resume accepting connections */
3315 if ( (MHD_ITC_IS_VALID_ (daemon->itc)) &&
3316 (! MHD_itc_activate_ (daemon->itc, "c")) )
3282 { 3317 {
3283 /* if we were at the connection limit before and are in
3284 thread-per-connection mode, signal the main thread
3285 to resume accepting connections */
3286 if ( (MHD_ITC_IS_VALID_ (daemon->itc)) &&
3287 (! MHD_itc_activate_ (daemon->itc, "c")) )
3288 {
3289#ifdef HAVE_MESSAGES 3318#ifdef HAVE_MESSAGES
3290 MHD_DLOG (daemon, 3319 MHD_DLOG (daemon,
3291 _("Failed to signal end of connection via inter-thread communication channel")); 3320 _ (
3321 "Failed to signal end of connection via inter-thread communication channel"));
3292#endif 3322#endif
3293 }
3294 } 3323 }
3324 }
3295} 3325}
3296 3326
3297 3327
@@ -3315,471 +3345,475 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
3315 3345
3316 connection->in_idle = true; 3346 connection->in_idle = true;
3317 while (! connection->suspended) 3347 while (! connection->suspended)
3318 { 3348 {
3319#ifdef HTTPS_SUPPORT 3349#ifdef HTTPS_SUPPORT
3320 if (MHD_TLS_CONN_NO_TLS != connection->tls_state) 3350 if (MHD_TLS_CONN_NO_TLS != connection->tls_state)
3321 { /* HTTPS connection. */ 3351 { /* HTTPS connection. */
3322 if ((MHD_TLS_CONN_INIT <= connection->tls_state) && 3352 if ((MHD_TLS_CONN_INIT <= connection->tls_state) &&
3323 (MHD_TLS_CONN_CONNECTED > connection->tls_state)) 3353 (MHD_TLS_CONN_CONNECTED > connection->tls_state))
3324 break; 3354 break;
3325 } 3355 }
3326#endif /* HTTPS_SUPPORT */ 3356#endif /* HTTPS_SUPPORT */
3327#if DEBUG_STATES 3357#if DEBUG_STATES
3328 MHD_DLOG (daemon, 3358 MHD_DLOG (daemon,
3329 _("In function %s handling connection at state: %s\n"), 3359 _ ("In function %s handling connection at state: %s\n"),
3330 __FUNCTION__, 3360 __FUNCTION__,
3331 MHD_state_to_string (connection->state)); 3361 MHD_state_to_string (connection->state));
3332#endif 3362#endif
3333 switch (connection->state) 3363 switch (connection->state)
3364 {
3365 case MHD_CONNECTION_INIT:
3366 line = get_next_header_line (connection,
3367 &line_len);
3368 /* Check for empty string, as we might want
3369 to tolerate 'spurious' empty lines; also
3370 NULL means we didn't get a full line yet;
3371 line is not 0-terminated here. */
3372 if ( (NULL == line) ||
3373 (0 == line[0]) )
3374 {
3375 if (MHD_CONNECTION_INIT != connection->state)
3376 continue;
3377 if (connection->read_closed)
3334 { 3378 {
3335 case MHD_CONNECTION_INIT: 3379 CONNECTION_CLOSE_ERROR (connection,
3336 line = get_next_header_line (connection, 3380 NULL);
3337 &line_len);
3338 /* Check for empty string, as we might want
3339 to tolerate 'spurious' empty lines; also
3340 NULL means we didn't get a full line yet;
3341 line is not 0-terminated here. */
3342 if ( (NULL == line) ||
3343 (0 == line[0]) )
3344 {
3345 if (MHD_CONNECTION_INIT != connection->state)
3346 continue;
3347 if (connection->read_closed)
3348 {
3349 CONNECTION_CLOSE_ERROR (connection,
3350 NULL);
3351 continue;
3352 }
3353 break;
3354 }
3355 if (MHD_NO == parse_initial_message_line (connection,
3356 line,
3357 line_len))
3358 CONNECTION_CLOSE_ERROR (connection,
3359 NULL);
3360 else
3361 connection->state = MHD_CONNECTION_URL_RECEIVED;
3362 continue; 3381 continue;
3363 case MHD_CONNECTION_URL_RECEIVED: 3382 }
3364 line = get_next_header_line (connection, 3383 break;
3365 NULL); 3384 }
3366 if (NULL == line) 3385 if (MHD_NO == parse_initial_message_line (connection,
3367 { 3386 line,
3368 if (MHD_CONNECTION_URL_RECEIVED != connection->state) 3387 line_len))
3369 continue; 3388 CONNECTION_CLOSE_ERROR (connection,
3370 if (connection->read_closed) 3389 NULL);
3371 { 3390 else
3372 CONNECTION_CLOSE_ERROR (connection, 3391 connection->state = MHD_CONNECTION_URL_RECEIVED;
3373 NULL); 3392 continue;
3374 continue; 3393 case MHD_CONNECTION_URL_RECEIVED:
3375 } 3394 line = get_next_header_line (connection,
3376 break; 3395 NULL);
3377 } 3396 if (NULL == line)
3378 if (0 == line[0]) 3397 {
3379 { 3398 if (MHD_CONNECTION_URL_RECEIVED != connection->state)
3380 connection->state = MHD_CONNECTION_HEADERS_RECEIVED;
3381 connection->header_size = (size_t) (line - connection->read_buffer);
3382 continue;
3383 }
3384 if (MHD_NO == process_header_line (connection,
3385 line))
3386 {
3387 transmit_error_response (connection,
3388 MHD_HTTP_BAD_REQUEST,
3389 REQUEST_MALFORMED);
3390 break;
3391 }
3392 connection->state = MHD_CONNECTION_HEADER_PART_RECEIVED;
3393 continue; 3399 continue;
3394 case MHD_CONNECTION_HEADER_PART_RECEIVED: 3400 if (connection->read_closed)
3395 line = get_next_header_line (connection, 3401 {
3396 NULL); 3402 CONNECTION_CLOSE_ERROR (connection,
3397 if (NULL == line) 3403 NULL);
3398 {
3399 if (connection->state != MHD_CONNECTION_HEADER_PART_RECEIVED)
3400 continue;
3401 if (connection->read_closed)
3402 {
3403 CONNECTION_CLOSE_ERROR (connection,
3404 NULL);
3405 continue;
3406 }
3407 break;
3408 }
3409 if (MHD_NO ==
3410 process_broken_line (connection,
3411 line,
3412 MHD_HEADER_KIND))
3413 continue;
3414 if (0 == line[0])
3415 {
3416 connection->state = MHD_CONNECTION_HEADERS_RECEIVED;
3417 connection->header_size = (size_t) (line - connection->read_buffer);
3418 continue;
3419 }
3420 continue; 3404 continue;
3421 case MHD_CONNECTION_HEADERS_RECEIVED: 3405 }
3422 parse_connection_headers (connection); 3406 break;
3423 if (MHD_CONNECTION_CLOSED == connection->state) 3407 }
3424 continue; 3408 if (0 == line[0])
3425 connection->state = MHD_CONNECTION_HEADERS_PROCESSED; 3409 {
3426 if (connection->suspended) 3410 connection->state = MHD_CONNECTION_HEADERS_RECEIVED;
3427 break; 3411 connection->header_size = (size_t) (line - connection->read_buffer);
3412 continue;
3413 }
3414 if (MHD_NO == process_header_line (connection,
3415 line))
3416 {
3417 transmit_error_response (connection,
3418 MHD_HTTP_BAD_REQUEST,
3419 REQUEST_MALFORMED);
3420 break;
3421 }
3422 connection->state = MHD_CONNECTION_HEADER_PART_RECEIVED;
3423 continue;
3424 case MHD_CONNECTION_HEADER_PART_RECEIVED:
3425 line = get_next_header_line (connection,
3426 NULL);
3427 if (NULL == line)
3428 {
3429 if (connection->state != MHD_CONNECTION_HEADER_PART_RECEIVED)
3428 continue; 3430 continue;
3429 case MHD_CONNECTION_HEADERS_PROCESSED: 3431 if (connection->read_closed)
3430 call_connection_handler (connection); /* first call */ 3432 {
3431 if (MHD_CONNECTION_CLOSED == connection->state) 3433 CONNECTION_CLOSE_ERROR (connection,
3432 continue; 3434 NULL);
3433 if (need_100_continue (connection))
3434 {
3435 connection->state = MHD_CONNECTION_CONTINUE_SENDING;
3436 break;
3437 }
3438 if ( (NULL != connection->response) &&
3439 ( (MHD_str_equal_caseless_ (connection->method,
3440 MHD_HTTP_METHOD_POST)) ||
3441 (MHD_str_equal_caseless_ (connection->method,
3442 MHD_HTTP_METHOD_PUT))) )
3443 {
3444 /* we refused (no upload allowed!) */
3445 connection->remaining_upload_size = 0;
3446 /* force close, in case client still tries to upload... */
3447 connection->read_closed = true;
3448 }
3449 connection->state = (0 == connection->remaining_upload_size)
3450 ? MHD_CONNECTION_FOOTERS_RECEIVED : MHD_CONNECTION_CONTINUE_SENT;
3451 if (connection->suspended)
3452 break;
3453 continue; 3435 continue;
3454 case MHD_CONNECTION_CONTINUE_SENDING: 3436 }
3455 if (connection->continue_message_write_offset == 3437 break;
3456 MHD_STATICSTR_LEN_ (HTTP_100_CONTINUE)) 3438 }
3457 { 3439 if (MHD_NO ==
3458 connection->state = MHD_CONNECTION_CONTINUE_SENT; 3440 process_broken_line (connection,
3459 continue; 3441 line,
3460 } 3442 MHD_HEADER_KIND))
3461 break; 3443 continue;
3462 case MHD_CONNECTION_CONTINUE_SENT: 3444 if (0 == line[0])
3463 if (0 != connection->read_buffer_offset) 3445 {
3464 { 3446 connection->state = MHD_CONNECTION_HEADERS_RECEIVED;
3465 process_request_body (connection); /* loop call */ 3447 connection->header_size = (size_t) (line - connection->read_buffer);
3466 if (MHD_CONNECTION_CLOSED == connection->state) 3448 continue;
3467 continue; 3449 }
3468 } 3450 continue;
3469 if ( (0 == connection->remaining_upload_size) || 3451 case MHD_CONNECTION_HEADERS_RECEIVED:
3470 ( (MHD_SIZE_UNKNOWN == connection->remaining_upload_size) && 3452 parse_connection_headers (connection);
3471 (0 == connection->read_buffer_offset) && 3453 if (MHD_CONNECTION_CLOSED == connection->state)
3472 (connection->read_closed) ) ) 3454 continue;
3473 { 3455 connection->state = MHD_CONNECTION_HEADERS_PROCESSED;
3474 if ( (connection->have_chunked_upload) && 3456 if (connection->suspended)
3475 (! connection->read_closed) ) 3457 break;
3476 connection->state = MHD_CONNECTION_BODY_RECEIVED; 3458 continue;
3477 else 3459 case MHD_CONNECTION_HEADERS_PROCESSED:
3478 connection->state = MHD_CONNECTION_FOOTERS_RECEIVED; 3460 call_connection_handler (connection); /* first call */
3479 if (connection->suspended) 3461 if (MHD_CONNECTION_CLOSED == connection->state)
3480 break; 3462 continue;
3481 continue; 3463 if (need_100_continue (connection))
3482 } 3464 {
3465 connection->state = MHD_CONNECTION_CONTINUE_SENDING;
3466 break;
3467 }
3468 if ( (NULL != connection->response) &&
3469 ( (MHD_str_equal_caseless_ (connection->method,
3470 MHD_HTTP_METHOD_POST)) ||
3471 (MHD_str_equal_caseless_ (connection->method,
3472 MHD_HTTP_METHOD_PUT))) )
3473 {
3474 /* we refused (no upload allowed!) */
3475 connection->remaining_upload_size = 0;
3476 /* force close, in case client still tries to upload... */
3477 connection->read_closed = true;
3478 }
3479 connection->state = (0 == connection->remaining_upload_size)
3480 ? MHD_CONNECTION_FOOTERS_RECEIVED :
3481 MHD_CONNECTION_CONTINUE_SENT;
3482 if (connection->suspended)
3483 break;
3484 continue;
3485 case MHD_CONNECTION_CONTINUE_SENDING:
3486 if (connection->continue_message_write_offset ==
3487 MHD_STATICSTR_LEN_ (HTTP_100_CONTINUE))
3488 {
3489 connection->state = MHD_CONNECTION_CONTINUE_SENT;
3490 continue;
3491 }
3492 break;
3493 case MHD_CONNECTION_CONTINUE_SENT:
3494 if (0 != connection->read_buffer_offset)
3495 {
3496 process_request_body (connection); /* loop call */
3497 if (MHD_CONNECTION_CLOSED == connection->state)
3498 continue;
3499 }
3500 if ( (0 == connection->remaining_upload_size) ||
3501 ( (MHD_SIZE_UNKNOWN == connection->remaining_upload_size) &&
3502 (0 == connection->read_buffer_offset) &&
3503 (connection->read_closed) ) )
3504 {
3505 if ( (connection->have_chunked_upload) &&
3506 (! connection->read_closed) )
3507 connection->state = MHD_CONNECTION_BODY_RECEIVED;
3508 else
3509 connection->state = MHD_CONNECTION_FOOTERS_RECEIVED;
3510 if (connection->suspended)
3483 break; 3511 break;
3484 case MHD_CONNECTION_BODY_RECEIVED: 3512 continue;
3485 line = get_next_header_line (connection, 3513 }
3486 NULL); 3514 break;
3487 if (NULL == line) 3515 case MHD_CONNECTION_BODY_RECEIVED:
3488 { 3516 line = get_next_header_line (connection,
3489 if (connection->state != MHD_CONNECTION_BODY_RECEIVED) 3517 NULL);
3490 continue; 3518 if (NULL == line)
3491 if (connection->read_closed) 3519 {
3492 { 3520 if (connection->state != MHD_CONNECTION_BODY_RECEIVED)
3493 CONNECTION_CLOSE_ERROR (connection,
3494 NULL);
3495 continue;
3496 }
3497 break;
3498 }
3499 if (0 == line[0])
3500 {
3501 connection->state = MHD_CONNECTION_FOOTERS_RECEIVED;
3502 if (connection->suspended)
3503 break;
3504 continue;
3505 }
3506 if (MHD_NO == process_header_line (connection,
3507 line))
3508 {
3509 transmit_error_response (connection,
3510 MHD_HTTP_BAD_REQUEST,
3511 REQUEST_MALFORMED);
3512 break;
3513 }
3514 connection->state = MHD_CONNECTION_FOOTER_PART_RECEIVED;
3515 continue; 3521 continue;
3516 case MHD_CONNECTION_FOOTER_PART_RECEIVED: 3522 if (connection->read_closed)
3517 line = get_next_header_line (connection, 3523 {
3518 NULL); 3524 CONNECTION_CLOSE_ERROR (connection,
3519 if (NULL == line) 3525 NULL);
3520 {
3521 if (connection->state != MHD_CONNECTION_FOOTER_PART_RECEIVED)
3522 continue;
3523 if (connection->read_closed)
3524 {
3525 CONNECTION_CLOSE_ERROR (connection,
3526 NULL);
3527 continue;
3528 }
3529 break;
3530 }
3531 if (MHD_NO ==
3532 process_broken_line (connection,
3533 line,
3534 MHD_FOOTER_KIND))
3535 continue;
3536 if (0 == line[0])
3537 {
3538 connection->state = MHD_CONNECTION_FOOTERS_RECEIVED;
3539 if (connection->suspended)
3540 break;
3541 continue;
3542 }
3543 continue; 3526 continue;
3544 case MHD_CONNECTION_FOOTERS_RECEIVED: 3527 }
3545 call_connection_handler (connection); /* "final" call */ 3528 break;
3546 if (connection->state == MHD_CONNECTION_CLOSED) 3529 }
3547 continue; 3530 if (0 == line[0])
3548 if (NULL == connection->response) 3531 {
3549 break; /* try again next time */ 3532 connection->state = MHD_CONNECTION_FOOTERS_RECEIVED;
3550 if (MHD_NO == build_header_response (connection)) 3533 if (connection->suspended)
3551 {
3552 /* oops - close! */
3553 CONNECTION_CLOSE_ERROR (connection,
3554 _("Closing connection (failed to create response header)\n"));
3555 continue;
3556 }
3557 connection->state = MHD_CONNECTION_HEADERS_SENDING;
3558 break; 3534 break;
3559 case MHD_CONNECTION_HEADERS_SENDING: 3535 continue;
3560 /* no default action */ 3536 }
3537 if (MHD_NO == process_header_line (connection,
3538 line))
3539 {
3540 transmit_error_response (connection,
3541 MHD_HTTP_BAD_REQUEST,
3542 REQUEST_MALFORMED);
3543 break;
3544 }
3545 connection->state = MHD_CONNECTION_FOOTER_PART_RECEIVED;
3546 continue;
3547 case MHD_CONNECTION_FOOTER_PART_RECEIVED:
3548 line = get_next_header_line (connection,
3549 NULL);
3550 if (NULL == line)
3551 {
3552 if (connection->state != MHD_CONNECTION_FOOTER_PART_RECEIVED)
3553 continue;
3554 if (connection->read_closed)
3555 {
3556 CONNECTION_CLOSE_ERROR (connection,
3557 NULL);
3558 continue;
3559 }
3560 break;
3561 }
3562 if (MHD_NO ==
3563 process_broken_line (connection,
3564 line,
3565 MHD_FOOTER_KIND))
3566 continue;
3567 if (0 == line[0])
3568 {
3569 connection->state = MHD_CONNECTION_FOOTERS_RECEIVED;
3570 if (connection->suspended)
3561 break; 3571 break;
3562 case MHD_CONNECTION_HEADERS_SENT: 3572 continue;
3563 /* Some clients may take some actions right after header receive */ 3573 }
3564 if (socket_flush_possible (connection)) 3574 continue;
3565 socket_start_no_buffering_flush (connection); /* REMOVE: Dead */ 3575 case MHD_CONNECTION_FOOTERS_RECEIVED:
3576 call_connection_handler (connection); /* "final" call */
3577 if (connection->state == MHD_CONNECTION_CLOSED)
3578 continue;
3579 if (NULL == connection->response)
3580 break; /* try again next time */
3581 if (MHD_NO == build_header_response (connection))
3582 {
3583 /* oops - close! */
3584 CONNECTION_CLOSE_ERROR (connection,
3585 _ (
3586 "Closing connection (failed to create response header)\n"));
3587 continue;
3588 }
3589 connection->state = MHD_CONNECTION_HEADERS_SENDING;
3590 break;
3591 case MHD_CONNECTION_HEADERS_SENDING:
3592 /* no default action */
3593 break;
3594 case MHD_CONNECTION_HEADERS_SENT:
3595 /* Some clients may take some actions right after header receive */
3596 if (socket_flush_possible (connection))
3597 socket_start_no_buffering_flush (connection); /* REMOVE: Dead */
3566 3598
3567#ifdef UPGRADE_SUPPORT 3599#ifdef UPGRADE_SUPPORT
3568 if (NULL != connection->response->upgrade_handler) 3600 if (NULL != connection->response->upgrade_handler)
3569 { 3601 {
3570 connection->state = MHD_CONNECTION_UPGRADE; 3602 connection->state = MHD_CONNECTION_UPGRADE;
3571 /* This connection is "upgraded". Pass socket to application. */ 3603 /* This connection is "upgraded". Pass socket to application. */
3572 if (MHD_YES != 3604 if (MHD_YES !=
3573 MHD_response_execute_upgrade_ (connection->response, 3605 MHD_response_execute_upgrade_ (connection->response,
3574 connection)) 3606 connection))
3575 { 3607 {
3576 /* upgrade failed, fail hard */ 3608 /* upgrade failed, fail hard */
3577 CONNECTION_CLOSE_ERROR (connection, 3609 CONNECTION_CLOSE_ERROR (connection,
3578 NULL); 3610 NULL);
3579 continue; 3611 continue;
3580 } 3612 }
3581 /* Response is not required anymore for this connection. */ 3613 /* Response is not required anymore for this connection. */
3582 { 3614 {
3583 struct MHD_Response * const resp = connection->response; 3615 struct MHD_Response *const resp = connection->response;
3584 3616
3585 connection->response = NULL; 3617 connection->response = NULL;
3586 MHD_destroy_response (resp); 3618 MHD_destroy_response (resp);
3587 } 3619 }
3588 continue; 3620 continue;
3589 } 3621 }
3590#endif /* UPGRADE_SUPPORT */ 3622#endif /* UPGRADE_SUPPORT */
3591 3623
3592 if (connection->have_chunked_upload) 3624 if (connection->have_chunked_upload)
3593 connection->state = MHD_CONNECTION_CHUNKED_BODY_UNREADY; 3625 connection->state = MHD_CONNECTION_CHUNKED_BODY_UNREADY;
3594 else 3626 else
3595 connection->state = MHD_CONNECTION_NORMAL_BODY_UNREADY; 3627 connection->state = MHD_CONNECTION_NORMAL_BODY_UNREADY;
3596 continue; 3628 continue;
3597 case MHD_CONNECTION_NORMAL_BODY_READY: 3629 case MHD_CONNECTION_NORMAL_BODY_READY:
3598 /* nothing to do here */ 3630 /* nothing to do here */
3599 break; 3631 break;
3600 case MHD_CONNECTION_NORMAL_BODY_UNREADY: 3632 case MHD_CONNECTION_NORMAL_BODY_UNREADY:
3601#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 3633#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
3602 if (NULL != connection->response->crc) 3634 if (NULL != connection->response->crc)
3603 MHD_mutex_lock_chk_ (&connection->response->mutex); 3635 MHD_mutex_lock_chk_ (&connection->response->mutex);
3604#endif 3636#endif
3605 if (0 == connection->response->total_size) 3637 if (0 == connection->response->total_size)
3606 { 3638 {
3607#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 3639#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
3608 if (NULL != connection->response->crc) 3640 if (NULL != connection->response->crc)
3609 MHD_mutex_unlock_chk_ (&connection->response->mutex); 3641 MHD_mutex_unlock_chk_ (&connection->response->mutex);
3610#endif 3642#endif
3611 connection->state = MHD_CONNECTION_BODY_SENT; 3643 connection->state = MHD_CONNECTION_BODY_SENT;
3612 continue; 3644 continue;
3613 } 3645 }
3614 if (MHD_YES == try_ready_normal_body (connection)) 3646 if (MHD_YES == try_ready_normal_body (connection))
3615 { 3647 {
3616#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 3648#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
3617 if (NULL != connection->response->crc) 3649 if (NULL != connection->response->crc)
3618 MHD_mutex_unlock_chk_ (&connection->response->mutex); 3650 MHD_mutex_unlock_chk_ (&connection->response->mutex);
3619#endif 3651#endif
3620 connection->state = MHD_CONNECTION_NORMAL_BODY_READY; 3652 connection->state = MHD_CONNECTION_NORMAL_BODY_READY;
3621 /* Buffering for flushable socket was already enabled*/ 3653 /* Buffering for flushable socket was already enabled*/
3622 3654
3623 break; 3655 break;
3624 } 3656 }
3625 /* mutex was already unlocked by "try_ready_normal_body */ 3657 /* mutex was already unlocked by "try_ready_normal_body */
3626 /* not ready, no socket action */ 3658 /* not ready, no socket action */
3627 break; 3659 break;
3628 case MHD_CONNECTION_CHUNKED_BODY_READY: 3660 case MHD_CONNECTION_CHUNKED_BODY_READY:
3629 /* nothing to do here */ 3661 /* nothing to do here */
3630 break; 3662 break;
3631 case MHD_CONNECTION_CHUNKED_BODY_UNREADY: 3663 case MHD_CONNECTION_CHUNKED_BODY_UNREADY:
3632#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 3664#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
3633 if (NULL != connection->response->crc) 3665 if (NULL != connection->response->crc)
3634 MHD_mutex_lock_chk_ (&connection->response->mutex); 3666 MHD_mutex_lock_chk_ (&connection->response->mutex);
3635#endif 3667#endif
3636 if ( (0 == connection->response->total_size) || 3668 if ( (0 == connection->response->total_size) ||
3637 (connection->response_write_position == 3669 (connection->response_write_position ==
3638 connection->response->total_size) ) 3670 connection->response->total_size) )
3639 { 3671 {
3640#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 3672#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
3641 if (NULL != connection->response->crc) 3673 if (NULL != connection->response->crc)
3642 MHD_mutex_unlock_chk_ (&connection->response->mutex); 3674 MHD_mutex_unlock_chk_ (&connection->response->mutex);
3643#endif 3675#endif
3644 connection->state = MHD_CONNECTION_BODY_SENT; 3676 connection->state = MHD_CONNECTION_BODY_SENT;
3645 continue; 3677 continue;
3646 } 3678 }
3647 if (MHD_YES == try_ready_chunked_body (connection)) 3679 if (MHD_YES == try_ready_chunked_body (connection))
3648 { 3680 {
3649#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 3681#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
3650 if (NULL != connection->response->crc) 3682 if (NULL != connection->response->crc)
3651 MHD_mutex_unlock_chk_ (&connection->response->mutex); 3683 MHD_mutex_unlock_chk_ (&connection->response->mutex);
3652#endif 3684#endif
3653 connection->state = MHD_CONNECTION_CHUNKED_BODY_READY; 3685 connection->state = MHD_CONNECTION_CHUNKED_BODY_READY;
3654 /* Buffering for flushable socket was already enabled */ 3686 /* Buffering for flushable socket was already enabled */
3655 3687
3656 continue; 3688 continue;
3657 } 3689 }
3658 /* mutex was already unlocked by try_ready_chunked_body */ 3690 /* mutex was already unlocked by try_ready_chunked_body */
3659 break; 3691 break;
3660 case MHD_CONNECTION_BODY_SENT: 3692 case MHD_CONNECTION_BODY_SENT:
3661 if (MHD_NO == build_header_response (connection)) 3693 if (MHD_NO == build_header_response (connection))
3662 { 3694 {
3663 /* oops - close! */ 3695 /* oops - close! */
3664 CONNECTION_CLOSE_ERROR (connection, 3696 CONNECTION_CLOSE_ERROR (connection,
3665 _("Closing connection (failed to create response header)\n")); 3697 _ (
3666 continue; 3698 "Closing connection (failed to create response header)\n"));
3667 } 3699 continue;
3668 if ( (! connection->have_chunked_upload) || 3700 }
3669 (connection->write_buffer_send_offset == 3701 if ( (! connection->have_chunked_upload) ||
3670 connection->write_buffer_append_offset) ) 3702 (connection->write_buffer_send_offset ==
3671 connection->state = MHD_CONNECTION_FOOTERS_SENT; 3703 connection->write_buffer_append_offset) )
3672 else 3704 connection->state = MHD_CONNECTION_FOOTERS_SENT;
3673 connection->state = MHD_CONNECTION_FOOTERS_SENDING; 3705 else
3674 continue; 3706 connection->state = MHD_CONNECTION_FOOTERS_SENDING;
3675 case MHD_CONNECTION_FOOTERS_SENDING: 3707 continue;
3676 /* no default action */ 3708 case MHD_CONNECTION_FOOTERS_SENDING:
3677 break; 3709 /* no default action */
3678 case MHD_CONNECTION_FOOTERS_SENT: 3710 break;
3679 if (MHD_HTTP_PROCESSING == connection->responseCode) 3711 case MHD_CONNECTION_FOOTERS_SENT:
3680 { 3712 if (MHD_HTTP_PROCESSING == connection->responseCode)
3681 /* After this type of response, we allow sending another! */ 3713 {
3682 connection->state = MHD_CONNECTION_HEADERS_PROCESSED; 3714 /* After this type of response, we allow sending another! */
3683 MHD_destroy_response (connection->response); 3715 connection->state = MHD_CONNECTION_HEADERS_PROCESSED;
3684 connection->response = NULL; 3716 MHD_destroy_response (connection->response);
3685 /* FIXME: maybe partially reset memory pool? */ 3717 connection->response = NULL;
3686 continue; 3718 /* FIXME: maybe partially reset memory pool? */
3687 } 3719 continue;
3688 MHD_destroy_response (connection->response); 3720 }
3689 connection->response = NULL; 3721 MHD_destroy_response (connection->response);
3690 if ( (NULL != daemon->notify_completed) && 3722 connection->response = NULL;
3691 (connection->client_aware) ) 3723 if ( (NULL != daemon->notify_completed) &&
3692 { 3724 (connection->client_aware) )
3693 daemon->notify_completed (daemon->notify_completed_cls, 3725 {
3694 connection, 3726 daemon->notify_completed (daemon->notify_completed_cls,
3695 &connection->client_context, 3727 connection,
3696 MHD_REQUEST_TERMINATED_COMPLETED_OK); 3728 &connection->client_context,
3697 } 3729 MHD_REQUEST_TERMINATED_COMPLETED_OK);
3698 connection->client_aware = false; 3730 }
3699 if ( (MHD_CONN_USE_KEEPALIVE != connection->keepalive) || 3731 connection->client_aware = false;
3700 (connection->read_closed) ) 3732 if ( (MHD_CONN_USE_KEEPALIVE != connection->keepalive) ||
3701 { 3733 (connection->read_closed) )
3702 /* have to close for some reason */ 3734 {
3703 MHD_connection_close_ (connection, 3735 /* have to close for some reason */
3704 MHD_REQUEST_TERMINATED_COMPLETED_OK); 3736 MHD_connection_close_ (connection,
3705 MHD_pool_destroy (connection->pool); 3737 MHD_REQUEST_TERMINATED_COMPLETED_OK);
3706 connection->pool = NULL; 3738 MHD_pool_destroy (connection->pool);
3707 connection->read_buffer = NULL; 3739 connection->pool = NULL;
3708 connection->read_buffer_size = 0; 3740 connection->read_buffer = NULL;
3709 connection->read_buffer_offset = 0; 3741 connection->read_buffer_size = 0;
3710 } 3742 connection->read_buffer_offset = 0;
3711 else 3743 }
3712 { 3744 else
3713 /* can try to keep-alive */ 3745 {
3714 3746 /* can try to keep-alive */
3715 connection->version = NULL; 3747
3716 connection->state = MHD_CONNECTION_INIT; 3748 connection->version = NULL;
3717 connection->last = NULL; 3749 connection->state = MHD_CONNECTION_INIT;
3718 connection->colon = NULL; 3750 connection->last = NULL;
3719 connection->header_size = 0; 3751 connection->colon = NULL;
3720 connection->keepalive = MHD_CONN_KEEPALIVE_UNKOWN; 3752 connection->header_size = 0;
3721 /* Reset the read buffer to the starting size, 3753 connection->keepalive = MHD_CONN_KEEPALIVE_UNKOWN;
3722 preserving the bytes we have already read. */ 3754 /* Reset the read buffer to the starting size,
3723 connection->read_buffer 3755 preserving the bytes we have already read. */
3724 = MHD_pool_reset (connection->pool, 3756 connection->read_buffer
3725 connection->read_buffer, 3757 = MHD_pool_reset (connection->pool,
3726 connection->read_buffer_offset, 3758 connection->read_buffer,
3727 connection->daemon->pool_size / 2); 3759 connection->read_buffer_offset,
3728 connection->read_buffer_size 3760 connection->daemon->pool_size / 2);
3729 = connection->daemon->pool_size / 2; 3761 connection->read_buffer_size
3730 } 3762 = connection->daemon->pool_size / 2;
3731 connection->client_context = NULL; 3763 }
3732 connection->continue_message_write_offset = 0; 3764 connection->client_context = NULL;
3733 connection->responseCode = 0; 3765 connection->continue_message_write_offset = 0;
3734 connection->headers_received = NULL; 3766 connection->responseCode = 0;
3735 connection->headers_received_tail = NULL; 3767 connection->headers_received = NULL;
3736 connection->response_write_position = 0; 3768 connection->headers_received_tail = NULL;
3737 connection->have_chunked_upload = false; 3769 connection->response_write_position = 0;
3738 connection->current_chunk_size = 0; 3770 connection->have_chunked_upload = false;
3739 connection->current_chunk_offset = 0; 3771 connection->current_chunk_size = 0;
3740 connection->method = NULL; 3772 connection->current_chunk_offset = 0;
3741 connection->url = NULL; 3773 connection->method = NULL;
3742 connection->write_buffer = NULL; 3774 connection->url = NULL;
3743 connection->write_buffer_size = 0; 3775 connection->write_buffer = NULL;
3744 connection->write_buffer_send_offset = 0; 3776 connection->write_buffer_size = 0;
3745 connection->write_buffer_append_offset = 0; 3777 connection->write_buffer_send_offset = 0;
3746 continue; 3778 connection->write_buffer_append_offset = 0;
3747 case MHD_CONNECTION_CLOSED: 3779 continue;
3748 cleanup_connection (connection); 3780 case MHD_CONNECTION_CLOSED:
3749 connection->in_idle = false; 3781 cleanup_connection (connection);
3750 return MHD_NO; 3782 connection->in_idle = false;
3783 return MHD_NO;
3751#ifdef UPGRADE_SUPPORT 3784#ifdef UPGRADE_SUPPORT
3752 case MHD_CONNECTION_UPGRADE: 3785 case MHD_CONNECTION_UPGRADE:
3753 connection->in_idle = false; 3786 connection->in_idle = false;
3754 return MHD_YES; /* keep open */ 3787 return MHD_YES; /* keep open */
3755#endif /* UPGRADE_SUPPORT */ 3788#endif /* UPGRADE_SUPPORT */
3756 default: 3789 default:
3757 mhd_assert (0); 3790 mhd_assert (0);
3758 break;
3759 }
3760 break; 3791 break;
3761 } 3792 }
3793 break;
3794 }
3762 if (! connection->suspended) 3795 if (! connection->suspended)
3796 {
3797 time_t timeout;
3798 timeout = connection->connection_timeout;
3799 if ( (0 != timeout) &&
3800 (timeout < (MHD_monotonic_sec_counter ()
3801 - connection->last_activity)) )
3763 { 3802 {
3764 time_t timeout; 3803 MHD_connection_close_ (connection,
3765 timeout = connection->connection_timeout; 3804 MHD_REQUEST_TERMINATED_TIMEOUT_REACHED);
3766 if ( (0 != timeout) && 3805 connection->in_idle = false;
3767 (timeout < (MHD_monotonic_sec_counter() - connection->last_activity)) ) 3806 return MHD_YES;
3768 {
3769 MHD_connection_close_ (connection,
3770 MHD_REQUEST_TERMINATED_TIMEOUT_REACHED);
3771 connection->in_idle = false;
3772 return MHD_YES;
3773 }
3774 } 3807 }
3808 }
3775 MHD_connection_update_event_loop_info (connection); 3809 MHD_connection_update_event_loop_info (connection);
3776 ret = MHD_YES; 3810 ret = MHD_YES;
3777#ifdef EPOLL_SUPPORT 3811#ifdef EPOLL_SUPPORT
3778 if ( (! connection->suspended) && 3812 if ( (! connection->suspended) &&
3779 (0 != (daemon->options & MHD_USE_EPOLL)) ) 3813 (0 != (daemon->options & MHD_USE_EPOLL)) )
3780 { 3814 {
3781 ret = MHD_connection_epoll_update_ (connection); 3815 ret = MHD_connection_epoll_update_ (connection);
3782 } 3816 }
3783#endif /* EPOLL_SUPPORT */ 3817#endif /* EPOLL_SUPPORT */
3784 connection->in_idle = false; 3818 connection->in_idle = false;
3785 return ret; 3819 return ret;
@@ -3805,31 +3839,31 @@ MHD_connection_epoll_update_ (struct MHD_Connection *connection)
3805 (0 == (connection->epoll_state & MHD_EPOLL_STATE_SUSPENDED)) && 3839 (0 == (connection->epoll_state & MHD_EPOLL_STATE_SUSPENDED)) &&
3806 ( ( (MHD_EVENT_LOOP_INFO_WRITE == connection->event_loop_info) && 3840 ( ( (MHD_EVENT_LOOP_INFO_WRITE == connection->event_loop_info) &&
3807 (0 == (connection->epoll_state & MHD_EPOLL_STATE_WRITE_READY))) || 3841 (0 == (connection->epoll_state & MHD_EPOLL_STATE_WRITE_READY))) ||
3808 ( (MHD_EVENT_LOOP_INFO_READ == connection->event_loop_info) && 3842 ( (MHD_EVENT_LOOP_INFO_READ == connection->event_loop_info) &&
3809 (0 == (connection->epoll_state & MHD_EPOLL_STATE_READ_READY)) ) ) ) 3843 (0 == (connection->epoll_state & MHD_EPOLL_STATE_READ_READY)) ) ) )
3844 {
3845 /* add to epoll set */
3846 struct epoll_event event;
3847
3848 event.events = EPOLLIN | EPOLLOUT | EPOLLPRI | EPOLLET;
3849 event.data.ptr = connection;
3850 if (0 != epoll_ctl (daemon->epoll_fd,
3851 EPOLL_CTL_ADD,
3852 connection->socket_fd,
3853 &event))
3810 { 3854 {
3811 /* add to epoll set */
3812 struct epoll_event event;
3813
3814 event.events = EPOLLIN | EPOLLOUT | EPOLLPRI | EPOLLET;
3815 event.data.ptr = connection;
3816 if (0 != epoll_ctl (daemon->epoll_fd,
3817 EPOLL_CTL_ADD,
3818 connection->socket_fd,
3819 &event))
3820 {
3821#ifdef HAVE_MESSAGES 3855#ifdef HAVE_MESSAGES
3822 if (0 != (daemon->options & MHD_USE_ERROR_LOG)) 3856 if (0 != (daemon->options & MHD_USE_ERROR_LOG))
3823 MHD_DLOG (daemon, 3857 MHD_DLOG (daemon,
3824 _("Call to epoll_ctl failed: %s\n"), 3858 _ ("Call to epoll_ctl failed: %s\n"),
3825 MHD_socket_last_strerr_ ()); 3859 MHD_socket_last_strerr_ ());
3826#endif 3860#endif
3827 connection->state = MHD_CONNECTION_CLOSED; 3861 connection->state = MHD_CONNECTION_CLOSED;
3828 cleanup_connection (connection); 3862 cleanup_connection (connection);
3829 return MHD_NO; 3863 return MHD_NO;
3830 }
3831 connection->epoll_state |= MHD_EPOLL_STATE_IN_EPOLL_SET;
3832 } 3864 }
3865 connection->epoll_state |= MHD_EPOLL_STATE_IN_EPOLL_SET;
3866 }
3833 return MHD_YES; 3867 return MHD_YES;
3834} 3868}
3835#endif 3869#endif
@@ -3864,45 +3898,48 @@ MHD_get_connection_info (struct MHD_Connection *connection,
3864 ...) 3898 ...)
3865{ 3899{
3866 switch (info_type) 3900 switch (info_type)
3867 { 3901 {
3868#ifdef HTTPS_SUPPORT 3902#ifdef HTTPS_SUPPORT
3869 case MHD_CONNECTION_INFO_CIPHER_ALGO: 3903 case MHD_CONNECTION_INFO_CIPHER_ALGO:
3870 if (NULL == connection->tls_session) 3904 if (NULL == connection->tls_session)
3871 return NULL;
3872 connection->cipher = gnutls_cipher_get (connection->tls_session);
3873 return (const union MHD_ConnectionInfo *) &connection->cipher;
3874 case MHD_CONNECTION_INFO_PROTOCOL:
3875 if (NULL == connection->tls_session)
3876 return NULL;
3877 connection->protocol = gnutls_protocol_get_version (connection->tls_session);
3878 return (const union MHD_ConnectionInfo *) &connection->protocol;
3879 case MHD_CONNECTION_INFO_GNUTLS_SESSION:
3880 if (NULL == connection->tls_session)
3881 return NULL;
3882 return (const union MHD_ConnectionInfo *) &connection->tls_session;
3883#endif /* HTTPS_SUPPORT */
3884 case MHD_CONNECTION_INFO_CLIENT_ADDRESS:
3885 return (const union MHD_ConnectionInfo *) &connection->addr;
3886 case MHD_CONNECTION_INFO_DAEMON:
3887 return (const union MHD_ConnectionInfo *) &connection->daemon;
3888 case MHD_CONNECTION_INFO_CONNECTION_FD:
3889 return (const union MHD_ConnectionInfo *) &connection->socket_fd;
3890 case MHD_CONNECTION_INFO_SOCKET_CONTEXT:
3891 return (const union MHD_ConnectionInfo *) &connection->socket_context;
3892 case MHD_CONNECTION_INFO_CONNECTION_SUSPENDED:
3893 connection->suspended_dummy = connection->suspended ? MHD_YES : MHD_NO;
3894 return (const union MHD_ConnectionInfo *) &connection->suspended_dummy;
3895 case MHD_CONNECTION_INFO_CONNECTION_TIMEOUT:
3896 connection->connection_timeout_dummy = (unsigned int)connection->connection_timeout;
3897 return (const union MHD_ConnectionInfo *) &connection->connection_timeout_dummy;
3898 case MHD_CONNECTION_INFO_REQUEST_HEADER_SIZE:
3899 if ( (MHD_CONNECTION_HEADERS_RECEIVED > connection->state) ||
3900 (MHD_CONNECTION_CLOSED == connection->state) )
3901 return NULL; /* invalid, too early! */
3902 return (const union MHD_ConnectionInfo *) &connection->header_size;
3903 default:
3904 return NULL; 3905 return NULL;
3905 } 3906 connection->cipher = gnutls_cipher_get (connection->tls_session);
3907 return (const union MHD_ConnectionInfo *) &connection->cipher;
3908 case MHD_CONNECTION_INFO_PROTOCOL:
3909 if (NULL == connection->tls_session)
3910 return NULL;
3911 connection->protocol = gnutls_protocol_get_version (
3912 connection->tls_session);
3913 return (const union MHD_ConnectionInfo *) &connection->protocol;
3914 case MHD_CONNECTION_INFO_GNUTLS_SESSION:
3915 if (NULL == connection->tls_session)
3916 return NULL;
3917 return (const union MHD_ConnectionInfo *) &connection->tls_session;
3918#endif /* HTTPS_SUPPORT */
3919 case MHD_CONNECTION_INFO_CLIENT_ADDRESS:
3920 return (const union MHD_ConnectionInfo *) &connection->addr;
3921 case MHD_CONNECTION_INFO_DAEMON:
3922 return (const union MHD_ConnectionInfo *) &connection->daemon;
3923 case MHD_CONNECTION_INFO_CONNECTION_FD:
3924 return (const union MHD_ConnectionInfo *) &connection->socket_fd;
3925 case MHD_CONNECTION_INFO_SOCKET_CONTEXT:
3926 return (const union MHD_ConnectionInfo *) &connection->socket_context;
3927 case MHD_CONNECTION_INFO_CONNECTION_SUSPENDED:
3928 connection->suspended_dummy = connection->suspended ? MHD_YES : MHD_NO;
3929 return (const union MHD_ConnectionInfo *) &connection->suspended_dummy;
3930 case MHD_CONNECTION_INFO_CONNECTION_TIMEOUT:
3931 connection->connection_timeout_dummy = (unsigned
3932 int) connection->connection_timeout;
3933 return (const union MHD_ConnectionInfo *) &connection->
3934 connection_timeout_dummy;
3935 case MHD_CONNECTION_INFO_REQUEST_HEADER_SIZE:
3936 if ( (MHD_CONNECTION_HEADERS_RECEIVED > connection->state) ||
3937 (MHD_CONNECTION_CLOSED == connection->state) )
3938 return NULL; /* invalid, too early! */
3939 return (const union MHD_ConnectionInfo *) &connection->header_size;
3940 default:
3941 return NULL;
3942 }
3906} 3943}
3907 3944
3908 3945
@@ -3917,56 +3954,56 @@ MHD_get_connection_info (struct MHD_Connection *connection,
3917 */ 3954 */
3918int 3955int
3919MHD_set_connection_option (struct MHD_Connection *connection, 3956MHD_set_connection_option (struct MHD_Connection *connection,
3920 enum MHD_CONNECTION_OPTION option, 3957 enum MHD_CONNECTION_OPTION option,
3921 ...) 3958 ...)
3922{ 3959{
3923 va_list ap; 3960 va_list ap;
3924 struct MHD_Daemon *daemon; 3961 struct MHD_Daemon *daemon;
3925 3962
3926 daemon = connection->daemon; 3963 daemon = connection->daemon;
3927 switch (option) 3964 switch (option)
3928 { 3965 {
3929 case MHD_CONNECTION_OPTION_TIMEOUT: 3966 case MHD_CONNECTION_OPTION_TIMEOUT:
3930 if (0 == connection->connection_timeout) 3967 if (0 == connection->connection_timeout)
3931 connection->last_activity = MHD_monotonic_sec_counter(); 3968 connection->last_activity = MHD_monotonic_sec_counter ();
3932#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 3969#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
3933 MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex); 3970 MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex);
3934#endif 3971#endif
3935 if ( (0 == (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) && 3972 if ( (0 == (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
3936 (! connection->suspended) ) 3973 (! connection->suspended) )
3937 { 3974 {
3938 if (connection->connection_timeout == daemon->connection_timeout) 3975 if (connection->connection_timeout == daemon->connection_timeout)
3939 XDLL_remove (daemon->normal_timeout_head, 3976 XDLL_remove (daemon->normal_timeout_head,
3940 daemon->normal_timeout_tail, 3977 daemon->normal_timeout_tail,
3941 connection); 3978 connection);
3942 else 3979 else
3943 XDLL_remove (daemon->manual_timeout_head, 3980 XDLL_remove (daemon->manual_timeout_head,
3944 daemon->manual_timeout_tail, 3981 daemon->manual_timeout_tail,
3945 connection); 3982 connection);
3946 } 3983 }
3947 va_start (ap, option); 3984 va_start (ap, option);
3948 connection->connection_timeout = va_arg (ap, 3985 connection->connection_timeout = va_arg (ap,
3949 unsigned int); 3986 unsigned int);
3950 va_end (ap); 3987 va_end (ap);
3951 if ( (0 == (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) && 3988 if ( (0 == (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) &&
3952 (! connection->suspended) ) 3989 (! connection->suspended) )
3953 { 3990 {
3954 if (connection->connection_timeout == daemon->connection_timeout) 3991 if (connection->connection_timeout == daemon->connection_timeout)
3955 XDLL_insert (daemon->normal_timeout_head, 3992 XDLL_insert (daemon->normal_timeout_head,
3956 daemon->normal_timeout_tail, 3993 daemon->normal_timeout_tail,
3957 connection); 3994 connection);
3958 else 3995 else
3959 XDLL_insert (daemon->manual_timeout_head, 3996 XDLL_insert (daemon->manual_timeout_head,
3960 daemon->manual_timeout_tail, 3997 daemon->manual_timeout_tail,
3961 connection); 3998 connection);
3962 } 3999 }
3963#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 4000#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
3964 MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex); 4001 MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex);
3965#endif 4002#endif
3966 return MHD_YES; 4003 return MHD_YES;
3967 default: 4004 default:
3968 return MHD_NO; 4005 return MHD_NO;
3969 } 4006 }
3970} 4007}
3971 4008
3972 4009
@@ -3992,7 +4029,7 @@ MHD_queue_response (struct MHD_Connection *connection,
3992 (NULL == response) || 4029 (NULL == response) ||
3993 (NULL != connection->response) || 4030 (NULL != connection->response) ||
3994 ( (MHD_CONNECTION_HEADERS_PROCESSED != connection->state) && 4031 ( (MHD_CONNECTION_HEADERS_PROCESSED != connection->state) &&
3995 (MHD_CONNECTION_FOOTERS_RECEIVED != connection->state) ) ) 4032 (MHD_CONNECTION_FOOTERS_RECEIVED != connection->state) ) )
3996 return MHD_NO; 4033 return MHD_NO;
3997 daemon = connection->daemon; 4034 daemon = connection->daemon;
3998 4035
@@ -4001,36 +4038,38 @@ MHD_queue_response (struct MHD_Connection *connection,
4001 * response will be aborted now or on later stage. */ 4038 * response will be aborted now or on later stage. */
4002 4039
4003#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS) 4040#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
4004 if ( (!connection->suspended) && 4041 if ( (! connection->suspended) &&
4005 (0 != (daemon->options & MHD_USE_INTERNAL_POLLING_THREAD)) && 4042 (0 != (daemon->options & MHD_USE_INTERNAL_POLLING_THREAD)) &&
4006 (!MHD_thread_ID_match_current_(connection->pid.ID)) ) 4043 (! MHD_thread_ID_match_current_ (connection->pid.ID)) )
4007 { 4044 {
4008#ifdef HAVE_MESSAGES 4045#ifdef HAVE_MESSAGES
4009 MHD_DLOG (daemon, 4046 MHD_DLOG (daemon,
4010 _("Attempted to queue response on wrong thread!\n")); 4047 _ ("Attempted to queue response on wrong thread!\n"));
4011#endif 4048#endif
4012 return MHD_NO; 4049 return MHD_NO;
4013 } 4050 }
4014#endif 4051#endif
4015#ifdef UPGRADE_SUPPORT 4052#ifdef UPGRADE_SUPPORT
4016 if ( (NULL != response->upgrade_handler) && 4053 if ( (NULL != response->upgrade_handler) &&
4017 (0 == (daemon->options & MHD_ALLOW_UPGRADE)) ) 4054 (0 == (daemon->options & MHD_ALLOW_UPGRADE)) )
4018 { 4055 {
4019#ifdef HAVE_MESSAGES 4056#ifdef HAVE_MESSAGES
4020 MHD_DLOG (daemon, 4057 MHD_DLOG (daemon,
4021 _("Attempted 'upgrade' connection on daemon without MHD_ALLOW_UPGRADE option!\n")); 4058 _ (
4059 "Attempted 'upgrade' connection on daemon without MHD_ALLOW_UPGRADE option!\n"));
4022#endif 4060#endif
4023 return MHD_NO; 4061 return MHD_NO;
4024 } 4062 }
4025 if ( (MHD_HTTP_SWITCHING_PROTOCOLS != status_code) && 4063 if ( (MHD_HTTP_SWITCHING_PROTOCOLS != status_code) &&
4026 (NULL != response->upgrade_handler) ) 4064 (NULL != response->upgrade_handler) )
4027 { 4065 {
4028#ifdef HAVE_MESSAGES 4066#ifdef HAVE_MESSAGES
4029 MHD_DLOG (daemon, 4067 MHD_DLOG (daemon,
4030 _("Application used invalid status code for 'upgrade' response!\n")); 4068 _ (
4069 "Application used invalid status code for 'upgrade' response!\n"));
4031#endif 4070#endif
4032 return MHD_NO; 4071 return MHD_NO;
4033 } 4072 }
4034#endif /* UPGRADE_SUPPORT */ 4073#endif /* UPGRADE_SUPPORT */
4035 MHD_increment_response_rc (response); 4074 MHD_increment_response_rc (response);
4036 connection->response = response; 4075 connection->response = response;
@@ -4049,24 +4088,24 @@ MHD_queue_response (struct MHD_Connection *connection,
4049 (MHD_HTTP_OK > status_code) || 4088 (MHD_HTTP_OK > status_code) ||
4050 (MHD_HTTP_NO_CONTENT == status_code) || 4089 (MHD_HTTP_NO_CONTENT == status_code) ||
4051 (MHD_HTTP_NOT_MODIFIED == status_code) ) 4090 (MHD_HTTP_NOT_MODIFIED == status_code) )
4052 { 4091 {
4053 /* if this is a "HEAD" request, or a status code for 4092 /* if this is a "HEAD" request, or a status code for
4054 which a body is not allowed, pretend that we 4093 which a body is not allowed, pretend that we
4055 have already sent the full message body. */ 4094 have already sent the full message body. */
4056 connection->response_write_position = response->total_size; 4095 connection->response_write_position = response->total_size;
4057 } 4096 }
4058 if ( (MHD_CONNECTION_HEADERS_PROCESSED == connection->state) && 4097 if ( (MHD_CONNECTION_HEADERS_PROCESSED == connection->state) &&
4059 (NULL != connection->method) && 4098 (NULL != connection->method) &&
4060 ( (MHD_str_equal_caseless_ (connection->method, 4099 ( (MHD_str_equal_caseless_ (connection->method,
4061 MHD_HTTP_METHOD_POST)) || 4100 MHD_HTTP_METHOD_POST)) ||
4062 (MHD_str_equal_caseless_ (connection->method, 4101 (MHD_str_equal_caseless_ (connection->method,
4063 MHD_HTTP_METHOD_PUT))) ) 4102 MHD_HTTP_METHOD_PUT))) )
4064 { 4103 {
4065 /* response was queued "early", refuse to read body / footers or 4104 /* response was queued "early", refuse to read body / footers or
4066 further requests! */ 4105 further requests! */
4067 connection->read_closed = true; 4106 connection->read_closed = true;
4068 connection->state = MHD_CONNECTION_FOOTERS_RECEIVED; 4107 connection->state = MHD_CONNECTION_FOOTERS_RECEIVED;
4069 } 4108 }
4070 if (! connection->in_idle) 4109 if (! connection->in_idle)
4071 (void) MHD_connection_handle_idle (connection); 4110 (void) MHD_connection_handle_idle (connection);
4072 MHD_update_last_activity_ (connection); 4111 MHD_update_last_activity_ (connection);
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-15 11:04:17 +0000