a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen#include "lib.h"

9f0f2de10e4ea0c99052bf4b2bef8179f2536228Timo Sirainen#include "str.h"

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen#include "llist.h"

9f0f2de10e4ea0c99052bf4b2bef8179f2536228Timo Sirainen#include "path-util.h"

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen#include "hostpid.h"

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen#include "ioloop.h"

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen#include "istream.h"

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen#include "ostream.h"

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen#include "iostream-temp.h"

b215a8a123623782554a83f3025ef4e771bd8f01Timo Sirainen#include "connection.h"

b215a8a123623782554a83f3025ef4e771bd8f01Timo Sirainen#include "test-common.h"

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen#include "http-url.h"

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen#include "http-request.h"

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen#include "http-server.h"

9f0f2de10e4ea0c99052bf4b2bef8179f2536228Timo Sirainen#include "http-client.h"

9f0f2de10e4ea0c99052bf4b2bef8179f2536228Timo Sirainen

9f0f2de10e4ea0c99052bf4b2bef8179f2536228Timo Sirainen#include <sys/types.h>

9f0f2de10e4ea0c99052bf4b2bef8179f2536228Timo Sirainen#include <sys/stat.h>

9f0f2de10e4ea0c99052bf4b2bef8179f2536228Timo Sirainen#include <sys/wait.h>

9f0f2de10e4ea0c99052bf4b2bef8179f2536228Timo Sirainen#include <signal.h>

9f0f2de10e4ea0c99052bf4b2bef8179f2536228Timo Sirainen#include <fcntl.h>

9f0f2de10e4ea0c99052bf4b2bef8179f2536228Timo Sirainen#include <unistd.h>

9f0f2de10e4ea0c99052bf4b2bef8179f2536228Timo Sirainen#include <dirent.h>

9f0f2de10e4ea0c99052bf4b2bef8179f2536228Timo Sirainen

9f0f2de10e4ea0c99052bf4b2bef8179f2536228Timo Sirainenenum payload_handling {

9f0f2de10e4ea0c99052bf4b2bef8179f2536228Timo Sirainen PAYLOAD_HANDLING_LOW_LEVEL,

9f0f2de10e4ea0c99052bf4b2bef8179f2536228Timo Sirainen PAYLOAD_HANDLING_FORWARD,

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen PAYLOAD_HANDLING_HANDLER,

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen};

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainenstatic bool debug = FALSE;

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainenstatic bool blocking = FALSE;

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainenstatic enum payload_handling server_payload_handling =

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen PAYLOAD_HANDLING_LOW_LEVEL;

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainenstatic unsigned int parallel_clients = 1;

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainenstatic bool request_100_continue = FALSE;

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainenstatic size_t read_server_partial = 0;

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainenstatic size_t read_client_partial = 0;

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainenstatic unsigned int test_max_pending = 200;

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainenstatic unsigned int client_ioloop_nesting = 0;

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainenstatic struct ip_addr bind_ip;

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainenstatic in_port_t bind_port = 0;

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainenstatic int fd_listen = -1;

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainenstatic pid_t server_pid = (pid_t)-1;

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainenstatic struct ioloop *ioloop_nested = NULL;

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainenstatic unsigned ioloop_nested_first = 0;

9f0f2de10e4ea0c99052bf4b2bef8179f2536228Timo Sirainenstatic unsigned ioloop_nested_last = 0;

9f0f2de10e4ea0c99052bf4b2bef8179f2536228Timo Sirainenstatic unsigned ioloop_nested_depth = 0;

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainenstatic ARRAY_TYPE(const_string) files;

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainenstatic pool_t files_pool;

7744586e3e0fd60158abfbb03a233d3bd8d6c48bTimo Sirainen

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainenstatic void test_files_read_dir(const char *path)

4f7987384f306ea93b0258623a4cdd69601f2d0eTimo Sirainen{

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen DIR *dirp;

61618d4c58080570f689614fec204ae14e90cef2Timo Sirainen

50e20db49f29917fe9adcf1b56b11badf28bd0e4Timo Sirainen /* open the directory */

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen if ((dirp = opendir(path)) == NULL) {

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen if (errno == ENOENT || errno == EACCES)

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen return;

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen i_fatal("test files: "

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen "failed to open directory %s: %m", path);

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen }

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen /* read entries */

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen for (;;) {

7744586e3e0fd60158abfbb03a233d3bd8d6c48bTimo Sirainen const char *file;

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen struct dirent *dp;

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen struct stat st;

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen errno = 0;

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen if ((dp=readdir(dirp)) == NULL)

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen break;

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen if (*dp->d_name == '.')

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen continue;

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen

01c7ba8366ceafdbc0752d93079bbe785bebc9e1Timo Sirainen file = t_abspath_to(dp->d_name, path);

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen if (stat(file, &st) == 0) {

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen if (S_ISREG(st.st_mode)) {

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen file += 2; /* skip "./" */

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen file = p_strdup(files_pool, file);

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen array_append(&files, &file, 1);

7744586e3e0fd60158abfbb03a233d3bd8d6c48bTimo Sirainen } else {

e9e5e84ffb2ce2e606a24ce6d930580367562ff0Timo Sirainen test_files_read_dir(file);

e9e5e84ffb2ce2e606a24ce6d930580367562ff0Timo Sirainen }

e9e5e84ffb2ce2e606a24ce6d930580367562ff0Timo Sirainen }

e9e5e84ffb2ce2e606a24ce6d930580367562ff0Timo Sirainen }

7744586e3e0fd60158abfbb03a233d3bd8d6c48bTimo Sirainen

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen if (errno != 0)

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen i_fatal("test files: "

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen "failed to read directory %s: %m", path);

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen /* Close the directory */

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen if (closedir(dirp) < 0)

383d0e8c24451468d6bea17e4b55d74de744abe6Timo Sirainen i_error("test files: "

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen "failed to close directory %s: %m", path);

383d0e8c24451468d6bea17e4b55d74de744abe6Timo Sirainen}

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainen

7bafda1813454621e03615e83d55bccfa7cc56bdTimo Sirainenstatic void test_files_init(void)

a64adf62fa33f2463a86f990217b0c9078531a40Timo Sirainen{

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen /* initialize file array */

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen files_pool = pool_alloconly_create

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen (MEMPOOL_GROWING"http_server_request", 4096);

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen p_array_init(&files, files_pool, 512);

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen /* obtain all filenames */

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen test_files_read_dir(".");

7744586e3e0fd60158abfbb03a233d3bd8d6c48bTimo Sirainen}

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainenstatic void test_files_deinit(void)

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen{

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen pool_unref(&files_pool);

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen}

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainenstatic struct istream *

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainentest_file_open(const char *path,

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen unsigned int *status_r, const char **reason_r)

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen ATTR_NULL(2, 3)

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen{

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen int fd;

7744586e3e0fd60158abfbb03a233d3bd8d6c48bTimo Sirainen

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen if (status_r != NULL)

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen *status_r = 200;

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen if (reason_r != NULL)

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen *reason_r = "OK";

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen fd = open(path, O_RDONLY);

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen if (fd < 0) {

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen if (debug) {

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen i_debug("test files: "

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen "open(%s) failed: %m", path);

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen }

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen switch (errno) {

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen case EFAULT:

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen case ENOENT:

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen if (status_r != NULL)

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen *status_r = 404;

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen if (reason_r != NULL)

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen *reason_r = "Not Found";

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen break;

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen case EISDIR:

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen case EACCES:

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen if (status_r != NULL)

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen *status_r = 403;

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen if (reason_r != NULL)

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen *reason_r = "Forbidden";

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen break;

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen default:

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen if (status_r != NULL)

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen *status_r = 500;

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen if (reason_r != NULL)

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen *reason_r = "Internal Server Error";

a8284e999d091cd29210fa75ecdc8076376a7345Timo Sirainen }

return NULL;

}

return i_stream_create_fd_autoclose(&fd, 40960);

}

struct client {

pool_t pool;

struct client *prev, *next;

struct http_server_connection *http_conn;

};

struct client_request {

struct client *client;

struct http_server_request *server_req;

const char *path;

struct istream *payload_input;

struct ostream *payload_output;

struct io *io;

};

static const struct http_server_callbacks http_callbacks;

static struct http_server *http_server;

static struct io *io_listen;

static struct client *clients;

static void

client_handle_success_request(struct client_request *creq)

{

struct http_server_request *req = creq->server_req;

const struct http_request *hreq =

http_server_request_get(req);

struct http_server_response *resp;

if (strcmp(hreq->method, "GET") != 0) {

http_server_request_fail(req,

405, "Method Not Allowed");

return;

}

resp = http_server_response_create(req, 200, "OK");

http_server_response_submit(resp);

}

static void

client_handle_download_request(

struct client_request *creq,

const char *path)

{

struct http_server_request *req = creq->server_req;

const struct http_request *hreq =

http_server_request_get(req);

struct http_server_response *resp;

const char *fpath, *reason;

struct istream *fstream;

struct ostream *output;

unsigned int status;

if (strcmp(hreq->method, "GET") != 0) {

http_server_request_fail(req,

405, "Method Not Allowed");

return;

}

fpath = t_strconcat(".", path, NULL);

if (debug) {

i_debug("test server: download: "

"sending payload for %s", fpath);

}

fstream = test_file_open(fpath, &status, &reason);

if (fstream == NULL) {

http_server_request_fail(req, status, reason);

return;

}

resp = http_server_response_create(req, 200, "OK");

http_server_response_add_header(resp, "Content-Type", "text/plain");

if (blocking) {

output = http_server_response_get_payload_output(resp, TRUE);

if (o_stream_send_istream(output, fstream) != OSTREAM_SEND_ISTREAM_RESULT_FINISHED) {

i_fatal("test server: download: "

"failed to send blocking file payload");

}

if (debug) {

i_debug("test server: download: "

"finished sending blocking payload for %s"

"(%"PRIuUOFF_T":%"PRIuUOFF_T")",

fpath, fstream->v_offset, output->offset);

}

o_stream_close(output);

o_stream_unref(&output);

} else {

http_server_response_set_payload(resp, fstream);

http_server_response_submit(resp);

}

i_stream_unref(&fstream);

}

static void

client_request_finish_payload_in(struct client_request *creq)

{

struct http_server_response *resp;

struct istream *payload_input;

payload_input = iostream_temp_finish(&creq->payload_output, 4096);

resp = http_server_response_create

(creq->server_req, 200, "OK");

http_server_response_add_header(resp, "Content-Type", "text/plain");

http_server_response_set_payload(resp, payload_input);

http_server_response_submit(resp);

i_stream_unref(&payload_input);

}

static void

client_request_read_echo(struct client_request *creq)

{

enum ostream_send_istream_result res;

o_stream_set_max_buffer_size(creq->payload_output, IO_BLOCK_SIZE);

res = o_stream_send_istream(creq->payload_output, creq->payload_input);

o_stream_set_max_buffer_size(creq->payload_output, (size_t)-1);

switch (res) {

case OSTREAM_SEND_ISTREAM_RESULT_FINISHED:

break;

case OSTREAM_SEND_ISTREAM_RESULT_WAIT_INPUT:

case OSTREAM_SEND_ISTREAM_RESULT_WAIT_OUTPUT:

return;

case OSTREAM_SEND_ISTREAM_RESULT_ERROR_INPUT:

i_fatal("test server: echo: "

"Failed to read all echo payload [%s]", creq->path);

case OSTREAM_SEND_ISTREAM_RESULT_ERROR_OUTPUT:

i_fatal("test server: echo: "

"Failed to write all echo payload [%s]", creq->path);

}

client_request_finish_payload_in(creq);

i_stream_unref(&creq->payload_input);

}

static void

client_request_read_echo_more(struct client_request *creq)

{

client_request_read_echo(creq);

if (creq->payload_input != NULL)

return;

io_remove(&creq->io);

if (debug) {

i_debug("test server: echo: "

"finished receiving payload for %s", creq->path);

}

}

static void

client_handle_echo_request(struct client_request *creq,

const char *path)

{

struct http_server_request *req = creq->server_req;

const struct http_request *hreq =

http_server_request_get(req);

struct http_server_response *resp;

struct ostream *payload_output;

uoff_t size;

creq->path = p_strdup

(http_server_request_get_pool(req), path);

if (strcmp(hreq->method, "PUT") != 0) {

http_server_request_fail(req,

405, "Method Not Allowed");

return;

}

size = 0;

(void)http_request_get_payload_size(hreq, &size);

if (size == 0) {

resp = http_server_response_create

(creq->server_req, 200, "OK");

http_server_response_add_header(resp, "Content-Type", "text/plain");

http_server_response_submit(resp);

return;

}

payload_output = iostream_temp_create

("/tmp/test-http-server", 0);

if (blocking) {

struct istream *payload_input;

payload_input =

http_server_request_get_payload_input(req, TRUE);

if (read_server_partial > 0) {

struct istream *partial =

i_stream_create_limit(payload_input, read_server_partial);

i_stream_unref(&payload_input);

payload_input = partial;

}

if (o_stream_send_istream(payload_output, payload_input) != OSTREAM_SEND_ISTREAM_RESULT_FINISHED) {

i_fatal("test server: echo: "

"failed to receive blocking echo payload");

}

i_stream_unref(&payload_input);

payload_input = iostream_temp_finish(&payload_output, 4096);

if (debug) {

i_debug("test server: echo: "

"finished receiving blocking payload for %s", path);

}

resp = http_server_response_create(req, 200, "OK");

http_server_response_add_header(resp, "Content-Type", "text/plain");

payload_output = http_server_response_get_payload_output(resp, TRUE);

if (o_stream_send_istream(payload_output, payload_input) != OSTREAM_SEND_ISTREAM_RESULT_FINISHED) {

i_fatal("test server: echo: "

"failed to send blocking echo payload");

}

if (debug) {

i_debug("test server: echo: "

"finished sending blocking payload for %s", path);

}

i_stream_unref(&payload_input);

o_stream_close(payload_output);

o_stream_unref(&payload_output);

} else {

creq->payload_output = payload_output;

switch (server_payload_handling) {

case PAYLOAD_HANDLING_LOW_LEVEL:

creq->payload_input =

http_server_request_get_payload_input(req, FALSE);

if (read_server_partial > 0) {

struct istream *partial =

i_stream_create_limit(creq->payload_input, read_server_partial);

i_stream_unref(&creq->payload_input);

creq->payload_input = partial;

}

creq->io = io_add_istream(creq->payload_input,

client_request_read_echo_more, creq);

client_request_read_echo_more(creq);

break;

case PAYLOAD_HANDLING_FORWARD:

http_server_request_forward_payload(req,

payload_output, (size_t)-1,

client_request_finish_payload_in, creq);

break;

case PAYLOAD_HANDLING_HANDLER:

creq->payload_input =

http_server_request_get_payload_input(req, FALSE);

http_server_request_handle_payload(req,

client_request_read_echo, creq);

break;

}

}

}

static void

http_server_request_destroyed(struct client_request *creq);

static struct client_request *

client_request_init(struct client *client,

struct http_server_request *req)

{

struct client_request *creq;

pool_t pool = http_server_request_get_pool(req);

http_server_request_ref(req);

creq = p_new(pool, struct client_request, 1);

creq->client = client;

creq->server_req = req;

http_server_request_set_destroy_callback(req,

http_server_request_destroyed, creq);

return creq;

}

static void client_request_deinit(struct client_request **_creq)

{

struct client_request *creq = *_creq;

struct http_server_request *req = creq->server_req;

*_creq = NULL;

if (creq->io != NULL) {

i_stream_unref(&creq->payload_input);

io_remove(&creq->io);

}

http_server_request_unref(&req);

}

static void

http_server_request_destroyed(struct client_request *creq)

{

client_request_deinit(&creq);

}

static void

client_handle_request(void *context,

struct http_server_request *req)

{

const struct http_request *hreq =

http_server_request_get(req);

const char *path = hreq->target.url->path, *p;

struct client *client = (struct client *)context;

struct client_request *creq;

if (debug) {

i_debug("test server: "

"request method=`%s' path=`%s'", hreq->method, path);

}

creq = client_request_init(client, req);

if (strcmp(path, "/success") == 0) {

client_handle_success_request(creq);

return;

}

if ((p=strchr(path+1, '/')) == NULL) {

http_server_request_fail(req, 404, "Not found");

return;

}

if (strncmp(path, "/download", p-path) == 0) {

client_handle_download_request(creq, p);

return;

}

if (strncmp(path, "/echo", p-path) == 0) {

client_handle_echo_request(creq, p);

return;

}

http_server_request_fail(req, 404, "Not found");

return;

}

static void

client_connection_destroy(void *context, const char *reason);

static const struct http_server_callbacks http_callbacks = {

.connection_destroy = client_connection_destroy,

.handle_request = client_handle_request

};

static void client_init(int fd)

{

struct client *client;

pool_t pool;

net_set_nonblock(fd, TRUE);

pool = pool_alloconly_create("client", 256);

client = p_new(pool, struct client, 1);

client->pool = pool;

client->http_conn = http_server_connection_create(http_server,

fd, fd, FALSE, &http_callbacks, client);

DLLIST_PREPEND(&clients, client);

}

static void client_deinit(struct client **_client)

{

struct client *client = *_client;

*_client = NULL;

DLLIST_REMOVE(&clients, client);

if (client->http_conn != NULL)

http_server_connection_close(&client->http_conn, "deinit");

pool_unref(&client->pool);

}

static void

client_connection_destroy(void *context, const char *reason ATTR_UNUSED)

{

struct client *client = context;

client->http_conn = NULL;

client_deinit(&client);

}

static void client_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");

}

client_init(fd);

}

static void

test_server_init(const struct http_server_settings *server_set)

{

/* open server socket */

io_listen = io_add(fd_listen,

IO_READ, client_accept, (void *)NULL);

http_server = http_server_init(server_set);

}

static void test_server_deinit(void)

{

/* close server socket */

io_remove(&io_listen);

/* deinitialize */

http_server_deinit(&http_server);

}

struct test_client_request {

struct test_client_request *prev, *next;

struct http_client_request *hreq;

struct io *io;

struct istream *payload;

struct istream *file;

unsigned int files_idx;

};

static struct http_client **http_clients;

static struct test_client_request *client_requests;

static unsigned int client_files_first, client_files_last;

static struct test_client_request *

test_client_request_new(void)

{

struct test_client_request *tcreq;

tcreq = i_new(struct test_client_request, 1);

DLLIST_PREPEND(&client_requests, tcreq);

return tcreq;

}

static void

test_client_request_destroy(struct test_client_request *tcreq)

{

io_remove(&tcreq->io);

i_stream_unref(&tcreq->payload);

i_stream_unref(&tcreq->file);

DLLIST_REMOVE(&client_requests, tcreq);

i_free(tcreq);

}

static void

test_client_requests_switch_ioloop(void)

{

struct test_client_request *tcreq;

for (tcreq = client_requests; tcreq != NULL;

tcreq = tcreq->next) {

if (tcreq->io != NULL)

tcreq->io = io_loop_move_io(&tcreq->io);

if (tcreq->payload != NULL)

i_stream_switch_ioloop(tcreq->payload);

}

}

static void

test_client_create_clients(const struct http_client_settings *client_set)

{

struct http_client_context *http_context;

unsigned int i;

http_context = http_client_context_create(client_set);

if (parallel_clients < 1)

parallel_clients = 1;

http_clients = i_new(struct http_client *, parallel_clients);

for (i = 0; i < parallel_clients; i++) {

http_clients[i] = http_client_init_shared(http_context, NULL);

}

http_client_context_unref(&http_context);

}

static void test_client_download_continue(void);

static void

test_client_download_finished(unsigned int files_idx)

{

const char **paths;

unsigned int count;

paths = array_get_modifiable(&files, &count);

i_assert(files_idx < count);

i_assert(client_files_first < count);

i_assert(paths[files_idx] != NULL);

paths[files_idx] = NULL;

test_client_download_continue();

}

static void

test_client_download_payload_input(struct test_client_request *tcreq)

{

struct istream *payload = tcreq->payload;

const unsigned char *pdata, *fdata;

size_t psize, fsize, pleft;

unsigned int files_idx = tcreq->files_idx;

off_t ret;

/* read payload */

while ((ret=i_stream_read_more(payload, &pdata, &psize)) > 0) {

if (debug) {

i_debug("test client: download: "

"got data for [%u] (size=%d)",

tcreq->files_idx, (int)psize);

}

/* compare with file on disk */

pleft = psize;

while ((ret=i_stream_read_more

(tcreq->file, &fdata, &fsize)) > 0 && pleft > 0) {

fsize = (fsize > pleft ? pleft : fsize);

if (memcmp(pdata, fdata, fsize) != 0) {

i_fatal("test client: download: "

"received data does not match file "

"(%"PRIuUOFF_T":%"PRIuUOFF_T")",

payload->v_offset, tcreq->file->v_offset);

}

i_stream_skip(tcreq->file, fsize);

pleft -= fsize;

pdata += fsize;

}

if (ret < 0 && tcreq->file->stream_errno != 0) {

i_fatal("test client: download: "

"failed to read file: %s", i_stream_get_error(tcreq->file));

}

i_stream_skip(payload, psize);

}

if (ret == 0) {

if (debug) {

i_debug("test client: download: "

"need more data for [%u]",

tcreq->files_idx);

}

/* we will be called again for this request */

} else {

(void)i_stream_read(tcreq->file);

if (payload->stream_errno != 0) {

i_fatal("test client: download: "

"failed to read request payload: %s",

i_stream_get_error(payload));

} if (i_stream_have_bytes_left(tcreq->file)) {

if (i_stream_read_more(tcreq->file, &fdata, &fsize) <= 0)

fsize = 0;

i_fatal("test client: download: "

"payload ended prematurely "

"(at least %"PRIuSIZE_T" bytes left)", fsize);

} else if (debug) {

i_debug("test client: download: "

"finished request for [%u]",

tcreq->files_idx);

}

/* dereference payload stream; finishes the request */

tcreq->payload = NULL;

io_remove(&tcreq->io); /* holds a reference too */

i_stream_unref(&payload);

/* finished */

test_client_download_finished(files_idx);

}

}

static void

test_client_download_response(const struct http_response *resp,

struct test_client_request *tcreq)

{

const char **paths;

const char *path;

unsigned int count, status;

struct istream *fstream;

const char *reason;

if (debug) {

i_debug("test client: download: "

"got response for [%u]",

tcreq->files_idx);

}

paths = array_get_modifiable(&files, &count);

i_assert(tcreq->files_idx < count);

i_assert(client_files_first < count);

path = paths[tcreq->files_idx];

i_assert(path != NULL);

if (debug) {

i_debug("test client: download: "

"path for [%u]: %s",

tcreq->files_idx, path);

}

fstream = test_file_open(path, &status, &reason);

i_assert(fstream != NULL);

if (status != resp->status) {

i_fatal("test client: download: "

"got wrong response for %s: %u %s (expected: %u %s)",

path, resp->status, resp->reason, status, reason);

}

if (resp->status / 100 != 2) {

if (debug) {

i_debug("test client: download: "

"HTTP request for %s failed: %u %s",

path, resp->status, resp->reason);

}

i_stream_unref(&fstream);

test_client_download_finished(tcreq->files_idx);

return;

}

if (resp->payload == NULL) {

if (debug) {

i_debug("test client: download: "

"no payload for %s [%u]",

path, tcreq->files_idx);

}

i_stream_unref(&fstream);

test_client_download_finished(tcreq->files_idx);

return;

}

i_assert(fstream != NULL);

if (read_client_partial == 0) {

i_stream_ref(resp->payload);

tcreq->payload = resp->payload;

tcreq->file = fstream;

} else {

struct istream *payload = resp->payload;

tcreq->payload = i_stream_create_limit

(payload, read_client_partial);

tcreq->file = i_stream_create_limit

(fstream, read_client_partial);

i_stream_unref(&fstream);

}

tcreq->io = io_add_istream(tcreq->payload,

test_client_download_payload_input, tcreq);

test_client_download_payload_input(tcreq);

}

static void test_client_download_continue(void)

{

struct test_client_request *tcreq;

struct http_client_request *hreq;

const char *const *paths;

unsigned int count;

paths = array_get(&files, &count);

i_assert(client_files_first <= count);

i_assert(client_files_last <= count);

i_assert(client_files_first <= client_files_last);

for (; client_files_first < client_files_last &&

paths[client_files_first] == NULL; client_files_first++)

if (debug) {

i_debug("test client: download: "

"received until [%u]",

client_files_first-1);

}

if (client_files_first >= count) {

io_loop_stop(current_ioloop);

return;

}

for (; client_files_last < count &&

(client_files_last - client_files_first) < test_max_pending;

client_files_last++) {

struct http_client *http_client =

http_clients[client_files_last % parallel_clients];

const char *path = paths[client_files_last];

tcreq = test_client_request_new();

tcreq->files_idx = client_files_last;

if (debug) {

i_debug("test client: download: "

"retrieving %s [%u]",

path, tcreq->files_idx);

}

hreq = tcreq->hreq = http_client_request(http_client,

"GET", net_ip2addr(&bind_ip),

t_strconcat("/download/", path, NULL),

test_client_download_response, tcreq);

http_client_request_set_port(hreq, bind_port);

http_client_request_set_destroy_callback(hreq,

test_client_request_destroy, tcreq);

http_client_request_submit(hreq);

}

}

static void

test_client_download(const struct http_client_settings *client_set)

{

/* create client(s) */

test_client_create_clients(client_set);

/* start querying server */

client_files_first = client_files_last = 0;

test_client_download_continue();

}

static void test_client_echo_continue(void);

static void

test_client_echo_finished(unsigned int files_idx)

{

const char **paths;

unsigned int count;

paths = array_get_modifiable(&files, &count);

i_assert(files_idx < count);

i_assert(client_files_first < count);

i_assert(paths[files_idx] != NULL);

paths[files_idx] = NULL;

test_client_echo_continue();

}

static void

test_client_echo_payload_input(struct test_client_request *tcreq)

{

struct istream *payload = tcreq->payload;

const unsigned char *pdata, *fdata;

size_t psize, fsize, pleft;

unsigned int files_idx = tcreq->files_idx;

off_t ret;

/* read payload */

while ((ret=i_stream_read_more(payload, &pdata, &psize)) > 0) {

if (debug) {

i_debug("test client: echo: "

"got data for [%u] (size=%d)",

tcreq->files_idx, (int)psize);

}

/* compare with file on disk */

pleft = psize;

while ((ret=i_stream_read_more

(tcreq->file, &fdata, &fsize)) > 0 && pleft > 0) {

fsize = (fsize > pleft ? pleft : fsize);

if (memcmp(pdata, fdata, fsize) != 0) {

i_fatal("test client: echo: "

"received data does not match file "

"(%"PRIuUOFF_T":%"PRIuUOFF_T")",

payload->v_offset, tcreq->file->v_offset);

}

i_stream_skip(tcreq->file, fsize);

pleft -= fsize;

pdata += fsize;

}

if (ret < 0 && tcreq->file->stream_errno != 0) {

i_fatal("test client: echo: "

"failed to read file: %s", i_stream_get_error(tcreq->file));

}

i_stream_skip(payload, psize);

}

if (ret == 0) {

if (debug) {

i_debug("test client: echo: "

"need more data for [%u]",

tcreq->files_idx);

}

/* we will be called again for this request */

} else {

(void)i_stream_read(tcreq->file);

if (payload->stream_errno != 0) {

i_fatal("test client: echo: "

"failed to read request payload: %s",

i_stream_get_error(payload));

} if (i_stream_have_bytes_left(tcreq->file)) {

if (i_stream_read_more(tcreq->file, &fdata, &fsize) <= 0)

fsize = 0;

i_fatal("test client: echo: "

"payload ended prematurely "

"(at least %"PRIuSIZE_T" bytes left)", fsize);

} else if (debug) {

i_debug("test client: echo: "

"finished request for [%u]",

tcreq->files_idx);

}

/* dereference payload stream; finishes the request */

tcreq->payload = NULL;

io_remove(&tcreq->io); /* holds a reference too */

i_stream_unref(&payload);

/* finished */

test_client_echo_finished(files_idx);

}

}

static void

test_client_echo_response(const struct http_response *resp,

struct test_client_request *tcreq)

{

const char **paths;

const char *path;

unsigned int count, status;

struct istream *fstream;

if (debug) {

i_debug("test client: echo: "

"got response for [%u]",

tcreq->files_idx);

}

paths = array_get_modifiable(&files, &count);

i_assert(tcreq->files_idx < count);

i_assert(client_files_first < count);

path = paths[tcreq->files_idx];

i_assert(path != NULL);

if (debug) {

i_debug("test client: echo: "

"path for [%u]: %s",

tcreq->files_idx, path);

}

if (resp->status / 100 != 2) {

i_fatal("test client: echo: "

"HTTP request for %s failed: %u %s",

path, resp->status, resp->reason);

}

fstream = test_file_open(path, &status, NULL);

if (fstream == NULL) {

i_fatal("test client: echo: "

"failed to open %s", path);

}

if (read_server_partial > 0) {

struct istream *partial = i_stream_create_limit

(fstream, read_server_partial);

i_stream_unref(&fstream);

fstream = partial;

}

if (resp->payload == NULL) {

// FIXME: check file is empty

if (debug) {

i_debug("test client: echo: "

"no payload for %s [%u]",

path, tcreq->files_idx);

}

i_stream_unref(&fstream);

test_client_echo_finished(tcreq->files_idx);

return;

}

i_assert(fstream != NULL);

tcreq->file = fstream;

i_stream_ref(resp->payload);

tcreq->payload = resp->payload;

tcreq->io = io_add_istream(resp->payload,

test_client_echo_payload_input, tcreq);

test_client_echo_payload_input(tcreq);

}

static void test_client_echo_continue(void)

{

struct test_client_request *tcreq;

struct http_client_request *hreq;

const char **paths;

unsigned int count, first_submitted;

paths = array_get_modifiable(&files, &count);

i_assert(client_files_first <= count);

i_assert(client_files_last <= count);

i_assert(client_files_first <= client_files_last);

for (; client_files_first < client_files_last &&

paths[client_files_first] == NULL; client_files_first++);

if (debug) {

i_debug("test client: echo: "

"received until [%u/%u]", client_files_first-1, count);

}

if (debug && client_files_first < count) {

const char *path = paths[client_files_first];

i_debug("test client: echo: "

"next blocking: %s [%d]",

(path == NULL ? "none" : path),

client_files_first);

}

if (client_files_first >= count) {

io_loop_stop(current_ioloop);

return;

}

first_submitted = client_files_last;

for (; client_files_last < count &&

(client_files_last - client_files_first) < test_max_pending;

client_files_last++) {

struct http_client *http_client =

http_clients[client_files_last % parallel_clients];

struct istream *fstream;

const char *path = paths[client_files_last];

fstream = test_file_open(path, NULL, NULL);

if (fstream == NULL) {

paths[client_files_last] = NULL;

if (debug) {

i_debug("test client: echo: "

"skipping %s [%u]",

path, client_files_last);

}

continue;

}

if (debug) {

i_debug("test client: echo: "

"retrieving %s [%u]",

path, client_files_last);

}

tcreq = test_client_request_new();

tcreq->files_idx = client_files_last;

hreq = tcreq->hreq = http_client_request(http_client,

"PUT", net_ip2addr(&bind_ip),

t_strconcat("/echo/", path, NULL),

test_client_echo_response, tcreq);

http_client_request_set_port(hreq, bind_port);

http_client_request_set_payload

(hreq, fstream, request_100_continue);

http_client_request_set_destroy_callback(hreq,

test_client_request_destroy, tcreq);

http_client_request_submit(hreq);

i_stream_unref(&fstream);

}

/* run nested ioloop (if requested) if new requests cross a nesting

if (ioloop_nested != NULL) {

unsigned int i;

i_assert(ioloop_nested_first <= count);

i_assert(ioloop_nested_last <= count);

for (i = ioloop_nested_first; i < ioloop_nested_last; i++) {

if (paths[i] != NULL) {

if (debug) {

i_debug("test client: "

"not leaving ioloop [%u]", i);

}

break;

}

}

if (i == ioloop_nested_last)

io_loop_stop(ioloop_nested);

} else if (client_ioloop_nesting > 0 &&

((client_files_last / client_ioloop_nesting) !=

(first_submitted / client_ioloop_nesting)) ) {

struct ioloop *prev_ioloop = current_ioloop;

unsigned int i;

ioloop_nested_first = first_submitted;

ioloop_nested_last = first_submitted + client_ioloop_nesting;

if (ioloop_nested_last > client_files_last)

ioloop_nested_last = client_files_last;

if (debug) {

i_debug("test client: echo: entering ioloop for %u...%u (depth=%u)",

ioloop_nested_first, ioloop_nested_last, ioloop_nested_depth);

}

ioloop_nested_depth++;

ioloop_nested = io_loop_create();

for (i = 0; i < parallel_clients; i++)

http_client_switch_ioloop(http_clients[i]);

test_client_requests_switch_ioloop();

io_loop_run(ioloop_nested);

io_loop_set_current(prev_ioloop);

for (i = 0; i < parallel_clients; i++)

http_client_switch_ioloop(http_clients[i]);

test_client_requests_switch_ioloop();

io_loop_set_current(ioloop_nested);

io_loop_destroy(&ioloop_nested);

ioloop_nested = NULL;

ioloop_nested_depth--;

if (debug) {

i_debug("test client: echo: leaving ioloop for %u...%u (depth=%u)",

ioloop_nested_first, ioloop_nested_last, ioloop_nested_depth);

}

ioloop_nested_first = ioloop_nested_last = 0;

if (client_files_first >= count) {

io_loop_stop(current_ioloop);

return;

}

}

}

static void

test_client_echo(const struct http_client_settings *client_set)

{

/* create client */

test_client_create_clients(client_set);

/* start querying server */

client_files_first = client_files_last = 0;

test_client_echo_continue();

}

static void test_client_deinit(void)

{

unsigned int i;

for (i = 0; i < parallel_clients; i++)

http_client_deinit(&http_clients[i]);

i_free(http_clients);

parallel_clients = 1;

}

static void test_open_server_fd(void)

{

i_close_fd(&fd_listen);

fd_listen = net_listen(&bind_ip, &bind_port, 128);

if (fd_listen == -1) {

i_fatal("listen(%s:%u) failed: %m",

net_ip2addr(&bind_ip), bind_port);

}

}

static void test_server_kill(void)

{

if (server_pid != (pid_t)-1) {

(void)kill(server_pid, SIGKILL);

(void)waitpid(server_pid, NULL, 0);

}

server_pid = (pid_t)-1;

}

static void test_run_client_server(

const struct http_client_settings *client_set,

const struct http_server_settings *server_set,

void (*client_init)(const struct http_client_settings *client_set))

{

struct ioloop *ioloop;

test_open_server_fd();

if ((server_pid = fork()) == (pid_t)-1)

i_fatal("fork() failed: %m");

if (server_pid == 0) {

server_pid = (pid_t)-1;

hostpid_init();

if (debug)

i_debug("server: PID=%s", my_pid);

/* child: server */

ioloop_nested = NULL;

ioloop_nested_depth = 0;

ioloop = io_loop_create();

test_server_init(server_set);

io_loop_run(ioloop);

test_server_deinit();

io_loop_destroy(&ioloop);

i_close_fd(&fd_listen);

} else {

if (debug)

i_debug("client: PID=%s", my_pid);

i_close_fd(&fd_listen);

/* parent: client */

ioloop_nested = NULL;

ioloop_nested_depth = 0;

ioloop = io_loop_create();

client_init(client_set);

io_loop_run(ioloop);

test_client_deinit();

io_loop_destroy(&ioloop);

test_server_kill();

}

}

static void test_run_sequential(

void (*client_init)(const struct http_client_settings *client_set))

{

struct http_server_settings http_server_set;

struct http_client_settings http_client_set;

/* download files from blocking server */

/* server settings */

i_zero(&http_server_set);

http_server_set.max_pipelined_requests = 0;

http_server_set.debug = debug;

http_server_set.request_limits.max_payload_size = (uoff_t)-1;

/* client settings */

i_zero(&http_client_set);

http_client_set.max_idle_time_msecs = 5*1000;

http_client_set.max_parallel_connections = 1;

http_client_set.max_pipelined_requests = 1;

http_client_set.max_redirects = 0;

http_client_set.max_attempts = 1;

http_client_set.debug = debug;

test_files_init();

test_run_client_server

(&http_client_set, &http_server_set, client_init);