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
do_request_to_session (SoupRequester *requester, const char *uri,
const char *comment, gboolean expect_timeout)
{
SoupRequest *req;
SoupMessage *msg;
GInputStream *stream;
GError *error = NULL;
gboolean finished = FALSE;
debug_printf (1, " req %s\n", comment);
req = soup_requester_request (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
g_signal_connect (msg, "finished",
G_CALLBACK (message_finished), &finished);
stream = soup_test_request_send (req, NULL, &error);
if (expect_timeout && !error) {
debug_printf (1, " FAILED: request did not time out\n");
errors++;
} else if (expect_timeout && !g_error_matches (error, G_IO_ERROR,
G_IO_ERROR_TIMED_OUT)) {
debug_printf (1, " FAILED: wrong error: %s\n",
error->message);
errors++;
} else if (!expect_timeout && error) {
debug_printf (1, " FAILED: expected success but got error: %s\n",
error->message);
errors++;
}
g_clear_error (&error);
if (stream) {
soup_test_request_close_stream (req, stream, NULL, &error);
if (error) {
debug_printf (1, " ERROR closing string: %s",
error->message);
errors++;
}
g_object_unref (stream);
}
if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code) &&
!soup_message_is_keepalive (msg)) {
debug_printf (1, " ERROR: message is not keepalive!\n");
errors++;
}
if (!finished) {
debug_printf (1, " ERROR: 'finished' was not emitted\n");
errors++;
}
g_signal_handlers_disconnect_by_func (msg,
G_CALLBACK (message_finished),
&finished);
g_object_unref (msg);
g_object_unref (req);
}
static guint
parse_request_headers (SoupMessage *msg, char *headers, guint headers_len,
SoupEncoding *encoding, gpointer sock)
{
SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
char *req_method, *req_path, *url;
SoupHTTPVersion version;
const char *req_host;
guint status;
SoupURI *uri;
status = soup_headers_parse_request (headers, headers_len,
msg->request_headers,
&req_method,
&req_path,
&version);
if (!SOUP_STATUS_IS_SUCCESSFUL (status))
return status;
g_object_set (G_OBJECT (msg),
SOUP_MESSAGE_METHOD, req_method,
SOUP_MESSAGE_HTTP_VERSION, version,
NULL);
g_free (req_method);
/* Handle request body encoding */
*encoding = soup_message_headers_get_encoding (msg->request_headers);
if (*encoding == SOUP_ENCODING_UNRECOGNIZED) {
if (soup_message_headers_get_list (msg->request_headers, "Transfer-Encoding"))
return SOUP_STATUS_NOT_IMPLEMENTED;
else
return SOUP_STATUS_BAD_REQUEST;
}
/* Generate correct context for request */
req_host = soup_message_headers_get_one (msg->request_headers, "Host");
if (req_host && strchr (req_host, '/')) {
g_free (req_path);
return SOUP_STATUS_BAD_REQUEST;
}
if (!strcmp (req_path, "*") && req_host) {
/* Eg, "OPTIONS * HTTP/1.1" */
url = g_strdup_printf ("%s://%s",
soup_socket_is_ssl (sock) ? "https" : "http",
req_host);
uri = soup_uri_new (url);
if (uri)
soup_uri_set_path (uri, "*");
g_free (url);
} else if (*req_path != '/') {
/* Must be an absolute URI */
uri = soup_uri_new (req_path);
} else if (req_host) {
url = g_strdup_printf ("%s://%s%s",
soup_socket_is_ssl (sock) ? "https" : "http",
req_host, req_path);
uri = soup_uri_new (url);
g_free (url);
} else if (priv->http_version == SOUP_HTTP_1_0) {
/* No Host header, no AbsoluteUri */
SoupAddress *addr = soup_socket_get_local_address (sock);
const char *host = soup_address_get_physical (addr);
url = g_strdup_printf ("%s://%s:%d%s",
soup_socket_is_ssl (sock) ? "https" : "http",
host, soup_address_get_port (addr),
req_path);
uri = soup_uri_new (url);
g_free (url);
} else
uri = NULL;
g_free (req_path);
if (!uri)
return SOUP_STATUS_BAD_REQUEST;
soup_message_set_uri (msg, uri);
soup_uri_free (uri);
return SOUP_STATUS_OK;
}
int main(int argc, char *argv[]) {
GError *error = NULL;
gchar *server = NULL;
gchar *form_data;
gchar *form_seconds;
SoupURI *watchdog_uri;
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(NULL);
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);
g_option_context_free(context);
if (!parse_succeeded) {
goto cleanup;
}
seconds = parse_time_string (argv[1], &error);
if (error) {
goto cleanup;
}
prefix = getenv("HARNESS_PREFIX") ? getenv("HARNESS_PREFIX") : "";
server_recipe_key = g_strdup_printf ("%sRECIPE_URL", prefix);
server_recipe = getenv(server_recipe_key);
if (!server && server_recipe) {
server = g_strdup_printf ("%s/watchdog", server_recipe);
}
if (!server) {
g_printerr("Try %s --help\n", argv[0]);
goto cleanup;
}
watchdog_uri = soup_uri_new (server);
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);
}
soup_uri_free (watchdog_uri);
cleanup:
if (error) {
g_printerr("%s [%s, %d]\n", error->message,
g_quark_to_string(error->domain), error->code);
return error->code;
} else {
return EXIT_SUCCESS;
}
}
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;
}
//
// Callback that's invoked once the main JSON file is downloaded.
//
// If the SoupMessage returns a successful response then this callback will
// trigger the processing of the users asynchronously. It will also register a
// a callback that will process all new buddies that are added while Pidgin is
// running.
//
static void
budicons_got_json_response (SoupSession *session, SoupMessage *message, gpointer data) {
BudiconsPlugin *plugin = (BudiconsPlugin *) data;
{
char *url = soup_uri_to_string(soup_message_get_uri(message), FALSE);
g_print("Downloaded URL %s: %d\n", url, message->status_code);
g_free(url);
}
if (! SOUP_STATUS_IS_SUCCESSFUL (message->status_code)) {
g_print("SOUP Message was not successful (%d)\n", message->status_code);
return;
}
const char *buffer = message->response_body->data;
gsize length = (gsize) message->response_body->length;
const char *mime = soup_message_headers_get_content_type(message->response_headers, NULL);
if (! (EQ(mime, "application/json") || EQ(mime, "text/plain"))) {
g_print("Got the wrong mime type (%s) for the JSON file\n", mime);
return;
}
// Parse the JSON file
GError *error = NULL;
plugin->users = budicons_json_parse_users(buffer, length, &error);
if (plugin->users == NULL) {
char *url = soup_uri_to_string(soup_message_get_uri(message), FALSE);
g_print("Failed to parse URL %s: %s\n", url, error->message);
g_free(url);
g_error_free(error);
return;
}
// Register a callback for every new buddy added
purple_signal_connect(
purple_blist_get_handle(),
"buddy-added",
plugin->purple,
PURPLE_CALLBACK(budicons_buddy_added_callback),
plugin
);
// Collect the buddies to process
PurpleBuddyList *list = purple_get_blist();
if (list == NULL) {return;}
plugin->buddies = NULL;
for (PurpleBlistNode *group = list->root; group; group = group->next) {
if (! PURPLE_BLIST_NODE_IS_GROUP(group)) {continue;}
for (PurpleBlistNode *contact = group->child; contact; contact = contact->next) {
if (! PURPLE_BLIST_NODE_IS_CONTACT(contact)) {continue;}
for (PurpleBlistNode *blist = contact->child; blist; blist = blist->next) {
if (! PURPLE_BLIST_NODE_IS_BUDDY(blist)) {continue;}
PurpleBuddy *buddy = (PurpleBuddy *) blist;
plugin->buddies = g_slist_prepend(plugin->buddies, buddy);
}
}
}
// Start a few workers that will process the buddies registered so far
plugin->buddy_iter = plugin->buddies;
guint workers = budicons_prefs_get_workers();
for (guint i = 0; i < workers; ++i) {
// No more buddies to process
if (plugin->buddy_iter == NULL) {break;}
// Create a new worker
BudiconsWorker *worker = g_new0(BudiconsWorker, 1);
worker->plugin = plugin;
worker->id = i;
g_print("[%d] Started a new worker\n", worker->id);
budicons_worker_iter(worker);
}
}
JsonNode *
json_node_from_call (RestProxyCall *call, GError** error)
{
JsonNode *root;
JsonObject *object = NULL;
char *error_message = NULL;
JsonParser *parser = NULL;
g_return_val_if_fail (call, NULL);
if (!SOUP_STATUS_IS_SUCCESSFUL (rest_proxy_call_get_status_code (call))) {
g_set_error (error, SW_SERVICE_ERROR,
SW_SERVICE_ERROR_REMOTE_ERROR,
"Error from Facebook: %s (%d)",
rest_proxy_call_get_status_message (call),
rest_proxy_call_get_status_code (call));
g_object_unref (parser);
return NULL;
}
parser = json_parser_new ();
if (!json_parser_load_from_data (parser,
rest_proxy_call_get_payload (call),
rest_proxy_call_get_payload_length (call),
NULL)) {
g_set_error (error, SW_SERVICE_ERROR,
SW_SERVICE_ERROR_REMOTE_ERROR,
"Malformed JSON from Facebook: %s",
rest_proxy_call_get_payload (call));
g_object_unref (parser);
return NULL;
}
root = json_parser_get_root (parser);
if (root)
root = json_node_copy (root);
g_object_unref (parser);
if (root == NULL) {
g_set_error (error, SW_SERVICE_ERROR,
SW_SERVICE_ERROR_REMOTE_ERROR,
"Error from Facebook: %s",
rest_proxy_call_get_payload (call));
return NULL;
}
/*
* Is it an error? If so, it'll be a hash containing
* the key "error", which maps to a hash containing
* a key "message".
*/
if (json_node_get_node_type (root) == JSON_NODE_OBJECT) {
object = json_node_get_object (root);
}
if (object && json_object_has_member (object, "error")) {
JsonNode *inner = json_object_get_member (object,
"error");
JsonObject *inner_object = NULL;
if (json_node_get_node_type (inner) == JSON_NODE_OBJECT)
inner_object = json_node_get_object (inner);
if (inner_object && json_object_has_member (inner_object, "message"))
error_message = get_child_node_value (inner, "message");
}
if (error_message) {
g_set_error (error, SW_SERVICE_ERROR,
SW_SERVICE_ERROR_REMOTE_ERROR,
"Error response from Facebook: %s", error_message);
g_free (error_message);
json_node_free (root);
return NULL;
} else {
return root;
}
}
static gboolean
cal_backend_http_load (ECalBackendHttp *backend,
const gchar *uri,
gchar **out_certificate_pem,
GTlsCertificateFlags *out_certificate_errors,
GCancellable *cancellable,
GError **error)
{
ECalBackendHttpPrivate *priv = backend->priv;
ETimezoneCache *timezone_cache;
SoupMessage *soup_message;
SoupSession *soup_session;
icalcomponent *icalcomp, *subcomp;
icalcomponent_kind kind;
const gchar *newuri;
SoupURI *uri_parsed;
GHashTable *old_cache;
GSList *comps_in_cache;
ESource *source;
guint status_code;
gulong cancel_id = 0;
struct {
SoupSession *soup_session;
SoupMessage *soup_message;
} cancel_data;
timezone_cache = E_TIMEZONE_CACHE (backend);
soup_session = backend->priv->soup_session;
soup_message = cal_backend_http_new_message (backend, uri);
if (soup_message == NULL) {
g_set_error (
error, SOUP_HTTP_ERROR,
SOUP_STATUS_MALFORMED,
_("Malformed URI: %s"), uri);
return FALSE;
}
if (G_IS_CANCELLABLE (cancellable)) {
cancel_data.soup_session = soup_session;
cancel_data.soup_message = soup_message;
cancel_id = g_cancellable_connect (
cancellable,
G_CALLBACK (cal_backend_http_cancelled),
&cancel_data, (GDestroyNotify) NULL);
}
source = e_backend_get_source (E_BACKEND (backend));
e_soup_ssl_trust_connect (soup_message, source);
e_source_set_connection_status (source, E_SOURCE_CONNECTION_STATUS_CONNECTING);
status_code = soup_session_send_message (soup_session, soup_message);
if (G_IS_CANCELLABLE (cancellable))
g_cancellable_disconnect (cancellable, cancel_id);
if (status_code == SOUP_STATUS_NOT_MODIFIED) {
e_source_set_connection_status (source, E_SOURCE_CONNECTION_STATUS_CONNECTED);
/* attempts with ETag can result in 304 status code */
g_object_unref (soup_message);
priv->opened = TRUE;
return TRUE;
}
/* Handle redirection ourselves */
if (SOUP_STATUS_IS_REDIRECTION (status_code)) {
gboolean success;
newuri = soup_message_headers_get_list (
soup_message->response_headers, "Location");
d (g_message ("Redirected from %s to %s\n", async_context->uri, newuri));
if (newuri != NULL) {
gchar *redirected_uri;
if (newuri[0]=='/') {
g_warning ("Hey! Relative URI returned! Working around...\n");
uri_parsed = soup_uri_new (uri);
soup_uri_set_path (uri_parsed, newuri);
soup_uri_set_query (uri_parsed, NULL);
/* g_free (newuri); */
newuri = soup_uri_to_string (uri_parsed, FALSE);
g_message ("Translated URI: %s\n", newuri);
soup_uri_free (uri_parsed);
}
redirected_uri =
webcal_to_http_method (newuri, FALSE);
success = cal_backend_http_load (
backend, redirected_uri, out_certificate_pem, out_certificate_errors, cancellable, error);
g_free (redirected_uri);
} else {
g_set_error (
error, SOUP_HTTP_ERROR,
SOUP_STATUS_BAD_REQUEST,
_("Redirected to Invalid URI"));
success = FALSE;
}
if (success) {
e_source_set_connection_status (source, E_SOURCE_CONNECTION_STATUS_CONNECTED);
} else {
e_source_set_connection_status (source, E_SOURCE_CONNECTION_STATUS_DISCONNECTED);
}
g_object_unref (soup_message);
return success;
}
/* check status code */
if (!SOUP_STATUS_IS_SUCCESSFUL (status_code)) {
/* because evolution knows only G_IO_ERROR_CANCELLED */
if (status_code == SOUP_STATUS_CANCELLED)
g_set_error (
error, G_IO_ERROR, G_IO_ERROR_CANCELLED,
"%s", soup_message->reason_phrase);
else
g_set_error (
error, SOUP_HTTP_ERROR, status_code,
"%s", soup_message->reason_phrase);
if (status_code == SOUP_STATUS_SSL_FAILED) {
e_source_set_connection_status (source, E_SOURCE_CONNECTION_STATUS_SSL_FAILED);
cal_backend_http_extract_ssl_failed_data (soup_message, out_certificate_pem, out_certificate_errors);
} else {
e_source_set_connection_status (source, E_SOURCE_CONNECTION_STATUS_DISCONNECTED);
}
g_object_unref (soup_message);
empty_cache (backend);
return FALSE;
}
e_source_set_connection_status (source, E_SOURCE_CONNECTION_STATUS_CONNECTED);
if (priv->store) {
const gchar *etag;
etag = soup_message_headers_get_one (
soup_message->response_headers, "ETag");
if (etag != NULL && *etag == '\0')
etag = NULL;
e_cal_backend_store_put_key_value (priv->store, "ETag", etag);
}
/* get the calendar from the response */
icalcomp = icalparser_parse_string (soup_message->response_body->data);
if (!icalcomp) {
g_set_error (
error, SOUP_HTTP_ERROR,
SOUP_STATUS_MALFORMED,
_("Bad file format."));
g_object_unref (soup_message);
empty_cache (backend);
return FALSE;
}
if (icalcomponent_isa (icalcomp) != ICAL_VCALENDAR_COMPONENT) {
g_set_error (
error, SOUP_HTTP_ERROR,
SOUP_STATUS_MALFORMED,
_("Not a calendar."));
icalcomponent_free (icalcomp);
g_object_unref (soup_message);
empty_cache (backend);
return FALSE;
}
g_object_unref (soup_message);
soup_message = NULL;
/* Update cache */
old_cache = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
comps_in_cache = e_cal_backend_store_get_components (priv->store);
while (comps_in_cache != NULL) {
const gchar *uid;
ECalComponent *comp = comps_in_cache->data;
e_cal_component_get_uid (comp, &uid);
g_hash_table_insert (old_cache, g_strdup (uid), e_cal_component_get_as_string (comp));
comps_in_cache = g_slist_remove (comps_in_cache, comps_in_cache->data);
g_object_unref (comp);
}
kind = e_cal_backend_get_kind (E_CAL_BACKEND (backend));
subcomp = icalcomponent_get_first_component (icalcomp, ICAL_ANY_COMPONENT);
e_cal_backend_store_freeze_changes (priv->store);
while (subcomp) {
ECalComponent *comp;
icalcomponent_kind subcomp_kind;
icalproperty *prop = NULL;
subcomp_kind = icalcomponent_isa (subcomp);
prop = icalcomponent_get_first_property (subcomp, ICAL_UID_PROPERTY);
if (!prop && subcomp_kind == kind) {
gchar *new_uid = e_cal_component_gen_uid ();
icalcomponent_set_uid (subcomp, new_uid);
g_free (new_uid);
}
if (subcomp_kind == kind) {
comp = e_cal_component_new ();
if (e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (subcomp))) {
const gchar *uid;
gpointer orig_key, orig_value;
e_cal_component_get_uid (comp, &uid);
if (!put_component_to_store (backend, comp)) {
g_hash_table_remove (old_cache, uid);
} else if (g_hash_table_lookup_extended (old_cache, uid, &orig_key, &orig_value)) {
ECalComponent *orig_comp = e_cal_component_new_from_string (orig_value);
e_cal_backend_notify_component_modified (E_CAL_BACKEND (backend), orig_comp, comp);
g_hash_table_remove (old_cache, uid);
if (orig_comp)
g_object_unref (orig_comp);
} else {
e_cal_backend_notify_component_created (E_CAL_BACKEND (backend), comp);
}
}
g_object_unref (comp);
} else if (subcomp_kind == ICAL_VTIMEZONE_COMPONENT) {
icaltimezone *zone;
zone = icaltimezone_new ();
icaltimezone_set_component (zone, icalcomponent_new_clone (subcomp));
e_timezone_cache_add_timezone (timezone_cache, zone);
icaltimezone_free (zone, 1);
}
subcomp = icalcomponent_get_next_component (icalcomp, ICAL_ANY_COMPONENT);
}
e_cal_backend_store_thaw_changes (priv->store);
/* notify the removals */
g_hash_table_foreach_remove (old_cache, (GHRFunc) notify_and_remove_from_cache, backend);
g_hash_table_destroy (old_cache);
/* free memory */
icalcomponent_free (icalcomp);
priv->opened = TRUE;
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);
}
static void
do_request_test (SoupSession *session, SoupURI *base_uri, int test)
{
SoupURI *uri = base_uri;
PutTestData ptd;
SoupMessage *msg;
const char *client_md5, *server_md5;
GChecksum *check;
int i, length;
gboolean streaming = FALSE;
switch (test) {
case 0:
debug_printf (1, "PUT\n");
break;
case 1:
debug_printf (1, "PUT w/ streaming\n");
streaming = TRUE;
break;
case 2:
debug_printf (1, "PUT w/ streaming and restart\n");
streaming = TRUE;
uri = soup_uri_copy (base_uri);
soup_uri_set_path (uri, "/redirect");
break;
}
ptd.session = session;
make_put_chunk (&ptd.chunks[0], "one\r\n");
make_put_chunk (&ptd.chunks[1], "two\r\n");
make_put_chunk (&ptd.chunks[2], "three\r\n");
ptd.next = ptd.nwrote = ptd.nfreed = 0;
ptd.streaming = 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 (streaming) {
g_signal_connect (msg, "wrote_chunk",
G_CALLBACK (write_next_chunk_streaming_hack), &ptd);
g_signal_connect (msg, "restarted",
G_CALLBACK (restarted_streaming_hack), &ptd);
} else {
g_signal_connect (msg, "wrote_chunk",
G_CALLBACK (write_next_chunk), &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);
}
void on_xiphos_web_listener_ready_callback (SoupSession *session, SoupMessage *msg, gpointer user_data)
{
if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
// Get the response body.
string body (msg->response_body->data);
body = trim (body);
// Log it.
//printf ("%s\n", body.c_str());
//fflush (stdout);
ParseLine parseline (body);
if (parseline.lines.size() >= 3) {
// It retrieves the message ID and uses this to ask for a higher ID next poll.
// Update GUI.
last_message_id = parseline.lines[0];
gtk_label_set_text (GTK_LABEL (label_id), last_message_id.c_str());
string command = parseline.lines[1];
gtk_label_set_text (GTK_LABEL (label_command), command.c_str());
string body = parseline.lines[2];
gtk_label_set_text (GTK_LABEL (label_body), body.c_str());
// Handle "quit" command.
if (command == "quit") {
gtk_main_quit ();
}
// Handle "focus" command.
if (command == "focus") {
Parse parse (body, false, ".");
if (parse.words.size() == 3) {
string book;
switch (convert_to_int (parse.words[0])) {
case 1: book = "Gen"; break;
case 2: book = "Exod"; break;
case 3: book = "Lev"; break;
case 4: book = "Num"; break;
case 5: book = "Deut"; break;
case 6: book = "Josh"; break;
case 7: book = "Judg"; break;
case 8: book = "Ruth"; break;
case 9: book = "1Sam"; break;
case 10: book = "2Sam"; break;
case 11: book = "1Kgs"; break;
case 12: book = "2Kgs"; break;
case 13: book = "1Chr"; break;
case 14: book = "2Chr"; break;
case 15: book = "Ezra"; break;
case 16: book = "Neh"; break;
case 17: book = "Esth"; break;
case 18: book = "Job"; break;
case 19: book = "Ps"; break;
case 20: book = "Prov"; break;
case 21: book = "Eccl"; break;
case 22: book = "Song"; break;
case 23: book = "Isa"; break;
case 24: book = "Jer"; break;
case 25: book = "Lam"; break;
case 26: book = "Ezek"; break;
case 27: book = "Dan"; break;
case 28: book = "Hos"; break;
case 29: book = "Joel"; break;
case 30: book = "Amos"; break;
case 31: book = "Obad"; break;
case 32: book = "Jonah"; break;
case 33: book = "Mic"; break;
case 34: book = "Nah"; break;
case 35: book = "Hab"; break;
case 36: book = "Zeph"; break;
case 37: book = "Hag"; break;
case 38: book = "Zech"; break;
case 39: book = "Mal"; break;
case 40: book = "Matt"; break;
case 41: book = "Mark"; break;
case 42: book = "Luke"; break;
case 43: book = "John"; break;
case 44: book = "Acts"; break;
case 45: book = "Rom"; break;
case 46: book = "1Cor"; break;
case 47: book = "2Cor"; break;
case 48: book = "Gal"; break;
case 49: book = "Eph"; break;
case 50: book = "Phil"; break;
case 51: book = "Col"; break;
case 52: book = "1Thess"; break;
case 53: book = "2Thess"; break;
case 54: book = "1Tim"; break;
case 55: book = "2Tim"; break;
case 56: book = "Titus"; break;
case 57: book = "Phlm"; break;
case 58: book = "Heb"; break;
case 59: book = "Jas"; break;
case 60: book = "1Pet"; break;
case 61: book = "2Pet"; break;
case 62: book = "1John"; break;
case 63: book = "2John"; break;
case 64: book = "3John"; break;
case 65: book = "Jude"; break;
case 66: book = "Rev"; break;
}
if (!book.empty()) {
string reference = "sword://" + book + "." + parse.words[1] + "." + parse.words[2];
send_to_xiphos (xiphos_dbus_object (), xiphos_dbus_interface (), "setCurrentReference", reference);
reference.insert (0, "setCurrentReference ");
gtk_label_set_text (GTK_LABEL (label_xiphos), reference.c_str());
}
}
}
}
} else {
// If the message was cancelled, do not start it again, just quit.
if (msg->status_code == 1) {
return;
}
// If it needs to quit, just quit.
if (quit) return;
// Handle error.
printf ("Xiphos web listener failure, code: %d, reason: %s\n", msg->status_code, msg->reason_phrase);
fflush (stdout);
for (unsigned int i = 0; i < 10; i++) {
while (gtk_events_pending()) gtk_main_iteration();
g_usleep (100000);
}
}
g_usleep (100000);
start_xiphos_web_listener ();
}
static gboolean
do_xmlrpc (SoupSession *session, const gchar *uri, const gchar *method,
GError **error, GValue *retval, ...)
{
SoupMessage *msg;
va_list args;
GArray *params = g_array_sized_new(FALSE, FALSE, sizeof(GValue), 1);
GError *err = NULL;
char *body;
GType type;
GValue val;
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
va_start (args, retval);
//copy soup_value_array_from_args() in here and change datatypes respectivly
while ((type = va_arg (args, GType)) != G_TYPE_INVALID)
{
SOUP_VALUE_SETV (&val, type, args);
g_array_append_val (params, val);
}
va_end (args);
body = soup_xmlrpc_build_method_call (method, (GValue*)params->data,
params->len);
g_array_unref (params);
if (!body)
{
err = g_error_new (SOUP_XMLRPC_FAULT,
SOUP_XMLRPC_FAULT_APPLICATION_ERROR,
_("An error occurred when creating the XMLRPC"
" request."));
g_propagate_error (error, err);
return FALSE;
}
msg = soup_message_new ("POST", uri);
soup_message_set_request (msg, "text/xml", SOUP_MEMORY_TAKE,
body, strlen (body));
soup_session_send_message (session, msg);
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code))
{
TRACE ("Error during the XMLRPC exchange: %d %s\n",
msg->status_code, msg->reason_phrase);
err = g_error_new (SOUP_XMLRPC_FAULT,
SOUP_XMLRPC_FAULT_TRANSPORT_ERROR,
_("An error occurred when transferring the data"
" to ZimageZ."));
g_propagate_error (error, err);
g_object_unref (msg);
return FALSE;
}
if (!soup_xmlrpc_parse_method_response (msg->response_body->data,
msg->response_body->length,
retval, &err))
{
if (err)
{
TRACE ("Fault when parsing the response: %d %s\n",
err->code, err->message);
g_propagate_error (error, err);
}
else
{
TRACE ("Unable to parse the response, and no error...");
err = g_error_new (SOUP_XMLRPC_FAULT,
SOUP_XMLRPC_FAULT_APPLICATION_ERROR,
_("An error occurred when parsing the response"
" from ZimageZ."));
g_propagate_error (error, err);
}
g_object_unref (msg);
return FALSE;
}
g_object_unref (msg);
return TRUE;
}
/*
* Description URL downloaded.
*/
static void
got_description_url (SoupSession *session,
SoupMessage *msg,
GetDescriptionURLData *data)
{
GUPnPXMLDoc *doc;
if (msg->status_code == SOUP_STATUS_CANCELLED)
return;
/* Now, make sure again this document is not already cached. If it is,
* we re-use the cached one. */
doc = g_hash_table_lookup (data->control_point->priv->doc_cache,
data->description_url);
if (doc) {
/* Doc was cached */
description_loaded (data->control_point,
doc,
data->udn,
data->service_type,
data->description_url);
get_description_url_data_free (data);
return;
}
/* Not cached */
if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
xmlDoc *xml_doc;
/* Parse response */
xml_doc = xmlRecoverMemory (msg->response_body->data,
msg->response_body->length);
if (xml_doc) {
doc = gupnp_xml_doc_new (xml_doc);
description_loaded (data->control_point,
doc,
data->udn,
data->service_type,
data->description_url);
/* Insert into document cache */
g_hash_table_insert
(data->control_point->priv->doc_cache,
g_strdup (data->description_url),
doc);
/* Make sure the document is removed from the cache
* once finalized. */
g_object_weak_ref (G_OBJECT (doc),
doc_finalized,
data->control_point);
/* If no proxy was created, make sure doc is freed. */
g_object_unref (doc);
} else
g_warning ("Failed to parse %s", data->description_url);
} else
g_warning ("Failed to GET %s: %s",
data->description_url,
msg->reason_phrase);
get_description_url_data_free (data);
}
gboolean upload_results(AppData *app_data) {
GError *error = NULL;
SoupURI *result_uri = NULL;
guint ret = 0;
SoupSession *session;
SoupMessage *server_msg;
SoupRequest *request;
gchar *form_data;
GHashTable *data_table = g_hash_table_new (NULL, NULL);
result_uri = soup_uri_new (app_data->server);
if (result_uri == NULL) {
g_set_error (&error, RESTRAINT_ERROR,
RESTRAINT_PARSE_ERROR_BAD_SYNTAX,
"Malformed server url: %s", app_data->server);
goto cleanup;
}
session = soup_session_new_with_options("timeout", 3600, NULL);
g_hash_table_insert (data_table, "path", app_data->test_name);
g_hash_table_insert (data_table, "result", app_data->test_result);
// if AVC_ERROR=+no_avc_check then disable the selinux check plugin
// This is for legacy rhts tests.. please use --disable-plugin
gchar *avc_error = getenv("AVC_ERROR");
if (g_strcmp0 (avc_error, "+no_avc_check") == 0) {
g_ptr_array_add (app_data->disable_plugin, g_strdup ("10_avc_check"));
}
if (app_data->disable_plugin->pdata) {
g_ptr_array_add (app_data->disable_plugin, NULL);
g_hash_table_insert (data_table, "disable_plugin",
g_strjoinv (" ", (gchar **)app_data->disable_plugin->pdata));
}
if (app_data->no_plugins)
g_hash_table_insert (data_table, "no_plugins", &app_data->no_plugins);
if (app_data->score)
g_hash_table_insert (data_table, "score", app_data->score);
if (app_data->result_msg)
g_hash_table_insert (data_table, "message", app_data->result_msg);
request = (SoupRequest *)soup_session_request_http_uri (session, "POST", result_uri, &error);
server_msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (request));
g_object_unref(request);
form_data = soup_form_encode_hash (data_table);
soup_message_set_request (server_msg, "application/x-www-form-urlencoded",
SOUP_MEMORY_TAKE, form_data, strlen (form_data));
g_print ("** %s %s Score:%s\n", app_data->test_name, app_data->test_result,
app_data->score != NULL ? app_data->score : "N/A");
ret = soup_session_send_message (session, server_msg);
if (SOUP_STATUS_IS_SUCCESSFUL (ret)) {
gchar *location = g_strdup_printf ("%s/logs/",
soup_message_headers_get_one (server_msg->response_headers, "Location"));
soup_uri_free (result_uri);
result_uri = soup_uri_new (location);
g_free (location);
if (app_data->outputfile != NULL &&
g_file_test (app_data->outputfile, G_FILE_TEST_EXISTS))
{
g_print ("Uploading %s ", app_data->filename);
if (upload_file (session, app_data->outputfile, app_data->filename, result_uri, &error)) {
g_print ("done\n");
} else {
g_print ("failed\n");
}
}
} else {
g_warning ("Failed to submit result, status: %d Message: %s\n", ret, server_msg->reason_phrase);
}
g_object_unref(server_msg);
soup_session_abort(session);
g_object_unref(session);
cleanup:
g_hash_table_destroy(data_table);
if (result_uri != NULL) {
soup_uri_free (result_uri);
}
if (error) {
g_printerr("%s [%s, %d]\n", error->message,
g_quark_to_string(error->domain), error->code);
g_clear_error(&error);
return FALSE;
} else {
return TRUE;
}
}
