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; }
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) { 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; }
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) { 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; }
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) { 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; }
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_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_select_auth_test (void) { SoupServer *server; SoupAuthDomain *basic_auth_domain, *digest_auth_domain; SoupURI *uri; debug_printf (1, "\nTesting selection among multiple auths:\n"); /* It doesn't seem to be possible to configure Apache to serve * multiple auth types for a single URL. So we have to use * SoupServer here. We know that SoupServer handles the server * side of this scenario correctly, because we test it against * curl in server-auth-test. */ 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)); 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); digest_auth_domain = soup_auth_domain_digest_new ( SOUP_AUTH_DOMAIN_REALM, "auth-test", SOUP_AUTH_DOMAIN_ADD_PATH, "/", SOUP_AUTH_DOMAIN_DIGEST_AUTH_CALLBACK, server_digest_auth_callback, NULL); soup_server_add_auth_domain (server, digest_auth_domain); debug_printf (1, " Testing with no auth\n"); select_auth_test_one (uri, FALSE, NULL, "Basic, Digest", "Digest", NULL, NULL, SOUP_STATUS_UNAUTHORIZED); debug_printf (1, " Testing with bad password\n"); select_auth_test_one (uri, FALSE, "bad", "Basic, Digest", "Digest", "Basic, Digest", "Digest", SOUP_STATUS_UNAUTHORIZED); debug_printf (1, " Testing with good password\n"); select_auth_test_one (uri, FALSE, "good", "Basic, Digest", "Digest", NULL, NULL, SOUP_STATUS_OK); /* Test with Digest disabled in the client. */ debug_printf (1, " Testing without Digest with no auth\n"); select_auth_test_one (uri, TRUE, NULL, "Basic, Digest", "Basic", NULL, NULL, SOUP_STATUS_UNAUTHORIZED); debug_printf (1, " Testing without Digest with bad password\n"); select_auth_test_one (uri, TRUE, "bad", "Basic, Digest", "Basic", "Basic, Digest", "Basic", SOUP_STATUS_UNAUTHORIZED); debug_printf (1, " Testing without Digest with good password\n"); select_auth_test_one (uri, TRUE, "good-basic", "Basic, Digest", "Basic", NULL, NULL, SOUP_STATUS_OK); /* Now flip the order of the domains, verify that this flips * the order of the headers, and make sure that digest auth * *still* gets used. */ soup_server_remove_auth_domain (server, basic_auth_domain); soup_server_remove_auth_domain (server, digest_auth_domain); soup_server_add_auth_domain (server, digest_auth_domain); soup_server_add_auth_domain (server, basic_auth_domain); debug_printf (1, " Testing flipped with no auth\n"); select_auth_test_one (uri, FALSE, NULL, "Digest, Basic", "Digest", NULL, NULL, SOUP_STATUS_UNAUTHORIZED); debug_printf (1, " Testing flipped with bad password\n"); select_auth_test_one (uri, FALSE, "bad", "Digest, Basic", "Digest", "Digest, Basic", "Digest", SOUP_STATUS_UNAUTHORIZED); debug_printf (1, " Testing flipped with good password\n"); select_auth_test_one (uri, FALSE, "good", "Digest, Basic", "Digest", NULL, NULL, SOUP_STATUS_OK); g_object_unref (basic_auth_domain); g_object_unref (digest_auth_domain); soup_uri_free (uri); soup_test_server_quit_unref (server); }
static gboolean 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; GSocketAddress *address; GError *err = NULL; SoupAuthDomain *domain = NULL; if (server_running) return TRUE; server_running = 1; *http_port = *https_port = 0; server = soup_server_new (NULL, NULL); if (!server) { GST_DEBUG ("Unable to create server"); return FALSE; } 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); address = g_inet_socket_address_new_from_string ("0.0.0.0", port); soup_server_listen (server, address, 0, &err); g_object_unref (address); if (err) { stop_server (); g_clear_error (&err); return FALSE; } *http_port = get_port_from_server (server); GST_DEBUG ("HTTP server listening on port %u", *http_port); if (ssl_cert_file && ssl_key_file) { GTlsBackend *backend = g_tls_backend_get_default (); if (backend != NULL && g_tls_backend_supports_tls (backend)) { ssl_server = soup_server_new (SOUP_SERVER_SSL_CERT_FILE, ssl_cert_file, SOUP_SERVER_SSL_KEY_FILE, ssl_key_file, NULL); } else { GST_INFO ("No TLS support"); } if (ssl_server) { GST_INFO ("HTTPS server listening on port %u", *https_port); soup_server_add_handler (ssl_server, NULL, server_callback, NULL, NULL); address = g_inet_socket_address_new_from_string ("0.0.0.0", ssl_port); soup_server_listen (ssl_server, address, SOUP_SERVER_LISTEN_HTTPS, &err); g_object_unref (address); if (err) { GST_ERROR ("Failed to start HTTPS server: %s", err->message); stop_server (); g_clear_error (&err); return FALSE; } *https_port = get_port_from_server (ssl_server); GST_DEBUG ("HTTPS server listening on port %u", *https_port); } } /* check if we can connect to our local http server */ { GSocketConnection *conn; GSocketClient *client; client = g_socket_client_new (); g_socket_client_set_timeout (client, 2); conn = g_socket_client_connect_to_host (client, "127.0.0.1", *http_port, NULL, NULL); if (conn == NULL) { GST_INFO ("Couldn't connect to http server 127.0.0.1:%u", *http_port); g_object_unref (client); stop_server (); return FALSE; } g_object_unref (conn); if (ssl_server == NULL) goto skip_https_check; conn = g_socket_client_connect_to_host (client, "127.0.0.1", *https_port, NULL, NULL); if (conn == NULL) { GST_INFO ("Couldn't connect to https server 127.0.0.1:%u", *https_port); g_object_unref (client); stop_server (); return FALSE; } g_object_unref (conn); skip_https_check: g_object_unref (client); } return TRUE; }
int main (int argc, char **argv) { GOptionContext *opts; GMainLoop *loop; GSList *uris, *u; char *str; 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 != 1) { g_printerr ("%s", g_option_context_get_help (opts, TRUE, NULL)); exit (1); } g_option_context_free (opts); signal (SIGINT, quit); server = g_object_new (SOUP_TYPE_SERVER, NULL); 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); } soup_server_listen_all (server, port, 0, &error); if (error) { g_printerr ("Unable to create server: %s\n", error->message); exit (1); } uris = soup_server_get_uris (server); for (u = uris; u; u = u->next) { str = soup_uri_to_string (u->data, FALSE); g_print ("Listening on %s\n", str); g_free (str); soup_uri_free (u->data); } g_slist_free (uris); session = soup_session_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; }