/*

 * 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 <stefw@collabora.co.uk>

 */

#include "config.h"

#include "array.h"

#include "attrs.h"

#include "buffer.h"

#define P11_DEBUG_FLAG P11_DEBUG_URI

#include "debug.h"

#include "message.h"

#include "pkcs11.h"

#include "private.h"

#include "p11-kit.h"

#include "uri.h"

#include "url.h"

#include <assert.h>

#include <ctype.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

/**

 * SECTION:p11-kit-uri

 * @title: URIs

 * @short_description: Parsing and formatting PKCS\#11 URIs

 *

 * 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:

 *

 * <literallayout>

 *      pkcs11:token=The\%20Software\%20PKCS\#11\%20softtoken;

 *          manufacturer=Snake\%20Oil,\%20Inc.;serial=;object=my-certificate;

 *          model=1.0;type=cert;id=\%69\%95\%3e\%5c\%f4\%bd\%ec\%91

 * </literallayout>

 *

 * 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_SLOT: The URI represents one or more slots

 * @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_UNEXPECTED: Unexpected or internal system error

 * @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_NO_MEMORY:

 *

 * Unexpected memory allocation failure result. Same as #P11_KIT_URI_UNEXPECTED.

 */

/**

 * 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 _Attribute {

	char *name;

	char *value;

} Attribute;

struct p11_kit_uri {

	bool unrecognized;

	CK_INFO module;

	CK_SLOT_INFO slot;

	CK_TOKEN_INFO token;

	CK_ATTRIBUTE *attrs;

	CK_SLOT_ID slot_id;

	char *pin_source;

	char *pin_value;

	char *module_name;

	char *module_path;

	p11_array *qattrs;

};

static char *

strip_whitespace (const char *value)

{

	size_t length = strlen (value);

	char *at, *pos;

	char *key;

	key = malloc (length + 1);

	return_val_if_fail (key != NULL, NULL);

	memcpy (key, value, length);

	key[length] = '\0';

	/* Do we have any whitespace? Strip it out. */

	if (strcspn (key, P11_URL_WHITESPACE) != length) {

		for (at = key, pos = key; pos != key + length + 1; ++pos) {

			if (!strchr (P11_URL_WHITESPACE, *pos))

				*(at++) = *pos;

		}

		*at = '\0';

	}

	return key;

}

static bool

match_struct_string (const unsigned char *inuri, const unsigned char *real,

                     size_t length)

{

	assert (inuri);

	assert (real);

	assert (length > 0);

	/* NULL matches anything */

	if (inuri[0] == 0)

		return true;

	return memcmp (inuri, real, length) == 0 ? true : false;

}

static bool

match_struct_version (CK_VERSION const *inuri, CK_VERSION const *real)

{

	/* This matches anything */

	if (inuri->major == (CK_BYTE)-1 && inuri->minor == (CK_BYTE)-1)

		return true;

	return memcmp (inuri, real, sizeof (CK_VERSION)) == 0 ? true : false;

}

/**

 * p11_kit_uri_get_module_info:

 * @uri: the URI

 *

 * Get the CK_INFO structure associated with this URI.

 *

 * If this is a parsed URI, then the fields corresponding to library parts of

 * the URI will be filled in. Any library URI parts that were missing will have

 * their fields filled with zeros.

 *

 * If the caller wishes to setup information for building a URI, then relevant

 * fields should be filled in. Fields that should not appear as parts in the

 * resulting URI should be filled with zeros.

 *

 * Returns: A pointer to the CK_INFO structure.

 */

CK_INFO_PTR

p11_kit_uri_get_module_info (P11KitUri *uri)

{

	return_val_if_fail (uri != NULL, NULL);

	return &uri->module;

}

int

p11_match_uri_module_info (CK_INFO const *one,

                           CK_INFO const *two)

{

	return (match_struct_string (one->libraryDescription,

	                             two->libraryDescription,

	                             sizeof (one->libraryDescription)) &&

	        match_struct_string (one->manufacturerID,

	                             two->manufacturerID,

	                             sizeof (one->manufacturerID)) &&

	        match_struct_version (&one->libraryVersion,

	                              &two->libraryVersion));

}

/**

 * p11_kit_uri_match_module_info:

 * @uri: the URI

 * @info: the structure to match against the URI

 *

 * Match a CK_INFO structure against the library parts of this URI.

 *

 * Only the fields of the CK_INFO structure that are valid for use

 * in a URI will be matched. A URI part that was not specified in the URI will

 * match any value in the structure. If during the URI parsing any unrecognized

 * parts were encountered then this match will fail.

 *

 * Returns: 1 if the URI matches, 0 if not.

 */

int

p11_kit_uri_match_module_info (const P11KitUri *uri, const CK_INFO *info)

{

	return_val_if_fail (uri != NULL, 0);

	return_val_if_fail (info != NULL, 0);

	if (uri->unrecognized)

		return 0;

	return p11_match_uri_module_info (&uri->module, info);

}

/**

 * p11_kit_uri_get_slot_info:

 * @uri: the URI

 *

 * Get the CK_SLOT_INFO structure associated with this URI.

 *

 * If this is a parsed URI, then the fields corresponding to slot parts of

 * the URI will be filled in. Any slot URI parts that were missing will have

 * their fields filled with zeros.

 *

 * If the caller wishes to setup information for building a URI, then relevant

 * fields should be filled in. Fields that should not appear as parts in the

 * resulting URI should be filled with zeros.

 *

 * Returns: A pointer to the CK_INFO structure.

 */

CK_SLOT_INFO_PTR

p11_kit_uri_get_slot_info (P11KitUri *uri)

{

	return_val_if_fail (uri != NULL, NULL);

	return &uri->slot;

}

int

p11_match_uri_slot_info (CK_SLOT_INFO const *one,

                         CK_SLOT_INFO const *two)

{

	return (match_struct_string (one->slotDescription,

				     two->slotDescription,

				     sizeof (one->slotDescription)) &&

		match_struct_string (one->manufacturerID,

				     two->manufacturerID,

				     sizeof (one->manufacturerID)));

}

/**

 * p11_kit_uri_match_slot_info:

 * @uri: the URI

 * @slot_info: the structure to match against the URI

 *

 * Match a CK_SLOT_INFO structure against the slot parts of this

 * URI.

 *

 * Only the fields of the CK_SLOT_INFO structure that are valid

 * for use in a URI will be matched. A URI part that was not specified in the

 * URI will match any value in the structure. If during the URI parsing any

 * unrecognized parts were encountered then this match will fail.

 *

 * Returns: 1 if the URI matches, 0 if not.

 */

int

p11_kit_uri_match_slot_info (const P11KitUri *uri, const CK_SLOT_INFO *slot_info)

{

	return_val_if_fail (uri != NULL, 0);

	return_val_if_fail (slot_info != NULL, 0);

	if (uri->unrecognized)

		return 0;

	return p11_match_uri_slot_info (&uri->slot, slot_info);

}

/**

 * p11_kit_uri_get_slot_id:

 * @uri: The URI

 *

 * Get the 'slot-id' part of the URI.

 *

 * Returns: The slot-id or (CK_SLOT_ID)-1 if not set.

 */

CK_SLOT_ID

p11_kit_uri_get_slot_id (P11KitUri *uri)

{

	return_val_if_fail (uri != NULL, (CK_SLOT_ID)-1);

	return uri->slot_id;

}

/**

 * p11_kit_uri_set_slot_id:

 * @uri: The URI

 * @slot_id: The new slot-id

 *

 * Set the 'slot-id' part of the URI.

 */

void

p11_kit_uri_set_slot_id (P11KitUri  *uri,

			 CK_SLOT_ID  slot_id)

{

	return_if_fail (uri != NULL);

	uri->slot_id = slot_id;

}

/**

 * p11_kit_uri_get_token_info:

 * @uri: the URI

 *

 * Get the CK_TOKEN_INFO structure associated with this URI.

 *

 * If this is a parsed URI, then the fields corresponding to token parts of

 * the URI will be filled in. Any token URI parts that were missing will have

 * their fields filled with zeros.

 *

 * If the caller wishes to setup information for building a URI, then relevant

 * fields should be filled in. Fields that should not appear as parts in the

 * resulting URI should be filled with zeros.

 *

 * Returns: A pointer to the CK_INFO structure.

 */

CK_TOKEN_INFO_PTR

p11_kit_uri_get_token_info (P11KitUri *uri)

{

	return_val_if_fail (uri != NULL, NULL);

	return &uri->token;

}

int

p11_match_uri_token_info (CK_TOKEN_INFO const *one,

                          CK_TOKEN_INFO const *two)

{

	return (match_struct_string (one->label,

	                             two->label,

	                             sizeof (one->label)) &&

	        match_struct_string (one->manufacturerID,

	                             two->manufacturerID,

	                             sizeof (one->manufacturerID)) &&

	        match_struct_string (one->model,

	                             two->model,

	                             sizeof (one->model)) &&

	        match_struct_string (one->serialNumber,

	                             two->serialNumber,

	                             sizeof (one->serialNumber)));

}

/**

 * p11_kit_uri_match_token_info:

 * @uri: the URI

 * @token_info: the structure to match against the URI

 *

 * Match a CK_TOKEN_INFO structure against the token parts of this

 * URI.

 *

 * Only the fields of the CK_TOKEN_INFO structure that are valid

 * for use in a URI will be matched. A URI part that was not specified in the

 * URI will match any value in the structure. If during the URI parsing any

 * unrecognized parts were encountered then this match will fail.

 *

 * Returns: 1 if the URI matches, 0 if not.

 */

int

p11_kit_uri_match_token_info (const P11KitUri *uri, const CK_TOKEN_INFO *token_info)

{

	return_val_if_fail (uri != NULL, 0);

	return_val_if_fail (token_info != NULL, 0);

	if (uri->unrecognized)

		return 0;

	return p11_match_uri_token_info (&uri->token, token_info);

}

/**

 * p11_kit_uri_get_attribute:

 * @uri: The URI

 * @attr_type: The attribute type

 *

 * Get a pointer to an attribute present in this URI.

 *

 * Returns: A pointer to the attribute, or NULL if not present.

 *     The attribute is owned by the URI and should not be freed.

 */

CK_ATTRIBUTE_PTR

p11_kit_uri_get_attribute (P11KitUri *uri, CK_ATTRIBUTE_TYPE attr_type)

{

	return_val_if_fail (uri != NULL, NULL);

	if (uri->attrs == NULL)

		return NULL;

	return p11_attrs_find (uri->attrs, attr_type);

}

/**

 * p11_kit_uri_set_attribute:

 * @uri: The URI

 * @attr: The attribute to set

 *

 * Set an attribute on the URI.

 *

 * Only attributes that map to parts in a PKCS\#11 URI will be accepted.

 *

 * Returns: %P11_KIT_URI_OK if the attribute was successfully set.

 *     %P11_KIT_URI_NOT_FOUND if the attribute was not valid for a URI.

 */

int

p11_kit_uri_set_attribute (P11KitUri *uri, CK_ATTRIBUTE_PTR attr)

{

	return_val_if_fail (uri != NULL, P11_KIT_URI_UNEXPECTED);

	uri->attrs = p11_attrs_buildn (uri->attrs, attr, 1);

	return_val_if_fail (uri->attrs != NULL, P11_KIT_URI_UNEXPECTED);

	return P11_KIT_URI_OK;

}

/**

 * p11_kit_uri_clear_attribute:

 * @uri: The URI

 * @attr_type: The type of the attribute to clear

 *

 * Clear an attribute on the URI.

 *

 * Only attributes that map to parts in a PKCS\#11 URI will be accepted.

 *

 * Returns: %P11_KIT_URI_OK if the attribute was successfully cleared.

 *     %P11_KIT_URI_NOT_FOUND if the attribute was not valid for a URI.

 */

int

p11_kit_uri_clear_attribute (P11KitUri *uri, CK_ATTRIBUTE_TYPE attr_type)

{

	return_val_if_fail (uri != NULL, P11_KIT_URI_UNEXPECTED);

	if (attr_type != CKA_CLASS &&

	    attr_type != CKA_LABEL &&

	    attr_type != CKA_ID)

		return P11_KIT_URI_NOT_FOUND;

	if (uri->attrs)

		p11_attrs_remove (uri->attrs, attr_type);

	return P11_KIT_URI_OK;

}

/**

 * p11_kit_uri_get_attribute_types:

 * @uri: The URI

 * @n_attrs: A location to store the number of attributes returned.

 *

 * Get the attributes present in this URI. The attributes and values are

 * owned by the URI. If the URI is modified, then the attributes that were

 * returned from this function will not remain consistent.

 *

 * Returns: The attributes for this URI. These are owned by the URI.

 */

CK_ATTRIBUTE_PTR

p11_kit_uri_get_attributes (P11KitUri *uri, CK_ULONG_PTR n_attrs)

{

	static const CK_ATTRIBUTE terminator = { CKA_INVALID, NULL, 0UL };

	return_val_if_fail (uri != NULL, NULL);

	if (!uri->attrs) {

		if (n_attrs)

			*n_attrs = 0;

		return (CK_ATTRIBUTE_PTR)&terminator;

	}

	if (n_attrs)

		*n_attrs = p11_attrs_count (uri->attrs);

	return uri->attrs;

}

int

p11_kit_uri_set_attributes (P11KitUri *uri, CK_ATTRIBUTE_PTR attrs,

                            CK_ULONG n_attrs)

{

	CK_ULONG i;

	int ret;

	return_val_if_fail (uri != NULL, P11_KIT_URI_UNEXPECTED);

	p11_kit_uri_clear_attributes (uri);

	for (i = 0; i < n_attrs; i++) {

		ret = p11_kit_uri_set_attribute (uri, &attrs[i]);

		if (ret != P11_KIT_URI_OK && ret != P11_KIT_URI_NOT_FOUND)

			return ret;

	}

	return P11_KIT_URI_OK;

}

void

p11_kit_uri_clear_attributes (P11KitUri *uri)

{

	return_if_fail (uri != NULL);

	p11_attrs_free (uri->attrs);

	uri->attrs = NULL;

}

/**

 * p11_kit_uri_match_attributes:

 * @uri: The URI

 * @attrs: The attributes to match

 * @n_attrs: The number of attributes

 *

 * Match a attributes against the object parts of this URI.

 *

 * Only the attributes that are valid for use in a URI will be matched. A URI

 * part that was not specified in the URI will match any attribute value. If

 * during the URI parsing any unrecognized parts were encountered then this

 * match will fail.

 *

 * Returns: 1 if the URI matches, 0 if not.

 */

int

p11_kit_uri_match_attributes (const P11KitUri *uri, const CK_ATTRIBUTE *attrs,

                              CK_ULONG n_attrs)

{

	CK_ATTRIBUTE *attr;

	CK_ULONG i;

	return_val_if_fail (uri != NULL, 0);

	return_val_if_fail (attrs != NULL || n_attrs == 0, 0);

	if (uri->unrecognized)

		return 0;

	for (i = 0; i < n_attrs; i++) {

		if (attrs[i].type != CKA_CLASS &&

		    attrs[i].type != CKA_LABEL &&

		    attrs[i].type != CKA_ID)

			continue;

		attr = NULL;

		if (uri->attrs)

			attr = p11_attrs_find (uri->attrs, attrs[i].type);

		if (!attr)

			continue;

		if (!p11_attr_equal (attr, attrs + i))

			return 0;

	}

	return 1;

}

/**

 * p11_kit_uri_set_unrecognized:

 * @uri: The URI

 * @unrecognized: The new unregognized flag value

 *

 * Set the unrecognized flag on this URI.

 *

 * The unrecognized flag is automatically set to 1 when during parsing any part

 * of the URI is unrecognized. If the unrecognized flag is set to 1, then

 * matching against this URI will always fail.

 */

void

p11_kit_uri_set_unrecognized (P11KitUri *uri, int unrecognized)

{

	return_if_fail (uri != NULL);

	uri->unrecognized = unrecognized ? true : false;

}

/**

 * p11_kit_uri_any_unrecognized:

 * @uri: The URI

 *

 * Get the unrecognized flag for this URI.

 *

 * The unrecognized flag is automatically set to 1 when during parsing any part

 * of the URI is unrecognized. If the unrecognized flag is set to 1, then

 * matching against this URI will always fail.

 *

 * Returns: 1 if unrecognized flag is set, 0 otherwise.

 */

int

p11_kit_uri_any_unrecognized (P11KitUri *uri)

{

	return_val_if_fail (uri != NULL, 1);

	return uri->unrecognized;

}

/**

 * p11_kit_uri_get_pin_value:

 * @uri: The URI

 *

 * Get the 'pin-value' part of the URI. This is used by some applications to

 * read the PIN for logging into a PKCS\#11 token.

 *

 * Returns: The pin-value or %NULL if not present.

 */

const char*

p11_kit_uri_get_pin_value (const P11KitUri *uri)

{

	return_val_if_fail (uri != NULL, NULL);

	return uri->pin_value;

}

/**

 * p11_kit_uri_set_pin_value:

 * @uri: The URI

 * @pin: The new pin-value

 *

 * Set the 'pin-value' part of the URI. This is used by some applications to

 * specify the PIN for logging into a PKCS\#11 token.

 */

void

p11_kit_uri_set_pin_value (P11KitUri *uri, const char *pin)

{

	return_if_fail (uri != NULL);

	free (uri->pin_value);

	uri->pin_value = pin ? strdup (pin) : NULL;

}

/**

 * p11_kit_uri_get_pin_source:

 * @uri: The URI

 *

 * Get the 'pin-source' part of the URI. This is used by some applications to

 * lookup a PIN for logging into a PKCS\#11 token.

 *

 * Returns: The pin-source or %NULL if not present.

 */

const char*

p11_kit_uri_get_pin_source (const P11KitUri *uri)

{

	return_val_if_fail (uri != NULL, NULL);

	return uri->pin_source;

}

/**

 * p11_kit_uri_get_pinfile:

 * @uri: The URI

 *

 * Deprecated: use p11_kit_uri_get_pin_source().

 */

const char*

p11_kit_uri_get_pinfile (const P11KitUri *uri)

{

	return_val_if_fail (uri != NULL, NULL);

	return p11_kit_uri_get_pin_source (uri);

}

/**

 * p11_kit_uri_set_pin_source:

 * @uri: The URI

 * @pin_source: The new pin-source

 *

 * Set the 'pin-source' part of the URI. This is used by some applications to

 * lookup a PIN for logging into a PKCS\#11 token.

 */

void

p11_kit_uri_set_pin_source (P11KitUri *uri, const char *pin_source)

{

	return_if_fail (uri != NULL);

	free (uri->pin_source);

	uri->pin_source = pin_source ? strdup (pin_source) : NULL;

}

/**

 * p11_kit_uri_set_pinfile:

 * @uri: The URI

 * @pinfile: The pinfile

 *

 * Deprecated: use p11_kit_uri_set_pin_source().

 */

void

p11_kit_uri_set_pinfile (P11KitUri *uri, const char *pinfile)

{

	return_if_fail (uri != NULL);

	p11_kit_uri_set_pin_source (uri, pinfile);

}

/**

 * p11_kit_uri_get_module_name:

 * @uri: The URI

 *

 * Get the 'module-name' part of the URI. This is used by some

 * applications to explicitly specify the name of a PKCS\#11 module.

 *

 * Returns: The module-name or %NULL if not present.

 */

const char*

p11_kit_uri_get_module_name (const P11KitUri *uri)

{

	return_val_if_fail (uri != NULL, NULL);

	return uri->module_name;

}

/**

 * p11_kit_uri_set_module_name:

 * @uri: The URI

 * @name: The new module-name

 *

 * Set the 'module-name' part of the URI. This is used by some

 * applications to explicitly specify the name of a PKCS\#11 module.

 */

void

p11_kit_uri_set_module_name (P11KitUri *uri, const char *name)

{

	return_if_fail (uri != NULL);

	free (uri->module_name);

	uri->module_name = name ? strdup (name) : NULL;

}

/**

 * p11_kit_uri_get_module_path:

 * @uri: The URI

 *

 * Get the 'module-path' part of the URI. This is used by some

 * applications to explicitly specify the path of a PKCS\#11 module.

 *

 * Returns: The module-path or %NULL if not present.

 */

const char*

p11_kit_uri_get_module_path (const P11KitUri *uri)

{

	return_val_if_fail (uri != NULL, NULL);

	return uri->module_path;

}

/**

 * p11_kit_uri_set_module_path:

 * @uri: The URI

 * @path: The new module-path

 *

 * Set the 'module-path' part of the URI. This is used by some

 * applications to explicitly specify the path of a PKCS\#11 module.

 */

void

p11_kit_uri_set_module_path (P11KitUri *uri, const char *path)

{

	return_if_fail (uri != NULL);

	free (uri->module_path);

	uri->module_path = path ? strdup (path) : NULL;

}

/**

 * p11_kit_uri_get_vendor_query:

 * @uri: The URI

 * @name: The name of vendor query

 *

 * Get the vendor query part of the URI, identified by @name. This is

 * used by some applications to explicitly specify the path of a

 * PKCS\#11 module.

 *

 * Returns: The value of vendor query or %NULL if not present.

 */

const char*

p11_kit_uri_get_vendor_query (const P11KitUri *uri, const char *name)

{

	size_t i;

	return_val_if_fail (uri != NULL, NULL);

	for (i = 0; i < uri->qattrs->num; i++) {

		Attribute *attr = uri->qattrs->elem[i];

		if (strcmp (attr->name, name) == 0)

			return attr->value;

	}

	return NULL;

}

static void

free_attribute (Attribute *attr)

{

	free (attr->name);

	free (attr->value);

	free (attr);

}

static bool

insert_attribute (p11_array *attrs, char *name, char *value)

{

	Attribute *attr;

	size_t i;

	return_val_if_fail (attrs != NULL, false);

	return_val_if_fail (name != NULL, false);

	return_val_if_fail (value != NULL, false);

	for (i = 0; i < attrs->num; i++) {

		attr = attrs->elem[i];

		if (strcmp (attr->name, (char *)name) > 0)

			break;

	}

	attr = calloc (1, sizeof (Attribute));

	return_val_if_fail (attr, false);

	attr->name = name;

	attr->value = value;

	return p11_array_insert (attrs, i, attr);

}

/**

 * p11_kit_uri_set_vendor_query:

 * @uri: The URI

 * @name: The name of vendor query

 * @value: (allow-none): The value of vendor query

 *

 * Set the vendor query part of the URI, identified by @name. This is

 * used by some applications to explicitly specify the path of a

 * PKCS\#11 module.

 *

 * Returns: 1 if the vendor query is set or removed, 0 if not.

 */

int

p11_kit_uri_set_vendor_query (P11KitUri *uri, const char *name,

			      const char *value)

{