/**
* soup_auth_is_ready:
* @auth: a #SoupAuth
* @msg: a #SoupMessage
*
* Tests if @auth is ready to make a request for @msg with. For most
* auths, this is equivalent to soup_auth_is_authenticated(), but for
* some auth types (eg, NTLM), the auth may be sendable (eg, as an
* authentication request) even before it is authenticated.
*
* Return value: %TRUE if @auth is ready to make a request with.
*
* Since: 2.42
**/
gboolean
soup_auth_is_ready (SoupAuth *auth,
SoupMessage *msg)
{
g_return_val_if_fail (SOUP_IS_AUTH (auth), TRUE);
g_return_val_if_fail (SOUP_IS_MESSAGE (msg), TRUE);
if (SOUP_AUTH_GET_CLASS (auth)->is_ready)
return SOUP_AUTH_GET_CLASS (auth)->is_ready (auth, msg);
else
return SOUP_AUTH_GET_CLASS (auth)->is_authenticated (auth);
}
/**
* soup_auth_get_info:
* @auth: a #SoupAuth
*
* Gets an opaque identifier for @auth, for use as a hash key or the
* like. #SoupAuth objects from the same server with the same
* identifier refer to the same authentication domain (eg, the URLs
* associated with them take the same usernames and passwords).
*
* Return value: the identifier
**/
char *
soup_auth_get_info (SoupAuth *auth)
{
g_return_val_if_fail (SOUP_IS_AUTH (auth), NULL);
if (SOUP_IS_CONNECTION_AUTH (auth))
return g_strdup (SOUP_AUTH_GET_CLASS (auth)->scheme_name);
else {
return g_strdup_printf ("%s:%s",
SOUP_AUTH_GET_CLASS (auth)->scheme_name,
auth->realm);
}
}
/**
* soup_auth_is_authenticated:
* @auth: a #SoupAuth
*
* Tests if @auth has been given a username and password
*
* Return value: %TRUE if @auth has been given a username and password
**/
gboolean
soup_auth_is_authenticated (SoupAuth *auth)
{
g_return_val_if_fail (SOUP_IS_AUTH (auth), TRUE);
return SOUP_AUTH_GET_CLASS (auth)->is_authenticated (auth);
}
/**
* soup_auth_get_scheme_name:
* @auth: a #SoupAuth
*
* Returns @auth's scheme name. (Eg, "Basic", "Digest", or "NTLM")
*
* Return value: the scheme name
**/
const char *
soup_auth_get_scheme_name (SoupAuth *auth)
{
g_return_val_if_fail (SOUP_IS_AUTH (auth), NULL);
return SOUP_AUTH_GET_CLASS (auth)->scheme_name;
}
/**
* soup_auth_update:
* @auth: a #SoupAuth
* @msg: the #SoupMessage @auth is being updated for
* @auth_header: the WWW-Authenticate/Proxy-Authenticate header
*
* Updates @auth with the information from @msg and @auth_header,
* possibly un-authenticating it. As with soup_auth_new(), this is
* normally only used by #SoupSession.
*
* Return value: %TRUE if @auth is still a valid (but potentially
* unauthenticated) #SoupAuth. %FALSE if something about @auth_params
* could not be parsed or incorporated into @auth at all.
**/
gboolean
soup_auth_update (SoupAuth *auth, SoupMessage *msg, const char *auth_header)
{
GHashTable *params;
const char *scheme, *realm;
gboolean was_authenticated, success;
g_return_val_if_fail (SOUP_IS_AUTH (auth), FALSE);
g_return_val_if_fail (SOUP_IS_MESSAGE (msg), FALSE);
g_return_val_if_fail (auth_header != NULL, FALSE);
scheme = soup_auth_get_scheme_name (auth);
if (g_ascii_strncasecmp (auth_header, scheme, strlen (scheme)) != 0)
return FALSE;
params = soup_header_parse_param_list (auth_header + strlen (scheme));
if (!params)
params = g_hash_table_new (NULL, NULL);
realm = g_hash_table_lookup (params, "realm");
if (realm && auth->realm && strcmp (realm, auth->realm) != 0) {
soup_header_free_param_list (params);
return FALSE;
}
was_authenticated = soup_auth_is_authenticated (auth);
success = SOUP_AUTH_GET_CLASS (auth)->update (auth, msg, params);
if (was_authenticated != soup_auth_is_authenticated (auth))
g_object_notify (G_OBJECT (auth), SOUP_AUTH_IS_AUTHENTICATED);
soup_header_free_param_list (params);
return success;
}
/**
* soup_auth_can_authenticate:
* @auth: a #SoupAuth
*
* Tests if @auth is able to authenticate by providing credentials to the
* soup_auth_authenticate().
*
* Return value: %TRUE if @auth is able to accept credentials.
*
* Since: 2.54
**/
gboolean
soup_auth_can_authenticate (SoupAuth *auth)
{
g_return_val_if_fail (SOUP_IS_AUTH (auth), FALSE);
return SOUP_AUTH_GET_CLASS (auth)->can_authenticate (auth);
}
/**
* soup_auth_get_protection_space:
* @auth: a #SoupAuth
* @source_uri: the URI of the request that @auth was generated in
* response to.
*
* Returns a list of paths on the server which @auth extends over.
* (All subdirectories of these paths are also assumed to be part
* of @auth's protection space, unless otherwise discovered not to
* be.)
*
* Return value: (element-type utf8) (transfer full): the list of
* paths, which can be freed with soup_auth_free_protection_space().
**/
GSList *
soup_auth_get_protection_space (SoupAuth *auth, SoupURI *source_uri)
{
g_return_val_if_fail (SOUP_IS_AUTH (auth), NULL);
g_return_val_if_fail (source_uri != NULL, NULL);
return SOUP_AUTH_GET_CLASS (auth)->get_protection_space (auth, source_uri);
}
/**
* soup_auth_get_authorization:
* @auth: a #SoupAuth
* @msg: the #SoupMessage to be authorized
*
* Generates an appropriate "Authorization" header for @msg. (The
* session will only call this if soup_auth_is_authenticated()
* returned %TRUE.)
*
* Return value: the "Authorization" header, which must be freed.
**/
char *
soup_auth_get_authorization (SoupAuth *auth, SoupMessage *msg)
{
g_return_val_if_fail (SOUP_IS_AUTH (auth), NULL);
g_return_val_if_fail (msg != NULL, NULL);
return SOUP_AUTH_GET_CLASS (auth)->get_authorization (auth, msg);
}
/**
* soup_auth_authenticate:
* @auth: a #SoupAuth
* @username: the username provided by the user or client
* @password: the password provided by the user or client
*
* Call this on an auth to authenticate it; normally this will cause
* the auth's message to be requeued with the new authentication info.
**/
void
soup_auth_authenticate (SoupAuth *auth, const char *username, const char *password)
{
gboolean was_authenticated;
g_return_if_fail (SOUP_IS_AUTH (auth));
g_return_if_fail (username != NULL);
g_return_if_fail (password != NULL);
was_authenticated = soup_auth_is_authenticated (auth);
SOUP_AUTH_GET_CLASS (auth)->authenticate (auth, username, password);
if (was_authenticated != soup_auth_is_authenticated (auth))
g_object_notify (G_OBJECT (auth), SOUP_AUTH_IS_AUTHENTICATED);
}
/**
* soup_auth_new:
* @type: the type of auth to create (a subtype of #SoupAuth)
* @msg: the #SoupMessage the auth is being created for
* @auth_header: the WWW-Authenticate/Proxy-Authenticate header
*
* Creates a new #SoupAuth of type @type with the information from
* @msg and @auth_header.
*
* This is called by #SoupSession; you will normally not create auths
* yourself.
*
* Return value: the new #SoupAuth, or %NULL if it could not be
* created
**/
SoupAuth *
soup_auth_new (GType type, SoupMessage *msg, const char *auth_header)
{
SoupAuth *auth;
GHashTable *params;
const char *scheme, *realm;
g_return_val_if_fail (g_type_is_a (type, SOUP_TYPE_AUTH), NULL);
g_return_val_if_fail (SOUP_IS_MESSAGE (msg), NULL);
g_return_val_if_fail (auth_header != NULL, NULL);
auth = g_object_new (type,
SOUP_AUTH_IS_FOR_PROXY, (msg->status_code == SOUP_STATUS_PROXY_UNAUTHORIZED),
SOUP_AUTH_HOST, soup_message_get_uri (msg)->host,
NULL);
scheme = soup_auth_get_scheme_name (auth);
if (g_ascii_strncasecmp (auth_header, scheme, strlen (scheme)) != 0) {
g_object_unref (auth);
return NULL;
}
params = soup_header_parse_param_list (auth_header + strlen (scheme));
if (!params) {
g_object_unref (auth);
return NULL;
}
realm = g_hash_table_lookup (params, "realm");
if (!realm) {
soup_header_free_param_list (params);
g_object_unref (auth);
return NULL;
}
auth->realm = g_strdup (realm);
if (!SOUP_AUTH_GET_CLASS (auth)->update (auth, msg, params)) {
g_object_unref (auth);
auth = NULL;
}
soup_header_free_param_list (params);
return auth;
}
