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