static gboolean
gst_soup_http_src_start (GstBaseSrc * bsrc)
{
GstSoupHTTPSrc *src = GST_SOUP_HTTP_SRC (bsrc);
GST_DEBUG_OBJECT (src, "start(\"%s\")", src->location);
if (!src->location) {
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (_("No URL set.")),
("Missing location property"));
return FALSE;
}
src->context = g_main_context_new ();
src->loop = g_main_loop_new (src->context, TRUE);
if (!src->loop) {
GST_ELEMENT_ERROR (src, LIBRARY, INIT,
(NULL), ("Failed to start GMainLoop"));
g_main_context_unref (src->context);
return FALSE;
}
if (src->proxy == NULL) {
src->session =
soup_session_async_new_with_options (SOUP_SESSION_ASYNC_CONTEXT,
src->context, SOUP_SESSION_USER_AGENT, src->user_agent,
SOUP_SESSION_TIMEOUT, src->timeout,
#ifdef HAVE_LIBSOUP_GNOME
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_PROXY_RESOLVER_GNOME,
#endif
NULL);
} else {
src->session =
soup_session_async_new_with_options (SOUP_SESSION_ASYNC_CONTEXT,
src->context, SOUP_SESSION_PROXY_URI, src->proxy,
SOUP_SESSION_TIMEOUT, src->timeout,
SOUP_SESSION_USER_AGENT, src->user_agent, NULL);
}
if (!src->session) {
GST_ELEMENT_ERROR (src, LIBRARY, INIT,
(NULL), ("Failed to create async session"));
return FALSE;
}
g_signal_connect (src->session, "authenticate",
G_CALLBACK (gst_soup_http_src_authenticate_cb), src);
return TRUE;
}
SoupSession *
open_app_soup_session_new (gboolean sync, gchar *cafile)
{
SoupSession *session;
if (sync) {
session = soup_session_sync_new_with_options (
SOUP_SESSION_SSL_CA_FILE, cafile,
#ifdef HAVE_GNOME
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_GNOME_FEATURES_2_26,
#endif
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_COOKIE_JAR,
SOUP_SESSION_USER_AGENT, "get ",
SOUP_SESSION_ACCEPT_LANGUAGE_AUTO, TRUE,
NULL);
} else {
session = soup_session_async_new_with_options (
SOUP_SESSION_SSL_CA_FILE, cafile,
#ifdef HAVE_GNOME
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_GNOME_FEATURES_2_26,
#endif
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_COOKIE_JAR,
SOUP_SESSION_USER_AGENT, "get ",
SOUP_SESSION_ACCEPT_LANGUAGE_AUTO, TRUE,
NULL);
}
return session;
}
void
XCAP::CoreImpl::erase (gmref_ptr<Path> path,
sigc::slot1<void,std::string> callback)
{
SoupSession* session = NULL;
SoupMessage* message = NULL;
cb_other_data* data = NULL;
clear_old_sessions ();
/* all of this is freed in the result callback */
session = soup_session_async_new_with_options ("user-agent", "ekiga", NULL);
message = soup_message_new ("DELETE", path->to_uri ().c_str ());
data = new cb_other_data;
data->core = this;
data->path = path;
data->callback = callback;
g_signal_connect (session, "authenticate",
G_CALLBACK (authenticate_other_callback), data);
soup_session_queue_message (session, message,
result_other_callback, data);
pending_sessions.push_back (session);
}
void
XCAP::CoreImpl::read (boost::shared_ptr<Path> path,
boost::function2<void, bool, std::string> callback)
{
SoupSession* session = NULL;
SoupMessage* message = NULL;
cb_read_data* data = NULL;
clear_old_sessions ();
/* all of this is freed in the result callback */
session = soup_session_async_new_with_options ("user-agent", "ekiga", NULL);
message = soup_message_new ("GET", path->to_uri ().c_str ());
data = new cb_read_data;
data->core = this;
data->path = path;
data->callback = callback;
g_signal_connect (session, "authenticate",
G_CALLBACK (authenticate_read_callback), data);
soup_session_queue_message (session, message,
result_read_callback, data);
pending_sessions.push_back (session);
}
int main(int argc, char *argv[]) {
GtkWidget *window;
g_type_init();
gtk_init(&argc, &argv);
builder = gtk_builder_new();
gtk_builder_add_from_file(builder, "gfer.ui", NULL);
window = GTK_WIDGET(gtk_builder_get_object(builder, "mainwin"));
gtk_builder_connect_signals(builder, NULL);
gtk_widget_show(window);
session = soup_session_async_new_with_options(
SOUP_SESSION_ADD_FEATURE, SOUP_SESSION_FEATURE(soup_cookie_jar_text_new("/home/mihai/.cookies/rapidshare", TRUE)),
NULL
);
// Monitor clipboard
g_signal_connect(G_OBJECT(window), "selection-received", G_CALLBACK(selection_received), NULL);
g_timeout_add(250, clipboard_timeout, window);
gtk_main();
g_object_unref(G_OBJECT(builder));
return 0;
}
static SoupSession *
create_hkp_soup_session (void)
{
SoupSession *session;
#if WITH_DEBUG
SoupLogger *logger;
const gchar *env;
#endif
session = soup_session_async_new_with_options (SOUP_SESSION_ADD_FEATURE_BY_TYPE,
SOUP_TYPE_PROXY_RESOLVER_DEFAULT,
NULL);
#if WITH_DEBUG
env = g_getenv ("G_MESSAGES_DEBUG");
if (env && strstr (env, "seahorse")) {
logger = soup_logger_new (SOUP_LOGGER_LOG_BODY, -1);
soup_session_add_feature (session, SOUP_SESSION_FEATURE (logger));
g_object_unref (logger);
}
#endif
return session;
}
static void
impl_start (RBPodcastSearch *bsearch, const char *text, int max_results)
{
SoupURI *uri;
SoupMessage *message;
char *limit;
RBPodcastSearchITunes *search = RB_PODCAST_SEARCH_ITUNES (bsearch);
search->session = soup_session_async_new_with_options (SOUP_SESSION_ADD_FEATURE_BY_TYPE,
SOUP_TYPE_PROXY_RESOLVER_DEFAULT,
NULL);
uri = soup_uri_new (ITUNES_SEARCH_URI);
limit = g_strdup_printf ("%d", max_results);
soup_uri_set_query_from_fields (uri,
"term", text,
"media", "podcast",
"entity", "podcast",
"limit", limit,
"version", "2",
"output", "json",
NULL);
g_free (limit);
message = soup_message_new_from_uri (SOUP_METHOD_GET, uri);
soup_uri_free (uri);
soup_session_queue_message (search->session, message, (SoupSessionCallback) search_response_cb, search);
}
int
main (int argc, char **argv)
{
SoupSession *session;
SoupURI *proxy = NULL;
SoupMessage *msg;
const char *uri = "http://bugzilla.redhat.com/bugzilla/xmlrpc.cgi";
int opt, bug;
g_thread_init (NULL);
g_type_init ();
while ((opt = getopt (argc, argv, "p:")) != -1) {
switch (opt) {
case 'p':
proxy = soup_uri_new (optarg);
if (!proxy) {
fprintf (stderr, "Could not parse %s as URI\n",
optarg);
exit (1);
}
break;
case '?':
usage ();
break;
}
}
argc -= optind;
argv += optind;
if (argc > 1) {
uri = argv[0];
argc--;
argv++;
}
if (argc != 1 || (bug = atoi (argv[0])) == 0)
usage ();
session = soup_session_async_new_with_options (
SOUP_SESSION_PROXY_URI, proxy,
NULL);
msg = soup_xmlrpc_request_new (uri, "bugzilla.getBug",
G_TYPE_INT, bug,
G_TYPE_INVALID);
if (!msg) {
fprintf (stderr, "Could not create web service request to '%s'\n", uri);
exit (1);
}
soup_session_queue_message (session, SOUP_MESSAGE (msg),
got_response, NULL);
loop = g_main_loop_new (NULL, TRUE);
g_main_loop_run (loop);
g_main_loop_unref (loop);
return 0;
}
static void
impl_start (RBPodcastSearch *bsearch, const char *text, int max_results)
{
SoupURI *uri;
SoupMessage *message;
char *limit;
RBPodcastSearchMiroGuide *search = RB_PODCAST_SEARCH_MIROGUIDE (bsearch);
search->session = soup_session_async_new_with_options (SOUP_SESSION_ADD_FEATURE_BY_TYPE,
SOUP_TYPE_PROXY_RESOLVER_DEFAULT,
NULL);
uri = soup_uri_new (MIROGUIDE_SEARCH_URI);
limit = g_strdup_printf ("%d", max_results);
soup_uri_set_query_from_fields (uri,
"filter", "audio",
"filter_value", "1",
"filter", "name",
"filter_value", text,
"sort", "popular", /* hmm */
"limit", limit,
"datatype", "json",
NULL);
g_free (limit);
message = soup_message_new_from_uri (SOUP_METHOD_GET, uri);
soup_uri_free (uri);
soup_session_queue_message (search->session, message, (SoupSessionCallback) search_response_cb, search);
}
static void
nm_connectivity_init (NMConnectivity *self)
{
NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self);
priv->soup_session = soup_session_async_new_with_options (SOUP_SESSION_TIMEOUT, 15, NULL);
}
void
XCAP::CoreImpl::write (boost::shared_ptr<Path> path,
const std::string content_type,
const std::string content,
boost::function1<void,std::string> callback)
{
SoupSession* session = NULL;
SoupMessage* message = NULL;
cb_other_data* data = NULL;
clear_old_sessions ();
/* all of this is freed in the result callback */
session = soup_session_async_new_with_options ("user-agent", "ekiga", NULL);
message = soup_message_new ("PUT", path->to_uri ().c_str ());
soup_message_set_request (message, content_type.c_str (),
SOUP_MEMORY_COPY,
content.c_str (), content.length ());
data = new cb_other_data;
data->core = this;
data->path = path;
data->callback = callback;
g_signal_connect (session, "authenticate",
G_CALLBACK (authenticate_other_callback), data);
soup_session_queue_message (session, message,
result_other_callback, data);
pending_sessions.push_back (session);
}
static void
aur_client_constructed (GObject * object)
{
AurClient *client = (AurClient *) (object);
gint max_con = 1;
if (G_OBJECT_CLASS (aur_client_parent_class)->constructed != NULL)
G_OBJECT_CLASS (aur_client_parent_class)->constructed (object);
client->soup =
soup_session_async_new_with_options (SOUP_SESSION_ASYNC_CONTEXT,
client->context, NULL);
g_assert (client->soup);
if (!g_strcmp0 ("1", g_getenv ("AURENA_DEBUG")))
soup_session_add_feature (client->soup,
SOUP_SESSION_FEATURE (soup_logger_new (SOUP_LOGGER_LOG_BODY, -1)));
/* Set a 20 second timeout on pings from the server */
g_object_set (G_OBJECT (client->soup), "idle-timeout", 20, NULL);
/* 5 second timeout before retrying with new connections */
g_object_set (G_OBJECT (client->soup), "timeout", 5, NULL);
if (client->flags & AUR_CLIENT_PLAYER)
max_con++;
if (client->flags & AUR_CLIENT_CONTROLLER)
max_con++;
g_object_set (client->soup, "max-conns-per-host", max_con, NULL);
try_reconnect (client);
}
void xmlrpc_init(void)
{
if (!loop) {
loop = g_main_loop_new(FALSE, FALSE);
}
if (!session) {
session = soup_session_async_new_with_options(SOUP_SESSION_TIMEOUT, 10, NULL);
}
}
static void
roadmap_engine_init (RoadmapEngine *self)
{
RoadmapEnginePrivate *priv;
priv = ROADMAP_ENGINE_GET_PRIVATE(self);
/* TODO: Move the NTLM use to a configurable option in the preferences dialog */
priv->session = soup_session_async_new_with_options (SOUP_SESSION_USE_NTLM, TRUE, NULL);
g_signal_connect (priv->session, "authenticate", G_CALLBACK (engine_authenticate_cb), self);
}
static void
seahorse_hkp_operation_init (SeahorseHKPOperation *hop)
{
SoupURI *uri;
gchar *host;
#if DEBUG_HKP_ENABLE
SoupLogger *logger;
#endif
if (seahorse_gconf_get_boolean (GCONF_USE_HTTP_PROXY)) {
host = seahorse_gconf_get_string (GCONF_HTTP_PROXY_HOST);
if (host) {
uri = soup_uri_new (NULL);
if (!uri) {
g_warning ("creation of SoupURI from '%s' failed", host);
} else {
soup_uri_set_scheme (uri, SOUP_URI_SCHEME_HTTP);
soup_uri_set_host (uri, host);
g_free (host);
soup_uri_set_port (uri, seahorse_gconf_get_integer (GCONF_PROXY_PORT));
if (seahorse_gconf_get_boolean (GCONF_USE_AUTH)) {
char *user, *pass;
user = seahorse_gconf_get_string (GCONF_AUTH_USER);
soup_uri_set_user (uri, user);
g_free (user);
pass = seahorse_gconf_get_string (GCONF_AUTH_PASS);
soup_uri_set_password (uri, pass);
g_free (pass);
}
hop->session = soup_session_async_new_with_options (SOUP_SESSION_PROXY_URI, uri, NULL);
soup_uri_free (uri);
}
}
}
/* Without a proxy */
if (!hop->session)
hop->session = soup_session_async_new ();
#if DEBUG_HKP_ENABLE
logger = soup_logger_new (SOUP_LOGGER_LOG_BODY, -1);
soup_logger_attach (logger, hop->session);
g_object_unref (logger);
#endif
}
void
http_client_init(void)
{
g_type_init();
g_thread_init(NULL);
if (file_config.proxy != NULL)
http_client.proxy = soup_uri_new(file_config.proxy);
else
http_client.proxy = NULL;
http_client.session =
soup_session_async_new_with_options(SOUP_SESSION_PROXY_URI,
http_client.proxy, NULL);
}
void
network_init (void)
{
gchar *useragent;
SoupCookieJar *cookies;
gchar *filename;
SoupLogger *logger;
SoupURI *proxy;
/* Set an appropriate user agent */
if (g_getenv ("LANG")) {
/* e.g. "Liferea/1.6.0 (Linux; de_DE; http://liferea.sf.net/)" */
useragent = g_strdup_printf ("Liferea/%s (%s; %s; %s)", VERSION, OSNAME, g_getenv ("LANG"), HOMEPAGE);
} else {
/* e.g. "Liferea/1.6.0 (Linux; http://liferea.sf.net/)" */
useragent = g_strdup_printf ("Liferea/%s (%s; %s)", VERSION, OSNAME, HOMEPAGE);
}
/* Cookies */
filename = common_create_cache_filename ("", "cookies", "txt");
cookies = soup_cookie_jar_text_new (filename, FALSE);
g_free (filename);
/* Initialize libsoup */
proxy = network_get_proxy_uri ();
session = soup_session_async_new_with_options (SOUP_SESSION_USER_AGENT, useragent,
SOUP_SESSION_TIMEOUT, 120,
SOUP_SESSION_IDLE_TIMEOUT, 30,
SOUP_SESSION_PROXY_URI, proxy,
SOUP_SESSION_ADD_FEATURE, cookies,
NULL);
if (proxy)
soup_uri_free (proxy);
g_signal_connect (session, "authenticate", G_CALLBACK (network_authenticate), NULL);
/* Soup debugging */
if (debug_level & DEBUG_NET) {
logger = soup_logger_new (SOUP_LOGGER_LOG_HEADERS, -1);
soup_session_add_feature (session, SOUP_SESSION_FEATURE (logger));
}
g_free (useragent);
}
static void
mex_download_queue_init (MexDownloadQueue *self)
{
MexDownloadQueuePrivate *priv = GET_PRIVATE (self);
self->priv = priv;
priv->queue = g_queue_new ();
priv->max_transfers = 3;
priv->session = soup_session_async_new_with_options (
#ifdef HAVE_LIBSOUP_GNOME
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_GNOME_FEATURES_2_26,
#endif
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_COOKIE_JAR,
SOUP_SESSION_ACCEPT_LANGUAGE_AUTO, TRUE,
NULL);
priv->cache = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free,
(GDestroyNotify) mex_download_queue_cache_item_free);
}
static void sync_dialog_start_sync(SyncDialog * sd)
{
gint nactions;
SyncNetAction *actions;
if (!session) {
SoupUri *proxy = sync_manager_get_proxy();
session =
soup_session_async_new_with_options(SOUP_SESSION_TIMEOUT, 10,
SOUP_SESSION_PROXY_URI,
proxy, NULL);
/* Crashes if we unref the proxy? O_o */
/*if (proxy)
g_object_unref(proxy); */
}
loop = g_main_loop_new(NULL, TRUE);
gtk_widget_hide(sd->button_sync);
sync_dialog_netarea_show(sd);
g_signal_connect(G_OBJECT(sd->button_cancel), "clicked",
(GCallback) _cancel_sync, sd);
actions = sync_manager_get_selected_actions(&nactions);
sync_dialog_netarea_start_actions(sd, actions, nactions);
g_free(actions);
if (sd->flag_cancel) {
gtk_widget_hide(sd->button_cancel);
gtk_widget_show(sd->button_close);
/* wait for the user to close the dialog */
g_main_run(loop);
}
g_main_loop_unref(loop);
}
int main (int argc, char *argv[])
{
#ifndef WIN32
// Do not run as root.
if (getuid () == 0) {
cout << "Bibledit-Xiphos has not been designed to run with root privileges." << endl;
return 1;
}
#endif
// The necessary g* initializers, in the proper order.
g_thread_init(NULL);
g_type_init ();
gtk_init (&argc, &argv);
gchar * iconfile = g_build_filename (PACKAGE_DATA_DIR, "bibledit-xiphos.xpm", NULL);
gtk_window_set_default_icon_from_file(iconfile, NULL);
g_free (iconfile);
// Initialize variables.
event_id_rescan_bus = 0;
last_message_id = "0";
quit = false;
// Read settings.
GKeyFile *keyfile = g_key_file_new();
gchar * key_file_name = registry_file_name ();
g_key_file_load_from_file(keyfile, key_file_name, G_KEY_FILE_NONE, NULL);
g_free (key_file_name);
GtkBuilder *gtkbuilder;
gtkbuilder = gtk_builder_new ();
gchar * filename = g_build_filename (PACKAGE_DATA_DIR, "gtkbuilder.xml", NULL);
gtk_builder_add_from_file (gtkbuilder, filename, NULL);
g_free (filename);
window = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "window"));
g_signal_connect ((gpointer) window, "delete_event", G_CALLBACK (quit_program), NULL);
gtk_widget_show_all (window);
entry_url = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "entry_url"));
gchar * url = g_key_file_get_string (keyfile, "settings", "bibledit-web-url", NULL);
if (!url) {
url = strdup ("http://localhost/bibledit");
}
gtk_entry_set_text (GTK_ENTRY (entry_url), url);
g_free (url);
g_signal_connect((gpointer) entry_url, "changed", G_CALLBACK(on_entry_url_changed), NULL);
button_url = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "button_url"));
g_signal_connect((gpointer) button_url, "clicked", G_CALLBACK(on_button_url_clicked), NULL);
label_url = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_url"));
entry_user = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "entry_user"));
gchar * user = g_key_file_get_string (keyfile, "settings", "bibledit-web-user", NULL);
if (!user) {
user = strdup ("");
}
gtk_entry_set_text (GTK_ENTRY (entry_user), user);
g_free (user);
g_signal_connect((gpointer) entry_user, "changed", G_CALLBACK(on_entry_user_changed), NULL);
label_xiphos_process = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_xiphos_process"));
label_id = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_id"));
label_command = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_command"));
label_body = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_body"));
label_xiphos = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_xiphos"));
button_hide = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "button_hide"));
g_signal_connect((gpointer) button_hide, "clicked", G_CALLBACK(on_button_hide_clicked), NULL);
g_key_file_free (keyfile);
// We use asynchronous transport, so that we can send several messages simultanously.
session = soup_session_async_new_with_options (SOUP_SESSION_USER_AGENT, "bibledit-xiphos/1.0", NULL);
start_xiphos_web_listener ();
// Obtain a connection to the Session Bus.
GError *error = NULL;
sigcon = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
if(sigcon) {
con = dbus_g_connection_get_connection(sigcon);
} else {
printf ("%s\n", error->message);
fflush (stdout);
g_error_free(error);
return 1;
}
// Request our name on the DBus.
if (con) {
DBusError *dbuserror = NULL;
int retval = dbus_bus_request_name(con, "org.bibledit.xiphos", 0, dbuserror);
if (retval != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
if (dbus_error_is_set(dbuserror)) {
printf ("%s\n", dbuserror->message);
fflush (stdout);
dbus_error_free(dbuserror);
}
}
}
// Connect to a couple of signals that indicate applications have started or have exited.
// Then a rescan of the bus can show whether the programs that we're interested in run.
proxy = NULL;
if (sigcon)
proxy = dbus_g_proxy_new_for_name(sigcon, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus");
if (proxy) {
dbus_g_proxy_add_signal(proxy, "NameAcquired", G_TYPE_STRING, G_TYPE_INVALID);
dbus_g_proxy_connect_signal(proxy, "NameAcquired", G_CALLBACK (on_name_acquired), NULL, NULL);
dbus_g_proxy_add_signal(proxy, "NameOwnerChanged", G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID);
dbus_g_proxy_connect_signal(proxy, "NameOwnerChanged", G_CALLBACK (on_name_owner_changed), NULL, NULL);
dbus_g_proxy_add_signal(proxy, "NameLost", G_TYPE_STRING, G_TYPE_INVALID);
dbus_g_proxy_connect_signal(proxy, "NameLost", G_CALLBACK (on_name_lost), NULL, NULL);
}
// Signal trapping for doing a clean exit.
signal(SIGINT, sigproc);
signal(SIGQUIT, sigquit);
// Main loop.
gtk_main();
// Destroy any pending timeout.
destroy_source(event_id_rescan_bus);
// Abort the session including the listeners
soup_session_abort (session);
// The connection obtained through dbus_g_connection_get_connection does not have its reference count incremented.
// Therefore it should not be unreferenced.
// dbus_connection_unref(con);
// Destroy the proxy.
if (proxy) {
g_object_unref(proxy);
}
// Well done.
return 0;
}
static gboolean
gst_soup_http_client_sink_start (GstBaseSink * sink)
{
GstSoupHttpClientSink *souphttpsink = GST_SOUP_HTTP_CLIENT_SINK (sink);
if (souphttpsink->prop_session) {
souphttpsink->session = souphttpsink->prop_session;
} else {
GSource *source;
GError *error = NULL;
souphttpsink->context = g_main_context_new ();
/* set up idle source to signal when the main loop is running and
* it's safe for ::stop() to call g_main_loop_quit() */
source = g_idle_source_new ();
g_source_set_callback (source, thread_ready_idle_cb, sink, NULL);
g_source_attach (source, souphttpsink->context);
g_source_unref (source);
souphttpsink->loop = g_main_loop_new (souphttpsink->context, TRUE);
g_mutex_lock (&souphttpsink->mutex);
souphttpsink->thread = g_thread_try_new ("souphttpclientsink-thread",
thread_func, souphttpsink, &error);
if (error != NULL) {
GST_DEBUG_OBJECT (souphttpsink, "failed to start thread, %s",
error->message);
g_error_free (error);
g_mutex_unlock (&souphttpsink->mutex);
return FALSE;
}
GST_LOG_OBJECT (souphttpsink, "waiting for main loop thread to start up");
g_cond_wait (&souphttpsink->cond, &souphttpsink->mutex);
g_mutex_unlock (&souphttpsink->mutex);
GST_LOG_OBJECT (souphttpsink, "main loop thread running");
if (souphttpsink->proxy == NULL) {
souphttpsink->session =
soup_session_async_new_with_options (SOUP_SESSION_ASYNC_CONTEXT,
souphttpsink->context, SOUP_SESSION_USER_AGENT,
souphttpsink->user_agent, SOUP_SESSION_TIMEOUT, souphttpsink->timeout,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_PROXY_RESOLVER_DEFAULT,
NULL);
} else {
souphttpsink->session =
soup_session_async_new_with_options (SOUP_SESSION_ASYNC_CONTEXT,
souphttpsink->context, SOUP_SESSION_USER_AGENT,
souphttpsink->user_agent, SOUP_SESSION_TIMEOUT, souphttpsink->timeout,
SOUP_SESSION_PROXY_URI, souphttpsink->proxy, NULL);
}
g_signal_connect (souphttpsink->session, "authenticate",
G_CALLBACK (authenticate), souphttpsink);
}
/* Set up logging */
gst_soup_util_log_setup (souphttpsink->session, souphttpsink->log_level,
GST_ELEMENT (souphttpsink));
return TRUE;
}
static void
g_vfs_backend_http_init (GVfsBackendHttp *backend)
{
const char *debug;
SoupSessionFeature *proxy_resolver;
SoupSessionFeature *cookie_jar;
SoupSessionFeature *content_decoder;
g_vfs_backend_set_user_visible (G_VFS_BACKEND (backend), FALSE);
backend->session = soup_session_sync_new_with_options ("user-agent",
"gvfs/" VERSION,
NULL);
backend->session_async = soup_session_async_new_with_options ("user-agent",
"gvfs/" VERSION,
NULL);
/* SoupRequester seems to depend on use-thread-context */
g_object_set (G_OBJECT (backend->session_async), "use-thread-context", TRUE, NULL);
/* Proxy handling */
proxy_resolver = g_object_new (SOUP_TYPE_PROXY_RESOLVER_GNOME, NULL);
soup_session_add_feature (backend->session, proxy_resolver);
soup_session_add_feature (backend->session_async, proxy_resolver);
g_object_unref (proxy_resolver);
/* Cookie handling - stored temporarlly in memory, mostly useful for
* authentication in WebDAV. */
cookie_jar = g_object_new (SOUP_TYPE_COOKIE_JAR, NULL);
soup_session_add_feature (backend->session, cookie_jar);
soup_session_add_feature (backend->session_async, cookie_jar);
g_object_unref (cookie_jar);
/* Send Accept-Language header (see bug 166795) */
g_object_set (backend->session, "accept-language-auto", TRUE, NULL);
g_object_set (backend->session_async, "accept-language-auto", TRUE, NULL);
/* Handle decompression automatically */
content_decoder = g_object_new (SOUP_TYPE_CONTENT_DECODER, NULL);
soup_session_add_feature (backend->session, content_decoder);
soup_session_add_feature (backend->session_async, content_decoder);
g_object_unref (content_decoder);
/* Request API */
soup_session_add_feature_by_type (backend->session, SOUP_TYPE_REQUESTER);
soup_session_add_feature_by_type (backend->session_async, SOUP_TYPE_REQUESTER);
/* Logging */
debug = g_getenv ("GVFS_HTTP_DEBUG");
if (debug)
{
SoupLogger *logger;
SoupLoggerLogLevel level;
if (g_ascii_strcasecmp (debug, "all") ||
g_ascii_strcasecmp (debug, "body"))
level = SOUP_LOGGER_LOG_BODY;
else if (g_ascii_strcasecmp (debug, "header"))
level = SOUP_LOGGER_LOG_HEADERS;
else
level = SOUP_LOGGER_LOG_MINIMAL;
logger = soup_logger_new (level, DEBUG_MAX_BODY_SIZE);
soup_session_add_feature (backend->session, SOUP_SESSION_FEATURE (logger));
soup_session_add_feature (backend->session_async, SOUP_SESSION_FEATURE (logger));
g_object_unref (logger);
}
}
static void paste(GeanyDocument * doc, const gchar * website)
{
SoupSession *session;
SoupMessage *msg = NULL;
gchar *f_content;
gchar const *f_type;
gchar *f_title;
gchar *p_url;
gchar *formdata = NULL;
gchar *user_agent = NULL;
gchar **tokens_array;
const gchar *langs_supported_codepad[] =
{
"C", "C++", "D", "Haskell",
"Lua", "OCaml", "PHP", "Perl", "Plain Text",
"Python", "Ruby", "Scheme", "Tcl"
};
const gchar *langs_supported_dpaste[] =
{
"Bash", "C", "CSS", "Diff",
"Django/Jinja", "HTML", "IRC logs", "JavaScript", "PHP",
"Python console session", "Python Traceback", "Python",
"Python3", "Restructured Text", "SQL", "Text only"
};
gint occ_position;
gint i;
guint status;
gsize f_length;
g_return_if_fail(doc && doc->is_valid);
f_type = doc->file_type->name;
if (doc->file_name == NULL)
f_title = document_get_basename_for_display(doc, -1);
else
f_title = g_path_get_basename(doc->file_name);
load_settings();
f_content = get_paste_text(doc, &f_length);
if (f_content == NULL || f_content[0] == '\0')
{
dialogs_show_msgbox(GTK_MESSAGE_ERROR, _("Refusing to create blank paste"));
return;
}
switch (website_selected)
{
case CODEPAD_ORG:
for (i = 0; i < G_N_ELEMENTS(langs_supported_codepad); i++)
{
if (g_strcmp0(f_type, langs_supported_codepad[i]) == 0)
break;
else
f_type = DEFAULT_TYPE_CODEPAD;
}
msg = soup_message_new("POST", website);
formdata = soup_form_encode("lang", f_type,
"code", f_content,
"submit", "Submit",
NULL);
break;
case TINYPASTE_COM:
msg = soup_message_new("POST", website);
formdata = soup_form_encode("paste", f_content,
"title", f_title,
"is_code", g_strcmp0(f_type, "None") == 0 ? "0" : "1",
NULL);
break;
case DPASTE_DE:
for (i = 0; i < G_N_ELEMENTS(langs_supported_dpaste); i++)
{
if (g_strcmp0(f_type, langs_supported_dpaste[i]) == 0)
break;
else
f_type = DEFAULT_TYPE_DPASTE;
}
msg = soup_message_new("POST", website);
/* apparently dpaste.de detects automatically the syntax of the
* pasted code so 'lexer' should be unneeded
*/
formdata = soup_form_encode("content", f_content,
"title", f_title,
"lexer", f_type,
NULL);
break;
case SPRUNGE_US:
msg = soup_message_new("POST", website);
formdata = soup_form_encode("sprunge", f_content, NULL);
break;
case PASTEBIN_GEANY_ORG:
msg = soup_message_new("POST", website);
formdata = soup_form_encode("content", f_content,
"author", author_name,
"title", f_title,
"lexer", f_type,
NULL);
break;
}
g_free(f_content);
user_agent = g_strconcat(PLUGIN_NAME, " ", PLUGIN_VERSION, " / Geany ", GEANY_VERSION, NULL);
session = soup_session_async_new_with_options(SOUP_SESSION_USER_AGENT, user_agent, NULL);
g_free(user_agent);
soup_message_set_request(msg, "application/x-www-form-urlencoded",
SOUP_MEMORY_TAKE, formdata, strlen(formdata));
status = soup_session_send_message(session, msg);
p_url = g_strdup(msg->response_body->data);
g_object_unref(session);
g_object_unref(msg);
if(status == SOUP_STATUS_OK)
{
/*
* codepad.org doesn't return only the url of the new snippet pasted
* but an html page. This minimal parser will get the bare url.
*/
if (website_selected == CODEPAD_ORG)
{
tokens_array = g_strsplit(p_url, "<a href=\"", 0);
/* cuts the string when it finds the first occurrence of '/'
* It shoud work even if codepad would change its url.
*/
SETPTR(p_url, g_strdup(tokens_array[5]));
occ_position = indexof(tokens_array[5], '\"');
g_strfreev(tokens_array);
if(occ_position != -1)
{
p_url[occ_position] = '\0';
}
else
{
dialogs_show_msgbox(GTK_MESSAGE_ERROR, _("Unable to paste the code on codepad.org\n"
"Retry or select another pastebin."));
g_free(p_url);
return;
}
}
else if(website_selected == TINYPASTE_COM)
{
/* tinypaste.com returns a XML response which looks
* like this:
*
* <?xml version="1.0" encoding="utf-8"?>
* <result>
* <response>xxxxx</response>
* </result>
*/
tokens_array = g_strsplit_set(p_url, "<>", 0);
SETPTR(p_url, g_strdup_printf("http://%s/%s", websites[TINYPASTE_COM], tokens_array[6]));
g_strfreev(tokens_array);
}
else if(website_selected == DPASTE_DE)
{
SETPTR(p_url, g_strndup(p_url + 1, strlen(p_url) - 2));
}
else if(website_selected == SPRUNGE_US)
{
/* in order to enable the syntax highlightning on sprunge.us
* it is necessary to append at the returned url a question
* mark '?' followed by the file type.
*
* e.g. sprunge.us/xxxx?c
*/
gchar *ft_tmp = g_ascii_strdown(f_type, -1);
g_strstrip(p_url);
SETPTR(p_url, g_strdup_printf("%s?%s", p_url, ft_tmp));
g_free(ft_tmp);
}
if (check_button_is_checked)
{
utils_open_browser(p_url);
}
else
{
GtkWidget *dlg = gtk_message_dialog_new(GTK_WINDOW(geany->main_widgets->window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
_("Paste Successful"));
gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(dlg),
_("Your paste can be found here:\n<a href=\"%s\" "
"title=\"Click to open the paste in your browser\">%s</a>"), p_url, p_url);
gtk_dialog_run(GTK_DIALOG(dlg));
gtk_widget_destroy(dlg);
}
}
else
{
dialogs_show_msgbox(GTK_MESSAGE_ERROR, _("Unable to paste the code. Check your connection and retry.\n"
"Error code: %d\n"), status);
}
g_free(p_url);
}
void
goa_ews_autodiscover (GoaObject *goa_object,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GoaAccount *goa_account;
GoaExchange *goa_exchange;
GoaPasswordBased *goa_password;
GSimpleAsyncResult *simple;
AutodiscoverData *data;
AutodiscoverAuthData *auth;
gchar *url1;
gchar *url2;
xmlDoc *doc;
xmlOutputBuffer *buf;
gchar *email;
gchar *host;
gchar *password = NULL;
GError *error = NULL;
g_return_if_fail (GOA_IS_OBJECT (goa_object));
goa_account = goa_object_get_account (goa_object);
goa_exchange = goa_object_get_exchange (goa_object);
goa_password = goa_object_get_password_based (goa_object);
email = goa_account_dup_presentation_identity (goa_account);
host = goa_exchange_dup_host (goa_exchange);
doc = ews_create_autodiscover_xml (email);
buf = xmlAllocOutputBuffer (NULL);
xmlNodeDumpOutput (buf, doc, xmlDocGetRootElement (doc), 0, 1, NULL);
xmlOutputBufferFlush (buf);
url1 = g_strdup_printf (
"https://%s/autodiscover/autodiscover.xml", host);
url2 = g_strdup_printf (
"https://autodiscover.%s/autodiscover/autodiscover.xml", host);
g_free (host);
g_free (email);
/* http://msdn.microsoft.com/en-us/library/ee332364.aspx says we are
* supposed to try $domain and then autodiscover.$domain. But some
* people have broken firewalls on the former which drop packets
* instead of rejecting connections, and make the request take ages
* to time out. So run both queries in parallel and let the fastest
* (successful) one win. */
data = g_slice_new0 (AutodiscoverData);
data->buf = buf;
data->msgs[0] = ews_create_msg_for_url (url1, buf);
data->msgs[1] = ews_create_msg_for_url (url2, buf);
data->session = soup_session_async_new_with_options (
SOUP_SESSION_USE_NTLM, TRUE,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
SOUP_SESSION_TIMEOUT, 90,
SOUP_SESSION_ACCEPT_LANGUAGE_AUTO, TRUE,
NULL);
if (G_IS_CANCELLABLE (cancellable)) {
data->cancellable = g_object_ref (cancellable);
data->cancellable_id = g_cancellable_connect (
data->cancellable,
G_CALLBACK (ews_autodiscover_cancelled_cb),
data, NULL);
}
simple = g_simple_async_result_new (
G_OBJECT (goa_object), callback,
user_data, goa_ews_autodiscover);
g_simple_async_result_set_check_cancellable (simple, cancellable);
g_simple_async_result_set_op_res_gpointer (
simple, data, (GDestroyNotify) ews_autodiscover_data_free);
goa_password_based_call_get_password_sync (
goa_password, "", &password, cancellable, &error);
/* Sanity check */
g_return_if_fail (
((password != NULL) && (error == NULL)) ||
((password == NULL) && (error != NULL)));
if (error == NULL) {
gchar *username;
username = goa_account_dup_identity (goa_account);
auth = g_slice_new0 (AutodiscoverAuthData);
auth->username = username; /* takes ownership */
auth->password = password; /* takes ownership */
g_signal_connect_data (
data->session, "authenticate",
G_CALLBACK (ews_authenticate), auth,
ews_autodiscover_auth_data_free, 0);
soup_session_queue_message (
data->session, data->msgs[0],
ews_autodiscover_response_cb, simple);
soup_session_queue_message (
data->session, data->msgs[1],
ews_autodiscover_response_cb, simple);
} else {
g_dbus_error_strip_remote_error (error);
g_simple_async_result_take_error (simple, error);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
}
g_free (url2);
g_free (url1);
xmlFreeDoc (doc);
g_object_unref (goa_account);
g_object_unref (goa_exchange);
g_object_unref (goa_password);
}
