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;
}
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);
}
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;
}
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;
}
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();
}
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)
{
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;
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 ();
}
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)
{
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)
{
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_ipv6_test (void)
{
SoupServer *ipv6_server;
SoupURI *ipv6_uri;
SoupAddress *ipv6_addr;
SoupSession *session;
SoupMessage *msg;
debug_printf (1, "\nIPv6 server test\n");
ipv6_addr = soup_address_new ("::1", SOUP_ADDRESS_ANY_PORT);
soup_address_resolve_sync (ipv6_addr, NULL);
ipv6_server = soup_server_new (SOUP_SERVER_INTERFACE, ipv6_addr,
NULL);
g_object_unref (ipv6_addr);
soup_server_add_handler (ipv6_server, NULL, ipv6_server_callback, NULL, NULL);
soup_server_run_async (ipv6_server);
ipv6_uri = soup_uri_new ("http://[::1]/");
soup_uri_set_port (ipv6_uri, soup_server_get_port (ipv6_server));
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
debug_printf (1, " HTTP/1.1\n");
msg = soup_message_new_from_uri ("GET", ipv6_uri);
soup_session_send_message (session, msg);
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
debug_printf (1, " request failed: %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
g_object_unref (msg);
debug_printf (1, " HTTP/1.0\n");
msg = soup_message_new_from_uri ("GET", ipv6_uri);
soup_message_set_http_version (msg, SOUP_HTTP_1_0);
soup_session_send_message (session, msg);
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
debug_printf (1, " request failed: %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
g_object_unref (msg);
soup_uri_free (ipv6_uri);
soup_test_session_abort_unref (session);
soup_test_server_quit_unref (ipv6_server);
}
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);
}
/**
* soup_server_run:
* @server: a #SoupServer
*
* Starts @server, causing it to listen for and process incoming
* connections. Unlike soup_server_run_async(), this creates a
* #GMainLoop and runs it, and it will not return until someone calls
* soup_server_quit() to stop the server.
**/
void
soup_server_run (SoupServer *server)
{
SoupServerPrivate *priv;
g_return_if_fail (SOUP_IS_SERVER (server));
priv = SOUP_SERVER_GET_PRIVATE (server);
if (!priv->loop) {
priv->loop = g_main_loop_new (priv->async_context, TRUE);
soup_server_run_async (server);
}
if (priv->loop)
g_main_loop_run (priv->loop);
}
static const gchar *
serve (SoupCutClient *client)
{
SoupServer *server;
GMainContext *context;
const gchar *uri;
context = soupcut_client_get_async_context(client);
server = soupcut_server_take_new(context);
uri = soupcut_server_build_uri(server, "/");
soup_server_add_handler(server, "/", server_callback,
NULL, NULL);
soup_server_run_async(server);
return uri;
}
int
main (int argc, char **argv)
{
GMainLoop *loop;
int opt;
int port = SOUP_ADDRESS_ANY_PORT;
g_thread_init (NULL);
g_type_init ();
signal (SIGINT, quit);
while ((opt = getopt (argc, argv, "p:s:")) != -1) {
switch (opt) {
case 'p':
port = atoi (optarg);
break;
default:
fprintf (stderr, "Usage: %s [-p port] [-n]\n",
argv[0]);
exit (1);
}
}
server = soup_server_new (SOUP_SERVER_PORT, port,
NULL);
if (!server) {
fprintf (stderr, "Unable to bind to server port %d\n", port);
exit (1);
}
soup_server_add_handler (server, NULL,
server_callback, NULL, NULL);
printf ("\nStarting proxy on port %d\n",
soup_server_get_port (server));
soup_server_run_async (server);
session = soup_session_async_new ();
printf ("\nWaiting for requests...\n");
loop = g_main_loop_new (NULL, TRUE);
g_main_loop_run (loop);
g_main_loop_unref (loop);
return 0;
}
void
start_http_server (DBusClient *dbus_client, guint port)
{
SoupServer *server;
server = soup_server_new (SOUP_SERVER_PORT, port,
SOUP_SERVER_SERVER_HEADER, "httpdbusd",
NULL);
if (!server)
g_error ("Sorry, unable to start server");
soup_server_run_async (server);
soup_server_add_handler (server, NULL, (SoupServerCallback)server_cb,
dbus_client,
NULL);
}
static SoupServer *
test_server_new (gboolean in_own_thread, gboolean ssl)
{
SoupServer *server;
GMainContext *async_context;
const char *ssl_cert_file, *ssl_key_file;
SoupAddress *addr;
async_context = in_own_thread ? g_main_context_new () : NULL;
if (ssl) {
ssl_cert_file = SRCDIR "/test-cert.pem";
ssl_key_file = SRCDIR "/test-key.pem";
} else
ssl_cert_file = ssl_key_file = NULL;
addr = soup_address_new ("127.0.0.1", SOUP_ADDRESS_ANY_PORT);
soup_address_resolve_sync (addr, NULL);
server = soup_server_new (SOUP_SERVER_INTERFACE, addr,
SOUP_SERVER_ASYNC_CONTEXT, async_context,
SOUP_SERVER_SSL_CERT_FILE, ssl_cert_file,
SOUP_SERVER_SSL_KEY_FILE, ssl_key_file,
NULL);
g_object_unref (addr);
if (async_context)
g_main_context_unref (async_context);
if (!server) {
fprintf (stderr, "Unable to create server\n");
exit (1);
}
if (in_own_thread) {
GThread *thread;
thread = g_thread_create (run_server_thread, server,
TRUE, NULL);
g_object_set_data (G_OBJECT (server), "thread", thread);
} else
soup_server_run_async (server);
return server;
}
TestHttp*
test_http_new(
GMappedFile* resp_file,
const char* resp_content_type,
int resp_status)
{
TestHttp* http = g_new0(TestHttp, 1);
http->ref_count = 1;
if (resp_file) {
http->resp_file = g_mapped_file_ref(resp_file);
http->resp_content_type = g_strdup(resp_content_type);
}
http->resp_status = resp_status;
http->server = g_object_new(SOUP_TYPE_SERVER, NULL);
MMS_DEBUG("Listening on port %hu", soup_server_get_port(http->server));
soup_server_add_handler(http->server, NULL, test_http_callback, http, NULL);
soup_server_run_async(http->server);
return http;
}
int init_server()
{
SoupServer *server;
int port = SOUP_ADDRESS_ANY_PORT;
server = soup_server_new (SOUP_SERVER_PORT, port,
SOUP_SERVER_SERVER_HEADER, "AwayFramework ",
NULL);
if (!server) {
g_log("AFR", G_LOG_LEVEL_ERROR, "Unable to bind to server port %d\n", port);
return -1;
}
soup_server_add_handler (server, NULL,
server_callback, NULL, NULL);
g_log("AFR", G_LOG_LEVEL_INFO, "Starting Server on port %d",
soup_server_get_port (server));
soup_server_run_async (server);
return soup_server_get_port (server);
}
static void
gss_server_set_http_port (GssServer * server, int port)
{
if (port == 0) {
GST_DEBUG_OBJECT (server, "trying port 80");
server->server = get_http_server (80);
port = 80;
if (server->server == NULL) {
GST_DEBUG_OBJECT (server, "trying port 8080");
server->server = get_http_server (8080);
port = 8080;
}
} else {
GST_DEBUG_OBJECT (server, "trying port %d", port);
server->server = get_http_server (port);
}
if (server->server == NULL) {
return;
}
server->http_port = port;
g_free (server->base_url);
if (server->http_port == 80) {
server->base_url = g_strdup_printf ("http://%s", server->server_hostname);
} else {
server->base_url = g_strdup_printf ("http://%s:%d", server->server_hostname,
server->http_port);
}
if (server->server) {
soup_server_add_handler (server->server, "/", gss_server_resource_callback,
server, NULL);
soup_server_run_async (server->server);
}
}
int main(int argc, char** argv)
{
SoupServer* server;
gtk_test_init(&argc, &argv, NULL);
server = soup_server_new(SOUP_SERVER_PORT, 0, NULL);
soup_server_run_async(server);
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));
g_test_bug_base("https://bugs.webkit.org/");
g_test_add("/webkit/loading/status",
WebLoadingFixture, NULL,
web_loading_fixture_setup,
test_loading_status,
web_loading_fixture_teardown);
g_test_add("/webkit/loading/error",
WebLoadingFixture, NULL,
web_loading_fixture_setup,
test_loading_error,
web_loading_fixture_teardown);
g_test_add("/webkit/loading/cancelled",
WebLoadingFixture, NULL,
web_loading_fixture_setup,
test_loading_cancelled,
web_loading_fixture_teardown);
g_test_add("/webkit/loading/goback",
WebLoadingFixture, NULL,
web_loading_fixture_setup,
test_loading_goback,
web_loading_fixture_teardown);
return g_test_run();
}
static SoupServer *
test_server_new (gboolean in_own_thread, gboolean ssl)
{
GMainContext *async_context;
const char *ssl_cert_file, *ssl_key_file;
if (test_server)
test_server_shutdown ();
async_context = in_own_thread ? g_main_context_new () : NULL;
if (ssl) {
ssl_cert_file = SRCDIR "/test-cert.pem";
ssl_key_file = SRCDIR "/test-key.pem";
} else
ssl_cert_file = ssl_key_file = NULL;
test_server = soup_server_new (SOUP_SERVER_ASYNC_CONTEXT, async_context,
SOUP_SERVER_SSL_CERT_FILE, ssl_cert_file,
SOUP_SERVER_SSL_KEY_FILE, ssl_key_file,
NULL);
if (async_context)
g_main_context_unref (async_context);
if (!test_server) {
fprintf (stderr, "Unable to create server\n");
exit (1);
}
if (in_own_thread) {
server_thread = g_thread_create (run_server_thread, test_server,
TRUE, NULL);
} else
soup_server_run_async (test_server);
return test_server;
}
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. */
while (!g_file_test ("WebKit/gtk/tests/resources/test.html", G_FILE_TEST_EXISTS)) {
char path_name[PATH_MAX];
g_chdir("..");
g_assert(!g_str_equal(getcwd(path_name, PATH_MAX), "/"));
}
g_chdir("WebKit/gtk/tests/resources/");
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);
return g_test_run ();
}
int main(int argc, char* argv[])
{
//ARGH: putting it after g_dbus_node_info_new_for_xml works on Fedora but crashes the XO...
gtk_init(&argc, &argv);
GError *error = NULL;
GOptionContext *context;
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
//g_option_context_add_group (context, gtk_get_option_group (TRUE));
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_print ("option parsing failed: %s\n", error->message);
exit (1);
}
if(bundle_id == NULL || activity_id == NULL)
{
g_print ("bundle-id and activity-id are required options\n");
exit (1);
}
/////////////////////////////////////////////////
introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, NULL);
g_assert (introspection_data != NULL);
gchar service_name[256];
sprintf(service_name, "org.laptop.Activity%s", activity_id);
/*guint owner_id =*/ g_bus_own_name(
G_BUS_TYPE_SESSION, service_name, G_BUS_NAME_OWNER_FLAGS_NONE,
on_bus_acquired, on_name_acquired, on_name_lost,
NULL, NULL);
/////////////////////////////////////////////////
/*
GDBusProxy *journal = g_dbus_proxy_new_for_bus_sync(
G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_NONE, NULL,
"org.laptop.sugar.DataStore",
"/org/laptop/sugar/DataStore",
"org.laptop.sugar.DataStore",
NULL, NULL);
GVariant *params = g_variant_new("(a{sv}as)", NULL, NULL);
//fprintf(stderr, "journal proxy params is %s\n", params == NULL ? "null" : "notnull");
GVariant *result = g_dbus_proxy_call_sync(
journal, "find", params, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
//fprintf(stderr, "journal proxy result is %s\n", result == NULL ? "null" : "notnull");
if(error != NULL) {fprintf(stderr, "error: %d, %d, %s\n", error->domain, error->code, error->message);}
if(result != NULL) {
//fprintf(stderr, "result type: %s\n", g_variant_get_type_string(result));
GVariant *results = NULL;
guint32 count = -1;
g_variant_get(result, "(@aa{sv}u)", &results, &count);
fprintf(stderr, "results is %s, count is %d\n", results == NULL ? "null" : "notnull", count);
//fprintf(stderr, "results type: %s\n", g_variant_get_type_string(results));
GVariant *dictionary = NULL;
GVariantIter results_iter;
g_variant_iter_init(&results_iter, results);
while (g_variant_iter_loop(&results_iter, "@a{sv}", &dictionary)) {
GVariantIter dictionary_iter;
g_variant_iter_init(&dictionary_iter, dictionary);
const char *key = NULL;
GVariant *value = NULL;
while (g_variant_iter_loop(&dictionary_iter, "{s@v}", &key, &value)) {
GVariant *unboxed = g_variant_get_variant(value);
if(strcmp(g_variant_get_type_string(unboxed), "ay") != 0) {
fprintf(stderr, "%s=%s\n", key, g_variant_print(unboxed, TRUE));
} else if(g_variant_n_children(unboxed) < 256) { // skip preview
//ARGH: for some 'clever' reason most of the strings are byte arrays...
fprintf(stderr, "%s=", key);
guchar c;
GVariantIter char_iter;
g_variant_iter_init(&char_iter, unboxed);
while (g_variant_iter_loop(&char_iter, "y", &c)) {
fprintf(stderr, "%c", c);
}
fprintf(stderr, "\n");
}
}
}
}
*/
/////////////////////////////////////////////////
WebKitWebView *webView = WEBKIT_WEB_VIEW(webkit_web_view_new());
/*
guint n = -1, i;
guint *alma = g_signal_list_ids(G_TYPE_FROM_INSTANCE(webView), &n);
for(i=0; i<n; ++i) {
GSignalQuery q;
g_signal_query(alma[i], &q);
printf("alma: %d, %s\n", q.signal_id, q.signal_name);
}
*/
GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL));
gtk_scrolled_window_add_with_viewport(scrolledWindow, GTK_WIDGET(webView));
GtkWidget *main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_decorated(GTK_WINDOW(main_window), FALSE);
gtk_window_maximize(GTK_WINDOW(main_window));
//ARGH: do not use fullscreen as it disables the frame
//gtk_window_fullscreen(GTK_WINDOW(main_window));
gtk_container_add(GTK_CONTAINER(main_window), GTK_WIDGET(scrolledWindow));
g_signal_connect_after(main_window, "realize", G_CALLBACK(afterMainWindowRealized), NULL);
g_signal_connect(main_window, "destroy", G_CALLBACK(destroyWindowCb), NULL);
#ifdef USE_WEBKIT2
g_signal_connect(webView, "close", G_CALLBACK(closeWebViewCb), main_window);
#else
g_signal_connect(webView, "close-web-view", G_CALLBACK(closeWebViewCb), main_window);
/*
//g_signal_connect(webView, "resource-request-starting", G_CALLBACK(resourceRequestStarting), main_window);
SoupSession *session = webkit_get_default_session();
fprintf(stderr, "session is %s\n", session == NULL ? "null" : "notnull");
g_signal_connect(session, "request-started", G_CALLBACK(requestStartedCb), main_window);
*/
#endif
SoupServer *server = soup_server_new(SOUP_SERVER_PORT, 0, NULL); // use some random port
//ARGH: it crashes
// SoupAddress *address = soup_address_new("localhost", 0);
// if(address != NULL) {
// SoupServer *server = soup_server_new(SOUP_SERVER_INTERFACE, address, NULL); // use some random port
// }
guint port = soup_server_get_port(server);
SoupSocket *listener = soup_server_get_listener(server);
SoupAddress *addr = soup_socket_get_local_address(listener);
fprintf(stderr, "server host %s port %d\n", soup_address_get_name(addr), port);
soup_server_add_handler(server, "/activity", serverHandleStatic, NULL, NULL);
soup_server_add_handler(server, "/web", serverHandleStatic, NULL, NULL);
soup_server_add_handler(server, "/journal", serverHandleJournal, NULL, NULL);
// g_signal_connect(server, "request-started", G_CALLBACK(serverRequestStartedCb), NULL);
soup_server_run_async(server);
/*
gchar *current_dir = g_get_current_dir();
gchar index_uri[256];
//ARGH: a file uri always has to be absolute
sprintf(index_uri, "file://%s/index.html", current_dir);
webkit_web_view_load_uri(webView, index_uri);
*/
//webkit_web_view_load_uri(webView, "http://nell-colors.github.cscott.net");
//webkit_web_view_load_uri(webView, "http://index.hu");
gchar buffer[256];
sprintf(buffer, "http://localhost:%d/web/index.html", port);
webkit_web_view_load_uri(webView, buffer);
gtk_widget_grab_focus(GTK_WIDGET(webView));
gtk_widget_show_all(main_window);
gtk_main();
return 0;
}
static gboolean
run (int argc, char **argv, GCancellable *cancellable, GError **error)
{
gboolean ret = FALSE;
g_autoptr(GOptionContext) context = NULL;
const char *dirpath;
OtTrivialHttpd appstruct = { 0, };
OtTrivialHttpd *app = &appstruct;
glnx_unref_object SoupServer *server = NULL;
g_autoptr(GFileMonitor) dirmon = NULL;
context = g_option_context_new ("[DIR] - Simple webserver");
g_option_context_add_main_entries (context, options, NULL);
app->root_dfd = -1;
if (!g_option_context_parse (context, &argc, &argv, error))
goto out;
if (argc > 1)
dirpath = argv[1];
else
dirpath = ".";
if (!glnx_opendirat (AT_FDCWD, dirpath, TRUE, &app->root_dfd, error))
goto out;
if (!(opt_random_500s_percentage >= 0 && opt_random_500s_percentage <= 99))
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Invalid --random-500s=%u", opt_random_500s_percentage);
goto out;
}
if (opt_log)
{
GOutputStream *stream = NULL;
if (g_strcmp0 (opt_log, "-") == 0)
{
if (opt_daemonize)
{
ot_util_usage_error (context, "Cannot use --log-file=- and --daemonize at the same time", error);
goto out;
}
stream = G_OUTPUT_STREAM (g_unix_output_stream_new (STDOUT_FILENO, FALSE));
}
else
{
g_autoptr(GFile) log_file = NULL;
GFileOutputStream* log_stream;
log_file = g_file_new_for_path (opt_log);
log_stream = g_file_create (log_file,
G_FILE_CREATE_PRIVATE,
cancellable,
error);
if (!log_stream)
goto out;
stream = G_OUTPUT_STREAM (log_stream);
}
app->log = stream;
}
#if SOUP_CHECK_VERSION(2, 48, 0)
server = soup_server_new (SOUP_SERVER_SERVER_HEADER, "ostree-httpd ", NULL);
if (!soup_server_listen_all (server, opt_port, 0, error))
goto out;
#else
server = soup_server_new (SOUP_SERVER_PORT, opt_port,
SOUP_SERVER_SERVER_HEADER, "ostree-httpd ",
NULL);
#endif
soup_server_add_handler (server, NULL, httpd_callback, app, NULL);
if (opt_port_file)
{
g_autofree char *portstr = NULL;
#if SOUP_CHECK_VERSION(2, 48, 0)
GSList *listeners = soup_server_get_listeners (server);
g_autoptr(GSocket) listener = NULL;
g_autoptr(GSocketAddress) addr = NULL;
g_assert (listeners);
listener = g_object_ref (listeners->data);
g_slist_free (listeners);
listeners = NULL;
addr = g_socket_get_local_address (listener, error);
if (!addr)
goto out;
g_assert (G_IS_INET_SOCKET_ADDRESS (addr));
portstr = g_strdup_printf ("%u\n", g_inet_socket_address_get_port ((GInetSocketAddress*)addr));
#else
portstr = g_strdup_printf ("%u\n", soup_server_get_port (server));
#endif
if (g_strcmp0 ("-", opt_port_file) == 0)
{
fputs (portstr, stdout); // not g_print - this must go to stdout, not a handler
fflush (stdout);
}
else if (!g_file_set_contents (opt_port_file, portstr, strlen (portstr), error))
goto out;
}
#if !SOUP_CHECK_VERSION(2, 48, 0)
soup_server_run_async (server);
#endif
if (opt_daemonize)
{
pid_t pid = fork();
if (pid == -1)
{
int errsv = errno;
g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (errsv),
g_strerror (errsv));
goto out;
}
else if (pid > 0)
{
ret = TRUE;
goto out;
}
/* Child, continue */
if (setsid () < 0)
err (1, "setsid");
/* Daemonising: close stdout/stderr so $() et al work on us */
if (freopen("/dev/null", "r", stdin) == NULL)
err (1, "freopen");
if (freopen("/dev/null", "w", stdout) == NULL)
err (1, "freopen");
if (freopen("/dev/null", "w", stderr) == NULL)
err (1, "freopen");
}
else
{
/* Since we're used for testing purposes, let's just do this by
* default. This ensures we exit when our parent does.
*/
if (prctl (PR_SET_PDEATHSIG, SIGTERM) != 0)
{
if (errno != ENOSYS)
{
glnx_set_error_from_errno (error);
goto out;
}
}
}
app->running = TRUE;
if (opt_autoexit)
{
gboolean is_symlink = FALSE;
g_autoptr(GFile) root = NULL;
g_autoptr(GFileInfo) info = NULL;
root = g_file_new_for_path (dirpath);
info = g_file_query_info (root,
G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
cancellable, error);
if (!info)
goto out;
is_symlink = g_file_info_get_is_symlink (info);
if (is_symlink)
dirmon = g_file_monitor_file (root, 0, cancellable, error);
else
dirmon = g_file_monitor_directory (root, 0, cancellable, error);
if (!dirmon)
goto out;
g_signal_connect (dirmon, "changed", G_CALLBACK (on_dir_changed), app);
}
httpd_log (app, "serving at root %s\n", dirpath);
while (app->running)
g_main_context_iteration (NULL, TRUE);
ret = TRUE;
out:
if (app->root_dfd != -1)
(void) close (app->root_dfd);
g_clear_object (&app->log);
return ret;
}
void WebKitTestServer::run(SoupServerCallback serverCallback)
{
soup_server_run_async(m_soupServer.get());
soup_server_add_handler(m_soupServer.get(), 0, serverCallback, 0, 0);
}
gboolean
rcd_rpc_remote_server_start (void)
{
SoupServerAuthContext auth_ctx = { 0 };
int port = rcd_prefs_get_remote_server_port ();
const char *bind_ip;
/* Server's already running... */
if (soup_server != NULL)
return TRUE;
rc_debug (RC_DEBUG_LEVEL_MESSAGE, "Starting remote server");
bind_ip = rcd_prefs_get_bind_ipaddress ();
if (bind_ip) {
SoupAddress *bind_address;
bind_address = soup_address_new (bind_ip, port);
if (!bind_address) {
rc_debug (RC_DEBUG_LEVEL_ERROR,
"Unable to bind remote server to '%s'", bind_ip);
return FALSE;
}
if (soup_address_resolve_sync (bind_address) != SOUP_STATUS_OK) {
rc_debug (RC_DEBUG_LEVEL_ERROR,
"Unable to bind remote server to '%s': Unable to "
"resolve address", bind_ip);
return FALSE;
}
soup_server = soup_server_new (SOUP_SERVER_INTERFACE, bind_address,
SOUP_SERVER_PORT, port,
SOUP_SERVER_SSL_CERT_FILE, SHAREDIR"/rcd.pem",
SOUP_SERVER_SSL_KEY_FILE, SHAREDIR"/rcd.pem",
NULL);
g_object_unref (bind_address);
} else {
soup_server = soup_server_new (SOUP_SERVER_PORT, port,
SOUP_SERVER_SSL_CERT_FILE, SHAREDIR"/rcd.pem",
SOUP_SERVER_SSL_KEY_FILE, SHAREDIR"/rcd.pem",
NULL);
}
if (!soup_server) {
rc_debug (RC_DEBUG_LEVEL_ERROR, "Could not start RPC server on port %d", port);
rc_debug (RC_DEBUG_LEVEL_ERROR, "(This may mean that another rcd process is already running, or that");
rc_debug (RC_DEBUG_LEVEL_ERROR, "you are not running as root and do not have the correct privileges");
rc_debug (RC_DEBUG_LEVEL_ERROR, "on this port.)");
return FALSE;
}
g_object_set (G_OBJECT (soup_server_get_listener (soup_server)),
SOUP_SOCKET_FLAG_CLOEXEC, TRUE,
NULL);
auth_ctx.types = SOUP_AUTH_TYPE_DIGEST;
auth_ctx.callback = soup_auth_callback;
auth_ctx.digest_info.realm = "RCD";
auth_ctx.digest_info.allow_algorithms = SOUP_ALGORITHM_MD5;
auth_ctx.digest_info.force_integrity = FALSE;
soup_server_add_handler (soup_server, "/RPC2", &auth_ctx,
soup_rpc_callback, NULL, NULL);
soup_server_add_handler (soup_server, NULL, NULL,
soup_default_callback, NULL, NULL);
soup_server_run_async (soup_server);
g_object_unref (soup_server);
notify_port_change (port);
return TRUE;
}
