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; }