static void
gdav_request_send (SoupRequestHTTP *request,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
SoupMessage *message;
/* This is an internal wrapper for soup_request_send_async().
* The input stream contents are written to the SoupMessage
* response body to ensure a SoupLogger sees it. */
task = g_task_new (request, cancellable, callback, user_data);
message = soup_request_http_get_message (request);
g_task_set_task_data (task, message, g_object_unref);
soup_request_send_async (
SOUP_REQUEST (request),
cancellable,
gdav_request_send_cb,
g_object_ref (task));
g_object_unref (task);
}
void
multipart_request_send_async (SoupRequest *request,
GCancellable *cancellable,
MultiPartCallback callback,
MultiPartDestroy destroy,
gpointer user_data)
{
MultiPartData *multipart_data = g_slice_new0 (MultiPartData);
multipart_data->callback = callback;
multipart_data->destroy = destroy;
multipart_data->user_data = user_data;
multipart_data->cancellable = cancellable;
multipart_data->buffer = NULL;
soup_request_send_async(request, cancellable, request_sent_cb, multipart_data);
}
static void
get_url_now (GrlNetWc *self,
const char *url,
GHashTable *headers,
GAsyncResult *result,
GCancellable *cancellable)
{
GrlNetWcPrivate *priv = self->priv;
struct request_res *rr = g_slice_new0 (struct request_res);
g_simple_async_result_set_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result),
rr,
NULL);
#ifdef LIBSOUP_REQUESTER_DEPRECATED
SoupURI *uri = soup_uri_new (url);
rr->request = soup_session_request_uri (priv->session, uri, NULL);
soup_uri_free (uri);
#else
rr->request = soup_requester_request (priv->requester, url, NULL);
#endif
if (headers != NULL) {
SoupMessage *message;
GHashTableIter iter;
const char *key, *value;
message = soup_request_http_get_message (SOUP_REQUEST_HTTP (rr->request));
if (message) {
g_hash_table_iter_init (&iter, headers);
while (g_hash_table_iter_next (&iter, (gpointer *) &key, (gpointer *)&value)) {
soup_message_headers_append (message->request_headers, key, value);
}
g_object_unref (message);
}
}
soup_request_send_async (rr->request, cancellable, reply_cb, result);
}
GInputStream *
soup_test_request_send (SoupRequest *req,
GCancellable *cancellable,
GError **error)
{
AsyncAsSyncData data;
GInputStream *stream;
if (SOUP_IS_SESSION_SYNC (soup_request_get_session (req)))
return soup_request_send (req, cancellable, error);
data.loop = g_main_loop_new (g_main_context_get_thread_default (), FALSE);
soup_request_send_async (req, cancellable, async_as_sync_callback, &data);
g_main_loop_run (data.loop);
stream = soup_request_send_finish (req, data.result, error);
g_main_loop_unref (data.loop);
g_object_unref (data.result);
return stream;
}
static void
test_multipart (int headers_expected, int sniffed_expected, MultipartMode multipart_mode)
{
GError* error = NULL;
SoupRequest* request = soup_session_request (session, base_uri_string, &error);
SoupMessage *msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (request));
GMainLoop *loop = g_main_loop_new (NULL, TRUE);
int headers_count = 0;
int sniffed_count = 0;
GHashTable *params;
const char *content_type;
gboolean message_is_multipart = FALSE;
debug_printf (1, "test_multipart(%s)\n", multipart_mode_to_string (multipart_mode));
/* This is used to track the number of parts. */
passes = 0;
/* Force the server to close the connection. */
soup_message_headers_append (msg->request_headers,
"Connection", "close");
g_signal_connect (msg, "got_headers",
G_CALLBACK (got_headers), &headers_count);
g_signal_connect (msg, "content-sniffed",
G_CALLBACK (content_sniffed), &sniffed_count);
if (multipart_mode == ASYNC_MULTIPART)
soup_request_send_async (request, NULL, multipart_handling_cb, loop);
else if (multipart_mode == ASYNC_MULTIPART_SMALL_READS) {
g_object_set_data (G_OBJECT (request), "multipart-small-reads", GINT_TO_POINTER(1));
soup_request_send_async (request, NULL, multipart_handling_cb, loop);
} else if (multipart_mode == SYNC_MULTIPART)
soup_request_send_async (request, NULL, sync_multipart_handling_cb, loop);
else
soup_request_send_async (request, NULL, no_multipart_handling_cb, loop);
g_main_loop_run (loop);
content_type = soup_message_headers_get_content_type (msg->response_headers, ¶ms);
if (content_type &&
g_str_has_prefix (content_type, "multipart/") &&
g_hash_table_lookup (params, "boundary")) {
message_is_multipart = TRUE;
}
g_clear_pointer (¶ms, g_hash_table_unref);
if (!message_is_multipart) {
debug_printf (1,
" Header does not indicate a multipart message!\n");
errors++;
}
if (headers_count != headers_expected) {
debug_printf (1,
" expected got_header %d times, got %d!\n",
headers_expected, headers_count);
errors++;
}
if (sniffed_count != sniffed_expected) {
debug_printf (1,
" expected content_sniffed %d times, got %d!\n",
sniffed_expected, sniffed_count);
errors++;
}
g_object_unref (msg);
g_object_unref (request);
g_main_loop_unref (loop);
}
static void
do_early_abort_req_test (void)
{
SoupSession *session;
SoupRequest *req;
GMainContext *context;
GMainLoop *loop;
GCancellable *cancellable;
debug_printf (1, "\nAbort with pending connection (request api)\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
NULL);
req = soup_session_request_uri (session, base_uri, NULL);
context = g_main_context_default ();
loop = g_main_loop_new (context, TRUE);
soup_request_send_async (req, NULL, ear_one_completed, NULL);
g_object_unref (req);
g_main_context_iteration (context, FALSE);
soup_session_abort (session);
while (g_main_context_pending (context))
g_main_context_iteration (context, FALSE);
soup_test_session_abort_unref (session);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
NULL);
req = soup_session_request_uri (session, base_uri, NULL);
g_signal_connect (session, "connection-created",
G_CALLBACK (ea_connection_created), NULL);
soup_request_send_async (req, NULL, ear_two_completed, loop);
g_main_loop_run (loop);
g_object_unref (req);
while (g_main_context_pending (context))
g_main_context_iteration (context, FALSE);
soup_test_session_abort_unref (session);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
NULL);
req = soup_session_request_uri (session, base_uri, NULL);
cancellable = g_cancellable_new ();
g_signal_connect (session, "request-started",
G_CALLBACK (ear_request_started), cancellable);
soup_request_send_async (req, cancellable, ear_three_completed, loop);
g_main_loop_run (loop);
g_object_unref (req);
g_object_unref (cancellable);
while (g_main_context_pending (context))
g_main_context_iteration (context, FALSE);
soup_test_session_abort_unref (session);
g_main_loop_unref (loop);
}
static void
do_callback_unref_req_test (void)
{
SoupServer *bad_server;
SoupAddress *addr;
SoupSession *session;
SoupRequest *one, *two;
GMainLoop *loop;
char *bad_uri;
debug_printf (1, "\nCallback unref handling (request api)\n");
/* Get a guaranteed-bad URI */
addr = soup_address_new ("127.0.0.1", SOUP_ADDRESS_ANY_PORT);
soup_address_resolve_sync (addr, NULL);
bad_server = soup_server_new (SOUP_SERVER_INTERFACE, addr,
NULL);
g_object_unref (addr);
bad_uri = g_strdup_printf ("http://127.0.0.1:%u/",
soup_server_get_port (bad_server));
g_object_unref (bad_server);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
NULL);
g_object_add_weak_pointer (G_OBJECT (session), (gpointer *)&session);
loop = g_main_loop_new (NULL, TRUE);
one = soup_session_request (session, bad_uri, NULL);
g_object_add_weak_pointer (G_OBJECT (one), (gpointer *)&one);
two = soup_session_request (session, bad_uri, NULL);
g_object_add_weak_pointer (G_OBJECT (two), (gpointer *)&two);
g_free (bad_uri);
soup_request_send_async (one, NULL, cur_one_completed, session);
g_object_unref (one);
soup_request_send_async (two, NULL, cur_two_completed, loop);
g_object_unref (two);
g_main_loop_run (loop);
g_main_loop_unref (loop);
if (session) {
g_object_remove_weak_pointer (G_OBJECT (session), (gpointer *)&session);
debug_printf (1, " Session not destroyed?\n");
errors++;
g_object_unref (session);
}
if (one) {
g_object_remove_weak_pointer (G_OBJECT (one), (gpointer *)&one);
debug_printf (1, " Request 1 not destroyed?\n");
errors++;
g_object_unref (one);
}
if (two) {
g_object_remove_weak_pointer (G_OBJECT (two), (gpointer *)&two);
debug_printf (1, " Request 2 not destroyed?\n");
errors++;
g_object_unref (two);
}
/* Otherwise, if we haven't crashed, we're ok. */
}
