/*
* gnome-keyring
*
* Copyright (C) 2008 Stefan Walter
*
* This program 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.
*
* This program 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 this program; if not, see
* .
*/
#include "config.h"
#include "gkm-attributes.h"
#include "gkm-manager.h"
#include "gkm-marshal.h"
#include "gkm-module.h"
#include "gkm-session.h"
#include "gkm-util.h"
#include
#include
#include
enum {
PROP_0,
PROP_FOR_TOKEN
};
enum {
OBJECT_ADDED,
OBJECT_REMOVED,
ATTRIBUTE_CHANGED,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0 };
struct _GkmManagerPrivate {
gboolean for_token;
GList *objects;
GHashTable *index_by_attribute;
GHashTable *index_by_property;
};
typedef struct _Index {
gboolean unique;
CK_ATTRIBUTE_TYPE attribute_type;
gchar *property_name;
GHashTable *values;
GHashTable *objects;
} Index;
typedef struct _Finder {
GkmManager *manager;
void (*accumulator) (struct _Finder *ctx, GkmObject *found);
gpointer results;
CK_ATTRIBUTE_PTR attrs;
CK_ULONG n_attrs;
GkmSession *session;
} Finder;
G_DEFINE_TYPE_WITH_PRIVATE (GkmManager, gkm_manager, G_TYPE_OBJECT);
/* Friend functions for GkmObject */
void _gkm_manager_register_object (GkmManager *self, GkmObject *object);
void _gkm_manager_unregister_object (GkmManager *self, GkmObject *object);
/* -----------------------------------------------------------------------------
* HELPERS
*/
static void
attribute_free (gpointer data)
{
CK_ATTRIBUTE_PTR attr = data;
if (attr) {
g_free (attr->pValue);
g_slice_free (CK_ATTRIBUTE, attr);
}
}
static Index*
index_new (gboolean unique)
{
Index *index = g_slice_new0 (Index);
index->unique = unique;
if (unique)
index->values = g_hash_table_new_full (gkm_attribute_hash, gkm_attribute_equal, attribute_free, NULL);
else
index->values = g_hash_table_new_full (gkm_attribute_hash, gkm_attribute_equal, attribute_free,
(GDestroyNotify)g_hash_table_destroy);
index->objects = g_hash_table_new (g_direct_hash, g_direct_equal);
return index;
}
static void
index_free (gpointer data)
{
Index *index = data;
if (index) {
g_hash_table_destroy (index->values);
g_hash_table_destroy (index->objects);
g_free (index->property_name);
g_slice_free (Index, index);
}
}
static gboolean
read_attribute(GkmObject *object, CK_ATTRIBUTE_TYPE type, CK_ATTRIBUTE_PTR *result)
{
CK_ATTRIBUTE attr;
CK_RV rv;
g_assert (GKM_IS_OBJECT (object));
g_assert (result);
*result = NULL;
attr.type = type;
attr.pValue = NULL;
attr.ulValueLen = 0;
/* Figure out memory length */
rv = gkm_object_get_attribute (object, NULL, &attr);
/* Not an error, just not present */
if (rv == CKR_ATTRIBUTE_TYPE_INVALID) {
*result = NULL;
return TRUE;
}
if (rv != CKR_OK) {
g_warning ("accessing indexed attribute failed");
return FALSE;
}
/* Allocate memory length */
if (attr.ulValueLen) {
attr.pValue = g_malloc0 (attr.ulValueLen);
rv = gkm_object_get_attribute (object, NULL, &attr);
if (rv != CKR_OK) {
g_warning ("accessing indexed attribute failed");
g_free (attr.pValue);
return FALSE;
}
}
*result = g_slice_new (CK_ATTRIBUTE);
memcpy (*result, &attr, sizeof (CK_ATTRIBUTE));
return TRUE;
}
static gboolean
read_value (GkmObject *object, const gchar *property, CK_ATTRIBUTE_PTR *result)
{
CK_ATTRIBUTE attr;
GParamSpec *spec;
GValue value = { 0, };
CK_ULONG number;
CK_BBOOL boolean;
g_assert (GKM_IS_OBJECT (object));
g_assert (property);
g_assert (result);
spec = g_object_class_find_property (G_OBJECT_GET_CLASS (object),
property);
/* Not an error, just no such property on object */
if (spec == NULL) {
*result = NULL;
return TRUE;
}
g_value_init(&value, spec->value_type);
g_object_get_property (G_OBJECT (object), property, &value);
attr.type = (CK_ATTRIBUTE_TYPE)-1;
attr.pValue = NULL;
attr.ulValueLen = 0;
/* We only support specific types of values */
switch (spec->value_type)
{
case G_TYPE_STRING:
attr.pValue = g_value_dup_string (&value);
attr.ulValueLen = attr.pValue ? strlen (attr.pValue) : 0;
break;
case G_TYPE_INT:
number = g_value_get_int (&value);
attr.ulValueLen = sizeof (number);
attr.pValue = g_memdup2 (&number, attr.ulValueLen);
break;
case G_TYPE_UINT:
number = g_value_get_uint (&value);
attr.ulValueLen = sizeof (number);
attr.pValue = g_memdup2 (&number, attr.ulValueLen);
break;
case G_TYPE_LONG:
number = g_value_get_long (&value);
attr.ulValueLen = sizeof (number);
attr.pValue = g_memdup2 (&number, attr.ulValueLen);
break;
case G_TYPE_ULONG:
number = g_value_get_ulong (&value);
attr.ulValueLen = sizeof (number);
attr.pValue = g_memdup2 (&number, attr.ulValueLen);
break;
case G_TYPE_BOOLEAN:
boolean = g_value_get_boolean (&value) ? CK_TRUE : CK_FALSE;
attr.ulValueLen = sizeof (boolean);
attr.pValue = g_memdup2 (&boolean, attr.ulValueLen);
break;
default:
g_warning ("couldn't convert value from type %s into attribute",
g_type_name (spec->value_type));
g_value_unset (&value);
return FALSE;
};
if (attr.pValue) {
*result = g_slice_new (CK_ATTRIBUTE);
memcpy (*result, &attr, sizeof (CK_ATTRIBUTE));
} else {
*result = NULL;
}
g_value_unset (&value);
return TRUE;
}
static void
index_remove_attr (Index *index, gpointer object, CK_ATTRIBUTE_PTR attr)
{
GHashTable *objects;
g_assert (index);
g_assert (object);
g_assert (attr);
if (index->unique) {
if (!g_hash_table_remove (index->values, attr))
g_assert_not_reached ();
} else {
objects = g_hash_table_lookup (index->values, attr);
g_assert (objects);
if (!g_hash_table_remove (objects, object))
g_assert_not_reached ();
if (g_hash_table_size (objects) == 0)
if (!g_hash_table_remove (index->values, attr))
g_assert_not_reached ();
}
}
static void
index_remove (Index *index, gpointer object)
{
CK_ATTRIBUTE_PTR attr;
/*
* We don't actually access the object. We want to be able to
* handle objects that have been destroyed as well.
*/
g_assert (object);
g_assert (index);
attr = g_hash_table_lookup (index->objects, object);
/* Object not in this index */
if (attr == NULL)
return;
/* Remove the actual value */
index_remove_attr (index, object, attr);
if (!g_hash_table_remove (index->objects, object))
g_assert_not_reached ();
}
static void
index_update (Index *index, GkmObject *object)
{
CK_ATTRIBUTE_PTR attr = NULL;
CK_ATTRIBUTE_PTR prev;
GHashTable *objects;
gboolean ret;
g_assert (GKM_IS_OBJECT (object));
g_assert (index);
/* Get the value for this index */
if (index->property_name)
ret = read_value (object, index->property_name, &attr);
else
ret = read_attribute (object, index->attribute_type, &attr);
g_return_if_fail (ret);
/* No such attribute/property on object */
if (attr == NULL)
return;
prev = g_hash_table_lookup (index->objects, object);
if (prev != NULL) {
/* The previous one is same, ignore */
if (gkm_attribute_equal (prev, attr)) {
attribute_free (attr);
return;
}
/* Remove the previous one */
index_remove_attr (index, object, prev);
}
/* In this case values is a direct pointer to the object */
if (index->unique) {
g_return_if_fail (g_hash_table_lookup (index->values, attr) == NULL);
g_hash_table_replace (index->values, attr, object);
g_hash_table_replace (index->objects, object, attr);
/* In this case values is a pointer to a hash set of objects */
} else {
gpointer key, value;
if (g_hash_table_lookup_extended (index->values, attr, &key, &value)) {
attribute_free (attr);
objects = value;
attr = key;
} else {
objects = g_hash_table_new (g_direct_hash, g_direct_equal);
g_hash_table_insert (index->values, attr, objects);
}
g_hash_table_insert (objects, object, object);
g_hash_table_replace (index->objects, object, attr);
}
}
static gboolean
index_contains (Index *index, GkmObject *object, CK_ATTRIBUTE_PTR attr)
{
GHashTable *objects;
g_assert (index);
g_assert (GKM_IS_OBJECT (object));
g_assert (attr);
if (index->unique) {
return (g_hash_table_lookup (index->values, attr) == object);
} else {
objects = g_hash_table_lookup (index->values, attr);
return (objects && g_hash_table_lookup (objects, object) == object);
}
}
static void
index_object_each (gpointer key, gpointer value, gpointer user_data)
{
index_update (value, user_data);
}
static void
index_remove_each (gpointer key, gpointer value, gpointer user_data)
{
index_remove (value, user_data);
}
static void
notify_attribute (GkmObject *object, CK_ATTRIBUTE_TYPE attr_type, GkmManager *self)
{
Index *index;
g_return_if_fail (GKM_IS_OBJECT (object));
g_return_if_fail (GKM_IS_MANAGER (self));
g_return_if_fail (gkm_object_get_manager (object) == self);
index = g_hash_table_lookup (self->pv->index_by_attribute, &attr_type);
if (index != NULL)
index_update (index, object);
/* Tell everyone that this attribute changed on this object */
g_signal_emit (self, signals[ATTRIBUTE_CHANGED], 0, object, attr_type);
}
static void
notify_property (GkmObject *object, GParamSpec *spec, GkmManager *self)
{
Index *index;
g_return_if_fail (GKM_IS_OBJECT (object));
g_return_if_fail (GKM_IS_MANAGER (self));
g_return_if_fail (gkm_object_get_manager (object) == self);
index = g_hash_table_lookup (self->pv->index_by_property, spec->name);
if (index != NULL)
index_update (index, object);
}
static void
add_object (GkmManager *self, GkmObject *object)
{
CK_OBJECT_HANDLE handle;
g_assert (GKM_IS_MANAGER (self));
g_assert (GKM_IS_OBJECT (object));
g_assert (gkm_object_get_manager (object) == self);
handle = gkm_object_get_handle (object);
if (!handle) {
/* Make a new handle */
handle = gkm_util_next_handle ();
gkm_object_set_handle (object, handle);
}
/*
* We don't ref the objects or anything. They're expected to
* unregister upon dispose.
*/
/* Note objects is being managed */
self->pv->objects = g_list_prepend (self->pv->objects, object);
/* Now index the object properly */
g_hash_table_foreach (self->pv->index_by_attribute, index_object_each, object);
g_hash_table_foreach (self->pv->index_by_property, index_object_each, object);
g_signal_connect (object, "notify-attribute", G_CALLBACK (notify_attribute), self);
g_signal_connect (object, "notify", G_CALLBACK (notify_property), self);
/* Tell everyone we added this object */
g_signal_emit (self, signals[OBJECT_ADDED], 0, object);
}
static void
remove_object (GkmManager *self, GkmObject *object)
{
CK_OBJECT_HANDLE handle;
g_assert (GKM_IS_MANAGER (self));
g_assert (GKM_IS_OBJECT (object));
g_assert (gkm_object_get_manager (object) == self);
handle = gkm_object_get_handle (object);
g_assert (handle);
/* Remove from all indexes */
g_signal_handlers_disconnect_by_func (object, G_CALLBACK (notify_attribute), self);
g_signal_handlers_disconnect_by_func (object, G_CALLBACK (notify_property), self);
g_hash_table_foreach (self->pv->index_by_attribute, index_remove_each, object);
g_hash_table_foreach (self->pv->index_by_property, index_remove_each, object);
/* Release object management */
self->pv->objects = g_list_remove (self->pv->objects, object);
/* Tell everyone this object is gone */
g_signal_emit (self, signals[OBJECT_REMOVED], 0, object);
}
static void
find_each_object (gpointer unused, gpointer object, gpointer user_data)
{
Finder *finder = user_data;
CK_ATTRIBUTE_PTR attr;
Index *index;
CK_ULONG i;
g_assert (finder);
g_assert (GKM_IS_MANAGER (finder->manager));
/* Match the object against all the other attributes */
for (i = 0; i < finder->n_attrs; ++i) {
attr = &(finder->attrs[i]);
index = g_hash_table_lookup (finder->manager->pv->index_by_attribute, &attr->type);
if (index) {
if (!index_contains (index, object, attr))
return;
} else {
if (!gkm_object_match (object, finder->session, attr))
return;
}
}
(finder->accumulator) (finder, object);
}
static void
find_for_attributes (Finder *finder)
{
GHashTable *objects;
CK_ATTRIBUTE_PTR first;
GkmObject *object;
Index *index;
GList *l;
g_assert (finder);
g_assert (GKM_IS_MANAGER (finder->manager));
g_assert (!finder->n_attrs || finder->attrs);
/* All the objects */
if (!finder->n_attrs) {
for (l = finder->manager->pv->objects; l; l = g_list_next (l))
(finder->accumulator) (finder, l->data);
return;
}
first = finder->attrs;
finder->attrs = finder->attrs + 1;
finder->n_attrs = finder->n_attrs - 1;
index = g_hash_table_lookup (finder->manager->pv->index_by_attribute,
&first->type);
/* No indexes, have to manually match */
if (!index) {
for (l = finder->manager->pv->objects; l; l = g_list_next (l)) {
if (gkm_object_match (l->data, NULL, first))
find_each_object (NULL, l->data, finder);
}
return;
}
/* Yay, an index */
if (index->unique) {
object = g_hash_table_lookup (index->values, first);
if (object)
find_each_object (NULL, object, finder);
} else {
objects = g_hash_table_lookup (index->values, first);
if (objects)
g_hash_table_foreach (objects, find_each_object, finder);
}
}
static void
accumulate_list (Finder *finder, GkmObject *object)
{
finder->results = g_list_prepend (finder->results, object);
}
static void
accumulate_one (Finder *finder, GkmObject *object)
{
if (!finder->results)
finder->results = object;
}
static void
accumulate_handles (Finder *finder, GkmObject *object)
{
CK_OBJECT_HANDLE handle = gkm_object_get_handle (object);
g_return_if_fail (handle);
g_array_append_val (finder->results, handle);
}
static void
accumulate_public_handles (Finder *finder, GkmObject *object)
{
gboolean is_private;
if (gkm_object_get_attribute_boolean (object, NULL, CKA_PRIVATE, &is_private) && is_private)
return;
accumulate_handles (finder, object);
}
static void
values_to_list (gpointer key, gpointer value, gpointer user_data)
{
GList** list = (GList**)user_data;
*list = g_list_prepend (*list, value);
}
static GList*
find_all_for_property (GkmManager *self, const gchar *property, CK_ATTRIBUTE_PTR attr)
{
GkmObject *object;
GHashTable *objects;
GList *results = NULL;
Index *index;
g_assert (GKM_IS_MANAGER (self));
g_assert (property);
g_assert (attr);
index = g_hash_table_lookup (self->pv->index_by_property, property);
g_return_val_if_fail (index, NULL);
if (index->unique) {
object = g_hash_table_lookup (index->values, attr);
return object ? g_list_prepend (NULL, object) : NULL;
} else {
objects = g_hash_table_lookup (index->values, attr);
if (!objects)
return NULL;
g_hash_table_foreach (objects, values_to_list, &results);
return results;
}
}
static GkmObject*
find_one_for_property (GkmManager *self, const gchar *property, CK_ATTRIBUTE_PTR attr)
{
GkmObject *object;
GHashTable *objects;
GList *results = NULL;
Index *index;
g_assert (GKM_IS_MANAGER (self));
g_assert (property);
g_assert (attr);
index = g_hash_table_lookup (self->pv->index_by_property, property);
g_return_val_if_fail (index, NULL);
if (index->unique) {
return g_hash_table_lookup (index->values, attr);
} else {
objects = g_hash_table_lookup (index->values, attr);
if (!objects)
return NULL;
g_hash_table_foreach (objects, values_to_list, &results);
object = results ? results->data : NULL;
g_list_free (results);
return object;
}
}
/* -----------------------------------------------------------------------------
* OBJECT
*/
static void
gkm_manager_init (GkmManager *self)
{
self->pv = gkm_manager_get_instance_private (self);
self->pv->index_by_attribute = g_hash_table_new_full (gkm_util_ulong_hash, gkm_util_ulong_equal,
gkm_util_ulong_free, index_free);
self->pv->index_by_property = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, index_free);
gkm_manager_add_property_index (self, "handle", TRUE);
gkm_manager_add_attribute_index (self, CKA_ID, FALSE);
gkm_manager_add_attribute_index (self, CKA_CLASS, FALSE);
}
static void
gkm_manager_set_property (GObject *obj, guint prop_id, const GValue *value,
GParamSpec *pspec)
{
GkmManager *self = GKM_MANAGER (obj);
switch (prop_id) {
case PROP_FOR_TOKEN:
self->pv->for_token = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
static void
gkm_manager_get_property (GObject *obj, guint prop_id, GValue *value,
GParamSpec *pspec)
{
GkmManager *self = GKM_MANAGER (obj);
switch (prop_id) {
case PROP_FOR_TOKEN:
g_value_set_boolean (value, gkm_manager_get_for_token (self));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
static void
gkm_manager_dispose (GObject *obj)
{
GkmManager *self = GKM_MANAGER (obj);
GList *objects, *l;
/* Unregister all objects */
objects = g_list_copy (self->pv->objects);
for (l = objects; l; l = g_list_next (l))
remove_object (self, GKM_OBJECT (l->data));
g_list_free (objects);
g_return_if_fail (self->pv->objects == NULL);
G_OBJECT_CLASS (gkm_manager_parent_class)->dispose (obj);
}
static void
gkm_manager_finalize (GObject *obj)
{
GkmManager *self = GKM_MANAGER (obj);
g_assert (!self->pv->objects);
g_hash_table_destroy (self->pv->index_by_attribute);
g_hash_table_destroy (self->pv->index_by_property);
G_OBJECT_CLASS (gkm_manager_parent_class)->finalize (obj);
}
static void
gkm_manager_class_init (GkmManagerClass *klass)
{
GObjectClass *gobject_class;
gobject_class = (GObjectClass*)klass;
gobject_class->dispose = gkm_manager_dispose;
gobject_class->get_property = gkm_manager_get_property;
gobject_class->set_property = gkm_manager_set_property;
gobject_class->finalize = gkm_manager_finalize;
g_object_class_install_property (gobject_class, PROP_FOR_TOKEN,
g_param_spec_boolean ("for-token", "For Token", "Whether this manager is for token objects or not",
FALSE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
signals[OBJECT_ADDED] = g_signal_new ("object-added", GKM_TYPE_MANAGER,
G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GkmManagerClass, object_added),
NULL, NULL, g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1, GKM_TYPE_OBJECT);
signals[OBJECT_REMOVED] = g_signal_new ("object-removed", GKM_TYPE_MANAGER,
G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GkmManagerClass, object_removed),
NULL, NULL, g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1, GKM_TYPE_OBJECT);
signals[ATTRIBUTE_CHANGED] = g_signal_new ("attribute-changed", GKM_TYPE_MANAGER,
G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GkmManagerClass, attribute_changed),
NULL, NULL, gkm_marshal_VOID__OBJECT_ULONG,
G_TYPE_NONE, 2, GKM_TYPE_OBJECT, G_TYPE_ULONG);
}
/* ------------------------------------------------------------------------
* PUBLIC METHODS
*/
gboolean
gkm_manager_get_for_token (GkmManager *self)
{
g_return_val_if_fail (GKM_IS_MANAGER (self), FALSE);
return self->pv->for_token;
}
void
gkm_manager_add_attribute_index (GkmManager *self, CK_ATTRIBUTE_TYPE attr, gboolean unique)
{
Index *index;
GList *l;
g_return_if_fail (GKM_IS_MANAGER (self));
g_return_if_fail (!g_hash_table_lookup (self->pv->index_by_attribute, &attr));
index = index_new (unique);
index->attribute_type = attr;
g_hash_table_replace (self->pv->index_by_attribute, gkm_util_ulong_alloc (attr), index);
for (l = self->pv->objects; l; l = g_list_next (l))
index_update (index, l->data);
}
void
gkm_manager_add_property_index (GkmManager *self, const gchar *property, gboolean unique)
{
Index *index;
GList *l;
g_return_if_fail (GKM_IS_MANAGER (self));
g_return_if_fail (property);
g_return_if_fail (!g_hash_table_lookup (self->pv->index_by_property, property));
index = index_new (unique);
index->property_name = g_strdup (property);
g_hash_table_replace (self->pv->index_by_property, g_strdup (property), index);
for (l = self->pv->objects; l; l = g_list_next (l))
index_update (index, l->data);
}
void
_gkm_manager_register_object (GkmManager *self, GkmObject *object)
{
g_return_if_fail (GKM_IS_MANAGER (self));
g_return_if_fail (GKM_IS_OBJECT (object));
g_return_if_fail (gkm_object_get_manager (object) == self);
add_object (self, object);
}
void
_gkm_manager_unregister_object (GkmManager *self, GkmObject *object)
{
g_return_if_fail (GKM_IS_MANAGER (self));
g_return_if_fail (GKM_IS_OBJECT (object));
g_return_if_fail (gkm_object_get_manager (object) == self);
remove_object (self, object);
}
GkmObject*
gkm_manager_find_by_handle (GkmManager *self, CK_OBJECT_HANDLE handle)
{
g_return_val_if_fail (GKM_IS_MANAGER (self), NULL);
g_return_val_if_fail (handle != 0, NULL);
return gkm_manager_find_one_by_number_property (self, "handle", handle);
}
GList*
gkm_manager_find_by_number_property (GkmManager *self, const gchar *property, gulong value)
{
CK_ATTRIBUTE attr;
CK_ULONG number = value;
attr.type = (CK_ATTRIBUTE_TYPE)-1;
attr.pValue = &number;
attr.ulValueLen = sizeof (number);
return find_all_for_property (self, property, &attr);
}
GkmObject*
gkm_manager_find_one_by_number_property (GkmManager *self, const gchar *property, gulong value)
{
CK_ATTRIBUTE attr;
CK_ULONG number = value;
attr.type = (CK_ATTRIBUTE_TYPE)-1;
attr.pValue = &number;
attr.ulValueLen = sizeof (number);
return find_one_for_property (self, property, &attr);
}
GList*
gkm_manager_find_by_string_property (GkmManager *self, const gchar *property, const gchar *value)
{
CK_ATTRIBUTE attr;
attr.type = (CK_ATTRIBUTE_TYPE)-1;
attr.pValue = (void*)value;
attr.ulValueLen = value ? strlen (value) : 0;
return find_all_for_property (self, property, &attr);
}
GkmObject*
gkm_manager_find_one_by_string_property (GkmManager *self, const gchar *property, const gchar *value)
{
CK_ATTRIBUTE attr;
attr.type = (CK_ATTRIBUTE_TYPE)-1;
attr.pValue = (void*)value;
attr.ulValueLen = value ? strlen (value) : 0;
return find_one_for_property (self, property, &attr);
}
GkmObject*
gkm_manager_find_one_by_attributes (GkmManager *self, GkmSession *session,
CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs)
{
Finder finder = { 0, };
g_return_val_if_fail (GKM_IS_MANAGER (self), NULL);
g_return_val_if_fail (attrs || !n_attrs, NULL);
finder.accumulator = accumulate_one;
finder.results = NULL;
finder.manager = self;
finder.attrs = attrs;
finder.n_attrs = n_attrs;
finder.session = session;
find_for_attributes (&finder);
return finder.results;
}
GList*
gkm_manager_find_by_attributes (GkmManager *self, GkmSession *session,
CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs)
{
Finder finder = { 0, };
g_return_val_if_fail (GKM_IS_MANAGER (self), NULL);
g_return_val_if_fail (attrs || !n_attrs, NULL);
finder.accumulator = accumulate_list;
finder.results = NULL;
finder.manager = self;
finder.attrs = attrs;
finder.n_attrs = n_attrs;
finder.session = session;
find_for_attributes (&finder);
return finder.results;
}
GList*
gkm_manager_find_by_class (GkmManager *self, GkmSession *session, CK_OBJECT_CLASS klass)
{
CK_ATTRIBUTE attr;
g_return_val_if_fail (GKM_IS_MANAGER (self), NULL);
attr.type = CKA_CLASS;
attr.ulValueLen = sizeof (klass);
attr.pValue = &klass;
return gkm_manager_find_by_attributes (self, session, &attr, 1);
}
GkmObject*
gkm_manager_find_related (GkmManager *self, GkmSession *session,
CK_OBJECT_CLASS klass, GkmObject *related_to)
{
CK_ATTRIBUTE attrs[2];
GkmObject *object;
guchar *id;
gsize n_id;
g_return_val_if_fail (GKM_IS_MANAGER (self), NULL);
g_return_val_if_fail (GKM_IS_OBJECT (related_to), NULL);
id = gkm_object_get_attribute_data (related_to, NULL, CKA_ID, &n_id);
if (id == NULL)
return NULL;
attrs[0].type = CKA_ID;
attrs[0].pValue = id;
attrs[0].ulValueLen = n_id;
attrs[1].type = CKA_CLASS;
attrs[1].pValue = &klass;
attrs[1].ulValueLen = sizeof (klass);
object = gkm_manager_find_one_by_attributes (self, session, attrs, 2);
g_free (id);
return object;
}
CK_RV
gkm_manager_find_handles (GkmManager *self, GkmSession *session,
gboolean also_private, CK_ATTRIBUTE_PTR attrs,
CK_ULONG n_attrs, GArray *found)
{
Finder finder = { 0, };
g_return_val_if_fail (GKM_IS_MANAGER (self), CKR_GENERAL_ERROR);
g_return_val_if_fail (attrs || !n_attrs, CKR_GENERAL_ERROR);
finder.accumulator = also_private ? accumulate_handles : accumulate_public_handles;
finder.results = found;
finder.manager = self;
finder.attrs = attrs;
finder.n_attrs = n_attrs;
finder.session = session;
find_for_attributes (&finder);
return CKR_OK;
}
/* Odd place for this function */
GkmManager*
gkm_manager_for_template (CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs, GkmSession *session)
{
gboolean is_token;
if (!gkm_attributes_find_boolean (attrs, n_attrs, CKA_TOKEN, &is_token) || !is_token)
return gkm_session_get_manager (session);
else
return gkm_module_get_manager (gkm_session_get_module (session));
}