const char *names; /* For get_decoder_from_store() */
const char *propquery; /* For get_decoder_from_store() */
- unsigned int flag_construct_error_occured : 1;
+ unsigned int flag_construct_error_occurred : 1;
};
/*
* record on inaccessible algorithms.
*/
if (method == NULL)
- methdata->flag_construct_error_occured = 1;
+ methdata->flag_construct_error_occurred = 1;
return method;
}
mcmdata.id = id;
mcmdata.names = name;
mcmdata.propquery = properties;
- mcmdata.flag_construct_error_occured = 0;
+ mcmdata.flag_construct_error_occurred = 0;
if ((method = ossl_method_construct(libctx, OSSL_OP_DECODER,
0 /* !force_cache */,
&mcm, &mcmdata)) != NULL) {
* If we never were in the constructor, the algorithm to be fetched
* is unsupported.
*/
- unsupported = !mcmdata.flag_construct_error_occured;
+ unsupported = !mcmdata.flag_construct_error_occurred;
}
if (method == NULL) {
STACK_OF(OPENSSL_CSTRING) *names;
OSSL_DECODER_CTX *ctx;
- unsigned int error_occured:1;
+ unsigned int error_occurred:1;
};
static void collect_decoder(OSSL_DECODER *decoder, void *arg)
const OSSL_PROVIDER *prov = OSSL_DECODER_provider(decoder);
void *provctx = OSSL_PROVIDER_get0_provider_ctx(prov);
- if (data->error_occured)
+ if (data->error_occurred)
return;
- data->error_occured = 1; /* Assume the worst */
+ data->error_occurred = 1; /* Assume the worst */
if (data->names == NULL)
return;
decoder->freectx(decoderctx);
}
- data->error_occured = 0; /* All is good now */
+ data->error_occurred = 0; /* All is good now */
}
int ossl_decoder_ctx_setup_for_pkey(OSSL_DECODER_CTX *ctx,
collect_decoder, &collect_decoder_data);
sk_OPENSSL_CSTRING_free(names);
- if (collect_decoder_data.error_occured)
+ if (collect_decoder_data.error_occurred)
goto err;
}
const char *names; /* For get_encoder_from_store() */
const char *propquery; /* For get_encoder_from_store() */
- unsigned int flag_construct_error_occured : 1;
+ unsigned int flag_construct_error_occurred : 1;
};
/*
* record on inaccessible algorithms.
*/
if (method == NULL)
- methdata->flag_construct_error_occured = 1;
+ methdata->flag_construct_error_occurred = 1;
return method;
}
mcmdata.id = id;
mcmdata.names = name;
mcmdata.propquery = properties;
- mcmdata.flag_construct_error_occured = 0;
+ mcmdata.flag_construct_error_occurred = 0;
if ((method = ossl_method_construct(libctx, OSSL_OP_ENCODER,
0 /* !force_cache */,
&mcm, &mcmdata)) != NULL) {
* If we never were in the constructor, the algorithm to be fetched
* is unsupported.
*/
- unsupported = !mcmdata.flag_construct_error_occured;
+ unsupported = !mcmdata.flag_construct_error_occurred;
}
if (method == NULL) {
OSSL_ENCODER_CTX *ctx;
- int error_occured;
+ int error_occurred;
};
static void collect_encoder(OSSL_ENCODER *encoder, void *arg)
struct collected_encoder_st *data = arg;
size_t i, end_i;
- if (data->error_occured)
+ if (data->error_occurred)
return;
- data->error_occured = 1; /* Assume the worst */
+ data->error_occurred = 1; /* Assume the worst */
if (data->names == NULL)
return;
break;
}
- data->error_occured = 0; /* All is good now */
+ data->error_occurred = 0; /* All is good now */
}
struct collected_names_st {
STACK_OF(OPENSSL_CSTRING) *names;
- unsigned int error_occured:1;
+ unsigned int error_occurred:1;
};
static void collect_name(const char *name, void *arg)
{
struct collected_names_st *data = arg;
- if (data->error_occured)
+ if (data->error_occurred)
return;
- data->error_occured = 1; /* Assume the worst */
+ data->error_occurred = 1; /* Assume the worst */
if (sk_OPENSSL_CSTRING_push(data->names, name) <= 0)
return;
- data->error_occured = 0; /* All is good now */
+ data->error_occurred = 0; /* All is good now */
}
/*
* First, collect the keymgmt names, then the encoders that match.
*/
keymgmt_data.names = sk_OPENSSL_CSTRING_new_null();
- keymgmt_data.error_occured = 0;
+ keymgmt_data.error_occurred = 0;
EVP_KEYMGMT_names_do_all(pkey->keymgmt, collect_name, &keymgmt_data);
- if (keymgmt_data.error_occured) {
+ if (keymgmt_data.error_occurred) {
sk_OPENSSL_CSTRING_free(keymgmt_data.names);
goto err;
}
encoder_data.names = keymgmt_data.names;
encoder_data.output_type = ctx->output_type;
encoder_data.output_structure = ctx->output_structure;
- encoder_data.error_occured = 0;
+ encoder_data.error_occurred = 0;
encoder_data.ctx = ctx;
OSSL_ENCODER_do_all_provided(libctx, collect_encoder, &encoder_data);
sk_OPENSSL_CSTRING_free(keymgmt_data.names);
- if (encoder_data.error_occured) {
+ if (encoder_data.error_occurred) {
ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_MALLOC_FAILURE);
goto err;
}
const char *names; /* For get_evp_method_from_store() */
const char *propquery; /* For get_evp_method_from_store() */
- unsigned int flag_construct_error_occured : 1;
+ unsigned int flag_construct_error_occurred : 1;
void *(*method_from_dispatch)(int name_id, const OSSL_DISPATCH *,
OSSL_PROVIDER *);
* record on inaccessible algorithms.
*/
if (method == NULL)
- methdata->flag_construct_error_occured = 1;
+ methdata->flag_construct_error_occurred = 1;
return method;
}
mcmdata.method_from_dispatch = new_method;
mcmdata.refcnt_up_method = up_ref_method;
mcmdata.destruct_method = free_method;
- mcmdata.flag_construct_error_occured = 0;
+ mcmdata.flag_construct_error_occurred = 0;
if ((method = ossl_method_construct(libctx, operation_id,
0 /* !force_cache */,
&mcm, &mcmdata)) != NULL) {
* If we never were in the constructor, the algorithm to be fetched
* is unsupported.
*/
- unsupported = !mcmdata.flag_construct_error_occured;
+ unsupported = !mcmdata.flag_construct_error_occurred;
}
if (method == NULL) {
const char *scheme; /* For get_loader_from_store() */
const char *propquery; /* For get_loader_from_store() */
- unsigned int flag_construct_error_occured : 1;
+ unsigned int flag_construct_error_occurred : 1;
};
/*
* record on inaccessible algorithms.
*/
if (method == NULL)
- methdata->flag_construct_error_occured = 1;
+ methdata->flag_construct_error_occurred = 1;
return method;
}
mcmdata.scheme_id = id;
mcmdata.scheme = scheme;
mcmdata.propquery = properties;
- mcmdata.flag_construct_error_occured = 0;
+ mcmdata.flag_construct_error_occurred = 0;
if ((method = ossl_method_construct(libctx, OSSL_OP_STORE,
0 /* !force_cache */,
&mcm, &mcmdata)) != NULL) {
* If we never were in the constructor, the algorithm to be fetched
* is unsupported.
*/
- unsupported = !mcmdata.flag_construct_error_occured;
+ unsupported = !mcmdata.flag_construct_error_occurred;
}
if (method == NULL) {