static void
do_ipv6_test (void)
{
SoupServer *ipv6_server;
SoupURI *ipv6_uri;
SoupAddress *ipv6_addr;
SoupSession *session;
SoupMessage *msg;
debug_printf (1, "\nIPv6 server test\n");
ipv6_addr = soup_address_new ("::1", SOUP_ADDRESS_ANY_PORT);
soup_address_resolve_sync (ipv6_addr, NULL);
ipv6_server = soup_server_new (SOUP_SERVER_INTERFACE, ipv6_addr,
NULL);
g_object_unref (ipv6_addr);
soup_server_add_handler (ipv6_server, NULL, ipv6_server_callback, NULL, NULL);
soup_server_run_async (ipv6_server);
ipv6_uri = soup_uri_new ("http://[::1]/");
soup_uri_set_port (ipv6_uri, soup_server_get_port (ipv6_server));
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
debug_printf (1, " HTTP/1.1\n");
msg = soup_message_new_from_uri ("GET", ipv6_uri);
soup_session_send_message (session, msg);
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
debug_printf (1, " request failed: %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
g_object_unref (msg);
debug_printf (1, " HTTP/1.0\n");
msg = soup_message_new_from_uri ("GET", ipv6_uri);
soup_message_set_http_version (msg, SOUP_HTTP_1_0);
soup_session_send_message (session, msg);
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
debug_printf (1, " request failed: %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
g_object_unref (msg);
soup_uri_free (ipv6_uri);
soup_test_session_abort_unref (session);
soup_test_server_quit_unref (ipv6_server);
}
static void
test_url (const char *url, int proxy, guint expected,
gboolean sync, gboolean close)
{
SoupSession *session;
SoupURI *proxy_uri;
SoupMessage *msg;
if (!tls_available && g_str_has_prefix (url, "https:"))
return;
debug_printf (1, " GET %s via %s%s\n", url, proxy_names[proxy],
close ? " (with Connection: close)" : "");
if (proxy == UNAUTH_PROXY && expected != SOUP_STATUS_FORBIDDEN)
expected = SOUP_STATUS_PROXY_UNAUTHORIZED;
/* We create a new session for each request to ensure that
* connections/auth aren't cached between tests.
*/
proxy_uri = soup_uri_new (proxies[proxy]);
session = soup_test_session_new (sync ? SOUP_TYPE_SESSION_SYNC : SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_PROXY_URI, proxy_uri,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
NULL);
soup_uri_free (proxy_uri);
g_signal_connect (session, "authenticate",
G_CALLBACK (authenticate), NULL);
if (close) {
g_signal_connect (session, "request-started",
G_CALLBACK (set_close_on_connect), NULL);
}
msg = soup_message_new (SOUP_METHOD_GET, url);
if (!msg) {
g_printerr ("proxy-test: Could not parse URI\n");
exit (1);
}
soup_session_send_message (session, msg);
debug_printf (1, " %d %s\n", msg->status_code, msg->reason_phrase);
if (msg->status_code != expected) {
debug_printf (1, " EXPECTED %d!\n", expected);
errors++;
}
g_object_unref (msg);
soup_test_session_abort_unref (session);
}
static void
select_auth_test_one (SoupURI *uri,
gboolean disable_digest, const char *password,
const char *first_headers, const char *first_response,
const char *second_headers, const char *second_response,
guint final_status)
{
SelectAuthData sad;
SoupMessage *msg;
SoupSession *session;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
if (disable_digest)
soup_session_remove_feature_by_type (session, SOUP_TYPE_AUTH_DIGEST);
g_signal_connect (session, "authenticate",
G_CALLBACK (select_auth_authenticate), &sad);
memset (&sad, 0, sizeof (sad));
sad.password = password;
msg = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msg);
soup_test_assert (strcmp (sad.round[0].headers, first_headers) == 0,
"Header order wrong: expected %s, got %s",
first_headers, sad.round[0].headers);
soup_test_assert (strcmp (sad.round[0].response, first_response) == 0,
"Selected auth type wrong: expected %s, got %s",
first_response, sad.round[0].response);
soup_test_assert (sad.round[1].headers || !second_headers,
"Expected a second round");
soup_test_assert (!sad.round[1].headers || second_headers,
"Didn't expect a second round");
if (second_headers && second_response) {
soup_test_assert (strcmp (sad.round[1].headers, second_headers) == 0,
"Second round header order wrong: expected %s, got %s\n",
second_headers, sad.round[1].headers);
soup_test_assert (strcmp (sad.round[1].response, second_response) == 0,
"Second round selected auth type wrong: expected %s, got %s\n",
second_response, sad.round[1].response);
}
soup_test_assert_message_status (msg, final_status);
g_object_unref (msg);
soup_test_session_abort_unref (session);
}
static void
do_auth_close_test (void)
{
SoupServer *server;
SoupAuthDomain *basic_auth_domain;
SoupURI *uri;
AuthCloseData acd;
debug_printf (1, "\nTesting auth when server times out connection:\n");
server = soup_test_server_new (FALSE);
soup_server_add_handler (server, NULL,
server_callback, NULL, NULL);
uri = soup_uri_new ("http://127.0.0.1/close");
soup_uri_set_port (uri, soup_server_get_port (server));
basic_auth_domain = soup_auth_domain_basic_new (
SOUP_AUTH_DOMAIN_REALM, "auth-test",
SOUP_AUTH_DOMAIN_ADD_PATH, "/",
SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK, server_basic_auth_callback,
NULL);
soup_server_add_auth_domain (server, basic_auth_domain);
g_object_unref (basic_auth_domain);
g_signal_connect (server, "request-started",
G_CALLBACK (auth_close_request_started), NULL);
acd.session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
g_signal_connect (acd.session, "authenticate",
G_CALLBACK (auth_close_authenticate), &acd);
acd.msg = soup_message_new_from_uri ("GET", uri);
soup_uri_free (uri);
soup_session_send_message (acd.session, acd.msg);
if (acd.msg->status_code != SOUP_STATUS_OK) {
debug_printf (1, " Final status wrong: expected %u, got %u %s\n",
SOUP_STATUS_OK, acd.msg->status_code,
acd.msg->reason_phrase);
errors++;
}
g_object_unref (acd.msg);
soup_test_session_abort_unref (acd.session);
soup_test_server_quit_unref (server);
}
static void
do_disappearing_auth_test (void)
{
SoupServer *server;
SoupAuthDomain *auth_domain;
SoupURI *uri;
SoupMessage *msg;
SoupSession *session;
int counter;
g_test_bug ("https://bugzilla.redhat.com/show_bug.cgi?id=916224");
server = soup_test_server_new (FALSE);
soup_server_add_handler (server, NULL,
server_callback, NULL, NULL);
uri = soup_test_server_get_uri (server, "http", NULL);
auth_domain = soup_auth_domain_basic_new (
SOUP_AUTH_DOMAIN_REALM, "auth-test",
SOUP_AUTH_DOMAIN_ADD_PATH, "/",
SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK, server_basic_auth_callback,
NULL);
soup_server_add_auth_domain (server, auth_domain);
g_signal_connect (server, "request-read",
G_CALLBACK (disappear_request_read), NULL);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
counter = 0;
g_signal_connect (session, "authenticate",
G_CALLBACK (disappear_authenticate), &counter);
msg = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msg);
soup_test_assert (counter <= 2,
"Got stuck in loop");
soup_test_assert_message_status (msg, SOUP_STATUS_UNAUTHORIZED);
g_object_unref (msg);
soup_test_session_abort_unref (session);
g_object_unref (auth_domain);
soup_uri_free (uri);
soup_test_server_quit_unref (server);
}
static void
do_chunk_tests (SoupURI *base_uri)
{
SoupSession *session;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
do_request_test (session, base_uri, 0);
debug_printf (2, "\n\n");
do_request_test (session, base_uri, 1);
debug_printf (2, "\n\n");
do_request_test (session, base_uri, 2);
debug_printf (2, "\n\n");
do_response_test (session, base_uri);
debug_printf (2, "\n\n");
do_temporary_test (session, base_uri);
soup_test_session_abort_unref (session);
}
static void
do_message_do_not_use_auth_cache_test (void)
{
SoupSession *session;
SoupAuthManager *manager;
SoupURI *soup_uri;
char *uri;
char *uri_with_credentials;
SOUP_TEST_SKIP_IF_NO_APACHE;
session = soup_test_session_new (SOUP_TYPE_SESSION, NULL);
uri = g_strconcat (base_uri, "Digest/realm1/", NULL);
/* First check that cached credentials are not used */
do_digest_nonce_test (session, "First", uri, TRUE, TRUE, TRUE);
do_digest_nonce_test (session, "Second", uri, TRUE, FALSE, FALSE);
do_digest_nonce_test (session, "Third", uri, FALSE, TRUE, TRUE);
/* Passing credentials in the URI should always authenticate
* no matter whether the cache is used or not
*/
soup_uri = soup_uri_new (uri);
soup_uri_set_user (soup_uri, "user1");
soup_uri_set_password (soup_uri, "realm1");
uri_with_credentials = soup_uri_to_string (soup_uri, FALSE);
soup_uri_free (soup_uri);
do_digest_nonce_test (session, "Fourth", uri_with_credentials, FALSE, TRUE, FALSE);
g_free (uri_with_credentials);
manager = SOUP_AUTH_MANAGER (soup_session_get_feature (session, SOUP_TYPE_AUTH_MANAGER));
soup_auth_manager_clear_cached_credentials (manager);
/* Now check that credentials are not stored */
do_digest_nonce_test (session, "First", uri, FALSE, TRUE, TRUE);
do_digest_nonce_test (session, "Second", uri, TRUE, TRUE, TRUE);
do_digest_nonce_test (session, "Third", uri, TRUE, FALSE, FALSE);
g_free (uri);
soup_test_session_abort_unref (session);
}
static void
get_correct_response (const char *uri)
{
SoupSession *session;
SoupMessage *msg;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
msg = soup_message_new (SOUP_METHOD_GET, uri);
soup_session_send_message (session, msg);
if (msg->status_code != SOUP_STATUS_OK) {
fprintf (stderr, "Could not fetch %s: %d %s\n", uri,
msg->status_code, msg->reason_phrase);
exit (1);
}
correct_response = soup_message_body_flatten (msg->response_body);
g_object_unref (msg);
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_coding_empty_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupURI *uri;
SoupRequester *requester;
SoupRequest *req;
GByteArray *body;
debug_printf (1, "\nEmpty allegedly-encoded body test\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_REQUESTER,
NULL);
requester = (SoupRequester *)soup_session_get_feature (session, SOUP_TYPE_REQUESTER);
uri = soup_uri_new_with_base (base_uri, "/mbox");
debug_printf (1, " SoupMessage\n");
msg = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "empty");
soup_session_send_message (session, msg);
check_response (msg, "gzip", "text/plain", EXPECT_NOT_DECODED);
g_object_unref (msg);
debug_printf (1, " SoupRequest\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "empty");
g_object_unref (msg);
body = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_NOT_DECODED);
g_byte_array_free (body, TRUE);
g_object_unref (req);
soup_uri_free (uri);
soup_test_session_abort_unref (session);
}
/* Host header handling: client must be able to override the default
* value, server must be able to recognize different Host values.
* #539803.
*/
static void
do_host_test (void)
{
SoupSession *session;
SoupMessage *one, *two;
debug_printf (1, "Host handling\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);
one = soup_message_new_from_uri ("GET", base_uri);
two = soup_message_new_from_uri ("GET", base_uri);
soup_message_headers_replace (two->request_headers, "Host", "foo");
soup_session_send_message (session, one);
soup_session_send_message (session, two);
soup_test_session_abort_unref (session);
if (!SOUP_STATUS_IS_SUCCESSFUL (one->status_code)) {
debug_printf (1, " Message 1 failed: %d %s\n",
one->status_code, one->reason_phrase);
errors++;
} else if (strcmp (one->response_body->data, "index") != 0) {
debug_printf (1, " Unexpected response to message 1: '%s'\n",
one->response_body->data);
errors++;
}
g_object_unref (one);
if (!SOUP_STATUS_IS_SUCCESSFUL (two->status_code)) {
debug_printf (1, " Message 2 failed: %d %s\n",
two->status_code, two->reason_phrase);
errors++;
} else if (strcmp (two->response_body->data, "foo-index") != 0) {
debug_printf (1, " Unexpected response to message 2: '%s'\n",
two->response_body->data);
errors++;
}
g_object_unref (two);
}
static void
do_md5_test_libsoup (const char *uri, const char *contents,
gsize length, const char *md5)
{
SoupMultipart *multipart;
SoupBuffer *buffer;
SoupMessage *msg;
SoupSession *session;
debug_printf (1, " via libsoup: ");
multipart = soup_multipart_new (SOUP_FORM_MIME_TYPE_MULTIPART);
buffer = soup_buffer_new (SOUP_MEMORY_COPY, contents, length);
soup_multipart_append_form_file (multipart, "file",
MD5_TEST_FILE_BASENAME,
MD5_TEST_FILE_MIME_TYPE,
buffer);
soup_buffer_free (buffer);
soup_multipart_append_form_string (multipart, "fmt", "text");
msg = soup_form_request_new_from_multipart (uri, multipart);
soup_multipart_free (multipart);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
soup_session_send_message (session, msg);
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
debug_printf (1, "ERROR: Unexpected status %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
} else if (strcmp (msg->response_body->data, md5) != 0) {
debug_printf (1, "ERROR: Incorrect response: expected '%s' got '%s'\n",
md5, msg->response_body->data);
errors++;
} else
debug_printf (1, "OK!\n");
g_object_unref (msg);
soup_test_session_abort_unref (session);
}
static void
do_auth_close_test (void)
{
SoupServer *server;
SoupAuthDomain *basic_auth_domain;
SoupURI *uri;
AuthCloseData acd;
server = soup_test_server_new (SOUP_TEST_SERVER_DEFAULT);
soup_server_add_handler (server, NULL,
server_callback, NULL, NULL);
uri = soup_test_server_get_uri (server, "http", NULL);
soup_uri_set_path (uri, "/close");
basic_auth_domain = soup_auth_domain_basic_new (
SOUP_AUTH_DOMAIN_REALM, "auth-test",
SOUP_AUTH_DOMAIN_ADD_PATH, "/",
SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK, server_basic_auth_callback,
NULL);
soup_server_add_auth_domain (server, basic_auth_domain);
g_object_unref (basic_auth_domain);
g_signal_connect (server, "request-started",
G_CALLBACK (auth_close_request_started), NULL);
acd.session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
g_signal_connect (acd.session, "authenticate",
G_CALLBACK (auth_close_authenticate), &acd);
acd.msg = soup_message_new_from_uri ("GET", uri);
soup_uri_free (uri);
soup_session_send_message (acd.session, acd.msg);
soup_test_assert_message_status (acd.msg, SOUP_STATUS_OK);
g_object_unref (acd.msg);
soup_test_session_abort_unref (acd.session);
soup_test_server_quit_unref (server);
}
static void
do_clear_credentials_test (void)
{
SoupSession *session;
SoupAuthManager *manager;
char *uri;
SOUP_TEST_SKIP_IF_NO_APACHE;
session = soup_test_session_new (SOUP_TYPE_SESSION, NULL);
uri = g_strconcat (base_uri, "Digest/realm1/", NULL);
do_digest_nonce_test (session, "First", uri, TRUE, TRUE, TRUE);
manager = SOUP_AUTH_MANAGER (soup_session_get_feature (session, SOUP_TYPE_AUTH_MANAGER));
soup_auth_manager_clear_cached_credentials (manager);
do_digest_nonce_test (session, "Second", uri, TRUE, TRUE, TRUE);
g_free (uri);
soup_test_session_abort_unref (session);
}
int
main (int argc, char **argv)
{
SoupServer *server;
test_init (argc, argv, NULL);
buffer = g_malloc (READ_BUFFER_SIZE);
server = soup_test_server_new (FALSE);
soup_server_add_handler (server, NULL, server_callback, NULL, NULL);
base_uri = soup_uri_new ("http://127.0.0.1");
soup_uri_set_port (base_uri, soup_server_get_port (server));
base_uri_string = soup_uri_to_string (base_uri, FALSE);
/* FIXME: I had to raise the number of connections allowed here, otherwise I
* was hitting the limit, which indicates some connections are not dying.
*/
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
"use-thread-context", TRUE,
"max-conns", 20,
"max-conns-per-host", 20,
NULL);
soup_session_add_feature_by_type (session, SOUP_TYPE_CONTENT_SNIFFER);
test_multipart (1, 1, NO_MULTIPART);
test_multipart (1, 1, SYNC_MULTIPART);
test_multipart (1, 1, ASYNC_MULTIPART);
test_multipart (1, 1, ASYNC_MULTIPART_SMALL_READS);
soup_uri_free (base_uri);
g_free (base_uri_string);
g_free (buffer);
soup_test_session_abort_unref (session);
soup_test_server_quit_unref (server);
test_cleanup ();
return errors != 0;
}
static void
do_proxy_redirect_test (void)
{
SoupSession *session;
SoupURI *proxy_uri, *req_uri, *new_uri;
SoupMessage *msg;
debug_printf (1, "\nTesting redirection through 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 (HTTPS_SERVER);
soup_uri_set_path (req_uri, "/redirected");
msg = soup_message_new_from_uri (SOUP_METHOD_GET, req_uri);
soup_message_headers_append (msg->request_headers,
"Connection", "close");
soup_session_send_message (session, msg);
new_uri = soup_message_get_uri (msg);
if (!strcmp (req_uri->path, new_uri->path)) {
debug_printf (1, " message was not redirected!\n");
errors++;
}
soup_uri_free (req_uri);
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_pause_abort_test (void)
{
SoupSession *session;
SoupMessage *msg;
gpointer ptr;
debug_printf (1, "\nTesting paused messages don't get leaked on abort\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
msg = soup_message_new_from_uri ("GET", base_uri);
soup_session_queue_message (session, msg, NULL, NULL);
soup_session_pause_message (session, msg);
g_object_add_weak_pointer (G_OBJECT (msg), &ptr);
soup_test_session_abort_unref (session);
if (ptr) {
debug_printf (1, " msg was leaked\n");
errors++;
}
}
static void
do_chunk_tests (SoupURI *base_uri)
{
SoupSession *session;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
do_request_test (session, base_uri, 0);
debug_printf (2, "\n\n");
do_request_test (session, base_uri, PROPER_STREAMING);
debug_printf (2, "\n\n");
do_request_test (session, base_uri, PROPER_STREAMING | RESTART);
debug_printf (2, "\n\n");
do_request_test (session, base_uri, HACKY_STREAMING);
debug_printf (2, "\n\n");
do_request_test (session, base_uri, HACKY_STREAMING | RESTART);
debug_printf (2, "\n\n");
do_response_test (session, base_uri);
debug_printf (2, "\n\n");
do_temporary_test (session, base_uri);
debug_printf (2, "\n\n");
do_large_chunk_test (session, base_uri);
soup_test_session_abort_unref (session);
}
static void
do_pipelined_auth_test (void)
{
SoupSession *session;
SoupMessage *msg;
gboolean authenticated;
char *uri;
int i;
g_test_bug ("271540");
SOUP_TEST_SKIP_IF_NO_APACHE;
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);
}
int
main (int argc, char **argv)
{
test_init (argc, argv, xmlrpc_entries);
if (!uri) {
apache_init ();
uri = default_uri;
}
srand (time (NULL));
session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);
if (!test_sum ())
errors++;
if (!test_countBools ())
errors++;
if (!test_md5sum ())
errors++;
if (!test_dateChange ())
errors++;
if (!test_echo ())
errors++;
if (!test_fault_malformed ())
errors++;
if (!test_fault_method ())
errors++;
if (!test_fault_args ())
errors++;
soup_test_session_abort_unref (session);
test_cleanup ();
return errors != 0;
}
static void
do_digest_expiration_test (const char *base_uri)
{
SoupSession *session;
char *uri;
debug_printf (1, "\nTesting digest nonce expiration:\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
uri = g_strconcat (base_uri, "Digest/realm1/", NULL);
do_digest_nonce_test (session, "First", uri, TRUE, TRUE);
g_free (uri);
sleep (2);
uri = g_strconcat (base_uri, "Digest/realm1/expire/", NULL);
do_digest_nonce_test (session, "Second", uri, TRUE, FALSE);
sleep (1);
do_digest_nonce_test (session, "Third", uri, FALSE, FALSE);
sleep (1);
do_digest_nonce_test (session, "Fourth", uri, FALSE, FALSE);
g_free (uri);
soup_test_session_abort_unref (session);
}
static void
do_digest_expiration_test (void)
{
SoupSession *session;
char *uri;
SOUP_TEST_SKIP_IF_NO_APACHE;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
uri = g_strconcat (base_uri, "Digest/realm1/", NULL);
do_digest_nonce_test (session, "First", uri, TRUE, TRUE, TRUE);
g_free (uri);
sleep (2);
uri = g_strconcat (base_uri, "Digest/realm1/expire/", NULL);
do_digest_nonce_test (session, "Second", uri, TRUE, TRUE, FALSE);
sleep (1);
do_digest_nonce_test (session, "Third", uri, TRUE, FALSE, FALSE);
sleep (1);
do_digest_nonce_test (session, "Fourth", uri, TRUE, FALSE, FALSE);
g_free (uri);
soup_test_session_abort_unref (session);
}
int
main (int argc, char **argv)
{
SoupSession *session;
SoupMessage *msg;
const char *base_uri;
char *uri;
gboolean authenticated;
int i, ntests;
test_init (argc, argv, NULL);
apache_init ();
base_uri = "http://127.0.0.1:47524/";
/* Main tests */
current_tests = main_tests;
ntests = G_N_ELEMENTS (main_tests);
do_batch_tests (base_uri, ntests);
/* Re-login tests */
current_tests = relogin_tests;
ntests = G_N_ELEMENTS (relogin_tests);
do_batch_tests (base_uri, ntests);
/* And now for some regression tests */
loop = g_main_loop_new (NULL, TRUE);
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);
g_main_loop_run (loop);
soup_test_session_abort_unref (session);
debug_printf (1, "\nTesting digest nonce expiration:\n");
/* We test two different things here:
*
* 1. If we get a 401 response with
* "WWW-Authenticate: Digest stale=true...", we should
* retry and succeed *without* the session asking for a
* password again.
*
* 2. If we get a successful response with
* "Authentication-Info: nextnonce=...", we should update
* the nonce automatically so as to avoid getting a
* stale nonce error on the next request.
*
* In our Apache config, /Digest/realm1 and
* /Digest/realm1/expire are set up to use the same auth info,
* but only the latter has an AuthDigestNonceLifetime (of 2
* seconds). The way nonces work in Apache, a nonce received
* from /Digest/realm1 will still expire in
* /Digest/realm1/expire, but it won't issue a nextnonce for a
* request in /Digest/realm1. This lets us test both
* behaviors.
*
* The expected conversation is:
*
* First message
* GET /Digest/realm1
*
* 401 Unauthorized
* WWW-Authenticate: Digest nonce=A
*
* [emit 'authenticate']
*
* GET /Digest/realm1
* Authorization: Digest nonce=A
*
* 200 OK
* [No Authentication-Info]
*
* [sleep 2 seconds: nonce A is no longer valid, but we have no
* way of knowing that]
*
* Second message
* GET /Digest/realm1/expire/
* Authorization: Digest nonce=A
*
* 401 Unauthorized
* WWW-Authenticate: Digest stale=true nonce=B
*
* GET /Digest/realm1/expire/
* Authorization: Digest nonce=B
*
* 200 OK
* Authentication-Info: nextnonce=C
*
* [sleep 1 second]
*
* Third message
* GET /Digest/realm1/expire/
* Authorization: Digest nonce=C
* [nonce=B would work here too]
*
* 200 OK
* Authentication-Info: nextnonce=D
*
* [sleep 1 second; nonces B and C are no longer valid, but D is]
*
* Fourth message
* GET /Digest/realm1/expire/
* Authorization: Digest nonce=D
*
* 200 OK
* Authentication-Info: nextnonce=D
*
*/
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
uri = g_strconcat (base_uri, "Digest/realm1/", NULL);
do_digest_nonce_test (session, "First", uri, TRUE, TRUE);
g_free (uri);
sleep (2);
uri = g_strconcat (base_uri, "Digest/realm1/expire/", NULL);
do_digest_nonce_test (session, "Second", uri, TRUE, FALSE);
sleep (1);
do_digest_nonce_test (session, "Third", uri, FALSE, FALSE);
sleep (1);
do_digest_nonce_test (session, "Fourth", uri, FALSE, FALSE);
g_free (uri);
soup_test_session_abort_unref (session);
/* Async auth */
do_async_auth_test (base_uri);
/* Selecting correct auth when multiple auth types are available */
do_select_auth_test ();
g_main_loop_unref (loop);
test_cleanup ();
return errors != 0;
}
static void
do_batch_tests (const gchar *base_uri_str, gint ntests)
{
SoupSession *session;
SoupMessage *msg;
char *expected;
SoupURI *base_uri;
int i;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
g_signal_connect (session, "authenticate",
G_CALLBACK (authenticate), &i);
base_uri = soup_uri_new (base_uri_str);
for (i = 0; i < ntests; i++) {
SoupURI *soup_uri = soup_uri_new_with_base (base_uri, current_tests[i].url);
debug_printf (1, "Test %d: %s\n", i + 1, current_tests[i].explanation);
if (current_tests[i].url_auth) {
gchar *username = g_strdup_printf ("user%c", current_tests[i].provided[0]);
gchar *password = g_strdup_printf ("realm%c", current_tests[i].provided[0]);
soup_uri_set_user (soup_uri, username);
soup_uri_set_password (soup_uri, password);
g_free (username);
g_free (password);
}
msg = soup_message_new_from_uri (SOUP_METHOD_GET, soup_uri);
soup_uri_free (soup_uri);
if (!msg) {
fprintf (stderr, "auth-test: Could not parse URI\n");
exit (1);
}
debug_printf (1, " GET %s\n", soup_uri_to_string (soup_message_get_uri (msg), FALSE));
expected = g_strdup (current_tests[i].expected);
soup_message_add_status_code_handler (
msg, "got_headers", SOUP_STATUS_UNAUTHORIZED,
G_CALLBACK (handler), expected);
soup_message_add_status_code_handler (
msg, "got_headers", SOUP_STATUS_OK,
G_CALLBACK (handler), expected);
soup_session_send_message (session, msg);
if (msg->status_code != SOUP_STATUS_UNAUTHORIZED &&
msg->status_code != SOUP_STATUS_OK) {
debug_printf (1, " %d %s !\n", msg->status_code,
msg->reason_phrase);
errors++;
}
if (*expected) {
debug_printf (1, " expected %d more round(s)\n",
(int)strlen (expected));
errors++;
}
g_free (expected);
if (msg->status_code != current_tests[i].final_status) {
debug_printf (1, " expected %d\n",
current_tests[i].final_status);
}
debug_printf (1, "\n");
g_object_unref (msg);
}
soup_uri_free (base_uri);
soup_test_session_abort_unref (session);
}
static void
do_async_auth_test (const char *base_uri)
{
SoupSession *session;
SoupMessage *msg1, *msg2, *msg3, msg2_bak;
guint auth_id;
char *uri;
SoupAuth *auth = NULL;
int remaining;
gboolean been_there;
debug_printf (1, "\nTesting async auth:\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
remaining = 0;
uri = g_strconcat (base_uri, "Basic/realm1/", NULL);
msg1 = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg1), "id", GINT_TO_POINTER (1));
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (async_authenticate), &auth);
g_object_ref (msg1);
remaining++;
soup_session_queue_message (session, msg1, async_finished, &remaining);
g_main_loop_run (loop);
g_signal_handler_disconnect (session, auth_id);
/* async_authenticate will pause msg1 and quit loop */
msg2 = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg2), "id", GINT_TO_POINTER (2));
soup_session_send_message (session, msg2);
if (msg2->status_code == SOUP_STATUS_UNAUTHORIZED)
debug_printf (1, " msg2 failed as expected\n");
else {
debug_printf (1, " msg2 got wrong status! (%u)\n",
msg2->status_code);
errors++;
}
/* msg2 should be done at this point; assuming everything is
* working correctly, the session won't look at it again; we
* ensure that if it does, it will crash the test program.
*/
memcpy (&msg2_bak, msg2, sizeof (SoupMessage));
memset (msg2, 0, sizeof (SoupMessage));
msg3 = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg3), "id", GINT_TO_POINTER (3));
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (async_authenticate), NULL);
g_object_ref (msg3);
remaining++;
soup_session_queue_message (session, msg3, async_finished, &remaining);
g_main_loop_run (loop);
g_signal_handler_disconnect (session, auth_id);
/* async_authenticate will pause msg3 and quit loop */
/* Now do the auth, and restart */
if (auth) {
soup_auth_authenticate (auth, "user1", "realm1");
g_object_unref (auth);
soup_session_unpause_message (session, msg1);
soup_session_unpause_message (session, msg3);
g_main_loop_run (loop);
/* async_finished will quit the loop */
} else {
debug_printf (1, " msg1 didn't get authenticate signal!\n");
errors++;
}
if (msg1->status_code == SOUP_STATUS_OK)
debug_printf (1, " msg1 succeeded\n");
else {
debug_printf (1, " msg1 FAILED! (%u %s)\n",
msg1->status_code, msg1->reason_phrase);
errors++;
}
if (msg3->status_code == SOUP_STATUS_OK)
debug_printf (1, " msg3 succeeded\n");
else {
debug_printf (1, " msg3 FAILED! (%u %s)\n",
msg3->status_code, msg3->reason_phrase);
errors++;
}
soup_test_session_abort_unref (session);
g_object_unref (msg1);
g_object_unref (msg3);
memcpy (msg2, &msg2_bak, sizeof (SoupMessage));
g_object_unref (msg2);
/* Test that giving the wrong password doesn't cause multiple
* authenticate signals the second time.
*/
debug_printf (1, "\nTesting async auth with wrong password (#522601):\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
remaining = 0;
auth = NULL;
msg1 = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg1), "id", GINT_TO_POINTER (1));
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (async_authenticate), &auth);
g_object_ref (msg1);
remaining++;
soup_session_queue_message (session, msg1, 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, msg1);
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);
if (!been_there) {
debug_printf (1, " authenticate not emitted?\n");
errors++;
}
soup_test_session_abort_unref (session);
g_object_unref (msg1);
/* Test that giving no password doesn't cause multiple
* authenticate signals the second time.
*/
debug_printf (1, "\nTesting async auth with no password (#583462):\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
remaining = 0;
/* Send a message that doesn't actually authenticate
*/
msg1 = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg1), "id", GINT_TO_POINTER (1));
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (async_authenticate), NULL);
g_object_ref (msg1);
remaining++;
soup_session_queue_message (session, msg1, async_finished, &remaining);
g_main_loop_run (loop);
g_signal_handler_disconnect (session, auth_id);
soup_session_unpause_message (session, msg1);
g_main_loop_run (loop);
g_object_unref(msg1);
/* Now send a second message */
msg1 = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg1), "id", GINT_TO_POINTER (2));
g_object_ref (msg1);
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, msg1, async_finished, &remaining);
g_main_loop_run (loop);
soup_session_unpause_message (session, msg1);
g_main_loop_run (loop);
g_signal_handler_disconnect (session, auth_id);
soup_test_session_abort_unref (session);
g_object_unref (msg1);
g_free (uri);
}
static void
do_batch_tests (gconstpointer data)
{
const SoupAuthTest *current_tests = data;
SoupSession *session;
SoupMessage *msg;
char *expected, *uristr;
SoupURI *base;
guint signal;
int i;
SOUP_TEST_SKIP_IF_NO_APACHE;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
base = soup_uri_new (base_uri);
for (i = 0; current_tests[i].url; i++) {
SoupURI *soup_uri = soup_uri_new_with_base (base, current_tests[i].url);
debug_printf (1, "Test %d: %s\n", i + 1, current_tests[i].explanation);
if (current_tests[i].url_auth) {
gchar *username = g_strdup_printf ("user%c", current_tests[i].provided[0]);
gchar *password = g_strdup_printf ("realm%c", current_tests[i].provided[0]);
soup_uri_set_user (soup_uri, username);
soup_uri_set_password (soup_uri, password);
g_free (username);
g_free (password);
}
msg = soup_message_new_from_uri (SOUP_METHOD_GET, soup_uri);
soup_uri_free (soup_uri);
if (!msg) {
g_printerr ("auth-test: Could not parse URI\n");
exit (1);
}
uristr = soup_uri_to_string (soup_message_get_uri (msg), FALSE);
debug_printf (1, " GET %s\n", uristr);
g_free (uristr);
expected = g_strdup (current_tests[i].expected);
soup_message_add_status_code_handler (
msg, "got_headers", SOUP_STATUS_UNAUTHORIZED,
G_CALLBACK (handler), expected);
soup_message_add_status_code_handler (
msg, "got_headers", SOUP_STATUS_OK,
G_CALLBACK (handler), expected);
signal = g_signal_connect (session, "authenticate",
G_CALLBACK (authenticate),
(gpointer)¤t_tests[i]);
soup_session_send_message (session, msg);
g_signal_handler_disconnect (session, signal);
soup_test_assert_message_status (msg, current_tests[i].final_status);
soup_test_assert (!*expected,
"expected %d more round(s)\n",
(int)strlen (expected));
g_free (expected);
debug_printf (1, "\n");
g_object_unref (msg);
}
soup_uri_free (base);
soup_test_session_abort_unref (session);
}
static void
do_coding_req_test (void)
{
SoupSession *session;
SoupRequester *requester;
SoupRequest *req;
SoupMessage *msg;
SoupURI *uri;
GByteArray *plain, *cmp;
debug_printf (1, "\nSoupRequest tests\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_REQUESTER,
NULL);
requester = (SoupRequester *)soup_session_get_feature (session, SOUP_TYPE_REQUESTER);
uri = soup_uri_new_with_base (base_uri, "/mbox");
/* Plain text data, no claim */
debug_printf (1, " GET /mbox, plain\n");
req = soup_requester_request_uri (requester, uri, NULL);
plain = do_single_coding_req_test (req, NULL, "text/plain", EXPECT_NOT_DECODED);
g_object_unref (req);
/* Plain text data, claim gzip */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip\n");
soup_session_add_feature_by_type (session, SOUP_TYPE_CONTENT_DECODER);
req = soup_requester_request_uri (requester, uri, NULL);
cmp = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed");
g_byte_array_free (cmp, TRUE);
g_object_unref (req);
/* Plain text data, claim gzip w/ junk */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip, plus trailing junk\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "trailing-junk");
cmp = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed w/ junk");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim gzip with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip, with server error\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "force-encode");
cmp = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_NOT_DECODED);
/* Failed content-decoding should have left the body untouched
* from what the server sent... which happens to be the
* uncompressed data.
*/
check_req_bodies (plain, cmp, "plain", "mis-encoded");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "prefer-deflate-zlib");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate w/ junk */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate, plus trailing junk\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "prefer-deflate-zlib, trailing-junk");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed w/ junk");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate, with server error\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "force-encode, prefer-deflate-zlib");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_NOT_DECODED);
check_req_bodies (plain, cmp, "plain", "mis-encoded");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate (no zlib headers)*/
debug_printf (1, " GET /mbox, Accept-Encoding: deflate (raw data)\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "prefer-deflate-raw");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate (raw data), with server error\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "force-encode, prefer-deflate-raw");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_NOT_DECODED);
check_req_bodies (plain, cmp, "plain", "mis-encoded");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
g_byte_array_free (plain, TRUE);
soup_uri_free (uri);
soup_test_session_abort_unref (session);
}
static void
do_coding_test (void)
{
SoupSession *session;
SoupMessage *msg, *msgz, *msgj, *msge, *msgzl, *msgzlj, *msgzle, *msgzlr, *msgzlre;
SoupURI *uri;
debug_printf (1, "SoupMessage tests\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
uri = soup_uri_new_with_base (base_uri, "/mbox");
/* Plain text data, no claim */
debug_printf (1, " GET /mbox, plain\n");
msg = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msg);
check_response (msg, NULL, "text/plain", EXPECT_NOT_DECODED);
/* Plain text data, claim gzip */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip\n");
soup_session_add_feature_by_type (session, SOUP_TYPE_CONTENT_DECODER);
msgz = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msgz);
check_response (msgz, "gzip", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgz, "plain", "compressed");
/* Plain text data, claim gzip w/ junk */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip, plus trailing junk\n");
msgj = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgj->request_headers,
"X-Test-Options", "trailing-junk");
soup_session_send_message (session, msgj);
check_response (msgj, "gzip", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgj, "plain", "compressed w/ junk");
/* Plain text data, claim gzip with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip, with server error\n");
msge = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msge->request_headers,
"X-Test-Options", "force-encode");
soup_session_send_message (session, msge);
check_response (msge, "gzip", "text/plain", EXPECT_NOT_DECODED);
/* Failed content-decoding should have left the body untouched
* from what the server sent... which happens to be the
* uncompressed data.
*/
check_msg_bodies (msg, msge, "plain", "mis-encoded");
/* Plain text data, claim deflate */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate\n");
msgzl = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzl->request_headers,
"X-Test-Options", "prefer-deflate-zlib");
soup_session_send_message (session, msgzl);
check_response (msgzl, "deflate", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgzl, "plain", "compressed");
/* Plain text data, claim deflate w/ junk */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate, plus trailing junk\n");
msgzlj = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzlj->request_headers,
"X-Test-Options", "prefer-deflate-zlib, trailing-junk");
soup_session_send_message (session, msgzlj);
check_response (msgzlj, "deflate", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgzlj, "plain", "compressed w/ junk");
/* Plain text data, claim deflate with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate, with server error\n");
msgzle = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzle->request_headers,
"X-Test-Options", "force-encode, prefer-deflate-zlib");
soup_session_send_message (session, msgzle);
check_response (msgzle, "deflate", "text/plain", EXPECT_NOT_DECODED);
check_msg_bodies (msg, msgzle, "plain", "mis-encoded");
/* Plain text data, claim deflate (no zlib headers)*/
debug_printf (1, " GET /mbox, Accept-Encoding: deflate (raw data)\n");
msgzlr = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzlr->request_headers,
"X-Test-Options", "prefer-deflate-raw");
soup_session_send_message (session, msgzlr);
check_response (msgzlr, "deflate", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgzlr, "plain", "compressed");
/* Plain text data, claim deflate with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate (raw data), with server error\n");
msgzlre = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzlre->request_headers,
"X-Test-Options", "force-encode, prefer-deflate-raw");
soup_session_send_message (session, msgzlre);
check_response (msgzlre, "deflate", "text/plain", EXPECT_NOT_DECODED);
check_msg_bodies (msg, msgzlre, "plain", "mis-encoded");
g_object_unref (msg);
g_object_unref (msgzlre);
g_object_unref (msgzlr);
g_object_unref (msgzlj);
g_object_unref (msgzle);
g_object_unref (msgzl);
g_object_unref (msgz);
g_object_unref (msgj);
g_object_unref (msge);
soup_uri_free (uri);
soup_test_session_abort_unref (session);
}
static void
do_multicontext_test (void)
{
SoupSession *session;
SoupMessage *msg1, *msg2;
GMainContext *context1, *context2;
GMainLoop *loop1, *loop2;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
NULL);
g_signal_connect (session, "request-started",
G_CALLBACK (multi_request_started), NULL);
context1 = g_main_context_new ();
loop1 = g_main_loop_new (context1, FALSE);
context2 = g_main_context_new ();
loop2 = g_main_loop_new (context2, FALSE);
g_main_context_push_thread_default (context1);
msg1 = soup_message_new ("GET", base_uri);
g_object_ref (msg1);
soup_session_queue_message (session, msg1, multi_msg_finished, loop1);
g_signal_connect (msg1, "got-headers",
G_CALLBACK (msg1_got_headers), loop1);
g_object_set_data (G_OBJECT (msg1), "session", session);
g_main_context_pop_thread_default (context1);
g_main_context_push_thread_default (context2);
msg2 = soup_message_new ("GET", base_uri);
g_object_ref (msg2);
soup_session_queue_message (session, msg2, multi_msg_finished, loop2);
g_main_context_pop_thread_default (context2);
g_main_context_push_thread_default (context1);
g_main_loop_run (loop1);
g_main_context_pop_thread_default (context1);
if (!g_object_get_data (G_OBJECT (msg1), "started"))
soup_test_assert (FALSE, "msg1 not started");
if (g_object_get_data (G_OBJECT (msg2), "started"))
soup_test_assert (FALSE, "msg2 started while loop1 was running");
g_main_context_push_thread_default (context2);
g_main_loop_run (loop2);
g_main_context_pop_thread_default (context2);
if (g_object_get_data (G_OBJECT (msg1), "finished"))
soup_test_assert (FALSE, "msg1 finished while loop2 was running");
if (!g_object_get_data (G_OBJECT (msg2), "finished"))
soup_test_assert (FALSE, "msg2 not finished");
g_main_context_push_thread_default (context1);
g_main_loop_run (loop1);
g_main_context_pop_thread_default (context1);
if (!g_object_get_data (G_OBJECT (msg1), "finished"))
soup_test_assert (FALSE, "msg1 not finished");
g_object_unref (msg1);
g_object_unref (msg2);
soup_test_session_abort_unref (session);
g_main_loop_unref (loop1);
g_main_loop_unref (loop2);
g_main_context_unref (context1);
g_main_context_unref (context2);
}
static void
do_async_auth_good_password_test (void)
{
SoupSession *session;
SoupMessage *msg1, *msg2, *msg3, msg2_bak;
guint auth_id;
char *uri;
SoupAuth *auth = NULL;
int remaining;
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;
msg1 = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg1), "id", GINT_TO_POINTER (1));
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (async_authenticate), &auth);
g_object_ref (msg1);
remaining++;
soup_session_queue_message (session, msg1, async_finished, &remaining);
g_main_loop_run (loop);
g_signal_handler_disconnect (session, auth_id);
/* async_authenticate will pause msg1 and quit loop */
msg2 = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg2), "id", GINT_TO_POINTER (2));
soup_session_send_message (session, msg2);
soup_test_assert_message_status (msg2, SOUP_STATUS_UNAUTHORIZED);
/* msg2 should be done at this point; assuming everything is
* working correctly, the session won't look at it again; we
* ensure that if it does, it will crash the test program.
*/
memcpy (&msg2_bak, msg2, sizeof (SoupMessage));
memset (msg2, 0, sizeof (SoupMessage));
msg3 = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg3), "id", GINT_TO_POINTER (3));
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (async_authenticate), NULL);
g_object_ref (msg3);
remaining++;
soup_session_queue_message (session, msg3, async_finished, &remaining);
g_main_loop_run (loop);
g_signal_handler_disconnect (session, auth_id);
/* async_authenticate will pause msg3 and quit loop */
/* Now do the auth, and restart */
if (auth) {
soup_auth_authenticate (auth, "user1", "realm1");
g_object_unref (auth);
soup_session_unpause_message (session, msg1);
soup_session_unpause_message (session, msg3);
g_main_loop_run (loop);
/* async_finished will quit the loop */
} else
soup_test_assert (auth, "msg1 didn't get authenticate signal");
soup_test_assert_message_status (msg1, SOUP_STATUS_OK);
soup_test_assert_message_status (msg3, SOUP_STATUS_OK);
soup_test_session_abort_unref (session);
g_object_unref (msg1);
g_object_unref (msg3);
memcpy (msg2, &msg2_bak, sizeof (SoupMessage));
g_object_unref (msg2);
g_free (uri);
g_main_loop_unref (loop);
}
