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 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[])
{
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;
}
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;
}
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);
}
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)
{
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 ();
}
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)
{
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)
{
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)
{
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;
}
static SoupServer *
get_http_server (int port)
{
SoupAddress *if6;
SoupServer *server;
if6 = soup_address_new_any (SOUP_ADDRESS_FAMILY_IPV6, port);
server = soup_server_new (SOUP_SERVER_INTERFACE, if6, SOUP_SERVER_PORT,
port, NULL);
g_object_unref (if6);
if (server)
return server;
/* try again with just IPv4 */
server = soup_server_new (SOUP_SERVER_PORT, port, NULL);
return server;
}
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;
}
int main()
{
SoupServer *server;
GError *error;
server = soup_server_new (SOUP_SERVER_SERVER_HEADER, "simple-httpd ", SOUP_SERVER_TLS_CERTIFICATE, NULL, NULL);
soup_server_listen_all (server, 1234, SOUP_SERVER_LISTEN_HTTPS, &error);
return 0;
}
int main()
{
g_type_init();
SoupServer *server = soup_server_new (
SOUP_SERVER_PORT, 3000,
NULL);
soup_server_add_handler (server, NULL, (SoupServerCallback) server_callback,
NULL,NULL);
btree = btree_open("/tmp/badger", 0, 0666);
soup_server_run(server);
}
static void
remote_display_host_init (RemoteDisplayHost *host)
{
RemoteDisplayHostPrivate *priv;
priv = GET_PRIVATE (host);
priv->files = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, (GDestroyNotify) file_free);
priv->server = soup_server_new (NULL, NULL);
soup_server_add_handler (priv->server, NULL,
server_callback, host, NULL);
}
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);
}
SoupServer *
soupcut_server_take_new (GMainContext *context)
{
SoupServer *server;
SoupAddress *address;
address = soup_address_new("localhost", SOUP_ADDRESS_ANY_PORT);
soup_address_resolve_sync(address, NULL);
server = soup_server_new(SOUP_SERVER_INTERFACE, address,
SOUP_SERVER_ASYNC_CONTEXT, context,
NULL);
g_object_unref(address);
return soupcut_server_take(server);
}
void trap_init(void)
{
GError *error = NULL;
SoupServer *server;
server = soup_server_new(SOUP_SERVER_SERVER_HEADER,
"TRAP-1.0", NULL);
soup_server_listen_all(server, 1373,
SOUP_SERVER_LISTEN_IPV4_ONLY, &error);
if (error) {
g_critical("Unable to create soup server: %s\n", error->message);
exit(1);
}
soup_server_add_handler(server, NULL, trap_callback, NULL, NULL);
}
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;
}
WebKitTestServer::WebKitTestServer(ServerType type)
{
GUniquePtr<char> sslCertificateFile;
GUniquePtr<char> sslKeyFile;
if (type == ServerHTTPS) {
CString resourcesDir = Test::getResourcesDir();
sslCertificateFile.reset(g_build_filename(resourcesDir.data(), "test-cert.pem", NULL));
sslKeyFile.reset(g_build_filename(resourcesDir.data(), "test-key.pem", NULL));
}
GRefPtr<SoupAddress> address = adoptGRef(soup_address_new("127.0.0.1", SOUP_ADDRESS_ANY_PORT));
soup_address_resolve_sync(address.get(), 0);
m_soupServer = adoptGRef(soup_server_new(SOUP_SERVER_INTERFACE, address.get(),
SOUP_SERVER_SSL_CERT_FILE, sslCertificateFile.get(),
SOUP_SERVER_SSL_KEY_FILE, sslKeyFile.get(), nullptr));
m_baseURI = type == ServerHTTPS ? soup_uri_new("https://127.0.0.1/") : soup_uri_new("http://127.0.0.1/");
soup_uri_set_port(m_baseURI, soup_server_get_port(m_soupServer.get()));
}
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);
}
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;
}
int
main (int argc, char **argv)
{
GOptionContext *opts;
GMainLoop *loop;
SoupServer *server;
GSList *uris, *u;
char *str;
GTlsCertificate *cert;
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);
if (tls_cert_file && tls_key_file) {
cert = g_tls_certificate_new_from_files (tls_cert_file, tls_key_file, &error);
if (error) {
g_printerr ("Unable to create server: %s\n", error->message);
exit (1);
}
server = soup_server_new (SOUP_SERVER_SERVER_HEADER, "simple-httpd ",
SOUP_SERVER_TLS_CERTIFICATE, cert,
NULL);
g_object_unref (cert);
soup_server_listen_all (server, port, SOUP_SERVER_LISTEN_HTTPS, &error);
} else {
server = soup_server_new (SOUP_SERVER_SERVER_HEADER, "simple-httpd ",
NULL);
soup_server_listen_all (server, port, 0, &error);
}
soup_server_add_handler (server, NULL,
server_callback, NULL, NULL);
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);
g_print ("\nWaiting for requests...\n");
loop = g_main_loop_new (NULL, TRUE);
g_main_loop_run (loop);
return 0;
}
