static SoupBuffer *
content_decode (SoupMessage *msg, SoupBuffer *buf)
{
SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
SoupCoding *decoder;
SoupBuffer *decoded;
GError *error = NULL;
GSList *d;
for (d = priv->decoders; d; d = d->next) {
decoder = d->data;
decoded = soup_coding_apply (decoder, buf->data, buf->length,
FALSE, &error);
if (error) {
if (g_error_matches (error, SOUP_CODING_ERROR, SOUP_CODING_ERROR_INTERNAL_ERROR))
g_warning ("Content-Decoding error: %s\n", error->message);
g_error_free (error);
soup_message_set_flags (msg, priv->msg_flags & ~SOUP_MESSAGE_CONTENT_DECODED);
break;
}
if (buf)
soup_buffer_free (buf);
if (decoded)
buf = decoded;
else
return NULL;
}
return buf;
}
SoupMessage* ResourceRequest::toSoupMessage() const
{
SoupMessage* soupMessage = soup_message_new(httpMethod().utf8().data(), url().string().utf8().data());
if (!soupMessage)
return 0;
const HTTPHeaderMap& headers = httpHeaderFields();
SoupMessageHeaders* soupHeaders = soupMessage->request_headers;
if (!headers.isEmpty()) {
HTTPHeaderMap::const_iterator end = headers.end();
for (HTTPHeaderMap::const_iterator it = headers.begin(); it != end; ++it)
soup_message_headers_append(soupHeaders, it->first.string().utf8().data(), it->second.utf8().data());
}
#ifdef HAVE_LIBSOUP_2_29_90
String firstPartyString = firstPartyForCookies().string();
if (!firstPartyString.isEmpty()) {
GOwnPtr<SoupURI> firstParty(soup_uri_new(firstPartyString.utf8().data()));
soup_message_set_first_party(soupMessage, firstParty.get());
}
#endif
soup_message_set_flags(soupMessage, m_soupFlags);
// Body data is only handled at ResourceHandleSoup::startHttp for
// now; this is because this may not be a good place to go
// openning and mmapping files. We should maybe revisit this.
return soupMessage;
}
static void
do_digest_nonce_test (SoupSession *session,
const char *nth, const char *uri, gboolean use_auth_cache,
gboolean expect_401, gboolean expect_signal)
{
SoupMessage *msg;
gboolean got_401;
msg = soup_message_new (SOUP_METHOD_GET, uri);
if (!use_auth_cache) {
SoupMessageFlags flags = soup_message_get_flags (msg);
soup_message_set_flags (msg, flags | SOUP_MESSAGE_DO_NOT_USE_AUTH_CACHE);
}
if (expect_signal) {
g_signal_connect (session, "authenticate",
G_CALLBACK (digest_nonce_authenticate),
NULL);
}
soup_message_add_status_code_handler (msg, "got_headers",
SOUP_STATUS_UNAUTHORIZED,
G_CALLBACK (digest_nonce_unauthorized),
&got_401);
got_401 = FALSE;
soup_session_send_message (session, msg);
soup_test_assert (got_401 == expect_401,
"%s request %s a 401 Unauthorized!\n", nth,
got_401 ? "got" : "did not get");
soup_test_assert_message_status (msg, SOUP_STATUS_OK);
g_object_unref (msg);
}
void
nm_connectivity_check_async (NMConnectivity *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
NMConnectivityPrivate *priv;
#if WITH_CONCHECK
SoupMessage *msg;
#endif
GSimpleAsyncResult *simple;
g_return_if_fail (NM_IS_CONNECTIVITY (self));
priv = NM_CONNECTIVITY_GET_PRIVATE (self);
simple = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
nm_connectivity_check_async);
#if WITH_CONCHECK
if (priv->uri && priv->interval) {
msg = soup_message_new ("GET", priv->uri);
soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT);
soup_session_queue_message (priv->soup_session,
msg,
nm_connectivity_check_cb,
simple);
return;
}
#endif
g_simple_async_result_set_op_res_gssize (simple, priv->state);
g_simple_async_result_complete_in_idle (simple);
}
static gboolean
run_check (gpointer user_data)
{
NMConnectivity *self = NM_CONNECTIVITY (user_data);
NMConnectivityPrivate *priv;
SoupURI *soup_uri;
SoupMessage *msg;
g_return_val_if_fail (NM_IS_CONNECTIVITY (self), FALSE);
priv = NM_CONNECTIVITY_GET_PRIVATE (self);
/* check given url async */
soup_uri = soup_uri_new (priv->uri);
if (soup_uri && SOUP_URI_VALID_FOR_HTTP (soup_uri)) {
msg = soup_message_new_from_uri ("GET", soup_uri);
soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT);
soup_session_queue_message (priv->soup_session,
msg,
nm_connectivity_check_cb,
self);
priv->running = TRUE;
g_object_notify (G_OBJECT (self), NM_CONNECTIVITY_RUNNING);
nm_log_dbg (LOGD_CORE, "Connectivity check with uri '%s' started.", priv->uri);
} else
nm_log_err (LOGD_CORE, "Invalid uri '%s' for connectivity check.", priv->uri);
if (soup_uri)
soup_uri_free (soup_uri);
return TRUE; /* keep firing */
}
static SoupMessage *
cal_backend_http_new_message (ECalBackendHttp *backend,
const gchar *uri)
{
SoupMessage *soup_message;
/* create message to be sent to server */
soup_message = soup_message_new (SOUP_METHOD_GET, uri);
if (soup_message == NULL)
return NULL;
soup_message_headers_append (
soup_message->request_headers,
"User-Agent", "Evolution/" VERSION);
soup_message_headers_append (
soup_message->request_headers,
"Connection", "close");
soup_message_set_flags (
soup_message, SOUP_MESSAGE_NO_REDIRECT);
if (backend->priv->store != NULL) {
const gchar *etag;
etag = e_cal_backend_store_get_key_value (
backend->priv->store, "ETag");
if (etag != NULL && *etag != '\0')
soup_message_headers_append (
soup_message->request_headers,
"If-None-Match", etag);
}
return soup_message;
}
/* Reads data from io->sock into io->read_meta_buf. If @to_blank is
* %TRUE, it reads up until a blank line ("CRLF CRLF" or "LF LF").
* Otherwise, it reads up until a single CRLF or LF.
*
* This function is used to read metadata, and read_body_chunk() is
* used to read the message body contents.
*
* read_metadata, read_body_chunk, and write_data all use the same
* convention for return values: if they return %TRUE, it means
* they've completely finished the requested read/write, and the
* caller should move on to the next step. If they return %FALSE, it
* means that either (a) the socket returned SOUP_SOCKET_WOULD_BLOCK,
* so the caller should give up for now and wait for the socket to
* emit a signal, or (b) the socket returned an error, and io_error()
* was called to process it and cancel the I/O. So either way, if the
* function returns %FALSE, the caller should return immediately.
*/
static gboolean
read_metadata (SoupMessage *msg, gboolean to_blank)
{
SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
SoupMessageIOData *io = priv->io_data;
SoupSocketIOStatus status;
guchar read_buf[RESPONSE_BLOCK_SIZE];
gsize nread;
gboolean got_lf;
GError *error = NULL;
while (1) {
status = soup_socket_read_until (io->sock, read_buf,
sizeof (read_buf),
"\n", 1, &nread, &got_lf,
NULL, &error);
switch (status) {
case SOUP_SOCKET_OK:
g_byte_array_append (io->read_meta_buf, read_buf, nread);
break;
case SOUP_SOCKET_ERROR:
case SOUP_SOCKET_EOF:
io_error (io->sock, msg, error);
return FALSE;
case SOUP_SOCKET_WOULD_BLOCK:
return FALSE;
}
if (got_lf) {
if (!to_blank)
break;
if (nread == 1 &&
!strncmp ((char *)io->read_meta_buf->data +
io->read_meta_buf->len - 2,
"\n\n", 2))
break;
else if (nread == 2 &&
!strncmp ((char *)io->read_meta_buf->data +
io->read_meta_buf->len - 3,
"\n\r\n", 3))
break;
}
}
if (soup_socket_is_ssl (io->sock)) {
gboolean trusted_certificate;
g_object_get (io->sock,
SOUP_SOCKET_TRUSTED_CERTIFICATE, &trusted_certificate,
NULL);
if (trusted_certificate)
soup_message_set_flags (msg, priv->msg_flags | SOUP_MESSAGE_CERTIFICATE_TRUSTED);
}
return TRUE;
}
static void
do_message_has_authorization_header_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupAuthManager *manager;
SoupAuth *auth = NULL;
char *token;
guint auth_id;
char *uri;
g_test_bug ("775882");
SOUP_TEST_SKIP_IF_NO_APACHE;
session = soup_test_session_new (SOUP_TYPE_SESSION, NULL);
uri = g_strconcat (base_uri, "Digest/realm1/", NULL);
msg = soup_message_new ("GET", uri);
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (has_authorization_header_authenticate), &auth);
soup_session_send_message (session, msg);
soup_test_assert_message_status (msg, SOUP_STATUS_OK);
soup_test_assert (SOUP_IS_AUTH (auth), "Expected a SoupAuth");
token = soup_auth_get_authorization (auth, msg);
g_object_unref (auth);
g_object_unref (msg);
g_signal_handler_disconnect (session, auth_id);
manager = SOUP_AUTH_MANAGER (soup_session_get_feature (session, SOUP_TYPE_AUTH_MANAGER));
soup_auth_manager_clear_cached_credentials (manager);
msg = soup_message_new ("GET", uri);
soup_message_headers_replace (msg->request_headers, "Authorization", token);
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (has_authorization_header_authenticate_assert),
NULL);
soup_session_send_message (session, msg);
soup_test_assert_message_status (msg, SOUP_STATUS_OK);
g_object_unref (msg);
/* Check that we can also provide our own Authorization header when not using credentials cache. */
soup_auth_manager_clear_cached_credentials (manager);
msg = soup_message_new ("GET", uri);
soup_message_headers_replace (msg->request_headers, "Authorization", token);
soup_message_set_flags (msg, soup_message_get_flags (msg) | SOUP_MESSAGE_DO_NOT_USE_AUTH_CACHE);
soup_session_send_message (session, msg);
soup_test_assert_message_status (msg, SOUP_STATUS_OK);
g_object_unref (msg);
g_free (token);
g_signal_handler_disconnect (session, auth_id);
g_free (uri);
soup_test_session_abort_unref (session);
}
void
nm_connectivity_check_async (NMConnectivity *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
NMConnectivityPrivate *priv;
GSimpleAsyncResult *simple;
g_return_if_fail (NM_IS_CONNECTIVITY (self));
priv = NM_CONNECTIVITY_GET_PRIVATE (self);
simple = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
nm_connectivity_check_async);
#if WITH_CONCHECK
if (priv->uri && priv->interval) {
SoupMessage *msg;
ConCheckCbData *cb_data = g_slice_new (ConCheckCbData);
msg = soup_message_new ("GET", priv->uri);
soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT);
/* Disable HTTP/1.1 keepalive; the connection should not persist */
soup_message_headers_append (msg->request_headers, "Connection", "close");
cb_data->simple = simple;
cb_data->uri = g_strdup (priv->uri);
cb_data->response = g_strdup (priv->response);
/* For internal calls (periodic), remember the check-id at time of scheduling. */
cb_data->check_id_when_scheduled = IS_PERIODIC_CHECK (callback) ? priv->check_id : 0;
soup_session_queue_message (priv->soup_session,
msg,
nm_connectivity_check_cb,
cb_data);
priv->initial_check_obsoleted = TRUE;
_LOGD ("check: send %srequest to '%s'", IS_PERIODIC_CHECK (callback) ? "periodic " : "", priv->uri);
return;
} else {
g_warn_if_fail (!IS_PERIODIC_CHECK (callback));
_LOGD ("check: faking request. Connectivity check disabled");
}
#else
_LOGD ("check: faking request. Compiled without connectivity-check support");
#endif
g_simple_async_result_set_op_res_gssize (simple, priv->state);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
}
static gboolean
gst_soup_http_src_build_message (GstSoupHTTPSrc * src)
{
src->msg = soup_message_new (SOUP_METHOD_GET, src->location);
if (!src->msg) {
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
("Error parsing URL."), ("URL: %s", src->location));
return FALSE;
}
src->session_io_status = GST_SOUP_HTTP_SRC_SESSION_IO_STATUS_IDLE;
soup_message_headers_append (src->msg->request_headers, "Connection",
"close");
if (src->iradio_mode) {
soup_message_headers_append (src->msg->request_headers, "icy-metadata",
"1");
}
if (src->cookies) {
gchar **cookie;
for (cookie = src->cookies; *cookie != NULL; cookie++) {
soup_message_headers_append (src->msg->request_headers, "Cookie",
*cookie);
}
}
soup_message_headers_append (src->msg->request_headers,
"transferMode.dlna.org", "Streaming");
src->retry = FALSE;
g_signal_connect (src->msg, "got_headers",
G_CALLBACK (gst_soup_http_src_got_headers_cb), src);
g_signal_connect (src->msg, "got_body",
G_CALLBACK (gst_soup_http_src_got_body_cb), src);
g_signal_connect (src->msg, "finished",
G_CALLBACK (gst_soup_http_src_finished_cb), src);
g_signal_connect (src->msg, "got_chunk",
G_CALLBACK (gst_soup_http_src_got_chunk_cb), src);
soup_message_set_flags (src->msg, SOUP_MESSAGE_OVERWRITE_CHUNKS |
(src->automatic_redirect ? 0 : SOUP_MESSAGE_NO_REDIRECT));
soup_message_set_chunk_allocator (src->msg,
gst_soup_http_src_chunk_allocator, src, NULL);
gst_soup_http_src_add_range_header (src, src->request_position);
gst_soup_http_src_add_extra_headers (src);
GST_DEBUG_OBJECT (src, "request headers:");
soup_message_headers_foreach (src->msg->request_headers,
gst_soup_http_src_headers_foreach, src);
return TRUE;
}
void ResourceRequest::updateSoupMessageMembers(SoupMessage* soupMessage) const
{
updateSoupMessageHeaders(soupMessage->request_headers);
String firstPartyString = firstPartyForCookies().string();
if (!firstPartyString.isEmpty()) {
GOwnPtr<SoupURI> firstParty(soup_uri_new(firstPartyString.utf8().data()));
soup_message_set_first_party(soupMessage, firstParty.get());
}
soup_message_set_flags(soupMessage, m_soupFlags);
if (!acceptEncoding())
soup_message_disable_feature(soupMessage, SOUP_TYPE_CONTENT_DECODER);
}
void
http_client_request(const char *url, const char *post_data,
const struct http_client_handler *handler, void *ctx)
{
SoupMessage *msg;
struct http_request *request;
if (post_data) {
msg = soup_message_new(SOUP_METHOD_POST, url);
#ifdef HAVE_SOUP_24
soup_message_set_request
(msg, "application/x-www-form-urlencoded",
SOUP_MEMORY_COPY, post_data, strlen(post_data));
soup_message_headers_append(msg->request_headers, "User-Agent",
"mpdscribble/" VERSION);
soup_message_headers_append(msg->request_headers, "Pragma",
"no-cache");
soup_message_headers_append(msg->request_headers, "Accept",
"*/*");
#else
soup_message_set_request
(msg, "application/x-www-form-urlencoded",
SOUP_BUFFER_SYSTEM_OWNED, g_strdup(post_data),
strlen(post_data));
soup_message_add_header(msg->request_headers, "User-Agent",
"mpdscribble/" VERSION);
soup_message_add_header(msg->request_headers, "Pragma",
"no-cache");
soup_message_add_header(msg->request_headers, "Accept", "*/*");
#endif
} else {
msg = soup_message_new(SOUP_METHOD_GET, url);
}
soup_message_set_flags(msg, SOUP_MESSAGE_NO_REDIRECT);
request = g_new(struct http_request, 1);
request->handler = handler;
request->handler_ctx = ctx;
soup_session_queue_message(http_client.session, msg,
http_client_soup_callback, request);
}
static void gotHeadersCallback(SoupMessage* msg, gpointer data)
{
if (!SOUP_STATUS_IS_SUCCESSFUL(msg->status_code))
return;
ResourceHandle* handle = static_cast<ResourceHandle*>(data);
if (!handle)
return;
ResourceHandleInternal* d = handle->getInternal();
if (d->m_cancelled)
return;
ResourceHandleClient* client = handle->client();
if (!client)
return;
fillResponseFromMessage(msg, &d->m_response);
client->didReceiveResponse(handle, d->m_response);
soup_message_set_flags(msg, SOUP_MESSAGE_OVERWRITE_CHUNKS);
}
void ResourceRequest::updateSoupMessage(SoupMessage* soupMessage) const
{
g_object_set(soupMessage, SOUP_MESSAGE_METHOD, httpMethod().utf8().data(), NULL);
const HTTPHeaderMap& headers = httpHeaderFields();
SoupMessageHeaders* soupHeaders = soupMessage->request_headers;
if (!headers.isEmpty()) {
HTTPHeaderMap::const_iterator end = headers.end();
for (HTTPHeaderMap::const_iterator it = headers.begin(); it != end; ++it)
soup_message_headers_append(soupHeaders, it->first.string().utf8().data(), it->second.utf8().data());
}
String firstPartyString = firstPartyForCookies().string();
if (!firstPartyString.isEmpty()) {
GOwnPtr<SoupURI> firstParty(soup_uri_new(firstPartyString.utf8().data()));
soup_message_set_first_party(soupMessage, firstParty.get());
}
soup_message_set_flags(soupMessage, m_soupFlags);
}
static void
auth_got_body (SoupMessage *msg, gpointer manager)
{
SoupAuthManagerPrivate *priv = SOUP_AUTH_MANAGER (manager)->priv;
SoupAuth *auth;
g_mutex_lock (&priv->lock);
auth = lookup_auth (priv, msg);
if (auth && soup_auth_is_ready (auth, msg)) {
if (SOUP_IS_CONNECTION_AUTH (auth)) {
SoupMessageFlags flags;
flags = soup_message_get_flags (msg);
soup_message_set_flags (msg, flags & ~SOUP_MESSAGE_NEW_CONNECTION);
}
soup_session_requeue_message (priv->session, msg);
}
g_mutex_unlock (&priv->lock);
}
SoupMessage* ResourceResponse::toSoupMessage() const
{
// This GET here is just because SoupMessage wants it, we dn't really know.
SoupMessage* soupMessage = soup_message_new("GET", url().string().utf8().data());
if (!soupMessage)
return 0;
soupMessage->status_code = httpStatusCode();
const HTTPHeaderMap& headers = httpHeaderFields();
SoupMessageHeaders* soupHeaders = soupMessage->response_headers;
if (!headers.isEmpty()) {
HTTPHeaderMap::const_iterator end = headers.end();
for (HTTPHeaderMap::const_iterator it = headers.begin(); it != end; ++it)
soup_message_headers_append(soupHeaders, it->first.string().utf8().data(), it->second.utf8().data());
}
soup_message_set_flags(soupMessage, m_soupFlags);
// Body data is not in the message.
return soupMessage;
}
SoupMessage* ResourceResponse::toSoupMessage() const
{
// This GET here is just because SoupMessage wants it, we dn't really know.
SoupMessage* soupMessage = soup_message_new("GET", url().string().utf8().data());
if (!soupMessage)
return 0;
soupMessage->status_code = httpStatusCode();
const HTTPHeaderMap& headers = httpHeaderFields();
SoupMessageHeaders* soupHeaders = soupMessage->response_headers;
if (!headers.isEmpty()) {
HTTPHeaderMap::const_iterator end = headers.end();
for (HTTPHeaderMap::const_iterator it = headers.begin(); it != end; ++it)
soup_message_headers_append(soupHeaders, it->key.string().utf8().data(), it->value.utf8().data());
}
soup_message_set_flags(soupMessage, m_soupFlags);
g_object_set(G_OBJECT(soupMessage), "tls-certificate", m_certificate.get(), "tls-errors", m_tlsErrors, NULL);
// Body data is not in the message.
return soupMessage;
}
SoupMessageQueueItem *
soup_session_make_connect_message (SoupSession *session,
SoupAddress *server_addr)
{
SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
SoupURI *uri;
SoupMessage *msg;
uri = soup_uri_new (NULL);
soup_uri_set_scheme (uri, SOUP_URI_SCHEME_HTTPS);
soup_uri_set_host (uri, soup_address_get_name (server_addr));
soup_uri_set_port (uri, soup_address_get_port (server_addr));
soup_uri_set_path (uri, "");
msg = soup_message_new_from_uri (SOUP_METHOD_CONNECT, uri);
soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT);
soup_uri_free (uri);
/* Call the base implementation of soup_session_queue_message
* directly, to add msg to the SoupMessageQueue and cause all
* the right signals to be emitted.
*/
queue_message (session, msg, tunnel_connected, NULL);
return soup_message_queue_lookup (priv->queue, msg);
}
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;
}
static void
do_request_test (SoupSession *session, SoupURI *base_uri, RequestTestFlags flags)
{
SoupURI *uri = base_uri;
PutTestData ptd;
SoupMessage *msg;
const char *client_md5, *server_md5;
GChecksum *check;
int i, length;
debug_printf (1, "PUT");
if (flags & HACKY_STREAMING)
debug_printf (1, " w/ hacky streaming");
else if (flags & PROPER_STREAMING)
debug_printf (1, " w/ proper streaming");
if (flags & RESTART) {
debug_printf (1, " and restart");
uri = soup_uri_copy (base_uri);
soup_uri_set_path (uri, "/redirect");
}
debug_printf (1, "\n");
ptd.session = session;
setup_request_body (&ptd);
ptd.streaming = flags & (HACKY_STREAMING | PROPER_STREAMING);
check = g_checksum_new (G_CHECKSUM_MD5);
length = 0;
for (i = 0; i < 3; i++) {
g_checksum_update (check, (guchar *)ptd.chunks[i]->data,
ptd.chunks[i]->length);
length += ptd.chunks[i]->length;
}
client_md5 = g_checksum_get_string (check);
msg = soup_message_new_from_uri ("PUT", uri);
soup_message_headers_set_encoding (msg->request_headers, SOUP_ENCODING_CHUNKED);
soup_message_body_set_accumulate (msg->request_body, FALSE);
soup_message_set_chunk_allocator (msg, error_chunk_allocator, NULL, NULL);
if (flags & HACKY_STREAMING) {
g_signal_connect (msg, "wrote_chunk",
G_CALLBACK (write_next_chunk_streaming_hack), &ptd);
if (flags & RESTART) {
g_signal_connect (msg, "restarted",
G_CALLBACK (restarted_streaming_hack), &ptd);
}
} else {
g_signal_connect (msg, "wrote_chunk",
G_CALLBACK (write_next_chunk), &ptd);
}
if (flags & PROPER_STREAMING) {
soup_message_set_flags (msg, SOUP_MESSAGE_CAN_REBUILD);
if (flags & RESTART) {
g_signal_connect (msg, "restarted",
G_CALLBACK (restarted_streaming), &ptd);
}
}
g_signal_connect (msg, "wrote_headers",
G_CALLBACK (write_next_chunk), &ptd);
g_signal_connect (msg, "wrote_body_data",
G_CALLBACK (wrote_body_data), &ptd);
soup_session_send_message (session, msg);
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
debug_printf (1, " message failed: %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
if (msg->request_body->data) {
debug_printf (1, " msg->request_body set!\n");
errors++;
}
if (msg->request_body->length != length || length != ptd.nwrote) {
debug_printf (1, " sent length mismatch: %d vs %d vs %d\n",
(int)msg->request_body->length, length, ptd.nwrote);
errors++;
}
server_md5 = soup_message_headers_get_one (msg->response_headers,
"Content-MD5");
if (!server_md5 || strcmp (client_md5, server_md5) != 0) {
debug_printf (1, " client/server data mismatch: %s vs %s\n",
client_md5, server_md5 ? server_md5 : "(null)");
errors++;
}
g_object_unref (msg);
g_checksum_free (check);
if (uri != base_uri)
soup_uri_free (uri);
}
// 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;
}
static void
send_message_locked (GstSoupHttpClientSink * souphttpsink)
{
GList *g;
guint64 n;
if (souphttpsink->queued_buffers == NULL || souphttpsink->message) {
return;
}
/* If the URI went away, drop all these buffers */
if (souphttpsink->location == NULL) {
GST_DEBUG_OBJECT (souphttpsink, "URI went away, dropping queued buffers");
g_list_free_full (souphttpsink->queued_buffers,
(GDestroyNotify) gst_buffer_unref);
souphttpsink->queued_buffers = NULL;
return;
}
souphttpsink->message = soup_message_new ("PUT", souphttpsink->location);
if (souphttpsink->message == NULL) {
GST_WARNING_OBJECT (souphttpsink,
"URI could not be parsed while creating message.");
g_list_free_full (souphttpsink->queued_buffers,
(GDestroyNotify) gst_buffer_unref);
souphttpsink->queued_buffers = NULL;
return;
}
soup_message_set_flags (souphttpsink->message,
(souphttpsink->automatic_redirect ? 0 : SOUP_MESSAGE_NO_REDIRECT));
if (souphttpsink->cookies) {
gchar **cookie;
for (cookie = souphttpsink->cookies; *cookie != NULL; cookie++) {
soup_message_headers_append (souphttpsink->message->request_headers,
"Cookie", *cookie);
}
}
n = 0;
if (souphttpsink->offset == 0) {
for (g = souphttpsink->streamheader_buffers; g; g = g_list_next (g)) {
GstBuffer *buffer = g->data;
GstMapInfo map;
GST_DEBUG_OBJECT (souphttpsink, "queueing stream headers");
gst_buffer_map (buffer, &map, GST_MAP_READ);
/* Stream headers are updated whenever ::set_caps is called, so there's
* no guarantees about their lifetime and we ask libsoup to copy them
* into the message body with SOUP_MEMORY_COPY. */
soup_message_body_append (souphttpsink->message->request_body,
SOUP_MEMORY_COPY, map.data, map.size);
n += map.size;
gst_buffer_unmap (buffer, &map);
}
}
for (g = souphttpsink->queued_buffers; g; g = g_list_next (g)) {
GstBuffer *buffer = g->data;
if (!GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_HEADER)) {
GstMapInfo map;
gst_buffer_map (buffer, &map, GST_MAP_READ);
/* Queued buffers are only freed in the next iteration of the mainloop
* after the message body has been written out, so we don't need libsoup
* to copy those while appending to the body. However, if the buffer is
* used elsewhere, it should be copied. Hence, SOUP_MEMORY_TEMPORARY. */
soup_message_body_append (souphttpsink->message->request_body,
SOUP_MEMORY_TEMPORARY, map.data, map.size);
n += map.size;
gst_buffer_unmap (buffer, &map);
}
}
if (souphttpsink->offset != 0) {
char *s;
s = g_strdup_printf ("bytes %" G_GUINT64_FORMAT "-%" G_GUINT64_FORMAT "/*",
souphttpsink->offset, souphttpsink->offset + n - 1);
soup_message_headers_append (souphttpsink->message->request_headers,
"Content-Range", s);
g_free (s);
}
if (n == 0) {
GST_DEBUG_OBJECT (souphttpsink,
"total size of buffers queued is 0, freeing everything");
g_list_free_full (souphttpsink->queued_buffers,
(GDestroyNotify) gst_buffer_unref);
souphttpsink->queued_buffers = NULL;
g_object_unref (souphttpsink->message);
souphttpsink->message = NULL;
return;
}
souphttpsink->sent_buffers = souphttpsink->queued_buffers;
souphttpsink->queued_buffers = NULL;
GST_DEBUG_OBJECT (souphttpsink,
"queue message %" G_GUINT64_FORMAT " %" G_GUINT64_FORMAT,
souphttpsink->offset, n);
soup_session_queue_message (souphttpsink->session, souphttpsink->message,
callback, souphttpsink);
souphttpsink->offset += n;
}
SoupBuffer *
open_app_get_data_by_request (SoupSession *session, const gchar *request)
{
SoupMessage *msg;
SoupBuffer *buf;
const gchar *name;
const gchar *header;
const gchar *method;
g_return_val_if_fail (request != NULL, NULL);
// g_debug ("open_app_get_data_by_request: %s\n", request);
buf = NULL;
method = SOUP_METHOD_GET;
msg = soup_message_new (method, request);
soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT);
soup_session_send_message (session, msg);
name = soup_message_get_uri (msg)->path;
if (SOUP_STATUS_IS_TRANSPORT_ERROR (msg->status_code)) {
g_debug ("%s: %d %s\n", name, msg->status_code, msg->reason_phrase);
} else {
#ifdef SERVER_DEBUG
SoupMessageHeadersIter iter;
const gchar *hname, *value;
gchar *path = soup_uri_to_string (soup_message_get_uri (msg), TRUE);
g_debug ("%s %s HTTP/1.%d\n", method, path,
soup_message_get_http_version (msg));
g_free (path);
soup_message_headers_iter_init (&iter, msg->request_headers);
while (soup_message_headers_iter_next (&iter, &hname, &value))
g_debug ("%s: %s\r\n", hname, value);
g_debug ("\n");
g_debug ("HTTP/1.%d %d %s\n",
soup_message_get_http_version (msg),
msg->status_code, msg->reason_phrase);
soup_message_headers_iter_init (&iter, msg->response_headers);
while (soup_message_headers_iter_next (&iter, &hname, &value))
g_debug ("%s: %s\r\n", hname, value);
g_debug ("\n");
#endif
}
if (SOUP_STATUS_IS_REDIRECTION (msg->status_code)) {
header = soup_message_headers_get_one (msg->response_headers,
"Location");
if (header) {
SoupURI *request;
gchar *request_string;
g_debug (" -> %s\n", header);
request = soup_uri_new_with_base (soup_message_get_uri (msg), header);
request_string = soup_uri_to_string (request, FALSE);
buf = open_app_get_data_by_request (session, request_string);
g_free (request_string);
soup_uri_free (request);
}
} else if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
buf = soup_message_body_flatten (msg->response_body);
}
g_object_unref (msg);
return buf;
}
static void
get_url (const char *url)
{
const char *name;
SoupMessage *msg;
const char *header;
FILE *output_file = NULL;
msg = soup_message_new (head ? "HEAD" : "GET", url);
soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT);
if (loop) {
g_object_ref (msg);
soup_session_queue_message (session, msg, finished, loop);
g_main_loop_run (loop);
} else
soup_session_send_message (session, msg);
name = soup_message_get_uri (msg)->path;
if (!debug) {
if (msg->status_code == SOUP_STATUS_SSL_FAILED) {
GTlsCertificateFlags flags;
if (soup_message_get_https_status (msg, NULL, &flags))
g_print ("%s: %d %s (0x%x)\n", name, msg->status_code, msg->reason_phrase, flags);
else
g_print ("%s: %d %s (no handshake status)\n", name, msg->status_code, msg->reason_phrase);
} else if (!quiet || SOUP_STATUS_IS_TRANSPORT_ERROR (msg->status_code))
g_print ("%s: %d %s\n", name, msg->status_code, msg->reason_phrase);
}
if (SOUP_STATUS_IS_REDIRECTION (msg->status_code)) {
header = soup_message_headers_get_one (msg->response_headers,
"Location");
if (header) {
SoupURI *uri;
char *uri_string;
if (!debug && !quiet)
g_print (" -> %s\n", header);
uri = soup_uri_new_with_base (soup_message_get_uri (msg), header);
uri_string = soup_uri_to_string (uri, FALSE);
get_url (uri_string);
g_free (uri_string);
soup_uri_free (uri);
}
} else if (!head && SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
if (output_file_path) {
output_file = fopen (output_file_path, "w");
if (!output_file)
g_printerr ("Error trying to create file %s.\n", output_file_path);
} else if (!quiet)
output_file = stdout;
if (output_file) {
fwrite (msg->response_body->data,
1,
msg->response_body->length,
output_file);
if (output_file_path)
fclose (output_file);
}
}
}
