static GBytes *
download_uri (SoupURI *uri,
GError **error)
{
g_autoptr(SoupSession) session = NULL;
g_autoptr(SoupRequest) req = NULL;
g_autoptr(GInputStream) input = NULL;
g_autoptr(GOutputStream) out = NULL;
g_assert (uri != NULL);
session = get_soup_session ();
req = soup_session_request_uri (session, uri, error);
if (req == NULL)
return NULL;
input = soup_request_send (req, NULL, error);
if (input == NULL)
return NULL;
out = g_memory_output_stream_new_resizable ();
if (!g_output_stream_splice (out,
input,
G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET | G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE,
NULL,
error))
return NULL;
return g_memory_output_stream_steal_as_bytes (G_MEMORY_OUTPUT_STREAM (out));
}
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);
}
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 gboolean
do_one_attempt (gpointer user_data)
{
GError *local_error = NULL;
MinCloudAgentApp *self = user_data;
gs_free char *uri_str = NULL;
gs_unref_object SoupRequest *request = NULL;
gs_unref_object GInputStream *instream = NULL;
gs_unref_object GFileOutputStream *outstream = NULL;
gs_unref_object GFile *authorized_keys_path = NULL;
gs_unref_object SoupMessage *msg = NULL;
SoupURI *uri = NULL;
const int max_request_failures = 5;
const char *state_description = NULL;
/* Skip over already completed states */
again:
switch (self->state)
{
case MCA_STATE_USER_DATA:
if (g_file_query_exists (self->userdata_done_stamp, NULL))
{
self->state++;
goto again;
}
break;
case MCA_STATE_OPENSSH_KEY:
if (g_file_query_exists (self->authorized_keys_path, NULL))
{
self->state++;
goto again;
}
break;
case MCA_STATE_DONE:
goto out;
}
uri = soup_uri_new (NULL);
soup_uri_set_scheme (uri, "http");
{
gs_free char *addr_str = g_inet_address_to_string (self->addr);
soup_uri_set_host (uri, addr_str);
}
soup_uri_set_port (uri, g_inet_socket_address_get_port (self->addr_port));
switch (self->state)
{
case MCA_STATE_USER_DATA:
soup_uri_set_path (uri, "/2009-04-04/user-data");
state_description = "user-data";
break;
case MCA_STATE_OPENSSH_KEY:
soup_uri_set_path (uri, "/2009-04-04/meta-data/public-keys/0/openssh-key");
state_description = "openssh-key";
break;
case MCA_STATE_DONE:
g_assert_not_reached ();
}
uri_str = soup_uri_to_string (uri, FALSE);
g_print ("Requesting '%s'...\n", uri_str);
request = soup_session_request_uri (self->session, uri, &local_error);
soup_uri_free (uri);
if (!request)
goto out;
instream = soup_request_send (request, NULL, &local_error);
if (!instream)
goto out;
msg = soup_request_http_get_message ((SoupRequestHTTP*) request);
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code))
{
switch (msg->status_code)
{
case 404:
case 410:
{
gs_log_structured_print_id_v (MCA_NOT_FOUND_ID, "No %s found", state_description);
g_clear_error (&local_error);
/* Note fallthrough to out, where we'll advance to the
next state */
goto out;
}
default:
/* Don't actually set the error, we will just continue to
* the next phase.
*/
gs_log_structured_print_id_v (MCA_TIMEOUT_ID,
"Error fetching %s: %u %s",
uri_str,
msg->status_code,
soup_status_get_phrase (msg->status_code));
goto out;
}
}
switch (self->state)
{
case MCA_STATE_USER_DATA:
if (!handle_userdata_script (self, instream, self->cancellable,
&local_error))
goto out;
break;
case MCA_STATE_OPENSSH_KEY:
if (!handle_install_authorized_keys (self, instream, self->cancellable,
&local_error))
goto out;
break;
default:
g_assert_not_reached ();
}
g_assert (self->state != MCA_STATE_DONE);
self->state++;
self->request_failure_count = 0;
out:
if (local_error)
{
self->request_failure_count++;
if (self->request_failure_count >= max_request_failures)
{
g_error_free (local_error);
gs_log_structured_print_id_v (MCA_TIMEOUT_ID,
"Reached maximum failed attempts (%u) to fetch metadata",
self->request_failure_count);
self->do_one_attempt_id = 0;
self->running = FALSE;
}
else
{
gs_log_structured_print_id_v (MCA_REQUEST_FAILED_ID,
"Request failed (count: %u): %s", self->request_failure_count,
local_error->message);
g_error_free (local_error);
self->do_one_attempt_id = g_timeout_add_seconds (self->request_failure_count,
do_one_attempt, self);
}
}
else
{
/* If we advanced in state, schedule the next callback in an
* idle so we're consistently scheduled out of an idle.
*/
if (self->state != MCA_STATE_DONE)
self->do_one_attempt_id = g_idle_add (do_one_attempt, self);
else
{
self->do_one_attempt_id = 0;
self->running = FALSE;
}
}
return FALSE;
}
static void
do_timeout_req_test_for_session (SoupSession *session)
{
SoupRequest *req;
SoupMessage *msg;
GInputStream *stream;
SoupSocket *sockets[4] = { NULL, NULL, NULL, NULL };
SoupURI *timeout_uri;
GError *error = NULL;
int i;
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_session_request_uri (session, 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_session_request_uri (session, 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
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);
}