static void
do_persistent_connection_timeout_test (void)
{
SoupSession *session;
debug_printf (1, "\nUnexpected timing out of persistent connections\n");
debug_printf (1, " Async session, message API\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
do_timeout_test_for_session (session);
soup_test_session_abort_unref (session);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
NULL);
do_timeout_req_test_for_session (session);
soup_test_session_abort_unref (session);
debug_printf (1, " Sync session, message API\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);
do_timeout_test_for_session (session);
soup_test_session_abort_unref (session);
session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);
do_timeout_req_test_for_session (session);
soup_test_session_abort_unref (session);
}
static void
do_aliases_test (void)
{
SoupSession *session;
char *aliases[] = { "foo", NULL };
debug_printf (1, "\nhttp-aliases / https-aliases\n");
debug_printf (1, " Default behavior\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
do_aliases_test_for_session (session, "http");
soup_test_session_abort_unref (session);
debug_printf (1, " foo-means-https\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_HTTPS_ALIASES, aliases,
NULL);
do_aliases_test_for_session (session, "https");
soup_test_session_abort_unref (session);
debug_printf (1, " foo-means-nothing\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_HTTP_ALIASES, NULL,
NULL);
do_aliases_test_for_session (session, NULL);
soup_test_session_abort_unref (session);
}
static void
do_timeout_tests (char *fast_uri, char *slow_uri)
{
SoupSession *timeout_session, *idle_session, *plain_session;
debug_printf (1, " async\n");
timeout_session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_TIMEOUT, 1,
NULL);
idle_session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_IDLE_TIMEOUT, 1,
NULL);
/* The "plain" session also has an idle timeout, but it's longer
* than the test takes, so for our purposes it should behave like
* it has no timeout.
*/
plain_session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_IDLE_TIMEOUT, 2,
NULL);
do_tests_for_session (timeout_session, idle_session, plain_session,
fast_uri, slow_uri);
soup_test_session_abort_unref (timeout_session);
soup_test_session_abort_unref (idle_session);
soup_test_session_abort_unref (plain_session);
debug_printf (1, " sync\n");
timeout_session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC,
SOUP_SESSION_TIMEOUT, 1,
NULL);
/* SOUP_SESSION_TIMEOUT doesn't work with sync sessions */
plain_session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC,
NULL);
do_tests_for_session (timeout_session, NULL, plain_session, fast_uri, slow_uri);
soup_test_session_abort_unref (timeout_session);
}
static gpointer
test1_thread (gpointer use_thread_context)
{
SoupSession *session;
GMainContext *async_context;
char *uri;
SoupMessage *msg;
GMainLoop *loop;
/* Wait for main thread to be waiting on test1_cond */
g_mutex_lock (&test1_mutex);
g_mutex_unlock (&test1_mutex);
async_context = g_main_context_new ();
if (use_thread_context) {
g_main_context_push_thread_default (async_context);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
NULL);
} else {
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_ASYNC_CONTEXT, async_context,
NULL);
}
g_main_context_unref (async_context);
uri = g_build_filename (base_uri, "slow", NULL);
debug_printf (1, " send_message\n");
msg = soup_message_new ("GET", uri);
soup_session_send_message (session, msg);
soup_test_assert_message_status (msg, SOUP_STATUS_OK);
g_object_unref (msg);
debug_printf (1, " queue_message\n");
msg = soup_message_new ("GET", uri);
loop = g_main_loop_new (async_context, FALSE);
g_object_ref (msg);
soup_session_queue_message (session, msg, test1_finished, loop);
g_main_loop_run (loop);
g_main_loop_unref (loop);
soup_test_assert_message_status (msg, SOUP_STATUS_OK);
g_object_unref (msg);
soup_test_session_abort_unref (session);
g_free (uri);
g_cond_signal (&test1_cond);
if (use_thread_context)
g_main_context_pop_thread_default (async_context);
return NULL;
}
int
main (int argc, char **argv)
{
SoupSession *session;
const char *base_uri;
test_init (argc, argv, NULL);
apache_init ();
base_uri = "http://127.0.0.1:47524/";
get_correct_response (base_uri);
debug_printf (1, "\nFully async, fast requests\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
g_signal_connect (session, "authenticate",
G_CALLBACK (authenticate), NULL);
do_fully_async_test (session, base_uri, "/",
TRUE, SOUP_STATUS_OK);
do_fully_async_test (session, base_uri, "/Basic/realm1/",
TRUE, SOUP_STATUS_UNAUTHORIZED);
do_fully_async_test (session, base_uri, "/Basic/realm2/",
TRUE, SOUP_STATUS_OK);
soup_test_session_abort_unref (session);
debug_printf (1, "\nFully async, slow requests\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
g_signal_connect (session, "authenticate",
G_CALLBACK (authenticate), NULL);
do_fully_async_test (session, base_uri, "/",
FALSE, SOUP_STATUS_OK);
do_fully_async_test (session, base_uri, "/Basic/realm1/",
FALSE, SOUP_STATUS_UNAUTHORIZED);
do_fully_async_test (session, base_uri, "/Basic/realm2/",
FALSE, SOUP_STATUS_OK);
soup_test_session_abort_unref (session);
debug_printf (1, "\nSynchronously async\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
g_signal_connect (session, "authenticate",
G_CALLBACK (authenticate), NULL);
do_synchronously_async_test (session, base_uri, "/",
SOUP_STATUS_OK);
do_synchronously_async_test (session, base_uri, "/Basic/realm1/",
SOUP_STATUS_UNAUTHORIZED);
do_synchronously_async_test (session, base_uri, "/Basic/realm2/",
SOUP_STATUS_OK);
soup_test_session_abort_unref (session);
soup_buffer_free (correct_response);
test_cleanup ();
return errors != 0;
}
static void
do_infinite_auth_test (void)
{
SoupSession *session;
SoupMessage *msg;
char *uri;
int timeout;
SOUP_TEST_SKIP_IF_NO_APACHE;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
g_signal_connect (session, "authenticate",
G_CALLBACK (infinite_authenticate), NULL);
uri = g_strconcat (base_uri, "Basic/realm1/", NULL);
msg = soup_message_new ("GET", uri);
g_free (uri);
timeout = g_timeout_add (500, infinite_cancel, session);
g_test_expect_message ("libsoup", G_LOG_LEVEL_WARNING,
"*stuck in infinite loop*");
soup_session_send_message (session, msg);
g_test_assert_expected_messages ();
soup_test_assert (msg->status_code != SOUP_STATUS_CANCELLED,
"Got stuck in loop");
soup_test_assert_message_status (msg, SOUP_STATUS_UNAUTHORIZED);
g_source_remove (timeout);
soup_test_session_abort_unref (session);
g_object_unref (msg);
}
static void
do_infinite_auth_test (const char *base_uri)
{
SoupSession *session;
SoupMessage *msg;
char *uri;
int timeout;
debug_printf (1, "\nTesting broken infinite-loop auth:\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
g_signal_connect (session, "authenticate",
G_CALLBACK (infinite_authenticate), NULL);
uri = g_strconcat (base_uri, "Basic/realm1/", NULL);
msg = soup_message_new ("GET", uri);
g_free (uri);
timeout = g_timeout_add (500, infinite_cancel, session);
expect_warning = TRUE;
soup_session_send_message (session, msg);
if (msg->status_code == SOUP_STATUS_CANCELLED) {
debug_printf (1, " FAILED: Got stuck in loop");
errors++;
} else if (msg->status_code != SOUP_STATUS_UNAUTHORIZED) {
debug_printf (1, " Final status wrong: expected 401, got %u\n",
msg->status_code);
errors++;
}
g_source_remove (timeout);
soup_test_session_abort_unref (session);
g_object_unref (msg);
}
static void
force_io_streams_init (void)
{
SoupServer *server;
SoupSession *session;
guint port;
SoupURI *base_uri;
SoupMessage *msg;
/* Poke libsoup enough to cause SoupBodyInputStream and
* SoupBodyOutputStream to get defined, so we can find them
* via g_type_from_name() later.
*/
server = soup_test_server_new (TRUE);
port = soup_server_get_port (server);
base_uri = soup_uri_new ("http://127.0.0.1");
soup_uri_set_port (base_uri, port);
session = soup_test_session_new (SOUP_TYPE_SESSION, NULL);
msg = soup_message_new_from_uri ("POST", base_uri);
soup_session_send_message (session, msg);
g_object_unref (msg);
soup_test_session_abort_unref (session);
soup_uri_free (base_uri);
soup_test_server_quit_unref (server);
}
static void
do_idle_on_dispose_test (void)
{
SoupSession *session;
SoupMessage *msg;
GMainContext *async_context;
debug_printf (1, "\nTesting SoupSessionAsync dispose behavior\n");
async_context = g_main_context_new ();
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_ASYNC_CONTEXT, async_context,
NULL);
msg = soup_message_new_from_uri ("GET", base_uri);
soup_session_send_message (session, msg);
g_object_unref (msg);
while (g_main_context_iteration (async_context, FALSE))
;
g_object_run_dispose (G_OBJECT (session));
if (g_main_context_iteration (async_context, FALSE)) {
debug_printf (1, " idle was queued!\n");
errors++;
}
g_object_unref (session);
g_main_context_unref (async_context);
}
static void
do_dot_dot_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupURI *uri;
debug_printf (1, "\n'..' smuggling test\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);
uri = soup_uri_new_with_base (base_uri, "/..%2ftest");
msg = soup_message_new_from_uri ("GET", uri);
soup_uri_free (uri);
soup_session_send_message (session, msg);
if (msg->status_code != SOUP_STATUS_BAD_REQUEST) {
debug_printf (1, " FAILED: %d %s (expected Bad Request)\n",
msg->status_code, msg->reason_phrase);
errors++;
}
g_object_unref (msg);
soup_test_session_abort_unref (session);
}
static void
do_pipelined_auth_test (const char *base_uri)
{
SoupSession *session;
SoupMessage *msg;
gboolean authenticated;
char *uri;
int i;
debug_printf (1, "Testing pipelined auth (bug 271540):\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
authenticated = FALSE;
g_signal_connect (session, "authenticate",
G_CALLBACK (bug271540_authenticate), &authenticated);
uri = g_strconcat (base_uri, "Basic/realm1/", NULL);
for (i = 0; i < 10; i++) {
msg = soup_message_new (SOUP_METHOD_GET, uri);
g_object_set_data (G_OBJECT (msg), "#", GINT_TO_POINTER (i + 1));
g_signal_connect (msg, "wrote_headers",
G_CALLBACK (bug271540_sent), &authenticated);
soup_session_queue_message (session, msg,
bug271540_finished, &i);
}
g_free (uri);
loop = g_main_loop_new (NULL, TRUE);
g_main_loop_run (loop);
g_main_loop_unref (loop);
soup_test_session_abort_unref (session);
}
static void
do_proxy_fragment_test (SoupURI *base_uri)
{
SoupSession *session;
SoupURI *proxy_uri, *req_uri;
SoupMessage *msg;
debug_printf (1, "\nTesting request with fragment via proxy\n");
proxy_uri = soup_uri_new (proxies[SIMPLE_PROXY]);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_PROXY_URI, proxy_uri,
NULL);
soup_uri_free (proxy_uri);
req_uri = soup_uri_new_with_base (base_uri, "/#foo");
msg = soup_message_new_from_uri (SOUP_METHOD_GET, req_uri);
soup_uri_free (req_uri);
soup_session_send_message (session, msg);
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
debug_printf (1, " unexpected status %d %s!\n",
msg->status_code, msg->reason_phrase);
errors++;
}
g_object_unref (msg);
soup_test_session_abort_unref (session);
}
static void
do_ntlm_round (SoupURI *base_uri, gboolean use_ntlm, const char *user)
{
SoupSession *session;
gboolean alice = use_ntlm && !strcmp (user, "alice");
gboolean bob = use_ntlm && !strcmp (user, "bob");
g_return_if_fail (use_ntlm || !alice);
session = soup_test_session_new (
SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_NTLM, use_ntlm,
NULL);
if (user) {
g_signal_connect (session, "authenticate",
G_CALLBACK (authenticate), (char *)user);
}
do_message (session, base_uri, "/noauth",
FALSE, use_ntlm,
FALSE, FALSE,
SOUP_STATUS_OK);
do_message (session, base_uri, "/alice",
!use_ntlm || bob, FALSE,
FALSE, FALSE,
alice ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
do_message (session, base_uri, "/alice/404",
!use_ntlm, bob,
FALSE, FALSE,
alice ? SOUP_STATUS_NOT_FOUND :
SOUP_STATUS_UNAUTHORIZED);
do_message (session, base_uri, "/alice",
!use_ntlm, bob,
FALSE, FALSE,
alice ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
do_message (session, base_uri, "/bob",
!use_ntlm || alice, bob,
FALSE, FALSE,
bob ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
do_message (session, base_uri, "/alice",
!use_ntlm || bob, alice,
FALSE, FALSE,
alice ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
do_message (session, base_uri, "/basic",
FALSE, bob,
TRUE, user != NULL,
user != NULL ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
do_message (session, base_uri, "/either",
!use_ntlm, FALSE,
!use_ntlm, !use_ntlm && user != NULL,
user != NULL ? SOUP_STATUS_OK :
SOUP_STATUS_UNAUTHORIZED);
soup_test_session_abort_unref (session);
}
static void
do_one_accept_language_test (const char *language, const char *expected_header)
{
SoupSession *session;
SoupMessage *msg;
const char *val;
debug_printf (1, " LANGUAGE=%s\n", language);
g_setenv ("LANGUAGE", language, TRUE);
session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC,
SOUP_SESSION_ACCEPT_LANGUAGE_AUTO, TRUE,
NULL);
msg = soup_message_new_from_uri ("GET", base_uri);
soup_session_send_message (session, msg);
soup_test_session_abort_unref (session);
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
debug_printf (1, " Message failed? %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
val = soup_message_headers_get_list (msg->request_headers,
"Accept-Language");
if (!val) {
debug_printf (1, " No Accept-Language set!\n");
errors++;
} else if (strcmp (val, expected_header) != 0) {
debug_printf (1, " Wrong Accept-Language: expected '%s', got '%s'\n",
expected_header, val);
errors++;
}
g_object_unref (msg);
}
static void
do_async_auth_no_password_test (void)
{
SoupSession *session;
SoupMessage *msg;
guint auth_id;
char *uri;
int remaining;
gboolean been_there;
/* Test that giving no password doesn't cause multiple
* authenticate signals the second time.
*/
g_test_bug ("583462");
SOUP_TEST_SKIP_IF_NO_APACHE;
loop = g_main_loop_new (NULL, TRUE);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
uri = g_strconcat (base_uri, "Basic/realm1/", NULL);
remaining = 0;
/* Send a message that doesn't actually authenticate
*/
msg = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg), "id", GINT_TO_POINTER (1));
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (async_authenticate), NULL);
g_object_ref (msg);
remaining++;
soup_session_queue_message (session, msg, async_finished, &remaining);
g_main_loop_run (loop);
g_signal_handler_disconnect (session, auth_id);
soup_session_unpause_message (session, msg);
g_main_loop_run (loop);
g_object_unref(msg);
/* Now send a second message */
msg = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg), "id", GINT_TO_POINTER (2));
g_object_ref (msg);
been_there = FALSE;
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (async_authenticate_assert_once_and_stop),
&been_there);
remaining++;
soup_session_queue_message (session, msg, async_finished, &remaining);
g_main_loop_run (loop);
soup_session_unpause_message (session, msg);
g_main_loop_run (loop);
g_signal_handler_disconnect (session, auth_id);
soup_test_session_abort_unref (session);
g_object_unref (msg);
g_free (uri);
g_main_loop_unref (loop);
}
/* Server handlers for "*" work but are separate from handlers for
* all other URIs. #590751
*/
static void
do_star_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupURI *star_uri;
const char *handled_by;
debug_printf (1, "\nOPTIONS *\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);
star_uri = soup_uri_copy (base_uri);
soup_uri_set_path (star_uri, "*");
debug_printf (1, " Testing with no handler\n");
msg = soup_message_new_from_uri ("OPTIONS", star_uri);
soup_session_send_message (session, msg);
if (msg->status_code != SOUP_STATUS_NOT_FOUND) {
debug_printf (1, " Unexpected response: %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
handled_by = soup_message_headers_get_one (msg->response_headers,
"X-Handled-By");
if (handled_by) {
/* Should have been rejected by SoupServer directly */
debug_printf (1, " Message reached handler '%s'\n",
handled_by);
errors++;
}
g_object_unref (msg);
soup_server_add_handler (server, "*", server_star_callback, NULL, NULL);
debug_printf (1, " Testing with handler\n");
msg = soup_message_new_from_uri ("OPTIONS", star_uri);
soup_session_send_message (session, msg);
if (msg->status_code != SOUP_STATUS_OK) {
debug_printf (1, " Unexpected response: %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
handled_by = soup_message_headers_get_one (msg->response_headers,
"X-Handled-By");
if (!handled_by) {
debug_printf (1, " Message did not reach handler!\n");
errors++;
} else if (strcmp (handled_by, "star_callback") != 0) {
debug_printf (1, " Message reached incorrect handler '%s'\n",
handled_by);
errors++;
}
g_object_unref (msg);
soup_test_session_abort_unref (session);
soup_uri_free (star_uri);
}
static void
do_cancel_while_reading_test (void)
{
SoupSession *session;
debug_printf (1, "\nCancelling message while reading response (msg api)\n");
debug_printf (1, " Async session\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
do_cancel_while_reading_test_for_session (session);
soup_test_session_abort_unref (session);
debug_printf (1, " Sync session\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);
do_cancel_while_reading_test_for_session (session);
soup_test_session_abort_unref (session);
}
static void
do_connection_event_test (void)
{
SoupSession *session;
debug_printf (1, "\nConnection events\n");
debug_printf (1, " Async session\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
do_connection_event_test_for_session (session);
soup_test_session_abort_unref (session);
debug_printf (1, " Sync session\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);
do_connection_event_test_for_session (session);
soup_test_session_abort_unref (session);
}
static void
do_non_persistent_connection_test (void)
{
SoupSession *session;
debug_printf (1, "\nNon-persistent connections are closed immediately\n");
debug_printf (1, " Async session\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
do_non_persistent_test_for_session (session);
soup_test_session_abort_unref (session);
debug_printf (1, " Sync session\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);
do_non_persistent_test_for_session (session);
soup_test_session_abort_unref (session);
}
static void
do_non_idempotent_connection_test (void)
{
SoupSession *session;
debug_printf (1, "\nNon-idempotent methods are always sent on new connections\n");
debug_printf (1, " Async session\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
do_non_idempotent_test_for_session (session);
soup_test_session_abort_unref (session);
debug_printf (1, " Sync session\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);
do_non_idempotent_test_for_session (session);
soup_test_session_abort_unref (session);
}
static void
do_content_length_framing_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupURI *request_uri;
goffset declared_length;
debug_printf (1, "\nInvalid Content-Length framing tests\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
debug_printf (1, " Content-Length larger than message body length\n");
request_uri = soup_uri_new_with_base (base_uri, "/content-length/long");
msg = soup_message_new_from_uri ("GET", request_uri);
soup_session_send_message (session, msg);
if (msg->status_code != SOUP_STATUS_OK) {
debug_printf (1, " Unexpected response: %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
} else {
declared_length = soup_message_headers_get_content_length (msg->response_headers);
debug_printf (2, " Content-Length: %lu, body: %s\n",
(gulong)declared_length, msg->response_body->data);
if (msg->response_body->length >= declared_length) {
debug_printf (1, " Body length %lu >= declared length %lu\n",
(gulong)msg->response_body->length,
(gulong)declared_length);
errors++;
}
}
soup_uri_free (request_uri);
g_object_unref (msg);
debug_printf (1, " Server claims 'Connection: close' but doesn't\n");
request_uri = soup_uri_new_with_base (base_uri, "/content-length/noclose");
msg = soup_message_new_from_uri ("GET", request_uri);
soup_session_send_message (session, msg);
if (msg->status_code != SOUP_STATUS_OK) {
debug_printf (1, " Unexpected response: %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
} else {
declared_length = soup_message_headers_get_content_length (msg->response_headers);
debug_printf (2, " Content-Length: %lu, body: %s\n",
(gulong)declared_length, msg->response_body->data);
if (msg->response_body->length != declared_length) {
debug_printf (1, " Body length %lu != declared length %lu\n",
(gulong)msg->response_body->length,
(gulong)declared_length);
errors++;
}
}
soup_uri_free (request_uri);
g_object_unref (msg);
soup_test_session_abort_unref (session);
}
static void
do_redirect_tests (SoupURI *base_uri)
{
SoupSession *session;
int n;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
debug_printf (1, "Async session\n");
for (n = 0; n < n_tests; n++)
do_test (session, base_uri, n);
soup_test_session_abort_unref (session);
session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);
debug_printf (1, "Sync session\n");
for (n = 0; n < n_tests; n++)
do_test (session, base_uri, n);
soup_test_session_abort_unref (session);
}
static void
do_early_abort_test (void)
{
SoupSession *session;
SoupMessage *msg;
GMainContext *context;
GMainLoop *loop;
debug_printf (1, "\nAbort with pending connection\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
msg = soup_message_new_from_uri ("GET", base_uri);
context = g_main_context_default ();
loop = g_main_loop_new (context, TRUE);
soup_session_queue_message (session, msg, ea_msg_completed_one, loop);
g_main_context_iteration (context, FALSE);
soup_session_abort (session);
while (g_main_context_pending (context))
g_main_context_iteration (context, FALSE);
g_main_loop_unref (loop);
soup_test_session_abort_unref (session);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
msg = soup_message_new_from_uri ("GET", base_uri);
g_signal_connect (session, "connection-created",
G_CALLBACK (ea_connection_created), NULL);
soup_session_send_message (session, msg);
debug_printf (2, " Message 2 completed\n");
if (msg->status_code != SOUP_STATUS_CANCELLED) {
debug_printf (1, " Unexpected response: %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
g_object_unref (msg);
while (g_main_context_pending (context))
g_main_context_iteration (context, FALSE);
soup_test_session_abort_unref (session);
}
static void
do_cookies_accept_policy_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupURI *uri;
SoupCookieJar *jar;
GSList *l, *p;
int i;
debug_printf (1, "SoupCookieJarAcceptPolicy test\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
soup_session_add_feature_by_type (session, SOUP_TYPE_COOKIE_JAR);
jar = SOUP_COOKIE_JAR (soup_session_get_feature (session, SOUP_TYPE_COOKIE_JAR));
for (i = 0; i < G_N_ELEMENTS (validResults); i++) {
soup_cookie_jar_set_accept_policy (jar, validResults[i].policy);
uri = soup_uri_new_with_base (first_party_uri, "/index.html");
msg = soup_message_new_from_uri ("GET", uri);
soup_message_set_first_party (msg, first_party_uri);
soup_session_send_message (session, msg);
soup_uri_free (uri);
g_object_unref (msg);
/* We can't use two servers due to limitations in
* test_server, so let's swap first and third party here
* to simulate a cookie coming from a third party.
*/
uri = soup_uri_new_with_base (first_party_uri, "/foo.jpg");
msg = soup_message_new_from_uri ("GET", uri);
soup_message_set_first_party (msg, third_party_uri);
soup_session_send_message (session, msg);
soup_uri_free (uri);
g_object_unref (msg);
l = soup_cookie_jar_all_cookies (jar);
if (g_slist_length (l) < validResults[i].n_cookies) {
debug_printf (1, " accepted less cookies than it should have\n");
errors++;
} else if (g_slist_length (l) > validResults[i].n_cookies) {
debug_printf (1, " accepted more cookies than it should have\n");
errors++;
}
for (p = l; p; p = p->next) {
soup_cookie_jar_delete_cookie (jar, p->data);
soup_cookie_free (p->data);
}
g_slist_free (l);
}
soup_test_session_abort_unref (session);
}
static void
do_timeout_tests (char *fast_uri, char *slow_uri)
{
SoupSession *session;
debug_printf (1, " async\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_TIMEOUT, 1,
NULL);
do_tests_for_session (session, fast_uri, slow_uri);
soup_test_session_abort_unref (session);
debug_printf (1, " sync\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC,
SOUP_SESSION_TIMEOUT, 1,
NULL);
do_tests_for_session (session, fast_uri, slow_uri);
soup_test_session_abort_unref (session);
}
static void
do_message_has_authorization_header_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupAuthManager *manager;
SoupAuth *auth = NULL;
char *token;
guint auth_id;
char *uri;
g_test_bug ("775882");
SOUP_TEST_SKIP_IF_NO_APACHE;
session = soup_test_session_new (SOUP_TYPE_SESSION, NULL);
uri = g_strconcat (base_uri, "Digest/realm1/", NULL);
msg = soup_message_new ("GET", uri);
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (has_authorization_header_authenticate), &auth);
soup_session_send_message (session, msg);
soup_test_assert_message_status (msg, SOUP_STATUS_OK);
soup_test_assert (SOUP_IS_AUTH (auth), "Expected a SoupAuth");
token = soup_auth_get_authorization (auth, msg);
g_object_unref (auth);
g_object_unref (msg);
g_signal_handler_disconnect (session, auth_id);
manager = SOUP_AUTH_MANAGER (soup_session_get_feature (session, SOUP_TYPE_AUTH_MANAGER));
soup_auth_manager_clear_cached_credentials (manager);
msg = soup_message_new ("GET", uri);
soup_message_headers_replace (msg->request_headers, "Authorization", token);
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (has_authorization_header_authenticate_assert),
NULL);
soup_session_send_message (session, msg);
soup_test_assert_message_status (msg, SOUP_STATUS_OK);
g_object_unref (msg);
/* Check that we can also provide our own Authorization header when not using credentials cache. */
soup_auth_manager_clear_cached_credentials (manager);
msg = soup_message_new ("GET", uri);
soup_message_headers_replace (msg->request_headers, "Authorization", token);
soup_message_set_flags (msg, soup_message_get_flags (msg) | SOUP_MESSAGE_DO_NOT_USE_AUTH_CACHE);
soup_session_send_message (session, msg);
soup_test_assert_message_status (msg, SOUP_STATUS_OK);
g_object_unref (msg);
g_free (token);
g_signal_handler_disconnect (session, auth_id);
g_free (uri);
soup_test_session_abort_unref (session);
}
static void
do_test2 (gconstpointer data)
{
gboolean use_thread_context = GPOINTER_TO_INT (data);
guint idle;
GMainContext *async_context;
SoupSession *session;
char *uri;
SoupMessage *msg;
idle = g_idle_add_full (G_PRIORITY_HIGH, idle_test2_fail, NULL, NULL);
async_context = g_main_context_new ();
if (use_thread_context) {
g_main_context_push_thread_default (async_context);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
NULL);
} else {
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_ASYNC_CONTEXT, async_context,
NULL);
}
g_main_context_unref (async_context);
uri = g_build_filename (base_uri, "slow", NULL);
debug_printf (1, " send_message\n");
msg = soup_message_new ("GET", uri);
soup_session_send_message (session, msg);
soup_test_assert_message_status (msg, SOUP_STATUS_OK);
g_object_unref (msg);
soup_test_session_abort_unref (session);
g_free (uri);
g_source_remove (idle);
if (use_thread_context)
g_main_context_pop_thread_default (async_context);
}
static void
do_max_conns_test (void)
{
SoupSession *session;
debug_printf (1, "\nExceeding max-conns\n");
debug_printf (1, " Async session\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_MAX_CONNS, MAX_CONNS,
NULL);
do_max_conns_test_for_session (session);
soup_test_session_abort_unref (session);
debug_printf (1, " Sync session\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC,
SOUP_SESSION_MAX_CONNS, MAX_CONNS,
NULL);
do_max_conns_test_for_session (session);
soup_test_session_abort_unref (session);
}
static void
do_msg_reuse_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupURI *uri;
guint *signal_ids, n_signal_ids;
debug_printf (1, "\nSoupMessage reuse\n");
signal_ids = g_signal_list_ids (SOUP_TYPE_MESSAGE, &n_signal_ids);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
g_signal_connect (session, "authenticate",
G_CALLBACK (reuse_test_authenticate), NULL);
debug_printf (1, " First message\n");
msg = soup_message_new_from_uri ("GET", base_uri);
soup_session_send_message (session, msg);
ensure_no_signal_handlers (msg, signal_ids, n_signal_ids);
debug_printf (1, " Redirect message\n");
uri = soup_uri_new_with_base (base_uri, "/redirect");
soup_message_set_uri (msg, uri);
soup_uri_free (uri);
soup_session_send_message (session, msg);
if (!soup_uri_equal (soup_message_get_uri (msg), base_uri)) {
debug_printf (1, " Message did not get redirected!\n");
errors++;
}
ensure_no_signal_handlers (msg, signal_ids, n_signal_ids);
debug_printf (1, " Auth message\n");
uri = soup_uri_new_with_base (base_uri, "/auth");
soup_message_set_uri (msg, uri);
soup_uri_free (uri);
soup_session_send_message (session, msg);
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
debug_printf (1, " Message did not get authenticated!\n");
errors++;
}
ensure_no_signal_handlers (msg, signal_ids, n_signal_ids);
/* One last try to make sure the auth stuff got cleaned up */
debug_printf (1, " Last message\n");
soup_message_set_uri (msg, base_uri);
soup_session_send_message (session, msg);
ensure_no_signal_handlers (msg, signal_ids, n_signal_ids);
soup_test_session_abort_unref (session);
g_object_unref (msg);
g_free (signal_ids);
}
static void
do_async_auth_bad_password_test (void)
{
SoupSession *session;
SoupMessage *msg;
guint auth_id;
char *uri;
SoupAuth *auth = NULL;
int remaining;
gboolean been_there;
/* Test that giving the wrong password doesn't cause multiple
* authenticate signals the second time.
*/
g_test_bug ("522601");
SOUP_TEST_SKIP_IF_NO_APACHE;
loop = g_main_loop_new (NULL, TRUE);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
uri = g_strconcat (base_uri, "Basic/realm1/", NULL);
remaining = 0;
auth = NULL;
msg = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg), "id", GINT_TO_POINTER (1));
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (async_authenticate), &auth);
g_object_ref (msg);
remaining++;
soup_session_queue_message (session, msg, async_finished, &remaining);
g_main_loop_run (loop);
g_signal_handler_disconnect (session, auth_id);
soup_auth_authenticate (auth, "user1", "wrong");
g_object_unref (auth);
soup_session_unpause_message (session, msg);
been_there = FALSE;
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (async_authenticate_assert_once),
&been_there);
g_main_loop_run (loop);
g_signal_handler_disconnect (session, auth_id);
soup_test_assert (been_there,
"authenticate not emitted");
soup_test_session_abort_unref (session);
g_object_unref (msg);
g_free (uri);
g_main_loop_unref (loop);
}