/**
* soup_server_add_handler:
* @server: a #SoupServer
* @path: the toplevel path for the handler
* @callback: callback to invoke for requests under @path
* @user_data: data for @callback
* @destroy: destroy notifier to free @user_data
*
* Adds a handler to @server for requests under @path. See the
* documentation for #SoupServerCallback for information about
* how callbacks should behave.
*
* If @path is %NULL or "/", then this will be the default handler for
* all requests that don't have a more specific handler. Note though
* that if you want to handle requests to the special "*" URI, you
* must explicitly register a handler for "*"; the default handler
* will not be used for that case.
**/
void
soup_server_add_handler (SoupServer *server,
const char *path,
SoupServerCallback callback,
gpointer user_data,
GDestroyNotify destroy)
{
SoupServerPrivate *priv;
SoupServerHandler *hand;
g_return_if_fail (SOUP_IS_SERVER (server));
g_return_if_fail (callback != NULL);
priv = SOUP_SERVER_GET_PRIVATE (server);
/* "" was never documented as meaning the same this as "/",
* but it effectively was. We have to special case it now or
* otherwise it would match "*" too.
*/
if (path && (!*path || !strcmp (path, "/")))
path = NULL;
hand = g_slice_new0 (SoupServerHandler);
hand->path = g_strdup (path);
hand->callback = callback;
hand->destroy = destroy;
hand->user_data = user_data;
soup_server_remove_handler (server, path);
if (path)
soup_path_map_add (priv->handlers, path, hand);
else
priv->default_handler = hand;
}
/**
* soup_auth_domain_remove_path:
* @domain: a #SoupAuthDomain
* @path: the path to remove from @domain
*
* Removes @path from @domain, such that requests under @path on
* @domain's server will NOT require authentication.
*
* This is not simply an undo-er for soup_auth_domain_add_path(); it
* can be used to "carve out" a subtree that does not require
* authentication inside a hierarchy that does. Note also that unlike
* with soup_auth_domain_add_path(), this cannot be overridden by
* adding a filter, as filters can only bypass authentication that
* would otherwise be required, not require it where it would
* otherwise be unnecessary.
*
* You can also remove paths by setting the
* %SOUP_AUTH_DOMAIN_REMOVE_PATH property, which can also be used to
* remove one or more paths at construct time.
**/
void
soup_auth_domain_remove_path (SoupAuthDomain *domain, const char *path)
{
SoupAuthDomainPrivate *priv = SOUP_AUTH_DOMAIN_GET_PRIVATE (domain);
soup_path_map_add (priv->paths, path, GINT_TO_POINTER (FALSE));
}
static SoupAuth *
record_auth_for_uri (SoupAuthManagerPrivate *priv, SoupURI *uri,
SoupAuth *auth, gboolean prior_auth_failed)
{
SoupAuthHost *host;
SoupAuth *old_auth;
const char *path;
char *auth_info, *old_auth_info;
GSList *pspace, *p;
host = get_auth_host_for_uri (priv, uri);
auth_info = soup_auth_get_info (auth);
if (!host->auth_realms) {
host->auth_realms = soup_path_map_new (g_free);
host->auths = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, g_object_unref);
}
/* Record where this auth realm is used. */
pspace = soup_auth_get_protection_space (auth, uri);
for (p = pspace; p; p = p->next) {
path = p->data;
old_auth_info = soup_path_map_lookup (host->auth_realms, path);
if (old_auth_info) {
if (!strcmp (old_auth_info, auth_info))
continue;
soup_path_map_remove (host->auth_realms, path);
}
soup_path_map_add (host->auth_realms, path,
g_strdup (auth_info));
}
soup_auth_free_protection_space (auth, pspace);
/* Now, make sure the auth is recorded. (If there's a
* pre-existing good auth, we keep that rather than the new one,
* since the old one might already be authenticated.)
*/
old_auth = g_hash_table_lookup (host->auths, auth_info);
if (old_auth && (old_auth != auth || !prior_auth_failed)) {
g_free (auth_info);
return old_auth;
} else {
g_hash_table_insert (host->auths, auth_info,
g_object_ref (auth));
return auth;
}
}
