static GByteArray *
do_single_coding_req_test (SoupRequest *req,
const char *expected_encoding,
const char *expected_content_type,
MessageContentStatus status)
{
GInputStream *stream;
SoupMessage *msg;
GByteArray *data;
guchar buf[1024];
gssize nread;
GError *error = NULL;
data = g_byte_array_new ();
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
stream = soup_test_request_send (req, NULL, &error);
if (error) {
debug_printf (1, " Error sending request: %s\n",
error->message);
g_error_free (error);
errors++;
return data;
}
do {
nread = -2;
g_input_stream_read_async (stream, buf, sizeof (buf),
G_PRIORITY_DEFAULT,
NULL, read_finished, &nread);
while (nread == -2)
g_main_context_iteration (NULL, TRUE);
if (nread > 0)
g_byte_array_append (data, buf, nread);
} while (nread > 0);
soup_test_request_close_stream (req, stream, NULL, &error);
if (error) {
debug_printf (1, " error closing stream: %s\n",
error->message);
g_error_free (error);
errors++;
}
g_object_unref (stream);
check_response (msg, expected_encoding, expected_content_type, status);
g_object_unref (msg);
return data;
}
static void
do_cancel_while_reading_req_test_for_session (SoupSession *session)
{
SoupRequest *req;
SoupURI *uri;
GCancellable *cancellable;
GError *error = NULL;
uri = soup_uri_new_with_base (base_uri, "/slow");
req = soup_session_request_uri (session, uri, NULL);
soup_uri_free (uri);
cancellable = g_cancellable_new ();
if (SOUP_IS_SESSION_ASYNC (soup_request_get_session (req))) {
g_timeout_add (100, cancel_request_timeout, cancellable);
soup_test_request_send (req, cancellable, &error);
} else {
GThread *thread;
thread = g_thread_new ("cancel_request_thread", cancel_request_thread, g_object_ref (cancellable));
soup_test_request_send (req, cancellable, &error);
g_thread_unref (thread);
}
if (!error) {
debug_printf (1, " Request succeeded?\n");
errors++;
} else if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
debug_printf (1, " Unexpected error: %s\n",
error->message);
errors++;
}
g_clear_error (&error);
g_object_unref (req);
g_object_unref (cancellable);
}
static void
do_request_to_session (SoupSession *session, const char *uri,
const char *comment, gboolean expect_timeout)
{
SoupRequest *req;
SoupMessage *msg;
GInputStream *stream;
GError *error = NULL;
gboolean finished = FALSE;
debug_printf (1, " req %s\n", comment);
req = soup_session_request (session, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
g_signal_connect (msg, "finished",
G_CALLBACK (message_finished), &finished);
stream = soup_test_request_send (req, NULL, &error);
if (expect_timeout && !error) {
debug_printf (1, " FAILED: request did not time out\n");
errors++;
} else if (expect_timeout && !g_error_matches (error, G_IO_ERROR,
G_IO_ERROR_TIMED_OUT)) {
debug_printf (1, " FAILED: wrong error: %s\n",
error->message);
errors++;
} else if (!expect_timeout && error) {
debug_printf (1, " FAILED: expected success but got error: %s\n",
error->message);
errors++;
}
g_clear_error (&error);
if (stream) {
soup_test_request_close_stream (req, stream, NULL, &error);
if (error) {
debug_printf (1, " ERROR closing string: %s",
error->message);
errors++;
}
g_object_unref (stream);
}
if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code) &&
!soup_message_is_keepalive (msg)) {
debug_printf (1, " ERROR: message is not keepalive!\n");
errors++;
}
if (!finished) {
debug_printf (1, " ERROR: 'finished' was not emitted\n");
errors++;
}
g_signal_handlers_disconnect_by_func (msg,
G_CALLBACK (message_finished),
&finished);
g_object_unref (msg);
g_object_unref (req);
}
static void
do_timeout_req_test_for_session (SoupSession *session)
{
SoupRequester *requester;
SoupRequest *req;
SoupMessage *msg;
GInputStream *stream;
SoupSocket *sockets[4] = { NULL, NULL, NULL, NULL };
SoupURI *timeout_uri;
GError *error = NULL;
int i;
requester = soup_requester_new ();
soup_session_add_feature (session, SOUP_SESSION_FEATURE (requester));
g_object_unref (requester);
g_signal_connect (session, "request-started",
G_CALLBACK (request_started_socket_collector),
&sockets);
debug_printf (1, " First request\n");
timeout_uri = soup_uri_new_with_base (base_uri, "/timeout-persistent");
req = soup_requester_request_uri (requester, timeout_uri, NULL);
soup_uri_free (timeout_uri);
stream = soup_test_request_send (req, NULL, &error);
if (!stream) {
debug_printf (1, " Unexpected error on send: %s\n",
error->message);
errors++;
g_clear_error (&error);
} else {
soup_test_request_close_stream (req, stream, NULL, &error);
if (error) {
debug_printf (1, " Unexpected error on close: %s\n",
error->message);
errors++;
g_clear_error (&error);
}
g_object_unref (stream);
}
if (sockets[1]) {
debug_printf (1, " Message was retried??\n");
errors++;
sockets[1] = sockets[2] = sockets[3] = NULL;
}
g_object_unref (req);
debug_printf (1, " Second request\n");
req = soup_requester_request_uri (requester, base_uri, NULL);
stream = soup_test_request_send (req, NULL, &error);
if (!stream) {
debug_printf (1, " Unexpected error on send: %s\n",
error->message);
errors++;
g_clear_error (&error);
} else {
soup_test_request_close_stream (req, stream, NULL, &error);
if (error) {
debug_printf (1, " Unexpected error on close: %s\n",
error->message);
errors++;
g_clear_error (&error);
}
g_object_unref (stream);
}
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
if (msg->status_code != SOUP_STATUS_OK) {
debug_printf (1, " Unexpected response: %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
if (sockets[1] != sockets[0]) {
debug_printf (1, " Message was not retried on existing connection\n");
errors++;
} else if (!sockets[2]) {
debug_printf (1, " Message was not retried after disconnect\n");
errors++;
} else if (sockets[2] == sockets[1]) {
debug_printf (1, " Message was retried on closed connection??\n");
errors++;
} else if (sockets[3]) {
debug_printf (1, " Message was retried again??\n");
errors++;
}
g_object_unref (msg);
g_object_unref (req);
for (i = 0; sockets[i]; i++)
g_object_unref (sockets[i]);
}
static void
test_url_new_api (const char *url, int proxy, guint expected,
gboolean sync, gboolean close)
{
SoupSession *session;
SoupURI *proxy_uri;
SoupMessage *msg;
SoupRequester *requester;
SoupRequest *request;
GInputStream *stream;
GError *error = NULL;
if (!tls_available && g_str_has_prefix (url, "https:"))
return;
debug_printf (1, " GET (requester API) %s via %s%s\n", url, proxy_names[proxy],
close ? " (with Connection: close)" : "");
if (proxy == UNAUTH_PROXY && expected != SOUP_STATUS_FORBIDDEN)
expected = SOUP_STATUS_PROXY_UNAUTHORIZED;
/* We create a new session for each request to ensure that
* connections/auth aren't cached between tests.
*/
proxy_uri = soup_uri_new (proxies[proxy]);
session = soup_test_session_new (sync ? SOUP_TYPE_SESSION_SYNC : SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_REQUESTER,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
SOUP_SESSION_PROXY_URI, proxy_uri,
NULL);
soup_uri_free (proxy_uri);
g_signal_connect (session, "authenticate",
G_CALLBACK (authenticate), NULL);
if (close) {
g_signal_connect (session, "request-started",
G_CALLBACK (set_close_on_connect), NULL);
}
requester = (SoupRequester *)soup_session_get_feature (session, SOUP_TYPE_REQUESTER);
request = soup_requester_request (requester, url, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (request));
stream = soup_test_request_send (request, NULL, &error);
if (!stream) {
debug_printf (1, " Unexpected error on Request: %s\n",
error->message);
errors++;
g_clear_error (&error);
}
if (stream) {
soup_test_request_close_stream (request, stream, NULL, NULL);
if (error) {
debug_printf (1, " Unexpected error on close: %s\n",
error->message);
errors++;
g_clear_error (&error);
}
g_object_unref (stream);
}
debug_printf (1, " %d %s\n", msg->status_code, msg->reason_phrase);
if (msg->status_code != expected) {
debug_printf (1, " EXPECTED %d!\n", expected);
errors++;
}
g_object_unref (msg);
g_object_unref (request);
soup_test_session_abort_unref (session);
}
static char *
do_request (SoupSession *session,
SoupURI *base_uri,
const char *method,
const char *path,
...)
{
SoupRequestHTTP *req;
SoupMessage *msg;
GInputStream *stream;
SoupURI *uri;
va_list ap;
const char *header, *value;
char buf[256];
gsize nread;
GError *error = NULL;
last_request_validated = last_request_hit_network = FALSE;
uri = soup_uri_new_with_base (base_uri, path);
req = soup_session_request_http_uri (session, method, uri, NULL);
soup_uri_free (uri);
msg = soup_request_http_get_message (req);
va_start (ap, path);
while ((header = va_arg (ap, const char *))) {
value = va_arg (ap, const char *);
soup_message_headers_append (msg->request_headers,
header, value);
}
g_object_unref (msg);
stream = soup_test_request_send (SOUP_REQUEST (req), NULL, &error);
if (!stream) {
debug_printf (1, " could not send request: %s\n",
error->message);
g_error_free (error);
g_object_unref (req);
return NULL;
}
last_request_hit_network = is_network_stream (stream);
g_input_stream_read_all (stream, buf, sizeof (buf), &nread,
NULL, &error);
if (error) {
debug_printf (1, " could not read response: %s\n",
error->message);
g_clear_error (&error);
}
soup_test_request_close_stream (SOUP_REQUEST (req), stream,
NULL, &error);
if (error) {
debug_printf (1, " could not close stream: %s\n",
error->message);
g_clear_error (&error);
}
g_object_unref (stream);
g_object_unref (req);
/* Cache writes are G_PRIORITY_LOW, so they won't have happened yet... */
soup_cache_flush ((SoupCache *)soup_session_get_feature (session, SOUP_TYPE_CACHE));
return nread ? g_memdup (buf, nread) : g_strdup ("");
}