From 55a2100778175c743377305a0b1121fb5792dbc2 Mon Sep 17 00:00:00 2001 From: Stephan Bosch Date: Fri, 8 Nov 2019 17:11:30 +0100 Subject: [PATCH] lib-http: Reformat http-server-connection.c. --- src/lib-http/http-server-connection.c | 469 ++++++++++++++------------ 1 file changed, 246 insertions(+), 223 deletions(-) diff --git a/src/lib-http/http-server-connection.c b/src/lib-http/http-server-connection.c index 7f175dea77..e0acaf72d3 100644 --- a/src/lib-http/http-server-connection.c +++ b/src/lib-http/http-server-connection.c @@ -22,7 +22,7 @@ static void http_server_connection_disconnect(struct http_server_connection *conn, - const char *reason); + const char *reason); static bool http_server_connection_unref_is_closed(struct http_server_connection *conn); @@ -33,57 +33,57 @@ http_server_connection_unref_is_closed(struct http_server_connection *conn); static inline void http_server_connection_debug(struct http_server_connection *conn, - const char *format, ...) ATTR_FORMAT(2, 3); + const char *format, ...) ATTR_FORMAT(2, 3); static inline void http_server_connection_debug(struct http_server_connection *conn, - const char *format, ...) + const char *format, ...) { va_list args; if (conn->server->set.debug) { - va_start(args, format); i_debug("http-server: conn %s: %s", - http_server_connection_label(conn), t_strdup_vprintf(format, args)); + http_server_connection_label(conn), + t_strdup_vprintf(format, args)); va_end(args); } } static inline void http_server_connection_error(struct http_server_connection *conn, - const char *format, ...) ATTR_FORMAT(2, 3); + const char *format, ...) ATTR_FORMAT(2, 3); static inline void http_server_connection_error(struct http_server_connection *conn, - const char *format, ...) + const char *format, ...) { va_list args; - va_start(args, format); + va_start(args, format); i_error("http-server: conn %s: %s", - http_server_connection_label(conn), t_strdup_vprintf(format, args)); + http_server_connection_label(conn), + t_strdup_vprintf(format, args)); va_end(args); } static inline void http_server_connection_client_error(struct http_server_connection *conn, - const char *format, ...) ATTR_FORMAT(2, 3); + const char *format, ...) ATTR_FORMAT(2, 3); static inline void http_server_connection_client_error(struct http_server_connection *conn, - const char *format, ...) + const char *format, ...) { va_list args; - va_start(args, format); + va_start(args, format); i_info("http-server: conn %s: %s", - http_server_connection_label(conn), t_strdup_vprintf(format, args)); + http_server_connection_label(conn), + t_strdup_vprintf(format, args)); va_end(args); } - - /* * Connection */ @@ -116,7 +116,7 @@ static void http_server_connection_input_resume(struct http_server_connection *conn) { if (!conn->closed && !conn->input_broken && !conn->close_indicated && - !conn->in_req_callback && conn->incoming_payload == NULL) { + !conn->in_req_callback && conn->incoming_payload == NULL) { connection_input_resume(&conn->conn); } } @@ -124,7 +124,8 @@ http_server_connection_input_resume(struct http_server_connection *conn) static void http_server_connection_idle_timeout(struct http_server_connection *conn) { - http_server_connection_client_error(conn, "Disconnected for inactivity"); + http_server_connection_client_error( + conn, "Disconnected for inactivity"); http_server_connection_close(&conn, "Disconnected for inactivity"); } @@ -137,9 +138,11 @@ http_server_connection_timeout_stop(struct http_server_connection *conn) static void http_server_connection_timeout_start(struct http_server_connection *conn) { - if (conn->to_idle == NULL && conn->server->set.max_client_idle_time_msecs > 0) { - conn->to_idle = timeout_add(conn->server->set.max_client_idle_time_msecs, - http_server_connection_idle_timeout, conn); + if (conn->to_idle == NULL && + conn->server->set.max_client_idle_time_msecs > 0) { + conn->to_idle = timeout_add( + conn->server->set.max_client_idle_time_msecs, + http_server_connection_idle_timeout, conn); } } @@ -153,7 +156,7 @@ http_server_connection_timeout_reset(struct http_server_connection *conn) bool http_server_connection_shut_down(struct http_server_connection *conn) { if (conn->request_queue_head == NULL || - conn->request_queue_head->state == HTTP_SERVER_REQUEST_STATE_NEW) { + conn->request_queue_head->state == HTTP_SERVER_REQUEST_STATE_NEW) { http_server_connection_close(&conn, "Server shutting down"); return TRUE; } @@ -167,7 +170,7 @@ static void http_server_connection_ready(struct http_server_connection *conn) struct stat st; if (conn->server->set.rawlog_dir != NULL && - stat(conn->server->set.rawlog_dir, &st) == 0) { + stat(conn->server->set.rawlog_dir, &st) == 0) { iostream_rawlog_create(conn->server->set.rawlog_dir, &conn->conn.input, &conn->conn.output); } @@ -183,7 +186,7 @@ static void http_server_connection_ready(struct http_server_connection *conn) conn->conn.input, &base_url, &conn->server->set.request_limits, HTTP_REQUEST_PARSE_FLAG_STRICT); o_stream_set_flush_callback(conn->conn.output, - http_server_connection_output, conn); + http_server_connection_output, conn); } static void http_server_connection_destroy(struct connection *_conn) @@ -214,12 +217,12 @@ static void http_server_payload_destroyed(struct http_server_request *req) i_assert(conn != NULL); i_assert(conn->request_queue_tail == req || - req->state >= HTTP_SERVER_REQUEST_STATE_FINISHED); + req->state >= HTTP_SERVER_REQUEST_STATE_FINISHED); i_assert(conn->conn.io == NULL); http_server_connection_debug(conn, "Request payload stream destroyed"); - /* caller is allowed to change the socket fd to blocking while reading + /* Caller is allowed to change the socket fd to blocking while reading the payload. make sure here that it's switched back. */ net_set_nonblock(conn->conn.fd_in, TRUE); @@ -229,55 +232,58 @@ static void http_server_payload_destroyed(struct http_server_request *req) if (conn->payload_handler != NULL) http_server_payload_handler_destroy(&conn->payload_handler); - /* handle errors in transfer stream */ + /* Handle errors in transfer stream */ if (req->response == NULL && stream_errno != 0 && - conn->conn.input->stream_errno == 0) { + conn->conn.input->stream_errno == 0) { switch (stream_errno) { case EMSGSIZE: conn->input_broken = TRUE; - http_server_connection_client_error(conn, - "Client sent excessively large request"); - http_server_request_fail_close(req, 413, "Payload Too Large"); + http_server_connection_client_error( + conn, "Client sent excessively large request"); + http_server_request_fail_close(req, 413, + "Payload Too Large"); return; case EIO: conn->input_broken = TRUE; - http_server_connection_client_error(conn, - "Client sent invalid request payload"); - http_server_request_fail_close(req, 400, "Bad Request"); + http_server_connection_client_error( + conn, "Client sent invalid request payload"); + http_server_request_fail_close(req, 400, + "Bad Request"); return; default: break; } } - /* resource stopped reading payload; update state */ + /* Resource stopped reading payload; update state */ switch (req->state) { case HTTP_SERVER_REQUEST_STATE_QUEUED: case HTTP_SERVER_REQUEST_STATE_PAYLOAD_IN: - /* finished reading request */ + /* Finished reading request */ req->state = HTTP_SERVER_REQUEST_STATE_PROCESSING; http_server_connection_timeout_stop(conn); if (req->response != NULL && req->response->submitted) http_server_request_submit_response(req); break; case HTTP_SERVER_REQUEST_STATE_PROCESSING: - /* no response submitted yet */ + /* No response submitted yet */ break; case HTTP_SERVER_REQUEST_STATE_SUBMITTED_RESPONSE: - /* response submitted, but not all payload is necessarily read */ + /* Response submitted, but not all payload is necessarily read + */ if (http_server_request_is_complete(req)) http_server_request_ready_to_respond(req); break; case HTTP_SERVER_REQUEST_STATE_READY_TO_RESPOND: case HTTP_SERVER_REQUEST_STATE_FINISHED: case HTTP_SERVER_REQUEST_STATE_ABORTED: - /* nothing to do */ + /* Nothing to do */ break; default: i_unreached(); } - /* input stream may have pending input. make sure input handler + /* Input stream may have pending input. make sure input handler gets called (but don't do it directly, since we get get here somewhere from the API user's code, which we can't really know what state it is in). this call also triggers sending the next response if @@ -297,14 +303,14 @@ static void http_server_connection_request_callback( http_server_request_fail(req, 505, "Not Implemented"); return; } - if (req->req.target.format != HTTP_REQUEST_TARGET_FORMAT_AUTHORITY) { + if (req->req.target.format != + HTTP_REQUEST_TARGET_FORMAT_AUTHORITY) { http_server_request_fail(req, 400, "Bad Request"); return; } - conn->callbacks->handle_connect_request - (conn->context, req, req->req.target.url); - - /* other methods */ + conn->callbacks->handle_connect_request(conn->context, req, + req->req.target.url); + /* Other methods */ } else { if (conn->callbacks->handle_request == NULL) { http_server_request_fail(req, 505, "Not Implemented"); @@ -316,7 +322,7 @@ static void http_server_connection_request_callback( static bool http_server_connection_handle_request(struct http_server_connection *conn, - struct http_server_request *req) + struct http_server_request *req) { const struct http_server_settings *set = &conn->server->set; unsigned int old_refcount; @@ -327,19 +333,21 @@ http_server_connection_handle_request(struct http_server_connection *conn, i_assert(conn->incoming_payload == NULL); if (req->req.version_major != 1) { - http_server_request_fail(req, 505, "HTTP Version Not Supported"); + http_server_request_fail(req, 505, + "HTTP Version Not Supported"); return TRUE; } req->state = HTTP_SERVER_REQUEST_STATE_QUEUED; if (req->req.payload != NULL) { - /* wrap the stream to capture the destroy event without destroying the - actual payload stream. */ + /* Wrap the stream to capture the destroy event without + destroying the actual payload stream. */ conn->incoming_payload = req->req.payload = - i_stream_create_timeout(req->req.payload, + i_stream_create_timeout( + req->req.payload, set->max_client_idle_time_msecs); - /* we've received the request itself, and we can't reset the + /* We've received the request itself, and we can't reset the timeout during the payload reading. */ http_server_connection_timeout_stop(conn); } else { @@ -348,51 +356,52 @@ http_server_connection_handle_request(struct http_server_connection *conn, } i_stream_add_destroy_callback(req->req.payload, http_server_payload_destroyed, req); - /* the callback may add its own I/O, so we need to remove - our one before calling it */ + /* The callback may add its own I/O, so we need to remove our one before + calling it. */ http_server_connection_input_halt(conn); old_refcount = req->refcount; conn->in_req_callback = TRUE; http_server_connection_request_callback(conn, req); if (conn->closed) { - /* the callback managed to get this connection destroyed/closed */ + /* The callback managed to get this connection destroyed/closed + */ return FALSE; } conn->in_req_callback = FALSE; req->callback_refcount = req->refcount - old_refcount; if (req->req.payload != NULL) { - /* send 100 Continue when appropriate */ - if (req->req.expect_100_continue && !req->payload_halted - && req->response == NULL) { + /* Send 100 Continue when appropriate */ + if (req->req.expect_100_continue && !req->payload_halted && + req->response == NULL) { http_server_connection_trigger_responses(conn); } - /* delegate payload handling to request handler */ + /* Delegate payload handling to request handler */ if (req->state < HTTP_SERVER_REQUEST_STATE_PAYLOAD_IN) req->state = HTTP_SERVER_REQUEST_STATE_PAYLOAD_IN; payload = req->req.payload; req->req.payload = NULL; i_stream_unref(&payload); if (conn->to_input != NULL) { - /* already finished reading the payload */ + /* Already finished reading the payload */ http_server_payload_finished(conn); payload_destroyed = TRUE; } } if (req->state < HTTP_SERVER_REQUEST_STATE_PROCESSING && - (conn->incoming_payload == NULL || - !i_stream_have_bytes_left(conn->incoming_payload))) { - /* finished reading request */ + (conn->incoming_payload == NULL || + !i_stream_have_bytes_left(conn->incoming_payload))) { + /* Finished reading request */ req->state = HTTP_SERVER_REQUEST_STATE_PROCESSING; if (req->response != NULL && req->response->submitted) http_server_request_submit_response(req); } i_assert(!payload_destroyed || req->callback_refcount > 0 || - (req->response != NULL && req->response->submitted)); + (req->response != NULL && req->response->submitted)); if (conn->incoming_payload == NULL) { if (conn->conn.io == NULL && conn->to_input == NULL) @@ -404,7 +413,7 @@ http_server_connection_handle_request(struct http_server_connection *conn, return FALSE; } -static int +static int http_server_connection_ssl_init(struct http_server_connection *conn) { struct http_server *server = conn->server; @@ -412,8 +421,8 @@ http_server_connection_ssl_init(struct http_server_connection *conn) int ret; if (http_server_init_ssl_ctx(server, &error) < 0) { - http_server_connection_error(conn, - "Couldn't initialize SSL: %s", error); + http_server_connection_error( + conn, "Couldn't initialize SSL: %s", error); return -1; } @@ -423,23 +432,27 @@ http_server_connection_ssl_init(struct http_server_connection *conn) http_server_connection_input_halt(conn); if (server->ssl_ctx == NULL) { ret = master_service_ssl_init(master_service, - &conn->conn.input, &conn->conn.output, - &conn->ssl_iostream, &error); + &conn->conn.input, + &conn->conn.output, + &conn->ssl_iostream, &error); } else { ret = io_stream_create_ssl_server(server->ssl_ctx, - server->set.ssl, &conn->conn.input, &conn->conn.output, - &conn->ssl_iostream, &error); + server->set.ssl, + &conn->conn.input, + &conn->conn.output, + &conn->ssl_iostream, &error); } if (ret < 0) { - http_server_connection_error(conn, - "Couldn't initialize SSL server for %s: %s", + http_server_connection_error( + conn, "Couldn't initialize SSL server for %s: %s", conn->conn.name, error); return -1; } http_server_connection_input_resume(conn); if (ssl_iostream_handshake(conn->ssl_iostream) < 0) { - http_server_connection_error(conn,"SSL handshake failed: %s", + http_server_connection_error( + conn,"SSL handshake failed: %s", ssl_iostream_get_last_error(conn->ssl_iostream)); return -1; } @@ -451,22 +464,23 @@ http_server_connection_ssl_init(struct http_server_connection *conn) static bool http_server_connection_pipeline_is_full(struct http_server_connection *conn) { - return (conn->request_queue_count >= - conn->server->set.max_pipelined_requests || - conn->server->shutting_down); + return ((conn->request_queue_count >= + conn->server->set.max_pipelined_requests) || + conn->server->shutting_down); } static void -http_server_connection_pipeline_handle_full( - struct http_server_connection *conn) +http_server_connection_pipeline_handle_full(struct http_server_connection *conn) { if (conn->server->shutting_down) { - http_server_connection_debug(conn, - "Pipeline full (%u requests pending; server shutting down)", + http_server_connection_debug( + conn, "Pipeline full " + "(%u requests pending; server shutting down)", conn->request_queue_count); } else { - http_server_connection_debug(conn, - "Pipeline full (%u requests pending; %u maximum)", + http_server_connection_debug( + conn, "Pipeline full " + "(%u requests pending; %u maximum)", conn->request_queue_count, conn->server->set.max_pipelined_requests); } @@ -484,30 +498,31 @@ http_server_connection_check_input(struct http_server_connection *conn) stream_errno = input->stream_errno; if (input->eof || stream_errno != 0) { - /* connection input broken; output may still be intact */ + /* Connection input broken; output may still be intact */ if (stream_errno != 0 && stream_errno != EPIPE && - stream_errno != ECONNRESET) { - http_server_connection_client_error(conn, - "Connection lost: read(%s) failed: %s", - i_stream_get_name(input), - i_stream_get_error(input)); + stream_errno != ECONNRESET) { + http_server_connection_client_error( + conn, "Connection lost: read(%s) failed: %s", + i_stream_get_name(input), + i_stream_get_error(input)); http_server_connection_close(&conn, "Read failure"); } else { - http_server_connection_debug(conn, - "Connection lost: Remote disconnected"); + http_server_connection_debug( + conn, "Connection lost: Remote disconnected"); if (conn->request_queue_head == NULL) { - /* no pending requests; close */ - http_server_connection_close(&conn, - "Remote closed connection"); + /* No pending requests; close */ + http_server_connection_close( + &conn, "Remote closed connection"); } else if (conn->request_queue_head->state < - HTTP_SERVER_REQUEST_STATE_SUBMITTED_RESPONSE) { - /* unfinished request; close */ + HTTP_SERVER_REQUEST_STATE_SUBMITTED_RESPONSE) { + /* Unfinished request; close */ http_server_connection_close(&conn, "Remote closed connection unexpectedly"); } else { - /* a request is still processing; only drop input io for now. - the other end may only have shutdown one direction */ + /* A request is still processing; only drop + input io for now. The other end may only have + shutdown one direction */ conn->input_broken = TRUE; http_server_connection_input_halt(conn); } @@ -527,38 +542,37 @@ http_server_connection_finish_request(struct http_server_connection *conn) req = conn->request_queue_tail; if (req != NULL && - req->state == HTTP_SERVER_REQUEST_STATE_SUBMITTED_RESPONSE) { + req->state == HTTP_SERVER_REQUEST_STATE_SUBMITTED_RESPONSE) { http_server_connection_debug(conn, "Finish receiving request"); - ret = http_request_parse_finish_payload - (conn->http_parser, &error_code, &error); - if (ret <= 0 && - !http_server_connection_check_input(conn)) + ret = http_request_parse_finish_payload(conn->http_parser, + &error_code, &error); + if (ret <= 0 && !http_server_connection_check_input(conn)) return FALSE; if (ret < 0) { http_server_connection_ref(conn); - http_server_connection_client_error(conn, - "Client sent invalid request: %s", error); + http_server_connection_client_error( + conn, "Client sent invalid request: %s", error); switch (error_code) { case HTTP_REQUEST_PARSE_ERROR_PAYLOAD_TOO_LARGE: conn->input_broken = TRUE; - http_server_request_fail_close(req, - 413, "Payload Too Large"); + http_server_request_fail_close( + req, 413, "Payload Too Large"); break; case HTTP_REQUEST_PARSE_ERROR_BROKEN_REQUEST: conn->input_broken = TRUE; - http_server_request_fail_close(req, - 400, "Bad request"); + http_server_request_fail_close( + req, 400, "Bad request"); break; default: i_unreached(); } if (http_server_connection_unref_is_closed(conn)) { - /* connection got closed */ + /* Connection got closed */ return FALSE; } @@ -598,8 +612,9 @@ static void http_server_connection_input(struct connection *_conn) if (conn->ssl && conn->ssl_iostream == NULL) { if (http_server_connection_ssl_init(conn) < 0) { - /* ssl failed */ - http_server_connection_close(&conn, "SSL Initialization failed"); + /* SSL failed */ + http_server_connection_close( + &conn, "SSL Initialization failed"); return; } } @@ -613,42 +628,42 @@ static void http_server_connection_input(struct connection *_conn) http_server_payload_finished(conn); } - /* finish up pending request */ + /* Finish up pending request */ if (!http_server_connection_finish_request(conn)) return; - /* create request object if none was created already */ + /* Create request object if none was created already */ if (conn->request_queue_tail != NULL && - conn->request_queue_tail->state == HTTP_SERVER_REQUEST_STATE_NEW) { + conn->request_queue_tail->state == HTTP_SERVER_REQUEST_STATE_NEW) { if (conn->request_queue_count > - conn->server->set.max_pipelined_requests) { - /* pipeline full */ + conn->server->set.max_pipelined_requests) { + /* Pipeline full */ http_server_connection_pipeline_handle_full(conn); return; } - /* continue last unfinished request*/ + /* Continue last unfinished request */ req = conn->request_queue_tail; } else { if (conn->request_queue_count >= - conn->server->set.max_pipelined_requests) { - /* pipeline full */ + conn->server->set.max_pipelined_requests) { + /* Pipeline full */ http_server_connection_pipeline_handle_full(conn); return; } - /* start new request */ + /* Start new request */ req = http_server_request_new(conn); } - /* parse requests */ + /* Parse requests */ ret = 1; while (!conn->close_indicated && ret != 0) { http_server_connection_ref(conn); - while ((ret = http_request_parse_next (conn->http_parser, - req->pool, &req->req, &error_code, &error)) > 0) { - + while ((ret = http_request_parse_next( + conn->http_parser, req->pool, &req->req, + &error_code, &error)) > 0) { conn->stats.request_count++; - http_server_connection_debug(conn, - "Received new request %s " + http_server_connection_debug( + conn, "Received new request %s " "(%u requests pending; %u maximum)", http_server_request_label(req), conn->request_queue_count, @@ -662,8 +677,8 @@ static void http_server_connection_input(struct connection *_conn) } T_END; req->delay_destroy = FALSE; if (!cont) { - /* connection closed or request body not read yet. - the request may be destroyed now. */ + /* Connection closed or request body not read + yet. The request may be destroyed now. */ if (req->destroy_pending) http_server_request_destroy(&req); else @@ -679,78 +694,82 @@ static void http_server_connection_input(struct connection *_conn) http_server_request_unref(&req); if (conn->closed) { - /* connection got closed in destroy callback */ + /* Connection got closed in destroy callback */ break; } if (conn->close_indicated) { - /* client indicated it will close after this request; stop trying - to read more. */ + /* Client indicated it will close after this + request; stop trying to read more. */ break; } - /* finish up pending request if possible */ + /* Finish up pending request if possible */ if (!http_server_connection_finish_request(conn)) { http_server_connection_unref(&conn); return; } if (http_server_connection_pipeline_is_full(conn)) { - /* pipeline full */ + /* Pipeline full */ http_server_connection_pipeline_handle_full(conn); http_server_connection_unref(&conn); return; } - /* start new request */ + /* Start new request */ req = http_server_request_new(conn); } if (http_server_connection_unref_is_closed(conn)) { - /* connection got closed */ + /* Connection got closed */ return; } - if (ret <= 0 && - !http_server_connection_check_input(conn)) + if (ret <= 0 && !http_server_connection_check_input(conn)) return; if (ret < 0) { http_server_connection_ref(conn); - http_server_connection_client_error(conn, - "Client sent invalid request: %s", error); + http_server_connection_client_error( + conn, "Client sent invalid request: %s", error); switch (error_code) { case HTTP_REQUEST_PARSE_ERROR_BROKEN_REQUEST: conn->input_broken = TRUE; /* fall through */ case HTTP_REQUEST_PARSE_ERROR_BAD_REQUEST: - http_server_request_fail(req, 400, "Bad Request"); + http_server_request_fail( + req, 400, "Bad Request"); break; case HTTP_REQUEST_PARSE_ERROR_METHOD_TOO_LONG: conn->input_broken = TRUE; /* fall through */ case HTTP_REQUEST_PARSE_ERROR_NOT_IMPLEMENTED: - http_server_request_fail(req, 501, "Not Implemented"); + http_server_request_fail( + req, 501, "Not Implemented"); break; case HTTP_REQUEST_PARSE_ERROR_TARGET_TOO_LONG: conn->input_broken = TRUE; - http_server_request_fail_close(req, 414, "URI Too Long"); + http_server_request_fail_close( + req, 414, "URI Too Long"); break; case HTTP_REQUEST_PARSE_ERROR_EXPECTATION_FAILED: - http_server_request_fail(req, 417, "Expectation Failed"); + http_server_request_fail( + req, 417, "Expectation Failed"); break; case HTTP_REQUEST_PARSE_ERROR_PAYLOAD_TOO_LARGE: conn->input_broken = TRUE; - http_server_request_fail_close(req, 413, "Payload Too Large"); + http_server_request_fail_close( + req, 413, "Payload Too Large"); break; default: i_unreached(); } if (http_server_connection_unref_is_closed(conn)) { - /* connection got closed */ + /* Connection got closed */ return; } } @@ -772,11 +791,10 @@ http_server_connection_discard_input(struct http_server_connection *conn) i_assert(server->ioloop != NULL); - ret = http_request_parse_finish_payload - (conn->http_parser, &error_code, &error); + ret = http_request_parse_finish_payload(conn->http_parser, + &error_code, &error); - if (ret <= 0 && - !http_server_connection_check_input(conn)) { + if (ret <= 0 && !http_server_connection_check_input(conn)) { io_loop_stop(server->ioloop); return; } @@ -784,13 +802,14 @@ http_server_connection_discard_input(struct http_server_connection *conn) if (ret < 0) { http_server_connection_ref(conn); - http_server_connection_client_error(conn, - "Client sent invalid request: %s", error); + http_server_connection_client_error( + conn, "Client sent invalid request: %s", error); switch (error_code) { case HTTP_REQUEST_PARSE_ERROR_PAYLOAD_TOO_LARGE: conn->input_broken = TRUE; - http_server_request_fail_close(conn->request_queue_head, + http_server_request_fail_close( + conn->request_queue_head, 413, "Payload Too Large"); break; default: @@ -806,8 +825,7 @@ http_server_connection_discard_input(struct http_server_connection *conn) io_loop_stop(server->ioloop); } -int http_server_connection_discard_payload( - struct http_server_connection *conn) +int http_server_connection_discard_payload(struct http_server_connection *conn) { struct http_server *server = conn->server; struct ioloop *prev_ioloop = current_ioloop; @@ -818,24 +836,24 @@ int http_server_connection_discard_payload( if (conn->payload_handler != NULL) http_server_payload_handler_destroy(&conn->payload_handler); - /* destroy payload wrapper early to advance state */ + /* Destroy payload wrapper early to advance state */ if (conn->incoming_payload != NULL) { i_stream_unref(&conn->incoming_payload); conn->incoming_payload = NULL; } - /* finish reading payload from the parser */ - if (http_request_parser_pending_payload - (conn->http_parser)) { - http_server_connection_debug(conn, - "Discarding remaining incoming payload"); + /* Finish reading payload from the parser */ + if (http_request_parser_pending_payload(conn->http_parser)) { + http_server_connection_debug( + conn, "Discarding remaining incoming payload"); server->ioloop = io_loop_create(); http_server_connection_switch_ioloop(conn); io_loop_set_running(server->ioloop); - conn->conn.io = io_add_istream(conn->conn.input, - http_server_connection_discard_input, conn); + conn->conn.io = io_add_istream( + conn->conn.input, http_server_connection_discard_input, + conn); http_server_connection_discard_input(conn); if (io_loop_is_running(server->ioloop)) io_loop_run(server->ioloop); @@ -846,11 +864,11 @@ int http_server_connection_discard_payload( io_loop_set_current(server->ioloop); io_loop_destroy(&server->ioloop); } else { - http_server_connection_debug(conn, - "No remaining incoming payload"); + http_server_connection_debug( + conn, "No remaining incoming payload"); } - /* check whether connection is still viable */ + /* Check whether connection is still viable */ http_server_connection_ref(conn); (void)http_server_connection_check_input(conn); return http_server_connection_unref_is_closed(conn) ? -1 : 0; @@ -866,17 +884,17 @@ void http_server_connection_handle_output_error( if (output->stream_errno != EPIPE && output->stream_errno != ECONNRESET) { - http_server_connection_error(conn, - "Connection lost: write(%s) failed: %s", + http_server_connection_error( + conn, "Connection lost: write(%s) failed: %s", o_stream_get_name(output), o_stream_get_error(output)); - http_server_connection_close(&conn, - "Write failure"); + http_server_connection_close( + &conn, "Write failure"); } else { - http_server_connection_debug(conn, - "Connection lost: Remote disconnected"); - http_server_connection_close(&conn, - "Remote closed connection unexpectedly"); + http_server_connection_debug( + conn, "Connection lost: Remote disconnected"); + http_server_connection_close( + &conn, "Remote closed connection unexpectedly"); } } @@ -891,34 +909,38 @@ http_server_connection_next_response(struct http_server_connection *conn) req = conn->request_queue_head; if (req == NULL || req->state == HTTP_SERVER_REQUEST_STATE_NEW) { - /* no requests pending */ + /* No requests pending */ http_server_connection_debug(conn, "No more requests pending"); http_server_connection_timeout_start(conn); return FALSE; } if (req->state < HTTP_SERVER_REQUEST_STATE_READY_TO_RESPOND) { if (req->state == HTTP_SERVER_REQUEST_STATE_PROCESSING) { - /* server is causing idle time */ - http_server_connection_debug(conn, - "Not ready to respond: Server is processing"); + /* Server is causing idle time */ + http_server_connection_debug( + conn, "Not ready to respond: " + "Server is processing"); http_server_connection_timeout_stop(conn); } else { - /* client is causing idle time */ - http_server_connection_debug(conn, - "Not ready to respond: Waiting for client"); + /* Client is causing idle time */ + http_server_connection_debug( + conn, "Not ready to respond: " + "Waiting for client"); http_server_connection_timeout_start(conn); } - + /* send 100 Continue if appropriate */ - if (req->state >= HTTP_SERVER_REQUEST_STATE_QUEUED - && conn->incoming_payload != NULL - && req->response == NULL && req->req.version_minor >= 1 - && req->req.expect_100_continue && !req->payload_halted - && !req->sent_100_continue) { - static const char *response = "HTTP/1.1 100 Continue\r\n\r\n"; + if (req->state >= HTTP_SERVER_REQUEST_STATE_QUEUED && + conn->incoming_payload != NULL && + req->response == NULL && req->req.version_minor >= 1 && + req->req.expect_100_continue && !req->payload_halted && + !req->sent_100_continue) { + static const char *response = + "HTTP/1.1 100 Continue\r\n\r\n"; struct ostream *output = conn->conn.output; - if (o_stream_send(output, response, strlen(response)) < 0) { + if (o_stream_send(output, response, + strlen(response)) < 0) { http_server_connection_handle_output_error(conn); return FALSE; } @@ -930,10 +952,9 @@ http_server_connection_next_response(struct http_server_connection *conn) } i_assert(req->state == HTTP_SERVER_REQUEST_STATE_READY_TO_RESPOND && - req->response != NULL); + req->response != NULL); - http_server_connection_debug(conn, - "Sending response"); + http_server_connection_debug(conn, "Sending response"); http_server_connection_timeout_start(conn); http_server_request_ref(req); @@ -947,22 +968,23 @@ http_server_connection_next_response(struct http_server_connection *conn) return TRUE; } -static int http_server_connection_send_responses( - struct http_server_connection *conn) +static int +http_server_connection_send_responses(struct http_server_connection *conn) { http_server_connection_ref(conn); - - /* send more responses until no more responses remain, the output + + /* Send more responses until no more responses remain, the output blocks again, or the connection is closed */ while (!conn->closed && http_server_connection_next_response(conn)); - + if (http_server_connection_unref_is_closed(conn)) return -1; - /* accept more requests if possible */ + /* Accept more requests if possible */ if (conn->incoming_payload == NULL && - conn->request_queue_count < conn->server->set.max_pipelined_requests && - !conn->server->shutting_down) { + (conn->request_queue_count < + conn->server->set.max_pipelined_requests) && + !conn->server->shutting_down) { http_server_connection_input_resume(conn); return 1; } @@ -1009,26 +1031,26 @@ int http_server_connection_output(struct http_server_connection *conn) return -1; if (!conn->output_locked) { - /* room for more responses */ + /* Room for more responses */ if (http_server_connection_send_responses(conn) < 0) return -1; } else if (conn->io_resp_payload != NULL) { - /* server is causing idle time */ - http_server_connection_debug(conn, - "Not ready to continue response: " + /* Server is causing idle time */ + http_server_connection_debug( + conn, "Not ready to continue response: " "Server is producing response"); http_server_connection_timeout_stop(conn); } else { - /* client is causing idle time */ - http_server_connection_debug(conn, - "Not ready to continue response: " + /* Client is causing idle time */ + http_server_connection_debug( + conn, "Not ready to continue response: " "Waiting for client"); http_server_connection_timeout_start(conn); } } if (conn->server->shutting_down && - http_server_connection_shut_down(conn)) + http_server_connection_shut_down(conn)) return 1; if (!http_server_connection_pipeline_is_full(conn)) { @@ -1046,8 +1068,8 @@ void http_server_connection_trigger_responses( o_stream_set_flush_pending(conn->conn.output, TRUE); } -bool -http_server_connection_pending_payload(struct http_server_connection *conn) +bool http_server_connection_pending_payload( + struct http_server_connection *conn) { return http_request_parser_pending_payload(conn->http_parser); } @@ -1064,17 +1086,17 @@ static const struct connection_vfuncs http_server_connection_vfuncs = { .input = http_server_connection_input }; -struct connection_list * -http_server_connection_list_init(void) +struct connection_list *http_server_connection_list_init(void) { - return connection_list_init - (&http_server_connection_set, &http_server_connection_vfuncs); + return connection_list_init(&http_server_connection_set, + &http_server_connection_vfuncs); } struct http_server_connection * http_server_connection_create(struct http_server *server, - int fd_in, int fd_out, bool ssl, - const struct http_server_callbacks *callbacks, void *context) + int fd_in, int fd_out, bool ssl, + const struct http_server_callbacks *callbacks, + void *context) { const struct http_server_settings *set = &server->set; struct http_server_connection *conn; @@ -1138,11 +1160,11 @@ http_server_connection_disconnect(struct http_server_connection *conn, conn->disconnect_reason = i_strdup(reason); conn->closed = TRUE; - /* preserve statistics */ + /* Preserve statistics */ http_server_connection_update_stats(conn); if (conn->incoming_payload != NULL) { - /* the stream is still accessed by lib-http caller. */ + /* The stream is still accessed by lib-http caller. */ i_stream_remove_destroy_callback(conn->incoming_payload, http_server_payload_destroyed); conn->incoming_payload = NULL; @@ -1150,7 +1172,7 @@ http_server_connection_disconnect(struct http_server_connection *conn, if (conn->payload_handler != NULL) http_server_payload_handler_destroy(&conn->payload_handler); - /* drop all requests before connection is closed */ + /* Drop all requests before connection is closed */ req = conn->request_queue_head; while (req != NULL) { req_next = req->next; @@ -1188,9 +1210,9 @@ bool http_server_connection_unref(struct http_server_connection **_conn) connection_deinit(&conn->conn); if (conn->callbacks != NULL && - conn->callbacks->connection_destroy != NULL) T_BEGIN { - conn->callbacks->connection_destroy - (conn->context, conn->disconnect_reason); + conn->callbacks->connection_destroy != NULL) T_BEGIN { + conn->callbacks->connection_destroy(conn->context, + conn->disconnect_reason); } T_END; i_free(conn->disconnect_reason); @@ -1209,7 +1231,7 @@ http_server_connection_unref_is_closed(struct http_server_connection *conn) } void http_server_connection_close(struct http_server_connection **_conn, - const char *reason) + const char *reason) { struct http_server_connection *conn = *_conn; @@ -1218,12 +1240,13 @@ void http_server_connection_close(struct http_server_connection **_conn, } void http_server_connection_tunnel(struct http_server_connection **_conn, - http_server_tunnel_callback_t callback, void *context) + http_server_tunnel_callback_t callback, + void *context) { struct http_server_connection *conn = *_conn; struct http_server_tunnel tunnel; - /* preserve statistics */ + /* Preserve statistics */ http_server_connection_update_stats(conn); i_zero(&tunnel); -- 2.47.3