/src/openssl36/providers/common/provider_ctx.c

Source
/*
 * Copyright 2020-2025 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
 * https://www.openssl.org/source/license.html
 */

#include <stdlib.h>
#include <string.h>
#include "prov/provider_ctx.h"
#include "prov/bio.h"

PROV_CTX *ossl_prov_ctx_new(void)
{
    return OPENSSL_zalloc(sizeof(PROV_CTX));
}

void ossl_prov_ctx_free(PROV_CTX *ctx)
{
    OPENSSL_free(ctx);
}

void ossl_prov_ctx_set0_libctx(PROV_CTX *ctx, OSSL_LIB_CTX *libctx)
{
    if (ctx != NULL)
        ctx->libctx = libctx;
}

void ossl_prov_ctx_set0_handle(PROV_CTX *ctx, const OSSL_CORE_HANDLE *handle)
{
    if (ctx != NULL)
        ctx->handle = handle;
}

void ossl_prov_ctx_set0_core_bio_method(PROV_CTX *ctx, BIO_METHOD *corebiometh)
{
    if (ctx != NULL)
        ctx->corebiometh = corebiometh;
}

void ossl_prov_ctx_set0_core_get_params(PROV_CTX *ctx,
    OSSL_FUNC_core_get_params_fn *c_get_params)
{
    if (ctx != NULL)
        ctx->core_get_params = c_get_params;
}

OSSL_LIB_CTX *ossl_prov_ctx_get0_libctx(PROV_CTX *ctx)
{
    if (ctx == NULL)
        return NULL;
    return ctx->libctx;
}

const OSSL_CORE_HANDLE *ossl_prov_ctx_get0_handle(PROV_CTX *ctx)
{
    if (ctx == NULL)
        return NULL;
    return ctx->handle;
}

BIO_METHOD *ossl_prov_ctx_get0_core_bio_method(PROV_CTX *ctx)
{
    if (ctx == NULL)
        return NULL;
    return ctx->corebiometh;
}

OSSL_FUNC_core_get_params_fn *ossl_prov_ctx_get0_core_get_params(PROV_CTX *ctx)
{
    if (ctx == NULL)
        return NULL;
    return ctx->core_get_params;
}

const char *
ossl_prov_ctx_get_param(PROV_CTX *ctx, const char *name, const char *defval)
{
    char *val = NULL;
    OSSL_PARAM param[2] = { OSSL_PARAM_END, OSSL_PARAM_END };

    if (ctx == NULL
        || ctx->handle == NULL
        || ctx->core_get_params == NULL)
        return defval;

    param[0].key = (char *)name;
    param[0].data_type = OSSL_PARAM_UTF8_PTR;
    param[0].data = (void *)&val;
    param[0].data_size = sizeof(val);
    param[0].return_size = OSSL_PARAM_UNMODIFIED;

    /* Errors are ignored, returning the default value */
    if (ctx->core_get_params(ctx->handle, param)
        && OSSL_PARAM_modified(param)
        && val != NULL)
        return val;
    return defval;
}

int ossl_prov_ctx_get_bool_param(PROV_CTX *ctx, const char *name, int defval)
{
    const char *val = ossl_prov_ctx_get_param(ctx, name, NULL);

    if (val != NULL) {
        if ((strcmp(val, "1") == 0)
            || (OPENSSL_strcasecmp(val, "yes") == 0)
            || (OPENSSL_strcasecmp(val, "true") == 0)
            || (OPENSSL_strcasecmp(val, "on") == 0))
            return 1;
        else if ((strcmp(val, "0") == 0)
            || (OPENSSL_strcasecmp(val, "no") == 0)
            || (OPENSSL_strcasecmp(val, "false") == 0)
            || (OPENSSL_strcasecmp(val, "off") == 0))
            return 0;
    }
    return defval;
}

Line	Count	Source
1		/*
2		* Copyright 2020-2025 The OpenSSL Project Authors. All Rights Reserved.
3		*
4		* Licensed under the Apache License 2.0 (the "License"). You may not use
5		* this file except in compliance with the License. You can obtain a copy
6		* in the file LICENSE in the source distribution or at
7		* https://www.openssl.org/source/license.html
8		*/
9
10		#include <stdlib.h>
11		#include <string.h>
12		#include "prov/provider_ctx.h"
13		#include "prov/bio.h"
14
15		PROV_CTX *ossl_prov_ctx_new(void)
16	99	{
17	99	return OPENSSL_zalloc(sizeof(PROV_CTX));
18	99	}
19
20		void ossl_prov_ctx_free(PROV_CTX *ctx)
21	72	{
22	72	OPENSSL_free(ctx);
23	72	}
24
25		void ossl_prov_ctx_set0_libctx(PROV_CTX ctx, OSSL_LIB_CTX libctx)
26	99	{
27	99	if (ctx != NULL)
28	99	ctx->libctx = libctx;
29	99	}
30
31		void ossl_prov_ctx_set0_handle(PROV_CTX ctx, const OSSL_CORE_HANDLE handle)
32	99	{
33	99	if (ctx != NULL)
34	99	ctx->handle = handle;
35	99	}
36
37		void ossl_prov_ctx_set0_core_bio_method(PROV_CTX ctx, BIO_METHOD corebiometh)
38	99	{
39	99	if (ctx != NULL)
40	99	ctx->corebiometh = corebiometh;
41	99	}
42
43		void ossl_prov_ctx_set0_core_get_params(PROV_CTX *ctx,
44		OSSL_FUNC_core_get_params_fn *c_get_params)
45	63	{
46	63	if (ctx != NULL)
47	63	ctx->core_get_params = c_get_params;
48	63	}
49
50		OSSL_LIB_CTX ossl_prov_ctx_get0_libctx(PROV_CTX ctx)
51	6.93M	{
52	6.93M	if (ctx == NULL)
53	0	return NULL;
54	6.93M	return ctx->libctx;
55	6.93M	}
56
57		const OSSL_CORE_HANDLE ossl_prov_ctx_get0_handle(PROV_CTX ctx)
58	2.94k	{
59	2.94k	if (ctx == NULL)
60	0	return NULL;
61	2.94k	return ctx->handle;
62	2.94k	}
63
64		BIO_METHOD ossl_prov_ctx_get0_core_bio_method(PROV_CTX ctx)
65	6.30M	{
66	6.30M	if (ctx == NULL)
67	0	return NULL;
68	6.30M	return ctx->corebiometh;
69	6.30M	}
70
71		OSSL_FUNC_core_get_params_fn ossl_prov_ctx_get0_core_get_params(PROV_CTX ctx)
72	0	{
73	0	if (ctx == NULL)
74	0	return NULL;
75	0	return ctx->core_get_params;
76	0	}
77
78		const char *
79		ossl_prov_ctx_get_param(PROV_CTX ctx, const char name, const char *defval)
80	153k	{
81	153k	char *val = NULL;
82	153k	OSSL_PARAM param[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
83
84	153k	if (ctx == NULL
85	153k	\|\| ctx->handle == NULL
86	153k	\|\| ctx->core_get_params == NULL)
87	0	return defval;
88
89	153k	param[0].key = (char *)name;
90	153k	param[0].data_type = OSSL_PARAM_UTF8_PTR;
91	153k	param[0].data = (void *)&val;
92	153k	param[0].data_size = sizeof(val);
93	153k	param[0].return_size = OSSL_PARAM_UNMODIFIED;
94
95		/* Errors are ignored, returning the default value */
96	153k	if (ctx->core_get_params(ctx->handle, param)
97	153k	&& OSSL_PARAM_modified(param)
98	0	&& val != NULL)
99	0	return val;
100	153k	return defval;
101	153k	}
102
103		int ossl_prov_ctx_get_bool_param(PROV_CTX ctx, const char name, int defval)
104	103k	{
105	103k	const char *val = ossl_prov_ctx_get_param(ctx, name, NULL);
106
107	103k	if (val != NULL) {
108	0	if ((strcmp(val, "1") == 0)
109	0	\|\| (OPENSSL_strcasecmp(val, "yes") == 0)
110	0	\|\| (OPENSSL_strcasecmp(val, "true") == 0)
111	0	\|\| (OPENSSL_strcasecmp(val, "on") == 0))
112	0	return 1;
113	0	else if ((strcmp(val, "0") == 0)
114	0	\|\| (OPENSSL_strcasecmp(val, "no") == 0)
115	0	\|\| (OPENSSL_strcasecmp(val, "false") == 0)
116	0	\|\| (OPENSSL_strcasecmp(val, "off") == 0))
117	0	return 0;
118	0	}
119	103k	return defval;
120	103k	}

Coverage Report

Created: 2025-12-31 06:58