From f1ca5d5b57909534d8b21f9be455c94ca57e6636 Mon Sep 17 00:00:00 2001 From: Stef Walter Date: Mon, 20 Jun 2011 21:17:03 +0200 Subject: Implement support for registering and calling pinfile callbacks * These are callbacks that hanlde the pinfile part of a PKCS#11 URI. * One library can register a callback that another can then call in a thread-safe and simple fashion. --- .gitignore | 2 + p11-kit/Makefile.am | 3 + p11-kit/pin.c | 332 +++++++++++++++++++++++++++++++++++++++++++++++++ p11-kit/pin.h | 85 +++++++++++++ p11-kit/ptr-array.c | 150 ++++++++++++++++++++++ p11-kit/ptr-array.h | 61 +++++++++ tests/Makefile.am | 12 +- tests/pin-test.c | 237 +++++++++++++++++++++++++++++++++++ tests/ptr-array-test.c | 259 ++++++++++++++++++++++++++++++++++++++ 9 files changed, 1140 insertions(+), 1 deletion(-) create mode 100644 p11-kit/pin.c create mode 100644 p11-kit/pin.h create mode 100644 p11-kit/ptr-array.c create mode 100644 p11-kit/ptr-array.h create mode 100644 tests/pin-test.c create mode 100644 tests/ptr-array-test.c diff --git a/.gitignore b/.gitignore index a844dce..c5a95f5 100644 --- a/.gitignore +++ b/.gitignore @@ -67,6 +67,8 @@ temp.txt /tests/coverage /tests/coverage.info /tests/hash-test +/tests/pin-test +/tests/ptr-array-test /tests/conf-test /tests/uri-test diff --git a/p11-kit/Makefile.am b/p11-kit/Makefile.am index 9afc6b6..9366a05 100644 --- a/p11-kit/Makefile.am +++ b/p11-kit/Makefile.am @@ -7,6 +7,7 @@ incdir = $(includedir)/p11-kit-1/p11-kit inc_HEADERS = \ p11-kit.h \ + pin.h \ uri.h \ pkcs11.h @@ -16,8 +17,10 @@ MODULE_SRCS = \ debug.c debug.h \ hash.c hash.h \ modules.c \ + pin.c \ proxy.c \ private.h \ + ptr-array.c ptr-array.h \ messages.c \ uri.c \ $(inc_HEADERS) diff --git a/p11-kit/pin.c b/p11-kit/pin.c new file mode 100644 index 0000000..328785f --- /dev/null +++ b/p11-kit/pin.c @@ -0,0 +1,332 @@ +/* + * Copyright (C) 2011 Collabora Ltd. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above + * copyright notice, this list of conditions and the + * following disclaimer. + * * Redistributions in binary form must reproduce the + * above copyright notice, this list of conditions and + * the following disclaimer in the documentation and/or + * other materials provided with the distribution. + * * The names of contributors to this software may not be + * used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * Author: Stef Walter + */ + +#include "config.h" + +#define DEBUG_FLAG DEBUG_PIN +#include "debug.h" +#include "hash.h" +#include "pkcs11.h" +#include "p11-kit.h" +#include "pin.h" +#include "private.h" +#include "ptr-array.h" + +#include +#include +#include +#include + +/** + * SECTION:p11-pin + * @title: PIN Callbacks + * @short_description: PIN Callbacks + * + * Applications can register a callback which will be called to provide a password + * associated with a given pin file. + * PKCS\#11 URIs can be used in configuration files or applications to represent + * PKCS\#11 modules, tokens or objects. An example of a URI might be: + * + * + * pkcs11:token=The\%20Software\%20PKCS\#11\%20softtoken; + * manufacturer=Snake\%20Oil,\%20Inc.;serial=;object=my-certificate; + * model=1.0;objecttype=cert;id=\%69\%95\%3e\%5c\%f4\%bd\%ec\%91 + * + * + * You can use p11_kit_uri_parse() to parse such a URI, and p11_kit_uri_format() + * to build one. URIs are represented by the #P11KitUri structure. You can match + * a parsed URI against PKCS\#11 tokens with p11_kit_uri_match_token_info() + * or attributes with p11_kit_uri_match_attributes(). + * + * Since URIs can represent different sorts of things, when parsing or formatting + * a URI a 'context' can be used to indicate which sort of URI is expected. + * + * URIs have an unrecognized flag. This flag is set during parsing + * if any parts of the URI are not recognized. This may be because the part is + * from a newer version of the PKCS\#11 spec or because that part was not valid + * inside of the desired context used when parsing. + */ + +/** + * P11KitUri: + * + * A structure representing a PKCS\#11 URI. There are no public fields + * visible in this structure. Use the various accessor functions. + */ + +/** + * P11KitUriType: + * @P11_KIT_URI_FOR_OBJECT: The URI represents one or more objects + * @P11_KIT_URI_FOR_TOKEN: The URI represents one or more tokens + * @P11_KIT_URI_FOR_MODULE: The URI represents one or more modules + * @P11_KIT_URI_FOR_MODULE_WITH_VERSION: The URI represents a module with + * a specific version. + * @P11_KIT_URI_FOR_OBJECT_ON_TOKEN: The URI represents one or more objects + * that are present on a specific token. + * @P11_KIT_URI_FOR_OBJECT_ON_TOKEN_AND_MODULE: The URI represents one or more + * objects that are present on a specific token, being used with a certain + * module. + * @P11_KIT_URI_FOR_ANY: The URI can represent anything + * + * A PKCS\#11 URI can represent different kinds of things. This flag is used by + * p11_kit_uri_parse() to denote in what context the URI will be used. + * + * The various types can be combined. + */ + +/** + * P11KitUriResult: + * @P11_KIT_URI_OK: Success + * @P11_KIT_URI_NO_MEMORY: Memory allocation failed + * @P11_KIT_URI_BAD_SCHEME: The URI had a bad scheme + * @P11_KIT_URI_BAD_ENCODING: The URI had a bad encoding + * @P11_KIT_URI_BAD_SYNTAX: The URI had a bad syntax + * @P11_KIT_URI_BAD_VERSION: The URI contained a bad version number + * @P11_KIT_URI_NOT_FOUND: A requested part of the URI was not found + * + * Error codes returned by various functions. The functions each clearly state + * which error codes they are capable of returning. + */ + +/** + * P11_KIT_URI_SCHEME: + * + * String of URI scheme for PKCS\#11 URIs. + */ + +/** + * P11_KIT_URI_SCHEME_LEN: + * + * Length of %P11_KIT_URI_SCHEME. + */ + +typedef struct _PinfileCallback { + /* Only used/modified within the lock */ + int refs; + + /* Readonly after construct */ + p11_kit_pin_callback func; + void *user_data; + p11_kit_pin_callback_destroy destroy; +} PinfileCallback; + +/* + * Shared data between threads, protected by the mutex, a structure so + * we can audit thread safety easier. + */ +static struct _Shared { + hash_t *pinfiles; +} gl = { NULL }; + +static void* +ref_pinfile_callback (void *pointer) +{ + PinfileCallback *cb = pointer; + cb->refs++; + return pointer; +} + +static void +unref_pinfile_callback (void *pointer) +{ + PinfileCallback *cb = pointer; + assert (cb->refs >= 1); + + cb->refs--; + if (cb->refs == 0) { + if (cb->destroy) + (cb->destroy) (cb->user_data); + free (cb); + } +} + +int +p11_kit_pin_register_callback (const char *pinfile, p11_kit_pin_callback callback, + void *callback_data, p11_kit_pin_callback_destroy callback_destroy) +{ + PinfileCallback *cb; + ptr_array_t *callbacks; + char *name; + int ret; + + cb = calloc (1, sizeof (PinfileCallback)); + if (cb == NULL) { + errno = ENOMEM; + return -1; + } + + name = strdup (pinfile); + if (name == NULL) { + free (cb); + errno = ENOMEM; + return -1; + } + + cb->refs = 1; + cb->func = callback; + cb->user_data = callback_data; + cb->destroy = callback_destroy; + + _p11_lock (); + + if (gl.pinfiles == NULL) { + gl.pinfiles = hash_create (hash_string_hash, hash_string_equal, + free, (hash_destroy_func)ptr_array_free); + if (gl.pinfiles == NULL) { + errno = ENOMEM; + ret = -1; + } + } + + if (gl.pinfiles != NULL) + callbacks = hash_get (gl.pinfiles, pinfile); + + if (callbacks == NULL) { + callbacks = ptr_array_create (unref_pinfile_callback); + if (callbacks == NULL) { + errno = ENOMEM; + ret = -1; + } else if (!hash_set (gl.pinfiles, name, callbacks)) { + ptr_array_free (callbacks); + callbacks = NULL; + errno = ENOMEM; + ret = -1; + } else { + /* Note that we've consumed the name */ + name = NULL; + } + } + + if (callbacks != NULL) { + if (ptr_array_add (callbacks, cb) < 0) { + errno = ENOMEM; + ret = -1; + } else { + /* Note that we've consumed the callback */ + cb = NULL; + } + } + + _p11_unlock (); + + /* Unless consumed above */ + free (name); + if (cb != NULL) + unref_pinfile_callback (cb); + + return ret; +} + +void +p11_kit_pin_unregister_callback (const char *pinfile, p11_kit_pin_callback callback, + void *callback_data) +{ + PinfileCallback *cb; + ptr_array_t *callbacks; + unsigned int i; + + _p11_lock (); + + if (gl.pinfiles) { + callbacks = hash_get (gl.pinfiles, pinfile); + if (callbacks) { + for (i = 0; i < ptr_array_count (callbacks); i++) { + cb = ptr_array_at (callbacks, i); + if (cb->func == callback && cb->user_data == callback_data) { + ptr_array_remove (callbacks, i); + break; + } + } + + if (ptr_array_count (callbacks) == 0) + hash_remove (gl.pinfiles, pinfile); + } + + /* When there are no more pinfiles, get rid of the hash table */ + if (hash_count (gl.pinfiles) == 0) { + hash_free (gl.pinfiles); + gl.pinfiles = NULL; + } + } + + _p11_unlock (); +} + +int +p11_kit_pin_read_pinfile (const char *pinfile, P11KitUri *pin_uri, + const char *pin_description, P11KitPinFlags flags, + char *pin, size_t pin_max) +{ + PinfileCallback **snapshot = NULL; + unsigned int snapshot_count = 0; + ptr_array_t *callbacks; + unsigned int i; + int ret; + + _p11_lock (); + + /* Find and ref the pinfile data */ + if (gl.pinfiles) { + callbacks = hash_get (gl.pinfiles, pinfile); + + /* If we didn't find any snapshots try the global ones */ + if (callbacks == NULL) + callbacks = hash_get (gl.pinfiles, P11_KIT_PIN_FALLBACK); + + if (callbacks != NULL) { + snapshot = (PinfileCallback**)ptr_array_snapshot (callbacks); + snapshot_count = ptr_array_count (callbacks); + for (i = 0; i < snapshot_count; i++) + ref_pinfile_callback (snapshot[i]); + } + } + + _p11_unlock (); + + if (snapshot == NULL) + return 0; + + for (i = 0; i < snapshot_count; i++) { + ret = (snapshot[i]->func) (pinfile, pin_uri, pin_description, flags, + snapshot[i]->user_data, pin, pin_max); + } + + _p11_lock (); + for (i = 0; i < snapshot_count; i++) + unref_pinfile_callback (snapshot[i]); + free (snapshot); + _p11_unlock (); + + return ret; +} diff --git a/p11-kit/pin.h b/p11-kit/pin.h new file mode 100644 index 0000000..780e72d --- /dev/null +++ b/p11-kit/pin.h @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2011 Collabora Ltd. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above + * copyright notice, this list of conditions and the + * following disclaimer. + * * Redistributions in binary form must reproduce the + * above copyright notice, this list of conditions and + * the following disclaimer in the documentation and/or + * other materials provided with the distribution. + * * The names of contributors to this software may not be + * used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * Author: Stef Walter + */ + +#ifndef P11_KIT_PIN_H +#define P11_KIT_PIN_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + P11_KIT_PIN_FLAGS_USER_LOGIN = 1, + P11_KIT_PIN_FLAGS_SO_LOGIN = 2, + P11_KIT_PIN_FLAGS_CONTEXT_LOGIN = 4, + P11_KIT_PIN_FLAGS_RETRY = 10, + P11_KIT_PIN_FLAGS_MANY_TRIES = 20, + P11_KIT_PIN_FLAGS_FINAL_TRY = 40 +} P11KitPinFlags; + +#define P11_KIT_PIN_FALLBACK "" + +typedef int (*p11_kit_pin_callback) (const char *pinfile, + P11KitUri *pin_uri, + const char *pin_description, + P11KitPinFlags pin_flags, + void *callback_data, + char *pin, + size_t pin_max); + +typedef void (*p11_kit_pin_callback_destroy) (void *callback_data); + +int p11_kit_pin_register_callback (const char *pinfile, + p11_kit_pin_callback callback, + void *callback_data, + p11_kit_pin_callback_destroy callback_destroy); + +void p11_kit_pin_unregister_callback (const char *pinfile, + p11_kit_pin_callback callback, + void *callback_data); + +int p11_kit_pin_read_pinfile (const char *pinfile, + P11KitUri *pin_uri, + const char *pin_description, + P11KitPinFlags pin_flags, + char *pin, + size_t pin_max); + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* P11_KIT_URI_H */ diff --git a/p11-kit/ptr-array.c b/p11-kit/ptr-array.c new file mode 100644 index 0000000..6a5ac4f --- /dev/null +++ b/p11-kit/ptr-array.c @@ -0,0 +1,150 @@ +/* + * Copyright (c) 2011 Collabora Ltd. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above + * copyright notice, this list of conditions and the + * following disclaimer. + * * Redistributions in binary form must reproduce the + * above copyright notice, this list of conditions and + * the following disclaimer in the documentation and/or + * other materials provided with the distribution. + * * The names of contributors to this software may not be + * used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + */ + +#include "config.h" + +#include "ptr-array.h" + +#include +#include + +struct ptr_array { + void **memory; + unsigned int length; + unsigned int allocated; + ptr_array_destroy_func destroy; +}; + +static int +maybe_expand_array (ptr_array_t *array, unsigned int length) +{ + unsigned int new_allocated; + void **new_memory; + + if (length <= array->allocated) + return 1; + + new_allocated = array->allocated + 16; + if (new_allocated < length) + new_allocated = length; + + new_memory = realloc (array->memory, new_allocated * sizeof (void*)); + if (new_memory == NULL) + return 0; + + array->memory = new_memory; + array->allocated = new_allocated; + return 1; +} + +ptr_array_t* +ptr_array_create (ptr_array_destroy_func destroy_func) +{ + ptr_array_t *array; + + array = calloc (1, sizeof (ptr_array_t)); + if (array == NULL) + return NULL; + + if (!maybe_expand_array (array, 2)) { + ptr_array_free (array); + return NULL; + } + + array->destroy = destroy_func; + return array; +} + +void +ptr_array_free (ptr_array_t *array) +{ + unsigned int i; + + if (array == NULL) + return; + + if (array->destroy) { + for (i = 0; i < array->length; i++) + (array->destroy) (array->memory[i]); + } + + free (array->memory); + free (array); +} + +unsigned int +ptr_array_count (ptr_array_t *array) +{ + return array->length; +} + +int +ptr_array_add (ptr_array_t *array, void *value) +{ + if (!maybe_expand_array (array, array->length + 1)) + return 0; + + array->memory[array->length] = value; + array->length++; + return 1; +} + +void +ptr_array_remove (ptr_array_t *array, unsigned int index) +{ + if (array->destroy) + (array->destroy) (array->memory[index]); + memmove (array->memory + index, array->memory + index + 1, + (array->length - (index + 1)) * sizeof (void*)); + array->length--; +} + +void* +ptr_array_at (ptr_array_t *array, unsigned int index) +{ + return array->memory[index]; +} + +void** +ptr_array_snapshot (ptr_array_t *array) +{ + void **snapshot; + size_t bytes; + + bytes = array->length * sizeof (void*); + snapshot = malloc (bytes); + if (!snapshot) + return NULL; + + memcpy (snapshot, array->memory, bytes); + return snapshot; +} diff --git a/p11-kit/ptr-array.h b/p11-kit/ptr-array.h new file mode 100644 index 0000000..acd894d --- /dev/null +++ b/p11-kit/ptr-array.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2011 Collabora Ltd. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above + * copyright notice, this list of conditions and the + * following disclaimer. + * * Redistributions in binary form must reproduce the + * above copyright notice, this list of conditions and + * the following disclaimer in the documentation and/or + * other materials provided with the distribution. + * * The names of contributors to this software may not be + * used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * Author: Stef Waler + */ + +#ifndef __PTR_ARRAY_H__ +#define __PTR_ARRAY_H__ + +#include + +typedef struct ptr_array ptr_array_t; + +typedef void (*ptr_array_destroy_func) (void *data); + +ptr_array_t* ptr_array_create (ptr_array_destroy_func destroy_func); + +void ptr_array_free (ptr_array_t *array); + +unsigned int ptr_array_count (ptr_array_t *array); + +int ptr_array_add (ptr_array_t *array, + void *value); + +void ptr_array_remove (ptr_array_t *array, + unsigned int index); + +void* ptr_array_at (ptr_array_t *array, + unsigned int index); + +void** ptr_array_snapshot (ptr_array_t *array); + +#endif /* __PTR_ARRAY_H__ */ diff --git a/tests/Makefile.am b/tests/Makefile.am index 6b988b8..cde804f 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -8,22 +8,32 @@ INCLUDES = \ noinst_PROGRAMS = \ hash-test \ + ptr-array-test \ conf-test \ - uri-test + uri-test \ + pin-test hash_test_LDADD = \ $(top_builddir)/p11-kit/libp11-kit-testable.la +ptr_array_test_LDADD = \ + $(top_builddir)/p11-kit/libp11-kit-testable.la + conf_test_LDADD = \ $(top_builddir)/p11-kit/libp11-kit-testable.la uri_test_LDADD = \ $(top_builddir)/p11-kit/libp11-kit-testable.la +pin_test_LDADD = \ + $(top_builddir)/p11-kit/libp11-kit-testable.la + check-am: ./hash-test + ./ptr-array-test ./conf-test ./uri-test + ./pin-test EXTRA_DIST = \ cutest \ diff --git a/tests/pin-test.c b/tests/pin-test.c new file mode 100644 index 0000000..7f1bc08 --- /dev/null +++ b/tests/pin-test.c @@ -0,0 +1,237 @@ +/* + * Copyright (c) 2011, Collabora Ltd. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above + * copyright notice, this list of conditions and the + * following disclaimer. + * * Redistributions in binary form must reproduce the + * above copyright notice, this list of conditions and + * the following disclaimer in the documentation and/or + * other materials provided with the distribution. + * * The names of contributors to this software may not be + * used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * Author: Stef Walter + */ + +#include "config.h" +#include "CuTest.h" + +#include +#include +#include +#include + +#include "p11-kit/pin.h" + +static int +callback_one (const char *pinfile, P11KitUri *pin_uri, const char *pin_description, + P11KitPinFlags pin_flags, void *callback_data, char *pin, + size_t pin_max) +{ + int *data = callback_data; + assert (*data == 33); + strncpy (pin, "one", pin_max); + return 1; +} + +static int +callback_other (const char *pinfile, P11KitUri *pin_uri, const char *pin_description, + P11KitPinFlags pin_flags, void *callback_data, char *pin, + size_t pin_max) +{ + char *data = callback_data; + strncpy (pin, data, pin_max); + return 1; +} + +static void +destroy_data (void *callback_data) +{ + int *data = callback_data; + (*data)++; +} + +static void +test_pin_register_unregister (CuTest *tc) +{ + int data = 33; + + p11_kit_pin_register_callback ("/the/pinfile", callback_one, + &data, destroy_data); + + p11_kit_pin_unregister_callback ("/the/pinfile", callback_one, + &data); + + CuAssertIntEquals (tc, 34, data); +} + +static void +test_pin_read (CuTest *tc) +{ + P11KitUri *uri; + char buffer[256]; + int data = 33; + int ret; + + p11_kit_pin_register_callback ("/the/pinfile", callback_one, + &data, destroy_data); + + uri = p11_kit_uri_new (); + ret = p11_kit_pin_read_pinfile ("/the/pinfile", uri, "The token", + P11_KIT_PIN_FLAGS_USER_LOGIN, + buffer, sizeof (buffer)); + p11_kit_uri_free (uri); + + CuAssertIntEquals (tc, 1, ret); + CuAssertStrEquals (tc, "one", buffer); + + p11_kit_pin_unregister_callback ("/the/pinfile", callback_one, + &data); +} + +static void +test_pin_read_no_match (CuTest *tc) +{ + P11KitUri *uri; + char buffer[256]; + int ret; + + uri = p11_kit_uri_new (); + ret = p11_kit_pin_read_pinfile ("/the/pinfile", uri, "The token", + P11_KIT_PIN_FLAGS_USER_LOGIN, + buffer, sizeof (buffer)); + p11_kit_uri_free (uri); + + CuAssertIntEquals (tc, 0, ret); +} + +static void +test_pin_register_duplicate (CuTest *tc) +{ + P11KitUri *uri; + char *value = "secret"; + char buffer[256]; + int data = 33; + int ret; + + uri = p11_kit_uri_new (); + + p11_kit_pin_register_callback ("/the/pinfile", callback_one, + &data, destroy_data); + + p11_kit_pin_register_callback ("/the/pinfile", callback_other, + value, NULL); + + ret = p11_kit_pin_read_pinfile ("/the/pinfile", uri, "The token", + P11_KIT_PIN_FLAGS_USER_LOGIN, + buffer, sizeof (buffer)); + + CuAssertIntEquals (tc, 1, ret); + CuAssertStrEquals (tc, "secret", buffer); + + p11_kit_pin_unregister_callback ("/the/pinfile", callback_other, + value); + + ret = p11_kit_pin_read_pinfile ("/the/pinfile", uri, "The token", + P11_KIT_PIN_FLAGS_USER_LOGIN, + buffer, sizeof (buffer)); + + CuAssertIntEquals (tc, 1, ret); + CuAssertStrEquals (tc, "one", buffer); + + p11_kit_pin_unregister_callback ("/the/pinfile", callback_one, + &data); + + ret = p11_kit_pin_read_pinfile ("/the/pinfile", uri, "The token", + P11_KIT_PIN_FLAGS_USER_LOGIN, + buffer, sizeof (buffer)); + + CuAssertIntEquals (tc, 0, ret); + + p11_kit_uri_free (uri); +} + +static void +test_pin_register_fallback (CuTest *tc) +{ + char *value = "secret"; + P11KitUri *uri; + char buffer[256]; + int data = 33; + int ret; + + uri = p11_kit_uri_new (); + + p11_kit_pin_register_callback (P11_KIT_PIN_FALLBACK, callback_one, + &data, destroy_data); + + ret = p11_kit_pin_read_pinfile ("/the/pinfile", uri, "The token", + P11_KIT_PIN_FLAGS_USER_LOGIN, + buffer, sizeof (buffer)); + + CuAssertIntEquals (tc, 1, ret); + CuAssertStrEquals (tc, "one", buffer); + + p11_kit_pin_register_callback ("/the/pinfile", callback_other, + value, NULL); + + ret = p11_kit_pin_read_pinfile ("/the/pinfile", uri, "The token", + P11_KIT_PIN_FLAGS_USER_LOGIN, + buffer, sizeof (buffer)); + + CuAssertIntEquals (tc, 1, ret); + CuAssertStrEquals (tc, "secret", buffer); + + p11_kit_pin_unregister_callback ("/the/pinfile", callback_other, + value); + + p11_kit_pin_unregister_callback (P11_KIT_PIN_FALLBACK, callback_one, + &data); + + p11_kit_uri_free (uri); +} + +int +main (void) +{ + CuString *output = CuStringNew (); + CuSuite* suite = CuSuiteNew (); + int ret; + + SUITE_ADD_TEST (suite, test_pin_register_unregister); + SUITE_ADD_TEST (suite, test_pin_read); + SUITE_ADD_TEST (suite, test_pin_read_no_match); + SUITE_ADD_TEST (suite, test_pin_register_duplicate); + SUITE_ADD_TEST (suite, test_pin_register_fallback); + + CuSuiteRun (suite); + CuSuiteSummary (suite, output); + CuSuiteDetails (suite, output); + printf ("%s\n", output->buffer); + ret = suite->failCount; + CuSuiteDelete (suite); + CuStringDelete (output); + + return ret; +} + +#include "CuTest.c" diff --git a/tests/ptr-array-test.c b/tests/ptr-array-test.c new file mode 100644 index 0000000..ff9959d --- /dev/null +++ b/tests/ptr-array-test.c @@ -0,0 +1,259 @@ +/* + * Copyright (c) 2011, Collabora Ltd. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above + * copyright notice, this list of conditions and the + * following disclaimer. + * * Redistributions in binary form must reproduce the + * above copyright notice, this list of conditions and + * the following disclaimer in the documentation and/or + * other materials provided with the distribution. + * * The names of contributors to this software may not be + * used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * Author: Stef Walter + */ + +#include "config.h" +#include "CuTest.h" + +#include +#include +#include + +#include "ptr-array.h" + +static void +test_ptr_array_create (CuTest *tc) +{ + ptr_array_t *array; + + array = ptr_array_create (NULL); + CuAssertPtrNotNull (tc, array); + ptr_array_free (array); +} + +static void +test_ptr_array_free_null (CuTest *tc) +{ + ptr_array_free (NULL); +} + +static void +destroy_value (void *data) +{ + int *value = data; + *value = 2; +} + +static void +test_ptr_array_free_destroys (CuTest *tc) +{ + ptr_array_t *array; + int value = 0; + + array = ptr_array_create (destroy_value); + CuAssertPtrNotNull (tc, array); + if (!ptr_array_add (array, &value)) + CuFail (tc, "should not be reached"); + ptr_array_free (array); + + CuAssertIntEquals (tc, 2, value); +} + +#if 0 +static void +test_hash_iterate (CuTest *tc) +{ + hash_t *ht; + hash_iter_t hi; + int key = 1; + int value = 2; + void *pkey; + void *pvalue; + int ret; + + ht = hash_create (hash_direct_hash, hash_direct_equal, NULL, NULL); + CuAssertPtrNotNull (tc, ht); + if (!hash_set (ht, &key, &value)) + CuFail (tc, "should not be reached"); + + hash_iterate (ht, &hi); + + ret = hash_next (&hi, &pkey, &pvalue); + CuAssertIntEquals (tc, 1, ret); + CuAssertPtrEquals (tc, pkey, &key); + CuAssertPtrEquals (tc, pvalue, &value); + + ret = hash_next (&hi, &pkey, &pvalue); + CuAssertIntEquals (tc, 0, ret); + + hash_free (ht); +} + +#endif + +static void +test_ptr_array_add (CuTest *tc) +{ + char *value = "VALUE"; + char *check; + ptr_array_t *array; + + array = ptr_array_create (NULL); + if (!ptr_array_add (array, value)) + CuFail (tc, "should not be reached"); + + CuAssertIntEquals (tc, 1, ptr_array_count (array)); + + check = ptr_array_at (array, 0); + CuAssertPtrEquals (tc, check, value); + + ptr_array_free (array); +} + +static void +test_ptr_array_add_remove (CuTest *tc) +{ + char *value = "VALUE"; + char *check; + ptr_array_t *array; + + array = ptr_array_create (NULL); + if (!ptr_array_add (array, value)) + CuFail (tc, "should not be reached"); + + CuAssertIntEquals (tc, 1, ptr_array_count (array)); + + check = ptr_array_at (array, 0); + CuAssertPtrEquals (tc, check, value); + + ptr_array_remove (array, 0); + + CuAssertIntEquals (tc, 0, ptr_array_count (array)); + + ptr_array_free (array); +} + +static void +test_ptr_array_remove_destroys (CuTest *tc) +{ + ptr_array_t *array; + int value = 0; + + array = ptr_array_create (destroy_value); + if (!ptr_array_add (array, &value)) + CuFail (tc, "should not be reached"); + + ptr_array_remove (array, 0); + + CuAssertIntEquals (tc, 2, value); + + /* should not be destroyed again */ + value = 0; + + ptr_array_free (array); + + CuAssertIntEquals (tc, 0, value); +} + +static void +test_ptr_array_remove_and_count (CuTest *tc) +{ + ptr_array_t *array; + int *value; + int i; + + array = ptr_array_create (free); + + CuAssertIntEquals (tc, 0, ptr_array_count (array)); + + for (i = 0; i < 20000; ++i) { + value = malloc (sizeof (int)); + *value = i; + if (!ptr_array_add (array, value)) + CuFail (tc, "should not be reached"); + CuAssertIntEquals (tc, i + 1, ptr_array_count (array)); + } + + for (i = 10; i < 20000; ++i) { + ptr_array_remove (array, 10); + CuAssertIntEquals (tc, 20010 - (i + 1), ptr_array_count (array)); + } + + CuAssertIntEquals (tc, 10, ptr_array_count (array)); + + ptr_array_free (array); +} + +static void +test_ptr_array_snapshot (CuTest *tc) +{ + ptr_array_t *array; + void **snapshot; + + array = ptr_array_create (NULL); + + ptr_array_add (array, "1"); + ptr_array_add (array, "2"); + ptr_array_add (array, "3"); + ptr_array_add (array, "4"); + CuAssertIntEquals (tc, 4, ptr_array_count (array)); + + snapshot = ptr_array_snapshot (array); + + CuAssertStrEquals (tc, "1", snapshot[0]); + CuAssertStrEquals (tc, "2", snapshot[1]); + CuAssertStrEquals (tc, "3", snapshot[2]); + CuAssertStrEquals (tc, "4", snapshot[3]); + + free (snapshot); + ptr_array_free (array); +} + +int +main (void) +{ + CuString *output = CuStringNew (); + CuSuite* suite = CuSuiteNew (); + int ret; + + SUITE_ADD_TEST (suite, test_ptr_array_create); + SUITE_ADD_TEST (suite, test_ptr_array_add); + SUITE_ADD_TEST (suite, test_ptr_array_add_remove); + SUITE_ADD_TEST (suite, test_ptr_array_remove_destroys); + SUITE_ADD_TEST (suite, test_ptr_array_remove_and_count); + SUITE_ADD_TEST (suite, test_ptr_array_free_null); + SUITE_ADD_TEST (suite, test_ptr_array_free_destroys); + SUITE_ADD_TEST (suite, test_ptr_array_snapshot); + + CuSuiteRun (suite); + CuSuiteSummary (suite, output); + CuSuiteDetails (suite, output); + printf ("%s\n", output->buffer); + ret = suite->failCount; + CuSuiteDelete (suite); + CuStringDelete (output); + + return ret; +} + +#include "CuTest.c" -- cgit v1.1