void
network_init (void)
{
gchar *useragent;
SoupCookieJar *cookies;
gchar *filename;
SoupLogger *logger;
/* Set an appropriate user agent */
if (g_getenv ("LANG")) {
/* e.g. "Liferea/1.10.0 (Linux; de_DE; https://lzone.de/liferea/) AppleWebKit (KHTML, like Gecko)" */
useragent = g_strdup_printf ("Liferea/%s (%s; %s; %s) AppleWebKit (KHTML, like Gecko)", VERSION, OSNAME, g_getenv ("LANG"), HOMEPAGE);
} else {
/* e.g. "Liferea/1.10.0 (Linux; https://lzone.de/liferea/) AppleWebKit (KHTML, like Gecko)" */
useragent = g_strdup_printf ("Liferea/%s (%s; %s) AppleWebKit (KHTML, like Gecko)", VERSION, OSNAME, HOMEPAGE);
}
/* Cookies */
filename = common_create_config_filename ("cookies.txt");
cookies = soup_cookie_jar_text_new (filename, FALSE);
g_free (filename);
/* Initialize libsoup */
session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT, useragent,
SOUP_SESSION_TIMEOUT, 120,
SOUP_SESSION_IDLE_TIMEOUT, 30,
SOUP_SESSION_ADD_FEATURE, cookies,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
NULL);
session2 = soup_session_new_with_options (SOUP_SESSION_USER_AGENT, useragent,
SOUP_SESSION_TIMEOUT, 120,
SOUP_SESSION_IDLE_TIMEOUT, 30,
SOUP_SESSION_ADD_FEATURE, cookies,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
SOUP_SESSION_PROXY_URI, NULL,
SOUP_SESSION_PROXY_RESOLVER, NULL,
NULL);
/* Only 'session' gets proxy, 'session2' is for non-proxy requests */
network_set_soup_session_proxy (session, network_get_proxy_detect_mode(),
network_get_proxy_host (),
network_get_proxy_port (),
network_get_proxy_username (),
network_get_proxy_password ());
g_signal_connect (session, "authenticate", G_CALLBACK (network_authenticate), NULL);
/* Soup debugging */
if (debug_level & DEBUG_NET) {
logger = soup_logger_new (SOUP_LOGGER_LOG_HEADERS, -1);
soup_session_add_feature (session, SOUP_SESSION_FEATURE (logger));
}
g_free (useragent);
}
SoupSession *
builder_context_get_soup_session (BuilderContext *self)
{
if (self->soup_session == NULL)
{
const char *http_proxy;
self->soup_session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT, "xdg-app-builder ",
SOUP_SESSION_SSL_USE_SYSTEM_CA_FILE, TRUE,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
SOUP_SESSION_TIMEOUT, 60,
SOUP_SESSION_IDLE_TIMEOUT, 60,
NULL);
http_proxy = g_getenv ("http_proxy");
if (http_proxy)
{
g_autoptr(SoupURI) proxy_uri = soup_uri_new (http_proxy);
if (!proxy_uri)
g_warning ("Invalid proxy URI '%s'", http_proxy);
else
g_object_set (self->soup_session, SOUP_SESSION_PROXY_URI, proxy_uri, NULL);
}
}
return self->soup_session;
}
static void
impl_start (RBPodcastSearch *bsearch, const char *text, int max_results)
{
SoupURI *uri;
SoupMessage *message;
char *limit;
RBPodcastSearchITunes *search = RB_PODCAST_SEARCH_ITUNES (bsearch);
search->session = soup_session_new_with_options (SOUP_SESSION_ADD_FEATURE_BY_TYPE,
SOUP_TYPE_PROXY_RESOLVER_DEFAULT,
NULL);
uri = soup_uri_new (ITUNES_SEARCH_URI);
limit = g_strdup_printf ("%d", max_results);
soup_uri_set_query_from_fields (uri,
"term", text,
"media", "podcast",
"entity", "podcast",
"limit", limit,
"version", "2",
"output", "json",
NULL);
g_free (limit);
message = soup_message_new_from_uri (SOUP_METHOD_GET, uri);
soup_uri_free (uri);
soup_session_queue_message (search->session, message, (SoupSessionCallback) search_response_cb, search);
}
static GstElement *
kms_recorder_end_point_get_sink_fallback (KmsRecorderEndPoint * self)
{
GstElement *sink = NULL;
gchar *prot;
prot = gst_uri_get_protocol (KMS_URI_END_POINT (self)->uri);
if ((g_strcmp0 (prot, HTTP_PROTO) == 0)
|| (g_strcmp0 (prot, HTTPS_PROTO) == 0)) {
SoupSession *ss;
if (kms_is_valid_uri (KMS_URI_END_POINT (self)->uri)) {
/* We use souphttpclientsink */
sink = gst_element_factory_make ("souphttpclientsink", NULL);
g_object_set (sink, "blocksize", MEGA_BYTES (1), NULL);
ss = soup_session_new_with_options ("timeout", HTTP_TIMEOUT,
"ssl-strict", FALSE, NULL);
g_object_set (G_OBJECT (sink), "session", ss, NULL);
} else {
GST_ERROR ("URL not valid");
}
}
/* Add more if required */
return sink;
}
static void
init_test_case ()
{
loop = NULL;
urls = g_hash_table_new_full (g_str_hash, g_str_equal, g_free,
g_object_unref);
urls_registered = 0;
signal_count = 0;
counted = 0;
port = 0;
host = NULL;
setenv ("GST_PLUGIN_PATH", "./plugins", TRUE);
gst_init (NULL, NULL);
GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, GST_DEFAULT_NAME, 0,
GST_DEFAULT_NAME);
loop = g_main_loop_new (NULL, FALSE);
session = soup_session_new_with_options (SOUP_SESSION_MAX_CONNS,
MAX_REGISTERED_HTTP_END_POINTS, SOUP_SESSION_MAX_CONNS_PER_HOST,
MAX_REGISTERED_HTTP_END_POINTS, NULL);
/* Start Http End Point Server */
httpepserver = kms_http_ep_server_new (NULL);
}
/**
* gs_plugin_initialize:
*/
void
gs_plugin_initialize (GsPlugin *plugin)
{
g_autoptr(GSettings) settings = NULL;
plugin->priv = GS_PLUGIN_GET_PRIVATE (GsPluginPrivate);
plugin->priv->session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT, gs_user_agent (),
NULL);
/* this is opt-in, and turned off by default */
settings = g_settings_new ("org.gnome.desktop.privacy");
if (!g_settings_get_boolean (settings, "send-software-usage-stats")) {
gs_plugin_set_enabled (plugin, FALSE);
g_debug ("disabling '%s' as 'send-software-usage-stats' "
"disabled in GSettings", plugin->name);
return;
}
/* check that we are running on Fedora */
if (!gs_plugin_check_distro_id (plugin, "fedora")) {
gs_plugin_set_enabled (plugin, FALSE);
g_debug ("disabling '%s' as we're not Fedora", plugin->name);
return;
}
}
void
goa_http_client_check (GoaHttpClient *self,
const gchar *uri,
const gchar *username,
const gchar *password,
gboolean accept_ssl_errors,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
CheckData *data;
CheckAuthData *auth;
SoupLogger *logger;
g_return_if_fail (GOA_IS_HTTP_CLIENT (self));
g_return_if_fail (uri != NULL && uri[0] != '\0');
g_return_if_fail (username != NULL && username[0] != '\0');
g_return_if_fail (password != NULL && password[0] != '\0');
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
data = g_slice_new0 (CheckData);
data->res = g_simple_async_result_new (G_OBJECT (self), callback, user_data, goa_http_client_check);
data->session = soup_session_new_with_options (SOUP_SESSION_SSL_STRICT, FALSE,
NULL);
logger = soup_logger_new (SOUP_LOGGER_LOG_BODY, -1);
soup_logger_set_printer (logger, http_client_log_printer, NULL, NULL);
soup_session_add_feature (data->session, SOUP_SESSION_FEATURE (logger));
g_object_unref (logger);
data->accept_ssl_errors = accept_ssl_errors;
data->msg = soup_message_new (SOUP_METHOD_GET, uri);
soup_message_headers_append (data->msg->request_headers, "Connection", "close");
if (cancellable != NULL)
{
data->cancellable = g_object_ref (cancellable);
data->cancellable_id = g_cancellable_connect (data->cancellable,
G_CALLBACK (http_client_check_cancelled_cb),
data,
NULL);
g_simple_async_result_set_check_cancellable (data->res, data->cancellable);
}
auth = g_slice_new0 (CheckAuthData);
auth->username = g_strdup (username);
auth->password = g_strdup (password);
g_signal_connect_data (data->session,
"authenticate",
G_CALLBACK (http_client_authenticate),
auth,
http_client_check_auth_data_free,
0);
g_signal_connect (data->session, "request-started", G_CALLBACK (http_client_request_started), data);
soup_session_queue_message (data->session, data->msg, http_client_check_response_cb, data);
}
/**
* asb_plugin_initialize:
*/
void
asb_plugin_initialize (AsbPlugin *plugin)
{
plugin->priv = ASB_PLUGIN_GET_PRIVATE (AsbPluginPrivate);
plugin->priv->filenames = g_ptr_array_new_with_free_func (g_free);
g_mutex_init (&plugin->priv->filenames_mutex);
plugin->priv->session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT, "createrepo_as",
SOUP_SESSION_TIMEOUT, 5000,
NULL);
soup_session_add_feature_by_type (plugin->priv->session,
SOUP_TYPE_PROXY_RESOLVER_DEFAULT);
}
static void
gs_page_needs_user_action (GsPageHelper *helper, AsScreenshot *ss)
{
GtkWidget *content_area;
GtkWidget *dialog;
GtkWidget *ssimg;
g_autofree gchar *escaped = NULL;
GsPagePrivate *priv = gs_page_get_instance_private (helper->page);
dialog = gtk_message_dialog_new (gs_shell_get_window (priv->shell),
GTK_DIALOG_MODAL |
GTK_DIALOG_USE_HEADER_BAR,
GTK_MESSAGE_INFO,
GTK_BUTTONS_CANCEL,
/* TRANSLATORS: this is a prompt message, and
* '%s' is an application summary, e.g. 'GNOME Clocks' */
_("Prepare %s"),
gs_app_get_name (helper->app));
escaped = g_markup_escape_text (as_screenshot_get_caption (ss, NULL), -1);
gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog),
"%s", escaped);
/* this will be enabled when the device is in the right mode */
helper->button_install = gtk_dialog_add_button (GTK_DIALOG (dialog),
/* TRANSLATORS: update the fw */
_("Install"),
GTK_RESPONSE_OK);
helper->notify_quirk_id =
g_signal_connect (helper->app, "notify::quirk",
G_CALLBACK (gs_page_notify_quirk_cb),
helper);
gtk_widget_set_sensitive (helper->button_install, FALSE);
/* load screenshot */
helper->soup_session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT,
gs_user_agent (), NULL);
ssimg = gs_screenshot_image_new (helper->soup_session);
gs_screenshot_image_set_screenshot (GS_SCREENSHOT_IMAGE (ssimg), ss);
gs_screenshot_image_set_size (GS_SCREENSHOT_IMAGE (ssimg), 400, 225);
gs_screenshot_image_load_async (GS_SCREENSHOT_IMAGE (ssimg),
helper->cancellable);
gtk_widget_set_margin_start (ssimg, 24);
gtk_widget_set_margin_end (ssimg, 24);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_container_add (GTK_CONTAINER (content_area), ssimg);
gtk_container_child_set (GTK_CONTAINER (content_area), ssimg, "pack-type", GTK_PACK_END, NULL);
/* handle this async */
g_signal_connect (dialog, "response",
G_CALLBACK (gs_page_update_app_response_cb), helper);
gs_shell_modal_dialog_present (priv->shell, GTK_DIALOG (dialog));
}
static gchar *
gs_editor_css_download_resources (GsEditor *self, const gchar *css, GError **error)
{
g_autoptr(GsPlugin) plugin = NULL;
g_autoptr(SoupSession) soup_session = NULL;
/* make remote URIs local */
plugin = gs_plugin_new ();
gs_plugin_set_name (plugin, "editor");
soup_session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT, gs_user_agent (),
SOUP_SESSION_TIMEOUT, 10,
NULL);
gs_plugin_set_soup_session (plugin, soup_session);
return gs_plugin_download_rewrite_resource (plugin, NULL, css, NULL, error);
}
static void
request_token (RBAudioscrobblerAccount *account)
{
/* requests an authentication token
* first stage of the authentication process
*/
char *sig_arg;
char *sig;
char *url;
SoupMessage *msg;
/* create the soup session, if we haven't got one yet */
if (account->priv->soup_session == NULL) {
account->priv->soup_session =
soup_session_new_with_options (SOUP_SESSION_ADD_FEATURE_BY_TYPE,
SOUP_TYPE_PROXY_RESOLVER_DEFAULT,
NULL);
}
/* create the request */
sig_arg = g_strdup_printf ("api_key%smethodauth.getToken%s",
rb_audioscrobbler_service_get_api_key (account->priv->service),
rb_audioscrobbler_service_get_api_secret (account->priv->service));
sig = g_compute_checksum_for_string (G_CHECKSUM_MD5, sig_arg, -1);
url = g_strdup_printf ("%s?method=auth.getToken&api_key=%s&api_sig=%s&format=json",
rb_audioscrobbler_service_get_api_url (account->priv->service),
rb_audioscrobbler_service_get_api_key (account->priv->service),
sig);
msg = soup_message_new ("GET", url);
/* send the request */
rb_debug ("requesting authorisation token");
soup_session_queue_message (account->priv->soup_session,
msg,
got_token_cb,
account);
/* update status */
account->priv->login_status = RB_AUDIOSCROBBLER_ACCOUNT_LOGIN_STATUS_LOGGING_IN;
g_signal_emit (account, rb_audioscrobbler_account_signals[LOGIN_STATUS_CHANGED],
0, account->priv->login_status);
g_free (sig_arg);
g_free (sig);
g_free (url);
}
static gboolean
as_app_validate_setup_networking (AsAppValidateHelper *helper, GError **error)
{
helper->session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT,
"libappstream-glib",
SOUP_SESSION_TIMEOUT,
5000,
NULL);
if (helper->session == NULL) {
g_set_error_literal (error,
AS_APP_ERROR,
AS_APP_ERROR_FAILED,
"Failed to set up networking");
return FALSE;
}
soup_session_add_feature_by_type (helper->session,
SOUP_TYPE_PROXY_RESOLVER_DEFAULT);
return TRUE;
}
static void update_check(gint type)
{
SoupSession *soup;
SoupMessage *msg;
gchar *user_agent = g_strconcat("Updatechecker ", VERSION, " at Geany ",
GEANY_VERSION, NULL);
g_message("Checking for updates (querying URL \"%s\")", UPDATE_CHECK_URL);
soup = soup_session_new_with_options(
SOUP_SESSION_USER_AGENT, user_agent,
SOUP_SESSION_TIMEOUT, 10,
NULL);
g_free(user_agent);
msg = soup_message_new ("GET", UPDATE_CHECK_URL);
soup_session_queue_message (soup, msg, update_check_result_cb, GINT_TO_POINTER(type));
}
/**
* gs_plugin_setup_networking:
*/
static gboolean
gs_plugin_setup_networking (GsPlugin *plugin, GError **error)
{
/* already set up */
if (plugin->priv->session != NULL)
return TRUE;
/* set up a session */
plugin->priv->session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT,
"gnome-software",
NULL);
if (plugin->priv->session == NULL) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"%s: failed to setup networking",
plugin->name);
return FALSE;
}
return TRUE;
}
void
gs_plugin_initialize (GsPlugin *plugin)
{
GsPluginData *priv = gs_plugin_alloc_data (plugin, sizeof(GsPluginData));
g_autofree gchar *user_agent = NULL;
g_autoptr(SoupSession) soup_session = NULL;
priv->client = fwupd_client_new ();
/* use a custom user agent to provide the fwupd version */
user_agent = fwupd_build_user_agent (PACKAGE_NAME, PACKAGE_VERSION);
soup_session = soup_session_new_with_options (SOUP_SESSION_USER_AGENT, user_agent,
SOUP_SESSION_TIMEOUT, 10,
NULL);
soup_session_remove_feature_by_type (soup_session,
SOUP_TYPE_CONTENT_DECODER);
gs_plugin_set_soup_session (plugin, soup_session);
/* set name of MetaInfo file */
gs_plugin_set_appstream_id (plugin, "org.gnome.Software.Plugin.Fwupd");
}
SoupSession *
get_soup_session (void)
{
return soup_session_new_with_options (SOUP_SESSION_USER_AGENT, PACKAGE_NAME,
NULL);
}
/**
* 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
g_vfs_backend_http_class_init (GVfsBackendHttpClass *klass)
{
const char *debug;
SoupSessionFeature *cookie_jar;
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GVfsBackendClass *backend_class;
gobject_class->finalize = g_vfs_backend_http_finalize;
backend_class = G_VFS_BACKEND_CLASS (klass);
backend_class->try_mount = try_mount;
backend_class->try_open_for_read = try_open_for_read;
backend_class->try_read = try_read;
backend_class->try_seek_on_read = try_seek_on_read;
backend_class->try_close_read = try_close_read;
backend_class->try_query_info = try_query_info;
backend_class->try_query_info_on_read = try_query_info_on_read;
backend_class->try_query_fs_info = try_query_fs_info;
/* Initialize the SoupSession, common to all backend instances */
the_session = soup_session_new_with_options ("user-agent",
"gvfs/" VERSION,
NULL);
g_object_set (the_session, "ssl-strict", FALSE, NULL);
/* Cookie handling - stored temporarlly in memory, mostly useful for
* authentication in WebDAV. */
cookie_jar = g_object_new (SOUP_TYPE_COOKIE_JAR, NULL);
soup_session_add_feature (the_session, cookie_jar);
g_object_unref (cookie_jar);
/* Send Accept-Language header (see bug 166795) */
g_object_set (the_session, "accept-language-auto", TRUE, NULL);
/* Prevent connection timeouts during long operations like COPY. */
g_object_set (the_session, "timeout", 0, NULL);
/* Logging */
debug = g_getenv ("GVFS_HTTP_DEBUG");
if (debug)
{
SoupLogger *logger;
SoupLoggerLogLevel level;
if (g_ascii_strcasecmp (debug, "all") == 0 ||
g_ascii_strcasecmp (debug, "body") == 0)
level = SOUP_LOGGER_LOG_BODY;
else if (g_ascii_strcasecmp (debug, "header") == 0)
level = SOUP_LOGGER_LOG_HEADERS;
else
level = SOUP_LOGGER_LOG_MINIMAL;
logger = soup_logger_new (level, DEBUG_MAX_BODY_SIZE);
soup_session_add_feature (the_session, SOUP_SESSION_FEATURE (logger));
g_object_unref (logger);
}
}
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;
}
}
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;
}
}
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;
}
}
