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 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; }
static void do_digest_nonce_test (SoupSession *session, const char *nth, const char *uri, gboolean use_auth_cache, gboolean expect_401, gboolean expect_signal) { SoupMessage *msg; gboolean got_401; msg = soup_message_new (SOUP_METHOD_GET, uri); if (!use_auth_cache) { SoupMessageFlags flags = soup_message_get_flags (msg); soup_message_set_flags (msg, flags | SOUP_MESSAGE_DO_NOT_USE_AUTH_CACHE); } if (expect_signal) { g_signal_connect (session, "authenticate", G_CALLBACK (digest_nonce_authenticate), NULL); } soup_message_add_status_code_handler (msg, "got_headers", SOUP_STATUS_UNAUTHORIZED, G_CALLBACK (digest_nonce_unauthorized), &got_401); got_401 = FALSE; soup_session_send_message (session, msg); soup_test_assert (got_401 == expect_401, "%s request %s a 401 Unauthorized!\n", nth, got_401 ? "got" : "did not get"); soup_test_assert_message_status (msg, SOUP_STATUS_OK); g_object_unref (msg); }
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 bug271540_finished (SoupSession *session, SoupMessage *msg, gpointer data) { int *left = data; soup_test_assert_message_status (msg, SOUP_STATUS_OK); (*left)--; if (!*left) g_main_loop_quit (loop); }
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_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_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 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_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_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 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); }