static void
multipart_handling_cb (GObject *source, GAsyncResult *res, gpointer data)
{
GMainLoop *loop = (GMainLoop*)data;
SoupRequest *request = SOUP_REQUEST (source);
GError *error = NULL;
GInputStream *in;
SoupMessage *message;
in = soup_request_send_finish (request, res, &error);
message = soup_request_http_get_message (SOUP_REQUEST_HTTP (request));
multipart = soup_multipart_input_stream_new (message, in);
g_object_unref (message);
g_object_unref (in);
if (error) {
debug_printf (1, " failed send: %s\n", error->message);
errors++;
g_main_loop_quit (loop);
return;
}
if (g_object_get_data (source, "multipart-small-reads"))
g_object_set_data (G_OBJECT (multipart), "multipart-small-reads", GINT_TO_POINTER(1));
soup_multipart_input_stream_next_part_async (multipart, G_PRIORITY_DEFAULT, NULL,
multipart_next_part_cb, data);
}
static void
gdav_options_request_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
SoupRequestHTTP *request;
GTask *task = G_TASK (user_data);
AsyncContext *async_context;
GError *local_error = NULL;
request = SOUP_REQUEST_HTTP (source_object);
async_context = g_task_get_task_data (task);
gdav_request_send_finish (request, result, &local_error);
if (local_error == NULL) {
async_context->allow =
gdav_options_from_headers (
async_context->message->response_headers);
async_context->options =
gdav_options_from_headers (
async_context->message->response_headers);
g_task_return_boolean (task, TRUE);
} else {
g_task_return_error (task, local_error);
}
g_object_unref (task);
}
static const char *
soup_request_http_get_content_type (SoupRequest *request)
{
SoupRequestHTTP *http = SOUP_REQUEST_HTTP (request);
return soup_message_headers_get_content_type (http->priv->msg->response_headers, NULL);
}
static goffset
soup_request_http_get_content_length (SoupRequest *request)
{
SoupRequestHTTP *http = SOUP_REQUEST_HTTP (request);
return soup_message_headers_get_content_length (http->priv->msg->response_headers);
}
static void
gdav_propfind_request_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
SoupRequestHTTP *request;
GTask *task = G_TASK (user_data);
SoupURI *base_uri;
gpointer parsable;
guint status_code;
AsyncContext *async_context;
GError *local_error = NULL;
request = SOUP_REQUEST_HTTP (source_object);
async_context = g_task_get_task_data (task);
status_code = async_context->message->status_code;
gdav_request_send_finish (request, result, &local_error);
if (local_error != NULL)
goto exit;
if (status_code != SOUP_STATUS_MULTI_STATUS) {
g_task_return_new_error (
task, GDAV_PARSABLE_ERROR,
GDAV_PARSABLE_ERROR_INTERNAL,
_("Expected status %u (%s), but got (%u) (%s)"),
SOUP_STATUS_MULTI_STATUS,
soup_status_get_phrase (SOUP_STATUS_MULTI_STATUS),
async_context->message->status_code,
async_context->message->reason_phrase);
goto exit;
}
base_uri = soup_message_get_uri (async_context->message);
parsable = gdav_parsable_new_from_data (
GDAV_TYPE_MULTI_STATUS, base_uri,
async_context->message->response_body->data,
async_context->message->response_body->length,
&local_error);
/* Sanity check */
g_warn_if_fail (
((parsable != NULL) && (local_error == NULL)) ||
((parsable == NULL) && (local_error != NULL)));
if (parsable != NULL) {
g_warn_if_fail (GDAV_IS_MULTI_STATUS (parsable));
g_task_return_pointer (task, parsable, g_object_unref);
}
exit:
if (local_error != NULL)
g_task_return_error (task, local_error);
g_object_unref (task);
}
static void
soup_request_http_finalize (GObject *object)
{
SoupRequestHTTP *http = SOUP_REQUEST_HTTP (object);
if (http->priv->msg)
g_object_unref (http->priv->msg);
G_OBJECT_CLASS (soup_request_http_parent_class)->finalize (object);
}
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 gboolean
soup_request_http_check_uri (SoupRequest *request,
SoupURI *uri,
GError **error)
{
SoupRequestHTTP *http = SOUP_REQUEST_HTTP (request);
if (!SOUP_URI_VALID_FOR_HTTP (uri))
return FALSE;
http->priv->msg = soup_message_new_from_uri (SOUP_METHOD_GET, uri);
return TRUE;
}
static GInputStream *
soup_request_http_send (SoupRequest *request,
GCancellable *cancellable,
GError **error)
{
SoupHTTPInputStream *httpstream;
SoupRequestHTTP *http = SOUP_REQUEST_HTTP (request);
httpstream = soup_http_input_stream_new (soup_request_get_session (request), http->priv->msg);
if (!soup_http_input_stream_send (httpstream, cancellable, error)) {
g_object_unref (httpstream);
return NULL;
}
return (GInputStream *)httpstream;
}
static void
do_coding_empty_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupURI *uri;
SoupRequester *requester;
SoupRequest *req;
GByteArray *body;
debug_printf (1, "\nEmpty allegedly-encoded body test\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_REQUESTER,
NULL);
requester = (SoupRequester *)soup_session_get_feature (session, SOUP_TYPE_REQUESTER);
uri = soup_uri_new_with_base (base_uri, "/mbox");
debug_printf (1, " SoupMessage\n");
msg = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "empty");
soup_session_send_message (session, msg);
check_response (msg, "gzip", "text/plain", EXPECT_NOT_DECODED);
g_object_unref (msg);
debug_printf (1, " SoupRequest\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "empty");
g_object_unref (msg);
body = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_NOT_DECODED);
g_byte_array_free (body, TRUE);
g_object_unref (req);
soup_uri_free (uri);
soup_test_session_abort_unref (session);
}
/*
* our multipart handler callback
* If we make an invalid request (like trying to cancel when no recipe is running)
* then status_code will not be 200 and we will exit out after propagating the error
* to our own GError
*/
static void
request_sent_cb (GObject *source, GAsyncResult *async_result, gpointer user_data)
{
//g_print ("request_sent_cb\n");
MultiPartData *multipart_data = (MultiPartData *) user_data;
SoupRequest *request = SOUP_REQUEST (source);
GInputStream *in = soup_request_send_finish (request,
async_result,
&multipart_data->error);
if (multipart_data->error) {
g_object_unref(request);
multipart_destroy (multipart_data);
return;
}
SoupMessage *message = soup_request_http_get_message (SOUP_REQUEST_HTTP (request));
g_object_unref(request);
if (message->status_code != SOUP_STATUS_OK) {
g_set_error_literal(&multipart_data->error,
RESTRAINT_ERROR,
message->status_code,
message->reason_phrase);
multipart_destroy (multipart_data);
return;
}
multipart_data->multipart = soup_multipart_input_stream_new (message,
in);
g_object_unref (message);
g_object_unref (in);
soup_multipart_input_stream_next_part_async (multipart_data->multipart,
G_PRIORITY_DEFAULT,
multipart_data->cancellable,
next_part_cb,
user_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);
}
static void
sync_multipart_handling_cb (GObject *source, GAsyncResult *res, gpointer data)
{
GMainLoop *loop = (GMainLoop*)data;
SoupRequest *request = SOUP_REQUEST (source);
GError *error = NULL;
GInputStream *in;
SoupMessage *message;
char buffer[READ_BUFFER_SIZE];
gsize bytes_read;
in = soup_request_send_finish (request, res, &error);
message = soup_request_http_get_message (SOUP_REQUEST_HTTP (request));
multipart = soup_multipart_input_stream_new (message, in);
g_object_unref (message);
g_object_unref (in);
if (error) {
debug_printf (1, " failed send: %s\n", error->message);
errors++;
g_main_loop_quit (loop);
return;
}
while (TRUE) {
in = soup_multipart_input_stream_next_part (multipart, NULL, &error);
if (error) {
debug_printf (1, " failed sync next part: %s\n", error->message);
errors++;
g_clear_error (&error);
break;
}
if (!in)
break;
check_headers (multipart, passes);
g_input_stream_read_all (in, (void*)buffer, sizeof (buffer), &bytes_read, NULL, &error);
if (error) {
debug_printf (1, " failed sync read: %s\n", error->message);
errors++;
g_clear_error (&error);
g_object_unref (in);
break;
}
check_read (bytes_read, passes);
passes++;
g_object_unref (in);
}
if (passes != 4) {
debug_printf (1, " expected 4 parts, got %u\n", passes);
errors++;
}
g_main_loop_quit (loop);
g_object_unref (multipart);
}
int main(int argc, char *argv[]) {
AppData *app_data = g_slice_new0 (AppData);
app_data->filename = g_strdup("resultoutputfile.log");
app_data->outputfile = g_strdup(getenv("OUTPUTFILE"));
app_data->disable_plugin = g_ptr_array_new_with_free_func (g_free);
GError *error = NULL;
gchar *server = NULL;
SoupURI *result_uri = NULL;
guint ret = 0;
SoupMessage *server_msg;
SoupRequest *request;
gchar *result_msg = NULL;
gchar *prefix = NULL;
gchar *server_recipe_key = NULL;
gchar *server_recipe = NULL;
gchar *task_id = NULL;
gchar *task_id_key = NULL;
gboolean no_plugins = FALSE;
gchar *form_data;
GHashTable *data_table = g_hash_table_new (NULL, NULL);
GOptionEntry entries[] = {
{"server", 's', 0, G_OPTION_ARG_STRING, &server,
"Server to connect to", "URL" },
{ "message", 't', 0, G_OPTION_ARG_STRING, &result_msg,
"Short 100 characters or less message", "TEXT" },
{ "outputfile", 'o', 0, G_OPTION_ARG_CALLBACK, callback_outputfile,
"Log to upload with result, $OUTPUTFILE is used by default", "FILE" },
{ "disable-plugin", 'p', 0, G_OPTION_ARG_CALLBACK, callback_disable_plugin,
"don't run plugin on server side", "PLUGIN" },
{ "no-plugins", 0, 0, G_OPTION_ARG_NONE, &no_plugins,
"don't run any plugins on server side", NULL },
{ NULL }
};
GOptionGroup *option_group = g_option_group_new ("main",
"Application Options",
"Various application related options",
app_data, NULL);
GOptionContext *context = g_option_context_new("TASK_PATH RESULT SCORE");
g_option_context_set_summary(context,
"Report results to lab controller. if you don't specify the\n"
"the server url you must have RECIPEID and TASKID defined.\n"
"If HARNESS_PREFIX is defined then the value of that must be\n"
"prefixed to RECIPEID and TASKID");
g_option_group_add_entries(option_group, entries);
g_option_context_set_main_group (context, option_group);
gboolean parse_succeeded = g_option_context_parse(context, &argc, &argv, &error);
if (!parse_succeeded) {
goto cleanup;
}
prefix = getenv("HARNESS_PREFIX") ? getenv("HARNESS_PREFIX") : "";
server_recipe_key = g_strdup_printf ("%sRECIPE_URL", prefix);
server_recipe = getenv(server_recipe_key);
task_id_key = g_strdup_printf ("%sTASKID", prefix);
task_id = getenv(task_id_key);
g_free(task_id_key);
g_free(server_recipe_key);
if (!server && server_recipe && task_id) {
server = g_strdup_printf ("%s/tasks/%s/results/", server_recipe, task_id);
}
if (argc < 3 || !server) {
cmd_usage(context);
goto cleanup;
}
result_uri = soup_uri_new (server);
if (result_uri == NULL) {
g_set_error (&error, RESTRAINT_ERROR,
RESTRAINT_PARSE_ERROR_BAD_SYNTAX,
"Malformed server url: %s", server);
goto cleanup;
}
session = soup_session_new_with_options("timeout", 3600, NULL);
g_hash_table_insert (data_table, "path", argv[1]);
g_hash_table_insert (data_table, "result", argv[2]);
// if AVC_ERROR=+no_avc_check then disable the selinux check plugin
// This is for legacy rhts tests.. please use --disable-plugin
gchar *avc_error = getenv("AVC_ERROR");
if (g_strcmp0 (avc_error, "+no_avc_check") == 0) {
g_ptr_array_add (app_data->disable_plugin, g_strdup ("10_avc_check"));
}
if (app_data->disable_plugin->pdata) {
g_hash_table_insert (data_table, "disable_plugin",
g_strjoinv (" ", (gchar **)app_data->disable_plugin->pdata));
}
if (no_plugins)
g_hash_table_insert (data_table, "no_plugins", &no_plugins);
if (argc > 3)
g_hash_table_insert (data_table, "score", argv[3]);
if (result_msg)
g_hash_table_insert (data_table, "message", result_msg);
request = (SoupRequest *)soup_session_request_http_uri (session, "POST", result_uri, &error);
server_msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (request));
g_object_unref(request);
form_data = soup_form_encode_hash (data_table);
soup_message_set_request (server_msg, "application/x-www-form-urlencoded",
SOUP_MEMORY_TAKE, form_data, strlen (form_data));
g_print ("** %s %s Score:%s\n", argv[1], argv[2], argv[3]);
ret = soup_session_send_message (session, server_msg);
if (SOUP_STATUS_IS_SUCCESSFUL (ret)) {
gchar *location = g_strdup_printf ("%s/logs/",
soup_message_headers_get_one (server_msg->response_headers, "Location"));
soup_uri_free (result_uri);
result_uri = soup_uri_new (location);
g_free (location);
if (app_data->outputfile != NULL &&
g_file_test (app_data->outputfile, G_FILE_TEST_EXISTS))
{
g_print ("Uploading %s ", app_data->filename);
if (upload_file (session, app_data->outputfile, app_data->filename, result_uri, &error)) {
g_print ("done\n");
} else {
g_print ("failed\n");
}
}
} else {
g_warning ("Failed to submit result, status: %d Message: %s\n", ret, server_msg->reason_phrase);
}
g_object_unref(server_msg);
soup_session_abort(session);
g_object_unref(session);
cleanup:
if (server != NULL) {
g_free(server);
}
if (result_msg != NULL) {
g_free(result_msg);
}
g_option_context_free(context);
g_hash_table_destroy(data_table);
if (result_uri != NULL) {
soup_uri_free (result_uri);
}
restraint_free_appdata(app_data);
if (error) {
int retcode = error->code;
g_printerr("%s [%s, %d]\n", error->message,
g_quark_to_string(error->domain), error->code);
g_clear_error(&error);
return retcode;
} else {
return EXIT_SUCCESS;
}
}
static void
read_async_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (user_data);
struct request_res *rr = g_simple_async_result_get_op_res_gpointer (result);;
GError *error = NULL;
gssize s = g_input_stream_read_finish (G_INPUT_STREAM (source), res, &error);
gsize to_read;
if (s > 0) {
/* Continue reading */
rr->offset += s;
to_read = rr->length - rr->offset;
if (!to_read) {
/* Buffer is not enough; we need to assign more space */
rr->length *= 2;
rr->buffer = g_renew (gchar, rr->buffer, rr->length);
to_read = rr->length - rr->offset;
}
g_input_stream_read_async (G_INPUT_STREAM (source),
rr->buffer + rr->offset,
to_read,
G_PRIORITY_DEFAULT,
NULL,
read_async_cb,
user_data);
return;
}
/* Put the end of string */
rr->buffer[rr->offset] = '\0';
g_input_stream_close (G_INPUT_STREAM (source), NULL, NULL);
if (error) {
if (error->code == G_IO_ERROR_CANCELLED) {
g_simple_async_result_set_error (result, GRL_NET_WC_ERROR,
GRL_NET_WC_ERROR_CANCELLED,
_("Operation was cancelled"));
} else {
g_simple_async_result_set_error (result, GRL_NET_WC_ERROR,
GRL_NET_WC_ERROR_UNAVAILABLE,
_("Data not available"));
}
g_error_free (error);
g_simple_async_result_complete (result);
g_object_unref (result);
return;
}
{
SoupMessage *msg =
soup_request_http_get_message (SOUP_REQUEST_HTTP (rr->request));
if (msg && msg->status_code != SOUP_STATUS_OK) {
parse_error (msg->status_code,
msg->reason_phrase,
msg->response_body->data,
G_SIMPLE_ASYNC_RESULT (user_data));
g_object_unref (msg);
}
}
g_simple_async_result_complete (result);
g_object_unref (result);
}
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 void
do_coding_req_test (void)
{
SoupSession *session;
SoupRequester *requester;
SoupRequest *req;
SoupMessage *msg;
SoupURI *uri;
GByteArray *plain, *cmp;
debug_printf (1, "\nSoupRequest tests\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_REQUESTER,
NULL);
requester = (SoupRequester *)soup_session_get_feature (session, SOUP_TYPE_REQUESTER);
uri = soup_uri_new_with_base (base_uri, "/mbox");
/* Plain text data, no claim */
debug_printf (1, " GET /mbox, plain\n");
req = soup_requester_request_uri (requester, uri, NULL);
plain = do_single_coding_req_test (req, NULL, "text/plain", EXPECT_NOT_DECODED);
g_object_unref (req);
/* Plain text data, claim gzip */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip\n");
soup_session_add_feature_by_type (session, SOUP_TYPE_CONTENT_DECODER);
req = soup_requester_request_uri (requester, uri, NULL);
cmp = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed");
g_byte_array_free (cmp, TRUE);
g_object_unref (req);
/* Plain text data, claim gzip w/ junk */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip, plus trailing junk\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "trailing-junk");
cmp = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed w/ junk");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim gzip with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip, with server error\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "force-encode");
cmp = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_NOT_DECODED);
/* Failed content-decoding should have left the body untouched
* from what the server sent... which happens to be the
* uncompressed data.
*/
check_req_bodies (plain, cmp, "plain", "mis-encoded");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "prefer-deflate-zlib");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate w/ junk */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate, plus trailing junk\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "prefer-deflate-zlib, trailing-junk");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed w/ junk");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate, with server error\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "force-encode, prefer-deflate-zlib");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_NOT_DECODED);
check_req_bodies (plain, cmp, "plain", "mis-encoded");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate (no zlib headers)*/
debug_printf (1, " GET /mbox, Accept-Encoding: deflate (raw data)\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "prefer-deflate-raw");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate (raw data), with server error\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "force-encode, prefer-deflate-raw");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_NOT_DECODED);
check_req_bodies (plain, cmp, "plain", "mis-encoded");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
g_byte_array_free (plain, TRUE);
soup_uri_free (uri);
soup_test_session_abort_unref (session);
}
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
soup_request_http_send_async (SoupRequest *request,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
SoupRequestHTTP *http = SOUP_REQUEST_HTTP (request);
SoupHTTPInputStream *httpstream;
GSimpleAsyncResult *simple;
SoupSession *session;
SoupCache *cache;
session = soup_request_get_session (request);
cache = (SoupCache *)soup_session_get_feature (session, SOUP_TYPE_CACHE);
if (cache) {
SoupCacheResponse response;
response = soup_cache_has_response (cache, http->priv->msg);
if (response == SOUP_CACHE_RESPONSE_FRESH) {
SoupHTTPInputStream *httpstream;
httpstream = (SoupHTTPInputStream *)
soup_cache_send_response (cache, http->priv->msg);
/* Cached resource file could have been deleted outside
*/
if (httpstream) {
/* Do return the stream asynchronously as in
* the other cases. It's not enough to use
* g_simple_async_result_complete_in_idle as
* the signals must be also emitted
* asynchronously
*/
SendAsyncHelper *helper = g_slice_new (SendAsyncHelper);
helper->http = g_object_ref (http);
helper->callback = callback;
helper->user_data = user_data;
helper->httpstream = httpstream;
g_timeout_add (0, send_async_cb, helper);
return;
}
} else if (response == SOUP_CACHE_RESPONSE_NEEDS_VALIDATION) {
SoupMessage *conditional_msg;
ConditionalHelper *helper;
conditional_msg = soup_cache_generate_conditional_request (cache, http->priv->msg);
helper = g_slice_new0 (ConditionalHelper);
helper->req = g_object_ref (http);
helper->original = g_object_ref (http->priv->msg);
helper->cancellable = cancellable;
helper->callback = callback;
helper->user_data = user_data;
soup_session_queue_message (session, conditional_msg,
conditional_get_ready_cb,
helper);
return;
}
}
simple = g_simple_async_result_new (G_OBJECT (http),
callback, user_data,
soup_request_http_send_async);
httpstream = soup_http_input_stream_new (soup_request_get_session (request),
http->priv->msg);
soup_http_input_stream_send_async (httpstream, G_PRIORITY_DEFAULT,
cancellable, sent_async, simple);
}
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);
}
gboolean upload_results(AppData *app_data) {
GError *error = NULL;
SoupURI *result_uri = NULL;
guint ret = 0;
SoupSession *session;
SoupMessage *server_msg;
SoupRequest *request;
gchar *form_data;
GHashTable *data_table = g_hash_table_new (NULL, NULL);
result_uri = soup_uri_new (app_data->server);
if (result_uri == NULL) {
g_set_error (&error, RESTRAINT_ERROR,
RESTRAINT_PARSE_ERROR_BAD_SYNTAX,
"Malformed server url: %s", app_data->server);
goto cleanup;
}
session = soup_session_new_with_options("timeout", 3600, NULL);
g_hash_table_insert (data_table, "path", app_data->test_name);
g_hash_table_insert (data_table, "result", app_data->test_result);
// if AVC_ERROR=+no_avc_check then disable the selinux check plugin
// This is for legacy rhts tests.. please use --disable-plugin
gchar *avc_error = getenv("AVC_ERROR");
if (g_strcmp0 (avc_error, "+no_avc_check") == 0) {
g_ptr_array_add (app_data->disable_plugin, g_strdup ("10_avc_check"));
}
if (app_data->disable_plugin->pdata) {
g_ptr_array_add (app_data->disable_plugin, NULL);
g_hash_table_insert (data_table, "disable_plugin",
g_strjoinv (" ", (gchar **)app_data->disable_plugin->pdata));
}
if (app_data->no_plugins)
g_hash_table_insert (data_table, "no_plugins", &app_data->no_plugins);
if (app_data->score)
g_hash_table_insert (data_table, "score", app_data->score);
if (app_data->result_msg)
g_hash_table_insert (data_table, "message", app_data->result_msg);
request = (SoupRequest *)soup_session_request_http_uri (session, "POST", result_uri, &error);
server_msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (request));
g_object_unref(request);
form_data = soup_form_encode_hash (data_table);
soup_message_set_request (server_msg, "application/x-www-form-urlencoded",
SOUP_MEMORY_TAKE, form_data, strlen (form_data));
g_print ("** %s %s Score:%s\n", app_data->test_name, app_data->test_result,
app_data->score != NULL ? app_data->score : "N/A");
ret = soup_session_send_message (session, server_msg);
if (SOUP_STATUS_IS_SUCCESSFUL (ret)) {
gchar *location = g_strdup_printf ("%s/logs/",
soup_message_headers_get_one (server_msg->response_headers, "Location"));
soup_uri_free (result_uri);
result_uri = soup_uri_new (location);
g_free (location);
if (app_data->outputfile != NULL &&
g_file_test (app_data->outputfile, G_FILE_TEST_EXISTS))
{
g_print ("Uploading %s ", app_data->filename);
if (upload_file (session, app_data->outputfile, app_data->filename, result_uri, &error)) {
g_print ("done\n");
} else {
g_print ("failed\n");
}
}
} else {
g_warning ("Failed to submit result, status: %d Message: %s\n", ret, server_msg->reason_phrase);
}
g_object_unref(server_msg);
soup_session_abort(session);
g_object_unref(session);
cleanup:
g_hash_table_destroy(data_table);
if (result_uri != NULL) {
soup_uri_free (result_uri);
}
if (error) {
g_printerr("%s [%s, %d]\n", error->message,
g_quark_to_string(error->domain), error->code);
g_clear_error(&error);
return FALSE;
} else {
return TRUE;
}
}
