diff options
Diffstat (limited to '')
| -rw-r--r-- | src/lib-http/test-http-client-errors.c | 3944 |
1 files changed, 3944 insertions, 0 deletions
diff --git a/src/lib-http/test-http-client-errors.c b/src/lib-http/test-http-client-errors.c new file mode 100644 index 0000000..e127041 --- /dev/null +++ b/src/lib-http/test-http-client-errors.c @@ -0,0 +1,3944 @@ +/* Copyright (c) 2016-2018 Dovecot authors, see the included COPYING file */ + +#include "lib.h" +#include "str.h" +#include "str-sanitize.h" +#include "hostpid.h" +#include "ioloop.h" +#include "istream.h" +#include "istream-chain.h" +#include "ostream.h" +#include "time-util.h" +#include "sleep.h" +#include "connection.h" +#include "test-common.h" +#include "test-subprocess.h" +#include "http-url.h" +#include "http-request.h" +#include "http-client.h" + +#include <unistd.h> +#include <sys/signal.h> + +#define CLIENT_PROGRESS_TIMEOUT 10 +#define SERVER_KILL_TIMEOUT_SECS 20 + +static void main_deinit(void); + +/* + * Types + */ + +struct server_connection { + struct connection conn; + void *context; + + pool_t pool; + bool version_sent:1; +}; + +typedef void (*test_server_init_t)(unsigned int index); +typedef bool +(*test_client_init_t)(const struct http_client_settings *client_set); +typedef void (*test_dns_init_t)(void); + +/* + * State + */ + +/* common */ +static struct ip_addr bind_ip; +static in_port_t *bind_ports = 0; +static struct ioloop *ioloop; +static bool debug = FALSE; + +/* server */ +static struct io *io_listen; +static int fd_listen = -1; +static struct connection_list *server_conn_list; +static size_t server_read_max = 0; +static unsigned int server_index; +static int (*test_server_init)(struct server_connection *conn); +static void (*test_server_deinit)(struct server_connection *conn); +static void (*test_server_input)(struct server_connection *conn); + +/* client */ +static struct timeout *to_client_progress = NULL; +static struct http_client *http_client = NULL; + +/* + * Forward declarations + */ + +/* server */ +static void test_server_run(unsigned int index); +static void server_connection_deinit(struct server_connection **_conn); + +/* client */ +static void test_client_defaults(struct http_client_settings *http_set); +static void test_client_deinit(void); + +/* test*/ +static void +test_run_client_server(const struct http_client_settings *client_set, + test_client_init_t client_test, + test_server_init_t server_test, + unsigned int server_tests_count, + test_dns_init_t dns_test) ATTR_NULL(3); + +/* + * Utility + */ + +static void +test_client_assert_response(const struct http_response *resp, + bool condition) +{ + const char *reason = (resp->reason != NULL ? resp->reason : "<NULL>"); + + test_assert(resp->reason != NULL && *resp->reason != '\0'); + + if (!condition) + i_error("BAD RESPONSE: %u %s", resp->status, reason); + else if (debug) + i_debug("RESPONSE: %u %s", resp->status, resp->reason); +} + +/* + * Unconfigured SSL + */ + +/* client */ + +struct _unconfigured_ssl { + unsigned int count; +}; + +static void +test_client_unconfigured_ssl_response(const struct http_response *resp, + struct _unconfigured_ssl *ctx) +{ + test_client_assert_response( + resp, resp->status == HTTP_CLIENT_REQUEST_ERROR_CONNECT_FAILED); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static bool +test_client_unconfigured_ssl(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _unconfigured_ssl *ctx; + + ctx = i_new(struct _unconfigured_ssl, 1); + ctx->count = 2; + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", "127.0.0.1", "/unconfigured-ssl.txt", + test_client_unconfigured_ssl_response, ctx); + http_client_request_set_ssl(hreq, TRUE); + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", "127.0.0.1", "/unconfigured-ssl2.txt", + test_client_unconfigured_ssl_response, ctx); + http_client_request_set_ssl(hreq, TRUE); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_unconfigured_ssl(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + + test_begin("unconfigured ssl"); + test_run_client_server(&http_client_set, + test_client_unconfigured_ssl, NULL, 0, NULL); + test_end(); +} + +/* + * Unconfigured SSL abort + */ + +/* client */ + +struct _unconfigured_ssl_abort { + unsigned int count; +}; + +static void +test_client_unconfigured_ssl_abort_response1( + const struct http_response *resp, + struct _unconfigured_ssl_abort *ctx ATTR_UNUSED) +{ + if (debug) + i_debug("RESPONSE: %u %s", resp->status, resp->reason); + + test_out_quiet("inappropriate callback", FALSE); +} + +static void +test_client_unconfigured_ssl_abort_response2( + const struct http_response *resp, struct _unconfigured_ssl_abort *ctx) +{ + test_client_assert_response( + resp, resp->status == HTTP_CLIENT_REQUEST_ERROR_CONNECT_FAILED); + + i_free(ctx); + io_loop_stop(ioloop); +} + +static bool +test_client_unconfigured_ssl_abort( + const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _unconfigured_ssl_abort *ctx; + + ctx = i_new(struct _unconfigured_ssl_abort, 1); + ctx->count = 1; + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", "127.0.0.1", "/unconfigured-ssl.txt", + test_client_unconfigured_ssl_abort_response1, ctx); + http_client_request_set_ssl(hreq, TRUE); + http_client_request_submit(hreq); + http_client_request_abort(&hreq); + + hreq = http_client_request( + http_client, "GET", "127.0.0.1", "/unconfigured-ssl2.txt", + test_client_unconfigured_ssl_abort_response2, ctx); + http_client_request_set_ssl(hreq, TRUE); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_unconfigured_ssl_abort(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + + test_begin("unconfigured ssl abort"); + test_run_client_server(&http_client_set, + test_client_unconfigured_ssl_abort, + NULL, 0, NULL); + test_end(); +} + +/* + * Invalid URL + */ + +/* client */ + +struct _invalid_url { + unsigned int count; +}; + +static void +test_client_invalid_url_response(const struct http_response *resp, + struct _invalid_url *ctx) +{ + test_client_assert_response( + resp, resp->status == HTTP_CLIENT_REQUEST_ERROR_INVALID_URL); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static bool +test_client_invalid_url(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _invalid_url *ctx; + + ctx = i_new(struct _invalid_url, 1); + ctx->count = 2; + + http_client = http_client_init(client_set); + + hreq = http_client_request_url_str( + http_client, "GET", "imap://example.com/INBOX", + test_client_invalid_url_response, ctx); + http_client_request_submit(hreq); + + hreq = http_client_request_url_str( + http_client, "GET", "http:/www.example.com", + test_client_invalid_url_response, ctx); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_invalid_url(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + + test_begin("invalid url"); + test_run_client_server(&http_client_set, + test_client_invalid_url, NULL, 0, NULL); + test_end(); +} + +/* + * Host lookup failed + */ + +/* client */ + +struct _host_lookup_failed { + unsigned int count; +}; + +static void +test_client_host_lookup_failed_response(const struct http_response *resp, + struct _host_lookup_failed *ctx) +{ + test_client_assert_response( + resp, + resp->status == HTTP_CLIENT_REQUEST_ERROR_HOST_LOOKUP_FAILED); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static bool +test_client_host_lookup_failed(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _host_lookup_failed *ctx; + + ctx = i_new(struct _host_lookup_failed, 1); + ctx->count = 2; + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", "host.in-addr.arpa", + "/host-lookup-failed.txt", + test_client_host_lookup_failed_response, ctx); + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", "host.in-addr.arpa", + "/host-lookup-failed2.txt", + test_client_host_lookup_failed_response, ctx); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_host_lookup_failed(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + + test_begin("host lookup failed"); + test_run_client_server(&http_client_set, + test_client_host_lookup_failed, NULL, 0, NULL); + test_end(); +} + +/* + * Connection refused + */ + +/* server */ + +static void +test_server_connection_refused(unsigned int index ATTR_UNUSED) +{ + i_close_fd(&fd_listen); + + test_subprocess_notify_signal_send_parent(SIGUSR1); +} + +/* client */ + +struct _connection_refused { + unsigned int count; + struct timeout *to; +}; + +static void +test_client_connection_refused_response(const struct http_response *resp, + struct _connection_refused *ctx) +{ + test_assert(ctx->to == NULL); + timeout_remove(&ctx->to); + + test_client_assert_response( + resp, resp->status == HTTP_CLIENT_REQUEST_ERROR_CONNECT_FAILED); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static void +test_client_connection_refused_timeout(struct _connection_refused *ctx) +{ + if (debug) + i_debug("TIMEOUT (ok)"); + timeout_remove(&ctx->to); +} + +static bool +test_client_connection_refused(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _connection_refused *ctx; + + /* wait for the server side to close the socket */ + test_subprocess_notify_signal_wait(SIGUSR1, 10000); + + ctx = i_new(struct _connection_refused, 1); + ctx->count = 2; + + if (client_set->max_connect_attempts > 0) { + ctx->to = timeout_add_short(250, + test_client_connection_refused_timeout, ctx); + } + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/connection-refused.txt", + test_client_connection_refused_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/connection-refused2.txt", + test_client_connection_refused_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_connection_refused(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + + test_begin("connection refused"); + test_subprocess_notify_signal_reset(SIGUSR1); + test_run_client_server(&http_client_set, + test_client_connection_refused, + test_server_connection_refused, 1, NULL); + test_end(); + + http_client_set.max_connect_attempts = 3; + + test_begin("connection refused backoff"); + test_subprocess_notify_signal_reset(SIGUSR1); + test_run_client_server(&http_client_set, + test_client_connection_refused, + test_server_connection_refused, 1, NULL); + test_end(); +} + +/* + * Connection lost prematurely + */ + +/* server */ + +static void +test_server_connection_lost_prematurely_input(struct server_connection *conn) +{ + server_connection_deinit(&conn); +} + +static void test_server_connection_lost_prematurely(unsigned int index) +{ + test_server_input = test_server_connection_lost_prematurely_input; + test_server_run(index); +} + +/* client */ + +struct _connection_lost_prematurely { + unsigned int count; + struct timeout *to; +}; + +static void +test_client_connection_lost_prematurely_response( + const struct http_response *resp, + struct _connection_lost_prematurely *ctx) +{ + test_assert(ctx->to == NULL); + timeout_remove(&ctx->to); + + test_client_assert_response( + resp, + resp->status == HTTP_CLIENT_REQUEST_ERROR_CONNECTION_LOST); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static void +test_client_connection_lost_prematurely_timeout( + struct _connection_lost_prematurely *ctx) +{ + if (debug) + i_debug("TIMEOUT (ok)"); + timeout_remove(&ctx->to); +} + +static bool +test_client_connection_lost_prematurely( + const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _connection_lost_prematurely *ctx; + + ctx = i_new(struct _connection_lost_prematurely, 1); + ctx->count = 2; + + ctx->to = timeout_add_short( + 250, test_client_connection_lost_prematurely_timeout, ctx); + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/connection-refused-retry.txt", + test_client_connection_lost_prematurely_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/connection-refused-retry2.txt", + test_client_connection_lost_prematurely_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_connection_lost_prematurely(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + http_client_set.max_connect_attempts = 3; + http_client_set.max_attempts = 3; + + test_begin("connection lost prematurely"); + test_run_client_server(&http_client_set, + test_client_connection_lost_prematurely, + test_server_connection_lost_prematurely, 1, + NULL); + test_end(); +} + +/* + * Connection timed out + */ + +/* client */ + +struct _connection_timed_out { + unsigned int count; +}; + +static void +test_client_connection_timed_out_response(const struct http_response *resp, + struct _connection_timed_out *ctx) +{ + test_client_assert_response( + resp, resp->status == HTTP_CLIENT_REQUEST_ERROR_CONNECT_FAILED); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static bool +test_client_connection_timed_out(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _connection_timed_out *ctx; + + ctx = i_new(struct _connection_timed_out, 1); + ctx->count = 2; + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", "192.168.0.0", "/connection-timed-out.txt", + test_client_connection_timed_out_response, ctx); + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", "192.168.0.0", "/connection-timed-out2.txt", + test_client_connection_timed_out_response, ctx); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_connection_timed_out(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + http_client_set.connect_timeout_msecs = 1000; + http_client_set.max_attempts = 1; + + test_begin("connection timed out"); + test_run_client_server(&http_client_set, + test_client_connection_timed_out, NULL, 0, NULL); + test_end(); +} + +/* + * Invalid redirect + */ + +/* server */ + +/* -> not accepted */ + +static void test_invalid_redirect_input1(struct server_connection *conn) +{ + static const char *resp = + "HTTP/1.1 302 Redirect\r\n" + "Location: http://localhost:4444\r\n" + "\r\n"; + + o_stream_nsend_str(conn->conn.output, resp); + server_connection_deinit(&conn); +} + +static void test_server_invalid_redirect1(unsigned int index) +{ + test_server_input = test_invalid_redirect_input1; + test_server_run(index); +} + +/* -> bad location */ + +static void test_invalid_redirect_input2(struct server_connection *conn) +{ + static const char *resp = + "HTTP/1.1 302 Redirect\r\n" + "Location: unix:/var/run/dovecot/auth-master\r\n" + "\r\n"; + + o_stream_nsend_str(conn->conn.output, resp); + server_connection_deinit(&conn); +} + +static void test_server_invalid_redirect2(unsigned int index) +{ + test_server_input = test_invalid_redirect_input2; + test_server_run(index); +} + +/* -> too many */ + +static void test_invalid_redirect_input3(struct server_connection *conn) +{ + string_t *resp; + + resp = t_str_new(512); + str_printfa(resp, + "HTTP/1.1 302 Redirect\r\n" + "Location: http://%s:%u/friep.txt\r\n" + "\r\n", + net_ip2addr(&bind_ip), bind_ports[server_index+1]); + o_stream_nsend(conn->conn.output, str_data(resp), str_len(resp)); + server_connection_deinit(&conn); +} + +static void test_server_invalid_redirect3(unsigned int index) +{ + test_server_input = test_invalid_redirect_input3; + test_server_run(index); +} + +/* client */ + +static void +test_client_invalid_redirect_response(const struct http_response *resp, + void *context ATTR_UNUSED) +{ + test_client_assert_response( + resp, + resp->status == HTTP_CLIENT_REQUEST_ERROR_INVALID_REDIRECT); + + io_loop_stop(ioloop); +} + +static bool +test_client_invalid_redirect(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/invalid-redirect.txt", + test_client_invalid_redirect_response, NULL); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_invalid_redirect(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + + test_begin("invalid redirect: not accepted"); + http_client_set.max_redirects = 0; + test_run_client_server(&http_client_set, + test_client_invalid_redirect, + test_server_invalid_redirect1, 1, NULL); + test_end(); + + test_begin("invalid redirect: bad location"); + http_client_set.max_redirects = 1; + test_run_client_server(&http_client_set, + test_client_invalid_redirect, + test_server_invalid_redirect2, 1, NULL); + test_end(); + + test_begin("invalid redirect: too many"); + http_client_set.max_redirects = 1; + test_run_client_server(&http_client_set, + test_client_invalid_redirect, + test_server_invalid_redirect3, 3, NULL); + test_end(); +} + +/* + * Unseekable redirect + */ + +/* server */ + +static void test_unseekable_redirect_input(struct server_connection *conn) +{ + string_t *resp; + + resp = t_str_new(512); + str_printfa(resp, + "HTTP/1.1 302 Redirect\r\n" + "Location: http://%s:%u/frml.txt\r\n" + "\r\n", + net_ip2addr(&bind_ip), bind_ports[server_index+1]); + o_stream_nsend(conn->conn.output, str_data(resp), str_len(resp)); + server_connection_deinit(&conn); +} + +static void test_server_unseekable_redirect(unsigned int index) +{ + test_server_input = test_unseekable_redirect_input; + test_server_run(index); +} + +/* client */ + +static void +test_client_unseekable_redirect_response(const struct http_response *resp, + void *context ATTR_UNUSED) +{ + test_client_assert_response( + resp, resp->status == HTTP_CLIENT_REQUEST_ERROR_ABORTED); + + io_loop_stop(ioloop); +} + +static bool +test_client_unseekable_redirect(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct istream *input; + + http_client = http_client_init(client_set); + + input = i_stream_create_from_data("FROP", 4); + input->seekable = FALSE; + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/unseekable-redirect.txt", + test_client_unseekable_redirect_response, NULL); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_set_payload(hreq, input, FALSE); + http_client_request_submit(hreq); + + i_stream_unref(&input); + return TRUE; +} + +/* test */ + +static void test_unseekable_redirect(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + http_client_set.max_redirects = 1; + + test_begin("unseekable redirect"); + test_run_client_server(&http_client_set, + test_client_unseekable_redirect, + test_server_unseekable_redirect, 2, NULL); + test_end(); +} + +/* + * Unseekable retry + */ + +/* server */ + +static void test_unseekable_retry_input(struct server_connection *conn) +{ + server_connection_deinit(&conn); +} + +static void test_server_unseekable_retry(unsigned int index) +{ + test_server_input = test_unseekable_retry_input; + test_server_run(index); +} + +/* client */ + +static void +test_client_unseekable_retry_response(const struct http_response *resp, + void *context ATTR_UNUSED) +{ + test_client_assert_response( + resp, resp->status == HTTP_CLIENT_REQUEST_ERROR_ABORTED); + + io_loop_stop(ioloop); +} + +static bool +test_client_unseekable_retry(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct istream *input; + + http_client = http_client_init(client_set); + + input = i_stream_create_from_data("FROP", 4); + input->seekable = FALSE; + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/unseekable-retry.txt", + test_client_unseekable_retry_response, NULL); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_set_payload(hreq, input, FALSE); + http_client_request_submit(hreq); + + i_stream_unref(&input); + return TRUE; +} + +/* test */ + +static void test_unseekable_retry(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + http_client_set.max_attempts = 3; + + test_begin("unseekable retry"); + test_run_client_server(&http_client_set, + test_client_unseekable_retry, + test_server_unseekable_retry, 2, NULL); + test_end(); +} + +/* + * Broken payload + */ + +/* server */ + +static void test_broken_payload_input(struct server_connection *conn) +{ + static const char *resp = + "HTTP/1.1 200 OK\r\n" + "Content-Length: 18\r\n" + "\r\n" + "Everything is OK\r\n"; + + o_stream_nsend_str(conn->conn.output, resp); + server_connection_deinit(&conn); +} + +static void test_server_broken_payload(unsigned int index) +{ + test_server_input = test_broken_payload_input; + test_server_run(index); +} + +/* client */ + +static void +test_client_broken_payload_response(const struct http_response *resp, + void *context ATTR_UNUSED) +{ + test_client_assert_response( + resp, resp->status == HTTP_CLIENT_REQUEST_ERROR_BROKEN_PAYLOAD); + + io_loop_stop(ioloop); +} + +static bool +test_client_broken_payload(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct istream *input; + + test_expect_errors(1); + + http_client = http_client_init(client_set); + + input = i_stream_create_error_str(EIO, "Moehahahaha!!"); + i_stream_set_name(input, "PURE EVIL"); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/broken-payload.txt", + test_client_broken_payload_response, NULL); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_set_payload(hreq, input, FALSE); + http_client_request_submit(hreq); + + i_stream_unref(&input); + return TRUE; +} + +/* test */ + +static void test_broken_payload(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + + test_begin("broken payload"); + test_run_client_server(&http_client_set, + test_client_broken_payload, + test_server_broken_payload, 1, NULL); + test_end(); +} + +/* + * Retry payload + */ + +/* server */ + +struct _retry_payload_sctx { + bool eoh; +}; + +static int test_retry_payload_init(struct server_connection *conn) +{ + struct _retry_payload_sctx *ctx; + + ctx = p_new(conn->pool, struct _retry_payload_sctx, 1); + conn->context = ctx; + return 0; +} + +static void test_retry_payload_input(struct server_connection *conn) +{ + struct _retry_payload_sctx *ctx = conn->context; + const char *line; + + while ((line = i_stream_read_next_line(conn->conn.input)) != NULL) { + if (*line == '\0') { + ctx->eoh = TRUE; + continue; + } + if (ctx->eoh) + break; + } + + if (conn->conn.input->stream_errno != 0) { + i_fatal("server: Stream error: %s", + i_stream_get_error(conn->conn.input)); + } + if (line == NULL) { + if (conn->conn.input->eof) + i_fatal("server: Client stream ended prematurely"); + return; + } + + i_assert(ctx->eoh); + + if (strcmp(line, "This is the payload we expect.") == 0) { + if (debug) + i_debug("Expected payload received"); + o_stream_nsend_str(conn->conn.output, + "HTTP/1.1 500 Oh no!\r\n" + "Connection: close\r\n" + "Content-Length: 17\r\n" + "\r\n" + "Expected result\r\n"); + } else { + i_error("Unexpected payload received: `%s'", + str_sanitize(line, 128)); + o_stream_nsend_str(conn->conn.output, + "HTTP/1.1 501 Oh no!\r\n" + "Connection: close\r\n" + "Content-Length: 19\r\n" + "\r\n" + "Unexpected result\r\n"); + } + server_connection_deinit(&conn); +} + +static void test_server_retry_payload(unsigned int index) +{ + test_server_init = test_retry_payload_init; + test_server_input = test_retry_payload_input; + test_server_run(index); +} + +/* client */ + +struct _retry_payload_ctx { + unsigned int count; +}; + +struct _retry_payload_request_ctx { + struct _retry_payload_ctx *ctx; + struct http_client_request *req; +}; + +static void +test_client_retry_payload_response(const struct http_response *resp, + struct _retry_payload_request_ctx *rctx) +{ + struct _retry_payload_ctx *ctx = rctx->ctx; + + test_client_assert_response(resp, resp->status == 500); + + if (http_client_request_try_retry(rctx->req)) { + if (debug) + i_debug("retrying"); + return; + } + i_free(rctx); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static bool +test_client_retry_payload(const struct http_client_settings *client_set) +{ + static const char payload[] = "This is the payload we expect.\r\n"; + struct _retry_payload_ctx *ctx; + struct _retry_payload_request_ctx *rctx; + struct http_client_request *hreq; + struct istream *input; + + ctx = i_new(struct _retry_payload_ctx, 1); + ctx->count = 1; + + http_client = http_client_init(client_set); + + input = i_stream_create_from_data(payload, sizeof(payload)-1); + + rctx = i_new(struct _retry_payload_request_ctx, 1); + rctx->ctx = ctx; + + rctx->req = hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), "/retry-payload.txt", + test_client_retry_payload_response, rctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_set_payload(hreq, input, FALSE); + http_client_request_submit(hreq); + + i_stream_unref(&input); + return TRUE; +} + +/* test */ + +static void test_retry_payload(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + http_client_set.max_attempts = 2; + + server_read_max = 0; + + test_begin("retry payload"); + test_run_client_server(&http_client_set, + test_client_retry_payload, + test_server_retry_payload, 1, NULL); + test_end(); +} + +/* + * Connection lost + */ + +/* server */ + +static void test_connection_lost_input(struct server_connection *conn) +{ + ssize_t ret; + + if (server_read_max == 0) { + server_connection_deinit(&conn); + return; + } + + i_stream_set_max_buffer_size(conn->conn.input, server_read_max); + ret = i_stream_read(conn->conn.input); + if (ret == -2) { + server_connection_deinit(&conn); + return; + } + if (ret < 0) { + i_assert(conn->conn.input->eof); + if (conn->conn.input->stream_errno == 0) + i_fatal("server: Client stream ended prematurely"); + else + i_fatal("server: Stream error: %s", + i_stream_get_error(conn->conn.input)); + } +} + +static void test_server_connection_lost(unsigned int index) +{ + test_server_input = test_connection_lost_input; + test_server_run(index); +} + +/* client */ + +struct _connection_lost_ctx { + unsigned int count; +}; + +struct _connection_lost_request_ctx { + struct _connection_lost_ctx *ctx; + struct http_client_request *req; +}; + +static void +test_client_connection_lost_response(const struct http_response *resp, + struct _connection_lost_request_ctx *rctx) +{ + struct _connection_lost_ctx *ctx = rctx->ctx; + + test_client_assert_response( + resp, + resp->status == HTTP_CLIENT_REQUEST_ERROR_CONNECTION_LOST); + + if (http_client_request_try_retry(rctx->req)) { + if (debug) + i_debug("retrying"); + return; + } + i_free(rctx); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static bool +test_client_connection_lost(const struct http_client_settings *client_set) +{ + static const char payload[] = + "This is a useless payload that only serves as a means to give " + "the server the opportunity to close the connection before the " + "payload is finished."; + struct _connection_lost_ctx *ctx; + struct _connection_lost_request_ctx *rctx; + struct http_client_request *hreq; + struct istream *input; + + ctx = i_new(struct _connection_lost_ctx, 1); + ctx->count = 2; + + http_client = http_client_init(client_set); + + input = i_stream_create_from_data(payload, sizeof(payload)-1); + + rctx = i_new(struct _connection_lost_request_ctx, 1); + rctx->ctx = ctx; + + rctx->req = hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/connection-lost.txt", + test_client_connection_lost_response, rctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_set_payload(hreq, input, FALSE); + http_client_request_submit(hreq); + + rctx = i_new(struct _connection_lost_request_ctx, 1); + rctx->ctx = ctx; + + rctx->req = hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/connection-lost2.txt", + test_client_connection_lost_response, rctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + i_stream_unref(&input); + return TRUE; +} + +/* test */ + +static void test_connection_lost(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + + server_read_max = 0; + + test_begin("connection lost: one attempt"); + http_client_set.max_attempts = 1; + test_run_client_server(&http_client_set, + test_client_connection_lost, + test_server_connection_lost, 1, NULL); + test_end(); + + test_begin("connection lost: two attempts"); + http_client_set.max_attempts = 2; + test_run_client_server(&http_client_set, + test_client_connection_lost, + test_server_connection_lost, 1, NULL); + test_end(); + + test_begin("connection lost: three attempts"); + http_client_set.max_attempts = 3; + test_run_client_server(&http_client_set, + test_client_connection_lost, + test_server_connection_lost, 1, NULL); + test_end(); + + test_begin("connection lost: manual retry"); + http_client_set.max_attempts = 3; + http_client_set.no_auto_retry = TRUE; + test_run_client_server(&http_client_set, + test_client_connection_lost, + test_server_connection_lost, 1, NULL); + test_end(); +} + +/* + * Connection lost after 100-continue + */ + +/* server */ + +static void test_connection_lost_100_input(struct server_connection *conn) +{ + static const char *resp = + "HTTP/1.1 100 Continue\r\n" + "\r\n"; + + o_stream_nsend_str(conn->conn.output, resp); + server_connection_deinit(&conn); +} + +static void test_server_connection_lost_100(unsigned int index) +{ + test_server_input = test_connection_lost_100_input; + test_server_run(index); +} + +/* client */ + +struct _connection_lost_100_ctx { + unsigned int count; +}; + +static void +test_client_connection_lost_100_response(const struct http_response *resp, + struct _connection_lost_100_ctx *ctx) +{ + test_client_assert_response( + resp, + resp->status == HTTP_CLIENT_REQUEST_ERROR_CONNECTION_LOST); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static bool +test_client_connection_lost_100( + const struct http_client_settings *client_set) +{ + static const char payload[] = + "This is a useless payload that only serves as a means to give " + "the server the opportunity to close the connection before the " + "payload is finished."; + struct _connection_lost_100_ctx *ctx; + struct http_client_request *hreq; + struct istream *input; + + ctx = i_new(struct _connection_lost_100_ctx, 1); + ctx->count = 2; + + http_client = http_client_init(client_set); + + input = i_stream_create_from_data(payload, sizeof(payload)-1); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/connection-lost.txt", + test_client_connection_lost_100_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_set_payload(hreq, input, TRUE); + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/connection-lost2.txt", + test_client_connection_lost_100_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_set_payload(hreq, input, TRUE); + http_client_request_submit(hreq); + + i_stream_unref(&input); + return TRUE; +} + +/* test */ + +static void test_connection_lost_100(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + + server_read_max = 0; + + test_begin("connection lost after 100-continue"); + http_client_set.max_attempts = 1; + test_run_client_server(&http_client_set, + test_client_connection_lost_100, + test_server_connection_lost_100, 1, NULL); + test_end(); +} + +/* + * Connection lost in sub-ioloop + */ + +/* server */ + +static void +test_connection_lost_sub_ioloop_input(struct server_connection *conn) +{ + static const char *resp = + "HTTP/1.1 200 OK\r\n" + "Content-Length: 0\r\n" + "\r\n"; + + o_stream_nsend_str(conn->conn.output, resp); + server_connection_deinit(&conn); +} + +static void test_server_connection_lost_sub_ioloop(unsigned int index) +{ + test_server_input = test_connection_lost_sub_ioloop_input; + test_server_run(index); +} + +/* client */ + +struct _connection_lost_sub_ioloop_ctx { + unsigned int count; +}; + +static void +test_client_connection_lost_sub_ioloop_response2( + const struct http_response *resp, struct ioloop *sub_ioloop) +{ + test_client_assert_response( + resp, + (resp->status == 200 || + resp->status == HTTP_CLIENT_REQUEST_ERROR_CONNECTION_LOST)); + + io_loop_stop(sub_ioloop); +} + +static void +test_client_connection_lost_sub_ioloop_response( + const struct http_response *resp, + struct _connection_lost_sub_ioloop_ctx *ctx) +{ + struct http_client_request *hreq; + struct ioloop *sub_ioloop; + + if (debug) + i_debug("RESPONSE: %u %s", resp->status, resp->reason); + + test_assert(resp->status == 200 || + resp->status == HTTP_CLIENT_REQUEST_ERROR_CONNECTION_LOST); + test_assert(resp->reason != NULL && *resp->reason != '\0'); + + sub_ioloop = io_loop_create(); + http_client_switch_ioloop(http_client); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/connection-lost-sub-ioloop3.txt", + test_client_connection_lost_sub_ioloop_response2, sub_ioloop); + http_client_request_set_port(hreq, bind_ports[1]); + http_client_request_submit(hreq); + + io_loop_run(sub_ioloop); + io_loop_set_current(ioloop); + http_client_switch_ioloop(http_client); + io_loop_set_current(sub_ioloop); + io_loop_destroy(&sub_ioloop); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static bool +test_client_connection_lost_sub_ioloop( + const struct http_client_settings *client_set) +{ + static const char payload[] = + "This is a useless payload that only serves as a means to give " + "the server the opportunity to close the connection before the " + "payload is finished."; + struct _connection_lost_sub_ioloop_ctx *ctx; + struct http_client_request *hreq; + struct istream *input; + + ctx = i_new(struct _connection_lost_sub_ioloop_ctx, 1); + ctx->count = 2; + + http_client = http_client_init(client_set); + + input = i_stream_create_from_data(payload, sizeof(payload)-1); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/connection-lost-sub-ioloop.txt", + test_client_connection_lost_sub_ioloop_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_set_payload(hreq, input, TRUE); + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/connection-lost-sub-ioloop2.txt", + test_client_connection_lost_sub_ioloop_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_set_payload(hreq, input, TRUE); + http_client_request_submit(hreq); + + i_stream_unref(&input); + return TRUE; +} + +/* test */ + +static void test_connection_lost_sub_ioloop(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + + server_read_max = 0; + + test_begin("connection lost while running sub-ioloop"); + http_client_set.max_attempts = 1; + test_run_client_server(&http_client_set, + test_client_connection_lost_sub_ioloop, + test_server_connection_lost_sub_ioloop, 2, NULL); + test_end(); +} + +/* + * Early success + */ + +/* server */ + +static void test_early_success_input(struct server_connection *conn) +{ + static const char *resp = + "HTTP/1.1 200 OK\r\n" + "Content-Length: 18\r\n" + "\r\n" + "Everything is OK\r\n"; + + i_sleep_msecs(200); + o_stream_nsend_str(conn->conn.output, resp); + server_connection_deinit(&conn); +} + +static void test_server_early_success(unsigned int index) +{ + test_server_input = test_early_success_input; + test_server_run(index); +} + +/* client */ + +struct _early_success_ctx { + unsigned int count; +}; + +static void +test_client_early_success_response(const struct http_response *resp, + struct _early_success_ctx *ctx) +{ + if (ctx->count == 2) { + test_client_assert_response( + resp, + resp->status == HTTP_CLIENT_REQUEST_ERROR_BAD_RESPONSE); + } else { + test_client_assert_response(resp, resp->status == 200); + } + + if (--ctx->count == 0) { + io_loop_stop(ioloop); + i_free(ctx); + } +} + +static bool +test_client_early_success(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _early_success_ctx *ctx; + string_t *payload; + unsigned int i; + + ctx = i_new(struct _early_success_ctx, 1); + ctx->count = 2; + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/early-success.txt", + test_client_early_success_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + + T_BEGIN { + struct istream_chain *chain; + struct istream *input, *chain_input; + + payload = t_str_new(64*3000); + for (i = 0; i < 3000; i++) { + str_append(payload, + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\r\n" + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\r\n"); + } + + chain_input = i_stream_create_chain(&chain, IO_BLOCK_SIZE); + + input = i_stream_create_copy_from_data(str_data(payload), + str_len(payload)); + i_stream_chain_append(chain, input); + i_stream_unref(&input); + + http_client_request_set_payload(hreq, chain_input, FALSE); + i_stream_unref(&chain_input); + } T_END; + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/early-success2.txt", + test_client_early_success_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_early_success(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + http_client_set.socket_send_buffer_size = 4096; + + test_begin("early succes"); + test_run_client_server(&http_client_set, + test_client_early_success, + test_server_early_success, 1, NULL); + test_end(); +} + +/* + * Bad response + */ + +/* server */ + +static void test_bad_response_input(struct server_connection *conn) +{ + static const char *resp = + "HTTP/1.1 666 Really bad response\r\n" + "\r\n"; + + o_stream_nsend_str(conn->conn.output, resp); + server_connection_deinit(&conn); +} + +static void test_server_bad_response(unsigned int index) +{ + test_server_input = test_bad_response_input; + test_server_run(index); +} + +/* client */ + +struct _bad_response_ctx { + unsigned int count; +}; + +static void +test_client_bad_response_response(const struct http_response *resp, + struct _bad_response_ctx *ctx) +{ + test_client_assert_response( + resp, resp->status == HTTP_CLIENT_REQUEST_ERROR_BAD_RESPONSE); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static bool +test_client_bad_response(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _bad_response_ctx *ctx; + + ctx = i_new(struct _bad_response_ctx, 1); + ctx->count = 2; + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/bad-response.txt", + test_client_bad_response_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/bad-response2.txt", + test_client_bad_response_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_bad_response(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + + test_begin("bad response"); + test_run_client_server(&http_client_set, + test_client_bad_response, + test_server_bad_response, 1, NULL); + test_end(); +} + +/* + * Request timed out + */ + +/* server */ + +static void +test_request_timed_out_input(struct server_connection *conn ATTR_UNUSED) +{ + /* do nothing */ +} + +static void test_server_request_timed_out(unsigned int index) +{ + test_server_input = test_request_timed_out_input; + test_server_run(index); +} + +/* client */ + +struct _request_timed_out1_ctx { + unsigned int count; +}; + +static void +test_client_request_timed_out1_response(const struct http_response *resp, + struct _request_timed_out1_ctx *ctx) +{ + test_client_assert_response( + resp, resp->status == HTTP_CLIENT_REQUEST_ERROR_TIMED_OUT); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static bool +test_client_request_timed_out1(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _request_timed_out1_ctx *ctx; + + ctx = i_new(struct _request_timed_out1_ctx, 1); + ctx->count = 2; + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/request-timed-out1-1.txt", + test_client_request_timed_out1_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/request-timed-out1-2.txt", + test_client_request_timed_out1_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + return TRUE; +} + +struct _request_timed_out2_ctx { + struct timeout *to; + unsigned int count; + unsigned int max_parallel_connections; +}; + +static void +test_client_request_timed_out2_timeout(struct _request_timed_out2_ctx *ctx) +{ + timeout_remove(&ctx->to); + i_debug("TIMEOUT"); +} + +static void +test_client_request_timed_out2_response(const struct http_response *resp, + struct _request_timed_out2_ctx *ctx) +{ + test_client_assert_response( + resp, resp->status == HTTP_CLIENT_REQUEST_ERROR_TIMED_OUT); + test_assert(ctx->to != NULL); + + if (--ctx->count > 0) { + if (ctx->to != NULL && ctx->max_parallel_connections <= 1) + timeout_reset(ctx->to); + } else { + timeout_remove(&ctx->to); + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static bool +test_client_request_timed_out2(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _request_timed_out2_ctx *ctx; + + ctx = i_new(struct _request_timed_out2_ctx, 1); + ctx->count = 2; + ctx->max_parallel_connections = + client_set->max_parallel_connections; + + ctx->to = timeout_add(2000, + test_client_request_timed_out2_timeout, ctx); + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/request-timed-out2-1.txt", + test_client_request_timed_out2_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_set_attempt_timeout_msecs(hreq, 1000); + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/request-timed-out2-2.txt", + test_client_request_timed_out2_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_set_attempt_timeout_msecs(hreq, 1000); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_request_timed_out(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + + test_begin("request timed out: one attempt"); + http_client_set.request_timeout_msecs = 1000; + http_client_set.max_attempts = 1; + test_run_client_server(&http_client_set, + test_client_request_timed_out1, + test_server_request_timed_out, 1, NULL); + test_end(); + + test_begin("request timed out: two attempts"); + http_client_set.request_timeout_msecs = 1000; + http_client_set.max_attempts = 1; + test_run_client_server(&http_client_set, + test_client_request_timed_out1, + test_server_request_timed_out, 1, NULL); + test_end(); + + test_begin("request absolutely timed out"); + http_client_set.request_timeout_msecs = 0; + http_client_set.request_absolute_timeout_msecs = 2000; + http_client_set.max_attempts = 3; + test_run_client_server(&http_client_set, + test_client_request_timed_out1, + test_server_request_timed_out, 1, NULL); + test_end(); + + test_begin("request double timed out"); + http_client_set.request_timeout_msecs = 500; + http_client_set.request_absolute_timeout_msecs = 2000; + http_client_set.max_attempts = 3; + test_run_client_server(&http_client_set, + test_client_request_timed_out1, + test_server_request_timed_out, 1, NULL); + test_end(); + + test_begin("request timed out: specific timeout"); + http_client_set.request_timeout_msecs = 3000; + http_client_set.request_absolute_timeout_msecs = 0; + http_client_set.max_attempts = 1; + http_client_set.max_parallel_connections = 1; + test_run_client_server(&http_client_set, + test_client_request_timed_out2, + test_server_request_timed_out, 1, NULL); + test_end(); + + test_begin("request timed out: specific timeout (parallel)"); + http_client_set.request_timeout_msecs = 3000; + http_client_set.request_absolute_timeout_msecs = 0; + http_client_set.max_attempts = 1; + http_client_set.max_parallel_connections = 4; + test_run_client_server(&http_client_set, + test_client_request_timed_out2, + test_server_request_timed_out, 1, NULL); + test_end(); +} + +/* + * Request aborted early + */ + +/* server */ + +static void +test_request_aborted_early_input(struct server_connection *conn ATTR_UNUSED) +{ + static const char *resp = + "HTTP/1.1 404 Not Found\r\n" + "\r\n"; + + /* wait one second to respond */ + i_sleep_intr_secs(1); + + /* respond */ + o_stream_nsend_str(conn->conn.output, resp); + server_connection_deinit(&conn); +} + +static void test_server_request_aborted_early(unsigned int index) +{ + test_server_input = test_request_aborted_early_input; + test_server_run(index); +} + +/* client */ + +struct _request_aborted_early_ctx { + struct http_client_request *req1, *req2; + struct timeout *to; +}; + +static void +test_client_request_aborted_early_response( + const struct http_response *resp, + struct _request_aborted_early_ctx *ctx ATTR_UNUSED) +{ + if (debug) + i_debug("RESPONSE: %u %s", resp->status, resp->reason); + + /* abort does not trigger callback */ + test_assert(FALSE); +} + +static void +test_client_request_aborted_early_timeout( + struct _request_aborted_early_ctx *ctx) +{ + timeout_remove(&ctx->to); + + if (ctx->req1 != NULL) { + /* abort early */ + http_client_request_abort(&ctx->req1); /* sent */ + http_client_request_abort(&ctx->req2); /* only queued */ + + /* wait a little for server to actually respond to an + already aborted request */ + ctx->to = timeout_add_short( + 1000, test_client_request_aborted_early_timeout, ctx); + } else { + /* all done */ + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static bool +test_client_request_aborted_early(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _request_aborted_early_ctx *ctx; + + ctx = i_new(struct _request_aborted_early_ctx, 1); + + http_client = http_client_init(client_set); + + hreq = ctx->req1 = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/request-aborted-early.txt", + test_client_request_aborted_early_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + hreq = ctx->req2 = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/request-aborted-early2.txt", + test_client_request_aborted_early_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + ctx->to = timeout_add_short( + 500, test_client_request_aborted_early_timeout, ctx); + return TRUE; +} + +/* test */ + +static void test_request_aborted_early(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + + test_begin("request aborted early"); + test_run_client_server(&http_client_set, + test_client_request_aborted_early, + test_server_request_aborted_early, 1, NULL); + test_end(); +} + +/* + * Request failed blocking + */ + +/* server */ + +static void +test_request_failed_blocking_input(struct server_connection *conn) +{ + static const char *resp = + "HTTP/1.1 500 Internal Server Error\r\n" + "\r\n"; + + /* respond */ + o_stream_nsend_str(conn->conn.output, resp); + i_sleep_intr_secs(10); + server_connection_deinit(&conn); +} + +static void test_server_request_failed_blocking(unsigned int index) +{ + test_server_input = test_request_failed_blocking_input; + test_server_run(index); +} + +/* client */ + +struct _request_failed_blocking_ctx { + struct http_client_request *req; +}; + +static void +test_client_request_failed_blocking_response( + const struct http_response *resp, + struct _request_failed_blocking_ctx *ctx ATTR_UNUSED) +{ + test_client_assert_response(resp, resp->status == 500); +} + +static bool +test_client_request_failed_blocking( + const struct http_client_settings *client_set) +{ + static const char *payload = "This a test payload!"; + struct http_client_request *hreq; + struct _request_failed_blocking_ctx *ctx; + unsigned int n; + string_t *data; + + data = str_new(default_pool, 1000000); + for (n = 0; n < 50000; n++) + str_append(data, payload); + + ctx = i_new(struct _request_failed_blocking_ctx, 1); + + http_client = http_client_init(client_set); + + hreq = ctx->req = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/request-failed-blocking.txt", + test_client_request_failed_blocking_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + + test_assert(http_client_request_send_payload(&hreq, + str_data(data), str_len(data)) < 0); + i_assert(hreq == NULL); + + str_free(&data); + i_free(ctx); + return FALSE; +} + +/* test */ + +static void test_request_failed_blocking(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + http_client_set.socket_send_buffer_size = 4096; + + test_begin("request failed blocking"); + test_run_client_server(&http_client_set, + test_client_request_failed_blocking, + test_server_request_failed_blocking, 1, NULL); + test_end(); +} + +/* + * Client deinit early + */ + +/* server */ + +static void +test_client_deinit_early_input(struct server_connection *conn ATTR_UNUSED) +{ + static const char *resp = + "HTTP/1.1 404 Not Found\r\n" + "\r\n"; + + /* wait one second to respond */ + i_sleep_intr_secs(1); + + /* respond */ + o_stream_nsend_str(conn->conn.output, resp); + server_connection_deinit(&conn); +} + +static void test_server_client_deinit_early(unsigned int index) +{ + test_server_input = test_client_deinit_early_input; + test_server_run(index); +} + +/* client */ + +struct _client_deinit_early_ctx { + struct timeout *to; +}; + +static void +test_client_client_deinit_early_response( + const struct http_response *resp, + struct _client_deinit_early_ctx *ctx ATTR_UNUSED) +{ + if (debug) + i_debug("RESPONSE: %u %s", resp->status, resp->reason); + + /* abort does not trigger callback */ + test_assert(FALSE); +} + +static void +test_client_client_deinit_early_timeout(struct _client_deinit_early_ctx *ctx) +{ + timeout_remove(&ctx->to); + + /* deinit early */ + http_client_deinit(&http_client); + + /* all done */ + i_free(ctx); + io_loop_stop(ioloop); +} + +static bool +test_client_client_deinit_early(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _client_deinit_early_ctx *ctx; + + ctx = i_new(struct _client_deinit_early_ctx, 1); + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/client-deinit-early.txt", + test_client_client_deinit_early_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/client-deinit-early2.txt", + test_client_client_deinit_early_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + ctx->to = timeout_add_short( + 500, test_client_client_deinit_early_timeout, ctx); + return TRUE; +} + +/* test */ + +static void test_client_deinit_early(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + + test_begin("client deinit early"); + test_run_client_server(&http_client_set, + test_client_client_deinit_early, + test_server_client_deinit_early, 1, NULL); + test_end(); +} + +/* + * Retry with delay + */ + +/* server */ + +static void test_retry_with_delay_input(struct server_connection *conn) +{ + string_t *resp; + + resp = t_str_new(512); + str_printfa(resp, + "HTTP/1.1 500 Internal Server Error\r\n" + "\r\n"); + o_stream_nsend(conn->conn.output, str_data(resp), str_len(resp)); + server_connection_deinit(&conn); +} + +static void test_server_retry_with_delay(unsigned int index) +{ + test_server_input = test_retry_with_delay_input; + test_server_run(index); +} + +/* client */ + +struct _client_retry_with_delay_ctx { + struct http_client_request *req; + unsigned int retries; + struct timeval time; +}; + +static void +test_client_retry_with_delay_response( + const struct http_response *resp, + struct _client_retry_with_delay_ctx *ctx) +{ + int real_delay, exp_delay; + + test_client_assert_response(resp, resp->status == 500); + + if (ctx->retries > 0) { + /* check delay */ + real_delay = timeval_diff_msecs(&ioloop_timeval, &ctx->time); + exp_delay = (1 << (ctx->retries-1)) * 50; + if (real_delay < exp_delay-2) { + i_fatal("Retry delay is too short %d < %d", + real_delay, exp_delay); + } + } + + http_client_request_delay_msecs(ctx->req, (1 << ctx->retries) * 50); + ctx->time = ioloop_timeval; + if (http_client_request_try_retry(ctx->req)) { + ctx->retries++; + if (debug) + i_debug("retrying"); + return; + } + + i_free(ctx); + io_loop_stop(ioloop); +} + +static bool +test_client_retry_with_delay(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _client_retry_with_delay_ctx *ctx; + + ctx = i_new(struct _client_retry_with_delay_ctx, 1); + ctx->time = ioloop_timeval; + + http_client = http_client_init(client_set); + + ctx->req = hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/retry-with-delay.txt", + test_client_retry_with_delay_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_retry_with_delay(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + http_client_set.max_attempts = 3; + + test_begin("retry with delay"); + test_run_client_server(&http_client_set, + test_client_retry_with_delay, + test_server_retry_with_delay, 1, NULL); + test_end(); +} + +/* + * DNS service failure + */ + +/* client */ + +struct _dns_service_failure { + unsigned int count; +}; + +static void +test_client_dns_service_failure_response( + const struct http_response *resp, + struct _dns_service_failure *ctx) +{ + test_client_assert_response( + resp, + resp->status == HTTP_CLIENT_REQUEST_ERROR_HOST_LOOKUP_FAILED); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static bool +test_client_dns_service_failure(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _dns_service_failure *ctx; + + ctx = i_new(struct _dns_service_failure, 1); + ctx->count = 2; + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", "example.com", "/dns-service-failure.txt", + test_client_dns_service_failure_response, ctx); + http_client_request_set_port(hreq, 80); + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", "example.com", "/dns-service-failure2.txt", + test_client_dns_service_failure_response, ctx); + http_client_request_set_port(hreq, 80); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_dns_service_failure(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + http_client_set.dns_client_socket_path = "./frop"; + + test_begin("dns service failure"); + test_run_client_server(&http_client_set, + test_client_dns_service_failure, + NULL, 0, NULL); + test_end(); +} + +/* + * DNS timeout + */ + +/* dns */ + +static void test_dns_timeout_input(struct server_connection *conn ATTR_UNUSED) +{ + /* hang */ + i_sleep_intr_secs(100); + server_connection_deinit(&conn); +} + +static void test_dns_dns_timeout(void) +{ + test_server_input = test_dns_timeout_input; + test_server_run(0); +} + +/* client */ + +struct _dns_timeout { + unsigned int count; +}; + +static void +test_client_dns_timeout_response( + const struct http_response *resp, + struct _dns_timeout *ctx) +{ + test_client_assert_response( + resp, + resp->status == HTTP_CLIENT_REQUEST_ERROR_HOST_LOOKUP_FAILED); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static bool +test_client_dns_timeout(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _dns_timeout *ctx; + + ctx = i_new(struct _dns_timeout, 1); + ctx->count = 2; + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", "example.com", "/dns-timeout.txt", + test_client_dns_timeout_response, ctx); + http_client_request_set_port(hreq, 80); + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", "example.com", "/dns-timeout2.txt", + test_client_dns_timeout_response, ctx); + http_client_request_set_port(hreq, 80); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_dns_timeout(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + http_client_set.request_timeout_msecs = 2000; + http_client_set.connect_timeout_msecs = 2000; + http_client_set.dns_client_socket_path = "./dns-test"; + + test_begin("dns timeout"); + test_run_client_server(&http_client_set, + test_client_dns_timeout, NULL, 0, + test_dns_dns_timeout); + test_end(); +} + +/* + * DNS lookup failure + */ + +/* dns */ + +static void +test_dns_lookup_failure_input(struct server_connection *conn) +{ + if (!conn->version_sent) { + conn->version_sent = TRUE; + o_stream_nsend_str(conn->conn.output, "VERSION\tdns\t1\t0\n"); + } + + o_stream_nsend_str(conn->conn.output, + t_strdup_printf("%d\tFAIL\n", EAI_FAIL)); + server_connection_deinit(&conn); +} + +static void test_dns_dns_lookup_failure(void) +{ + test_server_input = test_dns_lookup_failure_input; + test_server_run(0); +} + +/* client */ + +struct _dns_lookup_failure { + unsigned int count; +}; + +static void +test_client_dns_lookup_failure_response(const struct http_response *resp, + struct _dns_lookup_failure *ctx) +{ + test_client_assert_response( + resp, + resp->status == HTTP_CLIENT_REQUEST_ERROR_HOST_LOOKUP_FAILED); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static bool +test_client_dns_lookup_failure(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _dns_lookup_failure *ctx; + + ctx = i_new(struct _dns_lookup_failure, 1); + ctx->count = 2; + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", "example.com", "/dns-lookup-failure.txt", + test_client_dns_lookup_failure_response, ctx); + http_client_request_set_port(hreq, 80); + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", "example.com", "/dns-lookup-failure2.txt", + test_client_dns_lookup_failure_response, ctx); + http_client_request_set_port(hreq, 80); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_dns_lookup_failure(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + http_client_set.dns_client_socket_path = "./dns-test"; + + test_begin("dns lookup failure"); + test_run_client_server(&http_client_set, + test_client_dns_lookup_failure, NULL, 0, + test_dns_dns_lookup_failure); + test_end(); +} + +/* + * DNS lookup ttl + */ + +/* dns */ + +static void +test_dns_lookup_ttl_input(struct server_connection *conn) +{ + static unsigned int count = 0; + const char *line; + + if (!conn->version_sent) { + conn->version_sent = TRUE; + o_stream_nsend_str(conn->conn.output, "VERSION\tdns\t1\t0\n"); + } + + while ((line = i_stream_read_next_line(conn->conn.input)) != NULL) { + if (str_begins(line, "VERSION")) + continue; + if (debug) + i_debug("DNS REQUEST %u: %s", count, line); + + if (count == 0) { + o_stream_nsend_str(conn->conn.output, + "0\t127.0.0.1\n"); + } else { + o_stream_nsend_str( + conn->conn.output, + t_strdup_printf("%d\tFAIL\n", EAI_FAIL)); + if (count > 4) { + server_connection_deinit(&conn); + return; + } + } + count++; + } +} + +static void test_dns_dns_lookup_ttl(void) +{ + test_server_input = test_dns_lookup_ttl_input; + test_server_run(0); +} + +/* server */ + +static void +test_server_dns_lookup_ttl_input(struct server_connection *conn) +{ + string_t *resp; + + resp = t_str_new(512); + str_printfa(resp, + "HTTP/1.1 200 OK\r\n" + "Connection: close\r\n" + "\r\n"); + o_stream_nsend(conn->conn.output, str_data(resp), str_len(resp)); + server_connection_deinit(&conn); +} + +static void test_server_dns_lookup_ttl(unsigned int index) +{ + test_server_input = test_server_dns_lookup_ttl_input; + test_server_run(index); +} + +/* client */ + +struct _dns_lookup_ttl { + struct http_client *client; + unsigned int count; + struct timeout *to; +}; + +static void +test_client_dns_lookup_ttl_response_stage2(const struct http_response *resp, + struct _dns_lookup_ttl *ctx) +{ + test_client_assert_response( + resp, + resp->status == HTTP_CLIENT_REQUEST_ERROR_HOST_LOOKUP_FAILED); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static void test_client_dns_lookup_ttl_stage2_start(struct _dns_lookup_ttl *ctx) +{ + struct http_client_request *hreq; + + timeout_remove(&ctx->to); + + ctx->count = 2; + + hreq = http_client_request( + ctx->client, "GET", "example.com", + "/dns-lookup-ttl-stage2.txt", + test_client_dns_lookup_ttl_response_stage2, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + hreq = http_client_request( + ctx->client, "GET", "example.com", + "/dns-lookup-ttl2-stage2.txt", + test_client_dns_lookup_ttl_response_stage2, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); +} + +static void +test_client_dns_lookup_ttl_response_stage1(const struct http_response *resp, + struct _dns_lookup_ttl *ctx) +{ + test_client_assert_response(resp, resp->status == 200); + + if (--ctx->count == 0) { + ctx->to = timeout_add(2000, + test_client_dns_lookup_ttl_stage2_start, ctx); + } +} + +static bool +test_client_dns_lookup_ttl(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _dns_lookup_ttl *ctx; + + ctx = i_new(struct _dns_lookup_ttl, 1); + ctx->count = 2; + + ctx->client = http_client = http_client_init(client_set); + + hreq = http_client_request( + ctx->client, "GET", "example.com", + "/dns-lookup-ttl-stage1.txt", + test_client_dns_lookup_ttl_response_stage1, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + hreq = http_client_request( + ctx->client, "GET", "example.com", + "/dns-lookup-ttl2-stage1.txt", + test_client_dns_lookup_ttl_response_stage1, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_dns_lookup_ttl(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + http_client_set.dns_client_socket_path = "./dns-test"; + http_client_set.dns_ttl_msecs = 1000; + + test_begin("dns lookup ttl"); + test_run_client_server(&http_client_set, + test_client_dns_lookup_ttl, + test_server_dns_lookup_ttl, 1, + test_dns_dns_lookup_ttl); + test_end(); +} + +/* + * Peer reuse failure + */ + +/* server */ + +static void test_peer_reuse_failure_input(struct server_connection *conn) +{ + static unsigned int seq = 0; + static const char *resp = + "HTTP/1.1 200 OK\r\n" + "\r\n"; + + o_stream_nsend_str(conn->conn.output, resp); + if (seq++ > 2) { + server_connection_deinit(&conn); + io_loop_stop(current_ioloop); + } +} + +static void test_server_peer_reuse_failure(unsigned int index) +{ + test_server_input = test_peer_reuse_failure_input; + test_server_run(index); +} + +/* client */ + +struct _peer_reuse_failure { + struct timeout *to; + bool first:1; +}; + +static void +test_client_peer_reuse_failure_response2(const struct http_response *resp, + struct _peer_reuse_failure *ctx) +{ + test_client_assert_response( + resp, http_response_is_internal_error(resp)); + + i_free(ctx); + io_loop_stop(ioloop); +} + +static void +test_client_peer_reuse_failure_next(struct _peer_reuse_failure *ctx) +{ + struct http_client_request *hreq; + + timeout_remove(&ctx->to); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), + "/peer-reuse-next.txt", + test_client_peer_reuse_failure_response2, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); +} + +static void +test_client_peer_reuse_failure_response1(const struct http_response *resp, + struct _peer_reuse_failure *ctx) +{ + if (ctx->first) { + test_client_assert_response(resp, resp->status == 200); + + ctx->first = FALSE; + ctx->to = timeout_add_short( + 500, test_client_peer_reuse_failure_next, ctx); + } else { + test_client_assert_response( + resp, http_response_is_internal_error(resp)); + } + + test_assert(resp->reason != NULL && *resp->reason != '\0'); +} + +static bool +test_client_peer_reuse_failure(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _peer_reuse_failure *ctx; + + ctx = i_new(struct _peer_reuse_failure, 1); + ctx->first = TRUE; + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), "/peer-reuse.txt", + test_client_peer_reuse_failure_response1, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), "/peer-reuse.txt", + test_client_peer_reuse_failure_response1, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", net_ip2addr(&bind_ip), "/peer-reuse.txt", + test_client_peer_reuse_failure_response1, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_peer_reuse_failure(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + http_client_set.max_connect_attempts = 1; + http_client_set.max_idle_time_msecs = 500; + + test_begin("peer reuse failure"); + test_run_client_server(&http_client_set, + test_client_peer_reuse_failure, + test_server_peer_reuse_failure, 1, NULL); + test_end(); +} + +/* + * Reconnect failure + */ + +/* dns */ + +static void test_dns_reconnect_failure_input(struct server_connection *conn) +{ + static unsigned int count = 0; + const char *line; + + if (!conn->version_sent) { + conn->version_sent = TRUE; + o_stream_nsend_str(conn->conn.output, "VERSION\tdns\t1\t0\n"); + } + + while ((line = i_stream_read_next_line(conn->conn.input)) != NULL) { + if (str_begins(line, "VERSION")) + continue; + if (debug) + i_debug("DNS REQUEST %u: %s", count, line); + + if (count == 0) { + o_stream_nsend_str(conn->conn.output, + "0\t127.0.0.1\n"); + } else { + o_stream_nsend_str( + conn->conn.output, + t_strdup_printf("%d\tFAIL\n", EAI_FAIL)); + if (count > 4) { + server_connection_deinit(&conn); + return; + } + } + count++; + } +} + +static void test_dns_reconnect_failure(void) +{ + test_server_input = test_dns_reconnect_failure_input; + test_server_run(0); +} + +/* server */ + +static void test_reconnect_failure_input(struct server_connection *conn) +{ + static const char *resp = + "HTTP/1.1 200 OK\r\n" + "Content-Length: 18\r\n" + "\r\n" + "Everything is OK\r\n"; + + o_stream_nsend_str(conn->conn.output, resp); + io_loop_stop(current_ioloop); + io_remove(&io_listen); + i_close_fd(&fd_listen); + server_connection_deinit(&conn); +} + +static void test_server_reconnect_failure(unsigned int index) +{ + test_server_input = test_reconnect_failure_input; + test_server_run(index); +} + +/* client */ + +struct _reconnect_failure_ctx { + struct timeout *to; +}; + +static void +test_client_reconnect_failure_response2(const struct http_response *resp, + struct _reconnect_failure_ctx *ctx) +{ + test_client_assert_response( + resp, resp->status == HTTP_CLIENT_REQUEST_ERROR_CONNECT_FAILED); + + io_loop_stop(ioloop); + i_free(ctx); +} + +static void +test_client_reconnect_failure_next(struct _reconnect_failure_ctx *ctx) +{ + struct http_client_request *hreq; + + if (debug) + i_debug("NEXT REQUEST"); + + timeout_remove(&ctx->to); + + hreq = http_client_request( + http_client, "GET", "example.com", "/reconnect-failure-2.txt", + test_client_reconnect_failure_response2, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); +} + +static void +test_client_reconnect_failure_response1(const struct http_response *resp, + struct _reconnect_failure_ctx *ctx) +{ + test_client_assert_response(resp, resp->status == 200); + + ctx->to = timeout_add_short( + 5000, test_client_reconnect_failure_next, ctx); +} + +static bool +test_client_reconnect_failure(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _reconnect_failure_ctx *ctx; + + ctx = i_new(struct _reconnect_failure_ctx, 1); + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", "example.com", "/reconnect-failure-1.txt", + test_client_reconnect_failure_response1, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_reconnect_failure(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + http_client_set.dns_client_socket_path = "./dns-test"; + http_client_set.dns_ttl_msecs = 10000; + http_client_set.max_idle_time_msecs = 1000; + http_client_set.max_attempts = 1; + http_client_set.request_timeout_msecs = 1000; + + test_begin("reconnect failure"); + test_run_client_server(&http_client_set, + test_client_reconnect_failure, + test_server_reconnect_failure, 1, + test_dns_reconnect_failure); + test_end(); +} + +/* + * Multi IP attempts + */ + +/* dns */ + +static void test_multi_ip_attempts_input(struct server_connection *conn) +{ + unsigned int count = 0; + const char *line; + + if (!conn->version_sent) { + conn->version_sent = TRUE; + o_stream_nsend_str(conn->conn.output, "VERSION\tdns\t1\t0\n"); + } + + while ((line = i_stream_read_next_line(conn->conn.input)) != NULL) { + if (str_begins(line, "VERSION")) + continue; + if (debug) + i_debug("DNS REQUEST %u: %s", count, line); + + if (strcmp(line, "IP\ttest1.local") == 0) { + o_stream_nsend_str(conn->conn.output, + "0\t127.0.0.4\t127.0.0.3\t" + "127.0.0.2\t127.0.0.1\n"); + continue; + } + + o_stream_nsend_str(conn->conn.output, + "0\t10.255.255.1\t192.168.0.0\t" + "192.168.255.255\t127.0.0.1\n"); + } +} + +static void test_dns_multi_ip_attempts(void) +{ + test_server_input = test_multi_ip_attempts_input; + test_server_run(0); +} + +/* server */ + +static void test_server_multi_ip_attempts_input(struct server_connection *conn) +{ + string_t *resp; + + resp = t_str_new(512); + str_printfa(resp, + "HTTP/1.1 200 OK\r\n" + "Connection: close\r\n" + "\r\n"); + o_stream_nsend(conn->conn.output, str_data(resp), str_len(resp)); + server_connection_deinit(&conn); +} + +static void test_server_multi_ip_attempts(unsigned int index) +{ + test_server_input = test_server_multi_ip_attempts_input; + test_server_run(index); +} + +/* client */ + +struct _multi_ip_attempts { + unsigned int count; +}; + +static void +test_client_multi_ip_attempts_response(const struct http_response *resp, + struct _multi_ip_attempts *ctx) +{ + test_client_assert_response(resp, resp->status == 200); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static bool +test_client_multi_ip_attempts1(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _multi_ip_attempts *ctx; + + ctx = i_new(struct _multi_ip_attempts, 1); + ctx->count = 2; + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", "test1.local", "/multi-ip-attempts.txt", + test_client_multi_ip_attempts_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", "test1.local", "/multi-ip-attempts2.txt", + test_client_multi_ip_attempts_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + return TRUE; +} + +static bool +test_client_multi_ip_attempts2(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _multi_ip_attempts *ctx; + + ctx = i_new(struct _multi_ip_attempts, 1); + ctx->count = 2; + + http_client = http_client_init(client_set); + + hreq = http_client_request( + http_client, "GET", "test2.local", "/multi-ip-attempts.txt", + test_client_multi_ip_attempts_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + hreq = http_client_request( + http_client, "GET", "test2.local", "/multi-ip-attempts2.txt", + test_client_multi_ip_attempts_response, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_multi_ip_attempts(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + http_client_set.connect_timeout_msecs = 1000; + http_client_set.request_timeout_msecs = 1000; + http_client_set.dns_client_socket_path = "./dns-test"; + http_client_set.max_connect_attempts = 4; + + test_begin("multi IP attempts (connection refused)"); + test_run_client_server(&http_client_set, + test_client_multi_ip_attempts1, + test_server_multi_ip_attempts, 1, + test_dns_multi_ip_attempts); + test_end(); + + test_begin("multi IP attempts (connect timeout)"); + test_run_client_server(&http_client_set, + test_client_multi_ip_attempts2, + test_server_multi_ip_attempts, 1, + test_dns_multi_ip_attempts); + test_end(); + + http_client_set.soft_connect_timeout_msecs = 100; + + test_begin("multi IP attempts (soft connect timeout)"); + test_run_client_server(&http_client_set, + test_client_multi_ip_attempts2, + test_server_multi_ip_attempts, 1, + test_dns_multi_ip_attempts); + test_end(); +} + +/* + * Idle connections + */ + +/* server */ + +struct _idle_connections_sctx { + bool eoh; +}; + +static int test_idle_connections_init(struct server_connection *conn) +{ + struct _idle_connections_sctx *ctx; + + ctx = p_new(conn->pool, struct _idle_connections_sctx, 1); + conn->context = ctx; + return 0; +} + +static void test_idle_connections_input(struct server_connection *conn) +{ + struct _idle_connections_sctx *ctx = conn->context; + const char *line; + + while ((line = i_stream_read_next_line(conn->conn.input)) != NULL) { + if (*line == '\0') { + ctx->eoh = TRUE; + break; + } + } + + if (conn->conn.input->stream_errno != 0) { + i_fatal("server: Stream error: %s", + i_stream_get_error(conn->conn.input)); + } + if (line == NULL) { + if (conn->conn.input->eof) + server_connection_deinit(&conn); + return; + } + + i_assert(ctx->eoh); + ctx->eoh = FALSE; + + string_t *resp; + + resp = t_str_new(512); + str_printfa(resp, + "HTTP/1.1 200 OK\r\n" + "Content-Length: 0\r\n" + "\r\n"); + o_stream_nsend(conn->conn.output, str_data(resp), str_len(resp)); + if (o_stream_flush(conn->conn.output) < 0) { + i_fatal("server: Flush error: %s", + o_stream_get_error(conn->conn.output)); + } +} + +static void test_server_idle_connections(unsigned int index) +{ + test_server_init = test_idle_connections_init; + test_server_input = test_idle_connections_input; + test_server_run(index); +} + +/* client */ + +struct _idle_connections { + struct http_client *client; + unsigned int max, count; + struct timeout *to; +}; + +static void +test_client_idle_connections_response_stage2(const struct http_response *resp, + struct _idle_connections *ctx) +{ + test_client_assert_response( + resp, resp->status == 200); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static void test_client_idle_connections_stage2_start(struct _idle_connections *ctx) +{ + struct http_client_request *hreq; + unsigned int i; + + if (debug) + i_debug("STAGE 2"); + + timeout_remove(&ctx->to); + + ctx->count = ctx->max; + + for (i = 0; i < ctx->count; i++) { + hreq = http_client_request( + ctx->client, "GET", net_ip2addr(&bind_ip), + t_strdup_printf("/idle-connections-stage2-%d.txt", i), + test_client_idle_connections_response_stage2, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + } +} + +static void +test_client_idle_connections_response_stage1(const struct http_response *resp, + struct _idle_connections *ctx) +{ + test_client_assert_response(resp, resp->status == 200); + + if (--ctx->count == 0) { + if (debug) + i_debug("START STAGE 2"); + ctx->to = timeout_add_short( + 550, test_client_idle_connections_stage2_start, ctx); + } +} + +static bool +test_client_idle_connections(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _idle_connections *ctx; + unsigned int i; + + if (debug) + i_debug("STAGE 1"); + + ctx = i_new(struct _idle_connections, 1); + ctx->max = client_set->max_parallel_connections; + ctx->count = client_set->max_parallel_connections; + + ctx->client = http_client = http_client_init(client_set); + + for (i = 0; i < ctx->count; i++) { + hreq = http_client_request( + ctx->client, "GET", net_ip2addr(&bind_ip), + t_strdup_printf("/idle-connections-stage1-%d.txt", i), + test_client_idle_connections_response_stage1, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + } + + return TRUE; +} + +/* test */ + +static void test_idle_connections(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + http_client_set.max_idle_time_msecs = 1000; + + test_begin("idle connections (max 1)"); + http_client_set.max_parallel_connections = 1; + test_run_client_server(&http_client_set, + test_client_idle_connections, + test_server_idle_connections, 1, NULL); + test_end(); + + test_begin("idle connections (max 2)"); + http_client_set.max_parallel_connections = 2; + test_run_client_server(&http_client_set, + test_client_idle_connections, + test_server_idle_connections, 1, NULL); + test_end(); + + test_begin("idle connections (max 4)"); + http_client_set.max_parallel_connections = 4; + test_run_client_server(&http_client_set, + test_client_idle_connections, + test_server_idle_connections, 1, NULL); + test_end(); + + test_begin("idle connections (max 8)"); + http_client_set.max_parallel_connections = 8; + test_run_client_server(&http_client_set, + test_client_idle_connections, + test_server_idle_connections, 1, NULL); + test_end(); +} + +/* + * Idle hosts + */ + +/* dns */ + +static void +test_dns_idle_hosts_input(struct server_connection *conn) +{ + const char *line; + + if (!conn->version_sent) { + conn->version_sent = TRUE; + o_stream_nsend_str(conn->conn.output, "VERSION\tdns\t1\t0\n"); + } + + while ((line = i_stream_read_next_line(conn->conn.input)) != NULL) { + if (str_begins(line, "VERSION")) + continue; + if (debug) + i_debug("DNS REQUEST: %s", line); + + if (strcmp(line, "IP\thosta") == 0) { + o_stream_nsend_str(conn->conn.output, + "0\t127.0.0.1\n"); + } else { + i_sleep_msecs(300); + o_stream_nsend_str( + conn->conn.output, + t_strdup_printf("%d\tFAIL\n", EAI_FAIL)); + } + } +} + +static void test_dns_idle_hosts(void) +{ + test_server_input = test_dns_idle_hosts_input; + test_server_run(0); +} + +/* server */ + +struct _idle_hosts_sctx { + bool eoh; +}; + +static int test_idle_hosts_init(struct server_connection *conn) +{ + struct _idle_hosts_sctx *ctx; + + ctx = p_new(conn->pool, struct _idle_hosts_sctx, 1); + conn->context = ctx; + return 0; +} + +static void test_idle_hosts_input(struct server_connection *conn) +{ + struct _idle_hosts_sctx *ctx = conn->context; + const char *line; + + while ((line = i_stream_read_next_line(conn->conn.input)) != NULL) { + if (*line == '\0') { + ctx->eoh = TRUE; + break; + } + } + + if (conn->conn.input->stream_errno != 0) { + i_fatal("server: Stream error: %s", + i_stream_get_error(conn->conn.input)); + } + if (line == NULL) { + if (conn->conn.input->eof) + server_connection_deinit(&conn); + return; + } + + i_assert(ctx->eoh); + ctx->eoh = FALSE; + + string_t *resp; + + resp = t_str_new(512); + str_printfa(resp, + "HTTP/1.1 200 OK\r\n" + "Content-Length: 0\r\n" + "\r\n"); + o_stream_nsend(conn->conn.output, str_data(resp), str_len(resp)); + if (o_stream_flush(conn->conn.output) < 0) { + i_fatal("server: Flush error: %s", + o_stream_get_error(conn->conn.output)); + } +} + +static void test_server_idle_hosts(unsigned int index) +{ + test_server_init = test_idle_hosts_init; + test_server_input = test_idle_hosts_input; + test_server_run(index); +} + +/* client */ + +struct _idle_hosts { + struct http_client *client; + struct http_client_request *hostb_req; + unsigned int count; +}; + +static void +test_client_idle_hosts_response_hosta(const struct http_response *resp, + struct _idle_hosts *ctx) +{ + test_client_assert_response(resp, resp->status == 200); + + if (--ctx->count == 0) { + i_free(ctx); + io_loop_stop(ioloop); + } +} + +static void +test_client_idle_hosts_response_hostb(const struct http_response *resp, + struct _idle_hosts *ctx) +{ + test_client_assert_response(resp, + resp->status == HTTP_CLIENT_REQUEST_ERROR_HOST_LOOKUP_FAILED); + + if (http_client_request_try_retry(ctx->hostb_req)) { + if (debug) + i_debug("retrying"); + return; + } + + ctx->hostb_req = NULL; +} + +static bool +test_client_idle_hosts(const struct http_client_settings *client_set) +{ + struct http_client_request *hreq; + struct _idle_hosts *ctx; + + ctx = i_new(struct _idle_hosts, 1); + ctx->count = 2; + + ctx->client = http_client = http_client_init(client_set); + + hreq = http_client_request( + ctx->client, "GET", "hosta", + t_strdup_printf("/idle-hosts-a1.txt"), + test_client_idle_hosts_response_hosta, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + hreq = ctx->hostb_req = http_client_request( + ctx->client, "GET", "hostb", + t_strdup_printf("/idle-hosts-b.txt"), + test_client_idle_hosts_response_hostb, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_submit(hreq); + + hreq = http_client_request( + ctx->client, "GET", "hosta", + t_strdup_printf("/idle-hosts-a2.txt"), + test_client_idle_hosts_response_hosta, ctx); + http_client_request_set_port(hreq, bind_ports[0]); + http_client_request_delay_msecs(hreq, 600); + http_client_request_submit(hreq); + + return TRUE; +} + +/* test */ + +static void test_idle_hosts(void) +{ + struct http_client_settings http_client_set; + + test_client_defaults(&http_client_set); + http_client_set.dns_client_socket_path = "./dns-test"; + http_client_set.dns_ttl_msecs = 400; + http_client_set.max_parallel_connections = 1; + http_client_set.max_idle_time_msecs = 100; + http_client_set.max_attempts = 2; + + test_begin("idle hosts"); + test_run_client_server(&http_client_set, + test_client_idle_hosts, + test_server_idle_hosts, 1, + test_dns_idle_hosts); + test_end(); +} + +/* + * All tests + */ + +static void (*const test_functions[])(void) = { + test_unconfigured_ssl, + test_unconfigured_ssl_abort, + test_invalid_url, + test_host_lookup_failed, + test_connection_refused, + test_connection_lost_prematurely, + test_connection_timed_out, + test_invalid_redirect, + test_unseekable_redirect, + test_unseekable_retry, + test_broken_payload, + test_retry_payload, + test_connection_lost, + test_connection_lost_100, + test_connection_lost_sub_ioloop, + test_early_success, + test_bad_response, + test_request_timed_out, + test_request_aborted_early, + test_request_failed_blocking, + test_client_deinit_early, + test_retry_with_delay, + test_dns_service_failure, + test_dns_timeout, + test_dns_lookup_failure, + test_dns_lookup_ttl, + test_peer_reuse_failure, + test_reconnect_failure, + test_multi_ip_attempts, + test_idle_connections, + test_idle_hosts, + NULL +}; + +/* + * Test client + */ + +static void test_client_defaults(struct http_client_settings *http_set) +{ + /* client settings */ + i_zero(http_set); + http_set->max_idle_time_msecs = 5*1000; + http_set->max_parallel_connections = 1; + http_set->max_pipelined_requests = 1; + http_set->max_redirects = 0; + http_set->max_attempts = 1; + http_set->debug = debug; +} + +static void test_client_progress_timeout(void *context ATTR_UNUSED) +{ + /* Terminate test due to lack of progress */ + test_assert(FALSE); + timeout_remove(&to_client_progress); + io_loop_stop(current_ioloop); +} + +static bool +test_client_init(test_client_init_t client_test, + const struct http_client_settings *client_set) +{ + i_assert(client_test != NULL); + if (!client_test(client_set)) + return FALSE; + + to_client_progress = timeout_add(CLIENT_PROGRESS_TIMEOUT*1000, + test_client_progress_timeout, NULL); + return TRUE; +} + +static void test_client_deinit(void) +{ + timeout_remove(&to_client_progress); + + if (http_client != NULL) + http_client_deinit(&http_client); +} + +static void +test_client_run(test_client_init_t client_test, + const struct http_client_settings *client_set) +{ + if (test_client_init(client_test, client_set)) + io_loop_run(ioloop); + test_client_deinit(); +} + +/* + * Test server + */ + +/* client connection */ + +static void server_connection_input(struct connection *_conn) +{ + struct server_connection *conn = (struct server_connection *)_conn; + + test_server_input(conn); +} + +static void server_connection_init(int fd) +{ + struct server_connection *conn; + pool_t pool; + + net_set_nonblock(fd, TRUE); + + pool = pool_alloconly_create("server connection", 512); + conn = p_new(pool, struct server_connection, 1); + conn->pool = pool; + + connection_init_server(server_conn_list, &conn->conn, + "server connection", fd, fd); + + if (test_server_init != NULL) { + if (test_server_init(conn) != 0) + return; + } +} + +static void server_connection_deinit(struct server_connection **_conn) +{ + struct server_connection *conn = *_conn; + + *_conn = NULL; + + if (test_server_deinit != NULL) + test_server_deinit(conn); + + connection_deinit(&conn->conn); + pool_unref(&conn->pool); +} + +static void server_connection_destroy(struct connection *_conn) +{ + struct server_connection *conn = (struct server_connection *)_conn; + + server_connection_deinit(&conn); +} + +static void server_connection_accept(void *context ATTR_UNUSED) +{ + int fd; + + /* accept new client */ + fd = net_accept(fd_listen, NULL, NULL); + if (fd == -1) + return; + if (fd == -2) { + i_fatal("test server: accept() failed: %m"); + } + + server_connection_init(fd); +} + +/* */ + +static struct connection_settings server_connection_set = { + .input_max_size = SIZE_MAX, + .output_max_size = SIZE_MAX, + .client = FALSE +}; + +static const struct connection_vfuncs server_connection_vfuncs = { + .destroy = server_connection_destroy, + .input = server_connection_input +}; + +static void test_server_run(unsigned int index) +{ + server_index = index; + + /* open server socket */ + io_listen = io_add(fd_listen, IO_READ, server_connection_accept, NULL); + + server_conn_list = connection_list_init(&server_connection_set, + &server_connection_vfuncs); + + io_loop_run(ioloop); + + /* close server socket */ + io_remove(&io_listen); + + connection_list_deinit(&server_conn_list); +} + +/* + * Tests + */ + +struct test_server_data { + unsigned int index; + test_server_init_t server_test; +}; + +static int test_open_server_fd(in_port_t *bind_port) +{ + int fd = net_listen(&bind_ip, bind_port, 128); + if (debug) + i_debug("server listening on %u", *bind_port); + if (fd == -1) { + i_fatal("listen(%s:%u) failed: %m", + net_ip2addr(&bind_ip), *bind_port); + } + return fd; +} + +static int test_run_server(struct test_server_data *data) +{ + i_set_failure_prefix("SERVER[%u]: ", data->index + 1); + + if (debug) + i_debug("PID=%s", my_pid); + + test_subprocess_notify_signal_send_parent(SIGHUP); + ioloop = io_loop_create(); + data->server_test(data->index); + io_loop_destroy(&ioloop); + + if (debug) + i_debug("Terminated"); + + i_close_fd(&fd_listen); + i_free(bind_ports); + main_deinit(); + return 0; +} + +static int test_run_dns(test_dns_init_t dns_test) +{ + i_set_failure_prefix("DNS: "); + + if (debug) + i_debug("PID=%s", my_pid); + + ioloop = io_loop_create(); + dns_test(); + io_loop_destroy(&ioloop); + + if (debug) + i_debug("Terminated"); + + i_close_fd(&fd_listen); + i_free(bind_ports); + main_deinit(); + return 0; +} + +static void +test_run_client(const struct http_client_settings *client_set, + test_client_init_t client_test) +{ + i_set_failure_prefix("CLIENT: "); + + if (debug) + i_debug("PID=%s", my_pid); + + ioloop = io_loop_create(); + test_client_run(client_test, client_set); + io_loop_destroy(&ioloop); + + if (debug) + i_debug("Terminated"); +} + +static void +test_run_client_server(const struct http_client_settings *client_set, + test_client_init_t client_test, + test_server_init_t server_test, + unsigned int server_tests_count, + test_dns_init_t dns_test) +{ + unsigned int i; + + test_subprocess_notify_signal_reset(SIGHUP); + test_server_init = NULL; + test_server_deinit = NULL; + test_server_input = NULL; + + if (server_tests_count > 0) { + int fds[server_tests_count]; + + bind_ports = i_new(in_port_t, server_tests_count); + for (i = 0; i < server_tests_count; i++) + fds[i] = test_open_server_fd(&bind_ports[i]); + + for (i = 0; i < server_tests_count; i++) { + struct test_server_data data; + + i_zero(&data); + data.index = i; + data.server_test = server_test; + + /* Fork server */ + fd_listen = fds[i]; + test_subprocess_fork(test_run_server, &data, FALSE); + i_close_fd(&fd_listen); + test_subprocess_notify_signal_wait(SIGHUP, 10000); + test_subprocess_notify_signal_reset(SIGHUP); + } + } + + if (dns_test != NULL) { + int fd; + + i_unlink_if_exists("./dns-test"); + fd = net_listen_unix("./dns-test", 128); + if (fd == -1) { + i_fatal("listen(./dns-test) failed: %m"); + } + + /* Fork DNS service */ + fd_listen = fd; + test_subprocess_fork(test_run_dns, dns_test, FALSE); + i_close_fd(&fd_listen); + } + + /* Run client */ + test_run_client(client_set, client_test); + + i_unset_failure_prefix(); + test_subprocess_kill_all(SERVER_KILL_TIMEOUT_SECS); + i_free(bind_ports); + + i_unlink_if_exists("./dns-test"); +} + +/* + * Main + */ + +static void main_init(void) +{ + /* nothing yet */ +} + +static void main_deinit(void) +{ + /* nothing yet; also called from sub-processes */ +} + +int main(int argc, char *argv[]) +{ + int c; + int ret; + + lib_init(); + main_init(); + + while ((c = getopt(argc, argv, "D")) > 0) { + switch (c) { + case 'D': + debug = TRUE; + break; + default: + i_fatal("Usage: %s [-D]", argv[0]); + } + } + + test_subprocesses_init(debug); + + /* listen on localhost */ + i_zero(&bind_ip); + bind_ip.family = AF_INET; + bind_ip.u.ip4.s_addr = htonl(INADDR_LOOPBACK); + + ret = test_run(test_functions); + + test_subprocesses_deinit(); + main_deinit(); + lib_deinit(); + + return ret; +} |