[serf] r1867 committed - On the multiple_ssl_impls branch: Merge from trunk r1856-1866.

[se...@googlecode.com]

Revision: 1867
Author: lieven....@gmail.com
Date: Mon May 20 14:54:34 2013
Log: On the multiple_ssl_impls branch: Merge from trunk r1856-1866.

http://code.google.com/p/serf/source/detail?r=1867

Modified:
/branches/multiple_ssl_impls
/branches/multiple_ssl_impls/SConstruct
/branches/multiple_ssl_impls/buckets/buckets.c
/branches/multiple_ssl_impls/buckets/response_buckets.c
/branches/multiple_ssl_impls/test/server/test_server.c
/branches/multiple_ssl_impls/test/server/test_server.h
/branches/multiple_ssl_impls/test/server/test_sslserver.c
/branches/multiple_ssl_impls/test/test_context.c
/branches/multiple_ssl_impls/test/test_serf.h
/branches/multiple_ssl_impls/test/test_util.c

=======================================
--- /branches/multiple_ssl_impls/SConstruct Fri May 17 13:34:25 2013
+++ /branches/multiple_ssl_impls/SConstruct Mon May 20 14:54:34 2013
@@ -148,9 +148,9 @@
### -Wall is not available on Solaris
ccflags = ['-std=c89', ]
if sys.platform != 'sunos5':
- ccflags.append('-Wall')
+ ccflags.append(['-Wall', '-Wmissing-prototypes'])
if debug:
- ccflags.append(['-g', '-Wmissing-prototypes'])
+ ccflags.append(['-g'])
else:
ccflags.append('-O2')
libs = [ ]
=======================================
--- /branches/multiple_ssl_impls/buckets/buckets.c Fri May 3 02:43:18 2013
+++ /branches/multiple_ssl_impls/buckets/buckets.c Mon May 20 14:54:34 2013
@@ -17,7 +17,7 @@

#include "serf.h"
#include "serf_bucket_util.h"
-
+#include "serf_private.h"

serf_bucket_t *serf_bucket_create(
const serf_bucket_type_t *type,
=======================================
--- /branches/multiple_ssl_impls/buckets/response_buckets.c Fri Nov 9
04:03:15 2012
+++ /branches/multiple_ssl_impls/buckets/response_buckets.c Mon May 20
14:54:34 2013
@@ -19,7 +19,7 @@

#include "serf.h"
#include "serf_bucket_util.h"
-
+#include "serf_private.h"

typedef struct {
serf_bucket_t *stream;
=======================================
--- /branches/multiple_ssl_impls/test/server/test_server.c Sun May 5
13:38:09 2013
+++ /branches/multiple_ssl_impls/test/server/test_server.c Mon May 20
14:54:34 2013
@@ -24,8 +24,10 @@
#include "test_server.h"


-apr_status_t test_server_destroy(serv_ctx_t *servctx)
+/* Cleanup callback for a server. */
+static apr_status_t cleanup_server(void *baton)
{
+ serv_ctx_t *servctx = baton;
apr_status_t status;

status = apr_socket_close(servctx->serv_sock);
@@ -33,22 +35,9 @@
if (servctx->client_sock) {
apr_socket_close(servctx->client_sock);
}
-
- if (servctx->ssl_ctx)
- cleanup_ssl_context(servctx);

return status;
}
-
-/* Cleanup callback for a server. */
-static apr_status_t cleanup_server(void *baton)
-{
- serv_ctx_t *serv_ctx = baton;
-
- test_server_destroy(serv_ctx);
-
- return APR_SUCCESS;
-}

/* Replay support functions */
static void next_message(serv_ctx_t *servctx)
@@ -134,39 +123,46 @@
message = &servctx->message_list[servctx->cur_message];
msg_len = strlen(message->text);

- len = msg_len - servctx->message_buf_pos;
- if (len > sizeof(buf))
- len = sizeof(buf);
+ do
+ {
+ len = msg_len - servctx->message_buf_pos;
+ if (len > sizeof(buf))
+ len = sizeof(buf);
+
+ status = servctx->read(servctx, buf, &len);
+ if (SERF_BUCKET_READ_ERROR(status))
+ return status;

- status = servctx->read(servctx, buf, &len);
- if (status != APR_SUCCESS)
- return status;
+ if (servctx->options & TEST_SERVER_DUMP)
+ fwrite(buf, len, 1, stdout);

- if (servctx->options & TEST_SERVER_DUMP)
- fwrite(buf, len, 1, stdout);
+ if (strncmp(buf,
+ message->text + servctx->message_buf_pos,
+ len) != 0) {
+ /* ## TODO: Better diagnostics. */
+ printf("Expected: (\n");
+ fwrite(message->text + servctx->message_buf_pos, len,
1,
+ stdout);
+ printf(")\n");
+ printf("Actual: (\n");
+ fwrite(buf, len, 1, stdout);
+ printf(")\n");

- if (strncmp(buf, message->text + servctx->message_buf_pos,
len) != 0) {
- /* ## TODO: Better diagnostics. */
- printf("Expected: (\n");
- fwrite(message->text + servctx->message_buf_pos, len, 1,
stdout);
- printf(")\n");
- printf("Actual: (\n");
- fwrite(buf, len, 1, stdout);
- printf(")\n");
-
- return SERF_ERROR_ISSUE_IN_TESTSUITE;
- }
+ return SERF_ERROR_ISSUE_IN_TESTSUITE;
+ }

- servctx->message_buf_pos += len;
+ servctx->message_buf_pos += len;

- if (servctx->message_buf_pos >= msg_len) {
- next_message(servctx);
- servctx->message_buf_pos -= msg_len;
- if (action->kind == SERVER_RESPOND)
- servctx->outstanding_responses++;
- if (action->kind == SERVER_RECV)
- next_action(servctx);
- }
+ if (servctx->message_buf_pos >= msg_len) {
+ next_message(servctx);
+ servctx->message_buf_pos -= msg_len;
+ if (action->kind == SERVER_RESPOND)
+ servctx->outstanding_responses++;
+ if (action->kind == SERVER_RECV)
+ next_action(servctx);
+ break;
+ }
+ } while (!status);
}
}
if (rtnevents & APR_POLLOUT) {
@@ -213,7 +209,7 @@
return status;
}

-apr_status_t test_server_run(serv_ctx_t *servctx,
+apr_status_t run_test_server(serv_ctx_t *servctx,
apr_short_interval_time_t duration,
apr_pool_t *pool)
{
@@ -308,7 +304,7 @@
message_list is a list of expected requests.
action_list is the list of responses to be returned in order.
*/
-void test_setup_server(serv_ctx_t **servctx_p,
+void setup_test_server(serv_ctx_t **servctx_p,
apr_sockaddr_t *address,
test_server_message_t *message_list,
apr_size_t message_count,
@@ -344,35 +340,7 @@
*servctx_p = servctx;
}

-void test_setup_https_server(serv_ctx_t **servctx_p,
- apr_sockaddr_t *address,
- test_server_message_t *message_list,
- apr_size_t message_count,
- test_server_action_t *action_list,
- apr_size_t action_count,
- apr_int32_t options,
- const char *keyfile,
- const char **certfiles,
- const char *client_cn,
- apr_pool_t *pool)
-{
- serv_ctx_t *servctx;
-
- test_setup_server(servctx_p, address, message_list,
- message_count, action_list, action_count,
- options, pool);
-
- servctx = *servctx_p;
-
- servctx->handshake = ssl_handshake;
- /* Override with SSL encrypt/decrypt functions */
- servctx->read = ssl_socket_read;
- servctx->send = ssl_socket_write;
-
- init_ssl_context(servctx, keyfile, certfiles, client_cn);
-}
-
-apr_status_t test_start_server(serv_ctx_t *servctx)
+apr_status_t start_test_server(serv_ctx_t *servctx)
{
apr_status_t status;
apr_socket_t *serv_sock;
=======================================
--- /branches/multiple_ssl_impls/test/server/test_server.h Fri May 3
02:43:18 2013
+++ /branches/multiple_ssl_impls/test/server/test_server.h Mon May 20
14:54:34 2013
@@ -94,9 +94,10 @@
handshake_func_t handshake;
void *ssl_ctx;
const char *client_cn;
+ apr_status_t bio_read_status;
};

-void test_setup_server(serv_ctx_t **servctx_p,
+void setup_test_server(serv_ctx_t **servctx_p,
apr_sockaddr_t *address,
test_server_message_t *message_list,
apr_size_t message_count,
@@ -105,7 +106,7 @@
apr_int32_t options,
apr_pool_t *pool);

-void test_setup_https_server(serv_ctx_t **servctx_p,
+void setup_https_test_server(serv_ctx_t **servctx_p,
apr_sockaddr_t *address,
test_server_message_t *message_list,
apr_size_t message_count,
@@ -117,24 +118,12 @@
const char *client_cn,
apr_pool_t *pool);

-apr_status_t test_start_server(serv_ctx_t *serv_ctx);
+apr_status_t start_test_server(serv_ctx_t *serv_ctx);

-apr_status_t test_server_run(serv_ctx_t *servctx,
+apr_status_t run_test_server(serv_ctx_t *servctx,
apr_short_interval_time_t duration,
apr_pool_t *pool);

-apr_status_t test_server_destroy(serv_ctx_t *servctx);
-
-apr_status_t init_ssl_context(serv_ctx_t *serv_ctx,
- const char *keyfile,
- const char **certfiles,
- const char *client_cn);
-apr_status_t ssl_handshake(serv_ctx_t *servctx);
-apr_status_t ssl_socket_write(serv_ctx_t *serv_ctx, const char *data,
- apr_size_t *len);
-apr_status_t ssl_socket_read(serv_ctx_t *serv_ctx, char *data, apr_size_t
*len);
-void cleanup_ssl_context(serv_ctx_t *serv_ctx);
-

#ifndef APR_VERSION_AT_LEAST /* Introduced in APR 1.3.0 */
#define APR_VERSION_AT_LEAST(major,minor,patch) \
=======================================
--- /branches/multiple_ssl_impls/test/server/test_sslserver.c Sun May 5
13:38:09 2013
+++ /branches/multiple_ssl_impls/test/server/test_sslserver.c Mon May 20
14:54:34 2013
@@ -35,7 +35,7 @@

} ssl_context_t;

-int pem_passwd_cb(char *buf, int size, int rwflag, void *userdata)
+static int pem_passwd_cb(char *buf, int size, int rwflag, void *userdata)
{
strncpy(buf, "serftest", size);
buf[size - 1] = '\0';
@@ -91,11 +91,14 @@
BIO_clear_retry_flags(bio);

status = apr_socket_recv(serv_ctx->client_sock, in, &len);
+ serv_ctx->bio_read_status = status;
+
if (status == APR_EAGAIN) {
+ serf__log(TEST_VERBOSE, __FILE__, "Read %d bytes from socket with "
+ "status %d.\n", len, status);
BIO_set_retry_read(bio);
if (len == 0)
return -1;
-
}

if (SERF_BUCKET_READ_ERROR(status))
@@ -148,14 +151,16 @@
return preverify_ok;
}

-apr_status_t init_ssl_context(serv_ctx_t *serv_ctx,
- const char *keyfile,
- const char **certfiles,
- const char *client_cn)
+static apr_status_t
+init_ssl_context(serv_ctx_t *serv_ctx,
+ const char *keyfile,
+ const char **certfiles,
+ const char *client_cn)
{
ssl_context_t *ssl_ctx = apr_pcalloc(serv_ctx->pool, sizeof(*ssl_ctx));
serv_ctx->ssl_ctx = ssl_ctx;
serv_ctx->client_cn = client_cn;
+ serv_ctx->bio_read_status = APR_SUCCESS;

/* Init OpenSSL globally */
if (!init_done)
@@ -217,7 +222,7 @@
return APR_SUCCESS;
}

-apr_status_t ssl_handshake(serv_ctx_t *serv_ctx)
+static apr_status_t ssl_handshake(serv_ctx_t *serv_ctx)
{
ssl_context_t *ssl_ctx = serv_ctx->ssl_ctx;
int result;
@@ -284,7 +289,7 @@
return APR_EAGAIN;
}

-apr_status_t
+static apr_status_t
ssl_socket_write(serv_ctx_t *serv_ctx, const char *data,
apr_size_t *len)
{
@@ -302,7 +307,7 @@
return SERF_ERROR_ISSUE_IN_TESTSUITE;
}

-apr_status_t
+static apr_status_t
ssl_socket_read(serv_ctx_t *serv_ctx, char *data,
apr_size_t *len)
{
@@ -312,15 +317,68 @@
if (result > 0) {
*len = result;
return APR_SUCCESS;
+ } else {
+ int ssl_err;
+
+ ssl_err = SSL_get_error(ssl_ctx->ssl, result);
+ switch (ssl_err) {
+ case SSL_ERROR_SYSCALL:
+ /* error in bio_bucket_read, probably APR_EAGAIN or
APR_EOF */
+ *len = 0;
+ return serv_ctx->bio_read_status;
+ case SSL_ERROR_WANT_READ:
+ *len = 0;
+ return APR_EAGAIN;
+ case SSL_ERROR_SSL:
+ default:
+ *len = 0;
+ return SERF_ERROR_ISSUE_IN_TESTSUITE;
+ }
}

+ /* not reachable */
return SERF_ERROR_ISSUE_IN_TESTSUITE;
}

-void cleanup_ssl_context(serv_ctx_t *serv_ctx)
+static apr_status_t cleanup_https_server(void *baton)
+{
+ serv_ctx_t *servctx = baton;
+ ssl_context_t *ssl_ctx = servctx->ssl_ctx;
+
+ if (ssl_ctx) {
+ SSL_clear(ssl_ctx->ssl);
+ SSL_CTX_free(ssl_ctx->ctx);
+ }
+
+ return APR_SUCCESS;
+}
+
+void setup_https_test_server(serv_ctx_t **servctx_p,
+ apr_sockaddr_t *address,
+ test_server_message_t *message_list,
+ apr_size_t message_count,
+ test_server_action_t *action_list,
+ apr_size_t action_count,
+ apr_int32_t options,
+ const char *keyfile,
+ const char **certfiles,
+ const char *client_cn,
+ apr_pool_t *pool)
{
- ssl_context_t *ssl_ctx = serv_ctx->ssl_ctx;
+ serv_ctx_t *servctx;
+
+ setup_test_server(servctx_p, address, message_list,
+ message_count, action_list, action_count,
+ options, pool);
+ servctx = *servctx_p;
+ apr_pool_cleanup_register(pool, servctx,
+ cleanup_https_server,
+ apr_pool_cleanup_null);
+
+ servctx->handshake = ssl_handshake;
+ /* Override with SSL encrypt/decrypt functions */
+ servctx->read = ssl_socket_read;
+ servctx->send = ssl_socket_write;

- SSL_clear(ssl_ctx->ssl);
- SSL_CTX_free(ssl_ctx->ctx);
+ init_ssl_context(servctx, keyfile, certfiles, client_cn);
}
=======================================
--- /branches/multiple_ssl_impls/test/test_context.c Sat May 18 05:28:03
2013
+++ /branches/multiple_ssl_impls/test/test_context.c Mon May 20 14:54:34
2013
@@ -38,6 +38,8 @@

const char *method;
const char *path;
+ /* Use this for a raw request message */
+ const char *request;
int done;

test_baton_t *tb;
@@ -67,7 +69,7 @@
{
apr_pool_clear(iter_pool);

- status = test_server_run(tb->serv_ctx, 0, iter_pool);
+ status = run_test_server(tb->serv_ctx, 0, iter_pool);
if (!APR_STATUS_IS_TIMEUP(status) &&
SERF_BUCKET_READ_ERROR(status))
return status;
@@ -136,15 +138,26 @@
handler_baton_t *ctx = setup_baton;
serf_bucket_t *body_bkt;

- /* create a simple body text */
- const char *str = apr_psprintf(pool, "%d", ctx->req_id);
- body_bkt = serf_bucket_simple_create(str, strlen(str), NULL, NULL,
- serf_request_get_alloc(request));
- *req_bkt =
- serf_request_bucket_request_create(request,
- ctx->method, ctx->path,
- body_bkt,
-
serf_request_get_alloc(request));
+ if (ctx->request)
+ {
+ /* Create a raw request bucket. */
+ *req_bkt = serf_bucket_simple_create(ctx->request,
strlen(ctx->request),
+ NULL, NULL,
+
serf_request_get_alloc(request));
+ }
+ else
+ {
+ /* create a simple body text */
+ const char *str = apr_psprintf(pool, "%d", ctx->req_id);
+
+ body_bkt = serf_bucket_simple_create(str, strlen(str), NULL, NULL,
+
serf_request_get_alloc(request));
+ *req_bkt =
+ serf_request_bucket_request_create(request,
+ ctx->method, ctx->path,
+ body_bkt,
+
serf_request_get_alloc(request));
+ }

APR_ARRAY_PUSH(ctx->sent_requests, int) = ctx->req_id;

@@ -211,6 +224,7 @@
handler_ctx->sent_requests = tb->sent_requests;
handler_ctx->handled_requests = tb->handled_requests;
handler_ctx->tb = tb;
+ handler_ctx->request = NULL;
}

static void create_new_prio_request(test_baton_t *tb,
@@ -269,10 +283,10 @@
apr_pool_t *test_pool = tc->testBaton;

/* Set up a test context with a server */
- status = test_server_setup(&tb,
- message_list, num_requests,
- action_list, num_requests, 0, NULL,
- test_pool);
+ status = test_http_server_setup(&tb,
+ message_list, num_requests,
+ action_list, num_requests, 0, NULL,
+ test_pool);
CuAssertIntEquals(tc, APR_SUCCESS, status);

create_new_request(tb, &handler_ctx[0], "GET", "/", 1);
@@ -319,10 +333,10 @@
apr_pool_t *test_pool = tc->testBaton;

/* Set up a test context with a server */
- status = test_server_setup(&tb,
- message_list, num_requests,
- action_list, num_requests, 0, NULL,
- test_pool);
+ status = test_http_server_setup(&tb,
+ message_list, num_requests,
+ action_list, num_requests, 0, NULL,
+ test_pool);
CuAssertIntEquals(tc, APR_SUCCESS, status);

create_new_request(tb, &handler_ctx[0], "GET", "/", 2);
@@ -400,12 +414,12 @@
apr_pool_t *test_pool = tc->testBaton;

/* Set up a test context with a server. */
- status = test_server_setup(&tb,
- message_list, num_requests,
- action_list, 12,
- 0,
- NULL,
- test_pool);
+ status = test_http_server_setup(&tb,
+ message_list, num_requests,
+ action_list, 12,
+ 0,
+ NULL,
+ test_pool);
CuAssertIntEquals(tc, APR_SUCCESS, status);

/* Send some requests on the connections */
@@ -414,7 +428,7 @@
}

while (1) {
- status = test_server_run(tb->serv_ctx, 0, test_pool);
+ status = run_test_server(tb->serv_ctx, 0, test_pool);
if (APR_STATUS_IS_TIMEUP(status))
status = APR_SUCCESS;
CuAssertIntEquals(tc, APR_SUCCESS, status);
@@ -491,12 +505,12 @@
{
apr_pool_clear(iter_pool);

- status = test_server_run(tb->serv_ctx, 0, iter_pool);
+ status = run_test_server(tb->serv_ctx, 0, iter_pool);
if (APR_STATUS_IS_TIMEUP(status))
status = APR_SUCCESS;
CuAssertIntEquals(tc, APR_SUCCESS, status);

- status = test_server_run(tb->proxy_ctx, 0, iter_pool);
+ status = run_test_server(tb->proxy_ctx, 0, iter_pool);
if (APR_STATUS_IS_TIMEUP(status))
status = APR_SUCCESS;
CuAssertIntEquals(tc, APR_SUCCESS, status);
@@ -607,10 +621,10 @@
apr_pool_t *test_pool = tc->testBaton;

/* Set up a test context with a server. */
- status = test_server_setup(&tb,
- message_list, RCVD_REQUESTS,
- action_list, RCVD_REQUESTS, 0, NULL,
- test_pool);
+ status = test_http_server_setup(&tb,
+ message_list, RCVD_REQUESTS,
+ action_list, RCVD_REQUESTS, 0, NULL,
+ test_pool);
CuAssertIntEquals(tc, APR_SUCCESS, status);

for (i = 0 ; i < SEND_REQUESTS ; i++) {
@@ -621,7 +635,7 @@
}

while (1) {
- status = test_server_run(tb->serv_ctx, 0, test_pool);
+ status = run_test_server(tb->serv_ctx, 0, test_pool);
if (APR_STATUS_IS_TIMEUP(status))
status = APR_SUCCESS;
CuAssertIntEquals(tc, APR_SUCCESS, status);
@@ -738,10 +752,10 @@
apr_pool_t *test_pool = tc->testBaton;

/* Set up a test context with a server. */
- status = test_server_setup(&tb,
- message_list, RCVD_REQUESTS,
- action_list, RCVD_REQUESTS, 0, NULL,
- test_pool);
+ status = test_http_server_setup(&tb,
+ message_list, RCVD_REQUESTS,
+ action_list, RCVD_REQUESTS, 0, NULL,
+ test_pool);
CuAssertIntEquals(tc, APR_SUCCESS, status);

for (i = 0 ; i < SEND_REQUESTS ; i++) {
@@ -751,7 +765,7 @@
}

while (1) {
- status = test_server_run(tb->serv_ctx, 0, test_pool);
+ status = run_test_server(tb->serv_ctx, 0, test_pool);
if (APR_STATUS_IS_TIMEUP(status))
status = APR_SUCCESS;
CuAssertIntEquals(tc, APR_SUCCESS, status);
@@ -836,10 +850,10 @@
apr_pool_t *test_pool = tc->testBaton;

/* Set up a test context with a server. */
- status = test_server_setup(&tb,
- message_list, num_requests,
- action_list, num_requests, 0,
- progress_conn_setup, test_pool);
+ status = test_http_server_setup(&tb,
+ message_list, num_requests,
+ action_list, num_requests, 0,
+ progress_conn_setup, test_pool);
CuAssertIntEquals(tc, APR_SUCCESS, status);

/* Set up the progress callback. */
@@ -1015,10 +1029,10 @@
apr_pool_t *test_pool = tc->testBaton;

/* Set up a test context with a server. */
- status = test_server_setup(&tb,
- message_list, 2,
- action_list, 1, 0,
- NULL, test_pool);
+ status = test_http_server_setup(&tb,
+ message_list, 2,
+ action_list, 1, 0,
+ NULL, test_pool);
CuAssertIntEquals(tc, APR_SUCCESS, status);

/* Send some requests on the connection */
@@ -1098,13 +1112,82 @@
action_list[0].text = response;

/* Set up a test context with a server */
- status = test_server_setup(&tb,
- message_list, num_requests,
- action_list, num_requests, 0, NULL,
- test_pool);
+ status = test_http_server_setup(&tb,
+ message_list, num_requests,
+ action_list, num_requests, 0, NULL,
+ test_pool);
+ CuAssertIntEquals(tc, APR_SUCCESS, status);
+
+ create_new_request(tb, &handler_ctx[0], "GET", "/", 1);
+
+ test_helper_run_requests_expect_ok(tc, tb, num_requests, handler_ctx,
+ test_pool);
+}
+
+static const char *create_large_request_message(apr_pool_t *pool)
+{
+ const char *request = "GET / HTTP/1.1" CRLF
+ "Host: localhost:12345" CRLF
+ "Transfer-Encoding: chunked" CRLF
+ CRLF;
+ struct iovec vecs[500];
+ const int num_vecs = 5;
+ int i, j;
+ apr_size_t len;
+
+ vecs[0].iov_base = (char *)request;
+ vecs[0].iov_len = strlen(request);
+
+ for (i = 1; i < num_vecs; i++)
+ {
+ int chunk_len = 10 * i * 3;
+
+ /* end with empty chunk */
+ if (i == num_vecs - 1)
+ chunk_len = 0;
+
+ char *chunk, *buf = apr_pcalloc(pool, chunk_len + 1);
+ for (j = 0; j < chunk_len; j += 10)
+ memcpy(buf + j, "0123456789", 10);
+
+ chunk = apr_pstrcat(pool,
+ apr_psprintf(pool, "%x", chunk_len),
+ CRLF, buf, CRLF, NULL);
+ vecs[i].iov_base = chunk;
+ vecs[i].iov_len = strlen(chunk);
+ }
+
+ return apr_pstrcatv(pool, vecs, num_vecs, &len);
+}
+
+/* Validate sending a large chunked response. */
+static void test_serf_connection_large_request(CuTest *tc)
+{
+ test_baton_t *tb;
+ handler_baton_t handler_ctx[1];
+ const int num_requests = sizeof(handler_ctx)/sizeof(handler_ctx[0]);
+ test_server_message_t message_list[1];
+ test_server_action_t action_list[] = {
+ {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
+ };
+ const char *request;
+ apr_status_t status;
+
+ apr_pool_t *test_pool = tc->testBaton;
+
+ /* Set up a test context with a server */
+ status = test_http_server_setup(&tb,
+ message_list, num_requests,
+ action_list, num_requests, 0, NULL,
+ test_pool);
CuAssertIntEquals(tc, APR_SUCCESS, status);

+ /* create large chunked request message */
+ request = create_large_request_message(test_pool);
+ message_list[0].text = request;
+
create_new_request(tb, &handler_ctx[0], "GET", "/", 1);
+ handler_ctx[0].request = request;

test_helper_run_requests_expect_ok(tc, tb, num_requests, handler_ctx,
test_pool);
@@ -1698,8 +1781,46 @@
handler_ctx, test_pool);
}

-apr_status_t client_cert_cb(void *data,
- const char **cert_path)
+/* Similar to test_serf_connection_large_request, validate sending a large
+ chunked request over SSL. */
+static void test_serf_ssl_large_request(CuTest *tc)
+{
+ test_baton_t *tb;
+ handler_baton_t handler_ctx[1];
+ const int num_requests = sizeof(handler_ctx)/sizeof(handler_ctx[0]);
+ test_server_message_t message_list[1];
+ test_server_action_t action_list[] = {
+ {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
+ };
+ const char *request;
+ apr_status_t status;
+
+ /* Set up a test context with a server */
+ apr_pool_t *test_pool = tc->testBaton;
+
+ status = test_https_server_setup(&tb,
+ message_list, num_requests,
+ action_list, num_requests, 0,
+ https_set_root_ca_conn_setup,
+ "test/server/serfserverkey.pem",
+ server_certs,
+ NULL, /* no client cert */
+ NULL, /* No server cert callback */
+ test_pool);
+ CuAssertIntEquals(tc, APR_SUCCESS, status);
+
+ /* create large chunked request message */
+ request = create_large_request_message(test_pool);
+ message_list[0].text = request;
+
+ create_new_request(tb, &handler_ctx[0], "GET", "/", 1);
+ handler_ctx[0].request = request;
+
+ test_helper_run_requests_expect_ok(tc, tb, num_requests,
+ handler_ctx, test_pool);
+}
+
+static apr_status_t client_cert_cb(void *data, const char **cert_path)
{
test_baton_t *tb = data;

@@ -1710,9 +1831,9 @@
return APR_SUCCESS;
}

-apr_status_t client_cert_pw_cb(void *data,
- const char *cert_path,
- const char **password)
+static apr_status_t client_cert_pw_cb(void *data,
+ const char *cert_path,
+ const char **password)
{
test_baton_t *tb = data;

@@ -2019,6 +2140,7 @@
SUITE_ADD_TEST(suite, test_serf_progress_callback);
SUITE_ADD_TEST(suite, test_serf_request_timeout);
SUITE_ADD_TEST(suite, test_serf_connection_large_response);
+ SUITE_ADD_TEST(suite, test_serf_connection_large_request);
SUITE_ADD_TEST(suite, test_serf_ssl_handshake);
SUITE_ADD_TEST(suite, test_serf_ssl_trust_rootca);
SUITE_ADD_TEST(suite, test_serf_ssl_application_rejects_cert);
@@ -2027,6 +2149,7 @@
SUITE_ADD_TEST(suite, test_serf_ssl_no_servercert_callback_allok);
SUITE_ADD_TEST(suite, test_serf_ssl_no_servercert_callback_fail);
SUITE_ADD_TEST(suite, test_serf_ssl_large_response);
+ SUITE_ADD_TEST(suite, test_serf_ssl_large_request);
SUITE_ADD_TEST(suite, test_serf_ssl_client_certificate);
SUITE_ADD_TEST(suite, test_serf_ssl_identity);
SUITE_ADD_TEST(suite, test_serf_ssl_expired_server_cert);
=======================================
--- /branches/multiple_ssl_impls/test/test_serf.h Fri May 3 02:43:18 2013
+++ /branches/multiple_ssl_impls/test/test_serf.h Mon May 20 14:54:34 2013
@@ -124,14 +124,14 @@
serf_ssl_need_server_cert_t
server_cert_cb,
apr_pool_t *pool);

-apr_status_t test_server_setup(test_baton_t **tb_p,
- test_server_message_t *message_list,
- apr_size_t message_count,
- test_server_action_t *action_list,
- apr_size_t action_count,
- apr_int32_t options,
- serf_connection_setup_t conn_setup,
- apr_pool_t *pool);
+apr_status_t test_http_server_setup(test_baton_t **tb_p,
+ test_server_message_t *message_list,
+ apr_size_t message_count,
+ test_server_action_t *action_list,
+ apr_size_t action_count,
+ apr_int32_t options,
+ serf_connection_setup_t conn_setup,
+ apr_pool_t *pool);

apr_status_t test_server_proxy_setup(
test_baton_t **tb_p,
=======================================
--- /branches/multiple_ssl_impls/test/test_util.c Fri May 17 13:34:25 2013
+++ /branches/multiple_ssl_impls/test/test_util.c Mon May 20 14:54:34 2013
@@ -110,6 +110,8 @@
return APR_SUCCESS;
}

+/* Setup the client context, ready to connect and send requests to a
+ server.*/
static apr_status_t setup(test_baton_t **tb_p,
serf_connection_setup_t conn_setup,
const char *serv_url,
@@ -163,7 +165,7 @@
return status;
}

-
+/* Setup an https server and the client context to connect to that server
*/
apr_status_t test_https_server_setup(test_baton_t **tb_p,
test_server_message_t *message_list,
apr_size_t message_count,
@@ -193,24 +195,25 @@
tb->server_cert_cb = server_cert_cb;

/* Prepare a server. */
- test_setup_https_server(&tb->serv_ctx, tb->serv_addr,
+ setup_https_test_server(&tb->serv_ctx, tb->serv_addr,
message_list, message_count,
action_list, action_count, options,
keyfile, certfiles, client_cn,
pool);
- status = test_start_server(tb->serv_ctx);
+ status = start_test_server(tb->serv_ctx);

return status;
}

-apr_status_t test_server_setup(test_baton_t **tb_p,
- test_server_message_t *message_list,
- apr_size_t message_count,
- test_server_action_t *action_list,
- apr_size_t action_count,
- apr_int32_t options,
- serf_connection_setup_t conn_setup,
- apr_pool_t *pool)
+/* Setup an http server and the client context to connect to that server */
+apr_status_t test_http_server_setup(test_baton_t **tb_p,
+ test_server_message_t *message_list,
+ apr_size_t message_count,
+ test_server_action_t *action_list,
+ apr_size_t action_count,
+ apr_int32_t options,
+ serf_connection_setup_t conn_setup,
+ apr_pool_t *pool)
{
apr_status_t status;
test_baton_t *tb;
@@ -227,15 +230,17 @@
tb = *tb_p;

/* Prepare a server. */
- test_setup_server(&tb->serv_ctx, tb->serv_addr,
+ setup_test_server(&tb->serv_ctx, tb->serv_addr,
message_list, message_count,
action_list, action_count, options,
pool);
- status = test_start_server(tb->serv_ctx);
+ status = start_test_server(tb->serv_ctx);

return status;
}

+/* Setup a proxy server and an http server and the client context to
connect to
+ that proxy server */
apr_status_t
test_server_proxy_setup(test_baton_t **tb_p,
test_server_message_t *serv_message_list,
@@ -265,22 +270,22 @@
tb = *tb_p;

/* Prepare the server. */
- test_setup_server(&tb->serv_ctx, tb->serv_addr,
+ setup_test_server(&tb->serv_ctx, tb->serv_addr,
serv_message_list, serv_message_count,
serv_action_list, serv_action_count,
options,
pool);
- status = test_start_server(tb->serv_ctx);
+ status = start_test_server(tb->serv_ctx);
if (status != APR_SUCCESS)
return status;

/* Prepare the proxy. */
- test_setup_server(&tb->proxy_ctx, tb->proxy_addr,
+ setup_test_server(&tb->proxy_ctx, tb->proxy_addr,
proxy_message_list, proxy_message_count,
proxy_action_list, proxy_action_count,
options,
pool);
- status = test_start_server(tb->proxy_ctx);
+ status = start_test_server(tb->proxy_ctx);

return status;
}