=pod =head1 NAME ossl_provider_find, ossl_provider_new, ossl_provider_upref, ossl_provider_free, ossl_provider_set_fallback, ossl_provider_set_module_path, ossl_provider_add_parameter, ossl_provider_activate, ossl_provider_ctx, ossl_provider_forall_loaded, ossl_provider_name, ossl_provider_dso, ossl_provider_module_name, ossl_provider_module_path, ossl_provider_teardown, ossl_provider_get_param_types, ossl_provider_get_params, ossl_provider_query_operation - internal provider routines =head1 SYNOPSIS #include "internal/provider.h" OSSL_PROVIDER *ossl_provider_find(OPENSSL_CTX *libctx, const char *name); OSSL_PROVIDER *ossl_provider_new(OPENSSL_CTX *libctx, const char *name, ossl_provider_init_fn *init_function); int ossl_provider_upref(OSSL_PROVIDER *prov); void ossl_provider_free(OSSL_PROVIDER *prov); /* Setters */ int ossl_provider_set_fallback(OSSL_PROVIDER *prov); int ossl_provider_set_module_path(OSSL_PROVIDER *prov, const char *path); int ossl_provider_add_parameter(OSSL_PROVIDER *prov, const char *name, const char *value); /* Load and initialize the Provider */ int ossl_provider_activate(OSSL_PROVIDER *prov); /* Return pointer to the provider's context */ void *ossl_provider_ctx(const OSSL_PROVIDER *prov); /* Iterate over all loaded providers */ int ossl_provider_forall_loaded(OPENSSL_CTX *, int (*cb)(OSSL_PROVIDER *provider, void *cbdata), void *cbdata); /* Getters for other library functions */ const char *ossl_provider_name(OSSL_PROVIDER *prov); const DSO *ossl_provider_dso(OSSL_PROVIDER *prov); const char *ossl_provider_module_name(OSSL_PROVIDER *prov); const char *ossl_provider_module_path(OSSL_PROVIDER *prov); /* Thin wrappers around calls to the provider */ void ossl_provider_teardown(const OSSL_PROVIDER *prov); const OSSL_ITEM *ossl_provider_get_param_types(const OSSL_PROVIDER *prov); int ossl_provider_get_params(const OSSL_PROVIDER *prov, OSSL_PARAM params[]); const OSSL_ALGORITHM *ossl_provider_query_operation(const OSSL_PROVIDER *prov, int operation_id, int *no_cache); =head1 DESCRIPTION I is a type that holds all the necessary information to handle a provider, regardless of if it's built in to the application or the OpenSSL libraries, or if it's a loadable provider module. Instances of this type are commonly referred to as "provider objects". A provider object is always stored in a set of provider objects in the library context. Provider objects are reference counted. Provider objects are initially inactive, i.e. they are only recorded in the store, but are not used. They are activated with the first call to ossl_provider_activate(), and are inactivated when ossl_provider_free() has been called as many times as ossl_provider_activate() has. =head2 Functions ossl_provider_find() finds an existing provider object in the provider object store by I. The provider object it finds has its reference count incremented. ossl_provider_new() creates a new provider object named I and stores it in the provider object store, unless there already is one there with the same name. If there already is one with the same name, it's returned with its reference count incremented. The reference count of a newly created provider object will always be 2; one for being added to the store, and one for the returned reference. If I is NULL, the provider is assumed to be a dynamically loadable module, with the symbol B as its initialisation function. If I isn't NULL, the provider is assumed to be built in, with I being the pointer to its initialisation function. For further description of the initialisation function, see the description of ossl_provider_activate() below. ossl_provider_upref() increments the provider object I's reference count. ossl_provider_free() decrements the provider object I's reference count; if it drops below 2, the provider object is assumed to have fallen out of use and will be deactivated (its I function is called); if it drops down to zero, I is assumed to have been taken out of the store, and the associated module will be unloaded if one was loaded, and I itself will be freed. ossl_provider_set_fallback() marks an available provider I as fallback. Note that after this call, the provider object pointer that was used can simply be dropped, but not freed. ossl_provider_set_module_path() sets the module path to load the provider module given the provider object I. This will be used in preference to automatically trying to figure out the path from the provider name and the default module directory (more on this in L). ossl_provider_add_parameter() adds a global parameter for the provider to retrieve as it sees fit. The parameters are a combination of I and I, and the provider will use the name to find the value it wants. Only text parameters can be given, and it's up to the provider to interpret them. ossl_provider_activate() "activates" the provider for the given provider object I. What "activates" means depends on what type of provider object it is: =over 4 =item * If an initialization function was given with ossl_provider_new(), that function will get called. =item * If no intialization function was given with ossl_provider_new(), a loadable module with the I that was given to ossl_provider_new() will be located and loaded, then the symbol B will be located in that module, and called. =back ossl_provider_ctx() returns a context created by the provider. Outside of the provider, it's completely opaque, but it needs to be passed back to some of the provider functions. ossl_provider_forall_loaded() iterates over all the currently "activated" providers, and calls I for each of them. If no providers have been "activated" yet, it tries to activate all available fallback providers and tries another iteration. ossl_provider_name() returns the name that was given with ossl_provider_new(). ossl_provider_dso() returns a reference to the module, for providers that come in the form of loadable modules. ossl_provider_module_name() returns the file name of the module, for providers that come in the form of loadable modules. ossl_provider_module_path() returns the full path of the module file, for providers that come in the form of loadable modules. ossl_provider_teardown() calls the provider's I function, if the provider has one. ossl_provider_get_param_types() calls the provider's I function, if the provider has one. It should return an array of I to describe all the parameters that the provider has for the provider object. ossl_provider_get_params() calls the provider's parameter request responder. It should treat the given I array as described in L. ossl_provider_query_operation() calls the provider's I function, if the provider has one. It should return an array of I for the given I. =head1 NOTES Locating a provider module happens as follows: =over 4 =item 1. If a path was given with ossl_provider_set_module_path(), use that as module path. Otherwise, use the provider object's name as module path, with platform specific standard extensions added. =item 2. If the environment variable B is defined, assume its value is a directory specification and merge it with the module path. Otherwise, merge the value of the OpenSSL built in macro B with the module path. =back When this process is done, the result is used when trying to load the provider module. The command C can be used to find out the value of the built in macro B. =head1 RETURN VALUES ossl_provider_find() and ossl_provider_new() return a pointer to a provider object (I) on success, or NULL on error. ossl_provider_upref() returns the value of the reference count after it has been incremented. ossl_provider_free() doesn't return any value. ossl_provider_set_module_path(), ossl_provider_set_fallback() and ossl_provider_activate() return 1 on success, or 0 on error. ossl_provider_name(), ossl_provider_dso(), ossl_provider_module_name(), and ossl_provider_module_path() return a pointer to their respective data if it's available, otherwise NULL is returned. ossl_provider_teardown() doesnt't return any value. ossl_provider_get_param_types() returns a pointer to an I array if this function is available in the provider, otherwise NULL. ossl_provider_get_params() returns 1 on success, or 0 on error. If this function isn't available in the provider, 0 is returned. =head1 SEE ALSO L, L, L =head1 HISTORY The functions described here were all added in OpenSSL 3.0. =head1 COPYRIGHT Copyright 2019 The OpenSSL Project Authors. All Rights Reserved. Licensed under the Apache License 2.0 (the "License"). You may not use this file except in compliance with the License. You can obtain a copy in the file LICENSE in the source distribution or at L. =cut