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; }