static gboolean
send_review_request (GsPlugin *plugin,
const gchar *method, const gchar *path,
JsonBuilder *request,
gboolean do_sign,
guint *status_code,
JsonParser **result,
GCancellable *cancellable, GError **error)
{
g_autofree gchar *uri = NULL;
g_autoptr(SoupMessage) msg = NULL;
uri = g_strdup_printf ("%s%s",
UBUNTU_REVIEWS_SERVER, path);
msg = soup_message_new (method, uri);
if (request != NULL) {
g_autoptr(JsonGenerator) generator = NULL;
gchar *data;
gsize length;
generator = json_generator_new ();
json_generator_set_root (generator, json_builder_get_root (request));
data = json_generator_to_data (generator, &length);
soup_message_set_request (msg, "application/json", SOUP_MEMORY_TAKE, data, length);
}
if (do_sign)
sign_message (msg,
OA_PLAINTEXT,
gs_plugin_get_auth_by_id (plugin, "ubuntuone"));
*status_code = soup_session_send_message (gs_plugin_get_soup_session (plugin), msg);
if (*status_code == SOUP_STATUS_UNAUTHORIZED) {
g_set_error_literal (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_AUTH_REQUIRED,
"Requires authentication with @ubuntuone");
return FALSE;
}
if (result != NULL) {
g_autoptr(JsonParser) parser = NULL;
const gchar *content_type;
content_type = soup_message_headers_get_content_type (msg->response_headers, NULL);
if (g_strcmp0 (content_type, "application/json") != 0) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"Got unknown content type %s from reviews.ubuntu.com",
content_type);
return FALSE;
}
parser = json_parser_new ();
if (!json_parser_load_from_data (parser, msg->response_body->data, -1, error)) {
return FALSE;
}
*result = g_steal_pointer (&parser);
}
return TRUE;
}
int main(int argc, char *argv[]) {
GError *error = NULL;
gchar *server = NULL;
gchar *form_data;
gchar *form_seconds;
SoupURI *watchdog_uri = NULL;
guint ret = 0;
guint64 seconds;
gchar *prefix = NULL;
gchar *server_recipe_key = NULL;
gchar *server_recipe = NULL;
GHashTable *data_table = g_hash_table_new (NULL, NULL);
GOptionEntry entries[] = {
{"server", 's', 0, G_OPTION_ARG_STRING, &server,
"Server to connect to", "URL" },
{ NULL }
};
GOptionContext *context = g_option_context_new("<time>");
g_option_context_set_summary(context,
"Adjust watchdog on lab controller. if you don't specify the\n"
"the server url you must have RECIPEID defined.\n"
"If HARNESS_PREFIX is defined then the value of that must be\n"
"prefixed to RECIPEID");
g_option_context_add_main_entries(context, entries, NULL);
gboolean parse_succeeded = g_option_context_parse(context, &argc, &argv, &error);
if (argc < 2 || !parse_succeeded) {
g_set_error (&error, RESTRAINT_ERROR,
RESTRAINT_PARSE_ERROR_BAD_SYNTAX,
"Wrong arguments");
cmd_usage(context);
goto cleanup;
}
seconds = parse_time_string (argv[1], &error);
if (error) {
cmd_usage(context);
goto cleanup;
}
prefix = getenv("HARNESS_PREFIX") ? getenv("HARNESS_PREFIX") : "";
server_recipe_key = g_strdup_printf ("%sRECIPE_URL", prefix);
server_recipe = getenv(server_recipe_key);
g_free(server_recipe_key);
if (!server && server_recipe) {
server = g_strdup_printf ("%s/watchdog", server_recipe);
}
if (!server) {
cmd_usage(context);
goto cleanup;
}
watchdog_uri = soup_uri_new (server);
if (!watchdog_uri) {
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);
SoupMessage *server_msg = soup_message_new_from_uri ("POST", watchdog_uri);
form_seconds = g_strdup_printf ("%" PRIu64, seconds);
g_hash_table_insert (data_table, "seconds", form_seconds);
form_data = soup_form_encode_hash (data_table);
g_free (form_seconds);
soup_message_set_request (server_msg, "application/x-www-form-urlencoded",
SOUP_MEMORY_TAKE, form_data, strlen (form_data));
ret = soup_session_send_message (session, server_msg);
if (SOUP_STATUS_IS_SUCCESSFUL (ret)) {
} else {
g_warning ("Failed to adjust watchdog, 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);
g_option_context_free(context);
if (server != NULL) {
g_free(server);
}
if (watchdog_uri != NULL) {
soup_uri_free (watchdog_uri);
}
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 GPtrArray *
gs_plugin_odrs_fetch_for_app (GsPlugin *plugin, GsApp *app, GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
const gchar *version;
guint status_code;
g_autofree gchar *cachefn_basename = NULL;
g_autofree gchar *cachefn = NULL;
g_autofree gchar *data = NULL;
g_autofree gchar *uri = NULL;
g_autoptr(GFile) cachefn_file = NULL;
g_autoptr(GPtrArray) reviews = NULL;
g_autoptr(JsonBuilder) builder = NULL;
g_autoptr(JsonGenerator) json_generator = NULL;
g_autoptr(JsonNode) json_root = NULL;
g_autoptr(SoupMessage) msg = NULL;
/* look in the cache */
cachefn_basename = g_strdup_printf ("%s.json", gs_app_get_id (app));
cachefn = gs_utils_get_cache_filename ("reviews",
cachefn_basename,
GS_UTILS_CACHE_FLAG_WRITEABLE,
error);
if (cachefn == NULL)
return NULL;
cachefn_file = g_file_new_for_path (cachefn);
if (gs_utils_get_file_age (cachefn_file) < ODRS_REVIEW_CACHE_AGE_MAX) {
g_autofree gchar *json_data = NULL;
if (!g_file_get_contents (cachefn, &json_data, NULL, error))
return NULL;
g_debug ("got review data for %s from %s",
gs_app_get_id (app), cachefn);
return gs_plugin_odrs_parse_reviews (plugin,
json_data, -1,
error);
}
/* not always available */
version = gs_app_get_version (app);
if (version == NULL)
version = "unknown";
/* create object with review data */
builder = json_builder_new ();
json_builder_begin_object (builder);
json_builder_set_member_name (builder, "user_hash");
json_builder_add_string_value (builder, priv->user_hash);
json_builder_set_member_name (builder, "app_id");
json_builder_add_string_value (builder, gs_app_get_id (app));
json_builder_set_member_name (builder, "locale");
json_builder_add_string_value (builder, gs_plugin_get_locale (plugin));
json_builder_set_member_name (builder, "distro");
json_builder_add_string_value (builder, priv->distro);
json_builder_set_member_name (builder, "version");
json_builder_add_string_value (builder, version);
json_builder_set_member_name (builder, "limit");
json_builder_add_int_value (builder, ODRS_REVIEW_NUMBER_RESULTS_MAX);
json_builder_end_object (builder);
/* export as a string */
json_root = json_builder_get_root (builder);
json_generator = json_generator_new ();
json_generator_set_pretty (json_generator, TRUE);
json_generator_set_root (json_generator, json_root);
data = json_generator_to_data (json_generator, NULL);
if (data == NULL)
return NULL;
uri = g_strdup_printf ("%s/fetch", priv->review_server);
msg = soup_message_new (SOUP_METHOD_POST, uri);
soup_message_set_request (msg, "application/json; charset=utf-8",
SOUP_MEMORY_COPY, data, strlen (data));
status_code = soup_session_send_message (gs_plugin_get_soup_session (plugin), msg);
if (status_code != SOUP_STATUS_OK) {
if (!gs_plugin_odrs_parse_success (msg->response_body->data,
msg->response_body->length,
error))
return NULL;
/* not sure what to do here */
g_set_error_literal (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_DOWNLOAD_FAILED,
"status code invalid");
gs_utils_error_add_unique_id (error, priv->cached_origin);
return NULL;
}
reviews = gs_plugin_odrs_parse_reviews (plugin,
msg->response_body->data,
msg->response_body->length,
error);
if (reviews == NULL)
return NULL;
g_debug ("odrs returned: %s", msg->response_body->data);
/* save to the cache */
if (!g_file_set_contents (cachefn,
msg->response_body->data,
msg->response_body->length,
error))
return NULL;
/* success */
return g_steal_pointer (&reviews);
}
static void
do_async_auth_test (const char *base_uri)
{
SoupSession *session;
SoupMessage *msg1, *msg2, *msg3, msg2_bak;
guint auth_id;
char *uri;
SoupAuth *auth = NULL;
int remaining;
gboolean been_there;
debug_printf (1, "\nTesting async auth:\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
remaining = 0;
uri = g_strconcat (base_uri, "Basic/realm1/", NULL);
msg1 = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg1), "id", GINT_TO_POINTER (1));
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (async_authenticate), &auth);
g_object_ref (msg1);
remaining++;
soup_session_queue_message (session, msg1, async_finished, &remaining);
g_main_loop_run (loop);
g_signal_handler_disconnect (session, auth_id);
/* async_authenticate will pause msg1 and quit loop */
msg2 = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg2), "id", GINT_TO_POINTER (2));
soup_session_send_message (session, msg2);
if (msg2->status_code == SOUP_STATUS_UNAUTHORIZED)
debug_printf (1, " msg2 failed as expected\n");
else {
debug_printf (1, " msg2 got wrong status! (%u)\n",
msg2->status_code);
errors++;
}
/* msg2 should be done at this point; assuming everything is
* working correctly, the session won't look at it again; we
* ensure that if it does, it will crash the test program.
*/
memcpy (&msg2_bak, msg2, sizeof (SoupMessage));
memset (msg2, 0, sizeof (SoupMessage));
msg3 = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg3), "id", GINT_TO_POINTER (3));
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (async_authenticate), NULL);
g_object_ref (msg3);
remaining++;
soup_session_queue_message (session, msg3, async_finished, &remaining);
g_main_loop_run (loop);
g_signal_handler_disconnect (session, auth_id);
/* async_authenticate will pause msg3 and quit loop */
/* Now do the auth, and restart */
if (auth) {
soup_auth_authenticate (auth, "user1", "realm1");
g_object_unref (auth);
soup_session_unpause_message (session, msg1);
soup_session_unpause_message (session, msg3);
g_main_loop_run (loop);
/* async_finished will quit the loop */
} else {
debug_printf (1, " msg1 didn't get authenticate signal!\n");
errors++;
}
if (msg1->status_code == SOUP_STATUS_OK)
debug_printf (1, " msg1 succeeded\n");
else {
debug_printf (1, " msg1 FAILED! (%u %s)\n",
msg1->status_code, msg1->reason_phrase);
errors++;
}
if (msg3->status_code == SOUP_STATUS_OK)
debug_printf (1, " msg3 succeeded\n");
else {
debug_printf (1, " msg3 FAILED! (%u %s)\n",
msg3->status_code, msg3->reason_phrase);
errors++;
}
soup_test_session_abort_unref (session);
g_object_unref (msg1);
g_object_unref (msg3);
memcpy (msg2, &msg2_bak, sizeof (SoupMessage));
g_object_unref (msg2);
/* Test that giving the wrong password doesn't cause multiple
* authenticate signals the second time.
*/
debug_printf (1, "\nTesting async auth with wrong password (#522601):\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
remaining = 0;
auth = NULL;
msg1 = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg1), "id", GINT_TO_POINTER (1));
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (async_authenticate), &auth);
g_object_ref (msg1);
remaining++;
soup_session_queue_message (session, msg1, async_finished, &remaining);
g_main_loop_run (loop);
g_signal_handler_disconnect (session, auth_id);
soup_auth_authenticate (auth, "user1", "wrong");
g_object_unref (auth);
soup_session_unpause_message (session, msg1);
been_there = FALSE;
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (async_authenticate_assert_once),
&been_there);
g_main_loop_run (loop);
g_signal_handler_disconnect (session, auth_id);
if (!been_there) {
debug_printf (1, " authenticate not emitted?\n");
errors++;
}
soup_test_session_abort_unref (session);
g_object_unref (msg1);
/* Test that giving no password doesn't cause multiple
* authenticate signals the second time.
*/
debug_printf (1, "\nTesting async auth with no password (#583462):\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
remaining = 0;
/* Send a message that doesn't actually authenticate
*/
msg1 = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg1), "id", GINT_TO_POINTER (1));
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (async_authenticate), NULL);
g_object_ref (msg1);
remaining++;
soup_session_queue_message (session, msg1, async_finished, &remaining);
g_main_loop_run (loop);
g_signal_handler_disconnect (session, auth_id);
soup_session_unpause_message (session, msg1);
g_main_loop_run (loop);
g_object_unref(msg1);
/* Now send a second message */
msg1 = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg1), "id", GINT_TO_POINTER (2));
g_object_ref (msg1);
been_there = FALSE;
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (async_authenticate_assert_once_and_stop),
&been_there);
remaining++;
soup_session_queue_message (session, msg1, async_finished, &remaining);
g_main_loop_run (loop);
soup_session_unpause_message (session, msg1);
g_main_loop_run (loop);
g_signal_handler_disconnect (session, auth_id);
soup_test_session_abort_unref (session);
g_object_unref (msg1);
g_free (uri);
}
static void
do_batch_tests (const gchar *base_uri_str, gint ntests)
{
SoupSession *session;
SoupMessage *msg;
char *expected;
SoupURI *base_uri;
int i;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
g_signal_connect (session, "authenticate",
G_CALLBACK (authenticate), &i);
base_uri = soup_uri_new (base_uri_str);
for (i = 0; i < ntests; i++) {
SoupURI *soup_uri = soup_uri_new_with_base (base_uri, current_tests[i].url);
debug_printf (1, "Test %d: %s\n", i + 1, current_tests[i].explanation);
if (current_tests[i].url_auth) {
gchar *username = g_strdup_printf ("user%c", current_tests[i].provided[0]);
gchar *password = g_strdup_printf ("realm%c", current_tests[i].provided[0]);
soup_uri_set_user (soup_uri, username);
soup_uri_set_password (soup_uri, password);
g_free (username);
g_free (password);
}
msg = soup_message_new_from_uri (SOUP_METHOD_GET, soup_uri);
soup_uri_free (soup_uri);
if (!msg) {
fprintf (stderr, "auth-test: Could not parse URI\n");
exit (1);
}
debug_printf (1, " GET %s\n", soup_uri_to_string (soup_message_get_uri (msg), FALSE));
expected = g_strdup (current_tests[i].expected);
soup_message_add_status_code_handler (
msg, "got_headers", SOUP_STATUS_UNAUTHORIZED,
G_CALLBACK (handler), expected);
soup_message_add_status_code_handler (
msg, "got_headers", SOUP_STATUS_OK,
G_CALLBACK (handler), expected);
soup_session_send_message (session, msg);
if (msg->status_code != SOUP_STATUS_UNAUTHORIZED &&
msg->status_code != SOUP_STATUS_OK) {
debug_printf (1, " %d %s !\n", msg->status_code,
msg->reason_phrase);
errors++;
}
if (*expected) {
debug_printf (1, " expected %d more round(s)\n",
(int)strlen (expected));
errors++;
}
g_free (expected);
if (msg->status_code != current_tests[i].final_status) {
debug_printf (1, " expected %d\n",
current_tests[i].final_status);
}
debug_printf (1, "\n");
g_object_unref (msg);
}
soup_uri_free (base_uri);
soup_test_session_abort_unref (session);
}
static void
do_async_auth_good_password_test (void)
{
SoupSession *session;
SoupMessage *msg1, *msg2, *msg3, msg2_bak;
guint auth_id;
char *uri;
SoupAuth *auth = NULL;
int remaining;
SOUP_TEST_SKIP_IF_NO_APACHE;
loop = g_main_loop_new (NULL, TRUE);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
uri = g_strconcat (base_uri, "Basic/realm1/", NULL);
remaining = 0;
msg1 = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg1), "id", GINT_TO_POINTER (1));
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (async_authenticate), &auth);
g_object_ref (msg1);
remaining++;
soup_session_queue_message (session, msg1, async_finished, &remaining);
g_main_loop_run (loop);
g_signal_handler_disconnect (session, auth_id);
/* async_authenticate will pause msg1 and quit loop */
msg2 = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg2), "id", GINT_TO_POINTER (2));
soup_session_send_message (session, msg2);
soup_test_assert_message_status (msg2, SOUP_STATUS_UNAUTHORIZED);
/* msg2 should be done at this point; assuming everything is
* working correctly, the session won't look at it again; we
* ensure that if it does, it will crash the test program.
*/
memcpy (&msg2_bak, msg2, sizeof (SoupMessage));
memset (msg2, 0, sizeof (SoupMessage));
msg3 = soup_message_new ("GET", uri);
g_object_set_data (G_OBJECT (msg3), "id", GINT_TO_POINTER (3));
auth_id = g_signal_connect (session, "authenticate",
G_CALLBACK (async_authenticate), NULL);
g_object_ref (msg3);
remaining++;
soup_session_queue_message (session, msg3, async_finished, &remaining);
g_main_loop_run (loop);
g_signal_handler_disconnect (session, auth_id);
/* async_authenticate will pause msg3 and quit loop */
/* Now do the auth, and restart */
if (auth) {
soup_auth_authenticate (auth, "user1", "realm1");
g_object_unref (auth);
soup_session_unpause_message (session, msg1);
soup_session_unpause_message (session, msg3);
g_main_loop_run (loop);
/* async_finished will quit the loop */
} else
soup_test_assert (auth, "msg1 didn't get authenticate signal");
soup_test_assert_message_status (msg1, SOUP_STATUS_OK);
soup_test_assert_message_status (msg3, SOUP_STATUS_OK);
soup_test_session_abort_unref (session);
g_object_unref (msg1);
g_object_unref (msg3);
memcpy (msg2, &msg2_bak, sizeof (SoupMessage));
g_object_unref (msg2);
g_free (uri);
g_main_loop_unref (loop);
}
static gboolean
ai_app_validate_image_check (AsImage *im, AsAppValidateHelper *helper)
{
AsImageAlphaFlags alpha_flags;
const gchar *url;
gboolean require_correct_aspect_ratio = FALSE;
gdouble desired_aspect = 1.777777778;
gdouble screenshot_aspect;
guint status_code;
guint screenshot_height;
guint screenshot_width;
guint ss_size_height_max = 900;
guint ss_size_height_min = 351;
guint ss_size_width_max = 1600;
guint ss_size_width_min = 624;
g_autoptr(GdkPixbuf) pixbuf = NULL;
g_autoptr(GInputStream) stream = NULL;
g_autoptr(SoupMessage) msg = NULL;
g_autoptr(SoupURI) base_uri = NULL;
/* make the requirements more strict */
if ((helper->flags & AS_APP_VALIDATE_FLAG_STRICT) > 0) {
require_correct_aspect_ratio = TRUE;
}
/* relax the requirements a bit */
if ((helper->flags & AS_APP_VALIDATE_FLAG_RELAX) > 0) {
ss_size_height_max = 1800;
ss_size_height_min = 150;
ss_size_width_max = 3200;
ss_size_width_min = 300;
}
/* have we got network access */
if ((helper->flags & AS_APP_VALIDATE_FLAG_NO_NETWORK) > 0)
return TRUE;
/* GET file */
url = as_image_get_url (im);
g_debug ("checking %s", url);
base_uri = soup_uri_new (url);
if (!SOUP_URI_VALID_FOR_HTTP (base_uri)) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_URL_NOT_FOUND,
"<screenshot> url not valid [%s]", url);
return FALSE;
}
msg = soup_message_new_from_uri (SOUP_METHOD_GET, base_uri);
if (msg == NULL) {
g_warning ("Failed to setup message");
return FALSE;
}
/* send sync */
status_code = soup_session_send_message (helper->session, msg);
if (SOUP_STATUS_IS_TRANSPORT_ERROR(status_code)) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_URL_NOT_FOUND,
"<screenshot> failed to connect: %s [%s]",
soup_status_get_phrase(status_code), url);
return FALSE;
} else if (status_code != SOUP_STATUS_OK) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_URL_NOT_FOUND,
"<screenshot> failed to download (HTTP %d: %s) [%s]",
status_code, soup_status_get_phrase(status_code), url);
return FALSE;
}
/* check if it's a zero sized file */
if (msg->response_body->length == 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_FILE_INVALID,
"<screenshot> url is a zero length file [%s]",
url);
return FALSE;
}
/* create a buffer with the data */
stream = g_memory_input_stream_new_from_data (msg->response_body->data,
(gssize) msg->response_body->length,
NULL);
if (stream == NULL) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_URL_NOT_FOUND,
"<screenshot> failed to load data [%s]",
url);
return FALSE;
}
/* load the image */
pixbuf = gdk_pixbuf_new_from_stream (stream, NULL, NULL);
if (pixbuf == NULL) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_FILE_INVALID,
"<screenshot> failed to load [%s]",
url);
return FALSE;
}
/* check width matches */
screenshot_width = (guint) gdk_pixbuf_get_width (pixbuf);
screenshot_height = (guint) gdk_pixbuf_get_height (pixbuf);
if (as_image_get_width (im) != 0 &&
as_image_get_width (im) != screenshot_width) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_ATTRIBUTE_INVALID,
"<screenshot> width did not match specified [%s]",
url);
}
/* check height matches */
if (as_image_get_height (im) != 0 &&
as_image_get_height (im) != screenshot_height) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_ATTRIBUTE_INVALID,
"<screenshot> height did not match specified [%s]",
url);
}
/* check size is reasonable */
if (screenshot_width < ss_size_width_min) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_ATTRIBUTE_INVALID,
"<screenshot> width too small [%s] minimum is %upx",
url, ss_size_width_min);
}
if (screenshot_height < ss_size_height_min) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_ATTRIBUTE_INVALID,
"<screenshot> height too small [%s] minimum is %upx",
url, ss_size_height_min);
}
if (screenshot_width > ss_size_width_max) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_ATTRIBUTE_INVALID,
"<screenshot> width too large [%s] maximum is %upx",
url, ss_size_width_max);
}
if (screenshot_height > ss_size_height_max) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_ATTRIBUTE_INVALID,
"<screenshot> height too large [%s] maximum is %upx",
url, ss_size_height_max);
}
/* check padding */
as_image_set_pixbuf (im, pixbuf);
alpha_flags = as_image_get_alpha_flags (im);
if ((alpha_flags & AS_IMAGE_ALPHA_FLAG_TOP) > 0||
(alpha_flags & AS_IMAGE_ALPHA_FLAG_BOTTOM) > 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<image> has vertical padding [%s]",
url);
}
if ((alpha_flags & AS_IMAGE_ALPHA_FLAG_LEFT) > 0||
(alpha_flags & AS_IMAGE_ALPHA_FLAG_RIGHT) > 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<image> has horizontal padding [%s]",
url);
}
/* check aspect ratio */
if (require_correct_aspect_ratio) {
screenshot_aspect = (gdouble) screenshot_width / (gdouble) screenshot_height;
if (ABS (screenshot_aspect - 1.777777777) > 0.1) {
g_debug ("got aspect %.2f, wanted %.2f",
screenshot_aspect, desired_aspect);
ai_app_validate_add (helper,
AS_PROBLEM_KIND_ASPECT_RATIO_INCORRECT,
"<screenshot> aspect ratio not 16:9 [%s]",
url);
}
}
return TRUE;
}
static void
do_message (SoupSession *session, SoupURI *base_uri, const char *path,
gboolean get_ntlm_prompt, gboolean do_ntlm,
gboolean get_basic_prompt, gboolean do_basic,
guint status_code)
{
SoupURI *uri;
SoupMessage *msg;
NTLMState state = { FALSE, FALSE, FALSE, FALSE };
uri = soup_uri_new_with_base (base_uri, path);
msg = soup_message_new_from_uri ("GET", uri);
soup_uri_free (uri);
g_signal_connect (msg, "got_headers",
G_CALLBACK (prompt_check), &state);
g_signal_connect (msg, "got_headers",
G_CALLBACK (challenge_check), &state);
g_signal_connect (msg, "wrote-headers",
G_CALLBACK (request_check), &state);
g_signal_connect (msg, "wrote-headers",
G_CALLBACK (response_check), &state);
soup_session_send_message (session, msg);
debug_printf (1, " %-10s -> ", path);
if (state.got_ntlm_prompt) {
debug_printf (1, " NTLM_PROMPT");
if (!get_ntlm_prompt) {
debug_printf (1, "???");
errors++;
}
} else if (get_ntlm_prompt) {
debug_printf (1, " no-ntlm-prompt???");
errors++;
}
if (state.got_basic_prompt) {
debug_printf (1, " BASIC_PROMPT");
if (!get_basic_prompt) {
debug_printf (1, "???");
errors++;
}
} else if (get_basic_prompt) {
debug_printf (1, " no-basic-prompt???");
errors++;
}
if (state.sent_ntlm_request) {
debug_printf (1, " REQUEST");
if (!do_ntlm) {
debug_printf (1, "???");
errors++;
}
} else if (do_ntlm) {
debug_printf (1, " no-request???");
errors++;
}
if (state.got_ntlm_challenge) {
debug_printf (1, " CHALLENGE");
if (!do_ntlm) {
debug_printf (1, "???");
errors++;
}
} else if (do_ntlm) {
debug_printf (1, " no-challenge???");
errors++;
}
if (state.sent_ntlm_response) {
debug_printf (1, " NTLM_RESPONSE");
if (!do_ntlm) {
debug_printf (1, "???");
errors++;
}
} else if (do_ntlm) {
debug_printf (1, " no-ntlm-response???");
errors++;
}
if (state.sent_basic_response) {
debug_printf (1, " BASIC_RESPONSE");
if (!do_basic) {
debug_printf (1, "???");
errors++;
}
} else if (do_basic) {
debug_printf (1, " no-basic-response???");
errors++;
}
debug_printf (1, " -> %s", msg->reason_phrase);
if (msg->status_code != status_code) {
debug_printf (1, "???");
errors++;
}
debug_printf (1, "\n");
g_object_unref (msg);
}
static void
do_message (const char *path, gboolean long_body,
gboolean expect_continue, gboolean auth,
...)
{
SoupSession *session;
SoupMessage *msg;
const char *body;
char *uri;
va_list ap;
const char *expected_event;
char *actual_event;
int expected_status, actual_status;
static int count = 1;
debug_printf (1, "%d. /%s, %s body, %sExpect, %s password\n",
count++, path,
long_body ? "long" : "short",
expect_continue ? "" : "no ",
auth ? "with" : "without");
uri = g_strdup_printf ("http://%s127.0.0.1:%d/%s",
auth ? "user:pass@" : "",
port, path);
msg = soup_message_new ("POST", uri);
g_free (uri);
body = long_body ? LONG_BODY : SHORT_BODY;
soup_message_set_request (msg, "text/plain", SOUP_MEMORY_STATIC,
body, strlen (body));
soup_message_headers_append (msg->request_headers, "Connection", "close");
if (expect_continue) {
soup_message_headers_set_expectations (msg->request_headers,
SOUP_EXPECTATION_CONTINUE);
}
g_signal_connect (msg, "got_informational",
G_CALLBACK (got_informational), "client");
g_signal_connect (msg, "got_headers",
G_CALLBACK (got_headers), "client");
g_signal_connect (msg, "got_body",
G_CALLBACK (got_body), "client");
g_signal_connect (msg, "wrote_informational",
G_CALLBACK (wrote_informational), "client");
g_signal_connect (msg, "wrote_headers",
G_CALLBACK (wrote_headers), "client");
g_signal_connect (msg, "wrote_body",
G_CALLBACK (wrote_body), "client");
g_signal_connect (msg, "finished",
G_CALLBACK (finished), "client");
events = NULL;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
soup_session_send_message (session, msg);
soup_test_session_abort_unref (session);
va_start (ap, auth);
while ((expected_event = va_arg (ap, const char *))) {
if (!events) {
actual_event = g_strdup ("");
debug_printf (1, " Expected '%s', got end of list\n",
expected_event);
errors++;
} else {
actual_event = events->data;
if (strcmp (expected_event, actual_event) != 0) {
debug_printf (1, " Expected '%s', got '%s'\n",
expected_event, actual_event);
errors++;
}
events = g_slist_delete_link (events, events);
}
if (!strcmp (expected_event, "server-wrote_headers") ||
!strcmp (expected_event, "server-wrote_informational"))
expected_status = va_arg (ap, int);
else
expected_status = -1;
if (!strcmp (actual_event, "server-wrote_headers") ||
!strcmp (actual_event, "server-wrote_informational")) {
actual_status = GPOINTER_TO_INT (events->data);
events = g_slist_delete_link (events, events);
} else
expected_status = -1;
if (expected_status != -1 && actual_status != -1 &&
expected_status != actual_status) {
debug_printf (1, " Expected status '%s', got '%s'\n",
soup_status_get_phrase (expected_status),
soup_status_get_phrase (actual_status));
errors++;
}
g_free (actual_event);
}
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 paste(GeanyDocument * doc, const gchar * website)
{
SoupSession *session;
SoupMessage *msg = NULL;
gchar *f_content;
gchar const *f_type;
gchar *f_title;
gchar *p_url;
gchar *formdata = NULL;
gchar *user_agent = NULL;
gchar **tokens_array;
const gchar *langs_supported_codepad[] =
{
"C", "C++", "D", "Haskell",
"Lua", "OCaml", "PHP", "Perl", "Plain Text",
"Python", "Ruby", "Scheme", "Tcl"
};
const gchar *langs_supported_dpaste[] =
{
"Bash", "C", "CSS", "Diff",
"Django/Jinja", "HTML", "IRC logs", "JavaScript", "PHP",
"Python console session", "Python Traceback", "Python",
"Python3", "Restructured Text", "SQL", "Text only"
};
gint occ_position;
gint i;
guint status;
gsize f_length;
g_return_if_fail(doc && doc->is_valid);
f_type = doc->file_type->name;
if (doc->file_name == NULL)
f_title = document_get_basename_for_display(doc, -1);
else
f_title = g_path_get_basename(doc->file_name);
load_settings();
f_content = get_paste_text(doc, &f_length);
if (f_content == NULL || f_content[0] == '\0')
{
dialogs_show_msgbox(GTK_MESSAGE_ERROR, _("Refusing to create blank paste"));
return;
}
switch (website_selected)
{
case CODEPAD_ORG:
for (i = 0; i < G_N_ELEMENTS(langs_supported_codepad); i++)
{
if (g_strcmp0(f_type, langs_supported_codepad[i]) == 0)
break;
else
f_type = DEFAULT_TYPE_CODEPAD;
}
msg = soup_message_new("POST", website);
formdata = soup_form_encode("lang", f_type,
"code", f_content,
"submit", "Submit",
NULL);
break;
case TINYPASTE_COM:
msg = soup_message_new("POST", website);
formdata = soup_form_encode("paste", f_content,
"title", f_title,
"is_code", g_strcmp0(f_type, "None") == 0 ? "0" : "1",
NULL);
break;
case DPASTE_DE:
for (i = 0; i < G_N_ELEMENTS(langs_supported_dpaste); i++)
{
if (g_strcmp0(f_type, langs_supported_dpaste[i]) == 0)
break;
else
f_type = DEFAULT_TYPE_DPASTE;
}
msg = soup_message_new("POST", website);
/* apparently dpaste.de detects automatically the syntax of the
* pasted code so 'lexer' should be unneeded
*/
formdata = soup_form_encode("content", f_content,
"title", f_title,
"lexer", f_type,
NULL);
break;
case SPRUNGE_US:
msg = soup_message_new("POST", website);
formdata = soup_form_encode("sprunge", f_content, NULL);
break;
case PASTEBIN_GEANY_ORG:
msg = soup_message_new("POST", website);
formdata = soup_form_encode("content", f_content,
"author", author_name,
"title", f_title,
"lexer", f_type,
NULL);
break;
}
g_free(f_content);
user_agent = g_strconcat(PLUGIN_NAME, " ", PLUGIN_VERSION, " / Geany ", GEANY_VERSION, NULL);
session = soup_session_async_new_with_options(SOUP_SESSION_USER_AGENT, user_agent, NULL);
g_free(user_agent);
soup_message_set_request(msg, "application/x-www-form-urlencoded",
SOUP_MEMORY_TAKE, formdata, strlen(formdata));
status = soup_session_send_message(session, msg);
p_url = g_strdup(msg->response_body->data);
g_object_unref(session);
g_object_unref(msg);
if(status == SOUP_STATUS_OK)
{
/*
* codepad.org doesn't return only the url of the new snippet pasted
* but an html page. This minimal parser will get the bare url.
*/
if (website_selected == CODEPAD_ORG)
{
tokens_array = g_strsplit(p_url, "<a href=\"", 0);
/* cuts the string when it finds the first occurrence of '/'
* It shoud work even if codepad would change its url.
*/
SETPTR(p_url, g_strdup(tokens_array[5]));
occ_position = indexof(tokens_array[5], '\"');
g_strfreev(tokens_array);
if(occ_position != -1)
{
p_url[occ_position] = '\0';
}
else
{
dialogs_show_msgbox(GTK_MESSAGE_ERROR, _("Unable to paste the code on codepad.org\n"
"Retry or select another pastebin."));
g_free(p_url);
return;
}
}
else if(website_selected == TINYPASTE_COM)
{
/* tinypaste.com returns a XML response which looks
* like this:
*
* <?xml version="1.0" encoding="utf-8"?>
* <result>
* <response>xxxxx</response>
* </result>
*/
tokens_array = g_strsplit_set(p_url, "<>", 0);
SETPTR(p_url, g_strdup_printf("http://%s/%s", websites[TINYPASTE_COM], tokens_array[6]));
g_strfreev(tokens_array);
}
else if(website_selected == DPASTE_DE)
{
SETPTR(p_url, g_strndup(p_url + 1, strlen(p_url) - 2));
}
else if(website_selected == SPRUNGE_US)
{
/* in order to enable the syntax highlightning on sprunge.us
* it is necessary to append at the returned url a question
* mark '?' followed by the file type.
*
* e.g. sprunge.us/xxxx?c
*/
gchar *ft_tmp = g_ascii_strdown(f_type, -1);
g_strstrip(p_url);
SETPTR(p_url, g_strdup_printf("%s?%s", p_url, ft_tmp));
g_free(ft_tmp);
}
if (check_button_is_checked)
{
utils_open_browser(p_url);
}
else
{
GtkWidget *dlg = gtk_message_dialog_new(GTK_WINDOW(geany->main_widgets->window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
_("Paste Successful"));
gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(dlg),
_("Your paste can be found here:\n<a href=\"%s\" "
"title=\"Click to open the paste in your browser\">%s</a>"), p_url, p_url);
gtk_dialog_run(GTK_DIALOG(dlg));
gtk_widget_destroy(dlg);
}
}
else
{
dialogs_show_msgbox(GTK_MESSAGE_ERROR, _("Unable to paste the code. Check your connection and retry.\n"
"Error code: %d\n"), status);
}
g_free(p_url);
}
gboolean
net_queue_dispatcher(void)
{
STNET *_stnet;
guint qlen = g_queue_get_length(rf->stqueue);
d("que len:%d workers:%d\n",
g_queue_get_length(rf->stqueue),
net_queue_run_count);
#if EVOLUTION_VERSION < 30304
if (qlen && net_queue_run_count < gconf_client_get_int (
rss_gconf,
GCONF_KEY_DOWNLOAD_QUEUE_SIZE,
NULL)) {
#else
if (qlen && net_queue_run_count < g_settings_get_int (
settings,
CONF_DOWNLOAD_QUEUE_SIZE)) {
#endif
net_queue_run_count++;
_stnet = g_queue_pop_head(rf->stqueue);
soup_session_queue_message (
_stnet->ss,
_stnet->sm,
_stnet->cb2,
_stnet->cbdata2);
g_free(_stnet);
return TRUE;
}
net_qid = 0;
return FALSE;
}
GString*
net_post_blocking(gchar *url,
GSList *headers,
GString *post,
NetStatusCallback cb,
gpointer data,
GError **err) {
#if LIBSOUP_VERSION < 2003000
SoupUri *suri = NULL;
#else
SoupURI *suri = NULL;
#endif
SoupMessage *req = NULL;
GString *response = NULL;
CallbackInfo info = { cb, data, 0, 0 };
SoupSession *soup_sess = NULL;
gchar *agstr;
if (!rf->b_session)
rf->b_session = soup_sess =
soup_session_sync_new_with_options(
SOUP_SESSION_TIMEOUT,
SS_TIMEOUT,
NULL);
else
soup_sess = rf->b_session;
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
req = soup_message_new(SOUP_METHOD_GET, url);
if (!req) {
g_set_error(err, NET_ERROR, NET_ERROR_GENERIC, "%s",
soup_status_get_phrase(2)); //invalid url
goto out;
}
d("request ok :%d\n", req->status_code);
g_signal_connect(G_OBJECT(req), "got-chunk",
G_CALLBACK(got_chunk_blocking_cb), &info);
for (; headers; headers = headers->next) {
char *header = headers->data;
/* soup wants the key and value separate, so we have to munge this
* a bit. */
char *colonpos = strchr(header, ':');
*colonpos = 0;
#if LIBSOUP_VERSION < 2003000
soup_message_add_header(
req->request_headers,
header,
colonpos+1);
#else
soup_message_headers_append(
req->request_headers, header, colonpos+1);
#endif
*colonpos = ':';
}
agstr = g_strdup_printf("Evolution/%s; Evolution-RSS/%s",
EVOLUTION_VERSION_STRING, VERSION);
#if LIBSOUP_VERSION < 2003000
soup_message_add_header (
req->request_headers,
"User-Agent",
agstr);
#else
soup_message_headers_append (
req->request_headers,
"User-Agent",
agstr);
#endif
g_free(agstr);
#if (DATASERVER_VERSION >= 2023001)
proxify_session(proxy, soup_sess, url);
#endif
rf->b_session = soup_sess;
rf->b_msg_session = req;
soup_session_send_message(soup_sess, req);
if (req->status_code != SOUP_STATUS_OK) {
//might not be a good ideea
soup_session_abort(soup_sess);
g_object_unref(soup_sess);
rf->b_session = NULL;
g_set_error(err, NET_ERROR, NET_ERROR_GENERIC, "%s",
soup_status_get_phrase(req->status_code));
goto out;
}
#if LIBSOUP_VERSION < 2003000
response = g_string_new_len(
req->response.body,
req->response.length);
#else
response = g_string_new_len(
req->response_body->data,
req->response_body->length);
#endif
out:
if (suri) soup_uri_free(suri);
if (req) g_object_unref(G_OBJECT(req));
return response;
}
guint
net_get_status(const char *url, GError **err)
{
#if LIBSOUP_VERSION < 2003000
SoupUri *suri = NULL;
#else
SoupURI *suri = NULL;
#endif
SoupMessage *req = NULL;
guint response = 0;
SoupSession *soup_sess = NULL;
GSList *headers = NULL;
gchar *agstr;
if (!rf->b_session)
rf->b_session = soup_sess =
soup_session_sync_new_with_options(
SOUP_SESSION_TIMEOUT, SS_TIMEOUT, NULL);
else
soup_sess = rf->b_session;
req = soup_message_new(SOUP_METHOD_GET, url);
if (!req) {
g_set_error(err, NET_ERROR, NET_ERROR_GENERIC, "%s",
soup_status_get_phrase(2)); //invalid url
goto out;
}
for (; headers; headers = headers->next) {
char *header = headers->data;
/* soup wants the key and value separate, so we have to munge this
* a bit. */
char *colonpos = strchr(header, ':');
*colonpos = 0;
#if LIBSOUP_VERSION < 2003000
soup_message_add_header(
req->request_headers, header, colonpos+1);
#else
soup_message_headers_append(
req->request_headers, header, colonpos+1);
#endif
*colonpos = ':';
}
agstr = g_strdup_printf("Evolution/%s; Evolution-RSS/%s",
EVOLUTION_VERSION_STRING, VERSION);
#if LIBSOUP_VERSION < 2003000
soup_message_add_header (req->request_headers,
"User-Agent",
agstr);
#else
soup_message_headers_append (req->request_headers,
"User-Agent",
agstr);
#endif
g_free(agstr);
rf->b_session = soup_sess;
rf->b_msg_session = req;
soup_session_send_message(soup_sess, req);
if (req->status_code != SOUP_STATUS_OK) {
//might not be a good ideea
soup_session_abort(soup_sess);
g_object_unref(soup_sess);
rf->b_session = NULL;
g_set_error(err, NET_ERROR, NET_ERROR_GENERIC, "%s",
soup_status_get_phrase(req->status_code));
goto out;
}
out:
if (suri) soup_uri_free(suri);
response = req->status_code;
if (req) g_object_unref(G_OBJECT(req));
return response;
}
static void
cb_media_downloader_load_threaded (CbMediaDownloader *downloader,
CbMedia *media)
{
const char *url;
SoupMessage *msg;
GInputStream *input_stream;
g_return_if_fail (CB_IS_MEDIA_DOWNLOADER (downloader));
g_return_if_fail (CB_IS_MEDIA (media));
g_return_if_fail (media->url != NULL);
g_object_ref (media);
url = canonicalize_url (media->url);
/* For these, we first need to download some html and get the real
URL of the image we want to display */
if (g_str_has_prefix (url, "instagr.am") ||
g_str_has_prefix (url, "instagram.com/p/"))
{
cb_media_downloader_get_instagram_url (downloader, media);
}
else if (g_str_has_prefix (url, "ow.ly/i/") ||
g_str_has_prefix (url, "flickr.com/photos/") ||
g_str_has_prefix (url, "flic.kr/p/") ||
g_str_has_prefix (url, "flic.kr/s/") ||
g_str_has_prefix (url, "vine.co/v/"))
{
cb_media_downloader_load_real_url (downloader, media,
"<meta property=\"og:image\" content=\"(.*?)\"", 1);
}
else if (g_str_has_prefix (url, "twitpic.com/"))
{
cb_media_downloader_load_real_url (downloader, media,
"<meta name=\"twitter:image\" value=\"(.*?)\"", 1);
}
else if (g_str_has_suffix (url, "/photo/1"))
{
cb_media_downloader_load_twitter_video (downloader, media);
}
else if (g_str_has_prefix (url, "d.pr/i/"))
{
cb_media_downloader_load_real_url (downloader, media,
"<meta property=\"og:image\"\\s+content=\"(.*?)\"", 1);
}
if (media->url == NULL)
{
g_warning ("Media is invalid.");
mark_invalid (media);
return;
}
msg = soup_message_new ("GET", media->thumb_url ? media->thumb_url : media->url);
if (msg == NULL)
{
mark_invalid (media);
g_warning ("soup_message_new failed for URI '%s'",
media->thumb_url ? media->thumb_url : media->url);
return;
}
g_signal_connect (msg, "got-chunk", G_CALLBACK (update_media_progress), media);
soup_session_send_message (downloader->soup_session, msg);
if (msg->status_code != SOUP_STATUS_OK)
{
g_debug ("Request on '%s' returned status '%s'",
media->thumb_url ? media->thumb_url : media->url,
soup_status_get_phrase (msg->status_code));
mark_invalid (media);
g_object_unref (msg);
return;
}
input_stream = g_memory_input_stream_new_from_data (msg->response_body->data,
msg->response_body->length,
NULL);
load_animation (input_stream, media);
g_input_stream_close (input_stream, NULL, NULL);
g_object_unref (input_stream);
g_object_unref (msg);
}
/**
* fu_util_download_file:
**/
static gboolean
fu_util_download_file (FuUtilPrivate *priv,
const gchar *uri,
const gchar *fn,
const gchar *checksum_expected,
GError **error)
{
guint status_code;
_cleanup_error_free_ GError *error_local = NULL;
_cleanup_free_ gchar *checksum_actual = NULL;
_cleanup_object_unref_ SoupMessage *msg = NULL;
_cleanup_object_unref_ SoupSession *session = NULL;
session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT,
"fwupdmgr",
NULL);
if (session == NULL) {
g_set_error_literal (error,
FWUPD_ERROR,
FWUPD_ERROR_INTERNAL,
"%s: failed to setup networking");
return FALSE;
}
/* this disables the double-compression of the firmware.xml.gz file */
soup_session_remove_feature_by_type (session, SOUP_TYPE_CONTENT_DECODER);
/* download data */
g_debug ("downloading %s to %s:", uri, fn);
msg = soup_message_new (SOUP_METHOD_GET, uri);
status_code = soup_session_send_message (session, msg);
if (status_code != SOUP_STATUS_OK) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INVALID_FILE,
"Failed to download %s: %s",
uri, soup_status_get_phrase (status_code));
return FALSE;
}
/* verify checksum */
if (checksum_expected != NULL) {
checksum_actual = g_compute_checksum_for_data (G_CHECKSUM_SHA1,
(guchar *) msg->response_body->data,
msg->response_body->length);
if (g_strcmp0 (checksum_expected, checksum_actual) != 0) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INVALID_FILE,
"Checksum invalid, expected %s got %s",
checksum_expected, checksum_actual);
return FALSE;
}
}
/* save file */
if (!g_file_set_contents (fn,
msg->response_body->data,
msg->response_body->length,
&error_local)) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_WRITE,
"Failed to save file: %s",
error_local->message);
return FALSE;
}
return TRUE;
}
static void
refine_app (GsPlugin *plugin, GsApp *app, JsonObject *package, gboolean from_search, GCancellable *cancellable)
{
g_autofree gchar *macaroon = NULL;
g_auto(GStrv) discharges = NULL;
const gchar *status, *icon_url, *launch_name = NULL;
g_autoptr(GdkPixbuf) icon_pixbuf = NULL;
gint64 size = -1;
get_macaroon (plugin, &macaroon, &discharges);
status = json_object_get_string_member (package, "status");
if (g_strcmp0 (status, "installed") == 0 || g_strcmp0 (status, "active") == 0) {
const gchar *update_available;
update_available = json_object_has_member (package, "update_available") ?
json_object_get_string_member (package, "update_available") : NULL;
if (update_available)
gs_app_set_state (app, AS_APP_STATE_UPDATABLE);
else {
if (gs_app_get_state (app) == AS_APP_STATE_AVAILABLE)
gs_app_set_state (app, AS_APP_STATE_UNKNOWN);
gs_app_set_state (app, AS_APP_STATE_INSTALLED);
}
} else if (g_strcmp0 (status, "not installed") == 0 || g_strcmp0 (status, "available") == 0) {
gs_app_set_state (app, AS_APP_STATE_AVAILABLE);
}
gs_app_set_name (app, GS_APP_QUALITY_HIGHEST,
json_object_get_string_member (package, "summary"));
gs_app_set_summary (app, GS_APP_QUALITY_HIGHEST,
json_object_get_string_member (package, "summary"));
gs_app_set_description (app, GS_APP_QUALITY_HIGHEST,
json_object_get_string_member (package, "description"));
gs_app_set_version (app, json_object_get_string_member (package, "version"));
if (json_object_has_member (package, "installed-size")) {
size = json_object_get_int_member (package, "installed-size");
if (size > 0)
gs_app_set_size_installed (app, (guint64) size);
}
if (json_object_has_member (package, "download-size")) {
size = json_object_get_int_member (package, "download-size");
if (size > 0)
gs_app_set_size_download (app, (guint64) size);
}
gs_app_add_quirk (app, AS_APP_QUIRK_PROVENANCE);
icon_url = json_object_get_string_member (package, "icon");
if (g_str_has_prefix (icon_url, "/")) {
g_autofree gchar *icon_data = NULL;
gsize icon_data_length;
g_autoptr(GError) error = NULL;
icon_data = gs_snapd_get_resource (macaroon, discharges, icon_url, &icon_data_length, cancellable, &error);
if (icon_data != NULL) {
g_autoptr(GdkPixbufLoader) loader = NULL;
loader = gdk_pixbuf_loader_new ();
gdk_pixbuf_loader_write (loader,
(guchar *) icon_data,
icon_data_length,
NULL);
gdk_pixbuf_loader_close (loader, NULL);
icon_pixbuf = g_object_ref (gdk_pixbuf_loader_get_pixbuf (loader));
}
else
g_printerr ("Failed to get icon: %s\n", error->message);
}
else {
g_autoptr(SoupMessage) message = NULL;
g_autoptr(GdkPixbufLoader) loader = NULL;
message = soup_message_new (SOUP_METHOD_GET, icon_url);
if (message != NULL) {
soup_session_send_message (gs_plugin_get_soup_session (plugin), message);
loader = gdk_pixbuf_loader_new ();
gdk_pixbuf_loader_write (loader,
(guint8 *) message->response_body->data,
(gsize) message->response_body->length,
NULL);
gdk_pixbuf_loader_close (loader, NULL);
icon_pixbuf = g_object_ref (gdk_pixbuf_loader_get_pixbuf (loader));
}
}
if (icon_pixbuf) {
gs_app_set_pixbuf (app, icon_pixbuf);
} else {
g_autoptr(AsIcon) icon = as_icon_new ();
as_icon_set_kind (icon, AS_ICON_KIND_STOCK);
as_icon_set_name (icon, "package-x-generic");
gs_app_add_icon (app, icon);
}
if (json_object_has_member (package, "screenshots") && gs_app_get_screenshots (app)->len <= 0) {
JsonArray *screenshots;
guint i;
screenshots = json_object_get_array_member (package, "screenshots");
for (i = 0; i < json_array_get_length (screenshots); i++) {
JsonObject *screenshot = json_array_get_object_element (screenshots, i);
g_autoptr(AsScreenshot) ss = NULL;
g_autoptr(AsImage) image = NULL;
ss = as_screenshot_new ();
as_screenshot_set_kind (ss, AS_SCREENSHOT_KIND_NORMAL);
image = as_image_new ();
as_image_set_url (image, json_object_get_string_member (screenshot, "url"));
as_image_set_kind (image, AS_IMAGE_KIND_SOURCE);
as_screenshot_add_image (ss, image);
gs_app_add_screenshot (app, ss);
}
}
if (!from_search) {
JsonArray *apps;
apps = json_object_get_array_member (package, "apps");
if (apps && json_array_get_length (apps) > 0)
launch_name = json_object_get_string_member (json_array_get_object_element (apps, 0), "name");
if (launch_name)
gs_app_set_metadata (app, "snap::launch-name", launch_name);
else
gs_app_add_quirk (app, AS_APP_QUIRK_NOT_LAUNCHABLE);
}
}
static void
do_batch_tests (gconstpointer data)
{
const SoupAuthTest *current_tests = data;
SoupSession *session;
SoupMessage *msg;
char *expected, *uristr;
SoupURI *base;
guint signal;
int i;
SOUP_TEST_SKIP_IF_NO_APACHE;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
base = soup_uri_new (base_uri);
for (i = 0; current_tests[i].url; i++) {
SoupURI *soup_uri = soup_uri_new_with_base (base, current_tests[i].url);
debug_printf (1, "Test %d: %s\n", i + 1, current_tests[i].explanation);
if (current_tests[i].url_auth) {
gchar *username = g_strdup_printf ("user%c", current_tests[i].provided[0]);
gchar *password = g_strdup_printf ("realm%c", current_tests[i].provided[0]);
soup_uri_set_user (soup_uri, username);
soup_uri_set_password (soup_uri, password);
g_free (username);
g_free (password);
}
msg = soup_message_new_from_uri (SOUP_METHOD_GET, soup_uri);
soup_uri_free (soup_uri);
if (!msg) {
g_printerr ("auth-test: Could not parse URI\n");
exit (1);
}
uristr = soup_uri_to_string (soup_message_get_uri (msg), FALSE);
debug_printf (1, " GET %s\n", uristr);
g_free (uristr);
expected = g_strdup (current_tests[i].expected);
soup_message_add_status_code_handler (
msg, "got_headers", SOUP_STATUS_UNAUTHORIZED,
G_CALLBACK (handler), expected);
soup_message_add_status_code_handler (
msg, "got_headers", SOUP_STATUS_OK,
G_CALLBACK (handler), expected);
signal = g_signal_connect (session, "authenticate",
G_CALLBACK (authenticate),
(gpointer)¤t_tests[i]);
soup_session_send_message (session, msg);
g_signal_handler_disconnect (session, signal);
soup_test_assert_message_status (msg, current_tests[i].final_status);
soup_test_assert (!*expected,
"expected %d more round(s)\n",
(int)strlen (expected));
g_free (expected);
debug_printf (1, "\n");
g_object_unref (msg);
}
soup_uri_free (base);
soup_test_session_abort_unref (session);
}
/* FIXME: moar tests! */
static void
do_cookies_parsing_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupCookieJar *jar;
GSList *cookies, *iter;
SoupCookie *cookie;
gboolean got1, got2, got3;
debug_printf (1, "\nSoupCookie parsing test\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
soup_session_add_feature_by_type (session, SOUP_TYPE_COOKIE_JAR);
jar = SOUP_COOKIE_JAR (soup_session_get_feature (session, SOUP_TYPE_COOKIE_JAR));
/* "httponly" is case-insensitive, and its value (if any) is ignored */
msg = soup_message_new_from_uri ("GET", first_party_uri);
soup_message_headers_append (msg->request_headers, "Echo-Set-Cookie",
"one=1; httponly; max-age=100");
soup_session_send_message (session, msg);
g_object_unref (msg);
msg = soup_message_new_from_uri ("GET", first_party_uri);
soup_message_headers_append (msg->request_headers, "Echo-Set-Cookie",
"two=2; HttpOnly; max-age=100");
soup_session_send_message (session, msg);
g_object_unref (msg);
msg = soup_message_new_from_uri ("GET", first_party_uri);
soup_message_headers_append (msg->request_headers, "Echo-Set-Cookie",
"three=3; httpONLY=Wednesday; max-age=100");
soup_session_send_message (session, msg);
g_object_unref (msg);
cookies = soup_cookie_jar_get_cookie_list (jar, first_party_uri, TRUE);
got1 = got2 = got3 = FALSE;
for (iter = cookies; iter; iter = iter->next) {
cookie = iter->data;
if (!strcmp (soup_cookie_get_name (cookie), "one")) {
got1 = TRUE;
if (!soup_cookie_get_http_only (cookie)) {
debug_printf (1, " cookie 1 is not HttpOnly!\n");
errors++;
}
if (!soup_cookie_get_expires (cookie)) {
debug_printf (1, " cookie 1 did not fully parse!\n");
errors++;
}
} else if (!strcmp (soup_cookie_get_name (cookie), "two")) {
got2 = TRUE;
if (!soup_cookie_get_http_only (cookie)) {
debug_printf (1, " cookie 2 is not HttpOnly!\n");
errors++;
}
if (!soup_cookie_get_expires (cookie)) {
debug_printf (1, " cookie 3 did not fully parse!\n");
errors++;
}
} else if (!strcmp (soup_cookie_get_name (cookie), "three")) {
got3 = TRUE;
if (!soup_cookie_get_http_only (cookie)) {
debug_printf (1, " cookie 3 is not HttpOnly!\n");
errors++;
}
if (!soup_cookie_get_expires (cookie)) {
debug_printf (1, " cookie 3 did not fully parse!\n");
errors++;
}
} else {
debug_printf (1, " got unexpected cookie '%s'\n",
soup_cookie_get_name (cookie));
errors++;
}
soup_cookie_free (cookie);
}
g_slist_free (cookies);
if (!got1) {
debug_printf (1, " didn't get cookie 1\n");
errors++;
}
if (!got2) {
debug_printf (1, " didn't get cookie 2\n");
errors++;
}
if (!got3) {
debug_printf (1, " didn't get cookie 3\n");
errors++;
}
soup_test_session_abort_unref (session);
}
bool oauth_login(
GtkBuilder *builder,
char **username_p,
char **auth_token_p,
char **auth_secret_p,
uint64_t *userid_p,
GError **err_p)
{
#if !USE_LOCAL_CGI
const char *token_uri = "https://api.twitter.com/oauth/request_token";
const char *access_uri = "https://api.twitter.com/oauth/access_token";
#else
const char *token_uri = "https://localhost/cgi-bin/oauth.cgi/request_token";
const char *access_uri = "https://localhost/cgi-bin/oauth.cgi/access_token";
#endif
SoupSession *ss = soup_session_async_new();
#if 0
SoupLogger *logger = soup_logger_new(1, -1);
soup_session_add_feature(ss, SOUP_SESSION_FEATURE(logger));
g_object_unref(logger);
#endif
SoupMessage *msg = make_token_request_msg(token_uri, CONSUMER_KEY,
CONSUMER_SECRET);
if(msg == NULL) {
/* FIXME */
abort();
}
soup_session_send_message(ss, msg);
bool ok;
if(msg->status_code != SOUP_STATUS_OK) {
fprintf(stderr, "%s: server returned status %d (%s)\n", __func__,
msg->status_code, soup_status_get_phrase(msg->status_code));
ok = false;
goto end;
}
/* interpret the response. */
char **rt_output = oa_parse_response(msg->response_body->data,
"oauth_token", "oauth_token_secret", NULL);
if(rt_output == NULL) {
g_set_error(err_p, 0, EINVAL, "can't parse response data");
ok = false;
goto end;
}
/* do out-of-band OAuth */
const char *req_token = rt_output[0], *req_secret = rt_output[1];
#if !USE_LOCAL_CGI
GError *err = NULL;
if(!launch_authorization_browser(req_token, &err)) {
fprintf(stderr, "warning: browser launching failed: %s\n",
err->message);
g_error_free(err);
}
#endif
char *pin = query_pin(builder);
printf("PIN is: `%s'\n", pin);
/* get an access token */
g_object_unref(msg);
msg = make_access_token_request_msg(access_uri, req_token, req_secret,
pin, CONSUMER_KEY, CONSUMER_SECRET);
g_free(pin);
if(msg == NULL) {
fprintf(stderr, "can't sign access request message!\n");
abort();
}
soup_session_send_message(ss, msg);
if(msg->status_code != SOUP_STATUS_OK) {
fprintf(stderr, "%s: server returned status %d (%s)\n", __func__,
msg->status_code, soup_status_get_phrase(msg->status_code));
/* FIXME: handle */
abort();
}
char **at_output = oa_parse_response(msg->response_body->data,
"oauth_token", "oauth_token_secret", "user_id", "screen_name", NULL);
if(at_output == NULL) {
/* FIXME: response data parsing fail */
abort();
}
/* the payoff */
*auth_token_p = g_strdup(at_output[0]);
*auth_secret_p = g_strdup(at_output[1]);
*userid_p = strtoull(at_output[2], NULL, 10);
*username_p = g_strdup(at_output[3]);
printf("login successful! username `%s', userid %llu\n", *username_p,
(unsigned long long)*userid_p);
g_strfreev(at_output);
g_strfreev(rt_output);
ok = true;
end:
g_object_unref(msg);
g_object_unref(ss);
return ok;
}
/**
* gs_plugin_fedora_tagger_download:
*/
static gboolean
gs_plugin_fedora_tagger_download (GsPlugin *plugin, GError **error)
{
FedoraTaggerItem *item;
gdouble count_sum = 0;
guint i;
guint status_code;
_cleanup_free_ gchar *uri = NULL;
_cleanup_object_unref_ SoupMessage *msg = NULL;
_cleanup_ptrarray_unref_ GPtrArray *items = NULL;
_cleanup_strv_free_ gchar **split = NULL;
/* create the GET data */
uri = g_strdup_printf ("%s/api/v1/rating/dump/",
GS_PLUGIN_FEDORA_TAGGER_SERVER);
msg = soup_message_new (SOUP_METHOD_GET, uri);
/* ensure networking is set up */
if (!gs_plugin_setup_networking (plugin, error))
return FALSE;
/* set sync request */
status_code = soup_session_send_message (plugin->priv->session, msg);
if (status_code != SOUP_STATUS_OK) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"Failed to download fedora-tagger dump: %s",
soup_status_get_phrase (status_code));
return FALSE;
}
/* process the tab-delimited data */
items = g_ptr_array_new_with_free_func ((GDestroyNotify) fedora_tagger_item_free);
split = g_strsplit (msg->response_body->data, "\n", -1);
for (i = 0; split[i] != NULL; i++) {
_cleanup_strv_free_ gchar **fields = NULL;
if (split[i][0] == '\0' ||
split[i][0] == '#')
continue;
fields = g_strsplit (split[i], "\t", -1);
if (g_strv_length (fields) == 4) {
item = g_slice_new0 (FedoraTaggerItem);
item->pkgname = g_strdup (fields[0]);
item->rating = g_strtod (fields[1], NULL);
item->vote_count = g_strtod (fields[2], NULL);
item->user_count = g_strtod (fields[3], NULL);
g_ptr_array_add (items, item);
} else {
g_warning ("unexpected data from fedora-tagger, expected: "
"'pkgname\trating\tvote_count\tuser_count' and got '%s'",
split[i]);
}
}
/* no suitable data? */
if (items->len == 0) {
g_set_error_literal (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"Failed to get data from fedora-tagger");
return FALSE;
}
/* calculate confidence */
for (i = 0; i < items->len; i++) {
item = g_ptr_array_index (items, i);
count_sum += item->vote_count;
}
if (count_sum == 0) {
g_set_error_literal (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"Failed to get vote count in fedora-tagger");
return FALSE;
}
count_sum /= (gdouble) items->len;
g_debug ("fedora-tagger vote_count average is %.2f", count_sum);
for (i = 0; i < items->len; i++) {
item = g_ptr_array_index (items, i);
item->confidence = MAX (100.0f * item->vote_count / count_sum, 100);
}
/* add each completed item */
for (i = 0; i < items->len; i++) {
item = g_ptr_array_index (items, i);
g_debug ("adding %s: %.1f%% [%.1f] {%.1f%%}",
item->pkgname, item->rating,
item->vote_count, item->confidence);
if (!gs_plugin_fedora_tagger_add (plugin, item, error))
return FALSE;
}
/* reset the timestamp */
return gs_plugin_fedora_tagger_set_timestamp (plugin, "mtime", error);
}
static void
do_coding_test (void)
{
SoupSession *session;
SoupMessage *msg, *msgz, *msgj, *msge, *msgzl, *msgzlj, *msgzle, *msgzlr, *msgzlre;
SoupURI *uri;
debug_printf (1, "SoupMessage tests\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
uri = soup_uri_new_with_base (base_uri, "/mbox");
/* Plain text data, no claim */
debug_printf (1, " GET /mbox, plain\n");
msg = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msg);
check_response (msg, NULL, "text/plain", EXPECT_NOT_DECODED);
/* 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);
msgz = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msgz);
check_response (msgz, "gzip", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgz, "plain", "compressed");
/* Plain text data, claim gzip w/ junk */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip, plus trailing junk\n");
msgj = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgj->request_headers,
"X-Test-Options", "trailing-junk");
soup_session_send_message (session, msgj);
check_response (msgj, "gzip", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgj, "plain", "compressed w/ junk");
/* Plain text data, claim gzip with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip, with server error\n");
msge = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msge->request_headers,
"X-Test-Options", "force-encode");
soup_session_send_message (session, msge);
check_response (msge, "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_msg_bodies (msg, msge, "plain", "mis-encoded");
/* Plain text data, claim deflate */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate\n");
msgzl = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzl->request_headers,
"X-Test-Options", "prefer-deflate-zlib");
soup_session_send_message (session, msgzl);
check_response (msgzl, "deflate", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgzl, "plain", "compressed");
/* Plain text data, claim deflate w/ junk */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate, plus trailing junk\n");
msgzlj = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzlj->request_headers,
"X-Test-Options", "prefer-deflate-zlib, trailing-junk");
soup_session_send_message (session, msgzlj);
check_response (msgzlj, "deflate", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgzlj, "plain", "compressed w/ junk");
/* Plain text data, claim deflate with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate, with server error\n");
msgzle = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzle->request_headers,
"X-Test-Options", "force-encode, prefer-deflate-zlib");
soup_session_send_message (session, msgzle);
check_response (msgzle, "deflate", "text/plain", EXPECT_NOT_DECODED);
check_msg_bodies (msg, msgzle, "plain", "mis-encoded");
/* Plain text data, claim deflate (no zlib headers)*/
debug_printf (1, " GET /mbox, Accept-Encoding: deflate (raw data)\n");
msgzlr = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzlr->request_headers,
"X-Test-Options", "prefer-deflate-raw");
soup_session_send_message (session, msgzlr);
check_response (msgzlr, "deflate", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgzlr, "plain", "compressed");
/* Plain text data, claim deflate with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate (raw data), with server error\n");
msgzlre = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzlre->request_headers,
"X-Test-Options", "force-encode, prefer-deflate-raw");
soup_session_send_message (session, msgzlre);
check_response (msgzlre, "deflate", "text/plain", EXPECT_NOT_DECODED);
check_msg_bodies (msg, msgzlre, "plain", "mis-encoded");
g_object_unref (msg);
g_object_unref (msgzlre);
g_object_unref (msgzlr);
g_object_unref (msgzlj);
g_object_unref (msgzle);
g_object_unref (msgzl);
g_object_unref (msgz);
g_object_unref (msgj);
g_object_unref (msge);
soup_uri_free (uri);
soup_test_session_abort_unref (session);
}
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
select_auth_test_one (SoupURI *uri,
gboolean disable_digest, const char *password,
const char *first_headers, const char *first_response,
const char *second_headers, const char *second_response,
guint final_status)
{
SelectAuthData sad;
SoupMessage *msg;
SoupSession *session;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
if (disable_digest)
soup_session_remove_feature_by_type (session, SOUP_TYPE_AUTH_DIGEST);
g_signal_connect (session, "authenticate",
G_CALLBACK (select_auth_authenticate), &sad);
memset (&sad, 0, sizeof (sad));
sad.password = password;
msg = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msg);
if (strcmp (sad.round[0].headers, first_headers) != 0) {
debug_printf (1, " Header order wrong: expected %s, got %s\n",
first_headers, sad.round[0].headers);
errors++;
}
if (strcmp (sad.round[0].response, first_response) != 0) {
debug_printf (1, " Selected auth type wrong: expected %s, got %s\n",
first_response, sad.round[0].response);
errors++;
}
if (second_headers && !sad.round[1].headers) {
debug_printf (1, " Expected a second round!\n");
errors++;
} else if (!second_headers && sad.round[1].headers) {
debug_printf (1, " Didn't expect a second round!\n");
errors++;
} else if (second_headers) {
if (strcmp (sad.round[1].headers, second_headers) != 0) {
debug_printf (1, " Second round header order wrong: expected %s, got %s\n",
second_headers, sad.round[1].headers);
errors++;
}
if (strcmp (sad.round[1].response, second_response) != 0) {
debug_printf (1, " Second round selected auth type wrong: expected %s, got %s\n",
second_response, sad.round[1].response);
errors++;
}
}
if (msg->status_code != final_status) {
debug_printf (1, " Final status wrong: expected %u, got %u\n",
final_status, msg->status_code);
errors++;
}
g_object_unref (msg);
soup_test_session_abort_unref (session);
}
int main(int argc, char *argv[])
{
char packet[] = {0x00, 0x00, 0x00};
float temp, hum;
int error_count = 0;
int count = 1;
GError *error = NULL;
GOptionContext *context;
context = g_option_context_new ("- collect temperature and humidity readings");
g_option_context_add_main_entries (context, entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_print ("option parsing failed: %s\n", error->message);
exit (1);
}
g_option_context_free(context);
set_debug(debug);
hid_device *handle;
gboolean found = search_for_device();
if(!found) {
g_printerr("Sensor not found, aborting.\n");
exit(-1);
}
// Open the device using the VID and PID
handle = open_lascar();
if(handle == NULL) {
g_printerr("Error opening sensor.\n");
exit(-1);
}
SoupSession *session = NULL;
int channel;
gchar *channel_name;
gchar *room;
GString *uri, *body;
/* parse config file */
GKeyFile *gkf = g_key_file_new();
g_key_file_load_from_data_dirs(gkf,"templogger.conf",NULL,G_KEY_FILE_NONE,&error);
if(error!=NULL) {
g_printerr("Can't load configuration file, not uploading to server.\n");
g_key_file_free(gkf);
}
else {
gchar *url = g_key_file_get_string(gkf,"influx","url",NULL);
channel = g_key_file_get_integer(gkf,"channel","channel_num",NULL);
channel_name = g_key_file_get_string(gkf,"channel","channel_name",NULL);
room = g_key_file_get_string(gkf,"channel","room",NULL);
int port = g_key_file_get_integer(gkf,"influx","port",NULL);
gchar *db = g_key_file_get_string(gkf,"influx","database",NULL);
gchar *username = g_key_file_get_string(gkf,"influx","username",NULL);
gchar *password = g_key_file_get_string(gkf,"influx","password",NULL);
g_key_file_free(gkf);
/* open session */
session = soup_session_new();
uri = g_string_new("http://");
g_string_append_printf(uri,"%s:%d/write?db=%s&u=%s&p=%s",url,port,db,username,password);
g_message(uri->str);
body = g_string_new("");
g_print("Uploading as channel %d, name %s, room %s",channel, channel_name, room);
}
FILE *logfile = NULL;
if(log_local) {
logfile = fopen("log.txt","a");
}
const int upload_freq = floor(UPLOAD_TIME/SLEEP_TIME);
while(1) {
int ret = get_reading(handle, packet, &temp, &hum, TRUE);
if(ret >= 0) {
gint64 t = 1000*g_get_real_time();
if(log_local) {
fprintf(logfile,"%" G_GINT64_FORMAT "\t%.1f\t%.1f\n",t, temp, hum);
fflush(logfile);
}
if(debug)
g_print("%" G_GINT64_FORMAT "\t%.1f\t%.1f\n",t, temp, hum);
if(session && (count % upload_freq == 0)) {
SoupRequestHTTP *request = soup_session_request_http(session,"POST",uri->str,NULL);
SoupMessage *message = soup_request_http_get_message(request);
g_string_append_printf(body,"temp,channel=%d,channel_name=%s,room=%s",channel,channel_name,room);
g_string_append_printf(body," value=%.1f %" G_GINT64_FORMAT,temp,t);
g_string_append_printf(body,"\n");
g_string_append_printf(body,"hum,channel=%d,channel_name=%s,room=%s",channel,channel_name,room);
g_string_append_printf(body," value=%.1f %" G_GINT64_FORMAT,hum,t);
g_string_append_printf(body,"\n");
if(debug)
g_message(body->str);
if(!testing) {
soup_message_set_request(message,"application/binary",SOUP_MEMORY_COPY,body->str,body->len);
guint session_status = soup_session_send_message(session,message);
if(session_status == 204) { /* message was received */
//g_print("received status %d\n",session_status);
g_string_erase(body,0,-1); /* clear the string */
}
else {
g_print("no connection to server");
}
/* otherwise, keep it and attempt to resend next time */
}
g_object_unref(message);
}
count ++;
/* reset the error count on successful read */
error_count = 0;
} else if(error_count > MAX_ERRORS) {
g_printerr("Too many errors to continue\n");
exit(-1);
} else {
error_count++;
}
if(testing && count>60)
break;
g_usleep(SLEEP_TIME*1000000);
}
if(session) {
g_string_free(uri,TRUE);
g_string_free(body,TRUE);
g_object_unref(session);
}
hid_close(handle);
hid_exit();
return 0;
}
/* TODO: use .part extentions and continue even when using GRITS_ONCE */
gchar *grits_http_fetch(GritsHttp *http, const gchar *uri, const char *local,
GritsCacheType mode, GritsChunkCallback callback, gpointer user_data)
{
g_debug("GritsHttp: fetch - %s mode=%d", local, mode);
gchar *path = _get_cache_path(http, local);
/* Unlink the file if we're refreshing it */
if (mode == GRITS_REFRESH)
g_remove(path);
/* Do the cache if necessasairy */
if (!(mode == GRITS_ONCE && g_file_test(path, G_FILE_TEST_EXISTS)) &&
mode != GRITS_LOCAL) {
g_debug("GritsHttp: fetch - Caching file %s", local);
/* Open the file for writting */
gchar *part = path;
if (!g_file_test(path, G_FILE_TEST_EXISTS))
part = g_strdup_printf("%s.part", path);
FILE *fp = fopen_p(part, "ab");
if (!fp) {
g_warning("GritsHttp: fetch - error opening %s", path);
return NULL;
}
fseek(fp, 0, SEEK_END); // "a" is broken on Windows, twice
/* Make temp data */
struct _CacheInfo info = {
.fp = fp,
.path = path,
.callback = callback,
.user_data = user_data,
};
/* Download the file */
SoupMessage *message = soup_message_new("GET", uri);
if (message == NULL)
g_error("message is null, cannot parse uri");
g_signal_connect(message, "got-chunk", G_CALLBACK(_chunk_cb), &info);
//if (ftell(fp) > 0)
soup_message_headers_set_range(message->request_headers, ftell(fp), -1);
if (mode == GRITS_REFRESH)
soup_message_headers_replace(message->request_headers,
"Cache-Control", "max-age=0");
soup_session_send_message(http->soup, message);
/* Close file */
fclose(fp);
if (path != part) {
if (SOUP_STATUS_IS_SUCCESSFUL(message->status_code))
g_rename(part, path);
g_free(part);
}
/* Finished */
guint status = message->status_code;
g_object_unref(message);
if (status == SOUP_STATUS_CANCELLED) {
return NULL;
} else if (status == SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE) {
/* Range unsatisfiable, file already complete */
} else if (!SOUP_STATUS_IS_SUCCESSFUL(status)) {
g_warning("GritsHttp: done_cb - error copying file, status=%d\n"
"\tsrc=%s\n"
"\tdst=%s",
status, uri, path);
return NULL;
}
}
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);
}
}
}
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);
}
/**
* gupnp_service_info_get_introspection:
* @info: A #GUPnPServiceInfo
* @error: return location for a #GError, or %NULL
*
* Note that introspection object is created from the information in service
* description document (SCPD) provided by the service so it can not be created
* if the service does not provide an SCPD.
*
* Warning: You should use gupnp_service_info_get_introspection_async()
* instead, this function re-enter the GMainloop before returning or might
* even block.
*
* Return value: (transfer full): A new #GUPnPServiceIntrospection for this
* service or %NULL. Unref after use.
*
* Deprecated: 0.20.15. Use gupnp_service_info_get_introspection_async() or
* gupnp_service_info_get_introspection_async_full() instead.
**/
G_DEPRECATED GUPnPServiceIntrospection *
gupnp_service_info_get_introspection (GUPnPServiceInfo *info,
GError **error)
{
GUPnPServiceIntrospection *introspection;
SoupSession *session;
SoupMessage *msg;
int status;
char *scpd_url;
xmlDoc *scpd;
g_return_val_if_fail (GUPNP_IS_SERVICE_INFO (info), NULL);
introspection = NULL;
scpd_url = gupnp_service_info_get_scpd_url (info);
msg = NULL;
if (scpd_url != NULL) {
msg = soup_message_new (SOUP_METHOD_GET, scpd_url);
g_free (scpd_url);
}
if (msg == NULL) {
g_set_error (error,
GUPNP_SERVER_ERROR,
GUPNP_SERVER_ERROR_INVALID_URL,
"No valid SCPD URL defined");
return NULL;
}
/* Send off the message */
session = gupnp_context_get_session (info->priv->context);
status = soup_session_send_message (session, msg);
if (!SOUP_STATUS_IS_SUCCESSFUL (status)) {
_gupnp_error_set_server_error (error, msg);
g_object_unref (msg);
return NULL;
}
scpd = xmlRecoverMemory (msg->response_body->data,
msg->response_body->length);
g_object_unref (msg);
if (scpd) {
introspection = gupnp_service_introspection_new (scpd);
xmlFreeDoc (scpd);
}
if (!introspection) {
g_set_error (error,
GUPNP_SERVER_ERROR,
GUPNP_SERVER_ERROR_INVALID_RESPONSE,
"Could not parse SCPD");
}
return introspection;
}
gboolean
gs_plugin_add_unvoted_reviews (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
guint status_code;
guint i;
g_autofree gchar *uri = NULL;
g_autoptr(GHashTable) hash = NULL;
g_autoptr(GPtrArray) reviews = NULL;
g_autoptr(SoupMessage) msg = NULL;
/* create the GET data *with* the machine hash so we can later
* review the application ourselves */
uri = g_strdup_printf ("%s/moderate/%s/%s",
priv->review_server,
priv->user_hash,
gs_plugin_get_locale (plugin));
msg = soup_message_new (SOUP_METHOD_GET, uri);
status_code = soup_session_send_message (gs_plugin_get_soup_session (plugin), msg);
if (status_code != SOUP_STATUS_OK) {
if (!gs_plugin_odrs_parse_success (msg->response_body->data,
msg->response_body->length,
error))
return FALSE;
/* not sure what to do here */
g_set_error_literal (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_DOWNLOAD_FAILED,
"status code invalid");
gs_utils_error_add_unique_id (error, priv->cached_origin);
return FALSE;
}
g_debug ("odrs returned: %s", msg->response_body->data);
reviews = gs_plugin_odrs_parse_reviews (plugin,
msg->response_body->data,
msg->response_body->length,
error);
if (reviews == NULL)
return FALSE;
/* look at all the reviews; faking application objects */
hash = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, (GDestroyNotify) g_object_unref);
for (i = 0; i < reviews->len; i++) {
GsApp *app;
AsReview *review;
const gchar *app_id;
/* same app? */
review = g_ptr_array_index (reviews, i);
app_id = as_review_get_metadata_item (review, "app_id");
app = g_hash_table_lookup (hash, app_id);
if (app == NULL) {
app = gs_plugin_create_app_dummy (app_id);
gs_app_list_add (list, app);
g_hash_table_insert (hash, g_strdup (app_id), app);
}
gs_app_add_review (app, review);
}
return TRUE;
}
static void
do_coding_test (void)
{
SoupSession *session;
SoupMessage *msg, *msgz, *msgj;
SoupURI *uri;
const char *coding;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
uri = soup_uri_new_with_base (base_uri, "/mbox");
debug_printf (1, "GET /mbox, plain\n");
msg = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msg);
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
debug_printf (1, " Unexpected status %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
coding = soup_message_headers_get_one (msg->response_headers, "Content-Encoding");
if (coding) {
debug_printf (1, " Unexpected Content-Encoding: %s\n",
coding);
errors++;
}
if (soup_message_get_flags (msg) & SOUP_MESSAGE_CONTENT_DECODED) {
debug_printf (1, " SOUP_MESSAGE_CONTENT_DECODED set!\n");
errors++;
}
debug_printf (1, "GET /mbox, Accept-Encoding: gzip\n");
soup_session_add_feature_by_type (session, SOUP_TYPE_CONTENT_DECODER);
msgz = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msgz);
if (!SOUP_STATUS_IS_SUCCESSFUL (msgz->status_code)) {
debug_printf (1, " Unexpected status %d %s\n",
msgz->status_code, msgz->reason_phrase);
errors++;
}
coding = soup_message_headers_get_one (msgz->response_headers, "Content-Encoding");
if (!coding || g_ascii_strcasecmp (coding, "gzip") != 0) {
debug_printf (1, " Unexpected Content-Encoding: %s\n",
coding ? coding : "(none)");
errors++;
}
if (!(soup_message_get_flags (msgz) & SOUP_MESSAGE_CONTENT_DECODED)) {
debug_printf (1, " SOUP_MESSAGE_CONTENT_DECODED not set!\n");
errors++;
}
if (msg->response_body->length != msgz->response_body->length) {
debug_printf (1, " Message length mismatch: %lu (plain) vs %lu (compressed)\n",
(gulong)msg->response_body->length,
(gulong)msgz->response_body->length);
errors++;
} else if (memcmp (msg->response_body->data,
msgz->response_body->data,
msg->response_body->length) != 0) {
debug_printf (1, " Message data mismatch (plain/compressed)\n");
errors++;
}
debug_printf (1, "GET /mbox, Accept-Encoding: gzip, plus trailing junk\n");
msgj = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgj->request_headers,
"X-Trailing-Junk", "junk!");
soup_session_send_message (session, msgj);
if (!SOUP_STATUS_IS_SUCCESSFUL (msgj->status_code)) {
debug_printf (1, " Unexpected status %d %s\n",
msgj->status_code, msgj->reason_phrase);
errors++;
}
coding = soup_message_headers_get_one (msgj->response_headers, "Content-Encoding");
if (!coding || g_ascii_strcasecmp (coding, "gzip") != 0) {
debug_printf (1, " Unexpected Content-Encoding: %s\n",
coding ? coding : "(none)");
errors++;
}
if (!(soup_message_get_flags (msgj) & SOUP_MESSAGE_CONTENT_DECODED)) {
debug_printf (1, " SOUP_MESSAGE_CONTENT_DECODED not set!\n");
errors++;
}
if (msg->response_body->length != msgj->response_body->length) {
debug_printf (1, " Message length mismatch: %lu (plain) vs %lu (compressed w/ junk)\n",
(gulong)msg->response_body->length,
(gulong)msgj->response_body->length);
errors++;
} else if (memcmp (msg->response_body->data,
msgj->response_body->data,
msg->response_body->length) != 0) {
debug_printf (1, " Message data mismatch (plain/compressed w/ junk)\n");
errors++;
}
g_object_unref (msg);
g_object_unref (msgz);
g_object_unref (msgj);
soup_uri_free (uri);
soup_test_session_abort_unref (session);
}
