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_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_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);
}
static void
async_authenticate_assert_once (SoupSession *session, SoupMessage *msg,
SoupAuth *auth, gboolean retrying, gpointer data)
{
gboolean *been_here = data;
debug_printf (2, " async_authenticate_assert_once\n");
soup_test_assert (!*been_here,
"async_authenticate_assert_once called twice");
*been_here = TRUE;
}
static void
handler (SoupMessage *msg, gpointer data)
{
char *expected = data;
int auth, exp;
auth = identify_auth (msg);
debug_printf (1, " %d %s (using %s)\n",
msg->status_code, msg->reason_phrase,
auths[auth]);
if (*expected) {
exp = *expected - '0';
soup_test_assert (auth == exp,
"expected %s", auths[exp]);
memmove (expected, expected + 1, strlen (expected));
} else {
soup_test_assert (*expected,
"expected to be finished");
}
}
static void
async_authenticate_assert_once_and_stop (SoupSession *session, SoupMessage *msg,
SoupAuth *auth, gboolean retrying, gpointer data)
{
gboolean *been_here = data;
debug_printf (2, " async_authenticate_assert_once_and_stop\n");
soup_test_assert (!*been_here,
"async_authenticate_assert_once called twice");
*been_here = TRUE;
soup_session_pause_message (session, msg);
g_main_loop_quit (loop);
}
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
bug271540_authenticate (SoupSession *session, SoupMessage *msg,
SoupAuth *auth, gboolean retrying, gpointer data)
{
int n = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (msg), "#"));
gboolean *authenticated = data;
if (strcmp (soup_auth_get_scheme_name (auth), "Basic") != 0 ||
strcmp (soup_auth_get_realm (auth), "realm1") != 0)
return;
if (!*authenticated) {
debug_printf (1, " authenticating message %d\n", n);
soup_auth_authenticate (auth, "user1", "realm1");
*authenticated = TRUE;
} else {
soup_test_assert (!*authenticated,
"asked to authenticate message %d after authenticating", n);
}
}
static void
do_ssl_test_for_session (SoupSession *session, SoupURI *uri)
{
SoupMessage *msg;
GTlsCertificate *cert = NULL;
GTlsCertificateFlags flags;
gboolean is_https;
msg = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msg);
soup_test_assert_message_status (msg, SOUP_STATUS_SSL_FAILED);
is_https = soup_message_get_https_status (msg, &cert, &flags);
soup_test_assert (!is_https, "get_http_status() returned TRUE? (flags %x)", flags);
g_assert_null (cert);
g_assert_false (soup_message_get_flags (msg) & SOUP_MESSAGE_CERTIFICATE_TRUSTED);
g_object_unref (msg);
}
static gboolean
idle_start_test1_thread (gpointer use_thread_context)
{
guint64 time;
GThread *thread;
g_mutex_lock (&test1_mutex);
thread = g_thread_new ("test1_thread", test1_thread, use_thread_context);
time = g_get_monotonic_time () + 5000000;
if (g_cond_wait_until (&test1_cond, &test1_mutex, time))
g_thread_join (thread);
else {
soup_test_assert (FALSE, "timeout");
g_thread_unref (thread);
}
g_mutex_unlock (&test1_mutex);
g_main_loop_quit (test1_loop);
return FALSE;
}
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_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 gboolean
idle_test2_fail (gpointer user_data)
{
soup_test_assert (FALSE, "idle ran");
return FALSE;
}
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_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);
}
static void
has_authorization_header_authenticate_assert (SoupSession *session, SoupMessage *msg,
SoupAuth *auth, gboolean retrying, gpointer data)
{
soup_test_assert (FALSE, "authenticate emitted unexpectedly");
}
static void
do_session_property_tests (void)
{
gboolean use_system;
GTlsDatabase *tlsdb;
char *ca_file;
SoupSession *session;
GParamSpec *pspec;
g_test_bug ("700518");
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
session = soup_session_async_new ();
G_GNUC_END_IGNORE_DEPRECATIONS;
/* Temporarily undeprecate SOUP_SESSION_SSL_CA_FILE to avoid warnings. */
pspec = g_object_class_find_property (g_type_class_peek (SOUP_TYPE_SESSION),
SOUP_SESSION_SSL_CA_FILE);
pspec->flags &= ~G_PARAM_DEPRECATED;
g_object_get (G_OBJECT (session),
"ssl-use-system-ca-file", &use_system,
"tls-database", &tlsdb,
"ssl-ca-file", &ca_file,
NULL);
soup_test_assert (!use_system, "ssl-use-system-ca-file defaults to TRUE");
soup_test_assert (tlsdb == NULL, "tls-database set by default");
soup_test_assert (ca_file == NULL, "ca-file set by default");
g_object_set (G_OBJECT (session),
"ssl-use-system-ca-file", TRUE,
NULL);
g_object_get (G_OBJECT (session),
"ssl-ca-file", &ca_file,
NULL);
soup_test_assert (ca_file == NULL, "setting ssl-use-system-ca-file set ssl-ca-file");
g_object_set (G_OBJECT (session),
"ssl-ca-file",
g_test_get_filename (G_TEST_DIST, "test-cert.pem", NULL),
NULL);
g_object_get (G_OBJECT (session),
"ssl-use-system-ca-file", &use_system,
"tls-database", &tlsdb,
"ssl-ca-file", &ca_file,
NULL);
soup_test_assert (ca_file == NULL, "setting ssl-ca-file did not fail");
soup_test_assert (!use_system, "setting ssl-ca-file set ssl-use-system-ca-file");
soup_test_assert (tlsdb == NULL, "setting ssl-ca-file set tls-database");
g_object_set (G_OBJECT (session),
"tls-database", NULL,
NULL);
g_object_get (G_OBJECT (session),
"ssl-use-system-ca-file", &use_system,
"tls-database", &tlsdb,
"ssl-ca-file", &ca_file,
NULL);
soup_test_assert (tlsdb == NULL, "setting tls-database NULL failed");
soup_test_assert (!use_system, "setting tls-database NULL set ssl-use-system-ca-file");
soup_test_assert (ca_file == NULL, "setting tls-database NULL set ssl-ca-file");
soup_test_session_abort_unref (session);
/* Re-deprecate SOUP_SESSION_SSL_CA_FILE */
pspec->flags |= G_PARAM_DEPRECATED;
}
