static void
snra_client_init (SnraClient * client)
{
client->soup = soup_session_async_new ();
client->server_port = 5457;
client->state = GST_STATE_NULL;
}
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 void
soup_download_init (SoupDownload *object)
{
object->priv = SOUP_DOWNLOAD_PRIVATE (object);
object->priv->session = soup_session_async_new ();
object->priv->need_to_write = FALSE;
}
SoupNetworkSession::SoupNetworkSession(SoupCookieJar* cookieJar)
: m_soupSession(adoptGRef(soup_session_async_new()))
{
// Values taken from http://www.browserscope.org/ following
// the rule "Do What Every Other Modern Browser Is Doing". They seem
// to significantly improve page loading time compared to soup's
// default values.
static const int maxConnections = 35;
static const int maxConnectionsPerHost = 6;
g_object_set(m_soupSession.get(),
SOUP_SESSION_MAX_CONNS, maxConnections,
SOUP_SESSION_MAX_CONNS_PER_HOST, maxConnectionsPerHost,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_SNIFFER,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_PROXY_RESOLVER_DEFAULT,
SOUP_SESSION_ADD_FEATURE, cookieJar,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
nullptr);
setupLogger();
g_signal_connect(m_soupSession.get(), "authenticate", G_CALLBACK(authenticateCallback), nullptr);
#if ENABLE(WEB_TIMING)
g_signal_connect(m_soupSession.get(), "request-started", G_CALLBACK(requestStartedCallback), nullptr);
#endif
}
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;
}
//
// Called when the plugin is first loaded
//
static gboolean
budicons_plugin_load (PurplePlugin *purple) {
g_print("Plugin loaded\n");
// Create the plugin's global data
BudiconsPlugin *plugin = g_new0(BudiconsPlugin, 1);
purple->extra = plugin;
if (plugin == NULL) {
g_print("Failed to create the plugin's internal data structure\n");
return FALSE;
}
plugin->session = soup_session_async_new();
plugin->purple = purple;
// Download the JSON file (asynchronously)
const gchar *url = budicons_prefs_get_url_json();
if (url == NULL) {
g_print("No CONF_URL_JSON was provided\n");
return TRUE;
}
g_print("Download of JSON %s\n", url);
SoupMessage *message = soup_message_new(SOUP_METHOD_GET, url);
if (message == NULL) {
g_print("URL %s can't be parsed\n", url);
return TRUE;
}
soup_session_queue_message(plugin->session, message, budicons_got_json_response, plugin);
return TRUE;
}
static void ogd_provider_init (OGDProvider *item)
{
InstancesCounter++;
item->priv = OGD_PROVIDER_GET_PRIVATE (item);
memset (item->priv, 0, sizeof (OGDProviderPrivate));
item->priv->http_session = soup_session_sync_new ();
item->priv->async_http_session = soup_session_async_new ();
}
static void
grss_feeds_pool_init (GrssFeedsPool *node)
{
node->priv = FEEDS_POOL_GET_PRIVATE (node);
memset (node->priv, 0, sizeof (GrssFeedsPoolPrivate));
node->priv->parser = grss_feed_parser_new ();
node->priv->soupsession = soup_session_async_new ();
}
int
main (int argc, char **argv)
{
GMainLoop *loop;
int opt;
int port = SOUP_ADDRESS_ANY_PORT;
SoupAuthDomain *auth_domain = NULL;
g_type_init ();
signal (SIGINT, quit);
while ((opt = getopt (argc, argv, "ap:")) != -1) {
switch (opt) {
case 'a':
auth_domain = soup_auth_domain_basic_new (
SOUP_AUTH_DOMAIN_REALM, "simple-proxy",
SOUP_AUTH_DOMAIN_PROXY, TRUE,
SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK, auth_callback,
NULL);
break;
case 'p':
port = atoi (optarg);
break;
default:
g_printerr ("Usage: %s [-p port] [-n]\n",
argv[0]);
exit (1);
}
}
server = soup_server_new (SOUP_SERVER_PORT, port,
NULL);
if (!server) {
g_printerr ("Unable to bind to server port %d\n", port);
exit (1);
}
soup_server_add_handler (server, NULL,
server_callback, NULL, NULL);
if (auth_domain) {
soup_server_add_auth_domain (server, auth_domain);
g_object_unref (auth_domain);
}
g_print ("\nStarting proxy on port %d\n",
soup_server_get_port (server));
soup_server_run_async (server);
session = soup_session_async_new ();
g_print ("\nWaiting for requests...\n");
loop = g_main_loop_new (NULL, TRUE);
g_main_loop_run (loop);
g_main_loop_unref (loop);
return 0;
}
static void
do_session_property_tests (void)
{
gboolean use_system;
GTlsDatabase *tlsdb;
char *ca_file;
SoupSession *session;
debug_printf (1, "session properties\n");
session = soup_session_async_new ();
g_object_get (G_OBJECT (session),
"ssl-use-system-ca-file", &use_system,
"tls-database", &tlsdb,
"ssl-ca-file", &ca_file,
NULL);
soup_test_assert (!use_system, "ssl-use-system-ca-file defaults to TRUE");
soup_test_assert (tlsdb == NULL, "tls-database set by default");
soup_test_assert (ca_file == NULL, "ca-file set by default");
g_object_set (G_OBJECT (session),
"ssl-use-system-ca-file", TRUE,
NULL);
g_object_get (G_OBJECT (session),
"ssl-ca-file", &ca_file,
NULL);
soup_test_assert (ca_file == NULL, "setting ssl-use-system-ca-file set ssl-ca-file");
g_object_set (G_OBJECT (session),
"ssl-ca-file",
g_test_get_filename (G_TEST_DIST, "test-cert.pem", NULL),
NULL);
g_object_get (G_OBJECT (session),
"ssl-use-system-ca-file", &use_system,
"tls-database", &tlsdb,
"ssl-ca-file", &ca_file,
NULL);
soup_test_assert (ca_file == NULL, "setting ssl-ca-file did not fail");
soup_test_assert (!use_system, "setting ssl-ca-file set ssl-use-system-ca-file");
soup_test_assert (tlsdb == NULL, "setting ssl-ca-file set tls-database");
g_object_set (G_OBJECT (session),
"tls-database", NULL,
NULL);
g_object_get (G_OBJECT (session),
"ssl-use-system-ca-file", &use_system,
"tls-database", &tlsdb,
"ssl-ca-file", &ca_file,
NULL);
soup_test_assert (tlsdb == NULL, "setting tls-database NULL failed");
soup_test_assert (!use_system, "setting tls-database NULL set ssl-use-system-ca-file");
soup_test_assert (ca_file == NULL, "setting tls-database NULL set ssl-ca-file");
soup_test_session_abort_unref (session);
}
static void
snra_client_init (SnraClient * client)
{
client->soup = soup_session_async_new ();
client->server_port = 5457;
client->paused = TRUE;
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)));
}
static void
pluma_check_update_plugin_init (PlumaCheckUpdatePlugin *plugin)
{
plugin->priv = PLUMA_CHECK_UPDATE_PLUGIN_GET_PRIVATE (plugin);
pluma_debug_message (DEBUG_PLUGINS,
"PlumaCheckUpdatePlugin initializing");
plugin->priv->session = soup_session_async_new ();
plugin->priv->settings = g_settings_new (SETTINGS_SCHEMA);
}
static void
gss_server_init (GssServer * server)
{
char *s;
server->metrics = gss_metrics_new ();
server->resources = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL, (GDestroyNotify) gss_resource_free);
server->client_session = soup_session_async_new ();
server->enable_public_interface = DEFAULT_ENABLE_PUBLIC_INTERFACE;
s = gss_utils_gethostname ();
gss_server_set_server_hostname (server, s);
g_free (s);
gss_object_set_title (GSS_OBJECT (server), "GStreamer Streaming Server");
server->max_connections = DEFAULT_MAX_CONNECTIONS;
server->max_rate = DEFAULT_MAX_RATE;
server->admin_hosts_allow = g_strdup (DEFAULT_ADMIN_HOSTS_ALLOW);
server->admin_arl =
gss_addr_range_list_new_from_string (server->admin_hosts_allow, TRUE,
TRUE);
server->kiosk_hosts_allow = g_strdup (DEFAULT_KIOSK_HOSTS_ALLOW);
server->kiosk_arl =
gss_addr_range_list_new_from_string (server->kiosk_hosts_allow, FALSE,
FALSE);
server->admin_token = g_strdup (DEFAULT_ADMIN_TOKEN);
server->realm = g_strdup (DEFAULT_REALM);
server->enable_html5_video = DEFAULT_ENABLE_HTML5_VIDEO;
server->enable_cortado = DEFAULT_ENABLE_CORTADO;
server->enable_flash = DEFAULT_ENABLE_FLASH;
server->enable_rtsp = DEFAULT_ENABLE_RTSP;
server->enable_rtmp = DEFAULT_ENABLE_RTMP;
server->enable_vod = DEFAULT_ENABLE_VOD;
server->enable_flowplayer = FALSE;
server->enable_persona = FALSE;
server->enable_programs = TRUE;
server->programs = NULL;
server->archive_dir = g_strdup (DEFAULT_ARCHIVE_DIR);
server->cas_server = g_strdup (DEFAULT_CAS_SERVER);
#ifdef ENABLE_RTSP
if (server->enable_rtsp)
gss_server_rtsp_init (server);
#endif
gss_server_add_module (server, GSS_MODULE (server));
gss_server_setup_resources (server);
g_timeout_add (1000, (GSourceFunc) periodic_timer, server);
}
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
dmap_connection_setup (DMAPConnection * connection)
{
connection->priv->session = soup_session_async_new ();
connection->priv->base_uri = soup_uri_new (NULL);
soup_uri_set_scheme (connection->priv->base_uri,
SOUP_URI_SCHEME_HTTP);
soup_uri_set_host (connection->priv->base_uri,
connection->priv->host);
soup_uri_set_port (connection->priv->base_uri,
connection->priv->port);
}
bool ResourceHandle::startHttp(String urlString)
{
if (!session) {
session = soup_session_async_new();
soup_session_add_feature(session, SOUP_SESSION_FEATURE(getCookieJar()));
const char* soup_debug = g_getenv("WEBKIT_SOUP_LOGGING");
if (soup_debug) {
int soup_debug_level = atoi(soup_debug);
SoupLogger* logger = soup_logger_new(static_cast<SoupLoggerLogLevel>(soup_debug_level), -1);
soup_logger_attach(logger, session);
g_object_unref(logger);
}
}
SoupMessage* msg;
msg = soup_message_new(request().httpMethod().utf8().data(), urlString.utf8().data());
g_signal_connect(msg, "restarted", G_CALLBACK(restartedCallback), this);
g_signal_connect(msg, "got-headers", G_CALLBACK(gotHeadersCallback), this);
g_signal_connect(msg, "got-chunk", G_CALLBACK(gotChunkCallback), this);
HTTPHeaderMap customHeaders = d->m_request.httpHeaderFields();
if (!customHeaders.isEmpty()) {
HTTPHeaderMap::const_iterator end = customHeaders.end();
for (HTTPHeaderMap::const_iterator it = customHeaders.begin(); it != end; ++it)
soup_message_headers_append(msg->request_headers, it->first.utf8().data(), it->second.utf8().data());
}
FormData* httpBody = d->m_request.httpBody();
if (httpBody && !httpBody->isEmpty()) {
// Making a copy of the request body isn't the most efficient way to
// serialize it, but by far the most simple. Dealing with individual
// FormData elements and shared buffers should be more memory
// efficient.
//
// This possibly isn't handling file uploads/attachments, for which
// shared buffers or streaming should definitely be used.
Vector<char> body;
httpBody->flatten(body);
soup_message_set_request(msg, d->m_request.httpContentType().utf8().data(),
SOUP_MEMORY_COPY, body.data(), body.size());
}
d->m_msg = static_cast<SoupMessage*>(g_object_ref(msg));
soup_session_queue_message(session, d->m_msg, finishedCallback, this);
return true;
}
void
search_button_clicked_cb (GtkButton *button, TotemYouTubePlugin *self)
{
const gchar *search_terms;
search_terms = gtk_entry_get_text (self->search_entry);
g_debug ("Searching for \"%s\"", search_terms);
/* Focus the "Search" page */
gtk_notebook_set_current_page (self->notebook, SEARCH_TREE_VIEW);
/* Update the UI */
set_progress_bar_text (self, _("Fetching search results…"), SEARCH_TREE_VIEW);
/* Clear details pertaining to related videos, since we're doing a new search */
gtk_list_store_clear (self->list_store[RELATED_TREE_VIEW]);
if (self->playing_video != NULL)
g_object_unref (self->playing_video);
self->playing_video = NULL;
/* If this is the first query, set up some stuff which we didn't do before to save memory */
if (self->query[SEARCH_TREE_VIEW] == NULL) {
/* If this is the first query, compile the regex used to resolve the t param. Doing this here rather than when
* activating the plugin means we don't waste cycles if the plugin's never used. It also means we don't waste
* cycles repeatedly creating new regexes for each video whose t param we resolve. */
/* We're looking for a line of the form:
* var swfHTML = (isIE) ? "<object...econds=194&t=vjVQa1PpcFP36LLlIaDqZIG1w6e30b-7WVBgsQLLA3s%3D&rv.6.id=OzLjC6Pm... */
self->regex = g_regex_new ("swfHTML = .*&fmt_url_map=([^&]+)&", G_REGEX_OPTIMIZE, 0, NULL);
g_assert (self->regex != NULL);
/* Set up the GData service (needed for the tree views' queries) */
self->service = gdata_youtube_service_new (DEVELOPER_KEY, CLIENT_ID);
/* Set up network timeouts, if they're supported by our version of libgdata.
* This will return from queries with %GDATA_SERVICE_ERROR_NETWORK_ERROR if network operations take longer than 30 seconds. */
#ifdef HAVE_LIBGDATA_0_7
gdata_service_set_timeout (GDATA_SERVICE (self->service), 30);
#endif /* HAVE_LIBGDATA_0_7 */
/* Set up the queries */
self->query[SEARCH_TREE_VIEW] = gdata_query_new_with_limits (NULL, 0, MAX_RESULTS);
self->query[RELATED_TREE_VIEW] = gdata_query_new_with_limits (NULL, 0, MAX_RESULTS);
/* Lazily create the SoupSession used in resolve_t_param() */
self->session = soup_session_async_new ();
}
/* Do the query */
gdata_query_set_q (self->query[SEARCH_TREE_VIEW], search_terms);
execute_query (self, SEARCH_TREE_VIEW, TRUE);
}
static gboolean
has_stream (MarinaSource *source)
{
MarinaGoogleReaderSourcePrivate *priv;
IrisTask *task;
g_return_val_if_fail (MARINA_IS_GOOGLE_READER_SOURCE (source), FALSE);
priv = MARINA_GOOGLE_READER_SOURCE (source)->priv;
/* if they are asking if we have a stream, we can at this point
* go ahead and lookup our opml from google if necessary */
if (priv->username && !priv->children)
{
/* go ahead and start fetching the OPML from google */
if (!priv->session)
{
g_mutex_lock (priv->session_lock);
if (!priv->session)
priv->session = soup_session_async_new ();
g_mutex_unlock (priv->session_lock);
}
/* use gtask to get our remote items */
/* get the credentials from gnome-keyring if we can */
task = iris_task_new_full (fetch_keyring_pass,
g_object_ref (source),
g_object_unref,
TRUE,
NULL,
g_main_context_default ());
/* if that fails, ask the user. do this in an errback so we are in main thread */
iris_task_add_errback (task, ask_user_pass, g_object_ref (source), g_object_unref);
/* get our google cookie */
iris_task_add_callback (task, get_cookie, g_object_ref (source), g_object_unref);
/* fetch the OMPL from the google */
iris_task_add_callback (task, fetch_opml, g_object_ref (source), g_object_unref);
/* parse the OPML */
iris_task_add_callback (task, parse_opml, g_object_ref (source), g_object_unref);
iris_task_run (task);
}
return FALSE;
}
static void
grl_net_wc_init (GrlNetWc *wc)
{
GRL_LOG_DOMAIN_INIT (wc_log_domain, "wc");
wc->priv = GRL_NET_WC_GET_PRIVATE (wc);
wc->priv->session = soup_session_async_new ();
wc->priv->pending = g_queue_new ();
set_thread_context (wc);
init_mock_requester (wc);
init_requester (wc);
}
void trex_callback(SoupServer *server, SoupMessage *msg,
const char *path, GHashTable *query, const char *dest)
{
SoupMessage *new_msg;
SoupSession *session;
char *uri_str;
struct destination_info *to = malloc(sizeof(struct destination_info));
to->server = server;
to->msg = msg;
session = soup_session_async_new();
uri_str = soup_uri_to_string(soup_message_get_uri(msg), true);
/*
* TODO Memory Leak :-)
*/
uri_str = g_strjoin(NULL, dest, uri_str, NULL);
g_print("[%p] %s %s HTTP/1.%d\n", msg, msg->method, uri_str,
soup_message_get_http_version(msg));
/* build new request */
new_msg = soup_message_new(msg->method, uri_str);
soup_message_headers_foreach(msg->request_headers, copy_header,
new_msg->request_headers);
soup_message_headers_remove(new_msg->request_headers, "Host");
if (msg->request_body->length) {
SoupBuffer *request =
soup_message_body_flatten(msg->request_body);
soup_message_body_append_buffer(new_msg->request_body,
request);
soup_buffer_free(request);
}
soup_message_headers_set_encoding(msg->response_headers,
SOUP_ENCODING_CHUNKED);
soup_server_pause_message(server, msg);
g_signal_connect(new_msg, "got_headers",
G_CALLBACK(recv_headers), to);
g_signal_connect(new_msg, "got_chunk",
G_CALLBACK(recv_chunk), to);
soup_session_queue_message(session, new_msg, finish_msg, to);
g_object_ref(msg);
g_object_unref(session);
}
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;
}
sr_session_t *
sr_session_new(const char *url,
const char *client_id,
const char *client_ver)
{
sr_session_t *s;
struct sr_session_priv *priv;
s = calloc(1, sizeof(*s));
s->priv = priv = calloc(1, sizeof(*priv));
priv->queue = g_queue_new();
priv->queue_mutex = g_mutex_new();
priv->url = g_strdup(url);
priv->client_id = g_strdup(client_id);
priv->client_ver = g_strdup(client_ver);
priv->soup = soup_session_async_new();
priv->handshake_delay = 1;
priv->love_queue = g_queue_new();
priv->love_queue_mutex = g_mutex_new();
return s;
}
JsonParser* zenmoney_home_timeline (Zenmoney* self) {
JsonParser* result = NULL;
SoupSession* session = NULL;
SoupSessionAsync* _tmp0_ = NULL;
SoupMessage* message = NULL;
OauthZenmoney* _tmp1_ = NULL;
SoupMessage* _tmp2_ = NULL;
JsonParser* parser = NULL;
JsonParser* _tmp3_ = NULL;
SoupMessageBody* _tmp20_ = NULL;
SoupBuffer* _tmp21_ = NULL;
SoupBuffer* _tmp22_ = NULL;
guint8* _tmp23_ = NULL;
gint _tmp23__length1 = 0;
gchar* _tmp24_ = NULL;
gchar* _tmp25_ = NULL;
GError * _inner_error_ = NULL;
g_return_val_if_fail (self != NULL, NULL);
g_print ("Home_timeline /n");
_tmp0_ = (SoupSessionAsync*) soup_session_async_new ();
session = (SoupSession*) _tmp0_;
_tmp1_ = self->priv->ot;
_tmp2_ = oauth_zenmoney_Auth (_tmp1_, "POST", OWNER_INFO_URL, NULL);
message = _tmp2_;
soup_session_send_message (session, message);
_tmp3_ = json_parser_new ();
parser = _tmp3_;
{
SoupMessageBody* _tmp4_ = NULL;
SoupBuffer* _tmp5_ = NULL;
SoupBuffer* _tmp6_ = NULL;
guint8* _tmp7_ = NULL;
gint _tmp7__length1 = 0;
gchar* _tmp8_ = NULL;
gchar* _tmp9_ = NULL;
gchar* _tmp10_ = NULL;
gchar* _tmp11_ = NULL;
SoupMessageBody* _tmp12_ = NULL;
SoupBuffer* _tmp13_ = NULL;
SoupBuffer* _tmp14_ = NULL;
guint8* _tmp15_ = NULL;
gint _tmp15__length1 = 0;
_tmp4_ = message->response_body;
_tmp5_ = soup_message_body_flatten (_tmp4_);
_tmp6_ = _tmp5_;
_tmp7_ = _tmp6_->data;
_tmp7__length1 = (gint) _tmp6_->length;
_tmp8_ = g_strconcat ("response: ", (const gchar*) _tmp7_, NULL);
_tmp9_ = _tmp8_;
_tmp10_ = g_strconcat (_tmp9_, "\n", NULL);
_tmp11_ = _tmp10_;
g_print ("%s", _tmp11_);
_g_free0 (_tmp11_);
_g_free0 (_tmp9_);
__vala_SoupBuffer_free0 (_tmp6_);
_tmp12_ = message->response_body;
_tmp13_ = soup_message_body_flatten (_tmp12_);
_tmp14_ = _tmp13_;
_tmp15_ = _tmp14_->data;
_tmp15__length1 = (gint) _tmp14_->length;
json_parser_load_from_data (parser, (const gchar*) _tmp15_, (gssize) (-1), &_inner_error_);
__vala_SoupBuffer_free0 (_tmp14_);
if (G_UNLIKELY (_inner_error_ != NULL)) {
goto __catch5_g_error;
}
}
goto __finally5;
__catch5_g_error:
{
GError* e = NULL;
GError* _tmp16_ = NULL;
const gchar* _tmp17_ = NULL;
gchar* _tmp18_ = NULL;
gchar* _tmp19_ = NULL;
e = _inner_error_;
_inner_error_ = NULL;
_tmp16_ = e;
_tmp17_ = _tmp16_->message;
_tmp18_ = g_strconcat ("Error: ", _tmp17_, NULL);
_tmp19_ = _tmp18_;
g_print ("%s", _tmp19_);
_g_free0 (_tmp19_);
_g_error_free0 (e);
}
__finally5:
if (G_UNLIKELY (_inner_error_ != NULL)) {
_g_object_unref0 (parser);
_g_object_unref0 (message);
_g_object_unref0 (session);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return NULL;
}
_tmp20_ = message->response_body;
_tmp21_ = soup_message_body_flatten (_tmp20_);
_tmp22_ = _tmp21_;
_tmp23_ = _tmp22_->data;
_tmp23__length1 = (gint) _tmp22_->length;
_tmp24_ = g_strconcat ("response", (const gchar*) _tmp23_, NULL);
_tmp25_ = _tmp24_;
g_print ("%s", _tmp25_);
_g_free0 (_tmp25_);
__vala_SoupBuffer_free0 (_tmp22_);
result = parser;
_g_object_unref0 (message);
_g_object_unref0 (session);
return result;
}
gboolean
net_get_unblocking(gchar *url,
NetStatusCallback cb, gpointer data,
gpointer cb2, gpointer cbdata2,
guint track,
GError **err)
{
SoupMessage *msg;
CallbackInfo *info = NULL;
SoupSession *soup_sess;
gchar *agstr;
gchar *mainurl = NULL;
gchar **res;
STNET *stnet;
soup_sess = soup_session_async_new();
#if LIBSOUP_VERSION > 2024000
if (rss_soup_jar) {
soup_session_add_feature(
soup_sess, SOUP_SESSION_FEATURE(rss_soup_jar));
}
#endif
if (cb && data) {
info = g_new0(CallbackInfo, 1);
info->user_cb = cb;
info->user_data = data;
info->current = 0;
info->total = 0;
info->ss = soup_sess;
}
/*try to find upstream url to supply a password*/
if (data) {
res = g_strsplit(data, ";COMMENT-", 0);
if (res[0] && g_str_has_prefix(res[0], "RSS-")) {
mainurl = g_strdup(res[0]+4);
g_strfreev(res);
}
}
g_signal_connect (soup_sess, "authenticate",
G_CALLBACK (authenticate), (gpointer)mainurl?mainurl:g_strdup(url));
#if LIBSOUP_VERSION < 2003000
g_signal_connect (soup_sess, "reauthenticate",
G_CALLBACK (reauthenticate), (gpointer)mainurl?mainurl:g_strdup(url));
#endif
/* Queue an async HTTP request */
msg = soup_message_new ("GET", url);
if (!msg) {
if (info) g_free(info);
g_set_error(err, NET_ERROR, NET_ERROR_GENERIC, "%s",
soup_status_get_phrase(2)); //invalid url
return FALSE;
}
if (track) {
//we want to be able to abort this session by calling
//abort_all_soup
g_hash_table_insert(rf->session, soup_sess, msg);
g_hash_table_insert(rf->abort_session, soup_sess, msg);
g_hash_table_insert(rf->key_session, data, soup_sess);
}
agstr = g_strdup_printf("Evolution/%s; Evolution-RSS/%s",
EVOLUTION_VERSION_STRING, VERSION);
#if LIBSOUP_VERSION < 2003000
soup_message_add_header (msg->request_headers, "User-Agent",
agstr);
#else
soup_message_headers_append (msg->request_headers, "User-Agent",
agstr);
#endif
g_free(agstr);
if (info) {
g_signal_connect(G_OBJECT(msg), "got_chunk",
G_CALLBACK(got_chunk_cb), info); //FIXME Find a way to free this maybe weak_ref
soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT);
soup_message_add_header_handler (msg, "got_body",
"Location", G_CALLBACK (redirect_handler), info);
}
stnet = g_new0(STNET, 1);
stnet->ss = soup_sess;
stnet->sm = msg;
stnet->cb2 = cb2;
stnet->cbdata2 = cbdata2;
stnet->url = g_strdup(url);
stnet->callback = queue_callback;
stnet->data = stnet;
proxify_session_async(proxy, stnet);
//free stnet
//// g_object_add_weak_pointer (G_OBJECT(msg), (gpointer)info);
g_object_weak_ref (G_OBJECT(msg), unblock_free, soup_sess);
// g_object_weak_ref (G_OBJECT(soup_sess), unblock_free, soup_sess);
return TRUE;
}
// same stuff as net_get_* but without accumulating headers
// push all donwloads to a customizable length queue
gboolean
download_unblocking(
gchar *url,
NetStatusCallback cb,
gpointer data,
gpointer cb2,
gpointer cbdata2,
guint track,
GError **err)
{
SoupMessage *msg;
CallbackInfo *info = NULL;
SoupSession *soup_sess;
gchar *agstr;
STNET *stnet;
soup_sess = soup_session_async_new();
#if LIBSOUP_VERSION > 2024000
if (rss_soup_jar) {
soup_session_add_feature(soup_sess,
SOUP_SESSION_FEATURE(rss_soup_jar));
}
#endif
if (cb && data) {
info = g_new0(CallbackInfo, 1);
info->user_cb = cb;
info->user_data = data;
info->current = 0;
info->total = 0;
info->ss = soup_sess;
}
g_signal_connect (soup_sess, "authenticate",
G_CALLBACK (authenticate), (gpointer)url);
#if LIBSOUP_VERSION < 2003000
g_signal_connect (soup_sess, "reauthenticate",
G_CALLBACK (reauthenticate), (gpointer)url);
#endif
/* Queue an async HTTP request */
msg = soup_message_new ("GET", url);
if (!msg) {
g_free(info);
g_set_error(err, NET_ERROR, NET_ERROR_GENERIC, "%s",
soup_status_get_phrase(2)); //invalid url
return FALSE;
}
if (track) {
//we want to be able to abort this session by calling
//abort_all_soup
g_hash_table_insert(rf->session, soup_sess, msg);
g_hash_table_insert(rf->abort_session, soup_sess, msg);
g_hash_table_insert(rf->key_session, data, soup_sess);
}
agstr = g_strdup_printf("Evolution/%s; Evolution-RSS/%s",
EVOLUTION_VERSION_STRING, VERSION);
#if LIBSOUP_VERSION < 2003000
soup_message_add_header (msg->request_headers, "User-Agent",
agstr);
#else
soup_message_headers_append (msg->request_headers, "User-Agent",
agstr);
#endif
g_free(agstr);
if (info) {
g_signal_connect(G_OBJECT(msg), "got_chunk",
G_CALLBACK(got_chunk_cb), info); //FIXME Find a way to free this maybe weak_ref
soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT);
soup_message_add_header_handler (msg, "got_body",
"Location", G_CALLBACK (redirect_handler), info);
}
soup_message_body_set_accumulate (msg->response_body, FALSE);
stnet = g_new0(STNET, 1);
stnet->ss = soup_sess;
stnet->sm = msg;
stnet->cb2 = cb2;
stnet->cbdata2 = cbdata2;
stnet->url = url;
stnet->callback = idle_callback;
stnet->data = stnet;
if (!net_qid)
net_qid = g_idle_add((GSourceFunc)net_queue_dispatcher, NULL);
stnet->callback(stnet->data);
//// g_object_add_weak_pointer (G_OBJECT(msg), (gpointer)info);
g_object_weak_ref (G_OBJECT(msg), unblock_free, soup_sess);
// g_object_weak_ref (G_OBJECT(soup_sess), unblock_free, soup_sess);
// GMainLoop *mainloop = g_main_loop_new (g_main_context_default (), FALSE);
// g_timeout_add (10 * 1000, &conn_mainloop_quit, mainloop);
return TRUE;
}
bool oauth_login(
GtkBuilder *builder,
char **username_p,
char **auth_token_p,
char **auth_secret_p,
uint64_t *userid_p,
GError **err_p)
{
#if !USE_LOCAL_CGI
const char *token_uri = "https://api.twitter.com/oauth/request_token";
const char *access_uri = "https://api.twitter.com/oauth/access_token";
#else
const char *token_uri = "https://localhost/cgi-bin/oauth.cgi/request_token";
const char *access_uri = "https://localhost/cgi-bin/oauth.cgi/access_token";
#endif
SoupSession *ss = soup_session_async_new();
#if 0
SoupLogger *logger = soup_logger_new(1, -1);
soup_session_add_feature(ss, SOUP_SESSION_FEATURE(logger));
g_object_unref(logger);
#endif
SoupMessage *msg = make_token_request_msg(token_uri, CONSUMER_KEY,
CONSUMER_SECRET);
if(msg == NULL) {
/* FIXME */
abort();
}
soup_session_send_message(ss, msg);
bool ok;
if(msg->status_code != SOUP_STATUS_OK) {
fprintf(stderr, "%s: server returned status %d (%s)\n", __func__,
msg->status_code, soup_status_get_phrase(msg->status_code));
ok = false;
goto end;
}
/* interpret the response. */
char **rt_output = oa_parse_response(msg->response_body->data,
"oauth_token", "oauth_token_secret", NULL);
if(rt_output == NULL) {
g_set_error(err_p, 0, EINVAL, "can't parse response data");
ok = false;
goto end;
}
/* do out-of-band OAuth */
const char *req_token = rt_output[0], *req_secret = rt_output[1];
#if !USE_LOCAL_CGI
GError *err = NULL;
if(!launch_authorization_browser(req_token, &err)) {
fprintf(stderr, "warning: browser launching failed: %s\n",
err->message);
g_error_free(err);
}
#endif
char *pin = query_pin(builder);
printf("PIN is: `%s'\n", pin);
/* get an access token */
g_object_unref(msg);
msg = make_access_token_request_msg(access_uri, req_token, req_secret,
pin, CONSUMER_KEY, CONSUMER_SECRET);
g_free(pin);
if(msg == NULL) {
fprintf(stderr, "can't sign access request message!\n");
abort();
}
soup_session_send_message(ss, msg);
if(msg->status_code != SOUP_STATUS_OK) {
fprintf(stderr, "%s: server returned status %d (%s)\n", __func__,
msg->status_code, soup_status_get_phrase(msg->status_code));
/* FIXME: handle */
abort();
}
char **at_output = oa_parse_response(msg->response_body->data,
"oauth_token", "oauth_token_secret", "user_id", "screen_name", NULL);
if(at_output == NULL) {
/* FIXME: response data parsing fail */
abort();
}
/* the payoff */
*auth_token_p = g_strdup(at_output[0]);
*auth_secret_p = g_strdup(at_output[1]);
*userid_p = strtoull(at_output[2], NULL, 10);
*username_p = g_strdup(at_output[3]);
printf("login successful! username `%s', userid %llu\n", *username_p,
(unsigned long long)*userid_p);
g_strfreev(at_output);
g_strfreev(rt_output);
ok = true;
end:
g_object_unref(msg);
g_object_unref(ss);
return ok;
}
static SoupSession* createSoupSession()
{
return soup_session_async_new();
}
static void
do_session_property_tests (void)
{
gboolean use_system;
GTlsDatabase *tlsdb;
char *ca_file;
SoupSession *session;
GParamSpec *pspec;
g_test_bug ("700518");
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
session = soup_session_async_new ();
G_GNUC_END_IGNORE_DEPRECATIONS;
/* Temporarily undeprecate SOUP_SESSION_SSL_CA_FILE to avoid warnings. */
pspec = g_object_class_find_property (g_type_class_peek (SOUP_TYPE_SESSION),
SOUP_SESSION_SSL_CA_FILE);
pspec->flags &= ~G_PARAM_DEPRECATED;
g_object_get (G_OBJECT (session),
"ssl-use-system-ca-file", &use_system,
"tls-database", &tlsdb,
"ssl-ca-file", &ca_file,
NULL);
soup_test_assert (!use_system, "ssl-use-system-ca-file defaults to TRUE");
soup_test_assert (tlsdb == NULL, "tls-database set by default");
soup_test_assert (ca_file == NULL, "ca-file set by default");
g_object_set (G_OBJECT (session),
"ssl-use-system-ca-file", TRUE,
NULL);
g_object_get (G_OBJECT (session),
"ssl-ca-file", &ca_file,
NULL);
soup_test_assert (ca_file == NULL, "setting ssl-use-system-ca-file set ssl-ca-file");
g_object_set (G_OBJECT (session),
"ssl-ca-file",
g_test_get_filename (G_TEST_DIST, "test-cert.pem", NULL),
NULL);
g_object_get (G_OBJECT (session),
"ssl-use-system-ca-file", &use_system,
"tls-database", &tlsdb,
"ssl-ca-file", &ca_file,
NULL);
soup_test_assert (ca_file == NULL, "setting ssl-ca-file did not fail");
soup_test_assert (!use_system, "setting ssl-ca-file set ssl-use-system-ca-file");
soup_test_assert (tlsdb == NULL, "setting ssl-ca-file set tls-database");
g_object_set (G_OBJECT (session),
"tls-database", NULL,
NULL);
g_object_get (G_OBJECT (session),
"ssl-use-system-ca-file", &use_system,
"tls-database", &tlsdb,
"ssl-ca-file", &ca_file,
NULL);
soup_test_assert (tlsdb == NULL, "setting tls-database NULL failed");
soup_test_assert (!use_system, "setting tls-database NULL set ssl-use-system-ca-file");
soup_test_assert (ca_file == NULL, "setting tls-database NULL set ssl-ca-file");
soup_test_session_abort_unref (session);
/* Re-deprecate SOUP_SESSION_SSL_CA_FILE */
pspec->flags |= G_PARAM_DEPRECATED;
}
