/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ /* * GData Client * Copyright (C) Philip Withnall 2014 * * GData Client is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * GData Client is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with GData Client. If not, see . */ /* * SECTION:gdata-dummy-authorizer * @short_description: GData dummy authorization interface * @stability: Stable * @include: tests/gdata-dummy-authorizer.h * * #GDataDummyAuthorizer is a dummy #GDataAuthorizer implementation intended for * use in prototyping and testing code. It should not be used in production * code. * * It adds a constant ‘Authorization’ header to all requests it processes whose * domain is in the set of domains the authorizer was initialised with. All * requests for other domains have no header added, and are considered * non-authorized. * * Since: 0.16.0 */ #include #include #include #include #include "gdata-dummy-authorizer.h" #include "gdata-private.h" static void authorizer_init (GDataAuthorizerInterface *iface); static void finalize (GObject *object); static void process_request (GDataAuthorizer *self, GDataAuthorizationDomain *domain, SoupMessage *message); static gboolean is_authorized_for_domain (GDataAuthorizer *self, GDataAuthorizationDomain *domain); struct _GDataDummyAuthorizerPrivate { GMutex mutex; /* mutex for authorization_domains */ /* Mapping from GDataAuthorizationDomain to itself; a set of domains * which are authorised. */ GHashTable *authorization_domains; }; G_DEFINE_TYPE_WITH_CODE (GDataDummyAuthorizer, gdata_dummy_authorizer, G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE (GDATA_TYPE_AUTHORIZER, authorizer_init)) static void gdata_dummy_authorizer_class_init (GDataDummyAuthorizerClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); g_type_class_add_private (klass, sizeof (GDataDummyAuthorizerPrivate)); gobject_class->finalize = finalize; } static void authorizer_init (GDataAuthorizerInterface *iface) { iface->process_request = process_request; iface->is_authorized_for_domain = is_authorized_for_domain; } static void gdata_dummy_authorizer_init (GDataDummyAuthorizer *self) { self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GDATA_TYPE_DUMMY_AUTHORIZER, GDataDummyAuthorizerPrivate); /* Set up the authorizer's mutex */ g_mutex_init (&(self->priv->mutex)); self->priv->authorization_domains = g_hash_table_new_full (g_direct_hash, g_direct_equal, g_object_unref, NULL); } static void finalize (GObject *object) { GDataDummyAuthorizerPrivate *priv = GDATA_DUMMY_AUTHORIZER (object)->priv; g_hash_table_destroy (priv->authorization_domains); g_mutex_clear (&(priv->mutex)); /* Chain up to the parent class */ G_OBJECT_CLASS (gdata_dummy_authorizer_parent_class)->finalize (object); } static void process_request (GDataAuthorizer *self, GDataAuthorizationDomain *domain, SoupMessage *message) { GDataDummyAuthorizerPrivate *priv = GDATA_DUMMY_AUTHORIZER (self)->priv; /* Set the authorisation header */ g_mutex_lock (&(priv->mutex)); if (g_hash_table_lookup (priv->authorization_domains, domain) != NULL) { soup_message_headers_replace (message->request_headers, "Authorization", "dummy"); } g_mutex_unlock (&(priv->mutex)); } static gboolean is_authorized_for_domain (GDataAuthorizer *self, GDataAuthorizationDomain *domain) { GDataDummyAuthorizerPrivate *priv = GDATA_DUMMY_AUTHORIZER (self)->priv; gpointer result; g_mutex_lock (&(priv->mutex)); result = g_hash_table_lookup (priv->authorization_domains, domain); g_mutex_unlock (&(priv->mutex)); /* Sanity check */ g_assert (result == NULL || result == domain); return (result != NULL); } /* * gdata_dummy_authorizer_new: * @service_type: the #GType of a #GDataService subclass which the * #GDataDummyAuthorizer will be used with * * Creates a new #GDataDummyAuthorizer. * * The #GDataAuthorizationDomains for the given @service_type (i.e. as * returned by gdata_service_get_authorization_domains()) will be authorized, * and all others will not. * * Return value: (transfer full): a new #GDataDummyAuthorizer; unref with * g_object_unref() * * Since: 0.16.0 */ GDataDummyAuthorizer * gdata_dummy_authorizer_new (GType service_type) { GList/**/ *domains; /* owned */ GDataDummyAuthorizer *retval = NULL; /* owned */ g_return_val_if_fail (g_type_is_a (service_type, GDATA_TYPE_SERVICE), NULL); domains = gdata_service_get_authorization_domains (service_type); retval = gdata_dummy_authorizer_new_for_authorization_domains (domains); g_list_free (domains); return retval; } /* * gdata_dummy_authorizer_new_for_authorization_domains: * @authorization_domains: (element-type GDataAuthorizationDomain) (transfer none): * a non-empty list of #GDataAuthorizationDomains to be authorized * against by the #GDataDummyAuthorizer * * Creates a new #GDataDummyAuthorizer. This function is intended to be used * only when the default authorization domain list for a single #GDataService, * as used by gdata_dummy_authorizer_new(), isn't suitable. For example, this * could be because the #GDataDummyAuthorizer will be used with multiple * #GDataService subclasses, or because the client requires a specific set of * authorization domains. * * Return value: (transfer full): a new #GDataDummyAuthorizer; unref with * g_object_unref() * * Since: 0.16.0 */ GDataDummyAuthorizer * gdata_dummy_authorizer_new_for_authorization_domains (GList *authorization_domains) { GList *i; GDataDummyAuthorizer *authorizer; g_return_val_if_fail (authorization_domains != NULL, NULL); authorizer = GDATA_DUMMY_AUTHORIZER (g_object_new (GDATA_TYPE_DUMMY_AUTHORIZER, NULL)); /* Register all the domains with the authorizer */ for (i = authorization_domains; i != NULL; i = i->next) { GDataAuthorizationDomain *domain; g_return_val_if_fail (GDATA_IS_AUTHORIZATION_DOMAIN (i->data), NULL); /* We don't have to lock the authoriser's mutex here as no other * code has seen the authoriser yet */ domain = GDATA_AUTHORIZATION_DOMAIN (i->data); g_hash_table_insert (authorizer->priv->authorization_domains, g_object_ref (domain), domain); } return authorizer; }