lib-http: Reformat test-http-server-errors.c.

diff --git a/src/lib-http/test-http-server-errors.c b/src/lib-http/test-http-server-errors.c
index 771584b6add16e85037a082f30b1a13b56f68a75..f9a1dbc9f17707a2d8742d07e2b1f2c5160e5672 100644 (file)
--- a/src/lib-http/test-http-server-errors.c
+++ b/src/lib-http/test-http-server-errors.c
@@ -31,8 +31,8 @@ struct client_connection {
        pool_t pool;
 };
 
-typedef void (*test_server_init_t)
-       (const struct http_server_settings *server_set);
+typedef void
+(*test_server_init_t)(const struct http_server_settings *server_set);
 typedef void (*test_client_init_t)(unsigned int index);
 
 /*
@@ -64,21 +64,18 @@ static void (*test_client_input)(struct client_connection *conn);
  */
 
 /* server */
-static void
-test_server_defaults(struct http_server_settings *http_set);
-static void
-test_server_run(const struct http_server_settings *http_set);
+static void test_server_defaults(struct http_server_settings *http_set);
+static void test_server_run(const struct http_server_settings *http_set);
 
 /* client */
 static void test_client_run(unsigned int index);
 
 /* test*/
-static void test_run_client_server(
-       const struct http_server_settings *server_set,
-       test_server_init_t server_test,
-       test_client_init_t client_test,
-       unsigned int client_tests_count)
-       ATTR_NULL(3);
+static void
+test_run_client_server(const struct http_server_settings *server_set,
+                      test_server_init_t server_test,
+                      test_client_init_t client_test,
+                      unsigned int client_tests_count) ATTR_NULL(3);
 
 /*
  * Slow request
@@ -92,13 +89,12 @@ test_slow_request_input(struct client_connection *conn ATTR_UNUSED)
        /* do nothing */
 }
 
-static void
-test_slow_request_connected(struct client_connection *conn)
+static void test_slow_request_connected(struct client_connection *conn)
 {
        o_stream_nsend_str(conn->conn.output,
-               "GET / HTTP/1.1\r\n"
-               "Host: example.com\r\n"
-               "\r\n");
+                          "GET / HTTP/1.1\r\n"
+                          "Host: example.com\r\n"
+                          "\r\n");
 }
 
 static void test_client_slow_request(unsigned int index)
@@ -116,8 +112,7 @@ struct _slow_request {
        bool serviced:1;
 };
 
-static void
-test_server_slow_request_destroyed(struct _slow_request *ctx)
+static void test_server_slow_request_destroyed(struct _slow_request *ctx)
 {
        test_assert(ctx->serviced);
        timeout_remove(&ctx->to_delay);
@@ -125,8 +120,7 @@ test_server_slow_request_destroyed(struct _slow_request *ctx)
        io_loop_stop(ioloop);
 }
 
-static void
-test_server_slow_request_delayed(struct _slow_request *ctx)
+static void test_server_slow_request_delayed(struct _slow_request *ctx)
 {
        struct http_server_response *resp;
        struct http_server_request *req = ctx->req;
@@ -138,12 +132,9 @@ test_server_slow_request_delayed(struct _slow_request *ctx)
        http_server_request_unref(&req);
 }
 
-static void
-test_server_slow_request_request(
-       struct http_server_request *req)
+static void test_server_slow_request_request(struct http_server_request *req)
 {
-       const struct http_request *hreq =
-               http_server_request_get(req);
+       const struct http_request *hreq = http_server_request_get(req);
        struct _slow_request *ctx;
 
        if (debug) {
@@ -155,16 +146,16 @@ test_server_slow_request_request(
        ctx = i_new(struct _slow_request, 1);
        ctx->req = req;
 
-       http_server_request_set_destroy_callback(req,
-               test_server_slow_request_destroyed, ctx);
+       http_server_request_set_destroy_callback(
+               req, test_server_slow_request_destroyed, ctx);
 
        http_server_request_ref(req);
-       ctx->to_delay = timeout_add
-               (4000, test_server_slow_request_delayed, ctx);
+       ctx->to_delay =
+               timeout_add(4000, test_server_slow_request_delayed, ctx);
 }
 
-static void test_server_slow_request
-(const struct http_server_settings *server_set)
+static void
+test_server_slow_request(const struct http_server_settings *server_set)
 {
        test_server_request = test_server_slow_request_request;
        test_server_run(server_set);
@@ -180,9 +171,8 @@ static void test_slow_request(void)
        http_server_set.max_client_idle_time_msecs = 1000;
 
        test_begin("slow request");
-       test_run_client_server(&http_server_set,
-               test_server_slow_request,
-               test_client_slow_request, 1);
+       test_run_client_server(&http_server_set, test_server_slow_request,
+                              test_client_slow_request, 1);
        test_end();
 }
 
@@ -196,11 +186,11 @@ static void
 test_hanging_request_payload_connected(struct client_connection *conn)
 {
        o_stream_nsend_str(conn->conn.output,
-               "GET / HTTP/1.1\r\n"
-               "Host: example.com\r\n"
-               "Content-Length: 1000\r\n"
-               "\r\n"
-               "To be continued... or not");
+                          "GET / HTTP/1.1\r\n"
+                          "Host: example.com\r\n"
+                          "Content-Length: 1000\r\n"
+                          "\r\n"
+                          "To be continued... or not");
 }
 
 static void test_client_hanging_request_payload(unsigned int index)
@@ -219,7 +209,8 @@ struct _hanging_request_payload {
 };
 
 static void
-test_server_hanging_request_payload_destroyed(struct _hanging_request_payload *ctx)
+test_server_hanging_request_payload_destroyed(
+       struct _hanging_request_payload *ctx)
 {
        test_assert(!ctx->serviced);
        io_remove(&ctx->io);
@@ -239,10 +230,9 @@ test_server_hanging_request_payload_input(struct _hanging_request_payload *ctx)
        if (debug)
                i_debug("test server: got more payload");
 
-       while ((ret=i_stream_read_data
-               (ctx->payload_input, &data, &size, 0)) > 0) {
+       while ((ret = i_stream_read_data(ctx->payload_input,
+                                        &data, &size, 0)) > 0)
                i_stream_skip(ctx->payload_input, size);
-       }
 
        if (ret == 0)
                return;
@@ -253,8 +243,7 @@ test_server_hanging_request_payload_input(struct _hanging_request_payload *ctx)
                }
                i_stream_unref(&ctx->payload_input);
                io_remove(&ctx->io);
-               http_server_request_fail_close(req,
-                       400, "Bad request");
+               http_server_request_fail_close(req, 400, "Bad request");
                http_server_request_unref(&req);
                return;
        }
@@ -270,11 +259,9 @@ test_server_hanging_request_payload_input(struct _hanging_request_payload *ctx)
 }
 
 static void
-test_server_hanging_request_payload_request(
-       struct http_server_request *req)
+test_server_hanging_request_payload_request(struct http_server_request *req)
 {
-       const struct http_request *hreq =
-               http_server_request_get(req);
+       const struct http_request *hreq = http_server_request_get(req);
        struct _hanging_request_payload *ctx;
 
        if (debug) {
@@ -286,20 +273,21 @@ test_server_hanging_request_payload_request(
        ctx = i_new(struct _hanging_request_payload, 1);
        ctx->req = req;
 
-       http_server_request_set_destroy_callback(req,
-               test_server_hanging_request_payload_destroyed, ctx);
+       http_server_request_set_destroy_callback(
+               req, test_server_hanging_request_payload_destroyed, ctx);
 
-       ctx->payload_input =
-               http_server_request_get_payload_input(req, FALSE);
+       ctx->payload_input = http_server_request_get_payload_input(req, FALSE);
 
        http_server_request_ref(req);
        ctx->io = io_add_istream(ctx->payload_input,
-               test_server_hanging_request_payload_input, ctx);
+                                test_server_hanging_request_payload_input,
+                                ctx);
        test_server_hanging_request_payload_input(ctx);
 }
 
-static void test_server_hanging_request_payload
-(const struct http_server_settings *server_set)
+static void
+test_server_hanging_request_payload(
+       const struct http_server_settings *server_set)
 {
        test_server_request = test_server_hanging_request_payload_request;
        test_server_run(server_set);
@@ -316,8 +304,8 @@ static void test_hanging_request_payload(void)
 
        test_begin("hanging request payload");
        test_run_client_server(&http_server_set,
-               test_server_hanging_request_payload,
-               test_client_hanging_request_payload, 1);
+                              test_server_hanging_request_payload,
+                              test_client_hanging_request_payload, 1);
        test_end();
 }
 
@@ -331,11 +319,11 @@ static void
 test_hanging_response_payload_connected(struct client_connection *conn)
 {
        o_stream_nsend_str(conn->conn.output,
-               "GET / HTTP/1.1\r\n"
-               "Host: example.com\r\n"
-               "Content-Length: 18\r\n"
-               "\r\n"
-               "Complete payload\r\n");
+                          "GET / HTTP/1.1\r\n"
+                          "Host: example.com\r\n"
+                          "Content-Length: 18\r\n"
+                          "\r\n"
+                          "Complete payload\r\n");
 }
 
 static void test_client_hanging_response_payload(unsigned int index)
@@ -354,7 +342,8 @@ struct _hanging_response_payload {
 };
 
 static void
-test_server_hanging_response_payload_destroyed(struct _hanging_response_payload *ctx)
+test_server_hanging_response_payload_destroyed(
+       struct _hanging_response_payload *ctx)
 {
        test_assert(!ctx->serviced);
        io_remove(&ctx->io);
@@ -363,8 +352,7 @@ test_server_hanging_response_payload_destroyed(struct _hanging_response_payload
 }
 
 static void
-test_server_hanging_response_payload_request(
-       struct http_server_request *req)
+test_server_hanging_response_payload_request(struct http_server_request *req)
 {
        const struct http_request *hreq =
                http_server_request_get(req);
@@ -382,26 +370,27 @@ test_server_hanging_response_payload_request(
        ctx = i_new(struct _hanging_response_payload, 1);
        ctx->req = req;
 
-       http_server_request_set_destroy_callback(req,
-               test_server_hanging_response_payload_destroyed, ctx);
+       http_server_request_set_destroy_callback(
+               req, test_server_hanging_response_payload_destroyed, ctx);
 
        resp = http_server_response_create(req, 200, "OK");
        T_BEGIN {
                payload = t_str_new(204800);
                for (i = 0; i < 3200; i++) {
                        str_append(payload,
-                               "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\r\n"
-                               "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\r\n");
+                                  "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\r\n"
+                                  "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\r\n");
                }
 
-               http_server_response_set_payload_data
-                       (resp, str_data(payload), str_len(payload));
+               http_server_response_set_payload_data(resp, str_data(payload),
+                                                     str_len(payload));
        } T_END;
        http_server_response_submit(resp);
 }
 
-static void test_server_hanging_response_payload
-(const struct http_server_settings *server_set)
+static void
+test_server_hanging_response_payload(
+       const struct http_server_settings *server_set)
 {
        test_server_request = test_server_hanging_response_payload_request;
        test_server_run(server_set);
@@ -419,8 +408,8 @@ static void test_hanging_response_payload(void)
 
        test_begin("hanging response payload");
        test_run_client_server(&http_server_set,
-               test_server_hanging_response_payload,
-               test_client_hanging_response_payload, 1);
+                              test_server_hanging_response_payload,
+                              test_client_hanging_response_payload, 1);
        test_end();
 }
 
@@ -433,7 +422,8 @@ static void test_hanging_response_payload(void)
 static void
 test_excessive_payload_length_connected1(struct client_connection *conn)
 {
-       o_stream_nsend_str(conn->conn.output,
+       o_stream_nsend_str(
+               conn->conn.output,
                "GET / HTTP/1.1\r\n"
                "Host: example.com\r\n"
                "Content-Length: 150\r\n"
@@ -443,8 +433,7 @@ test_excessive_payload_length_connected1(struct client_connection *conn)
                "Too long\r\nToo long\r\nToo long\r\nToo long\r\nToo long\r\n");
 }
 
-static void
-test_client_excessive_payload_length1(unsigned int index)
+static void test_client_excessive_payload_length1(unsigned int index)
 {
        test_client_connected = test_excessive_payload_length_connected1;
        test_client_run(index);
@@ -453,7 +442,8 @@ test_client_excessive_payload_length1(unsigned int index)
 static void
 test_excessive_payload_length_connected2(struct client_connection *conn)
 {
-       o_stream_nsend_str(conn->conn.output,
+       o_stream_nsend_str(
+               conn->conn.output,
                "GET / HTTP/1.1\r\n"
                "Host: example.com\r\n"
                "Transfer-Encoding: chunked\r\n"
@@ -471,14 +461,12 @@ test_excessive_payload_length_connected2(struct client_connection *conn)
                "\r\n");
 }
 
-static void
-test_client_excessive_payload_length2(unsigned int index)
+static void test_client_excessive_payload_length2(unsigned int index)
 {
        test_client_connected = test_excessive_payload_length_connected2;
        test_client_run(index);
 }
 
-
 /* server */
 
 struct _excessive_payload_length {
@@ -520,11 +508,9 @@ test_server_excessive_payload_length_finished(
 }
 
 static void
-test_server_excessive_payload_length_request(
-       struct http_server_request *req)
+test_server_excessive_payload_length_request(struct http_server_request *req)
 {
-       const struct http_request *hreq =
-               http_server_request_get(req);
+       const struct http_request *hreq = http_server_request_get(req);
        struct _excessive_payload_length *ctx;
 
        if (debug) {
@@ -537,14 +523,16 @@ test_server_excessive_payload_length_request(
        ctx->req = req;
        ctx->buffer = buffer_create_dynamic(default_pool, 128);
 
-       http_server_request_set_destroy_callback(req,
-               test_server_excessive_payload_length_destroyed, ctx);
-       http_server_request_buffer_payload(req, ctx->buffer, 128,
+       http_server_request_set_destroy_callback(
+               req, test_server_excessive_payload_length_destroyed, ctx);
+       http_server_request_buffer_payload(
+               req, ctx->buffer, 128,
                test_server_excessive_payload_length_finished, ctx);
 }
 
-static void test_server_excessive_payload_length
-(const struct http_server_settings *server_set)
+static void
+test_server_excessive_payload_length(
+       const struct http_server_settings *server_set)
 {
        test_server_request = test_server_excessive_payload_length_request;
        test_server_run(server_set);
@@ -561,14 +549,14 @@ static void test_excessive_payload_length(void)
 
        test_begin("excessive payload length (length)");
        test_run_client_server(&http_server_set,
-               test_server_excessive_payload_length,
-               test_client_excessive_payload_length1, 1);
+                              test_server_excessive_payload_length,
+                              test_client_excessive_payload_length1, 1);
        test_end();
 
        test_begin("excessive payload length (chunked)");
        test_run_client_server(&http_server_set,
-               test_server_excessive_payload_length,
-               test_client_excessive_payload_length2, 1);
+                              test_server_excessive_payload_length,
+                              test_client_excessive_payload_length2, 1);
        test_end();
 }
 
@@ -590,8 +578,7 @@ static void (*const test_functions[])(void) = {
 
 /* client connection */
 
-static void
-client_connection_input(struct connection *_conn)
+static void client_connection_input(struct connection *_conn)
 {
        struct client_connection *conn = (struct client_connection *)_conn;
        
@@ -599,8 +586,7 @@ client_connection_input(struct connection *_conn)
                test_client_input(conn);
 }
 
-static void
-client_connection_connected(struct connection *_conn, bool success)
+static void client_connection_connected(struct connection *_conn, bool success)
 {
        struct client_connection *conn = (struct client_connection *)_conn;
 
@@ -608,8 +594,7 @@ client_connection_connected(struct connection *_conn, bool success)
                test_client_connected(conn);
 }
 
-static void
-client_connection_init(const struct ip_addr *ip, in_port_t port)
+static void client_connection_init(const struct ip_addr *ip, in_port_t port)
 {
        struct client_connection *conn;
        pool_t pool;
@@ -623,8 +608,7 @@ client_connection_init(const struct ip_addr *ip, in_port_t port)
        (void)connection_client_connect(&conn->conn);
 }
 
-static void
-server_connection_deinit(struct client_connection **_conn)
+static void server_connection_deinit(struct client_connection **_conn)
 {
        struct client_connection *conn = *_conn;
 
@@ -634,11 +618,9 @@ server_connection_deinit(struct client_connection **_conn)
        pool_unref(&conn->pool);
 }
 
-static void
-client_connection_destroy(struct connection *_conn)
+static void client_connection_destroy(struct connection *_conn)
 {
-       struct client_connection *conn =
-               (struct client_connection *)_conn;
+       struct client_connection *conn = (struct client_connection *)_conn;
 
        server_connection_deinit(&conn);
 }
@@ -664,8 +646,8 @@ static void test_client_run(unsigned int index)
        if (debug)
                i_debug("client connecting to %u", bind_port);
 
-       client_conn_list = connection_list_init
-               (&client_connection_set, &client_connection_vfuncs);
+       client_conn_list = connection_list_init(&client_connection_set,
+                                               &client_connection_vfuncs);
 
        client_connection_init(&bind_ip, bind_port);
 
@@ -681,8 +663,7 @@ static void test_client_run(unsigned int index)
  * Test server
  */
 
-static void
-test_server_defaults(struct http_server_settings *http_set)
+static void test_server_defaults(struct http_server_settings *http_set)
 {
        /* server settings */
        i_zero(http_set);
@@ -695,7 +676,7 @@ test_server_defaults(struct http_server_settings *http_set)
 
 static void
 server_handle_request(void *context ATTR_UNUSED,
-       struct http_server_request *req)
+                     struct http_server_request *req)
 {
        test_server_request(req);
 }
@@ -704,8 +685,7 @@ struct http_server_callbacks http_server_callbacks = {
        .handle_request = server_handle_request
 };
 
-static void
-server_connection_accept(void *context ATTR_UNUSED)
+static void server_connection_accept(void *context ATTR_UNUSED)
 {
        int fd;
 
@@ -718,28 +698,24 @@ server_connection_accept(void *context ATTR_UNUSED)
        }
 
        (void)http_server_connection_create(http_server, fd, fd, FALSE,
-               &http_server_callbacks, NULL);
+                                           &http_server_callbacks, NULL);
 }
 
 /* */
 
-static void
-test_server_timeout(void *context ATTR_UNUSED)
+static void test_server_timeout(void *context ATTR_UNUSED)
 {
        i_fatal("Server timed out");
 }
 
-static void
-test_server_run(const struct http_server_settings *http_set)
+static void test_server_run(const struct http_server_settings *http_set)
 {
        struct timeout *to;
 
-       to = timeout_add(SERVER_MAX_TIMEOUT_MSECS,
-               test_server_timeout, NULL);
+       to = timeout_add(SERVER_MAX_TIMEOUT_MSECS, test_server_timeout, NULL);
 
        /* open server socket */
-       io_listen = io_add(fd_listen,
-               IO_READ, server_connection_accept, NULL);
+       io_listen = io_add(fd_listen, IO_READ, server_connection_accept, NULL);
 
        http_server = http_server_init(http_set);
 
@@ -784,11 +760,11 @@ static void test_clients_kill_all(void)
        client_pids_count = 0;
 }
 
-static void test_run_client_server(
-       const struct http_server_settings *server_set,
-       test_server_init_t server_test,
-       test_client_init_t client_test,
-       unsigned int client_tests_count)
+static void
+test_run_client_server(const struct http_server_settings *server_set,
+                      test_server_init_t server_test,
+                      test_client_init_t client_test,
+                      unsigned int client_tests_count)
 {
        unsigned int i;
 
@@ -810,18 +786,21 @@ static void test_run_client_server(
                                client_pids[i] = (pid_t)-1;
                                client_pids_count = 0;
                                hostpid_init();
-                               if (debug)
-                                       i_debug("client[%d]: PID=%s", i+1, my_pid);
-                               /* child: client */
-                               /* wait a little for server setup */
+                               if (debug) {
+                                       i_debug("client[%d]: PID=%s",
+                                               i+1, my_pid);
+                               }
+                               /* Child: client */
+                               /* Wait a little for server setup */
                                i_sleep_msecs(100);
                                i_close_fd(&fd_listen);
                                ioloop = io_loop_create();
                                client_test(i);
                                io_loop_destroy(&ioloop);
                                i_free(client_pids);
-                               /* wait for it to be killed; this way, valgrind will not
-                                  object to this process going away inelegantly. */
+                               /* Wait for it to be killed; this way, valgrind
+                                  will not object to this process going away
+                                  inelegantly. */
                                sleep(60);
                                exit(1);
                        }
@@ -830,7 +809,7 @@ static void test_run_client_server(
                        i_debug("server: PID=%s", my_pid);
        }
 
-       /* parent: server */
+       /* Parent: server */
 
        ioloop = io_loop_create();
        server_test(server_set);
@@ -848,8 +827,7 @@ static void test_run_client_server(
 
 volatile sig_atomic_t terminating = 0;
 
-static void
-test_signal_handler(int signo)
+static void test_signal_handler(int signo)
 {
        if (terminating != 0)
                raise(signo);
@@ -879,7 +857,7 @@ int main(int argc, char *argv[])
        (void)signal(SIGSEGV, test_signal_handler);
        (void)signal(SIGABRT, test_signal_handler);
 
-  while ((c = getopt(argc, argv, "D")) > 0) {
+       while ((c = getopt(argc, argv, "D")) > 0) {
                switch (c) {
                case 'D':
                        debug = TRUE;
@@ -887,7 +865,7 @@ int main(int argc, char *argv[])
                default:
                        i_fatal("Usage: %s [-D]", argv[0]);
                }
-  }
+       }
 
        /* listen on localhost */
        i_zero(&bind_ip);