char *
ephy_sync_utils_make_audience (const char *url)
{
SoupURI *uri;
const char *scheme;
const char *host;
char *audience;
char *port;
g_return_val_if_fail (url != NULL, NULL);
uri = soup_uri_new (url);
scheme = soup_uri_get_scheme (uri);
host = soup_uri_get_host (uri);
port = g_strdup_printf (":%u", soup_uri_get_port (uri));
/* Even if the url doesn't contain the port, soup_uri_get_port() will return
* the default port for the url's scheme so we need to check if the port was
* really present in the url.
*/
if (g_strstr_len (url, -1, port) != NULL)
audience = g_strdup_printf ("%s://%s%s", scheme, host, port);
else
audience = g_strdup_printf ("%s://%s", scheme, host);
g_free (port);
soup_uri_free (uri);
return audience;
}
static GBytes *
download_file (SoupURI *uri)
{
g_autoptr(GBytes) contents = NULL;
if (soup_uri_get_scheme (uri) == SOUP_URI_SCHEME_FILE)
{
g_autoptr(GFile) file = g_file_new_for_path (soup_uri_get_path (uri));
eos_updater_read_file_to_bytes (file, NULL, &contents, NULL);
}
else
{
g_autoptr(SoupSession) soup = soup_session_new ();
g_autoptr(SoupMessage) msg = soup_message_new_from_uri ("GET", uri);
guint status = soup_session_send_message (soup, msg);
if (SOUP_STATUS_IS_SUCCESSFUL (status))
g_object_get (msg,
SOUP_MESSAGE_RESPONSE_BODY_DATA, &contents,
NULL);
}
return g_steal_pointer (&contents);
}
static void
set_property (GObject *object, guint property_id,
const GValue *value, GParamSpec *pspec)
{
NMConnectivity *self = NM_CONNECTIVITY (object);
NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self);
const char *uri, *response;
guint interval;
gboolean changed;
switch (property_id) {
case PROP_URI:
uri = g_value_get_string (value);
if (uri && !*uri)
uri = NULL;
changed = g_strcmp0 (uri, priv->uri) != 0;
#if WITH_CONCHECK
if (uri) {
SoupURI *soup_uri = soup_uri_new (uri);
if (!soup_uri || !SOUP_URI_VALID_FOR_HTTP (soup_uri)) {
_LOGE ("invalid uri '%s' for connectivity check.", uri);
uri = NULL;
}
if (uri && soup_uri && changed &&
soup_uri_get_scheme(soup_uri) == SOUP_URI_SCHEME_HTTPS)
_LOGW ("use of HTTPS for connectivity checking is not reliable and is discouraged (URI: %s)", uri);
if (soup_uri)
soup_uri_free (soup_uri);
}
#endif
if (changed) {
g_free (priv->uri);
priv->uri = g_strdup (uri);
_reschedule_periodic_checks (self, TRUE);
}
break;
case PROP_INTERVAL:
interval = g_value_get_uint (value);
if (priv->interval != interval) {
priv->interval = interval;
_reschedule_periodic_checks (self, TRUE);
}
break;
case PROP_RESPONSE:
response = g_value_get_string (value);
if (g_strcmp0 (response, priv->response) != 0) {
/* a response %NULL means, NM_CONFIG_DEFAULT_CONNECTIVITY_RESPONSE. Any other response
* (including "") is accepted. */
g_free (priv->response);
priv->response = g_strdup (response);
_reschedule_periodic_checks (self, TRUE);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void _request_access_token(GSignondOauthPlugin *self,
GSignondSessionData *session_data,
GError** error
)
{
//GSignondPlugin* plugin = GSIGNOND_PLUGIN(self);
const gchar* endpoint_url_s = gsignond_dictionary_get_string(session_data,
"TokenEndpoint");
if (endpoint_url_s == NULL) {
*error = g_error_new(GSIGNOND_ERROR,
GSIGNOND_ERROR_MISSING_DATA,
"Client did not supply TokenEndpoint");
return;
}
SoupURI* endpoint_uri = soup_uri_new(endpoint_url_s);
if (endpoint_uri == NULL) {
*error = g_error_new(GSIGNOND_ERROR,
GSIGNOND_ERROR_MISSING_DATA,
"Client did not supply a valid TokenEndpoint");
return;
}
if (g_strcmp0(soup_uri_get_scheme(endpoint_uri), "https") != 0) {
soup_uri_free(endpoint_uri);
*error = g_error_new(GSIGNOND_ERROR,
GSIGNOND_ERROR_MISSING_DATA,
"TokenEndpoint must use https");
return;
}
gsignond_oauth_plugin_check_host(soup_uri_get_host(endpoint_uri),
gsignond_session_data_get_allowed_realms (session_data), error);
if (*error != NULL) {
soup_uri_free(endpoint_uri);
return;
}
gchar* authorization_header = _make_authorization_header(
session_data,
endpoint_uri,
error
);
if (*error == NULL) {
SoupMessage *msg = soup_message_new_from_uri ("POST", endpoint_uri);
soup_message_headers_append(msg->request_headers, "Authorization",
authorization_header);
g_free(authorization_header);
soup_session_queue_message (self->soup_session,
msg,
_access_token_callback,
self);
}
soup_uri_free(endpoint_uri);
}
static char *
get_server_uri (SoupServer *server,
const char *filename)
{
GSList *uris;
SoupURI *uri;
char *ret;
uris = soup_server_get_uris (server);
g_assert (uris);
uri = uris->data;
ret = g_strdup_printf ("%s://%s:%d/%s",
soup_uri_get_scheme (uri),
soup_uri_get_host (uri),
soup_uri_get_port (uri),
filename);
g_slist_free_full (uris, (GDestroyNotify) soup_uri_free);
return ret;
}
/* Add an URI to completion model for autocompletion */
static void _interface_tweaks_add_uri_to_completion_model(InterfaceTweaks *self, const gchar *inURI)
{
g_return_if_fail(IS_INTERFACE_TWEAKS(self));
g_return_if_fail(inURI!=NULL);
InterfaceTweaksPrivate *priv=self->priv;
SoupURI *soupURI;
gchar *modelURI;
GtkTreeIter iter;
/* Create SoupURI from URI to retrieve host and/or scheme for completion */
soupURI=soup_uri_new(inURI);
g_return_if_fail(soupURI!=NULL);
/* Add URI with scheme and host to completion */
modelURI=g_strdup_printf("%s://%s", soup_uri_get_scheme(soupURI), soup_uri_get_host(soupURI));
if(modelURI && g_hash_table_lookup(priv->completionModelDomains, modelURI)==NULL)
{
gtk_list_store_append(priv->completionModel, &iter);
gtk_list_store_set(priv->completionModel, &iter, 0, modelURI, -1);
g_hash_table_insert(priv->completionModelDomains, modelURI, GINT_TO_POINTER(TRUE));
}
if(modelURI) g_free(modelURI);
/* Add URI without scheme - only host - to completion */
modelURI=g_strdup(soup_uri_get_host(soupURI));
if(modelURI && g_hash_table_lookup(priv->completionModelDomains, modelURI)==NULL)
{
gtk_list_store_append(priv->completionModel, &iter);
gtk_list_store_set(priv->completionModel, &iter, 0, modelURI, -1);
g_hash_table_insert(priv->completionModelDomains, modelURI, GINT_TO_POINTER(TRUE));
}
if(modelURI) g_free(modelURI);
/* Release allocated resources */
soup_uri_free(soupURI);
}
/**
* soup_uri_set_scheme:
* @uri: a #SoupURI
* @scheme: the URI scheme
*
* Sets @uri's scheme to @scheme. This will also set @uri's port to
* the default port for @scheme, if known.
**/
void
soup_uri_set_scheme (SoupURI *uri, const char *scheme)
{
uri->scheme = soup_uri_get_scheme (scheme, strlen (scheme));
uri->port = soup_scheme_default_port (uri->scheme);
}
/**
* soup_uri_new_with_base:
* @base: a base URI
* @uri_string: the URI
*
* Parses @uri_string relative to @base.
*
* Return value: a parsed #SoupURI.
**/
SoupURI *
soup_uri_new_with_base (SoupURI *base, const char *uri_string)
{
SoupURI *uri;
const char *end, *hash, *colon, *at, *path, *question;
const char *p, *hostend;
gboolean remove_dot_segments = TRUE;
uri = g_slice_new0 (SoupURI);
/* See RFC 3986 for details. IF YOU CHANGE ANYTHING IN THIS
* FUNCTION, RUN tests/uri-parsing AFTERWARDS.
*/
/* Find fragment. */
end = hash = strchr (uri_string, '#');
if (hash && hash[1]) {
uri->fragment = uri_normalized_copy (hash + 1, strlen (hash + 1),
NULL, FALSE);
if (!uri->fragment) {
soup_uri_free (uri);
return NULL;
}
} else
end = uri_string + strlen (uri_string);
/* Find scheme: initial [a-z+.-]* substring until ":" */
p = uri_string;
while (p < end && (g_ascii_isalnum (*p) ||
*p == '.' || *p == '+' || *p == '-'))
p++;
if (p > uri_string && *p == ':') {
uri->scheme = soup_uri_get_scheme (uri_string, p - uri_string);
if (!uri->scheme) {
soup_uri_free (uri);
return NULL;
}
uri_string = p + 1;
}
if (!*uri_string && !base)
return uri;
/* Check for authority */
if (strncmp (uri_string, "//", 2) == 0) {
uri_string += 2;
path = uri_string + strcspn (uri_string, "/?#");
at = strchr (uri_string, '@');
if (at && at < path) {
colon = strchr (uri_string, ':');
if (colon && colon < at) {
uri->password = uri_decoded_copy (colon + 1,
at - colon - 1);
if (!uri->password) {
soup_uri_free (uri);
return NULL;
}
} else {
uri->password = NULL;
colon = at;
}
uri->user = uri_decoded_copy (uri_string,
colon - uri_string);
if (!uri->user) {
soup_uri_free (uri);
return NULL;
}
uri_string = at + 1;
} else
uri->user = uri->password = NULL;
/* Find host and port. */
if (*uri_string == '[') {
uri_string++;
hostend = strchr (uri_string, ']');
if (!hostend || hostend > path) {
soup_uri_free (uri);
return NULL;
}
if (*(hostend + 1) == ':')
colon = hostend + 1;
else
colon = NULL;
} else {
colon = memchr (uri_string, ':', path - uri_string);
hostend = colon ? colon : path;
}
uri->host = uri_decoded_copy (uri_string, hostend - uri_string);
if (!uri->host) {
soup_uri_free (uri);
return NULL;
}
if (colon && colon != path - 1) {
char *portend;
uri->port = strtoul (colon + 1, &portend, 10);
if (portend != (char *)path) {
soup_uri_free (uri);
return NULL;
}
}
uri_string = path;
}
/* Find query */
question = memchr (uri_string, '?', end - uri_string);
if (question) {
if (question[1]) {
uri->query = uri_normalized_copy (question + 1,
end - (question + 1),
NULL, TRUE);
if (!uri->query) {
soup_uri_free (uri);
return NULL;
}
}
end = question;
}
if (end != uri_string) {
uri->path = uri_normalized_copy (uri_string, end - uri_string,
NULL, TRUE);
if (!uri->path) {
soup_uri_free (uri);
return NULL;
}
}
/* Apply base URI. Again, this is spelled out in RFC 3986. */
if (base && !uri->scheme && uri->host)
uri->scheme = base->scheme;
else if (base && !uri->scheme) {
uri->scheme = base->scheme;
uri->user = g_strdup (base->user);
uri->password = g_strdup (base->password);
uri->host = g_strdup (base->host);
uri->port = base->port;
if (!uri->path) {
uri->path = g_strdup (base->path);
if (!uri->query)
uri->query = g_strdup (base->query);
remove_dot_segments = FALSE;
} else if (*uri->path != '/') {
char *newpath, *last;
last = strrchr (base->path, '/');
if (last) {
newpath = g_strdup_printf ("%.*s/%s",
(int)(last - base->path),
base->path,
uri->path);
} else
newpath = g_strdup_printf ("/%s", uri->path);
g_free (uri->path);
uri->path = newpath;
}
}
if (remove_dot_segments && uri->path && *uri->path) {
char *p = uri->path, *q;
/* Remove "./" where "." is a complete segment. */
for (p = uri->path + 1; *p; ) {
if (*(p - 1) == '/' &&
*p == '.' && *(p + 1) == '/')
memmove (p, p + 2, strlen (p + 2) + 1);
else
p++;
}
/* Remove "." at end. */
if (p > uri->path + 2 &&
*(p - 1) == '.' && *(p - 2) == '/')
*(p - 1) = '\0';
/* Remove "<segment>/../" where <segment> != ".." */
for (p = uri->path + 1; *p; ) {
if (!strncmp (p, "../", 3)) {
p += 3;
continue;
}
q = strchr (p + 1, '/');
if (!q)
break;
if (strncmp (q, "/../", 4) != 0) {
p = q + 1;
continue;
}
memmove (p, q + 4, strlen (q + 4) + 1);
p = uri->path + 1;
}
/* Remove "<segment>/.." at end where <segment> != ".." */
q = strrchr (uri->path, '/');
if (q && !strcmp (q, "/..")) {
p = q - 1;
while (p > uri->path && *p != '/')
p--;
if (strncmp (p, "/../", 4) != 0)
*(p + 1) = 0;
}
/* Remove extraneous initial "/.."s */
while (!strncmp (uri->path, "/../", 4))
memmove (uri->path, uri->path + 3, strlen (uri->path) - 2);
if (!strcmp (uri->path, "/.."))
uri->path[1] = '\0';
}
/* HTTP-specific stuff */
if (uri->scheme == SOUP_URI_SCHEME_HTTP ||
uri->scheme == SOUP_URI_SCHEME_HTTPS) {
if (!SOUP_URI_VALID_FOR_HTTP (uri)) {
soup_uri_free (uri);
return NULL;
}
if (!uri->path)
uri->path = g_strdup ("/");
}
if (!uri->port)
uri->port = soup_scheme_default_port (uri->scheme);
if (!uri->path)
uri->path = g_strdup ("");
return uri;
}
static void
do_soup_uri_null_tests (void)
{
SoupURI *uri, *uri2;
char *uri_string;
debug_printf (1, "\nsoup_uri_new (NULL)\n");
uri = soup_uri_new (NULL);
if (SOUP_URI_IS_VALID (uri) || SOUP_URI_VALID_FOR_HTTP (uri)) {
debug_printf (1, " ERROR: soup_uri_new(NULL) returns valid URI?\n");
errors++;
}
/* This implicitly also verifies that none of these methods g_warn */
if (soup_uri_get_scheme (uri) ||
soup_uri_get_user (uri) ||
soup_uri_get_password (uri) ||
soup_uri_get_host (uri) ||
soup_uri_get_port (uri) ||
soup_uri_get_path (uri) ||
soup_uri_get_query (uri) ||
soup_uri_get_fragment (uri)) {
debug_printf (1, " ERROR: soup_uri_new(NULL) returns non-empty URI?\n");
errors++;
}
expect_warning = TRUE;
uri2 = soup_uri_new_with_base (uri, "/path");
if (uri2 || expect_warning) {
debug_printf (1, " ERROR: soup_uri_new_with_base didn't fail on NULL URI?\n");
errors++;
expect_warning = FALSE;
}
expect_warning = TRUE;
uri_string = soup_uri_to_string (uri, FALSE);
if (expect_warning) {
debug_printf (1, " ERROR: soup_uri_to_string didn't fail on NULL URI?\n");
errors++;
expect_warning = FALSE;
} else if (*uri_string) {
debug_printf (1, " ERROR: soup_uri_to_string on NULL URI returned '%s'\n",
uri_string);
errors++;
}
g_free (uri_string);
soup_uri_set_scheme (uri, SOUP_URI_SCHEME_HTTP);
if (SOUP_URI_IS_VALID (uri) || SOUP_URI_VALID_FOR_HTTP (uri)) {
debug_printf (1, " ERROR: setting scheme on NULL URI makes it valid?\n");
errors++;
}
expect_warning = TRUE;
uri_string = soup_uri_to_string (uri, FALSE);
if (expect_warning) {
debug_printf (1, " ERROR: soup_uri_to_string didn't fail on scheme-only URI?\n");
errors++;
expect_warning = FALSE;
} else if (strcmp (uri_string, "http:") != 0) {
debug_printf (1, " ERROR: soup_uri_to_string returned '%s' instead of 'http:'\n",
uri_string);
errors++;
}
g_free (uri_string);
soup_uri_set_host (uri, "localhost");
if (SOUP_URI_IS_VALID (uri)) {
debug_printf (1, " ERROR: setting scheme+host on NULL URI makes it valid?\n");
errors++;
}
if (SOUP_URI_VALID_FOR_HTTP (uri)) {
debug_printf (1, " ERROR: setting scheme+host on NULL URI makes it valid for http?\n");
errors++;
}
expect_warning = TRUE;
uri_string = soup_uri_to_string (uri, FALSE);
if (expect_warning) {
debug_printf (1, " ERROR: soup_uri_to_string didn't fail on scheme+host URI?\n");
errors++;
expect_warning = FALSE;
} else if (strcmp (uri_string, "http://localhost/") != 0) {
debug_printf (1, " ERROR: soup_uri_to_string with NULL path returned '%s' instead of 'http://localhost/'\n",
uri_string);
errors++;
}
g_free (uri_string);
expect_warning = TRUE;
uri2 = soup_uri_new_with_base (uri, "/path");
if (expect_warning) {
debug_printf (1, " ERROR: soup_uri_new_with_base didn't warn on NULL+scheme URI?\n");
errors++;
expect_warning = FALSE;
} else if (!uri2) {
debug_printf (1, " ERROR: soup_uri_new_with_base didn't fix path on NULL+scheme URI\n");
errors++;
}
if (uri2) {
uri_string = soup_uri_to_string (uri2, FALSE);
if (!uri_string) {
debug_printf (1, " ERROR: soup_uri_to_string failed on uri2?\n");
errors++;
} else if (strcmp (uri_string, "http://localhost/path") != 0) {
debug_printf (1, " ERROR: soup_uri_to_string returned '%s' instead of 'http://localhost/path'\n",
uri_string);
errors++;
}
g_free (uri_string);
soup_uri_free (uri2);
}
expect_warning = TRUE;
soup_uri_set_path (uri, NULL);
if (expect_warning) {
debug_printf (1, " ERROR: setting path to NULL doesn't warn\n");
errors++;
expect_warning = FALSE;
}
if (!uri->path || *uri->path) {
debug_printf (1, " ERROR: setting path to NULL != \"\"\n");
errors++;
soup_uri_set_path (uri, "");
}
uri_string = soup_uri_to_string (uri, FALSE);
if (!uri_string) {
debug_printf (1, " ERROR: soup_uri_to_string failed on complete URI?\n");
errors++;
} else if (strcmp (uri_string, "http://localhost/") != 0) {
debug_printf (1, " ERROR: soup_uri_to_string with empty path returned '%s' instead of 'http://localhost/'\n",
uri_string);
errors++;
}
g_free (uri_string);
if (!SOUP_URI_IS_VALID (uri)) {
debug_printf (1, " ERROR: setting scheme+path on NULL URI doesn't make it valid?\n");
errors++;
}
if (!SOUP_URI_VALID_FOR_HTTP (uri)) {
debug_printf (1, " ERROR: setting scheme+host+path on NULL URI doesn't make it valid for http?\n");
errors++;
}
soup_uri_free (uri);
}
