lib-http: server: Replace http_*_debug() with e_debug().

diff --git a/src/lib-http/http-server-connection.c b/src/lib-http/http-server-connection.c
index afa705e641cc9f0b4899dcb8ca962e68f2137f65..315f585b284d7a4aac8dbb139e5c3b223ec4925b 100644 (file)
--- a/src/lib-http/http-server-connection.c
+++ b/src/lib-http/http-server-connection.c
@@ -31,21 +31,6 @@ http_server_connection_unref_is_closed(struct http_server_connection *conn);
  * Logging
  */
 
-static inline void
-http_server_connection_debug(struct http_server_connection *conn,
-                            const char *format, ...) ATTR_FORMAT(2, 3);
-
-static inline void
-http_server_connection_debug(struct http_server_connection *conn,
-                            const char *format, ...)
-{
-       va_list args;
-
-       va_start(args, format);
-       e_debug(conn->event, "%s", 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);
@@ -197,7 +182,7 @@ static void http_server_payload_destroyed(struct http_server_request *req)
                 req->state >= HTTP_SERVER_REQUEST_STATE_FINISHED);
        i_assert(conn->conn.io == NULL);
 
-       http_server_connection_debug(conn, "Request payload stream destroyed");
+       e_debug(conn->event, "Request payload stream destroyed");
 
        /* Caller is allowed to change the socket fd to blocking while reading
           the payload. make sure here that it's switched back. */
@@ -402,7 +387,7 @@ http_server_connection_ssl_init(struct http_server_connection *conn)
                return -1;
        }
 
-       http_server_connection_debug(conn, "Starting SSL handshake");
+       e_debug(conn->event, "Starting SSL handshake");
 
        http_server_connection_input_halt(conn);
        if (server->ssl_ctx == NULL) {
@@ -447,13 +432,11 @@ static void
 http_server_connection_pipeline_handle_full(struct http_server_connection *conn)
 {
        if (conn->server->shutting_down) {
-               http_server_connection_debug(
-                       conn, "Pipeline full "
+               e_debug(conn->event, "Pipeline full "
                        "(%u requests pending; server shutting down)",
                        conn->request_queue_count);
        } else {
-               http_server_connection_debug(
-                       conn, "Pipeline full "
+               e_debug(conn->event, "Pipeline full "
                        "(%u requests pending; %u maximum)",
                        conn->request_queue_count,
                        conn->server->set.max_pipelined_requests);
@@ -481,8 +464,8 @@ http_server_connection_check_input(struct http_server_connection *conn)
                                i_stream_get_error(input));
                        http_server_connection_close(&conn, "Read failure");
                } else {
-                       http_server_connection_debug(
-                               conn, "Connection lost: Remote disconnected");
+                       e_debug(conn->event, "Connection lost: "
+                               "Remote disconnected");
 
                        if (conn->request_queue_head == NULL) {
                                /* No pending requests; close */
@@ -518,7 +501,7 @@ http_server_connection_finish_request(struct http_server_connection *conn)
        if (req != NULL &&
            req->state == HTTP_SERVER_REQUEST_STATE_SUBMITTED_RESPONSE) {
 
-               http_server_connection_debug(conn, "Finish receiving request");
+               e_debug(conn->event, "Finish receiving request");
 
                ret = http_request_parse_finish_payload(conn->http_parser,
                                                        &error_code, &error);
@@ -637,8 +620,7 @@ static void http_server_connection_input(struct connection *_conn)
                        &error_code, &error)) > 0) {
                        conn->stats.request_count++;
                        http_server_request_update_event(req);
-                       http_server_connection_debug(
-                               conn, "Received new request %s "
+                       e_debug(conn->event, "Received new request %s "
                                "(%u requests pending; %u maximum)",
                                http_server_request_label(req),
                                conn->request_queue_count,
@@ -819,8 +801,7 @@ int http_server_connection_discard_payload(struct http_server_connection *conn)
 
        /* Finish reading payload from the parser */
        if (http_request_parser_pending_payload(conn->http_parser)) {
-               http_server_connection_debug(
-                       conn, "Discarding remaining incoming payload");
+               e_debug(conn->event, "Discarding remaining incoming payload");
 
                server->ioloop = io_loop_create();
                http_server_connection_switch_ioloop(conn);
@@ -839,8 +820,7 @@ int http_server_connection_discard_payload(struct http_server_connection *conn)
                io_loop_set_current(server->ioloop);
                io_loop_destroy(&server->ioloop);
        } else {
-               http_server_connection_debug(
-                       conn, "No remaining incoming payload");
+               e_debug(conn->event, "No remaining incoming payload");
        }
 
        /* Check whether connection is still viable */
@@ -865,8 +845,7 @@ void http_server_connection_handle_output_error(
                http_server_connection_close(
                        &conn, "Write failure");
        } else {
-               http_server_connection_debug(
-                       conn, "Connection lost: Remote disconnected");
+               e_debug(conn->event, "Connection lost: Remote disconnected");
                http_server_connection_close(
                        &conn, "Remote closed connection unexpectedly");
        }
@@ -884,21 +863,19 @@ 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 */
-               http_server_connection_debug(conn, "No more requests pending");
+               e_debug(conn->event, "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: "
+                       e_debug(conn->event, "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: "
+                       e_debug(conn->event, "Not ready to respond: "
                                "Waiting for client");
                        http_server_connection_timeout_start(conn);
                }
@@ -919,7 +896,7 @@ http_server_connection_next_response(struct http_server_connection *conn)
                                return FALSE;
                        }
 
-                       http_server_connection_debug(conn, "Sent 100 Continue");
+                       e_debug(conn->event, "Sent 100 Continue");
                        req->sent_100_continue = TRUE;
                }
                return FALSE;
@@ -928,7 +905,7 @@ http_server_connection_next_response(struct http_server_connection *conn)
        i_assert(req->state == HTTP_SERVER_REQUEST_STATE_READY_TO_RESPOND &&
                 req->response != NULL);
 
-       http_server_connection_debug(conn, "Sending response");
+       e_debug(conn->event, "Sending response");
        http_server_connection_timeout_start(conn);
 
        http_server_request_ref(req);
@@ -1010,14 +987,12 @@ int http_server_connection_output(struct http_server_connection *conn)
                                return -1;
                } else if (conn->io_resp_payload != NULL) {
                        /* Server is causing idle time */
-                       http_server_connection_debug(
-                               conn, "Not ready to continue response: "
+                       e_debug(conn->event, "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: "
+                       e_debug(conn->event, "Not ready to continue response: "
                                "Waiting for client");
                        http_server_connection_timeout_start(conn);
                }
@@ -1116,7 +1091,7 @@ http_server_connection_create(struct http_server *server,
                http_server_connection_ready(conn);
        http_server_connection_timeout_start(conn);
 
-       http_server_connection_debug(conn, "Connection created");
+       e_debug(conn->event, "Connection created");
        return conn;
 }
 
@@ -1137,7 +1112,7 @@ http_server_connection_disconnect(struct http_server_connection *conn,
 
        if (reason == NULL)
                reason = "Connection closed";
-       http_server_connection_debug(conn, "Disconnected: %s", reason);
+       e_debug(conn->event, "Disconnected: %s", reason);
        conn->disconnect_reason = i_strdup(reason);
        conn->closed = TRUE;
 
@@ -1185,7 +1160,7 @@ bool http_server_connection_unref(struct http_server_connection **_conn)
 
        http_server_connection_disconnect(conn, NULL);
 
-       http_server_connection_debug(conn, "Connection destroy");
+       e_debug(conn->event, "Connection destroy");
 
        ssl_iostream_destroy(&conn->ssl_iostream);
        connection_deinit(&conn->conn);

diff --git a/src/lib-http/http-server-request.c b/src/lib-http/http-server-request.c
index 85c00e536af87090c6971365b1ab33c20e336cd1..b459924fad277bc728c9d590a1521d199bfd2c7b 100644 (file)
--- a/src/lib-http/http-server-request.c
+++ b/src/lib-http/http-server-request.c
@@ -11,21 +11,6 @@
  * Logging
  */
 
-static inline void
-http_server_request_debug(struct http_server_request *req,
-                         const char *format, ...) ATTR_FORMAT(2, 3);
-
-static inline void
-http_server_request_debug(struct http_server_request *req,
-                         const char *format, ...)
-{
-       va_list args;
-
-       va_start(args, format);
-       e_debug(req->event, "%s", t_strdup_vprintf(format, args));
-       va_end(args);
-}
-
 static inline void
 http_server_request_client_error(struct http_server_request *req,
                                 const char *format, ...) ATTR_FORMAT(2, 3);
@@ -107,7 +92,7 @@ bool http_server_request_unref(struct http_server_request **_req)
        if (--req->refcount > 0)
                return TRUE;
 
-       http_server_request_debug(req, "Free");
+       e_debug(req->event, "Free");
 
        if (req->state < HTTP_SERVER_REQUEST_STATE_FINISHED) {
                req->state = HTTP_SERVER_REQUEST_STATE_ABORTED;
@@ -138,7 +123,7 @@ void http_server_request_destroy(struct http_server_request **_req)
        struct http_server_request *req = *_req;
        struct http_server *server = req->server;
 
-       http_server_request_debug(req, "Destroy");
+       e_debug(req->event, "Destroy");
 
        /* Just make sure the request ends in a proper state */
        if (req->state < HTTP_SERVER_REQUEST_STATE_FINISHED)
@@ -176,7 +161,7 @@ void http_server_request_abort(struct http_server_request **_req,
        if (req->state >= HTTP_SERVER_REQUEST_STATE_FINISHED)
                return;
 
-       http_server_request_debug(req, "Abort");
+       e_debug(req->event, "Abort");
 
        req->conn = NULL;
        if (req->state < HTTP_SERVER_REQUEST_STATE_FINISHED) {
@@ -276,7 +261,7 @@ void http_server_request_continue_payload(struct http_server_request *req)
 
 void http_server_request_ready_to_respond(struct http_server_request *req)
 {
-       http_server_request_debug(req, "Ready to respond");
+       e_debug(req->event, "Ready to respond");
 
        req->state = HTTP_SERVER_REQUEST_STATE_READY_TO_RESPOND;
        http_server_connection_trigger_responses(req->conn);
@@ -301,7 +286,7 @@ void http_server_request_submit_response(struct http_server_request *req)
        case HTTP_SERVER_REQUEST_STATE_PROCESSING:
        case HTTP_SERVER_REQUEST_STATE_SUBMITTED_RESPONSE:
                if (!http_server_request_is_complete(req)) {
-                       http_server_request_debug(req, "Not ready to respond");
+                       e_debug(req->event, "Not ready to respond");
                        req->state = HTTP_SERVER_REQUEST_STATE_SUBMITTED_RESPONSE;
                        break;
                }
@@ -326,7 +311,7 @@ void http_server_request_finished(struct http_server_request *req)
        http_server_tunnel_callback_t tunnel_callback = resp->tunnel_callback;
        void *tunnel_context = resp->tunnel_context;
 
-       http_server_request_debug(req, "Finished");
+       e_debug(req->event, "Finished");
 
        i_assert(req->state < HTTP_SERVER_REQUEST_STATE_FINISHED);
        req->state = HTTP_SERVER_REQUEST_STATE_FINISHED;

diff --git a/src/lib-http/http-server-response.c b/src/lib-http/http-server-response.c
index b873ca846ec46d5b9e37a5ae690d19559f628d5a..41baeb8c1cc176620ce3f1e17bdbe9d00369dfe5 100644 (file)
--- a/src/lib-http/http-server-response.c
+++ b/src/lib-http/http-server-response.c
@@ -16,25 +16,6 @@ struct http_server_response_payload {
        size_t iov_pos;
 };
 
-/*
- * Logging
- */
-
-static inline void
-http_server_response_debug(struct http_server_response *resp,
-                          const char *format, ...) ATTR_FORMAT(2, 3);
-
-static inline void
-http_server_response_debug(struct http_server_response *resp,
-                          const char *format, ...)
-{
-       va_list args;
-
-       va_start(args, format);
-       e_debug(resp->event, "%s", t_strdup_vprintf(format, args));
-       va_end(args);
-}
-
 /*
  * Response
  */
@@ -93,7 +74,7 @@ http_server_response_create(struct http_server_request *req,
 
 void http_server_response_free(struct http_server_response *resp)
 {
-       http_server_response_debug(resp, "Destroy");
+       e_debug(resp->event, "Destroy");
 
        i_assert(!resp->payload_blocking);
 
@@ -231,7 +212,7 @@ http_server_response_do_submit(struct http_server_response *resp)
 
 void http_server_response_submit(struct http_server_response *resp)
 {
-       http_server_response_debug(resp, "Submitted");
+       e_debug(resp->event, "Submitted");
 
        http_server_response_do_submit(resp);
 }
@@ -246,7 +227,7 @@ void http_server_response_submit_tunnel(struct http_server_response *resp,
                                        http_server_tunnel_callback_t callback,
                                        void *context)
 {
-       http_server_response_debug(resp, "Started tunnelling");
+       e_debug(resp->event, "Started tunnelling");
 
        resp->tunnel_callback = callback;
        resp->tunnel_context = context;
@@ -264,7 +245,7 @@ http_server_response_finish_payload_out(struct http_server_response *resp)
                resp->payload_output = NULL;
        }
 
-       http_server_response_debug(resp, "Finished sending payload");
+       e_debug(resp->event, "Finished sending payload");
 
        http_server_connection_ref(conn);
        conn->output_locked = FALSE;
@@ -380,12 +361,12 @@ http_server_response_output_payload(struct http_server_response **_resp,
 
                do {
                        if (req->state < HTTP_SERVER_REQUEST_STATE_PAYLOAD_OUT) {
-                               http_server_response_debug(
-                                       resp, "Preparing to send blocking payload");
+                               e_debug(resp->event,
+                                       "Preparing to send blocking payload");
                                http_server_connection_trigger_responses(conn);
                        } else if (resp->payload_output != NULL) {
-                               http_server_response_debug(
-                                       resp, "Sending blocking payload");
+                               e_debug(resp->event,
+                                       "Sending blocking payload");
                                o_stream_unset_flush_callback(conn->conn.output);
                                o_stream_set_flush_callback(
                                        resp->payload_output,
@@ -417,8 +398,8 @@ http_server_response_output_payload(struct http_server_response **_resp,
                ret = 1;
                break;
        case HTTP_SERVER_REQUEST_STATE_ABORTED:
-               http_server_response_debug(
-                       resp, "Request aborted while sending blocking payload");
+               e_debug(resp->event,
+                       "Request aborted while sending blocking payload");
                ret = -1;
                break;
        default:
@@ -544,7 +525,7 @@ int http_server_response_send_more(struct http_server_response *resp)
                /* Output is blocking */
                conn->output_locked = TRUE;
                o_stream_set_flush_pending(output, TRUE);
-               //http_server_response_debug(resp, "Partially sent payload");
+               //e_debug(resp->event, "Partially sent payload");
                break;
        case OSTREAM_SEND_ISTREAM_RESULT_ERROR_INPUT:
                /* We're in the middle of sending a response, so the connection
@@ -688,7 +669,7 @@ static int http_server_response_send_real(struct http_server_response *resp)
                return -1;
        }
 
-       http_server_response_debug(resp, "Sent header");
+       e_debug(resp->event, "Sent header");
 
        if (resp->payload_blocking) {
                /* Blocking payload */