static void
resolve_callback (SoupAddress *addr, guint status, gpointer data)
{
if (status == SOUP_STATUS_OK) {
printf ("Name: %s\n", soup_address_get_name (addr));
printf ("Address: %s\n", soup_address_get_physical (addr));
} else {
printf ("Name: %s\n", soup_address_get_name (addr));
printf ("Error: %s\n", soup_status_get_phrase (status));
}
printf ("\n");
nlookups--;
if (nlookups == 0)
g_main_loop_quit (loop);
}
static void
on_address_resolved_complete (SoupAddress *address,
guint status,
gpointer user_data)
{
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (g_async_result_get_source_object (user_data));
source_connect_closure *closure = g_simple_async_result_get_op_res_gpointer (res);
gchar *server;
g_object_get (self, "key-server", &server, NULL);
g_return_if_fail (server && server[0]);
seahorse_progress_update (closure->cancellable, res, _("Connecting to: %s"), server);
g_free (server);
/* DNS failed */
if (!SOUP_STATUS_IS_SUCCESSFUL (status)) {
g_simple_async_result_set_error (res, SEAHORSE_ERROR, -1,
_("Couldn’t resolve address: %s"),
soup_address_get_name (address));
g_simple_async_result_complete_in_idle (res);
/* Yay resolved */
} else {
once_resolved_start_connect (self, res, soup_address_get_physical (address));
}
g_object_unref (res);
}
static SoupURI *
uri_from_address (SoupAddress *addr)
{
SoupURI *proxy_uri;
proxy_uri = soup_uri_new (NULL);
soup_uri_set_scheme (proxy_uri, SOUP_URI_SCHEME_HTTP);
soup_uri_set_host (proxy_uri, soup_address_get_name (addr));
soup_uri_set_port (proxy_uri, soup_address_get_port (addr));
return proxy_uri;
}
gboolean
soup_connection_start_ssl (SoupConnection *conn)
{
SoupConnectionPrivate *priv;
const char *server_name;
g_return_val_if_fail (SOUP_IS_CONNECTION (conn), FALSE);
priv = SOUP_CONNECTION_GET_PRIVATE (conn);
server_name = soup_address_get_name (priv->tunnel_addr ?
priv->tunnel_addr :
priv->remote_addr);
return soup_socket_start_proxy_ssl (priv->socket, server_name, NULL);
}
SoupMessageQueueItem *
soup_session_make_connect_message (SoupSession *session,
SoupAddress *server_addr)
{
SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
SoupURI *uri;
SoupMessage *msg;
uri = soup_uri_new (NULL);
soup_uri_set_scheme (uri, SOUP_URI_SCHEME_HTTPS);
soup_uri_set_host (uri, soup_address_get_name (server_addr));
soup_uri_set_port (uri, soup_address_get_port (server_addr));
soup_uri_set_path (uri, "");
msg = soup_message_new_from_uri (SOUP_METHOD_CONNECT, uri);
soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT);
soup_uri_free (uri);
/* Call the base implementation of soup_session_queue_message
* directly, to add msg to the SoupMessageQueue and cause all
* the right signals to be emitted.
*/
queue_message (session, msg, tunnel_connected, NULL);
return soup_message_queue_lookup (priv->queue, msg);
}
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;
}
