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;
}
static GByteArray *
idol_pl_parser_load_http_itunes (const char *uri)
{
SoupMessage *msg;
SoupSession *session;
GByteArray *data;
session = soup_session_sync_new_with_options (
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_GNOME_FEATURES_2_26,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
SOUP_SESSION_USER_AGENT, "iTunes/7.4.1",
SOUP_SESSION_ACCEPT_LANGUAGE_AUTO, TRUE,
NULL);
msg = soup_message_new (SOUP_METHOD_GET, uri);
soup_session_send_message (session, msg);
if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
data = g_byte_array_new ();
g_byte_array_append (data,
(guchar *) msg->response_body->data,
msg->response_body->length);
} else {
return NULL;
}
g_object_unref (msg);
g_object_unref (session);
return data;
}
/**
* as_app_validate_setup_networking:
**/
static gboolean
as_app_validate_setup_networking (AsAppValidateHelper *helper, GError **error)
{
helper->session = soup_session_sync_new_with_options (SOUP_SESSION_USER_AGENT,
"libappstream-glib",
SOUP_SESSION_TIMEOUT,
5000,
NULL);
if (helper->session == NULL) {
g_set_error_literal (error,
AS_APP_ERROR,
AS_APP_ERROR_FAILED,
"Failed to set up networking");
return FALSE;
}
soup_session_add_feature_by_type (helper->session,
SOUP_TYPE_PROXY_RESOLVER_DEFAULT);
return TRUE;
}
int
main (int argc, char **argv)
{
MinCloudAgentApp selfstruct = { 0, };
MinCloudAgentApp *self = &selfstruct;
GCancellable *cancellable = NULL;
const char *src_address;
guint srcport = 80;
g_setenv ("GIO_USE_VFS", "local", TRUE);
if (!prepare_root_ssh (cancellable, &self->error))
goto out;
src_address = g_getenv ("MIN_CLOUDAGENT_ADDRESS");
if (!src_address)
src_address = "169.254.169.254";
{
const char *srcport_str = g_getenv ("MIN_CLOUDAGENT_PORT");
if (srcport_str)
srcport = (guint) g_ascii_strtoull (srcport_str, NULL, 10);
}
self->addr = g_inet_address_new_from_string (src_address);
self->addr_port = (GInetSocketAddress*)g_inet_socket_address_new (self->addr, srcport);
self->netmon = g_network_monitor_get_default ();
self->cancellable = cancellable;
self->running = TRUE;
self->session = soup_session_sync_new_with_options (SOUP_SESSION_USER_AGENT, "min-cloud-agent",
SOUP_SESSION_SSL_USE_SYSTEM_CA_FILE, TRUE,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
NULL);
self->authorized_keys_path = g_file_new_for_path ("/root/.ssh/authorized_keys");
self->userdata_done_stamp = g_file_new_for_path (MIN_CLOUD_AGENT_STATEDIR "/userdata.stamp");
self->done_stamp = g_file_new_for_path (MIN_CLOUD_AGENT_STATEDIR "/done.stamp");
if (g_file_query_exists (self->done_stamp, NULL))
goto out;
g_signal_connect (self->netmon, "network-changed",
G_CALLBACK (on_network_changed),
self);
recheck_metadata_reachability (self);
while (self->running && self->error == NULL)
g_main_context_iteration (NULL, TRUE);
if (self->error)
goto out;
if (!g_file_replace_contents (self->done_stamp, "done\n", 5,
NULL, FALSE, 0,
NULL, cancellable, &self->error))
goto out;
out:
if (self->error)
{
g_printerr ("error: %s\n", self->error->message);
return 1;
}
return 0;
}
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);
}
}
gboolean
net_queue_dispatcher(void)
{
STNET *_stnet;
guint qlen = g_queue_get_length(rf->stqueue);
d("que len:%d workers:%d\n",
g_queue_get_length(rf->stqueue),
net_queue_run_count);
#if EVOLUTION_VERSION < 30304
if (qlen && net_queue_run_count < gconf_client_get_int (
rss_gconf,
GCONF_KEY_DOWNLOAD_QUEUE_SIZE,
NULL)) {
#else
if (qlen && net_queue_run_count < g_settings_get_int (
settings,
CONF_DOWNLOAD_QUEUE_SIZE)) {
#endif
net_queue_run_count++;
_stnet = g_queue_pop_head(rf->stqueue);
soup_session_queue_message (
_stnet->ss,
_stnet->sm,
_stnet->cb2,
_stnet->cbdata2);
g_free(_stnet);
return TRUE;
}
net_qid = 0;
return FALSE;
}
GString*
net_post_blocking(gchar *url,
GSList *headers,
GString *post,
NetStatusCallback cb,
gpointer data,
GError **err) {
#if LIBSOUP_VERSION < 2003000
SoupUri *suri = NULL;
#else
SoupURI *suri = NULL;
#endif
SoupMessage *req = NULL;
GString *response = NULL;
CallbackInfo info = { cb, data, 0, 0 };
SoupSession *soup_sess = NULL;
gchar *agstr;
if (!rf->b_session)
rf->b_session = soup_sess =
soup_session_sync_new_with_options(
SOUP_SESSION_TIMEOUT,
SS_TIMEOUT,
NULL);
else
soup_sess = rf->b_session;
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
req = soup_message_new(SOUP_METHOD_GET, url);
if (!req) {
g_set_error(err, NET_ERROR, NET_ERROR_GENERIC, "%s",
soup_status_get_phrase(2)); //invalid url
goto out;
}
d("request ok :%d\n", req->status_code);
g_signal_connect(G_OBJECT(req), "got-chunk",
G_CALLBACK(got_chunk_blocking_cb), &info);
for (; headers; headers = headers->next) {
char *header = headers->data;
/* soup wants the key and value separate, so we have to munge this
* a bit. */
char *colonpos = strchr(header, ':');
*colonpos = 0;
#if LIBSOUP_VERSION < 2003000
soup_message_add_header(
req->request_headers,
header,
colonpos+1);
#else
soup_message_headers_append(
req->request_headers, header, colonpos+1);
#endif
*colonpos = ':';
}
agstr = g_strdup_printf("Evolution/%s; Evolution-RSS/%s",
EVOLUTION_VERSION_STRING, VERSION);
#if LIBSOUP_VERSION < 2003000
soup_message_add_header (
req->request_headers,
"User-Agent",
agstr);
#else
soup_message_headers_append (
req->request_headers,
"User-Agent",
agstr);
#endif
g_free(agstr);
#if (DATASERVER_VERSION >= 2023001)
proxify_session(proxy, soup_sess, url);
#endif
rf->b_session = soup_sess;
rf->b_msg_session = req;
soup_session_send_message(soup_sess, req);
if (req->status_code != SOUP_STATUS_OK) {
//might not be a good ideea
soup_session_abort(soup_sess);
g_object_unref(soup_sess);
rf->b_session = NULL;
g_set_error(err, NET_ERROR, NET_ERROR_GENERIC, "%s",
soup_status_get_phrase(req->status_code));
goto out;
}
#if LIBSOUP_VERSION < 2003000
response = g_string_new_len(
req->response.body,
req->response.length);
#else
response = g_string_new_len(
req->response_body->data,
req->response_body->length);
#endif
out:
if (suri) soup_uri_free(suri);
if (req) g_object_unref(G_OBJECT(req));
return response;
}
guint
net_get_status(const char *url, GError **err)
{
#if LIBSOUP_VERSION < 2003000
SoupUri *suri = NULL;
#else
SoupURI *suri = NULL;
#endif
SoupMessage *req = NULL;
guint response = 0;
SoupSession *soup_sess = NULL;
GSList *headers = NULL;
gchar *agstr;
if (!rf->b_session)
rf->b_session = soup_sess =
soup_session_sync_new_with_options(
SOUP_SESSION_TIMEOUT, SS_TIMEOUT, NULL);
else
soup_sess = rf->b_session;
req = soup_message_new(SOUP_METHOD_GET, url);
if (!req) {
g_set_error(err, NET_ERROR, NET_ERROR_GENERIC, "%s",
soup_status_get_phrase(2)); //invalid url
goto out;
}
for (; headers; headers = headers->next) {
char *header = headers->data;
/* soup wants the key and value separate, so we have to munge this
* a bit. */
char *colonpos = strchr(header, ':');
*colonpos = 0;
#if LIBSOUP_VERSION < 2003000
soup_message_add_header(
req->request_headers, header, colonpos+1);
#else
soup_message_headers_append(
req->request_headers, header, colonpos+1);
#endif
*colonpos = ':';
}
agstr = g_strdup_printf("Evolution/%s; Evolution-RSS/%s",
EVOLUTION_VERSION_STRING, VERSION);
#if LIBSOUP_VERSION < 2003000
soup_message_add_header (req->request_headers,
"User-Agent",
agstr);
#else
soup_message_headers_append (req->request_headers,
"User-Agent",
agstr);
#endif
g_free(agstr);
rf->b_session = soup_sess;
rf->b_msg_session = req;
soup_session_send_message(soup_sess, req);
if (req->status_code != SOUP_STATUS_OK) {
//might not be a good ideea
soup_session_abort(soup_sess);
g_object_unref(soup_sess);
rf->b_session = NULL;
g_set_error(err, NET_ERROR, NET_ERROR_GENERIC, "%s",
soup_status_get_phrase(req->status_code));
goto out;
}
out:
if (suri) soup_uri_free(suri);
response = req->status_code;
if (req) g_object_unref(G_OBJECT(req));
return response;
}
