static gboolean
test_sum (void)
{
GValueArray *ints;
int i, val, sum, result;
GValue retval;
gboolean ok;
debug_printf (1, "sum (array of int -> int): ");
ints = g_value_array_new (10);
for (i = sum = 0; i < 10; i++) {
val = rand () % 100;
debug_printf (2, "%s%d", i == 0 ? "[" : ", ", val);
soup_value_array_append (ints, G_TYPE_INT, val);
sum += val;
}
debug_printf (2, "] -> ");
ok = (do_xmlrpc ("sum", &retval,
G_TYPE_VALUE_ARRAY, ints,
G_TYPE_INVALID) &&
check_xmlrpc (&retval, G_TYPE_INT, &result));
g_value_array_free (ints);
if (!ok)
return FALSE;
debug_printf (2, "%d: ", result);
debug_printf (1, "%s\n", result == sum ? "OK!" : "WRONG!");
return result == sum;
}
static gboolean
test_echo (void)
{
GValueArray *originals, *echoes;
GValue retval;
int i;
gboolean php_bug = FALSE;
debug_printf (1, "echo (array of string -> array of string): ");
originals = g_value_array_new (N_ECHO_STRINGS);
for (i = 0; i < N_ECHO_STRINGS; i++) {
soup_value_array_append (originals, G_TYPE_STRING, echo_strings[i]);
debug_printf (2, "%s\"%s\"", i == 0 ? "[" : ", ", echo_strings[i]);
}
debug_printf (2, "] -> ");
if (!(do_xmlrpc ("echo", &retval,
G_TYPE_VALUE_ARRAY, originals,
G_TYPE_INVALID) &&
check_xmlrpc (&retval, G_TYPE_VALUE_ARRAY, &echoes))) {
g_value_array_free (originals);
return FALSE;
}
g_value_array_free (originals);
if (debug_level >= 2) {
for (i = 0; i < echoes->n_values; i++) {
debug_printf (2, "%s\"%s\"", i == 0 ? "[" : ", ",
g_value_get_string (&echoes->values[i]));
}
debug_printf (2, "] -> ");
}
if (echoes->n_values != N_ECHO_STRINGS) {
debug_printf (1, " WRONG! Wrong number of return strings");
g_value_array_free (echoes);
return FALSE;
}
for (i = 0; i < echoes->n_values; i++) {
if (strcmp (echo_strings[i], g_value_get_string (&echoes->values[i])) != 0) {
if (!server_test && strcmp (echo_strings_broken[i], g_value_get_string (&echoes->values[i])) == 0)
php_bug = TRUE;
else {
debug_printf (1, " WRONG! Mismatch at %d\n", i + 1);
g_value_array_free (echoes);
return FALSE;
}
}
}
if (php_bug)
debug_printf (1, "WRONG, but it's php's fault\n");
else
debug_printf (1, "OK!\n");
g_value_array_free (echoes);
return TRUE;
}
static gboolean
test_countBools (void)
{
GValueArray *bools;
int i, trues, falses;
GValue retval;
int ret_trues, ret_falses;
gboolean val, ok;
GHashTable *result;
debug_printf (1, "countBools (array of boolean -> struct of ints): ");
bools = g_value_array_new (10);
for (i = trues = falses = 0; i < 10; i++) {
val = rand () > (RAND_MAX / 2);
debug_printf (2, "%s%c", i == 0 ? "[" : ", ", val ? 'T' : 'F');
soup_value_array_append (bools, G_TYPE_BOOLEAN, val);
if (val)
trues++;
else
falses++;
}
debug_printf (2, "] -> ");
ok = (do_xmlrpc ("countBools", &retval,
G_TYPE_VALUE_ARRAY, bools,
G_TYPE_INVALID) &&
check_xmlrpc (&retval, G_TYPE_HASH_TABLE, &result));
g_value_array_free (bools);
if (!ok)
return FALSE;
if (!soup_value_hash_lookup (result, "true", G_TYPE_INT, &ret_trues)) {
debug_printf (1, "NO 'true' value in response\n");
return FALSE;
}
if (!soup_value_hash_lookup (result, "false", G_TYPE_INT, &ret_falses)) {
debug_printf (1, "NO 'false' value in response\n");
return FALSE;
}
g_hash_table_destroy (result);
debug_printf (2, "{ true: %d, false: %d } ", ret_trues, ret_falses);
ok = (trues == ret_trues) && (falses == ret_falses);
debug_printf (1, "%s\n", ok ? "OK!" : "WRONG!");
return ok;
}
static gboolean
test_md5sum (void)
{
GByteArray *data, *result;
int i;
GChecksum *checksum;
guchar digest[16];
gsize digest_len = sizeof (digest);
GValue retval;
gboolean ok;
debug_printf (1, "md5sum (base64 -> base64): ");
data = g_byte_array_new ();
g_byte_array_set_size (data, 256);
for (i = 0; i < data->len; i++)
data->data[i] = (char)(rand ());
checksum = g_checksum_new (G_CHECKSUM_MD5);
g_checksum_update (checksum, data->data, data->len);
g_checksum_get_digest (checksum, digest, &digest_len);
g_checksum_free (checksum);
ok = (do_xmlrpc ("md5sum", &retval,
SOUP_TYPE_BYTE_ARRAY, data,
G_TYPE_INVALID) &&
check_xmlrpc (&retval, SOUP_TYPE_BYTE_ARRAY, &result));
g_byte_array_free (data, TRUE);
if (!ok)
return FALSE;
if (result->len != digest_len) {
debug_printf (1, "result has WRONG length (%d)\n", result->len);
g_byte_array_free (result, TRUE);
return FALSE;
}
ok = (memcmp (digest, result->data, digest_len) == 0);
debug_printf (1, "%s\n", ok ? "OK!" : "WRONG!");
g_byte_array_free (result, TRUE);
return ok;
}
GList*
roadmap_engine_get_tickets (RoadmapEngine *self, gchar *username)
{
GValue retval;
GValueArray *tickets;
int i, j;
gboolean ok;
GList *r_tickets;
RoadmapEnginePrivate *priv;
priv = ROADMAP_ENGINE_GET_PRIVATE(self);
r_tickets = NULL;
ok = (do_xmlrpc (priv->session,
"ticket.query", &retval,
G_TYPE_STRING, g_strdup_printf ("owner=%s", username),
G_TYPE_INVALID) &&
check_xmlrpc (&retval, G_TYPE_VALUE_ARRAY, &tickets));
if (!ok) {
g_print ("No se han podido obtener los tickets");
return NULL;
}
for (i = 0; i < tickets->n_values; i++) {
GValueArray *ticket_info;
gint t_id;
GHashTable *attributes;
GList *keys;
RoadmapTicket *rd_ticket;
gchar *test;
t_id = g_value_get_int (g_value_array_get_nth (tickets, i));
ok = (do_xmlrpc (priv->session,
"ticket.get", &retval,
G_TYPE_STRING, g_strdup_printf ("%d", t_id),
G_TYPE_INVALID) &&
check_xmlrpc (&retval, G_TYPE_VALUE_ARRAY, &ticket_info));
if (!ok) {
g_print ("No se ha encontrado información del ticket: %d", t_id);
return NULL;
}
// String?, SoupDate*, SoupDate*, GHashTable*
// g_print ("ID: %d (%d)\n", t_id, ticket_info->n_values);
// The 3 element it's the hash table with the ticket description
attributes = (GHashTable *) g_value_get_boxed (g_value_array_get_nth (ticket_info, 3));
/*
keys = g_hash_table_get_keys (attributes);
while (keys) {
g_print (" Attr: %s\n", ((gchar*) keys->data));
keys = g_list_next (keys);
}
g_list_free (keys);
*/
/*
for (j = 0; j < ticket_info->n_values; j++) {
GValue *ti;
ti = g_value_array_get_nth (ticket_info, j);
g_print ("%s\n", g_strdup_value_contents (ti));
}
*/
rd_ticket = g_object_new (ROADMAP_TYPE_TICKET,
"id", t_id,
"attributes", attributes,
NULL);
r_tickets = g_list_append (r_tickets, rd_ticket);
}
return r_tickets;
}
static gboolean
test_dateChange (void)
{
GHashTable *structval;
SoupDate *date, *result;
char *timestamp;
GValue retval;
gboolean ok;
debug_printf (1, "dateChange (date, struct of ints -> time): ");
date = soup_date_new (1970 + (rand () % 50),
1 + rand () % 12,
1 + rand () % 28,
rand () % 24,
rand () % 60,
rand () % 60);
if (debug_level >= 2) {
timestamp = soup_date_to_string (date, SOUP_DATE_ISO8601_XMLRPC);
debug_printf (2, "date: %s, {", timestamp);
g_free (timestamp);
}
structval = soup_value_hash_new ();
if (rand () % 3) {
date->year = 1970 + (rand () % 50);
debug_printf (2, "tm_year: %d, ", date->year - 1900);
soup_value_hash_insert (structval, "tm_year",
G_TYPE_INT, date->year - 1900);
}
if (rand () % 3) {
date->month = 1 + rand () % 12;
debug_printf (2, "tm_mon: %d, ", date->month - 1);
soup_value_hash_insert (structval, "tm_mon",
G_TYPE_INT, date->month - 1);
}
if (rand () % 3) {
date->day = 1 + rand () % 28;
debug_printf (2, "tm_mday: %d, ", date->day);
soup_value_hash_insert (structval, "tm_mday",
G_TYPE_INT, date->day);
}
if (rand () % 3) {
date->hour = rand () % 24;
debug_printf (2, "tm_hour: %d, ", date->hour);
soup_value_hash_insert (structval, "tm_hour",
G_TYPE_INT, date->hour);
}
if (rand () % 3) {
date->minute = rand () % 60;
debug_printf (2, "tm_min: %d, ", date->minute);
soup_value_hash_insert (structval, "tm_min",
G_TYPE_INT, date->minute);
}
if (rand () % 3) {
date->second = rand () % 60;
debug_printf (2, "tm_sec: %d, ", date->second);
soup_value_hash_insert (structval, "tm_sec",
G_TYPE_INT, date->second);
}
debug_printf (2, "} -> ");
ok = (do_xmlrpc ("dateChange", &retval,
SOUP_TYPE_DATE, date,
G_TYPE_HASH_TABLE, structval,
G_TYPE_INVALID) &&
check_xmlrpc (&retval, SOUP_TYPE_DATE, &result));
g_hash_table_destroy (structval);
if (!ok) {
soup_date_free (date);
return FALSE;
}
if (debug_level >= 2) {
timestamp = soup_date_to_string (result, SOUP_DATE_ISO8601_XMLRPC);
debug_printf (2, "%s: ", timestamp);
g_free (timestamp);
}
ok = ((date->year == result->year) &&
(date->month == result->month) &&
(date->day == result->day) &&
(date->hour == result->hour) &&
(date->minute == result->minute) &&
(date->second == result->second));
soup_date_free (date);
soup_date_free (result);
debug_printf (1, "%s\n", ok ? "OK!" : "WRONG!");
return ok;
}
static gboolean
zimagez_upload_job (ScreenshooterJob *job, GArray *param_values, GError **error)
{
const gchar *encoded_data;
const gchar *image_path;
const gchar *last_user;
const gchar *proxy_uri;
/* For translators: the first wildcard is the date, the second one the time,
* e.g. "Taken on 12/31/99, at 23:13:48". */
gchar *comment = screenshooter_get_datetime (_("Taken on %x, at %X"));
gchar *data = NULL;
gchar *encoded_password = NULL;
gchar *file_name = NULL;
gchar *login_response = NULL;
gchar *online_file_name = NULL;
gchar *password = g_strdup ("");
gchar *title;
gchar *user;
gsize data_length;
gboolean response = FALSE;
const gchar *serverurl = "http://www.zimagez.com/apiXml.php";
const gchar *method_login = "******";
const gchar *method_logout = "apiXml.xmlrpcLogout";
const gchar *method_upload = "apiXml.xmlrpcUpload";
SoupSession *session;
SoupURI *soup_proxy_uri;
GError *tmp_error = NULL;
GtkTreeIter iter;
GtkListStore *liststore;
GValue response_value;
g_return_val_if_fail (SCREENSHOOTER_IS_JOB (job), FALSE);
g_return_val_if_fail (param_values != NULL, FALSE);
g_return_val_if_fail (param_values->len == 3, FALSE);
g_return_val_if_fail (G_VALUE_HOLDS_STRING (&g_array_index (param_values, GValue, 0)), FALSE);
g_return_val_if_fail (G_VALUE_HOLDS_STRING (&g_array_index (param_values, GValue, 1)), FALSE);
g_return_val_if_fail (G_VALUE_HOLDS_STRING (&g_array_index (param_values, GValue, 2)), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
g_object_set_data (G_OBJECT (job), "jobtype", "zimagez");
if (exo_job_set_error_if_cancelled (EXO_JOB (job), error))
{
g_free (comment);
g_free (password);
return FALSE;
}
/* Get the last user */
last_user = g_value_get_string (&g_array_index (param_values, GValue, 1));
user = g_strdup (last_user);
if (user == NULL)
user = g_strdup ("");
if (!g_utf8_validate (user, -1, NULL))
{
g_free (user);
user = g_strdup ("");
}
g_object_set_data_full (G_OBJECT (job), "user",
g_strdup (user), (GDestroyNotify) g_free);
/* Get the default title */
title = g_strdup (g_value_get_string (&g_array_index (param_values, GValue, 2)));
if (title == NULL)
title = g_strdup ("");
if (!g_utf8_validate (title, -1, NULL))
{
g_free (title);
title = g_strdup ("");
}
/* Get the path of the image that is to be uploaded */
image_path = g_value_get_string (&g_array_index (param_values, GValue, 0));
/* Start the user soup session */
exo_job_info_message (EXO_JOB (job), _("Initialize the connection..."));
session = soup_session_sync_new ();
/* Set the proxy URI if any */
proxy_uri = g_getenv ("http_proxy");
if (proxy_uri != NULL)
{
soup_proxy_uri = soup_uri_new (proxy_uri);
g_object_set (session, "proxy-uri", soup_proxy_uri, NULL);
soup_uri_free (soup_proxy_uri);
}
TRACE ("Get the information liststore ready.");
liststore = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING);
TRACE ("Append the user");
gtk_list_store_append (liststore, &iter);
gtk_list_store_set (liststore, &iter,
0, USER,
1, user,
-1);
TRACE ("Append the password");
gtk_list_store_append (liststore, &iter);
gtk_list_store_set (liststore, &iter,
0, PASSWORD,
1, password,
-1);
TRACE ("Append the title");
gtk_list_store_append (liststore, &iter);
gtk_list_store_set (liststore, &iter,
0, TITLE,
1, title,
-1);
TRACE ("Append the comment");
gtk_list_store_append (liststore, &iter);
gtk_list_store_set (liststore, &iter,
0, COMMENT,
1, comment,
-1);
TRACE ("Ask the user to fill the information items.");
screenshooter_job_ask_info (job, liststore,
_("Please fill the following fields with your "
"<a href=\"http://www.zimagez.com\">ZimageZ</a> \n"
"user name, passsword and details about the screenshot."));
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (liststore), &iter);
do
{
gint field_index;
gchar *field_value = NULL;
gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter,
0, &field_index,
1, &field_value,
-1);
switch (field_index)
{
case USER:
user = g_strdup (field_value);
break;
case PASSWORD:
password = g_strdup (field_value);
break;
case TITLE:
title = g_strdup (field_value);
break;
case COMMENT:
comment = g_strdup (field_value);
break;
default:
break;
}
g_free (field_value);
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL (liststore), &iter));
while (!response)
{
if (exo_job_set_error_if_cancelled (EXO_JOB (job), error))
{
soup_session_abort (session);
g_object_unref (session);
g_free (user);
g_free (password);
g_free (title);
g_free (comment);
if (encoded_password != NULL)
g_free (encoded_password);
TRACE ("The upload job was cancelled.");
return FALSE;
}
exo_job_info_message (EXO_JOB (job), _("Check the user information..."));
/* Test if one of the information fields is empty */
if (has_empty_field (liststore))
{
TRACE ("One of the fields was empty, let the user file it.");
screenshooter_job_ask_info (job, liststore,
_("<span weight=\"bold\" foreground=\"darkred\" "
"stretch=\"semiexpanded\">You must fill all the "
"fields.</span>"));
continue;
}
encoded_password = g_utf8_strreverse (rot13 (password), -1);
TRACE ("User: %s", user);
TRACE ("Encoded password: %s", encoded_password);
/* Start the user session */
TRACE ("Call the login method");
exo_job_info_message (EXO_JOB (job), _("Login on ZimageZ..."));
if (!do_xmlrpc (session, serverurl, method_login,
&tmp_error, &response_value,
G_TYPE_STRING, user,
G_TYPE_STRING, encoded_password,
G_TYPE_INVALID))
{
g_propagate_error (error, tmp_error);
soup_session_abort (session);
g_object_unref (session);
g_free (password);
g_free (title);
g_free (comment);
g_free (encoded_password);
return FALSE;
}
TRACE ("Read the login response");
/* If the response is a boolean, there was an error */
if (G_VALUE_HOLDS_BOOLEAN (&response_value))
{
response = g_value_get_boolean (&response_value);
}
/* Else we read the string response to get the session ID */
else if (G_VALUE_HOLDS_STRING (&response_value))
{
TRACE ("Read the session ID");
login_response = g_strdup (g_value_get_string (&response_value));
response = TRUE;
}
/* We received an unexpected reply */
else
{
GError *tmp_err =
g_error_new (SOUP_XMLRPC_FAULT,
SOUP_XMLRPC_FAULT_PARSE_ERROR_NOT_WELL_FORMED,
"%s", _("An unexpected reply from ZimageZ was received."
" The upload of the screenshot failed."));
soup_session_abort (session);
g_object_unref (session);
g_free (user);
g_free (password);
g_free (title);
g_free (comment);
g_free (encoded_password);
g_propagate_error (error, tmp_err);
return FALSE;
}
g_value_unset (&response_value);
if (!response)
{
/* Login failed, erase the password and ask for the correct on to the
user */
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (liststore), &iter);
do
{
gint field_index;
gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter, 0, &field_index, -1);
if (field_index == PASSWORD)
{
gtk_list_store_set (liststore, &iter, 1, g_strdup (""), -1);
break;
}
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL (liststore), &iter));
screenshooter_job_ask_info (job, liststore,
_("<span weight=\"bold\" foreground=\"darkred\" "
"stretch=\"semiexpanded\">The user and the "
"password you entered do not match. "
"Please retry.</span>"));
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (liststore), &iter);
do
{
gint field_index;
gchar *field_value = NULL;
gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter,
0, &field_index,
1, &field_value,
-1);
switch (field_index)
{
case USER:
user = g_strdup (field_value);
break;
case PASSWORD:
password = g_strdup (field_value);
break;
case TITLE:
title = g_strdup (field_value);
break;
case COMMENT:
comment = g_strdup (field_value);
break;
default:
break;
}
g_free (field_value);
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL (liststore), &iter));
}
}
g_object_set_data_full (G_OBJECT (job), "user",
g_strdup (user), (GDestroyNotify) g_free);
g_free (user);
g_free (password);
g_free (encoded_password);
/* Get the contents of the image file and encode it to base64 */
g_file_get_contents (image_path, &data, &data_length, NULL);
encoded_data = g_base64_encode ((guchar*)data, data_length);
g_free (data);
/* Get the basename of the image path */
file_name = g_path_get_basename (image_path);
exo_job_info_message (EXO_JOB (job), _("Upload the screenshot..."));
TRACE ("Call the upload method");
do_xmlrpc (session, serverurl, method_upload,
&tmp_error, &response_value,
G_TYPE_STRING, encoded_data,
G_TYPE_STRING, file_name,
G_TYPE_STRING, title,
G_TYPE_STRING, comment,
G_TYPE_STRING, login_response,
G_TYPE_INVALID);
g_free (title);
g_free (comment);
g_free (file_name);
if (tmp_error)
{
soup_session_abort (session);
g_object_unref (session);
g_propagate_error (error, tmp_error);
return FALSE;
}
/* If the response is a boolean, there was an error */
if (G_VALUE_HOLDS_BOOLEAN (&response_value))
{
if (!g_value_get_boolean (&response_value))
{
GError *tmp_err =
g_error_new (G_IO_ERROR, G_IO_ERROR_FAILED,
_("An error occurred while uploading the screenshot."));
soup_session_abort (session);
g_object_unref (session);
g_propagate_error (error, tmp_err);
return FALSE;
}
}
/* Else we get the file name */
else if (G_VALUE_HOLDS_STRING (&response_value))
{
TRACE ("The screenshot has been uploaded, get the file name.");
online_file_name = g_strdup (g_value_get_string (&response_value));
}
/* We received un unexpected reply */
else
{
GError *tmp_err =
g_error_new (SOUP_XMLRPC_FAULT,
SOUP_XMLRPC_FAULT_PARSE_ERROR_NOT_WELL_FORMED,
"%s", _("An unexpected reply from ZimageZ was received."
" The upload of the screenshot failed."));
soup_session_abort (session);
g_object_unref (session);
g_propagate_error (error, tmp_err);
return FALSE;
}
g_value_unset (&response_value);
/* End the user session */
exo_job_info_message (EXO_JOB (job), _("Close the session on ZimageZ..."));
TRACE ("Closing the user session");
do_xmlrpc (session, serverurl, method_logout,
&tmp_error, &response_value,
G_TYPE_STRING, login_response,
G_TYPE_INVALID);
if (G_IS_VALUE (&response_value))
g_value_unset (&response_value);
/* Clean the soup session */
soup_session_abort (session);
g_object_unref (session);
g_free (login_response);
screenshooter_job_image_uploaded (job, online_file_name);
if (tmp_error)
{
g_propagate_error (error, tmp_error);
return FALSE;
}
return TRUE;
}
