int
main (int argc, char **argv)
{
SoupServer *server;
char *fast_uri, *slow_uri;
test_init (argc, argv, NULL);
debug_printf (1, "http\n");
server = soup_test_server_new (TRUE);
soup_server_add_handler (server, NULL, server_handler, NULL, NULL);
fast_uri = g_strdup_printf ("http://127.0.0.1:%u/",
soup_server_get_port (server));
slow_uri = g_strdup_printf ("http://127.0.0.1:%u/slow",
soup_server_get_port (server));
do_timeout_tests (fast_uri, slow_uri);
g_free (fast_uri);
g_free (slow_uri);
debug_printf (1, "https\n");
server = soup_test_server_new_ssl (TRUE);
soup_server_add_handler (server, NULL, server_handler, NULL, NULL);
fast_uri = g_strdup_printf ("https://127.0.0.1:%u/",
soup_server_get_port (server));
slow_uri = g_strdup_printf ("https://127.0.0.1:%u/slow",
soup_server_get_port (server));
do_timeout_tests (fast_uri, slow_uri);
g_free (fast_uri);
g_free (slow_uri);
test_cleanup ();
return errors != 0;
}
int
run_server (guint * http_port, guint * https_port)
{
guint port = SOUP_ADDRESS_ANY_PORT;
guint ssl_port = SOUP_ADDRESS_ANY_PORT;
const char *ssl_cert_file = GST_TEST_FILES_PATH "/test-cert.pem";
const char *ssl_key_file = GST_TEST_FILES_PATH "/test-key.pem";
static int server_running = 0;
SoupAuthDomain *domain = NULL;
if (server_running)
return 0;
server_running = 1;
*http_port = *https_port = 0;
server = soup_server_new (SOUP_SERVER_PORT, port, NULL);
if (!server) {
GST_DEBUG ("Unable to bind to server port %u", port);
return 1;
}
*http_port = soup_server_get_port (server);
GST_INFO ("HTTP server listening on port %u", *http_port);
soup_server_add_handler (server, NULL, server_callback, NULL, NULL);
domain = soup_auth_domain_basic_new (SOUP_AUTH_DOMAIN_REALM, realm,
SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK, basic_auth_cb,
SOUP_AUTH_DOMAIN_ADD_PATH, basic_auth_path, NULL);
soup_server_add_auth_domain (server, domain);
g_object_unref (domain);
domain = soup_auth_domain_digest_new (SOUP_AUTH_DOMAIN_REALM, realm,
SOUP_AUTH_DOMAIN_DIGEST_AUTH_CALLBACK, digest_auth_cb,
SOUP_AUTH_DOMAIN_ADD_PATH, digest_auth_path, NULL);
soup_server_add_auth_domain (server, domain);
g_object_unref (domain);
soup_server_run_async (server);
if (ssl_cert_file && ssl_key_file) {
ssl_server = soup_server_new (SOUP_SERVER_PORT, ssl_port,
SOUP_SERVER_SSL_CERT_FILE, ssl_cert_file,
SOUP_SERVER_SSL_KEY_FILE, ssl_key_file, NULL);
if (!ssl_server) {
GST_DEBUG ("Unable to bind to SSL server port %u", ssl_port);
return 1;
}
*https_port = soup_server_get_port (ssl_server);
GST_INFO ("HTTPS server listening on port %u", *https_port);
soup_server_add_handler (ssl_server, NULL, server_callback, NULL, NULL);
soup_server_run_async (ssl_server);
}
return 0;
}
int
main (int argc, char **argv)
{
SoupAuthDomain *auth_domain;
test_init (argc, argv, NULL);
server = soup_test_server_new (TRUE);
soup_server_add_handler (server, NULL, server_callback, "http", NULL);
base_uri = soup_uri_new ("http://127.0.0.1/");
soup_uri_set_port (base_uri, soup_server_get_port (server));
auth_domain = soup_auth_domain_basic_new (
SOUP_AUTH_DOMAIN_REALM, "misc-test",
SOUP_AUTH_DOMAIN_ADD_PATH, "/auth",
SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK, auth_callback,
NULL);
soup_server_add_auth_domain (server, auth_domain);
g_object_unref (auth_domain);
ssl_server = soup_test_server_new_ssl (TRUE);
soup_server_add_handler (ssl_server, NULL, server_callback, "https", NULL);
ssl_base_uri = soup_uri_new ("https://127.0.0.1/");
soup_uri_set_port (ssl_base_uri, soup_server_get_port (ssl_server));
do_host_test ();
do_callback_unref_test ();
do_callback_unref_req_test ();
do_msg_reuse_test ();
do_star_test ();
do_early_abort_test ();
do_early_abort_req_test ();
do_accept_language_test ();
do_cancel_while_reading_test ();
do_cancel_while_reading_req_test ();
do_aliases_test ();
do_dot_dot_test ();
do_ipv6_test ();
do_idle_on_dispose_test ();
do_pause_abort_test ();
soup_uri_free (base_uri);
soup_uri_free (ssl_base_uri);
soup_test_server_quit_unref (server);
soup_test_server_quit_unref (ssl_server);
test_cleanup ();
return errors != 0;
}
int
main (int argc, char **argv)
{
SoupServer *server;
char *uri;
int ret;
/* Force this test to use the dummy TLS backend */
g_setenv ("GIO_USE_TLS", "dummy", TRUE);
test_init (argc, argv, NULL);
/* Make a non-SSL server and pretend that it's ssl, which is fine
* since we won't ever actually talk to it anyway. We don't
* currently test that failing to construct an SSL server works.
*/
server = soup_test_server_new (TRUE);
soup_server_add_handler (server, NULL, server_handler, NULL, NULL);
uri = g_strdup_printf ("https://127.0.0.1:%u/",
soup_server_get_port (server));
g_test_add_func ("/no-ssl/session-properties", do_session_property_tests);
g_test_add_data_func ("/no-ssl/request-error", uri, do_ssl_tests);
ret = g_test_run ();
g_free (uri);
soup_test_server_quit_unref (server);
test_cleanup ();
return ret;
}
int main(int argc, char** argv)
{
SoupServer* server;
SoupURI* soup_uri;
gtk_test_init(&argc, &argv, NULL);
/* Hopefully make test independent of the path it's called from. */
testutils_relative_chdir("Source/WebKit/gtk/tests/resources/test.html", argv[0]);
server = soup_server_new(SOUP_SERVER_PORT, 0, NULL);
soup_server_run_async(server);
soup_server_add_handler(server, NULL, server_callback, NULL, NULL);
soup_uri = soup_uri_new("http://127.0.0.1/");
soup_uri_set_port(soup_uri, soup_server_get_port(server));
base_uri = soup_uri_to_string(soup_uri, FALSE);
soup_uri_free(soup_uri);
g_test_bug_base("https://bugs.webkit.org/");
g_test_add_func("/webkit/webview/icon-uri", test_webkit_web_view_icon_uri);
g_test_add_func("/webkit/webview/adjustments", test_webkit_web_view_adjustments);
g_test_add_func("/webkit/webview/destroy", test_webkit_web_view_destroy);
g_test_add_func("/webkit/webview/grab_focus", test_webkit_web_view_grab_focus);
g_test_add_func("/webkit/webview/window-features", test_webkit_web_view_window_features);
g_test_add_func("/webkit/webview/webview-in-offscreen-window-does-not-crash", test_webkit_web_view_in_offscreen_window_does_not_crash);
g_test_add_func("/webkit/webview/webview-does-not-steal-focus", test_webkit_web_view_does_not_steal_focus);
g_test_add_data_func("/webkit/webview/fullscreen", GINT_TO_POINTER(FALSE), test_webkit_web_view_fullscreen);
g_test_add_data_func("/webkit/webview/fullscreen-blocked", GINT_TO_POINTER(TRUE), test_webkit_web_view_fullscreen);
g_test_add_func("/webkit/webview/file-chooser", test_webkit_web_view_file_chooser);
return g_test_run ();
}
int
main (int argc, char **argv)
{
GMainLoop *loop;
SoupServer *server;
guint port;
SoupURI *base_uri;
test_init (argc, argv, NULL);
server = soup_test_server_new (TRUE);
soup_server_add_handler (server, NULL,
server_callback, NULL, NULL);
port = soup_server_get_port (server);
loop = g_main_loop_new (NULL, TRUE);
base_uri = soup_uri_new ("http://127.0.0.1");
soup_uri_set_port (base_uri, port);
do_chunk_tests (base_uri);
soup_uri_free (base_uri);
g_main_loop_unref (loop);
soup_test_server_quit_unref (server);
test_cleanup ();
return errors != 0;
}
int main(int argc, char** argv)
{
SoupServer* server;
SoupURI* soup_uri;
g_thread_init(NULL);
gtk_test_init(&argc, &argv, NULL);
/* Hopefully make test independent of the path it's called from. */
testutils_relative_chdir("WebKit/gtk/tests/resources/test.html", argv[0]);
server = soup_server_new(SOUP_SERVER_PORT, 0, NULL);
soup_server_run_async(server);
soup_server_add_handler(server, NULL, server_callback, NULL, NULL);
soup_uri = soup_uri_new("http://127.0.0.1/");
soup_uri_set_port(soup_uri, soup_server_get_port(server));
base_uri = soup_uri_to_string(soup_uri, FALSE);
soup_uri_free(soup_uri);
g_test_bug_base("https://bugs.webkit.org/");
g_test_add_func("/webkit/webview/icon-uri", test_webkit_web_view_icon_uri);
g_test_add_func("/webkit/webview/adjustments", test_webkit_web_view_adjustments);
g_test_add_func("/webkit/webview/destroy", test_webkit_web_view_destroy);
g_test_add_func("/webkit/webview/grab_focus", test_webkit_web_view_grab_focus);
g_test_add_func("/webkit/webview/window-features", test_webkit_web_view_window_features);
return g_test_run ();
}
int
main (int argc, char **argv)
{
SoupServer *server;
SoupURI *uri;
int ret;
test_init (argc, argv, NULL);
server = soup_test_server_new (SOUP_TEST_SERVER_IN_THREAD);
soup_server_add_handler (server, NULL, server_callback, NULL, NULL);
uri = soup_test_server_get_uri (server, "http", NULL);
base_uri = soup_uri_to_string (uri, FALSE);
soup_uri_free (uri);
g_test_add_data_func ("/context/blocking/explicit", GINT_TO_POINTER (FALSE), do_test1);
g_test_add_data_func ("/context/blocking/thread-default", GINT_TO_POINTER (TRUE), do_test1);
g_test_add_data_func ("/context/nested/explicit", GINT_TO_POINTER (FALSE), do_test2);
g_test_add_data_func ("/context/nested/thread-default", GINT_TO_POINTER (TRUE), do_test2);
g_test_add_func ("/context/multiple", do_multicontext_test);
ret = g_test_run ();
g_free (base_uri);
soup_test_server_quit_unref (server);
test_cleanup ();
return ret;
}
int
main (int argc, char **argv)
{
GMainLoop *loop;
SoupServer *server;
GHashTable *connections;
SoupURI *uri;
test_init (argc, argv, NULL);
server = soup_test_server_new (FALSE);
connections = g_hash_table_new (NULL, NULL);
soup_server_add_handler (server, NULL,
server_callback, connections, NULL);
loop = g_main_loop_new (NULL, TRUE);
uri = soup_uri_new ("http://127.0.0.1/");
soup_uri_set_port (uri, soup_server_get_port (server));
do_ntlm_tests (uri);
soup_uri_free (uri);
g_main_loop_unref (loop);
soup_test_server_quit_unref (server);
test_cleanup ();
g_hash_table_destroy (connections);
return errors != 0;
}
gboolean
sim_server_api_init (SoupServer * server)
{
gboolean result = FALSE;
g_return_val_if_fail (server != NULL, FALSE);
/* Add the auth code */
soup_server_add_handler (server, "/server/status", server_api_status_callback, NULL, NULL);
if ((ossim.domain_auth = soup_auth_domain_basic_new (
SOUP_AUTH_DOMAIN_REALM,"ossim api",
SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK, sim_server_auth_callback,
SOUP_AUTH_DOMAIN_BASIC_AUTH_DATA, ossim.user_auth,
SOUP_AUTH_DOMAIN_ADD_PATH,"/server/status",
NULL)) == NULL)
{
result = FALSE;
}
else
{
soup_auth_domain_set_filter (ossim.domain_auth,sim_server_api_auth_filter , NULL, NULL);
soup_server_add_auth_domain (server, ossim.domain_auth);
result = TRUE;
}
if (ossim.domain_auth != NULL)
g_object_unref (ossim.domain_auth);
return result;
}
int
main (int argc, char **argv)
{
SoupAuthDomain *auth_domain;
test_init (argc, argv, NULL);
server = soup_test_server_new (TRUE);
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));
auth_domain = soup_auth_domain_basic_new (
SOUP_AUTH_DOMAIN_REALM, "misc-test",
SOUP_AUTH_DOMAIN_ADD_PATH, "/auth",
SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK, auth_callback,
NULL);
soup_server_add_auth_domain (server, auth_domain);
g_object_unref (auth_domain);
do_host_test ();
do_callback_unref_test ();
do_msg_reuse_test ();
do_star_test ();
do_early_abort_test ();
do_content_length_framing_test ();
do_accept_language_test ();
do_persistent_connection_timeout_test ();
soup_uri_free (base_uri);
soup_test_server_quit_unref (server);
test_cleanup ();
return errors != 0;
}
int
main (int argc, char **argv)
{
GOptionContext *opts;
GMainLoop *loop;
GError *error = NULL;
opts = g_option_context_new (NULL);
g_option_context_add_main_entries (opts, entries, NULL);
if (!g_option_context_parse (opts, &argc, &argv, &error)) {
g_printerr ("Could not parse arguments: %s\n",
error->message);
g_printerr ("%s",
g_option_context_get_help (opts, TRUE, NULL));
exit (1);
}
if (argc != 2) {
g_printerr ("%s",
g_option_context_get_help (opts, TRUE, NULL));
exit (1);
}
g_option_context_free (opts);
signal (SIGINT, quit);
server = soup_server_new (SOUP_SERVER_PORT, port,
NULL);
if (!server) {
g_printerr ("Unable to bind to server port %d\n", port);
exit (1);
}
soup_server_add_handler (server, NULL,
server_callback, NULL, NULL);
if (require_auth) {
SoupAuthDomain *auth_domain;
auth_domain = soup_auth_domain_basic_new (
SOUP_AUTH_DOMAIN_REALM, "simple-proxy",
SOUP_AUTH_DOMAIN_PROXY, TRUE,
SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK, auth_callback,
NULL);
soup_server_add_auth_domain (server, auth_domain);
g_object_unref (auth_domain);
}
g_print ("\nStarting proxy on port %d\n",
soup_server_get_port (server));
soup_server_run_async (server);
session = soup_session_async_new ();
g_print ("\nWaiting for requests...\n");
loop = g_main_loop_new (NULL, TRUE);
g_main_loop_run (loop);
g_main_loop_unref (loop);
return 0;
}
int
main (int argc, char **argv)
{
SoupServer *server;
int ret;
test_init (argc, argv, NULL);
server = soup_test_server_new (TRUE);
soup_server_add_handler (server, NULL, server_callback, NULL, NULL);
base_uri = g_strdup_printf ("http://127.0.0.1:%u/",
soup_server_get_port (server));
g_test_add_data_func ("/context/blocking/explicit", GINT_TO_POINTER (FALSE), do_test1);
g_test_add_data_func ("/context/blocking/thread-default", GINT_TO_POINTER (TRUE), do_test1);
g_test_add_data_func ("/context/nested/explicit", GINT_TO_POINTER (FALSE), do_test2);
g_test_add_data_func ("/context/nested/thread-default", GINT_TO_POINTER (TRUE), do_test2);
g_test_add_func ("/context/multiple", do_multicontext_test);
ret = g_test_run ();
g_free (base_uri);
soup_test_server_quit_unref (server);
test_cleanup ();
return ret;
}
int
main (int argc, char **argv)
{
GMainLoop *loop;
SoupServer *server;
guint port;
SoupURI *base_uri;
test_init (argc, argv, no_test_entry);
server = soup_test_server_new (TRUE);
soup_server_add_handler (server, NULL,
server_callback, NULL, NULL);
port = soup_server_get_port (server);
loop = g_main_loop_new (NULL, TRUE);
if (run_tests) {
base_uri = soup_uri_new ("http://127.0.0.1");
soup_uri_set_port (base_uri, port);
do_redirect_tests (base_uri);
soup_uri_free (base_uri);
} else {
printf ("Listening on port %d\n", port);
g_main_loop_run (loop);
}
g_main_loop_unref (loop);
if (run_tests)
test_cleanup ();
return errors != 0;
}
static dlr_host_server_t *prv_host_server_new(const gchar *device_if,
guint port,
GError **error)
{
dlr_host_server_t *server = NULL;
SoupAddress *addr;
addr = soup_address_new(device_if, port);
if (soup_address_resolve_sync(addr, NULL) != SOUP_STATUS_OK) {
*error = g_error_new(DLEYNA_SERVER_ERROR,
DLEYNA_ERROR_HOST_FAILED,
"Unable to create host server on %s",
device_if);
goto on_error;
}
server = g_new(dlr_host_server_t, 1);
server->files = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, prv_host_file_delete);
server->soup_server = soup_server_new(SOUP_SERVER_INTERFACE, addr,
NULL);
soup_server_add_handler(server->soup_server, DLR_HOST_SERVICE_ROOT,
prv_soup_server_cb, server, NULL);
soup_server_run_async(server->soup_server);
server->counter = 0;
on_error:
g_object_unref(addr);
return server;
}
UiConnection *
ui_connection_new(const gchar *hostname, int internal_port, int external_port) {
UiConnection *self = g_new(UiConnection, 1);
self->connection = NULL;
self->main_network = NULL;
self->network_map = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, (GDestroyNotify)network_free);
self->hostname = g_strdup(hostname);
self->registry = registry_new(runtime_info_new_from_env(hostname, external_port));
self->component_lib = library_new();
setup_log_handlers(self);
self->server = soup_server_new(SOUP_SERVER_SERVER_HEADER, "imgflo-runtime", NULL);
if (!self->server) {
g_free(self);
return NULL;
}
soup_server_add_handler(self->server, NULL,
server_callback, self, NULL);
soup_server_add_websocket_handler(self->server, NULL, NULL, NULL,
websocket_callback, self, NULL);
soup_server_listen_all(self->server, internal_port, SOUP_SERVER_LISTEN_IPV4_ONLY, NULL);
return self;
}
static void
korva_upnp_file_server_init (KorvaUPnPFileServer *self)
{
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
KORVA_TYPE_UPNP_FILE_SERVER,
KorvaUPnPFileServerPrivate);
self->priv->http_server = soup_server_new (NULL, NULL);
soup_server_add_handler (self->priv->http_server,
"/item",
korva_upnp_file_server_handle_request,
self,
NULL);
soup_server_run_async (self->priv->http_server);
self->priv->host_data = g_hash_table_new_full (g_file_hash,
(GEqualFunc) g_file_equal,
g_object_unref,
g_object_unref);
self->priv->id_map = g_hash_table_new_full (g_str_hash,
(GEqualFunc) g_str_equal,
g_free,
g_object_unref);
self->priv->path_regex = g_regex_new (KORVA_PATH_REGEX,
G_REGEX_OPTIMIZE,
G_REGEX_MATCH_NEWLINE_ANY,
NULL);
}
int main(int argc, char **argv)
{
gtk_test_init(&argc, &argv, NULL);
/* This hopefully makes the test independent of the path it's called from. */
testutils_relative_chdir("Source/WebKit/gtk/tests/resources/test.html", argv[0]);
SoupServer *server = soup_server_new(SOUP_SERVER_PORT, 0, NULL);
soup_server_run_async(server);
soup_server_add_handler(server, NULL, serverCallback, NULL, NULL);
SoupURI *soupURI = soup_uri_new("http://127.0.0.1/");
soup_uri_set_port(soupURI, soup_server_get_port(server));
baseURI = soup_uri_to_string(soupURI, FALSE);
soup_uri_free(soupURI);
g_test_bug_base("https://bugs.webkit.org/");
g_test_add_func("/webkit/favicondatabase/set-path", testWebKitFaviconDatabaseSetPath);
// These two tests will trigger an ASSERTION on debug builds due
// to http://webkit.org/b/67582. Remove the guards once the bug is fixed.
#ifdef NDEBUG
g_test_add_func("/webkit/favicondatabase/get-favicon", testWebKitFaviconDatabaseGetFavicon);
g_test_add_func("/webkit/favicondatabase/get-favicon-uri", testWebKitFaviconDatabaseGetFaviconURI);
#endif
g_test_add_func("/webkit/favicondatabase/remove-all", testWebKitFaviconDatabaseRemoveAll);
g_test_add_func("/webkit/favicondatabase/close-db", testWebKitFaviconDatabaseCloseDatabase);
return g_test_run();
}
static void
gss_server_set_https_port (GssServer * server, int port)
{
if (port == 0) {
server->ssl_server = get_https_server (443);
port = 443;
if (server->ssl_server == NULL) {
server->ssl_server = get_https_server (8443);
port = 8443;
}
} else {
server->ssl_server = get_https_server (port);
}
if (server->ssl_server == NULL) {
return;
}
server->https_port = port;
g_free (server->base_url_https);
if (server->https_port == 443) {
server->base_url_https = g_strdup_printf ("https://%s",
server->server_hostname);
} else {
server->base_url_https = g_strdup_printf ("https://%s:%d",
server->server_hostname, server->https_port);
}
if (server->ssl_server) {
soup_server_add_handler (server->ssl_server, "/",
gss_server_resource_callback, server, NULL);
soup_server_run_async (server->ssl_server);
}
}
int
main (int argc, char **argv)
{
test_init (argc, argv, NULL);
#ifdef HAVE_APACHE
apache_init ();
#endif
server = soup_test_server_new (TRUE);
soup_server_add_handler (server, NULL, server_callback, "http", NULL);
base_uri = soup_uri_new ("http://127.0.0.1/");
soup_uri_set_port (base_uri, soup_server_get_port (server));
do_content_length_framing_test ();
do_persistent_connection_timeout_test ();
do_max_conns_test ();
do_non_persistent_connection_test ();
do_non_idempotent_connection_test ();
#ifdef HAVE_APACHE
do_connection_state_test ();
do_connection_event_test ();
#endif
soup_uri_free (base_uri);
soup_test_server_quit_unref (server);
test_cleanup ();
return errors != 0;
}
int main(int argc, char *argv[])
{
GMainLoop *loop;
SoupServer *server;
int port = 13333;
(void) argc;
(void) argv;
if ((glib_major_version == 2) && (glib_minor_version < 36))
g_type_init();
server = soup_server_new(SOUP_SERVER_PORT, port,
SOUP_SERVER_SERVER_HEADER, "auto-complete",
NULL);
if (!server) {
g_printerr("Unable to bind to server port %d\n", port);
exit(1);
}
soup_server_add_handler(server, NULL, server_callback, NULL, NULL);
soup_server_run_async(server);
g_print("\nWaiting for requests on port %u...\n", port);
loop = g_main_loop_new(NULL, TRUE);
g_main_loop_run(loop);
return 0;
}
int
main (int argc, char **argv)
{
SoupServer *server;
SoupURI *uri;
guint port;
int ret;
/* Force this test to use the dummy TLS backend */
g_setenv ("GIO_USE_TLS", "dummy", TRUE);
test_init (argc, argv, NULL);
/* Make a non-SSL server and pretend that it's ssl, which is fine
* since we won't ever actually talk to it anyway. We don't
* currently test that failing to construct an SSL server works.
*/
server = soup_test_server_new (TRUE);
soup_server_add_handler (server, NULL, server_handler, NULL, NULL);
uri = soup_test_server_get_uri (server, "http", NULL);
port = uri->port;
soup_uri_set_scheme (uri, SOUP_URI_SCHEME_HTTPS);
soup_uri_set_port (uri, port);
g_test_add_func ("/no-ssl/session-properties", do_session_property_tests);
g_test_add_data_func ("/no-ssl/request-error", uri, do_ssl_tests);
ret = g_test_run ();
soup_uri_free (uri);
soup_test_server_quit_unref (server);
test_cleanup ();
return ret;
}
int
main (int argc, char **argv)
{
SoupSession *session;
char *url;
RestProxy *proxy;
g_type_init ();
loop = g_main_loop_new (NULL, FALSE);
session = soup_session_async_new ();
server = soup_server_new (NULL);
soup_server_add_handler (server, NULL, server_callback, NULL, NULL);
soup_server_run_async (server);
url = g_strdup_printf ("http://127.0.0.1:%d/", soup_server_get_port (server));
proxy = rest_proxy_new (url, FALSE);
g_free (url);
stream_test (proxy);
g_main_loop_run (loop);
return errors != 0;
}
void
web_setup (WebFixture *fix, gconstpointer data)
{
if (!PORT)
PORT = 52853;
fix->server = soup_server_new (SOUP_SERVER_PORT, PORT, NULL);
while (!SOUP_IS_SERVER (fix->server)) {
PORT++;
fix->server = soup_server_new (SOUP_SERVER_PORT, PORT, NULL);
}
soup_server_add_handler (fix->server, "/feeds/", feed_server, NULL, NULL);
soup_server_add_handler (fix->server, "/video/", video_server, NULL, NULL);
soup_server_add_handler (fix->server, "/redirect/", redirect_server, NULL, NULL);
soup_server_run_async (fix->server);
}
/* Server handlers for "*" work but are separate from handlers for
* all other URIs. #590751
*/
static void
do_star_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupURI *star_uri;
const char *handled_by;
debug_printf (1, "\nOPTIONS *\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);
star_uri = soup_uri_copy (base_uri);
soup_uri_set_path (star_uri, "*");
debug_printf (1, " Testing with no handler\n");
msg = soup_message_new_from_uri ("OPTIONS", star_uri);
soup_session_send_message (session, msg);
if (msg->status_code != SOUP_STATUS_NOT_FOUND) {
debug_printf (1, " Unexpected response: %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
handled_by = soup_message_headers_get_one (msg->response_headers,
"X-Handled-By");
if (handled_by) {
/* Should have been rejected by SoupServer directly */
debug_printf (1, " Message reached handler '%s'\n",
handled_by);
errors++;
}
g_object_unref (msg);
soup_server_add_handler (server, "*", server_star_callback, NULL, NULL);
debug_printf (1, " Testing with handler\n");
msg = soup_message_new_from_uri ("OPTIONS", star_uri);
soup_session_send_message (session, msg);
if (msg->status_code != SOUP_STATUS_OK) {
debug_printf (1, " Unexpected response: %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
handled_by = soup_message_headers_get_one (msg->response_headers,
"X-Handled-By");
if (!handled_by) {
debug_printf (1, " Message did not reach handler!\n");
errors++;
} else if (strcmp (handled_by, "star_callback") != 0) {
debug_printf (1, " Message reached incorrect handler '%s'\n",
handled_by);
errors++;
}
g_object_unref (msg);
soup_test_session_abort_unref (session);
soup_uri_free (star_uri);
}
int
main (int argc, char **argv)
{
GMainLoop *loop;
int opt;
int port = SOUP_ADDRESS_ANY_PORT;
SoupAuthDomain *auth_domain = NULL;
g_type_init ();
signal (SIGINT, quit);
while ((opt = getopt (argc, argv, "ap:")) != -1) {
switch (opt) {
case 'a':
auth_domain = soup_auth_domain_basic_new (
SOUP_AUTH_DOMAIN_REALM, "simple-proxy",
SOUP_AUTH_DOMAIN_PROXY, TRUE,
SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK, auth_callback,
NULL);
break;
case 'p':
port = atoi (optarg);
break;
default:
g_printerr ("Usage: %s [-p port] [-n]\n",
argv[0]);
exit (1);
}
}
server = soup_server_new (SOUP_SERVER_PORT, port,
NULL);
if (!server) {
g_printerr ("Unable to bind to server port %d\n", port);
exit (1);
}
soup_server_add_handler (server, NULL,
server_callback, NULL, NULL);
if (auth_domain) {
soup_server_add_auth_domain (server, auth_domain);
g_object_unref (auth_domain);
}
g_print ("\nStarting proxy on port %d\n",
soup_server_get_port (server));
soup_server_run_async (server);
session = soup_session_async_new ();
g_print ("\nWaiting for requests...\n");
loop = g_main_loop_new (NULL, TRUE);
g_main_loop_run (loop);
g_main_loop_unref (loop);
return 0;
}
InstallResult install(WebServer *server)
{
soup_server_add_handler(server->soupServer,
NULL,
doesntexist_callback,
NULL,
NULL);
return INSTALL_RESULT_OK;
}
int
main (int argc, char **argv)
{
GMainLoop *loop;
SoupServer *server;
SoupURI *uri;
SoupAuthDomain *auth_domain;
test_init (argc, argv, no_test_entry);
server = soup_test_server_new (FALSE);
g_signal_connect (server, "request_started",
G_CALLBACK (request_started_callback), NULL);
soup_server_add_handler (server, NULL,
server_callback, NULL, NULL);
auth_domain = soup_auth_domain_basic_new (
SOUP_AUTH_DOMAIN_REALM, "server-auth-test",
SOUP_AUTH_DOMAIN_ADD_PATH, "/Basic",
SOUP_AUTH_DOMAIN_ADD_PATH, "/Any",
SOUP_AUTH_DOMAIN_REMOVE_PATH, "/Any/Not",
SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK, basic_auth_callback,
NULL);
soup_server_add_auth_domain (server, auth_domain);
g_object_unref (auth_domain);
auth_domain = soup_auth_domain_digest_new (
SOUP_AUTH_DOMAIN_REALM, "server-auth-test",
SOUP_AUTH_DOMAIN_ADD_PATH, "/Digest",
SOUP_AUTH_DOMAIN_ADD_PATH, "/Any",
SOUP_AUTH_DOMAIN_REMOVE_PATH, "/Any/Not",
SOUP_AUTH_DOMAIN_DIGEST_AUTH_CALLBACK, digest_auth_callback,
NULL);
soup_server_add_auth_domain (server, auth_domain);
g_object_unref (auth_domain);
loop = g_main_loop_new (NULL, TRUE);
if (run_tests) {
uri = soup_uri_new ("http://127.0.0.1");
soup_uri_set_port (uri, soup_server_get_port (server));
do_auth_tests (uri);
soup_uri_free (uri);
} else {
printf ("Listening on port %d\n", soup_server_get_port (server));
g_main_loop_run (loop);
}
g_main_loop_unref (loop);
soup_test_server_quit_unref (server);
if (run_tests)
test_cleanup ();
return errors != 0;
}
static void
do_disappearing_auth_test (void)
{
SoupServer *server;
SoupAuthDomain *auth_domain;
SoupURI *uri;
SoupMessage *msg;
SoupSession *session;
int counter;
debug_printf (1, "\nTesting auth when server does not repeat challenge on failure:\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/");
soup_uri_set_port (uri, soup_server_get_port (server));
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);
if (counter > 2) {
debug_printf (1, " FAILED: Got stuck in loop");
errors++;
} else if (msg->status_code != SOUP_STATUS_UNAUTHORIZED) {
debug_printf (1, " Final status wrong: expected 401, got %u\n",
msg->status_code);
errors++;
}
g_object_unref (msg);
soup_test_session_abort_unref (session);
g_object_unref (auth_domain);
soup_uri_free (uri);
soup_test_server_quit_unref (server);
}
int
main (int argc, char **argv)
{
GMainLoop *loop;
SoupServer *server;
guint port;
char *uri_str;
test_init (argc, argv, no_test_entry);
server = soup_test_server_new (TRUE);
soup_server_add_handler (server, "/hello",
hello_callback, NULL, NULL);
soup_server_add_handler (server, "/md5",
md5_callback, NULL, NULL);
port = soup_server_get_port (server);
loop = g_main_loop_new (NULL, TRUE);
if (run_tests) {
uri_str = g_strdup_printf ("http://127.0.0.1:%u/hello", port);
do_hello_tests (uri_str);
g_free (uri_str);
uri_str = g_strdup_printf ("http://127.0.0.1:%u/md5", port);
do_md5_tests (uri_str);
g_free (uri_str);
} else {
printf ("Listening on port %d\n", port);
g_main_loop_run (loop);
}
g_main_loop_unref (loop);
soup_test_server_quit_unref (server);
if (run_tests)
test_cleanup ();
return errors != 0;
}
