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