mirrors/openssl
0
0 Fork 0
mirror of https://github.com/openssl/openssl.git synced 2026-10-28 08:25:12 +08:00
Code Activity

Generate the error headers and tables at build time

Browse Source 
Teach util/mkerr.pl two new modes.  -emit FILE writes one generated
error file to standard output as a pure function of openssl.ec and
openssl.txt, with no source scan and no state update; every file in
the openssl.ec L table becomes a GENERATE rule driven by it, and the
generated error headers join the mandatory generated headers.
-state scans the sources and maintains openssl.txt but writes no
other files; "make errors" now uses it, so the developer flow only
curates the state and the build emits everything else.

Reason-code assignment moves out of the header emission into its own
pass, the three emitters become subroutines writing to a filehandle,
and the up-to-date stamp moves from the statefile's own timestamp to
a separate gitignored stamp file, since the statefile is now a build
input whose timestamp must track its content.

Removing the committed copies also retires 15 that had silently
drifted from the generator's output, among them crypto/bio/bio_err.c,
which was missing the reason strings for three BIO error codes that
exist in the state file.

Reviewed-by: Neil Horman <nhorman@openssl.org>
Reviewed-by: Andrew Dinh <andrewd@openssl.org>
Reviewed-by: Tomas Mraz <tomas@openssl.foundation>
Merge-date: Tue Sep  1 14:03:03 2026
Merged-from: https://github.com/openssl/openssl/pull/32243
This commit is contained in:
Bob Beck authored and Tomas Mraz committed 2026-09-01 16:01:38 +02:00
1 parent 5c0fe36ea3
commit 7a3fa58d9d
114 files changed
+604 -8178
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

.gitignore
+110
View File
@@ -193,6 +193,116 @@ providers/implementations/rands/test_rng.inc
# error code files
/crypto/err/openssl.txt.old
# Generated error code files (from crypto/err/openssl.txt)
/crypto/asn1/asn1_err.c
/crypto/async/async_err.c
/crypto/bio/bio_err.c
/crypto/bn/bn_err.c
/crypto/buffer/buf_err.c
/crypto/cmp/cmp_err.c
/crypto/cms/cms_err.c
/crypto/comp/comp_err.c
/crypto/conf/conf_err.c
/crypto/cpt_err.c
/crypto/crmf/crmf_err.c
/crypto/ct/ct_err.c
/crypto/dh/dh_err.c
/crypto/dsa/dsa_err.c
/crypto/dso/dso_err.c
/crypto/ec/ec_err.c
/crypto/encode_decode/decoder_err.c
/crypto/encode_decode/encoder_err.c
/crypto/ess/ess_err.c
/crypto/evp/evp_err.c
/crypto/http/http_err.c
/crypto/objects/obj_err.c
/crypto/ocsp/ocsp_err.c
/crypto/pem/pem_err.c
/crypto/pkcs12/pk12err.c
/crypto/pkcs7/pkcs7err.c
/crypto/property/property_err.c
/crypto/rand/rand_err.c
/crypto/rsa/rsa_err.c
/crypto/sm2/sm2_err.c
/crypto/ssl_err.c
/crypto/sslerr.h
/crypto/store/store_err.c
/crypto/ts/ts_err.c
/crypto/ui/ui_err.c
/crypto/x509/v3err.c
/crypto/x509/x509_err.c
/include/crypto/asn1err.h
/include/crypto/asyncerr.h
/include/crypto/bioerr.h
/include/crypto/bnerr.h
/include/crypto/buffererr.h
/include/crypto/cmperr.h
/include/crypto/cmserr.h
/include/crypto/comperr.h
/include/crypto/conferr.h
/include/crypto/crmferr.h
/include/crypto/cryptoerr.h
/include/crypto/cterr.h
/include/crypto/decodererr.h
/include/crypto/dherr.h
/include/crypto/dsaerr.h
/include/crypto/ecerr.h
/include/crypto/encodererr.h
/include/crypto/esserr.h
/include/crypto/evperr.h
/include/crypto/httperr.h
/include/crypto/objectserr.h
/include/crypto/ocsperr.h
/include/crypto/pemerr.h
/include/crypto/pkcs12err.h
/include/crypto/pkcs7err.h
/include/crypto/randerr.h
/include/crypto/rsaerr.h
/include/crypto/sm2err.h
/include/crypto/storeerr.h
/include/crypto/tserr.h
/include/crypto/uierr.h
/include/crypto/x509err.h
/include/crypto/x509v3err.h
/include/internal/dsoerr.h
/include/internal/propertyerr.h
/include/openssl/asn1err.h
/include/openssl/asyncerr.h
/include/openssl/bioerr.h
/include/openssl/bnerr.h
/include/openssl/buffererr.h
/include/openssl/cmperr.h
/include/openssl/cmserr.h
/include/openssl/comperr.h
/include/openssl/conferr.h
/include/openssl/crmferr.h
/include/openssl/cryptoerr.h
/include/openssl/cterr.h
/include/openssl/decodererr.h
/include/openssl/dherr.h
/include/openssl/dsaerr.h
/include/openssl/ecerr.h
/include/openssl/encodererr.h
/include/openssl/esserr.h
/include/openssl/evperr.h
/include/openssl/httperr.h
/include/openssl/objectserr.h
/include/openssl/ocsperr.h
/include/openssl/pemerr.h
/include/openssl/pkcs12err.h
/include/openssl/pkcs7err.h
/include/openssl/proverr.h
/include/openssl/randerr.h
/include/openssl/rsaerr.h
/include/openssl/sslerr.h
/include/openssl/storeerr.h
/include/openssl/tserr.h
/include/openssl/uierr.h
/include/openssl/x509err.h
/include/openssl/x509v3err.h
/providers/common/include/prov/proverr.h
/providers/common/provider_err.c
/crypto/err/openssl.txt.stamp
/engines/e_afalg.txt.old
/engines/e_capi.txt.old
/engines/e_dasync.txt.old
Configurations/unix-Makefile.tmpl
+1 -1
View File
@@ -1337,7 +1337,7 @@ ERROR_REBUILD=
errors:
( b=`pwd`; set -e; cd $(SRCDIR); \
$(PERL) util/ck_errf.pl -strict -internal; \
$(PERL) -I$$b util/mkerr.pl $(ERROR_REBUILD) -internal )
$(PERL) -I$$b util/mkerr.pl $(ERROR_REBUILD) -internal -state )
{- use File::Basename;
build.info
+33 -1
View File
@@ -1,5 +1,35 @@
# Note that some of these directories are filtered in Configure. Look for
# %skipdir there for further explanations.
{- use File::Spec::Functions;
# The L table in crypto/err/openssl.ec names, for each error library,
# the files mkerr.pl emits for it: fields three onwards, with NONE
# where there is nothing to emit.
our @err_files = ();
my $ec = catfile($sourcedir, "crypto", "err", "openssl.ec");
open my $fh, "<", $ec or die "Can't read $ec, $!\n";
while (<$fh>) {
s|\R$||;
next unless m|^L\s|;
my @field = split /\s+/;
push @err_files, grep { $_ ne "NONE" } @field[2 .. $#field];
}
close $fh;
our $err_headers = join(" \\\n ", grep { m|\.h$| } @err_files);
our $err_rules =
join("", map {
"GENERATE[$_]=util/mkerr.pl -internal \\\n"
. " -conf \$(SRCDIR)/crypto/err/openssl.ec -emit $_\n"
. "DEPEND[$_]=crypto/err/openssl.ec crypto/err/openssl.txt\n"
} @err_files);
# Adding a library to the table above changes the rules below, so the
# configuration has to be redone when it changes.
push @{$config{build_infos}}, $ec;
""
-}
SUBDIRS=crypto ssl apps util fuzz providers doc
IF[{- !$disabled{tests} -}]
@@ -32,6 +62,7 @@ DEPEND[]=include/openssl/asn1.h \
include/openssl/ess.h \
include/openssl/fipskey.h \
include/openssl/lhash.h \
{- $err_headers -} \
include/openssl/obj_mac.h \
include/openssl/opensslv.h \
include/openssl/ocsp.h \
@@ -142,7 +173,8 @@ DEPEND[]=include/openssl/asn1.h \
providers/implementations/rands/test_rng.inc
GENERATE[include/openssl/asn1.h]=include/openssl/asn1.h.in
GENERATE[include/openssl/obj_mac.h]=crypto/objects/objects.pl \
{- $err_rules -}GENERATE[include/openssl/obj_mac.h]=crypto/objects/objects.pl \
-a $(SRCDIR)/crypto/objects/obj_compat.h \
$(SRCDIR)/crypto/objects/objects.txt $(SRCDIR)/crypto/objects/obj_mac.num
DEPEND[include/openssl/obj_mac.h]=crypto/objects/objects.txt \
crypto/asn1/asn1_err.c
-216
View File
@@ -1,216 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2024 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 <openssl/err.h>
#include <openssl/asn1err.h>
#include "crypto/asn1err.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA ASN1_str_reasons[] = {
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ADDING_OBJECT), "adding object" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ASN1_PARSE_ERROR), "asn1 parse error" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ASN1_SIG_PARSE_ERROR),
"asn1 sig parse error" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_AUX_ERROR), "aux error" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_BAD_OBJECT_HEADER), "bad object header" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_BAD_TEMPLATE), "bad template" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_BMPSTRING_IS_WRONG_LENGTH),
"bmpstring is wrong length" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_BN_LIB), "bn lib" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_BOOLEAN_IS_WRONG_LENGTH),
"boolean is wrong length" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_BUFFER_TOO_SMALL), "buffer too small" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER),
"cipher has no object identifier" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_CONTEXT_NOT_INITIALISED),
"context not initialised" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_DATA_IS_WRONG), "data is wrong" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_DECODE_ERROR), "decode error" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_DEPTH_EXCEEDED), "depth exceeded" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_DIGEST_AND_KEY_TYPE_NOT_SUPPORTED),
"digest and key type not supported" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ENCODE_ERROR), "encode error" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ERROR_GETTING_TIME),
"error getting time" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ERROR_LOADING_SECTION),
"error loading section" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ERROR_SETTING_CIPHER_PARAMS),
"error setting cipher params" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_EXPECTING_AN_INTEGER),
"expecting an integer" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_EXPECTING_AN_OBJECT),
"expecting an object" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_EXPLICIT_LENGTH_MISMATCH),
"explicit length mismatch" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_EXPLICIT_TAG_NOT_CONSTRUCTED),
"explicit tag not constructed" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_FIELD_MISSING), "field missing" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_FIRST_NUM_TOO_LARGE),
"first num too large" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_GENERALIZEDTIME_IS_TOO_SHORT),
"generalizedtime is too short" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_HEADER_TOO_LONG), "header too long" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ILLEGAL_BITSTRING_FORMAT),
"illegal bitstring format" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ILLEGAL_BOOLEAN), "illegal boolean" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ILLEGAL_CHARACTERS),
"illegal characters" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ILLEGAL_FORMAT), "illegal format" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ILLEGAL_HEX), "illegal hex" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ILLEGAL_IMPLICIT_TAG),
"illegal implicit tag" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ILLEGAL_INTEGER), "illegal integer" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ILLEGAL_NEGATIVE_VALUE),
"illegal negative value" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ILLEGAL_NESTED_TAGGING),
"illegal nested tagging" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ILLEGAL_NULL), "illegal null" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ILLEGAL_NULL_VALUE),
"illegal null value" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ILLEGAL_OBJECT), "illegal object" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ILLEGAL_OPTIONAL_ANY),
"illegal optional any" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE),
"illegal options on item template" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ILLEGAL_PADDING), "illegal padding" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ILLEGAL_TAGGED_ANY),
"illegal tagged any" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ILLEGAL_TIME_VALUE),
"illegal time value" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ILLEGAL_ZERO_CONTENT),
"illegal zero content" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_INTEGER_NOT_ASCII_FORMAT),
"integer not ascii format" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_INTEGER_TOO_LARGE_FOR_LONG),
"integer too large for long" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_INVALID_BIT_STRING_BITS_LEFT),
"invalid bit string bits left" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_INVALID_BMPSTRING_LENGTH),
"invalid bmpstring length" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_INVALID_DIGIT), "invalid digit" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_INVALID_MIME_TYPE), "invalid mime type" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_INVALID_MODIFIER), "invalid modifier" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_INVALID_NUMBER), "invalid number" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_INVALID_OBJECT_ENCODING),
"invalid object encoding" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_INVALID_SCRYPT_PARAMETERS),
"invalid scrypt parameters" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_INVALID_SEPARATOR), "invalid separator" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_INVALID_STRING_TABLE_VALUE),
"invalid string table value" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_INVALID_UNIVERSALSTRING_LENGTH),
"invalid universalstring length" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_INVALID_UTF8STRING),
"invalid utf8string" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_INVALID_VALUE), "invalid value" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_LENGTH_TOO_LONG), "length too long" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_LIST_ERROR), "list error" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_MIME_NO_CONTENT_TYPE),
"mime no content type" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_MIME_PARSE_ERROR), "mime parse error" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_MIME_SIG_PARSE_ERROR),
"mime sig parse error" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_MISSING_EOC), "missing eoc" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_MISSING_SECOND_NUMBER),
"missing second number" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_MISSING_VALUE), "missing value" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_MSTRING_NOT_UNIVERSAL),
"mstring not universal" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_MSTRING_WRONG_TAG), "mstring wrong tag" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_NESTED_ASN1_STRING),
"nested asn1 string" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_NESTED_TOO_DEEP), "nested too deep" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_NON_HEX_CHARACTERS),
"non hex characters" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_NOT_ASCII_FORMAT), "not ascii format" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_NOT_ENOUGH_DATA), "not enough data" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_NO_CONTENT_TYPE), "no content type" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_NO_MATCHING_CHOICE_TYPE),
"no matching choice type" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_NO_MULTIPART_BODY_FAILURE),
"no multipart body failure" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_NO_MULTIPART_BOUNDARY),
"no multipart boundary" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_NO_SIG_CONTENT_TYPE),
"no sig content type" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_NULL_IS_WRONG_LENGTH),
"null is wrong length" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_OBJECT_NOT_ASCII_FORMAT),
"object not ascii format" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_ODD_NUMBER_OF_CHARS),
"odd number of chars" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_SECOND_NUMBER_TOO_LARGE),
"second number too large" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_SEQUENCE_LENGTH_MISMATCH),
"sequence length mismatch" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_SEQUENCE_NOT_CONSTRUCTED),
"sequence not constructed" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_SEQUENCE_OR_SET_NEEDS_CONFIG),
"sequence or set needs config" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_SHORT_LINE), "short line" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_SIG_INVALID_MIME_TYPE),
"sig invalid mime type" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_STREAMING_NOT_SUPPORTED),
"streaming not supported" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_STRING_TOO_LONG), "string too long" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_STRING_TOO_SHORT), "string too short" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD),
"the asn1 object identifier is not known for this md" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_TIME_NOT_ASCII_FORMAT),
"time not ascii format" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_TOO_LARGE), "too large" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_TOO_LONG), "too long" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_TOO_SMALL), "too small" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_TYPE_NOT_CONSTRUCTED),
"type not constructed" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_TYPE_NOT_PRIMITIVE),
"type not primitive" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UNEXPECTED_EOC), "unexpected eoc" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UNIVERSALSTRING_IS_WRONG_LENGTH),
"universalstring is wrong length" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UNKNOWN_DIGEST), "unknown digest" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UNKNOWN_FORMAT), "unknown format" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UNKNOWN_MESSAGE_DIGEST_ALGORITHM),
"unknown message digest algorithm" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UNKNOWN_OBJECT_TYPE),
"unknown object type" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UNKNOWN_PUBLIC_KEY_TYPE),
"unknown public key type" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UNKNOWN_SIGNATURE_ALGORITHM),
"unknown signature algorithm" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UNKNOWN_TAG), "unknown tag" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE),
"unsupported any defined by type" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UNSUPPORTED_CIPHER),
"unsupported cipher" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE),
"unsupported public key type" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UNSUPPORTED_TYPE), "unsupported type" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UTCTIME_IS_TOO_SHORT),
"utctime is too short" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_WRONG_INTEGER_TYPE),
"wrong integer type" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_WRONG_PUBLIC_KEY_TYPE),
"wrong public key type" },
{ ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_WRONG_TAG), "wrong tag" },
{ 0, NULL }
};
#endif
int ossl_err_load_ASN1_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(ASN1_str_reasons[0].error) == NULL)
ERR_load_strings_const(ASN1_str_reasons);
#endif
return 1;
}
crypto/async/async_err.c
-37
View File
@@ -1,37 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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 <openssl/err.h>
#include <openssl/asyncerr.h>
#include "crypto/asyncerr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA ASYNC_str_reasons[] = {
{ ERR_PACK(ERR_LIB_ASYNC, 0, ASYNC_R_FAILED_TO_SET_POOL),
"failed to set pool" },
{ ERR_PACK(ERR_LIB_ASYNC, 0, ASYNC_R_FAILED_TO_SWAP_CONTEXT),
"failed to swap context" },
{ ERR_PACK(ERR_LIB_ASYNC, 0, ASYNC_R_INIT_FAILED), "init failed" },
{ ERR_PACK(ERR_LIB_ASYNC, 0, ASYNC_R_INVALID_POOL_SIZE),
"invalid pool size" },
{ 0, NULL }
};
#endif
int ossl_err_load_ASYNC_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(ASYNC_str_reasons[0].error) == NULL)
ERR_load_strings_const(ASYNC_str_reasons);
#endif
return 1;
}
crypto/bio/bio_err.c
-99
View File
@@ -1,99 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-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 <openssl/err.h>
#include <openssl/bioerr.h>
#include "crypto/bioerr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA BIO_str_reasons[] = {
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_ACCEPT_ERROR), "accept error" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_ADDRINFO_ADDR_IS_NOT_AF_INET),
"addrinfo addr is not af inet" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_AMBIGUOUS_HOST_OR_SERVICE),
"ambiguous host or service" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_BAD_FOPEN_MODE), "bad fopen mode" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_BROKEN_PIPE), "broken pipe" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_CONNECT_ERROR), "connect error" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_CONNECT_TIMEOUT), "connect timeout" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET),
"gethostbyname addr is not af inet" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_GETSOCKNAME_ERROR), "getsockname error" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_GETSOCKNAME_TRUNCATED_ADDRESS),
"getsockname truncated address" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_GETTING_SOCKTYPE), "getting socktype" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_INVALID_ARGUMENT), "invalid argument" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_INVALID_SOCKET), "invalid socket" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_IN_USE), "in use" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_LENGTH_TOO_LONG), "length too long" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_LISTEN_V6_ONLY), "listen v6 only" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_LOOKUP_RETURNED_NOTHING),
"lookup returned nothing" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_MALFORMED_HOST_OR_SERVICE),
"malformed host or service" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_NBIO_CONNECT_ERROR), "nbio connect error" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED),
"no accept addr or service specified" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_NO_HOSTNAME_OR_SERVICE_SPECIFIED),
"no hostname or service specified" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_NO_PORT_DEFINED), "no port defined" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_NO_SUCH_FILE), "no such file" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_PORT_MISMATCH), "port mismatch" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_TFO_DISABLED), "tfo disabled" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_TFO_NO_KERNEL_SUPPORT),
"tfo no kernel support" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_TRANSFER_ERROR), "transfer error" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_TRANSFER_TIMEOUT), "transfer timeout" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_UNABLE_TO_BIND_SOCKET),
"unable to bind socket" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_UNABLE_TO_CREATE_SOCKET),
"unable to create socket" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_UNABLE_TO_KEEPALIVE),
"unable to keepalive" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_UNABLE_TO_LISTEN_SOCKET),
"unable to listen socket" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_UNABLE_TO_NODELAY), "unable to nodelay" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_UNABLE_TO_REUSEADDR),
"unable to reuseaddr" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_UNABLE_TO_TFO), "unable to tfo" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_UNAVAILABLE_IP_FAMILY),
"unavailable ip family" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_UNINITIALIZED), "uninitialized" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_UNKNOWN_INFO_TYPE), "unknown info type" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_UNSUPPORTED_IP_FAMILY),
"unsupported ip family" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_UNSUPPORTED_METHOD), "unsupported method" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_UNSUPPORTED_PROTOCOL_FAMILY),
"unsupported protocol family" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_WRITE_TO_READ_ONLY_BIO),
"write to read only BIO" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_WSASTARTUP), "WSAStartup" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_LOCAL_ADDR_NOT_AVAILABLE),
"local address not available" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_PEER_ADDR_NOT_AVAILABLE),
"peer address not available" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_NON_FATAL),
"non-fatal or transient error" },
{ ERR_PACK(ERR_LIB_BIO, 0, BIO_R_PORT_MISMATCH),
"port mismatch" },
{ 0, NULL }
};
#endif
int ossl_err_load_BIO_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(BIO_str_reasons[0].error) == NULL)
ERR_load_strings_const(BIO_str_reasons);
#endif
return 1;
}
crypto/bn/bn_err.c
-56
View File
@@ -1,56 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2022 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 <openssl/err.h>
#include <openssl/bnerr.h>
#include "crypto/bnerr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA BN_str_reasons[] = {
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_ARG2_LT_ARG3), "arg2 lt arg3" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_BAD_RECIPROCAL), "bad reciprocal" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_BIGNUM_TOO_LONG), "bignum too long" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_BITS_TOO_SMALL), "bits too small" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_CALLED_WITH_EVEN_MODULUS),
"called with even modulus" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_DIV_BY_ZERO), "div by zero" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_ENCODING_ERROR), "encoding error" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_EXPAND_ON_STATIC_BIGNUM_DATA),
"expand on static bignum data" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_INPUT_NOT_REDUCED), "input not reduced" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_INVALID_LENGTH), "invalid length" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_INVALID_RANGE), "invalid range" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_INVALID_SHIFT), "invalid shift" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_NOT_A_SQUARE), "not a square" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_NOT_INITIALIZED), "not initialized" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_NO_INVERSE), "no inverse" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_NO_PRIME_CANDIDATE), "no prime candidate" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_NO_SOLUTION), "no solution" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_NO_SUITABLE_DIGEST), "no suitable digest" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_PRIVATE_KEY_TOO_LARGE),
"private key too large" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_P_IS_NOT_PRIME), "p is not prime" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_TOO_MANY_ITERATIONS), "too many iterations" },
{ ERR_PACK(ERR_LIB_BN, 0, BN_R_TOO_MANY_TEMPORARY_VARIABLES),
"too many temporary variables" },
{ 0, NULL }
};
#endif
int ossl_err_load_BN_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(BN_str_reasons[0].error) == NULL)
ERR_load_strings_const(BN_str_reasons);
#endif
return 1;
}
crypto/buffer/buf_err.c
-30
View File
@@ -1,30 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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 <openssl/err.h>
#include <openssl/buffererr.h>
#include "crypto/buffererr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA BUF_str_reasons[] = {
{ 0, NULL }
};
#endif
int ossl_err_load_BUF_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(BUF_str_reasons[0].error) == NULL)
ERR_load_strings_const(BUF_str_reasons);
#endif
return 1;
}
crypto/cmp/cmp_err.c
-208
View File
@@ -1,208 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-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 <openssl/err.h>
#include <openssl/cmperr.h>
#include "crypto/cmperr.h"
#ifndef OPENSSL_NO_CMP
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA CMP_str_reasons[] = {
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ALGORITHM_NOT_SUPPORTED),
"algorithm not supported" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_BAD_CHECKAFTER_IN_POLLREP),
"bad checkafter in pollrep" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_BAD_REQUEST_ID), "bad request id" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_CERTHASH_UNMATCHED), "certhash unmatched" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_CERTID_NOT_FOUND), "certid not found" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_CERTIFICATE_NOT_ACCEPTED),
"certificate not accepted" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_CERTIFICATE_NOT_FOUND),
"certificate not found" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_CERTREQMSG_NOT_FOUND),
"certreqmsg not found" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_CERTRESPONSE_NOT_FOUND),
"certresponse not found" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_CERT_AND_KEY_DO_NOT_MATCH),
"cert and key do not match" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_CHECKAFTER_OUT_OF_RANGE),
"checkafter out of range" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ENCOUNTERED_KEYUPDATEWARNING),
"encountered keyupdatewarning" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ENCOUNTERED_WAITING),
"encountered waiting" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_CALCULATING_PROTECTION),
"error calculating protection" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_CREATING_CERTCONF),
"error creating certconf" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_CREATING_CERTREP),
"error creating certrep" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_CREATING_CERTREQ),
"error creating certreq" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_CREATING_ERROR),
"error creating error" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_CREATING_GENM),
"error creating genm" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_CREATING_GENP),
"error creating genp" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_CREATING_PKICONF),
"error creating pkiconf" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_CREATING_POLLREP),
"error creating pollrep" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_CREATING_POLLREQ),
"error creating pollreq" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_CREATING_RP), "error creating rp" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_CREATING_RR), "error creating rr" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_PARSING_PKISTATUS),
"error parsing pkistatus" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_PROCESSING_MESSAGE),
"error processing message" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_PROTECTING_MESSAGE),
"error protecting message" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_SETTING_CERTHASH),
"error setting certhash" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_UNEXPECTED_CERTCONF),
"error unexpected certconf" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_VALIDATING_PROTECTION),
"error validating protection" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_ERROR_VALIDATING_SIGNATURE),
"error validating signature" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_EXPECTED_POLLREQ), "expected pollreq" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_FAILED_BUILDING_OWN_CHAIN),
"failed building own chain" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_FAILED_EXTRACTING_CENTRAL_GEN_KEY),
"failed extracting central gen key" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_FAILED_EXTRACTING_PUBKEY),
"failed extracting pubkey" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_FAILURE_OBTAINING_RANDOM),
"failure obtaining random" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_FAIL_INFO_OUT_OF_RANGE),
"fail info out of range" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_GENERATE_CERTREQTEMPLATE),
"generate certreqtemplate" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_GENERATE_CRLSTATUS),
"error creating crlstatus" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_GETTING_GENP), "getting genp" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_GET_ITAV), "get itav" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_INVALID_ARGS), "invalid args" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_INVALID_GENP), "invalid genp" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_INVALID_KEYSPEC), "invalid keyspec" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_INVALID_OPTION), "invalid option" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_INVALID_ROOTCAKEYUPDATE),
"invalid rootcakeyupdate" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_MISSING_CENTRAL_GEN_KEY),
"missing central gen key" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_MISSING_CERTID), "missing certid" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_MISSING_KEY_INPUT_FOR_CREATING_PROTECTION),
"missing key input for creating protection" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_MISSING_KEY_USAGE_DIGITALSIGNATURE),
"missing key usage digitalsignature" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_MISSING_P10CSR), "missing p10csr" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_MISSING_PBM_SECRET), "missing pbm secret" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_MISSING_PRIVATE_KEY),
"missing private key" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_MISSING_PRIVATE_KEY_FOR_POPO),
"missing private key for popo" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_MISSING_PROTECTION), "missing protection" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_MISSING_PUBLIC_KEY), "missing public key" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_MISSING_REFERENCE_CERT),
"missing reference cert" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_MISSING_SECRET), "missing secret" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_MISSING_SENDER_IDENTIFICATION),
"missing sender identification" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_MISSING_TRUST_ANCHOR),
"missing trust anchor" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_MISSING_TRUST_STORE),
"missing trust store" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_MULTIPLE_REQUESTS_NOT_SUPPORTED),
"multiple requests not supported" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_MULTIPLE_RESPONSES_NOT_SUPPORTED),
"multiple responses not supported" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_MULTIPLE_SAN_SOURCES),
"multiple san sources" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_NO_STDIO), "no stdio" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_NO_SUITABLE_SENDER_CERT),
"no suitable sender cert" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_NULL_ARGUMENT), "null argument" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_PKIBODY_ERROR), "pkibody error" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_PKISTATUSINFO_NOT_FOUND),
"pkistatusinfo not found" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_POLLING_FAILED), "polling failed" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_POTENTIALLY_INVALID_CERTIFICATE),
"potentially invalid certificate" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_RECEIVED_ERROR), "received error" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_RECIPNONCE_UNMATCHED),
"recipnonce unmatched" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_REQUEST_NOT_ACCEPTED),
"request not accepted" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_REQUEST_REJECTED_BY_SERVER),
"request rejected by server" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_SENDER_GENERALNAME_TYPE_NOT_SUPPORTED),
"sender generalname type not supported" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_SRVCERT_DOES_NOT_VALIDATE_MSG),
"srvcert does not validate msg" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_TOTAL_TIMEOUT), "total timeout" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_TRANSACTIONID_UNMATCHED),
"transactionid unmatched" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_TRANSFER_ERROR), "transfer error" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_UNCLEAN_CTX), "unclean ctx" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_UNEXPECTED_CENTRAL_GEN_KEY),
"unexpected central gen key" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_UNEXPECTED_CERTPROFILE),
"unexpected certprofile" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_UNEXPECTED_CRLSTATUSLIST),
"unexpected crlstatuslist" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_UNEXPECTED_PKIBODY), "unexpected pkibody" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_UNEXPECTED_PKISTATUS),
"unexpected pkistatus" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_UNEXPECTED_POLLREQ), "unexpected pollreq" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_UNEXPECTED_PVNO), "unexpected pvno" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_UNEXPECTED_SENDER), "unexpected sender" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_UNKNOWN_ALGORITHM_ID),
"unknown algorithm id" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_UNKNOWN_CERT_TYPE), "unknown cert type" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_UNKNOWN_CRL_ISSUER), "unknown crl issuer" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_UNKNOWN_PKISTATUS), "unknown pkistatus" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_UNSUPPORTED_ALGORITHM),
"unsupported algorithm" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_UNSUPPORTED_KEY_TYPE),
"unsupported key type" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_UNSUPPORTED_PKIBODY),
"unsupported pkibody" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_UNSUPPORTED_PROTECTION_ALG_DHBASEDMAC),
"unsupported protection alg dhbasedmac" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_VALUE_TOO_LARGE), "value too large" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_VALUE_TOO_SMALL), "value too small" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_WRONG_ALGORITHM_OID),
"wrong algorithm oid" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_WRONG_CERTID), "wrong certid" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_WRONG_CERTID_IN_RP), "wrong certid in rp" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_WRONG_PBM_VALUE), "wrong pbm value" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_WRONG_RP_COMPONENT_COUNT),
"wrong rp component count" },
{ ERR_PACK(ERR_LIB_CMP, 0, CMP_R_WRONG_SERIAL_IN_RP), "wrong serial in rp" },
{ 0, NULL }
};
#endif
int ossl_err_load_CMP_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(CMP_str_reasons[0].error) == NULL)
ERR_load_strings_const(CMP_str_reasons);
#endif
return 1;
}
#else
NON_EMPTY_TRANSLATION_UNIT
#endif
crypto/cms/cms_err.c
-191
View File
@@ -1,191 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-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 <openssl/err.h>
#include <openssl/cmserr.h>
#include "crypto/cmserr.h"
#ifndef OPENSSL_NO_CMS
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA CMS_str_reasons[] = {
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_ADD_SIGNER_ERROR), "add signer error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_ATTRIBUTE_ERROR), "attribute error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CERTIFICATE_ALREADY_PRESENT),
"certificate already present" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CERTIFICATE_HAS_NO_KEYID),
"certificate has no keyid" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CERTIFICATE_VERIFY_ERROR),
"certificate verify error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CIPHER_AEAD_IN_ENVELOPED_DATA),
"cipher aead in enveloped data" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CIPHER_AEAD_SET_TAG_ERROR),
"cipher aead set tag error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CIPHER_GET_TAG), "cipher get tag" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CIPHER_INITIALISATION_ERROR),
"cipher initialisation error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR),
"cipher parameter initialisation error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CMS_DATAFINAL_ERROR),
"cms datafinal error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CMS_LIB), "cms lib" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CONTENTIDENTIFIER_MISMATCH),
"contentidentifier mismatch" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CONTENT_NOT_FOUND), "content not found" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CONTENT_TYPE_MISMATCH),
"content type mismatch" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CONTENT_TYPE_NOT_COMPRESSED_DATA),
"content type not compressed data" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CONTENT_TYPE_NOT_ENVELOPED_DATA),
"content type not enveloped data" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CONTENT_TYPE_NOT_SIGNED_DATA),
"content type not signed data" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CONTENT_VERIFY_ERROR),
"content verify error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CTRL_ERROR), "ctrl error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_CTRL_FAILURE), "ctrl failure" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_DECODE_ERROR), "decode error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_DECRYPT_ERROR), "decrypt error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_ERROR_GETTING_PUBLIC_KEY),
"error getting public key" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE),
"error reading messagedigest attribute" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_ERROR_SETTING_KEY), "error setting key" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_ERROR_SETTING_RECIPIENTINFO),
"error setting recipientinfo" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_ERROR_UNSUPPORTED_STATIC_KEY_AGREEMENT),
"error unsupported static key agreement" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_ESS_SIGNING_CERTID_MISMATCH_ERROR),
"ess signing certid mismatch error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_INVALID_ENCRYPTED_KEY_LENGTH),
"invalid encrypted key length" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_INVALID_KEY_ENCRYPTION_PARAMETER),
"invalid key encryption parameter" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_INVALID_KEY_LENGTH), "invalid key length" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_INVALID_LABEL), "invalid label" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_INVALID_OAEP_PARAMETERS),
"invalid oaep parameters" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_KDF_PARAMETER_ERROR),
"kdf parameter error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_MD_BIO_INIT_ERROR), "md bio init error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH),
"messagedigest attribute wrong length" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_MESSAGEDIGEST_WRONG_LENGTH),
"messagedigest wrong length" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_MSGSIGDIGEST_ERROR), "msgsigdigest error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_MSGSIGDIGEST_VERIFICATION_FAILURE),
"msgsigdigest verification failure" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_MSGSIGDIGEST_WRONG_LENGTH),
"msgsigdigest wrong length" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NEED_ONE_SIGNER), "need one signer" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NOT_A_SIGNED_RECEIPT),
"not a signed receipt" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NOT_ENCRYPTED_DATA), "not encrypted data" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NOT_KEK), "not kek" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NOT_KEM), "not kem" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NOT_KEY_AGREEMENT), "not key agreement" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NOT_KEY_TRANSPORT), "not key transport" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NOT_PWRI), "not pwri" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE),
"not supported for this key type" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NO_CIPHER), "no cipher" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NO_CONTENT), "no content" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NO_CONTENT_TYPE), "no content type" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NO_DEFAULT_DIGEST), "no default digest" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NO_DIGEST_SET), "no digest set" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NO_KEY), "no key" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NO_KEY_OR_CERT), "no key or cert" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NO_MATCHING_DIGEST), "no matching digest" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NO_MATCHING_RECIPIENT),
"no matching recipient" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NO_MATCHING_SIGNATURE),
"no matching signature" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NO_MSGSIGDIGEST), "no msgsigdigest" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NO_PASSWORD), "no password" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NO_PRIVATE_KEY), "no private key" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NO_PUBLIC_KEY), "no public key" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NO_RECEIPT_REQUEST), "no receipt request" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_NO_SIGNERS), "no signers" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_OPERATION_UNSUPPORTED),
"operation unsupported" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_PEER_KEY_ERROR), "peer key error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE),
"private key does not match certificate" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_RECEIPT_DECODE_ERROR),
"receipt decode error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_RECIPIENT_ERROR), "recipient error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_SHARED_INFO_ERROR), "shared info error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_SIGNER_CERTIFICATE_NOT_FOUND),
"signer certificate not found" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_SIGNFINAL_ERROR), "signfinal error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_SMIME_TEXT_ERROR), "smime text error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_STORE_INIT_ERROR), "store init error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_TYPE_NOT_COMPRESSED_DATA),
"type not compressed data" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_TYPE_NOT_DATA), "type not data" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_TYPE_NOT_DIGESTED_DATA),
"type not digested data" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_TYPE_NOT_ENCRYPTED_DATA),
"type not encrypted data" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_TYPE_NOT_ENVELOPED_DATA),
"type not enveloped data" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNABLE_TO_FINALIZE_CONTEXT),
"unable to finalize context" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNKNOWN_CIPHER), "unknown cipher" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNKNOWN_DIGEST_ALGORITHM),
"unknown digest algorithm" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNKNOWN_ID), "unknown id" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNKNOWN_KDF_ALGORITHM),
"unknown kdf algorithm" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNSUPPORTED_COMPRESSION_ALGORITHM),
"unsupported compression algorithm" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNSUPPORTED_CONTENT_ENCRYPTION_ALGORITHM),
"unsupported content encryption algorithm" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNSUPPORTED_CONTENT_TYPE),
"unsupported content type" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNSUPPORTED_ENCRYPTION_TYPE),
"unsupported encryption type" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNSUPPORTED_KDF_ALGORITHM),
"unsupported kdf algorithm" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNSUPPORTED_KEK_ALGORITHM),
"unsupported kek algorithm" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM),
"unsupported key encryption algorithm" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNSUPPORTED_LABEL_SOURCE),
"unsupported label source" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNSUPPORTED_RECIPIENTINFO_TYPE),
"unsupported recipientinfo type" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNSUPPORTED_RECIPIENT_TYPE),
"unsupported recipient type" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNSUPPORTED_SIGNATURE_ALGORITHM),
"unsupported signature algorithm" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNSUPPORTED_TYPE), "unsupported type" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNWRAP_ERROR), "unwrap error" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_UNWRAP_FAILURE), "unwrap failure" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_VERIFICATION_FAILURE),
"verification failure" },
{ ERR_PACK(ERR_LIB_CMS, 0, CMS_R_WRAP_ERROR), "wrap error" },
{ 0, NULL }
};
#endif
int ossl_err_load_CMS_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(CMS_str_reasons[0].error) == NULL)
ERR_load_strings_const(CMS_str_reasons);
#endif
return 1;
}
#else
NON_EMPTY_TRANSLATION_UNIT
#endif
crypto/comp/comp_err.c
-54
View File
@@ -1,54 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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 <openssl/err.h>
#include <openssl/comperr.h>
#include "crypto/comperr.h"
#ifndef OPENSSL_NO_COMP
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA COMP_str_reasons[] = {
{ ERR_PACK(ERR_LIB_COMP, 0, COMP_R_BROTLI_DECODE_ERROR),
"brotli decode error" },
{ ERR_PACK(ERR_LIB_COMP, 0, COMP_R_BROTLI_ENCODE_ERROR),
"brotli encode error" },
{ ERR_PACK(ERR_LIB_COMP, 0, COMP_R_BROTLI_NOT_SUPPORTED),
"brotli not supported" },
{ ERR_PACK(ERR_LIB_COMP, 0, COMP_R_ZLIB_DEFLATE_ERROR),
"zlib deflate error" },
{ ERR_PACK(ERR_LIB_COMP, 0, COMP_R_ZLIB_INFLATE_ERROR),
"zlib inflate error" },
{ ERR_PACK(ERR_LIB_COMP, 0, COMP_R_ZLIB_NOT_SUPPORTED),
"zlib not supported" },
{ ERR_PACK(ERR_LIB_COMP, 0, COMP_R_ZSTD_COMPRESS_ERROR),
"zstd compress error" },
{ ERR_PACK(ERR_LIB_COMP, 0, COMP_R_ZSTD_DECODE_ERROR), "zstd decode error" },
{ ERR_PACK(ERR_LIB_COMP, 0, COMP_R_ZSTD_DECOMPRESS_ERROR),
"zstd decompress error" },
{ ERR_PACK(ERR_LIB_COMP, 0, COMP_R_ZSTD_NOT_SUPPORTED),
"zstd not supported" },
{ 0, NULL }
};
#endif
int ossl_err_load_COMP_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(COMP_str_reasons[0].error) == NULL)
ERR_load_strings_const(COMP_str_reasons);
#endif
return 1;
}
#else
NON_EMPTY_TRANSLATION_UNIT
#endif
crypto/conf/conf_err.c
-74
View File
@@ -1,74 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2023 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 <openssl/err.h>
#include <openssl/conferr.h>
#include "crypto/conferr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA CONF_str_reasons[] = {
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_ERROR_LOADING_DSO), "error loading dso" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_INVALID_PRAGMA), "invalid pragma" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_LIST_CANNOT_BE_NULL),
"list cannot be null" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_MANDATORY_BRACES_IN_VARIABLE_EXPANSION),
"mandatory braces in variable expansion" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_MISSING_CLOSE_SQUARE_BRACKET),
"missing close square bracket" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_MISSING_EQUAL_SIGN),
"missing equal sign" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_MISSING_INIT_FUNCTION),
"missing init function" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_MODULE_INITIALIZATION_ERROR),
"module initialization error" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_NO_CLOSE_BRACE), "no close brace" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_NO_CONF), "no conf" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE),
"no conf or environment variable" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_NO_SECTION), "no section" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_NO_SUCH_FILE), "no such file" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_NO_VALUE), "no value" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_NUMBER_TOO_LARGE), "number too large" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_OPENSSL_CONF_REFERENCES_MISSING_SECTION),
"openssl conf references missing section" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_RECURSIVE_DIRECTORY_INCLUDE),
"recursive directory include" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_RECURSIVE_SECTION_REFERENCE),
"recursive section reference" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_RELATIVE_PATH), "relative path" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_SSL_COMMAND_SECTION_EMPTY),
"ssl command section empty" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_SSL_COMMAND_SECTION_NOT_FOUND),
"ssl command section not found" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_SSL_SECTION_EMPTY), "ssl section empty" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_SSL_SECTION_NOT_FOUND),
"ssl section not found" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_UNABLE_TO_CREATE_NEW_SECTION),
"unable to create new section" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_UNKNOWN_MODULE_NAME),
"unknown module name" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_VARIABLE_EXPANSION_TOO_LONG),
"variable expansion too long" },
{ ERR_PACK(ERR_LIB_CONF, 0, CONF_R_VARIABLE_HAS_NO_VALUE),
"variable has no value" },
{ 0, NULL }
};
#endif
int ossl_err_load_CONF_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(CONF_str_reasons[0].error) == NULL)
ERR_load_strings_const(CONF_str_reasons);
#endif
return 1;
}
crypto/cpt_err.c
-89
View File
@@ -1,89 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2024 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 <openssl/err.h>
#include <openssl/cryptoerr.h>
#include "crypto/cryptoerr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA CRYPTO_str_reasons[] = {
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_BAD_ALGORITHM_NAME),
"bad algorithm name" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_CONFLICTING_NAMES),
"conflicting names" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_HEX_STRING_TOO_SHORT),
"hex string too short" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_ILLEGAL_HEX_DIGIT),
"illegal hex digit" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_INSUFFICIENT_DATA_SPACE),
"insufficient data space" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_INSUFFICIENT_PARAM_SIZE),
"insufficient param size" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_INSUFFICIENT_SECURE_DATA_SPACE),
"insufficient secure data space" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_INTEGER_OVERFLOW),
"integer overflow" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_INVALID_NEGATIVE_VALUE),
"invalid negative value" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_INVALID_NULL_ARGUMENT),
"invalid null argument" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_INVALID_OSSL_PARAM_TYPE),
"invalid ossl param type" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_NO_PARAMS_TO_MERGE),
"no params to merge" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_NO_SPACE_FOR_TERMINATING_NULL),
"no space for terminating null" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_ODD_NUMBER_OF_DIGITS),
"odd number of digits" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_PARAM_CANNOT_BE_REPRESENTED_EXACTLY),
"param cannot be represented exactly" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_PARAM_NOT_INTEGER_TYPE),
"param not integer type" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_PARAM_OF_INCOMPATIBLE_TYPE),
"param of incompatible type" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_PARAM_UNSIGNED_INTEGER_NEGATIVE_VALUE_UNSUPPORTED),
"param unsigned integer negative value unsupported" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_PARAM_UNSUPPORTED_FLOATING_POINT_FORMAT),
"param unsupported floating point format" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_PARAM_VALUE_TOO_LARGE_FOR_DESTINATION),
"param value too large for destination" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_PROVIDER_ALREADY_EXISTS),
"provider already exists" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_PROVIDER_SECTION_ERROR),
"provider section error" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_RANDOM_SECTION_ERROR),
"random section error" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_SECURE_MALLOC_FAILURE),
"secure malloc failure" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_STRING_TOO_LONG), "string too long" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_TOO_MANY_BYTES), "too many bytes" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_TOO_MANY_NAMES), "too many names" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_TOO_MANY_RECORDS),
"too many records" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_TOO_SMALL_BUFFER),
"too small buffer" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_UNKNOWN_NAME_IN_RANDOM_SECTION),
"unknown name in random section" },
{ ERR_PACK(ERR_LIB_CRYPTO, 0, CRYPTO_R_ZERO_LENGTH_NUMBER),
"zero length number" },
{ 0, NULL }
};
#endif
int ossl_err_load_CRYPTO_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(CRYPTO_str_reasons[0].error) == NULL)
ERR_load_strings_const(CRYPTO_str_reasons);
#endif
return 1;
}
crypto/crmf/crmf_err.c
-89
View File
@@ -1,89 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-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 <openssl/err.h>
#include <openssl/crmferr.h>
#include "crypto/crmferr.h"
#ifndef OPENSSL_NO_CRMF
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA CRMF_str_reasons[] = {
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_BAD_PBM_ITERATIONCOUNT),
"bad pbm iterationcount" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_CMS_NOT_SUPPORTED), "cms not supported" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_CRMFERROR), "crmferror" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_ERROR), "error" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_ERROR_DECODING_CERTIFICATE),
"error decoding certificate" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_ERROR_DECODING_ENCRYPTEDKEY),
"error decoding encryptedkey" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_ERROR_DECRYPTING_CERTIFICATE),
"error decrypting certificate" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_ERROR_DECRYPTING_ENCRYPTEDKEY),
"error decrypting encryptedkey" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_ERROR_DECRYPTING_ENCRYPTEDVALUE),
"error decrypting encryptedvalue" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_ERROR_DECRYPTING_SYMMETRIC_KEY),
"error decrypting symmetric key" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_ERROR_SETTING_PURPOSE),
"error setting purpose" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_ERROR_SIGNING_POPO),
"error signing popo" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_ERROR_VERIFYING_ENCRYPTEDKEY),
"error verifying encryptedkey" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_FAILURE_OBTAINING_RANDOM),
"failure obtaining random" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_ITERATIONCOUNT_BELOW_100),
"iterationcount below 100" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_MALFORMED_IV), "malformed iv" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_NULL_ARGUMENT), "null argument" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_POPOSKINPUT_NOT_SUPPORTED),
"poposkinput not supported" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_POPO_INCONSISTENT_CENTRAL_KEYGEN),
"popo inconsistent central keygen" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_POPO_INCONSISTENT_PUBLIC_KEY),
"popo inconsistent public key" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_POPO_MISSING), "popo missing" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_POPO_MISSING_PUBLIC_KEY),
"popo missing public key" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_POPO_MISSING_SUBJECT),
"popo missing subject" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_POPO_RAVERIFIED_NOT_ACCEPTED),
"popo raverified not accepted" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_SETTING_MAC_ALGOR_FAILURE),
"setting mac algor failure" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_SETTING_OWF_ALGOR_FAILURE),
"setting owf algor failure" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_UNSUPPORTED_ALGORITHM),
"unsupported algorithm" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_UNSUPPORTED_CIPHER),
"unsupported cipher" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_UNSUPPORTED_METHOD_FOR_CREATING_POPO),
"unsupported method for creating popo" },
{ ERR_PACK(ERR_LIB_CRMF, 0, CRMF_R_UNSUPPORTED_POPO_METHOD),
"unsupported popo method" },
{ 0, NULL }
};
#endif
int ossl_err_load_CRMF_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(CRMF_str_reasons[0].error) == NULL)
ERR_load_strings_const(CRMF_str_reasons);
#endif
return 1;
}
#else
NON_EMPTY_TRANSLATION_UNIT
#endif
crypto/ct/ct_err.c
-61
View File
@@ -1,61 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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 <openssl/err.h>
#include <openssl/cterr.h>
#include "crypto/cterr.h"
#ifndef OPENSSL_NO_CT
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA CT_str_reasons[] = {
{ ERR_PACK(ERR_LIB_CT, 0, CT_R_BASE64_DECODE_ERROR), "base64 decode error" },
{ ERR_PACK(ERR_LIB_CT, 0, CT_R_INVALID_LOG_ID_LENGTH),
"invalid log id length" },
{ ERR_PACK(ERR_LIB_CT, 0, CT_R_LOG_CONF_INVALID), "log conf invalid" },
{ ERR_PACK(ERR_LIB_CT, 0, CT_R_LOG_CONF_INVALID_KEY),
"log conf invalid key" },
{ ERR_PACK(ERR_LIB_CT, 0, CT_R_LOG_CONF_MISSING_DESCRIPTION),
"log conf missing description" },
{ ERR_PACK(ERR_LIB_CT, 0, CT_R_LOG_CONF_MISSING_KEY),
"log conf missing key" },
{ ERR_PACK(ERR_LIB_CT, 0, CT_R_LOG_KEY_INVALID), "log key invalid" },
{ ERR_PACK(ERR_LIB_CT, 0, CT_R_SCT_FUTURE_TIMESTAMP),
"sct future timestamp" },
{ ERR_PACK(ERR_LIB_CT, 0, CT_R_SCT_INVALID), "sct invalid" },
{ ERR_PACK(ERR_LIB_CT, 0, CT_R_SCT_INVALID_SIGNATURE),
"sct invalid signature" },
{ ERR_PACK(ERR_LIB_CT, 0, CT_R_SCT_LIST_INVALID), "sct list invalid" },
{ ERR_PACK(ERR_LIB_CT, 0, CT_R_SCT_LOG_ID_MISMATCH), "sct log id mismatch" },
{ ERR_PACK(ERR_LIB_CT, 0, CT_R_SCT_NOT_SET), "sct not set" },
{ ERR_PACK(ERR_LIB_CT, 0, CT_R_SCT_UNSUPPORTED_VERSION),
"sct unsupported version" },
{ ERR_PACK(ERR_LIB_CT, 0, CT_R_UNRECOGNIZED_SIGNATURE_NID),
"unrecognized signature nid" },
{ ERR_PACK(ERR_LIB_CT, 0, CT_R_UNSUPPORTED_ENTRY_TYPE),
"unsupported entry type" },
{ ERR_PACK(ERR_LIB_CT, 0, CT_R_UNSUPPORTED_VERSION), "unsupported version" },
{ 0, NULL }
};
#endif
int ossl_err_load_CT_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(CT_str_reasons[0].error) == NULL)
ERR_load_strings_const(CT_str_reasons);
#endif
return 1;
}
#else
NON_EMPTY_TRANSLATION_UNIT
#endif
crypto/dh/dh_err.c
-77
View File
@@ -1,77 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2023 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 <openssl/err.h>
#include <openssl/dherr.h>
#include "crypto/dherr.h"
#ifndef OPENSSL_NO_DH
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA DH_str_reasons[] = {
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_BAD_FFC_PARAMETERS), "bad ffc parameters" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_BAD_GENERATOR), "bad generator" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_BN_DECODE_ERROR), "bn decode error" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_BN_ERROR), "bn error" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_CHECK_INVALID_J_VALUE),
"check invalid j value" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_CHECK_INVALID_Q_VALUE),
"check invalid q value" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_CHECK_PUBKEY_INVALID),
"check pubkey invalid" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_CHECK_PUBKEY_TOO_LARGE),
"check pubkey too large" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_CHECK_PUBKEY_TOO_SMALL),
"check pubkey too small" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_CHECK_P_NOT_PRIME), "check p not prime" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_CHECK_P_NOT_SAFE_PRIME),
"check p not safe prime" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_CHECK_Q_NOT_PRIME), "check q not prime" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_DECODE_ERROR), "decode error" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_INVALID_PARAMETER_NAME),
"invalid parameter name" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_INVALID_PARAMETER_NID),
"invalid parameter nid" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_INVALID_PUBKEY), "invalid public key" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_INVALID_SECRET), "invalid secret" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_INVALID_SIZE), "invalid size" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_KDF_PARAMETER_ERROR), "kdf parameter error" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_KEYS_NOT_SET), "keys not set" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_MISSING_PUBKEY), "missing pubkey" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_MODULUS_TOO_LARGE), "modulus too large" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_MODULUS_TOO_SMALL), "modulus too small" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_NOT_SUITABLE_GENERATOR),
"not suitable generator" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_NO_PARAMETERS_SET), "no parameters set" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_NO_PRIVATE_VALUE), "no private value" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_PARAMETER_ENCODING_ERROR),
"parameter encoding error" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_PEER_KEY_ERROR), "peer key error" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_Q_TOO_LARGE), "q too large" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_SHARED_INFO_ERROR), "shared info error" },
{ ERR_PACK(ERR_LIB_DH, 0, DH_R_UNABLE_TO_CHECK_GENERATOR),
"unable to check generator" },
{ 0, NULL }
};
#endif
int ossl_err_load_DH_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(DH_str_reasons[0].error) == NULL)
ERR_load_strings_const(DH_str_reasons);
#endif
return 1;
}
#else
NON_EMPTY_TRANSLATION_UNIT
#endif
crypto/dsa/dsa_err.c
-55
View File
@@ -1,55 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2023 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 <openssl/err.h>
#include <openssl/dsaerr.h>
#include "crypto/dsaerr.h"
#ifndef OPENSSL_NO_DSA
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA DSA_str_reasons[] = {
{ ERR_PACK(ERR_LIB_DSA, 0, DSA_R_BAD_FFC_PARAMETERS), "bad ffc parameters" },
{ ERR_PACK(ERR_LIB_DSA, 0, DSA_R_BAD_Q_VALUE), "bad q value" },
{ ERR_PACK(ERR_LIB_DSA, 0, DSA_R_BN_DECODE_ERROR), "bn decode error" },
{ ERR_PACK(ERR_LIB_DSA, 0, DSA_R_BN_ERROR), "bn error" },
{ ERR_PACK(ERR_LIB_DSA, 0, DSA_R_DECODE_ERROR), "decode error" },
{ ERR_PACK(ERR_LIB_DSA, 0, DSA_R_INVALID_DIGEST_TYPE),
"invalid digest type" },
{ ERR_PACK(ERR_LIB_DSA, 0, DSA_R_INVALID_PARAMETERS), "invalid parameters" },
{ ERR_PACK(ERR_LIB_DSA, 0, DSA_R_MISSING_PARAMETERS), "missing parameters" },
{ ERR_PACK(ERR_LIB_DSA, 0, DSA_R_MISSING_PRIVATE_KEY),
"missing private key" },
{ ERR_PACK(ERR_LIB_DSA, 0, DSA_R_MODULUS_TOO_LARGE), "modulus too large" },
{ ERR_PACK(ERR_LIB_DSA, 0, DSA_R_NO_PARAMETERS_SET), "no parameters set" },
{ ERR_PACK(ERR_LIB_DSA, 0, DSA_R_PARAMETER_ENCODING_ERROR),
"parameter encoding error" },
{ ERR_PACK(ERR_LIB_DSA, 0, DSA_R_P_NOT_PRIME), "p not prime" },
{ ERR_PACK(ERR_LIB_DSA, 0, DSA_R_Q_NOT_PRIME), "q not prime" },
{ ERR_PACK(ERR_LIB_DSA, 0, DSA_R_SEED_LEN_SMALL),
"seed_len is less than the length of q" },
{ ERR_PACK(ERR_LIB_DSA, 0, DSA_R_TOO_MANY_RETRIES), "too many retries" },
{ 0, NULL }
};
#endif
int ossl_err_load_DSA_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(DSA_str_reasons[0].error) == NULL)
ERR_load_strings_const(DSA_str_reasons);
#endif
return 1;
}
#else
NON_EMPTY_TRANSLATION_UNIT
#endif
crypto/dso/dso_err.c
-56
View File
@@ -1,56 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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 <openssl/err.h>
#include "internal/dsoerr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA DSO_str_reasons[] = {
{ ERR_PACK(ERR_LIB_DSO, 0, DSO_R_CTRL_FAILED), "control command failed" },
{ ERR_PACK(ERR_LIB_DSO, 0, DSO_R_DSO_ALREADY_LOADED), "dso already loaded" },
{ ERR_PACK(ERR_LIB_DSO, 0, DSO_R_EMPTY_FILE_STRUCTURE),
"empty file structure" },
{ ERR_PACK(ERR_LIB_DSO, 0, DSO_R_FAILURE), "failure" },
{ ERR_PACK(ERR_LIB_DSO, 0, DSO_R_FILENAME_TOO_BIG), "filename too big" },
{ ERR_PACK(ERR_LIB_DSO, 0, DSO_R_FINISH_FAILED),
"cleanup method function failed" },
{ ERR_PACK(ERR_LIB_DSO, 0, DSO_R_INCORRECT_FILE_SYNTAX),
"incorrect file syntax" },
{ ERR_PACK(ERR_LIB_DSO, 0, DSO_R_LOAD_FAILED),
"could not load the shared library" },
{ ERR_PACK(ERR_LIB_DSO, 0, DSO_R_NAME_TRANSLATION_FAILED),
"name translation failed" },
{ ERR_PACK(ERR_LIB_DSO, 0, DSO_R_NO_FILENAME), "no filename" },
{ ERR_PACK(ERR_LIB_DSO, 0, DSO_R_NULL_HANDLE),
"a null shared library handle was used" },
{ ERR_PACK(ERR_LIB_DSO, 0, DSO_R_SET_FILENAME_FAILED),
"set filename failed" },
{ ERR_PACK(ERR_LIB_DSO, 0, DSO_R_STACK_ERROR),
"the meth_data stack is corrupt" },
{ ERR_PACK(ERR_LIB_DSO, 0, DSO_R_SYM_FAILURE),
"could not bind to the requested symbol name" },
{ ERR_PACK(ERR_LIB_DSO, 0, DSO_R_UNLOAD_FAILED),
"could not unload the shared library" },
{ ERR_PACK(ERR_LIB_DSO, 0, DSO_R_UNSUPPORTED),
"functionality not supported" },
{ 0, NULL }
};
#endif
int ossl_err_load_DSO_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(DSO_str_reasons[0].error) == NULL)
ERR_load_strings_const(DSO_str_reasons);
#endif
return 1;
}
crypto/ec/ec_err.c
-136
View File
@@ -1,136 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2023 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 <openssl/err.h>
#include <openssl/ecerr.h>
#include "crypto/ecerr.h"
#ifndef OPENSSL_NO_EC
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA EC_str_reasons[] = {
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_ASN1_ERROR), "asn1 error" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_BAD_SIGNATURE), "bad signature" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_BIGNUM_OUT_OF_RANGE), "bignum out of range" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_BUFFER_TOO_SMALL), "buffer too small" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_CANNOT_INVERT), "cannot invert" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_COORDINATES_OUT_OF_RANGE),
"coordinates out of range" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_CURVE_DOES_NOT_SUPPORT_ECDH),
"curve does not support ecdh" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_CURVE_DOES_NOT_SUPPORT_ECDSA),
"curve does not support ecdsa" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_CURVE_DOES_NOT_SUPPORT_SIGNING),
"curve does not support signing" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_DECODE_ERROR), "decode error" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_DISCRIMINANT_IS_ZERO),
"discriminant is zero" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_EC_GROUP_NEW_BY_NAME_FAILURE),
"ec group new by name failure" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_EXPLICIT_PARAMS_NOT_SUPPORTED),
"explicit params not supported" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_FAILED_MAKING_PUBLIC_KEY),
"failed making public key" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_FIELD_TOO_LARGE), "field too large" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_GF2M_NOT_SUPPORTED), "gf2m not supported" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_GROUP2PKPARAMETERS_FAILURE),
"group2pkparameters failure" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_I2D_ECPKPARAMETERS_FAILURE),
"i2d ecpkparameters failure" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INCOMPATIBLE_OBJECTS),
"incompatible objects" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_A), "invalid a" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_ARGUMENT), "invalid argument" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_B), "invalid b" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_COFACTOR), "invalid cofactor" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_COMPRESSED_POINT),
"invalid compressed point" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_COMPRESSION_BIT),
"invalid compression bit" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_CURVE), "invalid curve" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_DIGEST), "invalid digest" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_DIGEST_TYPE), "invalid digest type" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_ENCODING), "invalid encoding" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_FIELD), "invalid field" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_FORM), "invalid form" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_GENERATOR), "invalid generator" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_GROUP_ORDER), "invalid group order" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_KEY), "invalid key" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_LENGTH), "invalid length" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_NAMED_GROUP_CONVERSION),
"invalid named group conversion" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_OUTPUT_LENGTH),
"invalid output length" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_P), "invalid p" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_PEER_KEY), "invalid peer key" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_PENTANOMIAL_BASIS),
"invalid pentanomial basis" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_PRIVATE_KEY), "invalid private key" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_SEED), "invalid seed" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_INVALID_TRINOMIAL_BASIS),
"invalid trinomial basis" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_KDF_PARAMETER_ERROR), "kdf parameter error" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_KEYS_NOT_SET), "keys not set" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_LADDER_POST_FAILURE), "ladder post failure" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_LADDER_PRE_FAILURE), "ladder pre failure" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_LADDER_STEP_FAILURE), "ladder step failure" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_MISSING_OID), "missing OID" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_MISSING_PARAMETERS), "missing parameters" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_MISSING_PRIVATE_KEY), "missing private key" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_NEED_NEW_SETUP_VALUES),
"need new setup values" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_NOT_A_NIST_PRIME), "not a NIST prime" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_NOT_IMPLEMENTED), "not implemented" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_NOT_INITIALIZED), "not initialized" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_NO_PARAMETERS_SET), "no parameters set" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_NO_PRIVATE_VALUE), "no private value" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_OPERATION_NOT_SUPPORTED),
"operation not supported" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_PASSED_NULL_PARAMETER),
"passed null parameter" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_PEER_KEY_ERROR), "peer key error" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_POINT_ARITHMETIC_FAILURE),
"point arithmetic failure" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_POINT_AT_INFINITY), "point at infinity" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_POINT_COORDINATES_BLIND_FAILURE),
"point coordinates blind failure" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_POINT_IS_NOT_ON_CURVE),
"point is not on curve" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_RANDOM_NUMBER_GENERATION_FAILED),
"random number generation failed" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_SHARED_INFO_ERROR), "shared info error" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_SLOT_FULL), "slot full" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_TOO_MANY_RETRIES), "too many retries" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_UNDEFINED_GENERATOR), "undefined generator" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_UNDEFINED_ORDER), "undefined order" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_UNKNOWN_COFACTOR), "unknown cofactor" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_UNKNOWN_GROUP), "unknown group" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_UNKNOWN_ORDER), "unknown order" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_UNSUPPORTED_FIELD), "unsupported field" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_WRONG_CURVE_PARAMETERS),
"wrong curve parameters" },
{ ERR_PACK(ERR_LIB_EC, 0, EC_R_WRONG_ORDER), "wrong order" },
{ 0, NULL }
};
#endif
int ossl_err_load_EC_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(EC_str_reasons[0].error) == NULL)
ERR_load_strings_const(EC_str_reasons);
#endif
return 1;
}
#else
NON_EMPTY_TRANSLATION_UNIT
#endif
crypto/encode_decode/decoder_err.c
-36
View File
@@ -1,36 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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 <openssl/err.h>
#include <openssl/decodererr.h>
#include "crypto/decodererr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA OSSL_DECODER_str_reasons[] = {
{ ERR_PACK(ERR_LIB_OSSL_DECODER, 0, OSSL_DECODER_R_COULD_NOT_DECODE_OBJECT),
"could not decode object" },
{ ERR_PACK(ERR_LIB_OSSL_DECODER, 0, OSSL_DECODER_R_DECODER_NOT_FOUND),
"decoder not found" },
{ ERR_PACK(ERR_LIB_OSSL_DECODER, 0, OSSL_DECODER_R_MISSING_GET_PARAMS),
"missing get params" },
{ 0, NULL }
};
#endif
int ossl_err_load_OSSL_DECODER_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(OSSL_DECODER_str_reasons[0].error) == NULL)
ERR_load_strings_const(OSSL_DECODER_str_reasons);
#endif
return 1;
}
crypto/encode_decode/encoder_err.c
-40
View File
@@ -1,40 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-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 <openssl/err.h>
#include <openssl/encodererr.h>
#include "crypto/encodererr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA OSSL_ENCODER_str_reasons[] = {
{ ERR_PACK(ERR_LIB_OSSL_ENCODER, 0, OSSL_ENCODER_R_BAD_PARAMETER_VALUE),
"bad parameter value" },
{ ERR_PACK(ERR_LIB_OSSL_ENCODER, 0, OSSL_ENCODER_R_ENCODER_NOT_FOUND),
"encoder not found" },
{ ERR_PACK(ERR_LIB_OSSL_ENCODER, 0, OSSL_ENCODER_R_INCORRECT_PROPERTY_QUERY),
"incorrect property query" },
{ ERR_PACK(ERR_LIB_OSSL_ENCODER, 0, OSSL_ENCODER_R_MISSING_GET_PARAMS),
"missing get params" },
{ ERR_PACK(ERR_LIB_OSSL_ENCODER, 0, OSSL_ENCODER_R_UNKNOWN_PARAMETER_NAME),
"unknown parameter name" },
{ 0, NULL }
};
#endif
int ossl_err_load_OSSL_ENCODER_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(OSSL_ENCODER_str_reasons[0].error) == NULL)
ERR_load_strings_const(OSSL_ENCODER_str_reasons);
#endif
return 1;
}
crypto/err/README.md
+36 -42
View File
@@ -1,55 +1,49 @@
Adding new libraries
====================
When adding a new sub-library to OpenSSL, assign it a library number
`ERR_LIB_XXX`, define a macro `XXXerr()` (both in `err.h`), add its
name to `ERR_str_libraries[]` (in `crypto/err/err.c`), and add
`ERR_load_XXX_strings()` to the `ERR_load_crypto_strings()` function
(in `crypto/err/err_all.c`). Finally, add an entry:
When adding a new sub-library to OpenSSL:
L XXX xxx.h xxx_err.c
- assign it a library number `ERR_LIB_XXX` in `include/openssl/err.h`;
- add its name to `ERR_str_libraries[]` in `crypto/err/err.c`;
- add a call to `ossl_err_load_XXX_strings()` in
`ossl_err_load_crypto_strings()` in `crypto/err/err_all.c`. That
function is defined in the generated source named below;
- add an entry to `crypto/err/openssl.ec`:
to `crypto/err/openssl.ec`, and add `xxx_err.c` to the `Makefile`.
Running make errors will then generate a file `xxx_err.c`, and
add all error codes used in the library to `xxx.h`.
L XXX include/openssl/xxxerr.h crypto/xxx/xxx_err.c
Additionally the library include file must have a certain form.
Typically it will initially look like this:
The fields after the library name are the public header, the source
file, and an optional private header. `NONE` stands for a file that
is not wanted. The public header must be under `include/openssl/`,
and a private header may only be given for an internal library;
#ifndef HEADER_XXX_H
#define HEADER_XXX_H
- add the files named on that entry to the block of generated error
files in `.gitignore`.
#ifdef __cplusplus
extern "C" {
#endif
/* Include files */
#include <openssl/bio.h>
#include <openssl/x509.h>
/* Macros, structures and function prototypes */
/* BEGIN ERROR CODES */
The `BEGIN ERROR CODES` sequence is used by the error code
generation script as the point to place new error codes, any text
after this point will be overwritten when make errors is run.
The closing `#endif` etc will be automatically added by the script.
The generated C error code file `xxx_err.c` will load the header
files `stdio.h`, `openssl/err.h` and `openssl/xxx.h` so the
header file must load any additional header files containing any
definitions it uses.
Those files are produced during the build from `crypto/err/openssl.ec`
and `crypto/err/openssl.txt`, and are not in git. They are left
read-only: an edit to one is lost the next time it is generated.
Adding new error codes
======================
Instead of manually adding error codes into `crypto/err/openssl.txt`,
it is recommended to leverage `make update` for error code generation.
The target will process relevant sources and generate error codes for
any *used* error codes.
Raise an error with `ERR_raise()`, using a reason name of the form
`XXX_R_...`:
If an error code is added manually into `crypto/err/openssl.txt`,
subsequent `make update` has no effect.
ERR_raise(ERR_LIB_XXX, XXX_R_SOMETHING_FAILED);
The reason does not have to be declared first. Running
make update
scans the sources, assigns a number to each reason that does not have
one, and records it in `crypto/err/openssl.txt`:
XXX_R_SOMETHING_FAILED:100:something failed
Numbers already recorded there are kept, so they remain stable for
applications that have compiled against them.
The third field is the string returned by `ERR_reason_error_string()`.
It is derived from the reason name, with underscores replaced by
spaces; edit `crypto/err/openssl.txt` if it should read differently.
crypto/ess/ess_err.c
-48
View File
@@ -1,48 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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 <openssl/err.h>
#include <openssl/esserr.h>
#include "crypto/esserr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA ESS_str_reasons[] = {
{ ERR_PACK(ERR_LIB_ESS, 0, ESS_R_EMPTY_ESS_CERT_ID_LIST),
"empty ess cert id list" },
{ ERR_PACK(ERR_LIB_ESS, 0, ESS_R_ESS_CERT_DIGEST_ERROR),
"ess cert digest error" },
{ ERR_PACK(ERR_LIB_ESS, 0, ESS_R_ESS_CERT_ID_NOT_FOUND),
"ess cert id not found" },
{ ERR_PACK(ERR_LIB_ESS, 0, ESS_R_ESS_CERT_ID_WRONG_ORDER),
"ess cert id wrong order" },
{ ERR_PACK(ERR_LIB_ESS, 0, ESS_R_ESS_DIGEST_ALG_UNKNOWN),
"ess digest alg unknown" },
{ ERR_PACK(ERR_LIB_ESS, 0, ESS_R_ESS_SIGNING_CERTIFICATE_ERROR),
"ess signing certificate error" },
{ ERR_PACK(ERR_LIB_ESS, 0, ESS_R_ESS_SIGNING_CERT_ADD_ERROR),
"ess signing cert add error" },
{ ERR_PACK(ERR_LIB_ESS, 0, ESS_R_ESS_SIGNING_CERT_V2_ADD_ERROR),
"ess signing cert v2 add error" },
{ ERR_PACK(ERR_LIB_ESS, 0, ESS_R_MISSING_SIGNING_CERTIFICATE_ATTRIBUTE),
"missing signing certificate attribute" },
{ 0, NULL }
};
#endif
int ossl_err_load_ESS_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(ESS_str_reasons[0].error) == NULL)
ERR_load_strings_const(ESS_str_reasons);
#endif
return 1;
}
crypto/evp/evp_err.c
-236
View File
@@ -1,236 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-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 <openssl/err.h>
#include <openssl/evperr.h>
#include "crypto/evperr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA EVP_str_reasons[] = {
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_AES_KEY_SETUP_FAILED),
"aes key setup failed" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_ARIA_KEY_SETUP_FAILED),
"aria key setup failed" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_BAD_ALGORITHM_NAME), "bad algorithm name" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_BAD_DECRYPT), "bad decrypt" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_BAD_KEY_LENGTH), "bad key length" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_BUFFER_TOO_SMALL), "buffer too small" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_CACHE_CONSTANTS_FAILED),
"cache constants failed" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_CAMELLIA_KEY_SETUP_FAILED),
"camellia key setup failed" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_CANNOT_GET_PARAMETERS),
"cannot get parameters" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_CANNOT_SET_PARAMETERS),
"cannot set parameters" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_CIPHER_NOT_GCM_MODE),
"cipher not gcm mode" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_CIPHER_PARAMETER_ERROR),
"cipher parameter error" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_COMMAND_NOT_SUPPORTED),
"command not supported" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_CONFLICTING_ALGORITHM_NAME),
"conflicting algorithm name" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_CONTEXT_FINALIZED), "context finalized" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_COPY_ERROR), "copy error" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_CTRL_NOT_IMPLEMENTED),
"ctrl not implemented" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED),
"ctrl operation not implemented" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH),
"data not multiple of block length" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_DECODE_ERROR), "decode error" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_DEFAULT_QUERY_PARSE_ERROR),
"default query parse error" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_DIFFERENT_KEY_TYPES),
"different key types" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_DIFFERENT_PARAMETERS),
"different parameters" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_ERROR_LOADING_SECTION),
"error loading section" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_EXPECTING_AN_HMAC_KEY),
"expecting an hmac key" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_EXPECTING_AN_RSA_KEY),
"expecting an rsa key" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_EXPECTING_A_DH_KEY), "expecting a dh key" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_EXPECTING_A_DSA_KEY),
"expecting a dsa key" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_EXPECTING_A_ECX_KEY),
"expecting an ecx key" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_EXPECTING_A_EC_KEY), "expecting an ec key" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_EXPECTING_A_POLY1305_KEY),
"expecting a poly1305 key" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_EXPECTING_A_SIPHASH_KEY),
"expecting a siphash key" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_FINAL_ERROR), "final error" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_GENERATE_ERROR), "generate error" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_GETTING_ALGORITHMIDENTIFIER_NOT_SUPPORTED),
"getting AlgorithmIdentifier not supported" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_GET_RAW_KEY_FAILED), "get raw key failed" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_ILLEGAL_SCRYPT_PARAMETERS),
"illegal scrypt parameters" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_INACCESSIBLE_DOMAIN_PARAMETERS),
"inaccessible domain parameters" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_INACCESSIBLE_KEY), "inaccessible key" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_INITIALIZATION_ERROR),
"initialization error" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_INPUT_NOT_INITIALIZED),
"input not initialized" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_INVALID_CUSTOM_LENGTH),
"invalid custom length" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_INVALID_DIGEST), "invalid digest" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_INVALID_IV_LENGTH), "invalid iv length" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_INVALID_KEY), "invalid key" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_INVALID_KEY_LENGTH), "invalid key length" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_INVALID_LENGTH), "invalid length" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_INVALID_NULL_ALGORITHM),
"invalid null algorithm" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_INVALID_OPERATION), "invalid operation" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_INVALID_PROVIDER_FUNCTIONS),
"invalid provider functions" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_INVALID_SALT_LENGTH),
"invalid salt length" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_INVALID_SECRET_LENGTH),
"invalid secret length" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_INVALID_SEED_LENGTH),
"invalid seed length" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_INVALID_VALUE), "invalid value" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_KEYMGMT_EXPORT_FAILURE),
"keymgmt export failure" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_KEY_SETUP_FAILED), "key setup failed" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_LOCKING_NOT_SUPPORTED),
"locking not supported" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_MEMORY_LIMIT_EXCEEDED),
"memory limit exceeded" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_MESSAGE_DIGEST_IS_NULL),
"message digest is null" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_METHOD_NOT_SUPPORTED),
"method not supported" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_MISSING_PARAMETERS), "missing parameters" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_NOT_ABLE_TO_COPY_CTX),
"not able to copy ctx" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_NOT_XOF_OR_INVALID_LENGTH),
"not XOF or invalid length" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_NO_CIPHER_SET), "no cipher set" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_NO_DEFAULT_DIGEST), "no default digest" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_NO_DIGEST_SET), "no digest set" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_NO_IMPORT_FUNCTION), "no import function" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_NO_KEYMGMT_AVAILABLE),
"no keymgmt available" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_NO_KEYMGMT_PRESENT), "no keymgmt present" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_NO_KEY_SET), "no key set" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_NO_OPERATION_SET), "no operation set" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_NULL_MAC_PKEY_CTX), "null mac pkey ctx" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_ONLY_ONESHOT_SUPPORTED),
"only oneshot supported" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_OPERATION_NOT_INITIALIZED),
"operation not initialized" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE),
"operation not supported for this keytype" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_SIGNATURE_TYPE),
"operation not supported for this signature type" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_OUTPUT_WOULD_OVERFLOW),
"output would overflow" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_PARAMETER_TOO_LARGE),
"parameter too large" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_PARTIALLY_OVERLAPPING),
"partially overlapping buffers" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_PBKDF2_ERROR), "pbkdf2 error" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_PIPELINE_NOT_SUPPORTED),
"pipeline not supported" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_PKEY_APPLICATION_ASN1_METHOD_ALREADY_REGISTERED),
"pkey application asn1 method already registered" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_PRIVATE_KEY_DECODE_ERROR),
"private key decode error" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_PRIVATE_KEY_ENCODE_ERROR),
"private key encode error" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_PROVIDER_ASYM_CIPHER_FAILURE),
"provider asym cipher failure" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_PROVIDER_ASYM_CIPHER_NOT_SUPPORTED),
"provider asym cipher not supported" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_PROVIDER_GET_CTX_PARAMS_NOT_SUPPORTED),
"provider get ctx params not supported" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_PROVIDER_KEYMGMT_FAILURE),
"provider keymgmt failure" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_PROVIDER_KEYMGMT_NOT_SUPPORTED),
"provider keymgmt not supported" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_PROVIDER_SIGNATURE_FAILURE),
"provider signature failure" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_PROVIDER_SIGNATURE_NOT_SUPPORTED),
"provider signature not supported" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_PUBLIC_KEY_NOT_RSA), "public key not rsa" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_SETTING_XOF_FAILED), "setting xof failed" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_SET_DEFAULT_PROPERTY_FAILURE),
"set default property failure" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_SIGNATURE_TYPE_AND_KEY_TYPE_INCOMPATIBLE),
"signature type and key type incompatible" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_TOO_MANY_PIPES), "too many pipes" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_TOO_MANY_RECORDS), "too many records" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNABLE_TO_ENABLE_LOCKING),
"unable to enable locking" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNABLE_TO_GET_MAXIMUM_REQUEST_SIZE),
"unable to get maximum request size" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNABLE_TO_GET_RANDOM_STRENGTH),
"unable to get random strength" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNABLE_TO_LOCK_CONTEXT),
"unable to lock context" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNABLE_TO_SET_CALLBACKS),
"unable to set callbacks" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNKNOWN_BITS), "unknown bits" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNKNOWN_CIPHER), "unknown cipher" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNKNOWN_DIGEST), "unknown digest" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNKNOWN_KEY_TYPE), "unknown key type" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNKNOWN_MAX_SIZE), "unknown max size" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNKNOWN_OPTION), "unknown option" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNKNOWN_PBE_ALGORITHM),
"unknown pbe algorithm" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNKNOWN_SECURITY_BITS),
"unknown security bits" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNSUPPORTED_ALGORITHM),
"unsupported algorithm" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNSUPPORTED_CIPHER), "unsupported cipher" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNSUPPORTED_KEYLENGTH),
"unsupported keylength" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION),
"unsupported key derivation function" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNSUPPORTED_KEY_SIZE),
"unsupported key size" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNSUPPORTED_KEY_TYPE),
"unsupported key type" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNSUPPORTED_NUMBER_OF_ROUNDS),
"unsupported number of rounds" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNSUPPORTED_PRF), "unsupported prf" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM),
"unsupported private key algorithm" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UNSUPPORTED_SALT_TYPE),
"unsupported salt type" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_UPDATE_ERROR), "update error" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_WRAP_MODE_NOT_ALLOWED),
"wrap mode not allowed" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_WRONG_FINAL_BLOCK_LENGTH),
"wrong final block length" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_XTS_DATA_UNIT_IS_TOO_LARGE),
"xts data unit is too large" },
{ ERR_PACK(ERR_LIB_EVP, 0, EVP_R_XTS_DUPLICATED_KEYS),
"xts duplicated keys" },
{ 0, NULL }
};
#endif
int ossl_err_load_EVP_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(EVP_str_reasons[0].error) == NULL)
ERR_load_strings_const(EVP_str_reasons);
#endif
return 1;
}
crypto/http/http_err.c
-91
View File
@@ -1,91 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2026 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 <openssl/err.h>
#include <openssl/httperr.h>
#include "crypto/httperr.h"
#ifndef OPENSSL_NO_HTTP
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA HTTP_str_reasons[] = {
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_ASN1_LEN_EXCEEDS_MAX_RESP_LEN),
"asn1 len exceeds max resp len" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_CONNECT_FAILURE), "connect failure" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_CONTENT_TYPE_MISMATCH),
"content type mismatch" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_ERROR_PARSING_ASN1_LENGTH),
"error parsing asn1 length" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_ERROR_PARSING_CONTENT_LENGTH),
"error parsing content length" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_ERROR_PARSING_URL), "error parsing url" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_ERROR_RECEIVING), "error receiving" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_ERROR_SENDING), "error sending" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_FAILED_READING_DATA),
"failed reading data" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_HEADER_PARSE_ERROR),
"header parse error" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_INCONSISTENT_CONTENT_LENGTH),
"inconsistent content length" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_INVALID_PORT_NUMBER),
"invalid port number" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_INVALID_URL_PATH), "invalid url path" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_INVALID_URL_SCHEME),
"invalid url scheme" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_MAX_RESP_LEN_EXCEEDED),
"max resp len exceeded" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_MISSING_ASN1_ENCODING),
"missing asn1 encoding" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_MISSING_CONTENT_TYPE),
"missing content type" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_MISSING_REDIRECT_LOCATION),
"missing redirect location" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_RECEIVED_ERROR), "received error" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_RECEIVED_WRONG_HTTP_VERSION),
"received wrong http version" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_REDIRECTION_FROM_HTTPS_TO_HTTP),
"redirection from https to http" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_REDIRECTION_NOT_ENABLED),
"redirection not enabled" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_RESPONSE_LINE_TOO_LONG),
"response line too long" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_RESPONSE_PARSE_ERROR),
"response parse error" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_RESPONSE_TOO_MANY_HDRLINES),
"response too many hdrlines" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_RETRY_TIMEOUT), "retry timeout" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_SERVER_CANCELED_CONNECTION),
"server canceled connection" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_SOCK_NOT_SUPPORTED),
"sock not supported" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_STATUS_CODE_UNSUPPORTED),
"status code unsupported" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_TLS_NOT_ENABLED), "tls not enabled" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_TOO_MANY_REDIRECTIONS),
"too many redirections" },
{ ERR_PACK(ERR_LIB_HTTP, 0, HTTP_R_UNEXPECTED_CONTENT_TYPE),
"unexpected content type" },
{ 0, NULL }
};
#endif
int ossl_err_load_HTTP_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(HTTP_str_reasons[0].error) == NULL)
ERR_load_strings_const(HTTP_str_reasons);
#endif
return 1;
}
#else
NON_EMPTY_TRANSLATION_UNIT
#endif
crypto/objects/obj_err.c
-34
View File
@@ -1,34 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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 <openssl/err.h>
#include <openssl/objectserr.h>
#include "crypto/objectserr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA OBJ_str_reasons[] = {
{ ERR_PACK(ERR_LIB_OBJ, 0, OBJ_R_OID_EXISTS), "oid exists" },
{ ERR_PACK(ERR_LIB_OBJ, 0, OBJ_R_UNKNOWN_NID), "unknown nid" },
{ ERR_PACK(ERR_LIB_OBJ, 0, OBJ_R_UNKNOWN_OBJECT_NAME),
"unknown object name" },
{ 0, NULL }
};
#endif
int ossl_err_load_OBJ_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(OBJ_str_reasons[0].error) == NULL)
ERR_load_strings_const(OBJ_str_reasons);
#endif
return 1;
}
crypto/ocsp/ocsp_err.c
-75
View File
@@ -1,75 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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 <openssl/err.h>
#include <openssl/ocsperr.h>
#include "crypto/ocsperr.h"
#ifndef OPENSSL_NO_OCSP
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA OCSP_str_reasons[] = {
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_CERTIFICATE_VERIFY_ERROR),
"certificate verify error" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_DIGEST_ERR), "digest err" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_DIGEST_NAME_ERR), "digest name err" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_DIGEST_SIZE_ERR), "digest size err" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_ERROR_IN_NEXTUPDATE_FIELD),
"error in nextupdate field" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_ERROR_IN_THISUPDATE_FIELD),
"error in thisupdate field" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_MISSING_OCSPSIGNING_USAGE),
"missing ocspsigning usage" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_NEXTUPDATE_BEFORE_THISUPDATE),
"nextupdate before thisupdate" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_NOT_BASIC_RESPONSE),
"not basic response" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_NO_CERTIFICATES_IN_CHAIN),
"no certificates in chain" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_NO_RESPONSE_DATA), "no response data" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_NO_REVOKED_TIME), "no revoked time" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_NO_SIGNER_KEY), "no signer key" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE),
"private key does not match certificate" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_REQUEST_NOT_SIGNED),
"request not signed" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_RESPONSE_CONTAINS_NO_REVOCATION_DATA),
"response contains no revocation data" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_ROOT_CA_NOT_TRUSTED),
"root ca not trusted" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_SIGNATURE_FAILURE), "signature failure" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_SIGNER_CERTIFICATE_NOT_FOUND),
"signer certificate not found" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_STATUS_EXPIRED), "status expired" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_STATUS_NOT_YET_VALID),
"status not yet valid" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_STATUS_TOO_OLD), "status too old" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_UNKNOWN_MESSAGE_DIGEST),
"unknown message digest" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_UNKNOWN_NID), "unknown nid" },
{ ERR_PACK(ERR_LIB_OCSP, 0, OCSP_R_UNSUPPORTED_REQUESTORNAME_TYPE),
"unsupported requestorname type" },
{ 0, NULL }
};
#endif
int ossl_err_load_OCSP_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(OCSP_str_reasons[0].error) == NULL)
ERR_load_strings_const(OCSP_str_reasons);
#endif
return 1;
}
#else
NON_EMPTY_TRANSLATION_UNIT
#endif
crypto/pem/pem_err.c
-76
View File
@@ -1,76 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-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 <openssl/err.h>
#include <openssl/pemerr.h>
#include "crypto/pemerr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA PEM_str_reasons[] = {
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_BAD_BASE64_DECODE), "bad base64 decode" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_BAD_DECRYPT), "bad decrypt" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_BAD_END_LINE), "bad end line" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_BAD_IV_CHARS), "bad iv chars" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_BAD_MAGIC_NUMBER), "bad magic number" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_BAD_PASSWORD_READ), "bad password read" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_BAD_VERSION_NUMBER), "bad version number" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_BIO_WRITE_FAILURE), "bio write failure" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_CIPHER_IS_NULL), "cipher is null" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_ERROR_CONVERTING_PRIVATE_KEY),
"error converting private key" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_EXPECTING_DSS_KEY_BLOB),
"expecting dss key blob" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_EXPECTING_PRIVATE_KEY_BLOB),
"expecting private key blob" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_EXPECTING_PUBLIC_KEY_BLOB),
"expecting public key blob" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_EXPECTING_RSA_KEY_BLOB),
"expecting rsa key blob" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_HEADER_TOO_LONG), "header too long" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_INCONSISTENT_HEADER),
"inconsistent header" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_KEYBLOB_HEADER_PARSE_ERROR),
"keyblob header parse error" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_KEYBLOB_TOO_SHORT), "keyblob too short" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_MISSING_DEK_IV), "missing dek iv" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_NOT_DEK_INFO), "not dek info" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_NOT_ENCRYPTED), "not encrypted" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_NOT_PROC_TYPE), "not proc type" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_NO_START_LINE), "no start line" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_PROBLEMS_GETTING_PASSWORD),
"problems getting password" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_PVK_DATA_TOO_SHORT), "pvk data too short" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_PVK_TOO_SHORT), "pvk too short" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_READ_KEY), "read key" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_SHORT_HEADER), "short header" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_UNEXPECTED_DEK_IV), "unexpected dek iv" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_UNSUPPORTED_CIPHER), "unsupported cipher" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_UNSUPPORTED_ENCRYPTION),
"unsupported encryption" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_UNSUPPORTED_KEY_COMPONENTS),
"unsupported key components" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_UNSUPPORTED_PUBLIC_KEY_TYPE),
"unsupported public key type" },
{ ERR_PACK(ERR_LIB_PEM, 0, PEM_R_UNSUPPORTED_PVK_KEY_TYPE),
"unsupported pvk key type" },
{ 0, NULL }
};
#endif
int ossl_err_load_PEM_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(PEM_str_reasons[0].error) == NULL)
ERR_load_strings_const(PEM_str_reasons);
#endif
return 1;
}
crypto/pkcs12/pk12err.c
-64
View File
@@ -1,64 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-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 <openssl/err.h>
#include <openssl/pkcs12err.h>
#include "crypto/pkcs12err.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA PKCS12_str_reasons[] = {
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_CALLBACK_FAILED), "callback failed" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_CANT_PACK_STRUCTURE),
"can't pack structure" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_CONTENT_TYPE_NOT_DATA),
"content type not data" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_DECODE_ERROR), "decode error" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_ENCODE_ERROR), "encode error" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_ENCRYPT_ERROR), "encrypt error" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_ERROR_SETTING_ENCRYPTED_DATA_TYPE),
"error setting encrypted data type" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_INVALID_NULL_ARGUMENT),
"invalid null argument" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_INVALID_NULL_PKCS12_POINTER),
"invalid null pkcs12 pointer" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_INVALID_SALT_LENGTH),
"invalid salt length" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_INVALID_TYPE), "invalid type" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_IV_GEN_ERROR), "iv gen error" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_KEY_GEN_ERROR), "key gen error" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_MAC_ABSENT), "mac absent" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_MAC_GENERATION_ERROR),
"mac generation error" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_MAC_SETUP_ERROR), "mac setup error" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_MAC_STRING_SET_ERROR),
"mac string set error" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_MAC_VERIFY_FAILURE),
"mac verify failure" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_PARSE_ERROR), "parse error" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_PKCS12_CIPHERFINAL_ERROR),
"pkcs12 cipherfinal error" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_UNKNOWN_DIGEST_ALGORITHM),
"unknown digest algorithm" },
{ ERR_PACK(ERR_LIB_PKCS12, 0, PKCS12_R_UNSUPPORTED_PKCS12_MODE),
"unsupported pkcs12 mode" },
{ 0, NULL }
};
#endif
int ossl_err_load_PKCS12_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(PKCS12_str_reasons[0].error) == NULL)
ERR_load_strings_const(PKCS12_str_reasons);
#endif
return 1;
}
crypto/pkcs7/pkcs7err.c
-98
View File
@@ -1,98 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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 <openssl/err.h>
#include <openssl/pkcs7err.h>
#include "crypto/pkcs7err.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA PKCS7_str_reasons[] = {
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_CERTIFICATE_VERIFY_ERROR),
"certificate verify error" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER),
"cipher has no object identifier" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_CIPHER_NOT_INITIALIZED),
"cipher not initialized" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_CONTENT_AND_DATA_PRESENT),
"content and data present" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_CTRL_ERROR), "ctrl error" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_DECRYPT_ERROR), "decrypt error" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_DIGEST_FAILURE), "digest failure" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_ENCRYPTION_CTRL_FAILURE),
"encryption ctrl failure" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE),
"encryption not supported for this key type" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_ERROR_ADDING_RECIPIENT),
"error adding recipient" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_ERROR_SETTING_CIPHER),
"error setting cipher" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_INVALID_NULL_POINTER),
"invalid null pointer" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_INVALID_SIGNED_DATA_TYPE),
"invalid signed data type" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_NO_CONTENT), "no content" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_NO_DEFAULT_DIGEST),
"no default digest" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_NO_MATCHING_DIGEST_TYPE_FOUND),
"no matching digest type found" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_NO_RECIPIENT_MATCHES_CERTIFICATE),
"no recipient matches certificate" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_NO_SIGNATURES_ON_DATA),
"no signatures on data" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_NO_SIGNERS), "no signers" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE),
"operation not supported on this type" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_PKCS7_ADD_SIGNATURE_ERROR),
"pkcs7 add signature error" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_PKCS7_ADD_SIGNER_ERROR),
"pkcs7 add signer error" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_PKCS7_DATASIGN), "pkcs7 datasign" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE),
"private key does not match certificate" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_SIGNATURE_FAILURE),
"signature failure" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_SIGNER_CERTIFICATE_NOT_FOUND),
"signer certificate not found" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_SIGNING_CTRL_FAILURE),
"signing ctrl failure" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE),
"signing not supported for this key type" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_SMIME_TEXT_ERROR), "smime text error" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_UNABLE_TO_FIND_CERTIFICATE),
"unable to find certificate" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_UNABLE_TO_FIND_MEM_BIO),
"unable to find mem bio" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST),
"unable to find message digest" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_UNKNOWN_DIGEST_TYPE),
"unknown digest type" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_UNKNOWN_OPERATION),
"unknown operation" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_UNSUPPORTED_CIPHER_TYPE),
"unsupported cipher type" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_UNSUPPORTED_CONTENT_TYPE),
"unsupported content type" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_WRONG_CONTENT_TYPE),
"wrong content type" },
{ ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_WRONG_PKCS7_TYPE), "wrong pkcs7 type" },
{ 0, NULL }
};
#endif
int ossl_err_load_PKCS7_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(PKCS7_str_reasons[0].error) == NULL)
ERR_load_strings_const(PKCS7_str_reasons);
#endif
return 1;
}
crypto/property/property_err.c
-46
View File
@@ -1,46 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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 <openssl/err.h>
#include "internal/propertyerr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA PROP_str_reasons[] = {
{ ERR_PACK(ERR_LIB_PROP, 0, PROP_R_NAME_TOO_LONG), "name too long" },
{ ERR_PACK(ERR_LIB_PROP, 0, PROP_R_NOT_AN_ASCII_CHARACTER),
"not an ascii character" },
{ ERR_PACK(ERR_LIB_PROP, 0, PROP_R_NOT_AN_HEXADECIMAL_DIGIT),
"not an hexadecimal digit" },
{ ERR_PACK(ERR_LIB_PROP, 0, PROP_R_NOT_AN_IDENTIFIER), "not an identifier" },
{ ERR_PACK(ERR_LIB_PROP, 0, PROP_R_NOT_AN_OCTAL_DIGIT),
"not an octal digit" },
{ ERR_PACK(ERR_LIB_PROP, 0, PROP_R_NOT_A_DECIMAL_DIGIT),
"not a decimal digit" },
{ ERR_PACK(ERR_LIB_PROP, 0, PROP_R_NO_MATCHING_STRING_DELIMITER),
"no matching string delimiter" },
{ ERR_PACK(ERR_LIB_PROP, 0, PROP_R_NO_VALUE), "no value" },
{ ERR_PACK(ERR_LIB_PROP, 0, PROP_R_PARSE_FAILED), "parse failed" },
{ ERR_PACK(ERR_LIB_PROP, 0, PROP_R_STRING_TOO_LONG), "string too long" },
{ ERR_PACK(ERR_LIB_PROP, 0, PROP_R_TRAILING_CHARACTERS),
"trailing characters" },
{ 0, NULL }
};
#endif
int ossl_err_load_PROP_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(PROP_str_reasons[0].error) == NULL)
ERR_load_strings_const(PROP_str_reasons);
#endif
return 1;
}
crypto/rand/rand_err.c
-111
View File
@@ -1,111 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2024 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 <openssl/err.h>
#include <openssl/randerr.h>
#include "crypto/randerr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA RAND_str_reasons[] = {
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_ADDITIONAL_INPUT_TOO_LONG),
"additional input too long" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_ALREADY_INSTANTIATED),
"already instantiated" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_ARGUMENT_OUT_OF_RANGE),
"argument out of range" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_CANNOT_OPEN_FILE), "Cannot open file" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_DRBG_ALREADY_INITIALIZED),
"drbg already initialized" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_DRBG_NOT_INITIALISED),
"drbg not initialised" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_ENTROPY_INPUT_TOO_LONG),
"entropy input too long" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_ENTROPY_OUT_OF_RANGE),
"entropy out of range" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_ERROR_ENTROPY_POOL_WAS_IGNORED),
"error entropy pool was ignored" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_ERROR_INITIALISING_DRBG),
"error initialising drbg" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_ERROR_INSTANTIATING_DRBG),
"error instantiating drbg" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_ERROR_RETRIEVING_ADDITIONAL_INPUT),
"error retrieving additional input" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_ERROR_RETRIEVING_ENTROPY),
"error retrieving entropy" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_ERROR_RETRIEVING_NONCE),
"error retrieving nonce" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_FAILED_TO_CREATE_LOCK),
"failed to create lock" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_FUNC_NOT_IMPLEMENTED),
"Function not implemented" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_FWRITE_ERROR), "Error writing file" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_GENERATE_ERROR), "generate error" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_INSUFFICIENT_DRBG_STRENGTH),
"insufficient drbg strength" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_INTERNAL_ERROR), "internal error" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_INVALID_PROPERTY_QUERY),
"invalid property query" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_IN_ERROR_STATE), "in error state" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_NOT_A_REGULAR_FILE),
"Not a regular file" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_NOT_INSTANTIATED), "not instantiated" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_NO_DRBG_IMPLEMENTATION_SELECTED),
"no drbg implementation selected" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_PARENT_LOCKING_NOT_ENABLED),
"parent locking not enabled" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_PARENT_STRENGTH_TOO_WEAK),
"parent strength too weak" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_PERSONALISATION_STRING_TOO_LONG),
"personalisation string too long" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_PREDICTION_RESISTANCE_NOT_SUPPORTED),
"prediction resistance not supported" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_PRNG_NOT_SEEDED), "PRNG not seeded" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_RANDOM_POOL_IS_EMPTY),
"random pool is empty" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_RANDOM_POOL_OVERFLOW),
"random pool overflow" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_RANDOM_POOL_UNDERFLOW),
"random pool underflow" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_REQUEST_TOO_LARGE_FOR_DRBG),
"request too large for drbg" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_RESEED_ERROR), "reseed error" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_SELFTEST_FAILURE), "selftest failure" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_TOO_LITTLE_NONCE_REQUESTED),
"too little nonce requested" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_TOO_MUCH_NONCE_REQUESTED),
"too much nonce requested" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_UNABLE_TO_CREATE_DRBG),
"unable to create drbg" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_UNABLE_TO_FETCH_DRBG),
"unable to fetch drbg" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_UNABLE_TO_GET_PARENT_RESEED_PROP_COUNTER),
"unable to get parent reseed prop counter" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_UNABLE_TO_GET_PARENT_STRENGTH),
"unable to get parent strength" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_UNABLE_TO_LOCK_PARENT),
"unable to lock parent" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_UNSUPPORTED_DRBG_FLAGS),
"unsupported drbg flags" },
{ ERR_PACK(ERR_LIB_RAND, 0, RAND_R_UNSUPPORTED_DRBG_TYPE),
"unsupported drbg type" },
{ 0, NULL }
};
#endif
int ossl_err_load_RAND_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(RAND_str_reasons[0].error) == NULL)
ERR_load_strings_const(RAND_str_reasons);
#endif
return 1;
}
crypto/rsa/rsa_err.c
-164
View File
@@ -1,164 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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 <openssl/err.h>
#include <openssl/rsaerr.h>
#include "crypto/rsaerr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA RSA_str_reasons[] = {
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_ALGORITHM_MISMATCH), "algorithm mismatch" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_BAD_E_VALUE), "bad e value" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_BAD_FIXED_HEADER_DECRYPT),
"bad fixed header decrypt" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_BAD_PAD_BYTE_COUNT), "bad pad byte count" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_BAD_SIGNATURE), "bad signature" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_BLOCK_TYPE_IS_NOT_01),
"block type is not 01" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_BLOCK_TYPE_IS_NOT_02),
"block type is not 02" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_DATA_GREATER_THAN_MOD_LEN),
"data greater than mod len" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_DATA_TOO_LARGE), "data too large" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE),
"data too large for key size" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_DATA_TOO_LARGE_FOR_MODULUS),
"data too large for modulus" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_DATA_TOO_SMALL), "data too small" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_DATA_TOO_SMALL_FOR_KEY_SIZE),
"data too small for key size" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_DIGEST_DOES_NOT_MATCH),
"digest does not match" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_DIGEST_NOT_ALLOWED), "digest not allowed" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY),
"digest too big for rsa key" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_DMP1_NOT_CONGRUENT_TO_D),
"dmp1 not congruent to d" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_DMQ1_NOT_CONGRUENT_TO_D),
"dmq1 not congruent to d" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_D_E_NOT_CONGRUENT_TO_1),
"d e not congruent to 1" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_FIRST_OCTET_INVALID),
"first octet invalid" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE),
"illegal or unsupported padding mode" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_DIGEST), "invalid digest" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_DIGEST_LENGTH),
"invalid digest length" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_HEADER), "invalid header" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_KEYPAIR), "invalid keypair" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_KEY_LENGTH), "invalid key length" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_LABEL), "invalid label" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_LENGTH), "invalid length" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_MESSAGE_LENGTH),
"invalid message length" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_MGF1_MD), "invalid mgf1 md" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_MODULUS), "invalid modulus" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_MULTI_PRIME_KEY),
"invalid multi prime key" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_OAEP_PARAMETERS),
"invalid oaep parameters" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_PADDING), "invalid padding" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_PADDING_MODE),
"invalid padding mode" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_PSS_PARAMETERS),
"invalid pss parameters" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_PSS_SALTLEN),
"invalid pss saltlen" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_REQUEST), "invalid request" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_SALT_LENGTH),
"invalid salt length" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_STRENGTH), "invalid strength" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_TRAILER), "invalid trailer" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_INVALID_X931_DIGEST),
"invalid x931 digest" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_IQMP_NOT_INVERSE_OF_Q),
"iqmp not inverse of q" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_KEY_PRIME_NUM_INVALID),
"key prime num invalid" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_KEY_SIZE_TOO_SMALL), "key size too small" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_LAST_OCTET_INVALID), "last octet invalid" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_MGF1_DIGEST_NOT_ALLOWED),
"mgf1 digest not allowed" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_MISSING_PRIVATE_KEY),
"missing private key" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_MODULUS_TOO_LARGE), "modulus too large" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_MP_COEFFICIENT_NOT_INVERSE_OF_R),
"mp coefficient not inverse of r" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_MP_EXPONENT_NOT_CONGRUENT_TO_D),
"mp exponent not congruent to d" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_MP_R_NOT_PRIME), "mp r not prime" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_NO_PUBLIC_EXPONENT), "no public exponent" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_NULL_BEFORE_BLOCK_MISSING),
"null before block missing" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_N_DOES_NOT_EQUAL_PRODUCT_OF_PRIMES),
"n does not equal product of primes" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_N_DOES_NOT_EQUAL_P_Q),
"n does not equal p q" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_OAEP_DECODING_ERROR),
"oaep decoding error" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE),
"operation not supported for this keytype" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_PADDING_CHECK_FAILED),
"padding check failed" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_PAIRWISE_TEST_FAILURE),
"pairwise test failure" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_PKCS_DECODING_ERROR),
"pkcs decoding error" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_PSS_SALTLEN_TOO_SMALL),
"pss saltlen too small" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_PUB_EXPONENT_OUT_OF_RANGE),
"pub exponent out of range" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_P_NOT_PRIME), "p not prime" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_Q_NOT_PRIME), "q not prime" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_RANDOMNESS_SOURCE_STRENGTH_INSUFFICIENT),
"randomness source strength insufficient" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_RSA_OPERATIONS_NOT_SUPPORTED),
"rsa operations not supported" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_SLEN_CHECK_FAILED),
"salt length check failed" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_SLEN_RECOVERY_FAILED),
"salt length recovery failed" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD),
"the asn1 object identifier is not known for this md" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_UNKNOWN_ALGORITHM_TYPE),
"unknown algorithm type" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_UNKNOWN_DIGEST), "unknown digest" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_UNKNOWN_MASK_DIGEST),
"unknown mask digest" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_UNKNOWN_PADDING_TYPE),
"unknown padding type" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_UNSUPPORTED_ENCRYPTION_TYPE),
"unsupported encryption type" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_UNSUPPORTED_LABEL_SOURCE),
"unsupported label source" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_UNSUPPORTED_MASK_ALGORITHM),
"unsupported mask algorithm" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_UNSUPPORTED_MASK_PARAMETER),
"unsupported mask parameter" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_UNSUPPORTED_SIGNATURE_TYPE),
"unsupported signature type" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_VALUE_MISSING), "value missing" },
{ ERR_PACK(ERR_LIB_RSA, 0, RSA_R_WRONG_SIGNATURE_LENGTH),
"wrong signature length" },
{ 0, NULL }
};
#endif
int ossl_err_load_RSA_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(RSA_str_reasons[0].error) == NULL)
ERR_load_strings_const(RSA_str_reasons);
#endif
return 1;
}
crypto/sm2/sm2_err.c
-50
View File
@@ -1,50 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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 <openssl/err.h>
#include "crypto/sm2err.h"
#ifndef OPENSSL_NO_SM2
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA SM2_str_reasons[] = {
{ ERR_PACK(ERR_LIB_SM2, 0, SM2_R_ASN1_ERROR), "asn1 error" },
{ ERR_PACK(ERR_LIB_SM2, 0, SM2_R_BAD_SIGNATURE), "bad signature" },
{ ERR_PACK(ERR_LIB_SM2, 0, SM2_R_BUFFER_TOO_SMALL), "buffer too small" },
{ ERR_PACK(ERR_LIB_SM2, 0, SM2_R_DIST_ID_TOO_LARGE), "dist id too large" },
{ ERR_PACK(ERR_LIB_SM2, 0, SM2_R_ID_NOT_SET), "id not set" },
{ ERR_PACK(ERR_LIB_SM2, 0, SM2_R_ID_TOO_LARGE), "id too large" },
{ ERR_PACK(ERR_LIB_SM2, 0, SM2_R_INVALID_CURVE), "invalid curve" },
{ ERR_PACK(ERR_LIB_SM2, 0, SM2_R_INVALID_DIGEST), "invalid digest" },
{ ERR_PACK(ERR_LIB_SM2, 0, SM2_R_INVALID_DIGEST_TYPE),
"invalid digest type" },
{ ERR_PACK(ERR_LIB_SM2, 0, SM2_R_INVALID_ENCODING), "invalid encoding" },
{ ERR_PACK(ERR_LIB_SM2, 0, SM2_R_INVALID_FIELD), "invalid field" },
{ ERR_PACK(ERR_LIB_SM2, 0, SM2_R_INVALID_PRIVATE_KEY),
"invalid private key" },
{ ERR_PACK(ERR_LIB_SM2, 0, SM2_R_NO_PARAMETERS_SET), "no parameters set" },
{ ERR_PACK(ERR_LIB_SM2, 0, SM2_R_USER_ID_TOO_LARGE), "user id too large" },
{ 0, NULL }
};
#endif
int ossl_err_load_SM2_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(SM2_str_reasons[0].error) == NULL)
ERR_load_strings_const(SM2_str_reasons);
#endif
return 1;
}
#else
NON_EMPTY_TRANSLATION_UNIT
#endif
crypto/ssl_err.c
-635
View File
@@ -1,635 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2026 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 <openssl/err.h>
#include <openssl/sslerr.h>
#include "sslerr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA SSL_str_reasons[] = {
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY),
"application data after close notify" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_APP_DATA_IN_HANDSHAKE),
"app data in handshake" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT),
"attempt to reuse session in different context" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE),
"at least (D)TLS 1.2 needed in Suite B mode" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_CERTIFICATE), "bad certificate" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_CHANGE_CIPHER_SPEC),
"bad change cipher spec" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_CIPHER), "bad cipher" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_COMPRESSION_ALGORITHM),
"bad compression algorithm" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_DATA), "bad data" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_DATA_RETURNED_BY_CALLBACK),
"bad data returned by callback" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_DECOMPRESSION), "bad decompression" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_DH_VALUE), "bad dh value" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_DIGEST_LENGTH), "bad digest length" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_EARLY_DATA), "bad early data" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_ECC_CERT), "bad ecc cert" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_ECHCONFIG_EXTENSION),
"bad echconfig extension" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_ECPOINT), "bad ecpoint" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_EXTENSION), "bad extension" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_HANDSHAKE_LENGTH),
"bad handshake length" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_HANDSHAKE_STATE),
"bad handshake state" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_HELLO_REQUEST), "bad hello request" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_HRR_VERSION), "bad hrr version" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_KEY_SHARE), "bad key share" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_KEY_UPDATE), "bad key update" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_LEGACY_VERSION), "bad legacy version" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_LENGTH), "bad length" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_PACKET), "bad packet" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_PACKET_LENGTH), "bad packet length" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_PROTOCOL_VERSION_NUMBER),
"bad protocol version number" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_PSK), "bad psk" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_PSK_IDENTITY), "bad psk identity" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_RECORD_TYPE), "bad record type" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_RSA_ENCRYPT), "bad rsa encrypt" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_SIGNATURE), "bad signature" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_SRP_A_LENGTH), "bad srp a length" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_SRP_PARAMETERS), "bad srp parameters" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_SRTP_MKI_VALUE), "bad srtp mki value" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST),
"bad srtp protection profile list" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_SSL_FILETYPE), "bad ssl filetype" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_VALUE), "bad value" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_WRITE_RETRY), "bad write retry" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BINDER_DOES_NOT_VERIFY),
"binder does not verify" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BIO_NOT_SET), "bio not set" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BLOCK_CIPHER_PAD_IS_WRONG),
"block cipher pad is wrong" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BN_LIB), "bn lib" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CALLBACK_FAILED), "callback failed" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CANNOT_CHANGE_CIPHER),
"cannot change cipher" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CANNOT_GET_GROUP_NAME),
"cannot get group name" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CA_DN_LENGTH_MISMATCH),
"ca dn length mismatch" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CA_KEY_TOO_SMALL), "ca key too small" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CA_MD_TOO_WEAK), "ca md too weak" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CCS_RECEIVED_EARLY), "ccs received early" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CERTIFICATE_VERIFY_FAILED),
"certificate verify failed" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CERT_CB_ERROR), "cert cb error" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CERT_LENGTH_MISMATCH),
"cert length mismatch" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CIPHERSUITE_DIGEST_HAS_CHANGED),
"ciphersuite digest has changed" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CIPHER_CODE_WRONG_LENGTH),
"cipher code wrong length" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CLIENTHELLO_TLSEXT), "clienthello tlsext" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COMPRESSED_LENGTH_TOO_LONG),
"compressed length too long" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COMPRESSION_DISABLED),
"compression disabled" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COMPRESSION_FAILURE),
"compression failure" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE),
"compression id not within private range" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COMPRESSION_LIBRARY_ERROR),
"compression library error" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CONNECTION_TYPE_NOT_SET),
"connection type not set" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CONN_USE_ONLY), "conn use only" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CONTEXT_NOT_DANE_ENABLED),
"context not dane enabled" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COOKIE_GEN_CALLBACK_FAILURE),
"cookie gen callback failure" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COOKIE_MISMATCH), "cookie mismatch" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COPY_PARAMETERS_FAILED),
"copy parameters failed" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED),
"custom ext handler already installed" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_ALREADY_ENABLED),
"dane already enabled" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_CANNOT_OVERRIDE_MTYPE_FULL),
"dane cannot override mtype full" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_NOT_ENABLED), "dane not enabled" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_CERTIFICATE),
"dane tlsa bad certificate" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_CERTIFICATE_USAGE),
"dane tlsa bad certificate usage" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_DATA_LENGTH),
"dane tlsa bad data length" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_DIGEST_LENGTH),
"dane tlsa bad digest length" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_MATCHING_TYPE),
"dane tlsa bad matching type" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_PUBLIC_KEY),
"dane tlsa bad public key" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_SELECTOR),
"dane tlsa bad selector" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_NULL_DATA),
"dane tlsa null data" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DATA_BETWEEN_CCS_AND_FINISHED),
"data between ccs and finished" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DATA_LENGTH_TOO_LONG),
"data length too long" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DECRYPTION_FAILED), "decryption failed" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC),
"decryption failed or bad record mac" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DH_KEY_TOO_SMALL), "dh key too small" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG),
"dh public value length is wrong" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DIGEST_CHECK_FAILED),
"digest check failed" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DOMAIN_USE_ONLY), "domain use only" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DTLS_MESSAGE_TOO_BIG),
"dtls message too big" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DUPLICATE_COMPRESSION_ID),
"duplicate compression id" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ECC_CERT_NOT_FOR_SIGNING),
"ecc cert not for signing" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ECDH_REQUIRED_FOR_SUITEB_MODE),
"ecdh required for suiteb mode" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ECH_DECODE_ERROR), "ech decode error" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ECH_REQUIRED), "ech required" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EE_KEY_TOO_SMALL), "ee key too small" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EMPTY_RAW_PUBLIC_KEY),
"empty raw public key" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EMPTY_SRTP_PROTECTION_PROFILE_LIST),
"empty srtp protection profile list" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ENCRYPTED_LENGTH_TOO_LONG),
"encrypted length too long" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST),
"error in received cipher list" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ERROR_IN_SYSTEM_DEFAULT_CONFIG),
"error in system default config" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN),
"error setting tlsa base domain" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EXCEEDS_MAX_FRAGMENT_SIZE),
"exceeds max fragment size" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EXCESSIVE_MESSAGE_SIZE),
"excessive message size" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EXTENSION_NOT_RECEIVED),
"extension not received" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EXTRA_DATA_IN_MESSAGE),
"extra data in message" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EXT_LENGTH_MISMATCH),
"ext length mismatch" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_FAILED_TO_GET_PARAMETER),
"failed to get parameter" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_FAILED_TO_INIT_ASYNC),
"failed to init async" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_FEATURE_NEGOTIATION_NOT_COMPLETE),
"feature negotiation not complete" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_FEATURE_NOT_RENEGOTIABLE),
"feature not renegotiable" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_FRAGMENTED_CLIENT_HELLO),
"fragmented client hello" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_GOT_A_FIN_BEFORE_A_CCS),
"got a fin before a ccs" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_HTTPS_PROXY_REQUEST),
"https proxy request" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_HTTP_REQUEST), "http request" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ILLEGAL_POINT_COMPRESSION),
"illegal point compression" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ILLEGAL_SUITEB_DIGEST),
"illegal Suite B digest" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INAPPROPRIATE_FALLBACK),
"inappropriate fallback" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INCONSISTENT_COMPRESSION),
"inconsistent compression" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INCONSISTENT_EARLY_DATA_ALPN),
"inconsistent early data alpn" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INCONSISTENT_EARLY_DATA_SNI),
"inconsistent early data sni" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INCONSISTENT_EXTMS), "inconsistent extms" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INSUFFICIENT_SECURITY),
"insufficient security" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_ALERT), "invalid alert" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_CCS_MESSAGE),
"invalid ccs message" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_CERTIFICATE_OR_ALG),
"invalid certificate or alg" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_COMMAND), "invalid command" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_COMPRESSION_ALGORITHM),
"invalid compression algorithm" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_CONFIG), "invalid config" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_CONFIGURATION_NAME),
"invalid configuration name" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_CONTEXT), "invalid context" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_CT_VALIDATION_TYPE),
"invalid ct validation type" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_KEY_UPDATE_TYPE),
"invalid key update type" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_MAX_EARLY_DATA),
"invalid max early data" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_NULL_CMD_NAME),
"invalid null cmd name" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_RAW_PUBLIC_KEY),
"invalid raw public key" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_RECORD), "invalid record" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_SEQUENCE_NUMBER),
"invalid sequence number" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_SERVERINFO_DATA),
"invalid serverinfo data" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_SESSION_ID), "invalid session id" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_SRP_USERNAME),
"invalid srp username" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_STATUS_RESPONSE),
"invalid status response" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_TICKET_KEYS_LENGTH),
"invalid ticket keys length" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LEGACY_SIGALG_DISALLOWED_OR_UNSUPPORTED),
"legacy sigalg disallowed or unsupported" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LENGTH_MISMATCH), "length mismatch" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LENGTH_TOO_LONG), "length too long" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LENGTH_TOO_SHORT), "length too short" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LIBRARY_BUG), "library bug" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LIBRARY_HAS_NO_CIPHERS),
"library has no ciphers" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LISTENER_USE_ONLY), "listener use only" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MAXIMUM_ENCRYPTED_PKTS_REACHED),
"maximum encrypted pkts reached" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_DSA_SIGNING_CERT),
"missing dsa signing cert" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_ECDSA_SIGNING_CERT),
"missing ecdsa signing cert" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_FATAL), "missing fatal" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_PARAMETERS), "missing parameters" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_PSK_KEX_MODES_EXTENSION),
"missing psk kex modes extension" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_QUIC_TLS_FUNCTIONS),
"missing quic tls functions" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_RSA_CERTIFICATE),
"missing rsa certificate" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_RSA_ENCRYPTING_CERT),
"missing rsa encrypting cert" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_RSA_SIGNING_CERT),
"missing rsa signing cert" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_SIGALGS_EXTENSION),
"missing sigalgs extension" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_SIGNING_CERT),
"missing signing cert" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_SRP_PARAM),
"can't find SRP server param" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_SUPPORTED_GROUPS_EXTENSION),
"missing supported groups extension" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_SUPPORTED_VERSIONS_EXTENSION),
"missing supported versions extension" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_TMP_DH_KEY), "missing tmp dh key" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_TMP_ECDH_KEY),
"missing tmp ecdh key" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA),
"mixed handshake and non handshake data" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NOT_ON_RECORD_BOUNDARY),
"not on record boundary" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NOT_REPLACING_CERTIFICATE),
"not replacing certificate" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NOT_SERVER), "not server" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_APPLICATION_PROTOCOL),
"no application protocol" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CERTIFICATES_RETURNED),
"no certificates returned" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CERTIFICATE_ASSIGNED),
"no certificate assigned" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CERTIFICATE_SET), "no certificate set" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CHANGE_FOLLOWING_HRR),
"no change following hrr" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CIPHERS_AVAILABLE),
"no ciphers available" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CIPHERS_SPECIFIED),
"no ciphers specified" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CIPHER_MATCH), "no cipher match" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CLIENT_CERT_METHOD),
"no client cert method" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_COMPRESSION_SPECIFIED),
"no compression specified" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_COOKIE_CALLBACK_SET),
"no cookie callback set" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER),
"Peer haven't sent GOST certificate, required for selected ciphersuite" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_METHOD_SPECIFIED),
"no method specified" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_PEM_EXTENSIONS), "no pem extensions" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_PRIVATE_KEY_ASSIGNED),
"no private key assigned" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_PROTOCOLS_AVAILABLE),
"no protocols available" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_RENEGOTIATION), "no renegotiation" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_REQUIRED_DIGEST), "no required digest" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SHARED_CIPHER), "no shared cipher" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SHARED_GROUPS), "no shared groups" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS),
"no shared signature algorithms" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SRTP_PROFILES), "no srtp profiles" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_STREAM), "no stream" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SUITABLE_DIGEST_ALGORITHM),
"no suitable digest algorithm" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SUITABLE_GROUPS), "no suitable groups" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SUITABLE_KEY_SHARE),
"no suitable key share" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SUITABLE_RECORD_LAYER),
"no suitable record layer" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM),
"no suitable signature algorithm" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_VALID_SCTS), "no valid scts" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_VERIFY_COOKIE_CALLBACK),
"no verify cookie callback" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NULL_SSL_CTX), "null ssl ctx" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NULL_SSL_METHOD_PASSED),
"null ssl method passed" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_OCSP_CALLBACK_FAILURE),
"ocsp callback failure" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED),
"old session cipher not returned" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED),
"old session compression algorithm not returned" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_OVERFLOW_ERROR), "overflow error" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PACKET_LENGTH_TOO_LONG),
"packet length too long" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PARSE_TLSEXT), "parse tlsext" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PATH_TOO_LONG), "path too long" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE),
"peer did not return a certificate" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PEM_NAME_BAD_PREFIX),
"pem name bad prefix" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PEM_NAME_TOO_SHORT), "pem name too short" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PIPELINE_FAILURE), "pipeline failure" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_POLL_REQUEST_NOT_SUPPORTED),
"poll request not supported" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_POST_HANDSHAKE_AUTH_ENCODING_ERR),
"post handshake auth encoding err" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PRIVATE_KEY_MISMATCH),
"private key mismatch" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PROTOCOL_IS_SHUTDOWN),
"protocol is shutdown" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PSK_IDENTITY_NOT_FOUND),
"psk identity not found" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PSK_NO_CLIENT_CB), "psk no client cb" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PSK_NO_SERVER_CB), "psk no server cb" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_QUIC_HANDSHAKE_LAYER_ERROR),
"quic handshake layer error" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_QUIC_NETWORK_ERROR), "quic network error" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_QUIC_PROTOCOL_ERROR),
"quic protocol error" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_READ_BIO_NOT_SET), "read bio not set" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_READ_TIMEOUT_EXPIRED),
"read timeout expired" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RECORDS_NOT_RELEASED),
"records not released" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RECORD_LAYER_FAILURE),
"record layer failure" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RECORD_LENGTH_MISMATCH),
"record length mismatch" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RECORD_TOO_SMALL), "record too small" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_REMOTE_PEER_ADDRESS_NOT_SET),
"remote peer address not set" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RENEGOTIATE_EXT_TOO_LONG),
"renegotiate ext too long" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RENEGOTIATION_ENCODING_ERR),
"renegotiation encoding err" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RENEGOTIATION_MISMATCH),
"renegotiation mismatch" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_REQUEST_PENDING), "request pending" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_REQUEST_SENT), "request sent" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_REQUIRED_CIPHER_MISSING),
"required cipher missing" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_REQUIRED_COMPRESSION_ALGORITHM_MISSING),
"required compression algorithm missing" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING),
"scsv received when renegotiating" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SCT_VERIFICATION_FAILED),
"sct verification failed" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SEQUENCE_CTR_WRAPPED),
"sequence ctr wrapped" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SERVERHELLO_TLSEXT), "serverhello tlsext" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED),
"session id context uninitialized" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SHUTDOWN_WHILE_IN_INIT),
"shutdown while in init" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SIGNATURE_ALGORITHMS_ERROR),
"signature algorithms error" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE),
"signature for non signing certificate" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SRP_A_CALC), "error with the srp params" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES),
"srtp could not allocate profiles" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SRTP_PROTECTION_PROFILE_LIST_TOO_LONG),
"srtp protection profile list too long" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SRTP_UNKNOWN_PROTECTION_PROFILE),
"srtp unknown protection profile" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_COMMAND_SECTION_EMPTY),
"ssl command section empty" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_COMMAND_SECTION_NOT_FOUND),
"ssl command section not found" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION),
"ssl ctx has no default ssl version" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_HANDSHAKE_FAILURE),
"ssl handshake failure" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS),
"ssl library has no ciphers" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_NEGATIVE_LENGTH),
"ssl negative length" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SECTION_EMPTY), "ssl section empty" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SECTION_NOT_FOUND),
"ssl section not found" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SESSION_ID_CALLBACK_FAILED),
"ssl session id callback failed" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SESSION_ID_CONFLICT),
"ssl session id conflict" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG),
"ssl session id context too long" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH),
"ssl session id has bad length" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SESSION_ID_TOO_LONG),
"ssl session id too long" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SESSION_VERSION_MISMATCH),
"ssl session version mismatch" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_STILL_IN_INIT), "still in init" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_STREAM_COUNT_LIMITED),
"stream count limited" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_STREAM_FINISHED), "stream finished" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_STREAM_RECV_ONLY), "stream recv only" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_STREAM_RESET), "stream reset" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_STREAM_SEND_ONLY), "stream send only" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV13_ALERT_CERTIFICATE_REQUIRED),
"tlsv13 alert certificate required" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV13_ALERT_MISSING_EXTENSION),
"tlsv13 alert missing extension" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_ACCESS_DENIED),
"tlsv1 alert access denied" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_DECODE_ERROR),
"tlsv1 alert decode error" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_DECRYPTION_FAILED),
"tlsv1 alert decryption failed" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_DECRYPT_ERROR),
"tlsv1 alert decrypt error" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION),
"tlsv1 alert export restriction" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_INAPPROPRIATE_FALLBACK),
"tlsv1 alert inappropriate fallback" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY),
"tlsv1 alert insufficient security" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_INTERNAL_ERROR),
"tlsv1 alert internal error" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_NO_APPLICATION_PROTOCOL),
"tlsv1 alert no application protocol" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_NO_RENEGOTIATION),
"tlsv1 alert no renegotiation" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_PROTOCOL_VERSION),
"tlsv1 alert protocol version" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_RECORD_OVERFLOW),
"tlsv1 alert record overflow" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_UNKNOWN_CA),
"tlsv1 alert unknown ca" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_UNKNOWN_PSK_IDENTITY),
"tlsv1 alert unknown psk identity" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_USER_CANCELLED),
"tlsv1 alert user cancelled" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_BAD_CERTIFICATE_HASH_VALUE),
"tlsv1 bad certificate hash value" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE),
"tlsv1 bad certificate status response" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_CERTIFICATE_UNOBTAINABLE),
"tlsv1 certificate unobtainable" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_UNRECOGNIZED_NAME),
"tlsv1 unrecognized name" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_UNSUPPORTED_EXTENSION),
"tlsv1 unsupported extension" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_ALERT_BAD_CERTIFICATE),
"tls alert bad certificate" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_ALERT_BAD_RECORD_MAC),
"tls alert bad record mac" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_ALERT_CERTIFICATE_EXPIRED),
"tls alert certificate expired" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_ALERT_CERTIFICATE_REVOKED),
"tls alert certificate revoked" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_ALERT_CERTIFICATE_UNKNOWN),
"tls alert certificate unknown" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_ALERT_DECOMPRESSION_FAILURE),
"tls alert decompression failure" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_ALERT_HANDSHAKE_FAILURE),
"tls alert handshake failure" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_ALERT_ILLEGAL_PARAMETER),
"tls alert illegal parameter" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_ALERT_NO_CERTIFICATE),
"tls alert no certificate" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_ALERT_UNEXPECTED_MESSAGE),
"tls alert unexpected message" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_ALERT_UNSUPPORTED_CERTIFICATE),
"tls alert unsupported certificate" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_EXT_INVALID_MAX_FRAGMENT_LENGTH),
"tls ext invalid max fragment length" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_EXT_INVALID_SERVERNAME),
"tls ext invalid servername" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_EXT_INVALID_SERVERNAME_TYPE),
"tls ext invalid servername type" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_ILLEGAL_EXPORTER_LABEL),
"tls illegal exporter label" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST),
"tls invalid ecpointformat list" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_SESSION_ID_TOO_LONG),
"tls session id too long" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TOO_MANY_KEY_UPDATES),
"too many key updates" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TOO_MANY_WARN_ALERTS),
"too many warn alerts" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TOO_MUCH_EARLY_DATA),
"too much early data" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS),
"unable to find ecdh parameters" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS),
"unable to find public key parameters" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNEXPECTED_CCS_MESSAGE),
"unexpected ccs message" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNEXPECTED_END_OF_EARLY_DATA),
"unexpected end of early data" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNEXPECTED_EOF_WHILE_READING),
"unexpected eof while reading" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNEXPECTED_MESSAGE), "unexpected message" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNEXPECTED_RECORD), "unexpected record" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNINITIALIZED), "uninitialized" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_ALERT_TYPE), "unknown alert type" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_CERTIFICATE_TYPE),
"unknown certificate type" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_CIPHER_RETURNED),
"unknown cipher returned" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_CIPHER_TYPE),
"unknown cipher type" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_CMD_NAME), "unknown cmd name" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_COMMAND), "unknown command" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_DIGEST), "unknown digest" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE),
"unknown key exchange type" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_MANDATORY_PARAMETER),
"unknown mandatory parameter" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_PKEY_TYPE), "unknown pkey type" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_PROTOCOL), "unknown protocol" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_SSL_VERSION),
"unknown ssl version" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_STATE), "unknown state" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED),
"unsafe legacy renegotiation disabled" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSOLICITED_EXTENSION),
"unsolicited extension" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM),
"unsupported compression algorithm" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_CONFIG_VALUE),
"unsupported config value" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_CONFIG_VALUE_CLASS),
"unsupported config value class" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_CONFIG_VALUE_OP),
"unsupported config value op" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_ELLIPTIC_CURVE),
"unsupported elliptic curve" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_PROTOCOL),
"unsupported protocol" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_SSL_VERSION),
"unsupported ssl version" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_STATUS_TYPE),
"unsupported status type" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_WRITE_FLAG),
"unsupported write flag" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_USE_SRTP_NOT_NEGOTIATED),
"use srtp not negotiated" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_VERSION_TOO_HIGH), "version too high" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_VERSION_TOO_LOW), "version too low" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_CERTIFICATE_TYPE),
"wrong certificate type" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_CIPHER_RETURNED),
"wrong cipher returned" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_CURVE), "wrong curve" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_RPK_TYPE), "wrong rpk type" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_SIGNATURE_LENGTH),
"wrong signature length" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_SIGNATURE_SIZE),
"wrong signature size" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_SIGNATURE_TYPE),
"wrong signature type" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_SSL_VERSION), "wrong ssl version" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_VERSION_NUMBER),
"wrong version number" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_X509_LIB), "x509 lib" },
{ ERR_PACK(ERR_LIB_SSL, 0, SSL_R_X509_VERIFICATION_SETUP_PROBLEMS),
"x509 verification setup problems" },
{ 0, NULL }
};
#endif
int ossl_err_load_SSL_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(SSL_str_reasons[0].error) == NULL)
ERR_load_strings_const(SSL_str_reasons);
#endif
return 1;
}
crypto/sslerr.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2026 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
*/
#ifndef OSSL_SSLERR_H
#define OSSL_SSLERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_SSL_strings(void);
#ifdef __cplusplus
}
#endif
#endif
crypto/store/store_err.c
-77
View File
@@ -1,77 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2026 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 <openssl/err.h>
#include <openssl/storeerr.h>
#include "crypto/storeerr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA OSSL_STORE_str_reasons[] = {
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_AMBIGUOUS_CONTENT_TYPE),
"ambiguous content type" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_BAD_PASSWORD_READ),
"bad password read" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_ERROR_VERIFYING_PKCS12_MAC),
"error verifying pkcs12 mac" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_FINGERPRINT_SIZE_DOES_NOT_MATCH_DIGEST),
"fingerprint size does not match digest" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_INVALID_SCHEME),
"invalid scheme" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_IS_NOT_A), "is not a" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_LOADER_INCOMPLETE),
"loader incomplete" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_LOADING_STARTED),
"loading started" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_NOT_A_CERTIFICATE),
"not a certificate" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_NOT_A_CRL), "not a crl" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_NOT_A_NAME), "not a name" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_NOT_A_PRIVATE_KEY),
"not a private key" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_NOT_A_PUBLIC_KEY),
"not a public key" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_NOT_A_SYMMETRIC_KEY),
"not a symmetric key" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_NOT_PARAMETERS),
"not parameters" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_NO_LOADERS_FOUND),
"no loaders found" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_PASSPHRASE_CALLBACK_ERROR),
"passphrase callback error" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_PATH_MUST_BE_ABSOLUTE),
"path must be absolute" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES),
"search only supported for directories" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_UI_PROCESS_INTERRUPTED_OR_CANCELLED),
"ui process interrupted or cancelled" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_UNREGISTERED_SCHEME),
"unregistered scheme" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_UNSUPPORTED_CONTENT_TYPE),
"unsupported content type" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_UNSUPPORTED_OPERATION),
"unsupported operation" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_UNSUPPORTED_SEARCH_TYPE),
"unsupported search type" },
{ ERR_PACK(ERR_LIB_OSSL_STORE, 0, OSSL_STORE_R_URI_AUTHORITY_UNSUPPORTED),
"uri authority unsupported" },
{ 0, NULL }
};
#endif
int ossl_err_load_OSSL_STORE_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(OSSL_STORE_str_reasons[0].error) == NULL)
ERR_load_strings_const(OSSL_STORE_str_reasons);
#endif
return 1;
}
crypto/ts/ts_err.c
-91
View File
@@ -1,91 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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 <openssl/err.h>
#include <openssl/tserr.h>
#include "crypto/tserr.h"
#ifndef OPENSSL_NO_TS
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA TS_str_reasons[] = {
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_BAD_PKCS7_TYPE), "bad pkcs7 type" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_BAD_TYPE), "bad type" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_CANNOT_LOAD_CERT), "cannot load certificate" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_CANNOT_LOAD_KEY), "cannot load private key" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_CERTIFICATE_VERIFY_ERROR),
"certificate verify error" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_COULD_NOT_SET_ENGINE),
"could not set engine" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_COULD_NOT_SET_TIME), "could not set time" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_DETACHED_CONTENT), "detached content" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_ESS_ADD_SIGNING_CERT_ERROR),
"ess add signing cert error" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_ESS_ADD_SIGNING_CERT_V2_ERROR),
"ess add signing cert v2 error" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_ESS_SIGNING_CERTIFICATE_ERROR),
"ess signing certificate error" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_INVALID_NULL_POINTER),
"invalid null pointer" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_INVALID_SIGNER_CERTIFICATE_PURPOSE),
"invalid signer certificate purpose" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_MESSAGE_IMPRINT_MISMATCH),
"message imprint mismatch" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_NONCE_MISMATCH), "nonce mismatch" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_NONCE_NOT_RETURNED), "nonce not returned" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_NO_CONTENT), "no content" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_NO_TIME_STAMP_TOKEN), "no time stamp token" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_PKCS7_ADD_SIGNATURE_ERROR),
"pkcs7 add signature error" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_PKCS7_ADD_SIGNED_ATTR_ERROR),
"pkcs7 add signed attr error" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_PKCS7_TO_TS_TST_INFO_FAILED),
"pkcs7 to ts tst info failed" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_POLICY_MISMATCH), "policy mismatch" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE),
"private key does not match certificate" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_RESPONSE_SETUP_ERROR),
"response setup error" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_SIGNATURE_FAILURE), "signature failure" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_THERE_MUST_BE_ONE_SIGNER),
"there must be one signer" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_TIME_SYSCALL_ERROR), "time syscall error" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_TOKEN_NOT_PRESENT), "token not present" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_TOKEN_PRESENT), "token present" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_TSA_NAME_MISMATCH), "tsa name mismatch" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_TSA_UNTRUSTED), "tsa untrusted" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_TST_INFO_SETUP_ERROR),
"tst info setup error" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_TS_DATASIGN), "ts datasign" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_UNACCEPTABLE_POLICY), "unacceptable policy" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_UNSUPPORTED_MD_ALGORITHM),
"unsupported md algorithm" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_UNSUPPORTED_VERSION), "unsupported version" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_VAR_BAD_VALUE), "var bad value" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_VAR_LOOKUP_FAILURE),
"cannot find config variable" },
{ ERR_PACK(ERR_LIB_TS, 0, TS_R_WRONG_CONTENT_TYPE), "wrong content type" },
{ 0, NULL }
};
#endif
int ossl_err_load_TS_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(TS_str_reasons[0].error) == NULL)
ERR_load_strings_const(TS_str_reasons);
#endif
return 1;
}
#else
NON_EMPTY_TRANSLATION_UNIT
#endif
crypto/ui/ui_err.c
-47
View File
@@ -1,47 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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 <openssl/err.h>
#include <openssl/uierr.h>
#include "crypto/uierr.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA UI_str_reasons[] = {
{ ERR_PACK(ERR_LIB_UI, 0, UI_R_COMMON_OK_AND_CANCEL_CHARACTERS),
"common ok and cancel characters" },
{ ERR_PACK(ERR_LIB_UI, 0, UI_R_INDEX_TOO_LARGE), "index too large" },
{ ERR_PACK(ERR_LIB_UI, 0, UI_R_INDEX_TOO_SMALL), "index too small" },
{ ERR_PACK(ERR_LIB_UI, 0, UI_R_NO_RESULT_BUFFER), "no result buffer" },
{ ERR_PACK(ERR_LIB_UI, 0, UI_R_PROCESSING_ERROR), "processing error" },
{ ERR_PACK(ERR_LIB_UI, 0, UI_R_RESULT_TOO_LARGE), "result too large" },
{ ERR_PACK(ERR_LIB_UI, 0, UI_R_RESULT_TOO_SMALL), "result too small" },
{ ERR_PACK(ERR_LIB_UI, 0, UI_R_SYSASSIGN_ERROR), "sys$assign error" },
{ ERR_PACK(ERR_LIB_UI, 0, UI_R_SYSDASSGN_ERROR), "sys$dassgn error" },
{ ERR_PACK(ERR_LIB_UI, 0, UI_R_SYSQIOW_ERROR), "sys$qiow error" },
{ ERR_PACK(ERR_LIB_UI, 0, UI_R_UNKNOWN_CONTROL_COMMAND),
"unknown control command" },
{ ERR_PACK(ERR_LIB_UI, 0, UI_R_UNKNOWN_TTYGET_ERRNO_VALUE),
"unknown ttyget errno value" },
{ ERR_PACK(ERR_LIB_UI, 0, UI_R_USER_DATA_DUPLICATION_UNSUPPORTED),
"user data duplication unsupported" },
{ 0, NULL }
};
#endif
int ossl_err_load_UI_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(UI_str_reasons[0].error) == NULL)
ERR_load_strings_const(UI_str_reasons);
#endif
return 1;
}
crypto/x509/v3err.c
-153
View File
@@ -1,153 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2026 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 <openssl/err.h>
#include <openssl/x509v3err.h>
#include "crypto/x509v3err.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA X509V3_str_reasons[] = {
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_BAD_IP_ADDRESS), "bad ip address" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_BAD_OBJECT), "bad object" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_BAD_OPTION), "bad option" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_BAD_VALUE), "bad value" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_BN_DEC2BN_ERROR), "bn dec2bn error" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_BN_TO_ASN1_INTEGER_ERROR),
"bn to asn1 integer error" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_DIRNAME_ERROR), "dirname error" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_DISTPOINT_ALREADY_SET),
"distpoint already set" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_DUPLICATE_FIELD), "duplicate field" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_DUPLICATE_ZONE_ID),
"duplicate zone id" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_EMPTY_KEY_USAGE), "empty key usage" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_ERROR_CONVERTING_ZONE),
"error converting zone" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_ERROR_CREATING_EXTENSION),
"error creating extension" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_ERROR_IN_EXTENSION),
"error in extension" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_EXPECTED_A_SECTION_NAME),
"expected a section name" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_EXTENSION_EXISTS),
"extension exists" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_EXTENSION_NAME_ERROR),
"extension name error" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_EXTENSION_NOT_FOUND),
"extension not found" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_EXTENSION_SETTING_NOT_SUPPORTED),
"extension setting not supported" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_EXTENSION_VALUE_ERROR),
"extension value error" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_ILLEGAL_EMPTY_EXTENSION),
"illegal empty extension" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INCORRECT_POLICY_SYNTAX_TAG),
"incorrect policy syntax tag" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_ASNUMBER),
"invalid asnumber" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_ASRANGE), "invalid asrange" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_BOOLEAN_STRING),
"invalid boolean string" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_CERTIFICATE),
"invalid certificate" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_EMPTY_NAME),
"invalid empty name" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_EXTENSION_STRING),
"invalid extension string" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_INHERITANCE),
"invalid inheritance" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_IPADDRESS),
"invalid ipaddress" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_MULTIPLE_RDNS),
"invalid multiple rdns" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_NAME), "invalid name" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_NULL_ARGUMENT),
"invalid null argument" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_NULL_VALUE),
"invalid null value" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_NUMBER), "invalid number" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_NUMBERS), "invalid numbers" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_OBJECT_IDENTIFIER),
"invalid object identifier" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_OPTION), "invalid option" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_POLICY_IDENTIFIER),
"invalid policy identifier" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_PROXY_POLICY_SETTING),
"invalid proxy policy setting" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_PURPOSE), "invalid purpose" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_SAFI), "invalid safi" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_SECTION), "invalid section" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_INVALID_SYNTAX), "invalid syntax" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_ISSUER_DECODE_ERROR),
"issuer decode error" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_MISSING_VALUE), "missing value" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_NEED_ORGANIZATION_AND_NUMBERS),
"need organization and numbers" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_NEGATIVE_PATHLEN),
"negative pathlen" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_NO_CONFIG_DATABASE),
"no config database" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_NO_ISSUER_CERTIFICATE),
"no issuer certificate" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_NO_ISSUER_DETAILS),
"no issuer details" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_NO_POLICY_IDENTIFIER),
"no policy identifier" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_NO_PROXY_CERT_POLICY_LANGUAGE_DEFINED),
"no proxy cert policy language defined" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_NO_PUBLIC_KEY), "no public key" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_NO_SUBJECT_DETAILS),
"no subject details" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_OPERATION_NOT_DEFINED),
"operation not defined" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_OTHERNAME_ERROR), "othername error" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_POLICY_LANGUAGE_ALREADY_DEFINED),
"policy language already defined" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_POLICY_PATH_LENGTH),
"policy path length" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_POLICY_PATH_LENGTH_ALREADY_DEFINED),
"policy path length already defined" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_POLICY_WHEN_PROXY_LANGUAGE_REQUIRES_NO_POLICY),
"policy when proxy language requires no policy" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_PURPOSE_NOT_UNIQUE),
"purpose not unique" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_SECTION_NOT_FOUND),
"section not found" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_UNABLE_TO_GET_ISSUER_DETAILS),
"unable to get issuer details" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_UNABLE_TO_GET_ISSUER_KEYID),
"unable to get issuer keyid" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_UNKNOWN_BIT_STRING_ARGUMENT),
"unknown bit string argument" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_UNKNOWN_EXTENSION),
"unknown extension" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_UNKNOWN_EXTENSION_NAME),
"unknown extension name" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_UNKNOWN_OPTION), "unknown option" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_UNKNOWN_VALUE), "unknown value" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_UNSUPPORTED_OPTION),
"unsupported option" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_UNSUPPORTED_TYPE),
"unsupported type" },
{ ERR_PACK(ERR_LIB_X509V3, 0, X509V3_R_USER_TOO_LONG), "user too long" },
{ 0, NULL }
};
#endif
int ossl_err_load_X509V3_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(X509V3_str_reasons[0].error) == NULL)
ERR_load_strings_const(X509V3_str_reasons);
#endif
return 1;
}
crypto/x509/x509_err.c
-101
View File
@@ -1,101 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2026 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 <openssl/err.h>
#include <openssl/x509err.h>
#include "crypto/x509err.h"
#ifndef OPENSSL_NO_ERR
static const ERR_STRING_DATA X509_str_reasons[] = {
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_AKID_MISMATCH), "akid mismatch" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_BAD_SELECTOR), "bad selector" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_BAD_X509_FILETYPE), "bad x509 filetype" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_BASE64_DECODE_ERROR),
"base64 decode error" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_CANT_CHECK_DH_KEY), "can't check dh key" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_CERTIFICATE_VERIFICATION_FAILED),
"certificate verification failed" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_CERT_ALREADY_IN_HASH_TABLE),
"cert already in hash table" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_CRL_ALREADY_DELTA), "crl already delta" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_CRL_SIGNATURE_ALGORITHM_MISMATCH),
"crl signature algorithm mismatch" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_CRL_VERIFY_FAILURE),
"crl verify failure" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_DUPLICATE_ATTRIBUTE),
"duplicate attribute" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_ERROR_GETTING_MD_BY_NID),
"error getting md by nid" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_ERROR_USING_SIGINF_SET),
"error using siginf set" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_IDP_MISMATCH), "idp mismatch" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_INVALID_ATTRIBUTES),
"invalid attributes" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_INVALID_DIRECTORY), "invalid directory" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_INVALID_DISTPOINT), "invalid distpoint" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_INVALID_EXTENSION), "invalid extension" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_INVALID_FIELD_NAME),
"invalid field name" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_INVALID_TRUST), "invalid trust" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_ISSUER_MISMATCH), "issuer mismatch" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_KEY_TYPE_MISMATCH), "key type mismatch" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_KEY_VALUES_MISMATCH),
"key values mismatch" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_LOADING_CERT_DIR), "loading cert dir" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_LOADING_DEFAULTS), "loading defaults" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_METHOD_NOT_SUPPORTED),
"method not supported" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_NAME_TOO_LONG), "name too long" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_NEWER_CRL_NOT_NEWER),
"newer crl not newer" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_NO_CERTIFICATE_FOUND),
"no certificate found" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_NO_CERTIFICATE_OR_CRL_FOUND),
"no certificate or crl found" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_NO_CERT_SET_FOR_US_TO_VERIFY),
"no cert set for us to verify" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_NO_CRL_FOUND), "no crl found" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_NO_CRL_NUMBER), "no crl number" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_PUBLIC_KEY_DECODE_ERROR),
"public key decode error" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_PUBLIC_KEY_ENCODE_ERROR),
"public key encode error" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_SHOULD_RETRY), "should retry" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN),
"unable to find parameters in chain" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY),
"unable to get certs public key" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_UNKNOWN_KEY_TYPE), "unknown key type" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_UNKNOWN_NID), "unknown nid" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_UNKNOWN_PURPOSE_ID),
"unknown purpose id" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_UNKNOWN_SIGID_ALGS),
"unknown sigid algs" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_UNKNOWN_TRUST_ID), "unknown trust id" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_UNSUPPORTED_ALGORITHM),
"unsupported algorithm" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_UNSUPPORTED_VERSION),
"unsupported version" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_WRONG_LOOKUP_TYPE), "wrong lookup type" },
{ ERR_PACK(ERR_LIB_X509, 0, X509_R_WRONG_TYPE), "wrong type" },
{ 0, NULL }
};
#endif
int ossl_err_load_X509_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_reason_error_string(X509_str_reasons[0].error) == NULL)
ERR_load_strings_const(X509_str_reasons);
#endif
return 1;
}
include/crypto/asn1err.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_CRYPTO_ASN1ERR_H
#define OSSL_CRYPTO_ASN1ERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_ASN1_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/asyncerr.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_CRYPTO_ASYNCERR_H
#define OSSL_CRYPTO_ASYNCERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_ASYNC_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/bioerr.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2022 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
*/
#ifndef OSSL_CRYPTO_BIOERR_H
#define OSSL_CRYPTO_BIOERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_BIO_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/bnerr.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2022 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
*/
#ifndef OSSL_CRYPTO_BNERR_H
#define OSSL_CRYPTO_BNERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_BN_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/buffererr.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_CRYPTO_BUFFERERR_H
#define OSSL_CRYPTO_BUFFERERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_BUF_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/cmperr.h
-30
View File
@@ -1,30 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2023 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
*/
#ifndef OSSL_CRYPTO_CMPERR_H
#define OSSL_CRYPTO_CMPERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef OPENSSL_NO_CMP
int ossl_err_load_CMP_strings(void);
#endif
#ifdef __cplusplus
}
#endif
#endif
include/crypto/cmserr.h
-30
View File
@@ -1,30 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* 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
*/
#ifndef OSSL_CRYPTO_CMSERR_H
#define OSSL_CRYPTO_CMSERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef OPENSSL_NO_CMS
int ossl_err_load_CMS_strings(void);
#endif
#ifdef __cplusplus
}
#endif
#endif
include/crypto/comperr.h
-30
View File
@@ -1,30 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_CRYPTO_COMPERR_H
#define OSSL_CRYPTO_COMPERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef OPENSSL_NO_COMP
int ossl_err_load_COMP_strings(void);
#endif
#ifdef __cplusplus
}
#endif
#endif
include/crypto/conferr.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2023 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
*/
#ifndef OSSL_CRYPTO_CONFERR_H
#define OSSL_CRYPTO_CONFERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_CONF_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/crmferr.h
-30
View File
@@ -1,30 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_CRYPTO_CRMFERR_H
#define OSSL_CRYPTO_CRMFERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef OPENSSL_NO_CRMF
int ossl_err_load_CRMF_strings(void);
#endif
#ifdef __cplusplus
}
#endif
#endif
include/crypto/cryptoerr.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2024 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
*/
#ifndef OSSL_CRYPTO_CRYPTOERR_H
#define OSSL_CRYPTO_CRYPTOERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_CRYPTO_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/cterr.h
-30
View File
@@ -1,30 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_CRYPTO_CTERR_H
#define OSSL_CRYPTO_CTERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef OPENSSL_NO_CT
int ossl_err_load_CT_strings(void);
#endif
#ifdef __cplusplus
}
#endif
#endif
include/crypto/decodererr.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_CRYPTO_DECODERERR_H
#define OSSL_CRYPTO_DECODERERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_OSSL_DECODER_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/dherr.h
-30
View File
@@ -1,30 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2023 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
*/
#ifndef OSSL_CRYPTO_DHERR_H
#define OSSL_CRYPTO_DHERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef OPENSSL_NO_DH
int ossl_err_load_DH_strings(void);
#endif
#ifdef __cplusplus
}
#endif
#endif
include/crypto/dsaerr.h
-30
View File
@@ -1,30 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2023 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
*/
#ifndef OSSL_CRYPTO_DSAERR_H
#define OSSL_CRYPTO_DSAERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef OPENSSL_NO_DSA
int ossl_err_load_DSA_strings(void);
#endif
#ifdef __cplusplus
}
#endif
#endif
include/crypto/ecerr.h
-30
View File
@@ -1,30 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2023 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
*/
#ifndef OSSL_CRYPTO_ECERR_H
#define OSSL_CRYPTO_ECERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef OPENSSL_NO_EC
int ossl_err_load_EC_strings(void);
#endif
#ifdef __cplusplus
}
#endif
#endif
include/crypto/encodererr.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* 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
*/
#ifndef OSSL_CRYPTO_ENCODERERR_H
#define OSSL_CRYPTO_ENCODERERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_OSSL_ENCODER_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/esserr.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_CRYPTO_ESSERR_H
#define OSSL_CRYPTO_ESSERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_ESS_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/evperr.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* 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
*/
#ifndef OSSL_CRYPTO_EVPERR_H
#define OSSL_CRYPTO_EVPERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_EVP_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/httperr.h
-30
View File
@@ -1,30 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2026 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
*/
#ifndef OSSL_CRYPTO_HTTPERR_H
#define OSSL_CRYPTO_HTTPERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef OPENSSL_NO_HTTP
int ossl_err_load_HTTP_strings(void);
#endif
#ifdef __cplusplus
}
#endif
#endif
include/crypto/objectserr.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_CRYPTO_OBJECTSERR_H
#define OSSL_CRYPTO_OBJECTSERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_OBJ_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/ocsperr.h
-30
View File
@@ -1,30 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_CRYPTO_OCSPERR_H
#define OSSL_CRYPTO_OCSPERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef OPENSSL_NO_OCSP
int ossl_err_load_OCSP_strings(void);
#endif
#ifdef __cplusplus
}
#endif
#endif
include/crypto/pemerr.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_CRYPTO_PEMERR_H
#define OSSL_CRYPTO_PEMERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_PEM_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/pkcs12err.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* 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
*/
#ifndef OSSL_CRYPTO_PKCS12ERR_H
#define OSSL_CRYPTO_PKCS12ERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_PKCS12_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/pkcs7err.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_CRYPTO_PKCS7ERR_H
#define OSSL_CRYPTO_PKCS7ERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_PKCS7_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/randerr.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2024 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
*/
#ifndef OSSL_CRYPTO_RANDERR_H
#define OSSL_CRYPTO_RANDERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_RAND_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/rsaerr.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_CRYPTO_RSAERR_H
#define OSSL_CRYPTO_RSAERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_RSA_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/sm2err.h
-49
View File
@@ -1,49 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_CRYPTO_SM2ERR_H
#define OSSL_CRYPTO_SM2ERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef OPENSSL_NO_SM2
int ossl_err_load_SM2_strings(void);
/*
* SM2 reason codes.
*/
#define SM2_R_ASN1_ERROR 100
#define SM2_R_BAD_SIGNATURE 101
#define SM2_R_BUFFER_TOO_SMALL 107
#define SM2_R_DIST_ID_TOO_LARGE 110
#define SM2_R_ID_NOT_SET 112
#define SM2_R_ID_TOO_LARGE 111
#define SM2_R_INVALID_CURVE 108
#define SM2_R_INVALID_DIGEST 102
#define SM2_R_INVALID_DIGEST_TYPE 103
#define SM2_R_INVALID_ENCODING 104
#define SM2_R_INVALID_FIELD 105
#define SM2_R_INVALID_PRIVATE_KEY 113
#define SM2_R_NO_PARAMETERS_SET 109
#define SM2_R_USER_ID_TOO_LARGE 106
#endif
#ifdef __cplusplus
}
#endif
#endif
include/crypto/storeerr.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_CRYPTO_STOREERR_H
#define OSSL_CRYPTO_STOREERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_OSSL_STORE_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/tserr.h
-30
View File
@@ -1,30 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_CRYPTO_TSERR_H
#define OSSL_CRYPTO_TSERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef OPENSSL_NO_TS
int ossl_err_load_TS_strings(void);
#endif
#ifdef __cplusplus
}
#endif
#endif
include/crypto/uierr.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_CRYPTO_UIERR_H
#define OSSL_CRYPTO_UIERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_UI_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/x509err.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2026 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
*/
#ifndef OSSL_CRYPTO_X509ERR_H
#define OSSL_CRYPTO_X509ERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_X509_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/crypto/x509v3err.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2026 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
*/
#ifndef OSSL_CRYPTO_X509V3ERR_H
#define OSSL_CRYPTO_X509V3ERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_X509V3_strings(void);
#ifdef __cplusplus
}
#endif
#endif
include/internal/dsoerr.h
-47
View File
@@ -1,47 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_INTERNAL_DSOERR_H
#define OSSL_INTERNAL_DSOERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_DSO_strings(void);
/*
* DSO reason codes.
*/
#define DSO_R_CTRL_FAILED 100
#define DSO_R_DSO_ALREADY_LOADED 110
#define DSO_R_EMPTY_FILE_STRUCTURE 113
#define DSO_R_FAILURE 114
#define DSO_R_FILENAME_TOO_BIG 101
#define DSO_R_FINISH_FAILED 102
#define DSO_R_INCORRECT_FILE_SYNTAX 115
#define DSO_R_LOAD_FAILED 103
#define DSO_R_NAME_TRANSLATION_FAILED 109
#define DSO_R_NO_FILENAME 111
#define DSO_R_NULL_HANDLE 104
#define DSO_R_SET_FILENAME_FAILED 112
#define DSO_R_STACK_ERROR 105
#define DSO_R_SYM_FAILURE 106
#define DSO_R_UNLOAD_FAILED 107
#define DSO_R_UNSUPPORTED 108
#ifdef __cplusplus
}
#endif
#endif
include/internal/propertyerr.h
-42
View File
@@ -1,42 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 2020-2021 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
*/
#ifndef OSSL_INTERNAL_PROPERTYERR_H
#define OSSL_INTERNAL_PROPERTYERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#ifdef __cplusplus
extern "C" {
#endif
int ossl_err_load_PROP_strings(void);
/*
* PROP reason codes.
*/
#define PROP_R_NAME_TOO_LONG 100
#define PROP_R_NOT_AN_ASCII_CHARACTER 101
#define PROP_R_NOT_AN_HEXADECIMAL_DIGIT 102
#define PROP_R_NOT_AN_IDENTIFIER 103
#define PROP_R_NOT_AN_OCTAL_DIGIT 104
#define PROP_R_NOT_A_DECIMAL_DIGIT 105
#define PROP_R_NO_MATCHING_STRING_DELIMITER 106
#define PROP_R_NO_VALUE 107
#define PROP_R_PARSE_FAILED 108
#define PROP_R_STRING_TOO_LONG 109
#define PROP_R_TRAILING_CHARACTERS 110
#ifdef __cplusplus
}
#endif
#endif
include/openssl/asn1err.h
-140
View File
@@ -1,140 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2024 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
*/
#ifndef OPENSSL_ASN1ERR_H
#define OPENSSL_ASN1ERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
/*
* ASN1 reason codes.
*/
#define ASN1_R_ADDING_OBJECT 171
#define ASN1_R_ASN1_PARSE_ERROR 203
#define ASN1_R_ASN1_SIG_PARSE_ERROR 204
#define ASN1_R_AUX_ERROR 100
#define ASN1_R_BAD_OBJECT_HEADER 102
#define ASN1_R_BAD_TEMPLATE 230
#define ASN1_R_BMPSTRING_IS_WRONG_LENGTH 214
#define ASN1_R_BN_LIB 105
#define ASN1_R_BOOLEAN_IS_WRONG_LENGTH 106
#define ASN1_R_BUFFER_TOO_SMALL 107
#define ASN1_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER 108
#define ASN1_R_CONTEXT_NOT_INITIALISED 217
#define ASN1_R_DATA_IS_WRONG 109
#define ASN1_R_DECODE_ERROR 110
#define ASN1_R_DEPTH_EXCEEDED 174
#define ASN1_R_DIGEST_AND_KEY_TYPE_NOT_SUPPORTED 198
#define ASN1_R_ENCODE_ERROR 112
#define ASN1_R_ERROR_GETTING_TIME 173
#define ASN1_R_ERROR_LOADING_SECTION 172
#define ASN1_R_ERROR_SETTING_CIPHER_PARAMS 114
#define ASN1_R_EXPECTING_AN_INTEGER 115
#define ASN1_R_EXPECTING_AN_OBJECT 116
#define ASN1_R_EXPLICIT_LENGTH_MISMATCH 119
#define ASN1_R_EXPLICIT_TAG_NOT_CONSTRUCTED 120
#define ASN1_R_FIELD_MISSING 121
#define ASN1_R_FIRST_NUM_TOO_LARGE 122
#define ASN1_R_GENERALIZEDTIME_IS_TOO_SHORT 232
#define ASN1_R_HEADER_TOO_LONG 123
#define ASN1_R_ILLEGAL_BITSTRING_FORMAT 175
#define ASN1_R_ILLEGAL_BOOLEAN 176
#define ASN1_R_ILLEGAL_CHARACTERS 124
#define ASN1_R_ILLEGAL_FORMAT 177
#define ASN1_R_ILLEGAL_HEX 178
#define ASN1_R_ILLEGAL_IMPLICIT_TAG 179
#define ASN1_R_ILLEGAL_INTEGER 180
#define ASN1_R_ILLEGAL_NEGATIVE_VALUE 226
#define ASN1_R_ILLEGAL_NESTED_TAGGING 181
#define ASN1_R_ILLEGAL_NULL 125
#define ASN1_R_ILLEGAL_NULL_VALUE 182
#define ASN1_R_ILLEGAL_OBJECT 183
#define ASN1_R_ILLEGAL_OPTIONAL_ANY 126
#define ASN1_R_ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE 170
#define ASN1_R_ILLEGAL_PADDING 221
#define ASN1_R_ILLEGAL_TAGGED_ANY 127
#define ASN1_R_ILLEGAL_TIME_VALUE 184
#define ASN1_R_ILLEGAL_ZERO_CONTENT 222
#define ASN1_R_INTEGER_NOT_ASCII_FORMAT 185
#define ASN1_R_INTEGER_TOO_LARGE_FOR_LONG 128
#define ASN1_R_INVALID_BIT_STRING_BITS_LEFT 220
#define ASN1_R_INVALID_BMPSTRING_LENGTH 129
#define ASN1_R_INVALID_DIGIT 130
#define ASN1_R_INVALID_MIME_TYPE 205
#define ASN1_R_INVALID_MODIFIER 186
#define ASN1_R_INVALID_NUMBER 187
#define ASN1_R_INVALID_OBJECT_ENCODING 216
#define ASN1_R_INVALID_SCRYPT_PARAMETERS 227
#define ASN1_R_INVALID_SEPARATOR 131
#define ASN1_R_INVALID_STRING_TABLE_VALUE 218
#define ASN1_R_INVALID_UNIVERSALSTRING_LENGTH 133
#define ASN1_R_INVALID_UTF8STRING 134
#define ASN1_R_INVALID_VALUE 219
#define ASN1_R_LENGTH_TOO_LONG 231
#define ASN1_R_LIST_ERROR 188
#define ASN1_R_MIME_NO_CONTENT_TYPE 206
#define ASN1_R_MIME_PARSE_ERROR 207
#define ASN1_R_MIME_SIG_PARSE_ERROR 208
#define ASN1_R_MISSING_EOC 137
#define ASN1_R_MISSING_SECOND_NUMBER 138
#define ASN1_R_MISSING_VALUE 189
#define ASN1_R_MSTRING_NOT_UNIVERSAL 139
#define ASN1_R_MSTRING_WRONG_TAG 140
#define ASN1_R_NESTED_ASN1_STRING 197
#define ASN1_R_NESTED_TOO_DEEP 201
#define ASN1_R_NON_HEX_CHARACTERS 141
#define ASN1_R_NOT_ASCII_FORMAT 190
#define ASN1_R_NOT_ENOUGH_DATA 142
#define ASN1_R_NO_CONTENT_TYPE 209
#define ASN1_R_NO_MATCHING_CHOICE_TYPE 143
#define ASN1_R_NO_MULTIPART_BODY_FAILURE 210
#define ASN1_R_NO_MULTIPART_BOUNDARY 211
#define ASN1_R_NO_SIG_CONTENT_TYPE 212
#define ASN1_R_NULL_IS_WRONG_LENGTH 144
#define ASN1_R_OBJECT_NOT_ASCII_FORMAT 191
#define ASN1_R_ODD_NUMBER_OF_CHARS 145
#define ASN1_R_SECOND_NUMBER_TOO_LARGE 147
#define ASN1_R_SEQUENCE_LENGTH_MISMATCH 148
#define ASN1_R_SEQUENCE_NOT_CONSTRUCTED 149
#define ASN1_R_SEQUENCE_OR_SET_NEEDS_CONFIG 192
#define ASN1_R_SHORT_LINE 150
#define ASN1_R_SIG_INVALID_MIME_TYPE 213
#define ASN1_R_STREAMING_NOT_SUPPORTED 202
#define ASN1_R_STRING_TOO_LONG 151
#define ASN1_R_STRING_TOO_SHORT 152
#define ASN1_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 154
#define ASN1_R_TIME_NOT_ASCII_FORMAT 193
#define ASN1_R_TOO_LARGE 223
#define ASN1_R_TOO_LONG 155
#define ASN1_R_TOO_SMALL 224
#define ASN1_R_TYPE_NOT_CONSTRUCTED 156
#define ASN1_R_TYPE_NOT_PRIMITIVE 195
#define ASN1_R_UNEXPECTED_EOC 159
#define ASN1_R_UNIVERSALSTRING_IS_WRONG_LENGTH 215
#define ASN1_R_UNKNOWN_DIGEST 229
#define ASN1_R_UNKNOWN_FORMAT 160
#define ASN1_R_UNKNOWN_MESSAGE_DIGEST_ALGORITHM 161
#define ASN1_R_UNKNOWN_OBJECT_TYPE 162
#define ASN1_R_UNKNOWN_PUBLIC_KEY_TYPE 163
#define ASN1_R_UNKNOWN_SIGNATURE_ALGORITHM 199
#define ASN1_R_UNKNOWN_TAG 194
#define ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE 164
#define ASN1_R_UNSUPPORTED_CIPHER 228
#define ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE 167
#define ASN1_R_UNSUPPORTED_TYPE 196
#define ASN1_R_UTCTIME_IS_TOO_SHORT 233
#define ASN1_R_WRONG_INTEGER_TYPE 225
#define ASN1_R_WRONG_PUBLIC_KEY_TYPE 200
#define ASN1_R_WRONG_TAG 168
#endif
include/openssl/asyncerr.h
-27
View File
@@ -1,27 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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
*/
#ifndef OPENSSL_ASYNCERR_H
#define OPENSSL_ASYNCERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
/*
* ASYNC reason codes.
*/
#define ASYNC_R_FAILED_TO_SET_POOL 101
#define ASYNC_R_FAILED_TO_SWAP_CONTEXT 102
#define ASYNC_R_INIT_FAILED 105
#define ASYNC_R_INVALID_POOL_SIZE 103
#endif
include/openssl/bioerr.h
-70
View File
@@ -1,70 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2022 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
*/
#ifndef OPENSSL_BIOERR_H
#define OPENSSL_BIOERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
/*
* BIO reason codes.
*/
#define BIO_R_ACCEPT_ERROR 100
#define BIO_R_ADDRINFO_ADDR_IS_NOT_AF_INET 141
#define BIO_R_AMBIGUOUS_HOST_OR_SERVICE 129
#define BIO_R_BAD_FOPEN_MODE 101
#define BIO_R_BROKEN_PIPE 124
#define BIO_R_CONNECT_ERROR 103
#define BIO_R_CONNECT_TIMEOUT 147
#define BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET 107
#define BIO_R_GETSOCKNAME_ERROR 132
#define BIO_R_GETSOCKNAME_TRUNCATED_ADDRESS 133
#define BIO_R_GETTING_SOCKTYPE 134
#define BIO_R_INVALID_ARGUMENT 125
#define BIO_R_INVALID_SOCKET 135
#define BIO_R_IN_USE 123
#define BIO_R_LENGTH_TOO_LONG 102
#define BIO_R_LISTEN_V6_ONLY 136
#define BIO_R_LOCAL_ADDR_NOT_AVAILABLE 111
#define BIO_R_LOOKUP_RETURNED_NOTHING 142
#define BIO_R_MALFORMED_HOST_OR_SERVICE 130
#define BIO_R_NBIO_CONNECT_ERROR 110
#define BIO_R_NON_FATAL 112
#define BIO_R_NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED 143
#define BIO_R_NO_HOSTNAME_OR_SERVICE_SPECIFIED 144
#define BIO_R_NO_PORT_DEFINED 113
#define BIO_R_NO_SUCH_FILE 128
#define BIO_R_NULL_PARAMETER 115 /* unused */
#define BIO_R_TFO_DISABLED 106
#define BIO_R_TFO_NO_KERNEL_SUPPORT 108
#define BIO_R_TRANSFER_ERROR 104
#define BIO_R_TRANSFER_TIMEOUT 105
#define BIO_R_UNABLE_TO_BIND_SOCKET 117
#define BIO_R_UNABLE_TO_CREATE_SOCKET 118
#define BIO_R_UNABLE_TO_KEEPALIVE 137
#define BIO_R_UNABLE_TO_LISTEN_SOCKET 119
#define BIO_R_UNABLE_TO_NODELAY 138
#define BIO_R_UNABLE_TO_REUSEADDR 139
#define BIO_R_UNABLE_TO_TFO 109
#define BIO_R_UNAVAILABLE_IP_FAMILY 145
#define BIO_R_UNINITIALIZED 120
#define BIO_R_UNKNOWN_INFO_TYPE 140
#define BIO_R_UNSUPPORTED_IP_FAMILY 146
#define BIO_R_UNSUPPORTED_METHOD 121
#define BIO_R_UNSUPPORTED_PROTOCOL_FAMILY 131
#define BIO_R_WRITE_TO_READ_ONLY_BIO 126
#define BIO_R_WSASTARTUP 122
#define BIO_R_PORT_MISMATCH 150
#define BIO_R_PEER_ADDR_NOT_AVAILABLE 151
#endif
include/openssl/bnerr.h
-45
View File
@@ -1,45 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2022 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
*/
#ifndef OPENSSL_BNERR_H
#define OPENSSL_BNERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
/*
* BN reason codes.
*/
#define BN_R_ARG2_LT_ARG3 100
#define BN_R_BAD_RECIPROCAL 101
#define BN_R_BIGNUM_TOO_LONG 114
#define BN_R_BITS_TOO_SMALL 118
#define BN_R_CALLED_WITH_EVEN_MODULUS 102
#define BN_R_DIV_BY_ZERO 103
#define BN_R_ENCODING_ERROR 104
#define BN_R_EXPAND_ON_STATIC_BIGNUM_DATA 105
#define BN_R_INPUT_NOT_REDUCED 110
#define BN_R_INVALID_LENGTH 106
#define BN_R_INVALID_RANGE 115
#define BN_R_INVALID_SHIFT 119
#define BN_R_NOT_A_SQUARE 111
#define BN_R_NOT_INITIALIZED 107
#define BN_R_NO_INVERSE 108
#define BN_R_NO_PRIME_CANDIDATE 121
#define BN_R_NO_SOLUTION 116
#define BN_R_NO_SUITABLE_DIGEST 120
#define BN_R_PRIVATE_KEY_TOO_LARGE 117
#define BN_R_P_IS_NOT_PRIME 112
#define BN_R_TOO_MANY_ITERATIONS 113
#define BN_R_TOO_MANY_TEMPORARY_VARIABLES 109
#endif
include/openssl/buffererr.h
-23
View File
@@ -1,23 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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
*/
#ifndef OPENSSL_BUFFERERR_H
#define OPENSSL_BUFFERERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
/*
* BUF reason codes.
*/
#endif
include/openssl/cmperr.h
-132
View File
@@ -1,132 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-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
*/
#ifndef OPENSSL_CMPERR_H
#define OPENSSL_CMPERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
#ifndef OPENSSL_NO_CMP
/*
* CMP reason codes.
*/
#define CMP_R_ALGORITHM_NOT_SUPPORTED 139
#define CMP_R_BAD_CHECKAFTER_IN_POLLREP 167
#define CMP_R_BAD_REQUEST_ID 108
#define CMP_R_CERTHASH_UNMATCHED 156
#define CMP_R_CERTID_NOT_FOUND 109
#define CMP_R_CERTIFICATE_NOT_ACCEPTED 169
#define CMP_R_CERTIFICATE_NOT_FOUND 112
#define CMP_R_CERTREQMSG_NOT_FOUND 157
#define CMP_R_CERTRESPONSE_NOT_FOUND 113
#define CMP_R_CERT_AND_KEY_DO_NOT_MATCH 114
#define CMP_R_CHECKAFTER_OUT_OF_RANGE 181
#define CMP_R_ENCOUNTERED_KEYUPDATEWARNING 176
#define CMP_R_ENCOUNTERED_WAITING 162
#define CMP_R_ERROR_CALCULATING_PROTECTION 115
#define CMP_R_ERROR_CREATING_CERTCONF 116
#define CMP_R_ERROR_CREATING_CERTREP 117
#define CMP_R_ERROR_CREATING_CERTREQ 163
#define CMP_R_ERROR_CREATING_ERROR 118
#define CMP_R_ERROR_CREATING_GENM 119
#define CMP_R_ERROR_CREATING_GENP 120
#define CMP_R_ERROR_CREATING_PKICONF 122
#define CMP_R_ERROR_CREATING_POLLREP 123
#define CMP_R_ERROR_CREATING_POLLREQ 124
#define CMP_R_ERROR_CREATING_RP 125
#define CMP_R_ERROR_CREATING_RR 126
#define CMP_R_ERROR_PARSING_PKISTATUS 107
#define CMP_R_ERROR_PROCESSING_MESSAGE 158
#define CMP_R_ERROR_PROTECTING_MESSAGE 127
#define CMP_R_ERROR_SETTING_CERTHASH 128
#define CMP_R_ERROR_UNEXPECTED_CERTCONF 160
#define CMP_R_ERROR_VALIDATING_PROTECTION 140
#define CMP_R_ERROR_VALIDATING_SIGNATURE 171
#define CMP_R_EXPECTED_POLLREQ 104
#define CMP_R_FAILED_BUILDING_OWN_CHAIN 164
#define CMP_R_FAILED_EXTRACTING_CENTRAL_GEN_KEY 203
#define CMP_R_FAILED_EXTRACTING_PUBKEY 141
#define CMP_R_FAILURE_OBTAINING_RANDOM 110
#define CMP_R_FAIL_INFO_OUT_OF_RANGE 129
#define CMP_R_GENERATE_CERTREQTEMPLATE 197
#define CMP_R_GENERATE_CRLSTATUS 198
#define CMP_R_GETTING_GENP 192
#define CMP_R_GET_ITAV 199
#define CMP_R_INVALID_ARGS 100
#define CMP_R_INVALID_GENP 193
#define CMP_R_INVALID_KEYSPEC 202
#define CMP_R_INVALID_OPTION 174
#define CMP_R_INVALID_ROOTCAKEYUPDATE 195
#define CMP_R_MISSING_CENTRAL_GEN_KEY 204
#define CMP_R_MISSING_CERTID 165
#define CMP_R_MISSING_KEY_INPUT_FOR_CREATING_PROTECTION 130
#define CMP_R_MISSING_KEY_USAGE_DIGITALSIGNATURE 142
#define CMP_R_MISSING_P10CSR 121
#define CMP_R_MISSING_PBM_SECRET 166
#define CMP_R_MISSING_PRIVATE_KEY 131
#define CMP_R_MISSING_PRIVATE_KEY_FOR_POPO 190
#define CMP_R_MISSING_PROTECTION 143
#define CMP_R_MISSING_PUBLIC_KEY 183
#define CMP_R_MISSING_REFERENCE_CERT 168
#define CMP_R_MISSING_SECRET 178
#define CMP_R_MISSING_SENDER_IDENTIFICATION 111
#define CMP_R_MISSING_TRUST_ANCHOR 179
#define CMP_R_MISSING_TRUST_STORE 144
#define CMP_R_MULTIPLE_REQUESTS_NOT_SUPPORTED 161
#define CMP_R_MULTIPLE_RESPONSES_NOT_SUPPORTED 170
#define CMP_R_MULTIPLE_SAN_SOURCES 102
#define CMP_R_NO_STDIO 194
#define CMP_R_NO_SUITABLE_SENDER_CERT 145
#define CMP_R_NULL_ARGUMENT 103
#define CMP_R_PKIBODY_ERROR 146
#define CMP_R_PKISTATUSINFO_NOT_FOUND 132
#define CMP_R_POLLING_FAILED 172
#define CMP_R_POTENTIALLY_INVALID_CERTIFICATE 147
#define CMP_R_RECEIVED_ERROR 180
#define CMP_R_RECIPNONCE_UNMATCHED 148
#define CMP_R_REQUEST_NOT_ACCEPTED 149
#define CMP_R_REQUEST_REJECTED_BY_SERVER 182
#define CMP_R_SENDER_GENERALNAME_TYPE_NOT_SUPPORTED 150
#define CMP_R_SRVCERT_DOES_NOT_VALIDATE_MSG 151
#define CMP_R_TOTAL_TIMEOUT 184
#define CMP_R_TRANSACTIONID_UNMATCHED 152
#define CMP_R_TRANSFER_ERROR 159
#define CMP_R_UNCLEAN_CTX 191
#define CMP_R_UNEXPECTED_CENTRAL_GEN_KEY 205
#define CMP_R_UNEXPECTED_CERTPROFILE 196
#define CMP_R_UNEXPECTED_CRLSTATUSLIST 201
#define CMP_R_UNEXPECTED_PKIBODY 133
#define CMP_R_UNEXPECTED_PKISTATUS 185
#define CMP_R_UNEXPECTED_POLLREQ 105
#define CMP_R_UNEXPECTED_PVNO 153
#define CMP_R_UNEXPECTED_SENDER 106
#define CMP_R_UNKNOWN_ALGORITHM_ID 134
#define CMP_R_UNKNOWN_CERT_TYPE 135
#define CMP_R_UNKNOWN_CRL_ISSUER 200
#define CMP_R_UNKNOWN_PKISTATUS 186
#define CMP_R_UNSUPPORTED_ALGORITHM 136
#define CMP_R_UNSUPPORTED_KEY_TYPE 137
#define CMP_R_UNSUPPORTED_PKIBODY 101
#define CMP_R_UNSUPPORTED_PROTECTION_ALG_DHBASEDMAC 154
#define CMP_R_VALUE_TOO_LARGE 175
#define CMP_R_VALUE_TOO_SMALL 177
#define CMP_R_WRONG_ALGORITHM_OID 138
#define CMP_R_WRONG_CERTID 189
#define CMP_R_WRONG_CERTID_IN_RP 187
#define CMP_R_WRONG_PBM_VALUE 155
#define CMP_R_WRONG_RP_COMPONENT_COUNT 188
#define CMP_R_WRONG_SERIAL_IN_RP 173
#endif
#endif
include/openssl/cmserr.h
-128
View File
@@ -1,128 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-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
*/
#ifndef OPENSSL_CMSERR_H
#define OPENSSL_CMSERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
#ifndef OPENSSL_NO_CMS
/*
* CMS reason codes.
*/
#define CMS_R_ADD_SIGNER_ERROR 99
#define CMS_R_ATTRIBUTE_ERROR 161
#define CMS_R_CERTIFICATE_ALREADY_PRESENT 175
#define CMS_R_CERTIFICATE_HAS_NO_KEYID 160
#define CMS_R_CERTIFICATE_VERIFY_ERROR 100
#define CMS_R_CIPHER_AEAD_IN_ENVELOPED_DATA 200
#define CMS_R_CIPHER_AEAD_SET_TAG_ERROR 184
#define CMS_R_CIPHER_GET_TAG 185
#define CMS_R_CIPHER_INITIALISATION_ERROR 101
#define CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR 102
#define CMS_R_CMS_DATAFINAL_ERROR 103
#define CMS_R_CMS_LIB 104
#define CMS_R_CONTENTIDENTIFIER_MISMATCH 170
#define CMS_R_CONTENT_NOT_FOUND 105
#define CMS_R_CONTENT_TYPE_MISMATCH 171
#define CMS_R_CONTENT_TYPE_NOT_COMPRESSED_DATA 106
#define CMS_R_CONTENT_TYPE_NOT_ENVELOPED_DATA 107
#define CMS_R_CONTENT_TYPE_NOT_SIGNED_DATA 108
#define CMS_R_CONTENT_VERIFY_ERROR 109
#define CMS_R_CTRL_ERROR 110
#define CMS_R_CTRL_FAILURE 111
#define CMS_R_DECODE_ERROR 187
#define CMS_R_DECRYPT_ERROR 112
#define CMS_R_ERROR_GETTING_PUBLIC_KEY 113
#define CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE 114
#define CMS_R_ERROR_SETTING_KEY 115
#define CMS_R_ERROR_SETTING_RECIPIENTINFO 116
#define CMS_R_ERROR_UNSUPPORTED_STATIC_KEY_AGREEMENT 196
#define CMS_R_ESS_SIGNING_CERTID_MISMATCH_ERROR 183
#define CMS_R_INVALID_ENCRYPTED_KEY_LENGTH 117
#define CMS_R_INVALID_KEY_ENCRYPTION_PARAMETER 176
#define CMS_R_INVALID_KEY_LENGTH 118
#define CMS_R_INVALID_LABEL 190
#define CMS_R_INVALID_OAEP_PARAMETERS 191
#define CMS_R_KDF_PARAMETER_ERROR 186
#define CMS_R_MD_BIO_INIT_ERROR 119
#define CMS_R_MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH 120
#define CMS_R_MESSAGEDIGEST_WRONG_LENGTH 121
#define CMS_R_MSGSIGDIGEST_ERROR 172
#define CMS_R_MSGSIGDIGEST_VERIFICATION_FAILURE 162
#define CMS_R_MSGSIGDIGEST_WRONG_LENGTH 163
#define CMS_R_NEED_ONE_SIGNER 164
#define CMS_R_NOT_A_SIGNED_RECEIPT 165
#define CMS_R_NOT_ENCRYPTED_DATA 122
#define CMS_R_NOT_KEK 123
#define CMS_R_NOT_KEM 197
#define CMS_R_NOT_KEY_AGREEMENT 181
#define CMS_R_NOT_KEY_TRANSPORT 124
#define CMS_R_NOT_PWRI 177
#define CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 125
#define CMS_R_NO_CIPHER 126
#define CMS_R_NO_CONTENT 127
#define CMS_R_NO_CONTENT_TYPE 173
#define CMS_R_NO_DEFAULT_DIGEST 128
#define CMS_R_NO_DIGEST_SET 129
#define CMS_R_NO_KEY 130
#define CMS_R_NO_KEY_OR_CERT 174
#define CMS_R_NO_MATCHING_DIGEST 131
#define CMS_R_NO_MATCHING_RECIPIENT 132
#define CMS_R_NO_MATCHING_SIGNATURE 166
#define CMS_R_NO_MSGSIGDIGEST 167
#define CMS_R_NO_PASSWORD 178
#define CMS_R_NO_PRIVATE_KEY 133
#define CMS_R_NO_PUBLIC_KEY 134
#define CMS_R_NO_RECEIPT_REQUEST 168
#define CMS_R_NO_SIGNERS 135
#define CMS_R_OPERATION_UNSUPPORTED 182
#define CMS_R_PEER_KEY_ERROR 188
#define CMS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 136
#define CMS_R_RECEIPT_DECODE_ERROR 169
#define CMS_R_RECIPIENT_ERROR 137
#define CMS_R_SHARED_INFO_ERROR 189
#define CMS_R_SIGNER_CERTIFICATE_NOT_FOUND 138
#define CMS_R_SIGNFINAL_ERROR 139
#define CMS_R_SMIME_TEXT_ERROR 140
#define CMS_R_STORE_INIT_ERROR 141
#define CMS_R_TYPE_NOT_COMPRESSED_DATA 142
#define CMS_R_TYPE_NOT_DATA 143
#define CMS_R_TYPE_NOT_DIGESTED_DATA 144
#define CMS_R_TYPE_NOT_ENCRYPTED_DATA 145
#define CMS_R_TYPE_NOT_ENVELOPED_DATA 146
#define CMS_R_UNABLE_TO_FINALIZE_CONTEXT 147
#define CMS_R_UNKNOWN_CIPHER 148
#define CMS_R_UNKNOWN_DIGEST_ALGORITHM 149
#define CMS_R_UNKNOWN_ID 150
#define CMS_R_UNKNOWN_KDF_ALGORITHM 198
#define CMS_R_UNSUPPORTED_COMPRESSION_ALGORITHM 151
#define CMS_R_UNSUPPORTED_CONTENT_ENCRYPTION_ALGORITHM 194
#define CMS_R_UNSUPPORTED_CONTENT_TYPE 152
#define CMS_R_UNSUPPORTED_ENCRYPTION_TYPE 192
#define CMS_R_UNSUPPORTED_KDF_ALGORITHM 199
#define CMS_R_UNSUPPORTED_KEK_ALGORITHM 153
#define CMS_R_UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM 179
#define CMS_R_UNSUPPORTED_LABEL_SOURCE 193
#define CMS_R_UNSUPPORTED_RECIPIENTINFO_TYPE 155
#define CMS_R_UNSUPPORTED_RECIPIENT_TYPE 154
#define CMS_R_UNSUPPORTED_SIGNATURE_ALGORITHM 195
#define CMS_R_UNSUPPORTED_TYPE 156
#define CMS_R_UNWRAP_ERROR 157
#define CMS_R_UNWRAP_FAILURE 180
#define CMS_R_VERIFICATION_FAILURE 158
#define CMS_R_WRAP_ERROR 159
#endif
#endif
include/openssl/comperr.h
-36
View File
@@ -1,36 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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
*/
#ifndef OPENSSL_COMPERR_H
#define OPENSSL_COMPERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
#ifndef OPENSSL_NO_COMP
/*
* COMP reason codes.
*/
#define COMP_R_BROTLI_DECODE_ERROR 102
#define COMP_R_BROTLI_ENCODE_ERROR 103
#define COMP_R_BROTLI_NOT_SUPPORTED 104
#define COMP_R_ZLIB_DEFLATE_ERROR 99
#define COMP_R_ZLIB_INFLATE_ERROR 100
#define COMP_R_ZLIB_NOT_SUPPORTED 101
#define COMP_R_ZSTD_COMPRESS_ERROR 105
#define COMP_R_ZSTD_DECODE_ERROR 106
#define COMP_R_ZSTD_DECOMPRESS_ERROR 107
#define COMP_R_ZSTD_NOT_SUPPORTED 108
#endif
#endif
include/openssl/conferr.h
-50
View File
@@ -1,50 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2023 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
*/
#ifndef OPENSSL_CONFERR_H
#define OPENSSL_CONFERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
/*
* CONF reason codes.
*/
#define CONF_R_ERROR_LOADING_DSO 110
#define CONF_R_INVALID_PRAGMA 122
#define CONF_R_LIST_CANNOT_BE_NULL 115
#define CONF_R_MANDATORY_BRACES_IN_VARIABLE_EXPANSION 123
#define CONF_R_MISSING_CLOSE_SQUARE_BRACKET 100
#define CONF_R_MISSING_EQUAL_SIGN 101
#define CONF_R_MISSING_INIT_FUNCTION 112
#define CONF_R_MODULE_INITIALIZATION_ERROR 109
#define CONF_R_NO_CLOSE_BRACE 102
#define CONF_R_NO_CONF 105
#define CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE 106
#define CONF_R_NO_SECTION 107
#define CONF_R_NO_SUCH_FILE 114
#define CONF_R_NO_VALUE 108
#define CONF_R_NUMBER_TOO_LARGE 121
#define CONF_R_OPENSSL_CONF_REFERENCES_MISSING_SECTION 124
#define CONF_R_RECURSIVE_DIRECTORY_INCLUDE 111
#define CONF_R_RECURSIVE_SECTION_REFERENCE 126
#define CONF_R_RELATIVE_PATH 125
#define CONF_R_SSL_COMMAND_SECTION_EMPTY 117
#define CONF_R_SSL_COMMAND_SECTION_NOT_FOUND 118
#define CONF_R_SSL_SECTION_EMPTY 119
#define CONF_R_SSL_SECTION_NOT_FOUND 120
#define CONF_R_UNABLE_TO_CREATE_NEW_SECTION 103
#define CONF_R_UNKNOWN_MODULE_NAME 113
#define CONF_R_VARIABLE_EXPANSION_TOO_LONG 116
#define CONF_R_VARIABLE_HAS_NO_VALUE 104
#endif
include/openssl/crmferr.h
-56
View File
@@ -1,56 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-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
*/
#ifndef OPENSSL_CRMFERR_H
#define OPENSSL_CRMFERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
#ifndef OPENSSL_NO_CRMF
/*
* CRMF reason codes.
*/
#define CRMF_R_BAD_PBM_ITERATIONCOUNT 100
#define CRMF_R_CMS_NOT_SUPPORTED 122
#define CRMF_R_CRMFERROR 102
#define CRMF_R_ERROR 103
#define CRMF_R_ERROR_DECODING_CERTIFICATE 104
#define CRMF_R_ERROR_DECODING_ENCRYPTEDKEY 123
#define CRMF_R_ERROR_DECRYPTING_CERTIFICATE 105
#define CRMF_R_ERROR_DECRYPTING_ENCRYPTEDKEY 124
#define CRMF_R_ERROR_DECRYPTING_ENCRYPTEDVALUE 125
#define CRMF_R_ERROR_DECRYPTING_SYMMETRIC_KEY 106
#define CRMF_R_ERROR_SETTING_PURPOSE 126
#define CRMF_R_ERROR_SIGNING_POPO 129
#define CRMF_R_ERROR_VERIFYING_ENCRYPTEDKEY 127
#define CRMF_R_FAILURE_OBTAINING_RANDOM 107
#define CRMF_R_ITERATIONCOUNT_BELOW_100 108
#define CRMF_R_MALFORMED_IV 101
#define CRMF_R_NULL_ARGUMENT 109
#define CRMF_R_POPOSKINPUT_NOT_SUPPORTED 113
#define CRMF_R_POPO_INCONSISTENT_CENTRAL_KEYGEN 128
#define CRMF_R_POPO_INCONSISTENT_PUBLIC_KEY 117
#define CRMF_R_POPO_MISSING 121
#define CRMF_R_POPO_MISSING_PUBLIC_KEY 118
#define CRMF_R_POPO_MISSING_SUBJECT 119
#define CRMF_R_POPO_RAVERIFIED_NOT_ACCEPTED 120
#define CRMF_R_SETTING_MAC_ALGOR_FAILURE 110
#define CRMF_R_SETTING_OWF_ALGOR_FAILURE 111
#define CRMF_R_UNSUPPORTED_ALGORITHM 112
#define CRMF_R_UNSUPPORTED_CIPHER 114
#define CRMF_R_UNSUPPORTED_METHOD_FOR_CREATING_POPO 115
#define CRMF_R_UNSUPPORTED_POPO_METHOD 116
#endif
#endif
include/openssl/cryptoerr.h
-54
View File
@@ -1,54 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2024 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
*/
#ifndef OPENSSL_CRYPTOERR_H
#define OPENSSL_CRYPTOERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
/*
* CRYPTO reason codes.
*/
#define CRYPTO_R_BAD_ALGORITHM_NAME 117
#define CRYPTO_R_CONFLICTING_NAMES 118
#define CRYPTO_R_HEX_STRING_TOO_SHORT 121
#define CRYPTO_R_ILLEGAL_HEX_DIGIT 102
#define CRYPTO_R_INSUFFICIENT_DATA_SPACE 106
#define CRYPTO_R_INSUFFICIENT_PARAM_SIZE 107
#define CRYPTO_R_INSUFFICIENT_SECURE_DATA_SPACE 108
#define CRYPTO_R_INTEGER_OVERFLOW 127
#define CRYPTO_R_INVALID_NEGATIVE_VALUE 122
#define CRYPTO_R_INVALID_NULL_ARGUMENT 109
#define CRYPTO_R_INVALID_OSSL_PARAM_TYPE 110
#define CRYPTO_R_NO_PARAMS_TO_MERGE 131
#define CRYPTO_R_NO_SPACE_FOR_TERMINATING_NULL 128
#define CRYPTO_R_ODD_NUMBER_OF_DIGITS 103
#define CRYPTO_R_PARAM_CANNOT_BE_REPRESENTED_EXACTLY 123
#define CRYPTO_R_PARAM_NOT_INTEGER_TYPE 124
#define CRYPTO_R_PARAM_OF_INCOMPATIBLE_TYPE 129
#define CRYPTO_R_PARAM_UNSIGNED_INTEGER_NEGATIVE_VALUE_UNSUPPORTED 125
#define CRYPTO_R_PARAM_UNSUPPORTED_FLOATING_POINT_FORMAT 130
#define CRYPTO_R_PARAM_VALUE_TOO_LARGE_FOR_DESTINATION 126
#define CRYPTO_R_PROVIDER_ALREADY_EXISTS 104
#define CRYPTO_R_PROVIDER_SECTION_ERROR 105
#define CRYPTO_R_RANDOM_SECTION_ERROR 119
#define CRYPTO_R_SECURE_MALLOC_FAILURE 111
#define CRYPTO_R_STRING_TOO_LONG 112
#define CRYPTO_R_TOO_MANY_BYTES 113
#define CRYPTO_R_TOO_MANY_NAMES 132
#define CRYPTO_R_TOO_MANY_RECORDS 114
#define CRYPTO_R_TOO_SMALL_BUFFER 116
#define CRYPTO_R_UNKNOWN_NAME_IN_RANDOM_SECTION 120
#define CRYPTO_R_ZERO_LENGTH_NUMBER 115
#endif
include/openssl/cterr.h
-43
View File
@@ -1,43 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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
*/
#ifndef OPENSSL_CTERR_H
#define OPENSSL_CTERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
#ifndef OPENSSL_NO_CT
/*
* CT reason codes.
*/
#define CT_R_BASE64_DECODE_ERROR 108
#define CT_R_INVALID_LOG_ID_LENGTH 100
#define CT_R_LOG_CONF_INVALID 109
#define CT_R_LOG_CONF_INVALID_KEY 110
#define CT_R_LOG_CONF_MISSING_DESCRIPTION 111
#define CT_R_LOG_CONF_MISSING_KEY 112
#define CT_R_LOG_KEY_INVALID 113
#define CT_R_SCT_FUTURE_TIMESTAMP 116
#define CT_R_SCT_INVALID 104
#define CT_R_SCT_INVALID_SIGNATURE 107
#define CT_R_SCT_LIST_INVALID 105
#define CT_R_SCT_LOG_ID_MISMATCH 114
#define CT_R_SCT_NOT_SET 106
#define CT_R_SCT_UNSUPPORTED_VERSION 115
#define CT_R_UNRECOGNIZED_SIGNATURE_NID 101
#define CT_R_UNSUPPORTED_ENTRY_TYPE 102
#define CT_R_UNSUPPORTED_VERSION 103
#endif
#endif
include/openssl/decodererr.h
-26
View File
@@ -1,26 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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
*/
#ifndef OPENSSL_DECODERERR_H
#define OPENSSL_DECODERERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
/*
* OSSL_DECODER reason codes.
*/
#define OSSL_DECODER_R_COULD_NOT_DECODE_OBJECT 101
#define OSSL_DECODER_R_DECODER_NOT_FOUND 102
#define OSSL_DECODER_R_MISSING_GET_PARAMS 100
#endif
include/openssl/dherr.h
-57
View File
@@ -1,57 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2023 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
*/
#ifndef OPENSSL_DHERR_H
#define OPENSSL_DHERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
#ifndef OPENSSL_NO_DH
/*
* DH reason codes.
*/
#define DH_R_BAD_FFC_PARAMETERS 127
#define DH_R_BAD_GENERATOR 101
#define DH_R_BN_DECODE_ERROR 109
#define DH_R_BN_ERROR 106
#define DH_R_CHECK_INVALID_J_VALUE 115
#define DH_R_CHECK_INVALID_Q_VALUE 116
#define DH_R_CHECK_PUBKEY_INVALID 122
#define DH_R_CHECK_PUBKEY_TOO_LARGE 123
#define DH_R_CHECK_PUBKEY_TOO_SMALL 124
#define DH_R_CHECK_P_NOT_PRIME 117
#define DH_R_CHECK_P_NOT_SAFE_PRIME 118
#define DH_R_CHECK_Q_NOT_PRIME 119
#define DH_R_DECODE_ERROR 104
#define DH_R_INVALID_PARAMETER_NAME 110
#define DH_R_INVALID_PARAMETER_NID 114
#define DH_R_INVALID_PUBKEY 102
#define DH_R_INVALID_SECRET 128
#define DH_R_INVALID_SIZE 129
#define DH_R_KDF_PARAMETER_ERROR 112
#define DH_R_KEYS_NOT_SET 108
#define DH_R_MISSING_PUBKEY 125
#define DH_R_MODULUS_TOO_LARGE 103
#define DH_R_MODULUS_TOO_SMALL 126
#define DH_R_NOT_SUITABLE_GENERATOR 120
#define DH_R_NO_PARAMETERS_SET 107
#define DH_R_NO_PRIVATE_VALUE 100
#define DH_R_PARAMETER_ENCODING_ERROR 105
#define DH_R_PEER_KEY_ERROR 111
#define DH_R_Q_TOO_LARGE 130
#define DH_R_SHARED_INFO_ERROR 113
#define DH_R_UNABLE_TO_CHECK_GENERATOR 121
#endif
#endif
include/openssl/dsaerr.h
-42
View File
@@ -1,42 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2023 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
*/
#ifndef OPENSSL_DSAERR_H
#define OPENSSL_DSAERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
#ifndef OPENSSL_NO_DSA
/*
* DSA reason codes.
*/
#define DSA_R_BAD_FFC_PARAMETERS 114
#define DSA_R_BAD_Q_VALUE 102
#define DSA_R_BN_DECODE_ERROR 108
#define DSA_R_BN_ERROR 109
#define DSA_R_DECODE_ERROR 104
#define DSA_R_INVALID_DIGEST_TYPE 106
#define DSA_R_INVALID_PARAMETERS 112
#define DSA_R_MISSING_PARAMETERS 101
#define DSA_R_MISSING_PRIVATE_KEY 111
#define DSA_R_MODULUS_TOO_LARGE 103
#define DSA_R_NO_PARAMETERS_SET 107
#define DSA_R_PARAMETER_ENCODING_ERROR 105
#define DSA_R_P_NOT_PRIME 115
#define DSA_R_Q_NOT_PRIME 113
#define DSA_R_SEED_LEN_SMALL 110
#define DSA_R_TOO_MANY_RETRIES 116
#endif
#endif
include/openssl/ecerr.h
-102
View File
@@ -1,102 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2023 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
*/
#ifndef OPENSSL_ECERR_H
#define OPENSSL_ECERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
#ifndef OPENSSL_NO_EC
/*
* EC reason codes.
*/
#define EC_R_ASN1_ERROR 115
#define EC_R_BAD_SIGNATURE 156
#define EC_R_BIGNUM_OUT_OF_RANGE 144
#define EC_R_BUFFER_TOO_SMALL 100
#define EC_R_CANNOT_INVERT 165
#define EC_R_COORDINATES_OUT_OF_RANGE 146
#define EC_R_CURVE_DOES_NOT_SUPPORT_ECDH 160
#define EC_R_CURVE_DOES_NOT_SUPPORT_ECDSA 170
#define EC_R_CURVE_DOES_NOT_SUPPORT_SIGNING 159
#define EC_R_DECODE_ERROR 142
#define EC_R_DISCRIMINANT_IS_ZERO 118
#define EC_R_EC_GROUP_NEW_BY_NAME_FAILURE 119
#define EC_R_EXPLICIT_PARAMS_NOT_SUPPORTED 127
#define EC_R_FAILED_MAKING_PUBLIC_KEY 166
#define EC_R_FIELD_TOO_LARGE 143
#define EC_R_GF2M_NOT_SUPPORTED 147
#define EC_R_GROUP2PKPARAMETERS_FAILURE 120
#define EC_R_I2D_ECPKPARAMETERS_FAILURE 121
#define EC_R_INCOMPATIBLE_OBJECTS 101
#define EC_R_INVALID_A 168
#define EC_R_INVALID_ARGUMENT 112
#define EC_R_INVALID_B 169
#define EC_R_INVALID_COFACTOR 171
#define EC_R_INVALID_COMPRESSED_POINT 110
#define EC_R_INVALID_COMPRESSION_BIT 109
#define EC_R_INVALID_CURVE 141
#define EC_R_INVALID_DIGEST 151
#define EC_R_INVALID_DIGEST_TYPE 138
#define EC_R_INVALID_ENCODING 102
#define EC_R_INVALID_FIELD 103
#define EC_R_INVALID_FORM 104
#define EC_R_INVALID_GENERATOR 173
#define EC_R_INVALID_GROUP_ORDER 122
#define EC_R_INVALID_KEY 116
#define EC_R_INVALID_LENGTH 117
#define EC_R_INVALID_NAMED_GROUP_CONVERSION 174
#define EC_R_INVALID_OUTPUT_LENGTH 161
#define EC_R_INVALID_P 172
#define EC_R_INVALID_PEER_KEY 133
#define EC_R_INVALID_PENTANOMIAL_BASIS 132
#define EC_R_INVALID_PRIVATE_KEY 123
#define EC_R_INVALID_SEED 175
#define EC_R_INVALID_TRINOMIAL_BASIS 137
#define EC_R_KDF_PARAMETER_ERROR 148
#define EC_R_KEYS_NOT_SET 140
#define EC_R_LADDER_POST_FAILURE 136
#define EC_R_LADDER_PRE_FAILURE 153
#define EC_R_LADDER_STEP_FAILURE 162
#define EC_R_MISSING_OID 167
#define EC_R_MISSING_PARAMETERS 124
#define EC_R_MISSING_PRIVATE_KEY 125
#define EC_R_NEED_NEW_SETUP_VALUES 157
#define EC_R_NOT_A_NIST_PRIME 135
#define EC_R_NOT_IMPLEMENTED 126
#define EC_R_NOT_INITIALIZED 111
#define EC_R_NO_PARAMETERS_SET 139
#define EC_R_NO_PRIVATE_VALUE 154
#define EC_R_OPERATION_NOT_SUPPORTED 152
#define EC_R_PASSED_NULL_PARAMETER 134
#define EC_R_PEER_KEY_ERROR 149
#define EC_R_POINT_ARITHMETIC_FAILURE 155
#define EC_R_POINT_AT_INFINITY 106
#define EC_R_POINT_COORDINATES_BLIND_FAILURE 163
#define EC_R_POINT_IS_NOT_ON_CURVE 107
#define EC_R_RANDOM_NUMBER_GENERATION_FAILED 158
#define EC_R_SHARED_INFO_ERROR 150
#define EC_R_SLOT_FULL 108
#define EC_R_TOO_MANY_RETRIES 176
#define EC_R_UNDEFINED_GENERATOR 113
#define EC_R_UNDEFINED_ORDER 128
#define EC_R_UNKNOWN_COFACTOR 164
#define EC_R_UNKNOWN_GROUP 129
#define EC_R_UNKNOWN_ORDER 114
#define EC_R_UNSUPPORTED_FIELD 131
#define EC_R_WRONG_CURVE_PARAMETERS 145
#define EC_R_WRONG_ORDER 130
#endif
#endif
include/openssl/encodererr.h
-28
View File
@@ -1,28 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-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
*/
#ifndef OPENSSL_ENCODERERR_H
#define OPENSSL_ENCODERERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
/*
* OSSL_ENCODER reason codes.
*/
#define OSSL_ENCODER_R_BAD_PARAMETER_VALUE 103
#define OSSL_ENCODER_R_ENCODER_NOT_FOUND 101
#define OSSL_ENCODER_R_INCORRECT_PROPERTY_QUERY 100
#define OSSL_ENCODER_R_MISSING_GET_PARAMS 102
#define OSSL_ENCODER_R_UNKNOWN_PARAMETER_NAME 104
#endif
include/openssl/esserr.h
-32
View File
@@ -1,32 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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
*/
#ifndef OPENSSL_ESSERR_H
#define OPENSSL_ESSERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
/*
* ESS reason codes.
*/
#define ESS_R_EMPTY_ESS_CERT_ID_LIST 107
#define ESS_R_ESS_CERT_DIGEST_ERROR 103
#define ESS_R_ESS_CERT_ID_NOT_FOUND 104
#define ESS_R_ESS_CERT_ID_WRONG_ORDER 105
#define ESS_R_ESS_DIGEST_ALG_UNKNOWN 106
#define ESS_R_ESS_SIGNING_CERTIFICATE_ERROR 102
#define ESS_R_ESS_SIGNING_CERT_ADD_ERROR 100
#define ESS_R_ESS_SIGNING_CERT_V2_ADD_ERROR 101
#define ESS_R_MISSING_SIGNING_CERTIFICATE_ATTRIBUTE 108
#endif
include/openssl/evperr.h
-148
View File
@@ -1,148 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-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
*/
#ifndef OPENSSL_EVPERR_H
#define OPENSSL_EVPERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
/*
* EVP reason codes.
*/
#define EVP_R_AES_KEY_SETUP_FAILED 143
#define EVP_R_ARIA_KEY_SETUP_FAILED 176
#define EVP_R_BAD_ALGORITHM_NAME 200
#define EVP_R_BAD_DECRYPT 100
#define EVP_R_BAD_KEY_LENGTH 195
#define EVP_R_BUFFER_TOO_SMALL 155
#define EVP_R_CACHE_CONSTANTS_FAILED 225
#define EVP_R_CAMELLIA_KEY_SETUP_FAILED 157
#define EVP_R_CANNOT_GET_PARAMETERS 197
#define EVP_R_CANNOT_SET_PARAMETERS 198
#define EVP_R_CIPHER_NOT_GCM_MODE 184
#define EVP_R_CIPHER_PARAMETER_ERROR 122
#define EVP_R_COMMAND_NOT_SUPPORTED 147
#define EVP_R_CONFLICTING_ALGORITHM_NAME 201
#define EVP_R_CONTEXT_FINALIZED 239
#define EVP_R_COPY_ERROR 173
#define EVP_R_CTRL_NOT_IMPLEMENTED 132
#define EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED 133
#define EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH 138
#define EVP_R_DECODE_ERROR 114
#define EVP_R_DEFAULT_QUERY_PARSE_ERROR 210
#define EVP_R_DIFFERENT_KEY_TYPES 101
#define EVP_R_DIFFERENT_PARAMETERS 153
#define EVP_R_ERROR_LOADING_SECTION 165
#define EVP_R_EXPECTING_AN_HMAC_KEY 174
#define EVP_R_EXPECTING_AN_RSA_KEY 127
#define EVP_R_EXPECTING_A_DH_KEY 128
#define EVP_R_EXPECTING_A_DSA_KEY 129
#define EVP_R_EXPECTING_A_ECX_KEY 219
#define EVP_R_EXPECTING_A_EC_KEY 142
#define EVP_R_EXPECTING_A_POLY1305_KEY 164
#define EVP_R_EXPECTING_A_SIPHASH_KEY 175
#define EVP_R_FINAL_ERROR 188
#define EVP_R_GENERATE_ERROR 214
#define EVP_R_GETTING_ALGORITHMIDENTIFIER_NOT_SUPPORTED 229
#define EVP_R_GET_RAW_KEY_FAILED 182
#define EVP_R_ILLEGAL_SCRYPT_PARAMETERS 171
#define EVP_R_INACCESSIBLE_DOMAIN_PARAMETERS 204
#define EVP_R_INACCESSIBLE_KEY 203
#define EVP_R_INITIALIZATION_ERROR 134
#define EVP_R_INPUT_NOT_INITIALIZED 111
#define EVP_R_INVALID_CUSTOM_LENGTH 185
#define EVP_R_INVALID_DIGEST 152
#define EVP_R_INVALID_IV_LENGTH 194
#define EVP_R_INVALID_KEY 163
#define EVP_R_INVALID_KEY_LENGTH 130
#define EVP_R_INVALID_LENGTH 221
#define EVP_R_INVALID_NULL_ALGORITHM 218
#define EVP_R_INVALID_OPERATION 148
#define EVP_R_INVALID_PROVIDER_FUNCTIONS 193
#define EVP_R_INVALID_SALT_LENGTH 186
#define EVP_R_INVALID_SECRET_LENGTH 223
#define EVP_R_INVALID_SEED_LENGTH 220
#define EVP_R_INVALID_VALUE 222
#define EVP_R_KEYMGMT_EXPORT_FAILURE 205
#define EVP_R_KEY_SETUP_FAILED 180
#define EVP_R_LOCKING_NOT_SUPPORTED 213
#define EVP_R_MEMORY_LIMIT_EXCEEDED 172
#define EVP_R_MESSAGE_DIGEST_IS_NULL 159
#define EVP_R_METHOD_NOT_SUPPORTED 144
#define EVP_R_MISSING_PARAMETERS 103
#define EVP_R_NOT_ABLE_TO_COPY_CTX 190
#define EVP_R_NOT_XOF_OR_INVALID_LENGTH 178
#define EVP_R_NO_CIPHER_SET 131
#define EVP_R_NO_DEFAULT_DIGEST 158
#define EVP_R_NO_DIGEST_SET 139
#define EVP_R_NO_IMPORT_FUNCTION 206
#define EVP_R_NO_KEYMGMT_AVAILABLE 199
#define EVP_R_NO_KEYMGMT_PRESENT 196
#define EVP_R_NO_KEY_SET 154
#define EVP_R_NO_OPERATION_SET 149
#define EVP_R_NULL_MAC_PKEY_CTX 208
#define EVP_R_ONLY_ONESHOT_SUPPORTED 177
#define EVP_R_OPERATION_NOT_INITIALIZED 151
#define EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE 150
#define EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_SIGNATURE_TYPE 226
#define EVP_R_OUTPUT_WOULD_OVERFLOW 202
#define EVP_R_PARAMETER_TOO_LARGE 187
#define EVP_R_PARTIALLY_OVERLAPPING 162
#define EVP_R_PBKDF2_ERROR 181
#define EVP_R_PIPELINE_NOT_SUPPORTED 230
#define EVP_R_PKEY_APPLICATION_ASN1_METHOD_ALREADY_REGISTERED 179
#define EVP_R_PRIVATE_KEY_DECODE_ERROR 145
#define EVP_R_PRIVATE_KEY_ENCODE_ERROR 146
#define EVP_R_PROVIDER_ASYM_CIPHER_FAILURE 232
#define EVP_R_PROVIDER_ASYM_CIPHER_NOT_SUPPORTED 235
#define EVP_R_PROVIDER_GET_CTX_PARAMS_NOT_SUPPORTED 238
#define EVP_R_PROVIDER_KEYMGMT_FAILURE 233
#define EVP_R_PROVIDER_KEYMGMT_NOT_SUPPORTED 236
#define EVP_R_PROVIDER_SIGNATURE_FAILURE 234
#define EVP_R_PROVIDER_SIGNATURE_NOT_SUPPORTED 237
#define EVP_R_PUBLIC_KEY_NOT_RSA 106
#define EVP_R_SETTING_XOF_FAILED 227
#define EVP_R_SET_DEFAULT_PROPERTY_FAILURE 209
#define EVP_R_SIGNATURE_TYPE_AND_KEY_TYPE_INCOMPATIBLE 228
#define EVP_R_TOO_MANY_PIPES 231
#define EVP_R_TOO_MANY_RECORDS 183
#define EVP_R_UNABLE_TO_ENABLE_LOCKING 212
#define EVP_R_UNABLE_TO_GET_MAXIMUM_REQUEST_SIZE 215
#define EVP_R_UNABLE_TO_GET_RANDOM_STRENGTH 216
#define EVP_R_UNABLE_TO_LOCK_CONTEXT 211
#define EVP_R_UNABLE_TO_SET_CALLBACKS 217
#define EVP_R_UNKNOWN_BITS 166
#define EVP_R_UNKNOWN_CIPHER 160
#define EVP_R_UNKNOWN_DIGEST 161
#define EVP_R_UNKNOWN_KEY_TYPE 207
#define EVP_R_UNKNOWN_MAX_SIZE 167
#define EVP_R_UNKNOWN_OPTION 169
#define EVP_R_UNKNOWN_PBE_ALGORITHM 121
#define EVP_R_UNKNOWN_SECURITY_BITS 168
#define EVP_R_UNSUPPORTED_ALGORITHM 156
#define EVP_R_UNSUPPORTED_CIPHER 107
#define EVP_R_UNSUPPORTED_KEYLENGTH 123
#define EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION 124
#define EVP_R_UNSUPPORTED_KEY_SIZE 108
#define EVP_R_UNSUPPORTED_KEY_TYPE 224
#define EVP_R_UNSUPPORTED_NUMBER_OF_ROUNDS 135
#define EVP_R_UNSUPPORTED_PRF 125
#define EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM 118
#define EVP_R_UNSUPPORTED_SALT_TYPE 126
#define EVP_R_UPDATE_ERROR 189
#define EVP_R_WRAP_MODE_NOT_ALLOWED 170
#define EVP_R_WRONG_FINAL_BLOCK_LENGTH 109
#define EVP_R_XTS_DATA_UNIT_IS_TOO_LARGE 191
#define EVP_R_XTS_DUPLICATED_KEYS 192
#endif
include/openssl/httperr.h
-55
View File
@@ -1,55 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2026 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
*/
#ifndef OPENSSL_HTTPERR_H
#define OPENSSL_HTTPERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
/*
* HTTP reason codes.
*/
#define HTTP_R_ASN1_LEN_EXCEEDS_MAX_RESP_LEN 108
#define HTTP_R_CONNECT_FAILURE 100
#define HTTP_R_CONTENT_TYPE_MISMATCH 131
#define HTTP_R_ERROR_PARSING_ASN1_LENGTH 109
#define HTTP_R_ERROR_PARSING_CONTENT_LENGTH 119
#define HTTP_R_ERROR_PARSING_URL 101
#define HTTP_R_ERROR_RECEIVING 103
#define HTTP_R_ERROR_SENDING 102
#define HTTP_R_FAILED_READING_DATA 128
#define HTTP_R_HEADER_PARSE_ERROR 126
#define HTTP_R_INCONSISTENT_CONTENT_LENGTH 120
#define HTTP_R_INVALID_PORT_NUMBER 123
#define HTTP_R_INVALID_URL_PATH 125
#define HTTP_R_INVALID_URL_SCHEME 124
#define HTTP_R_MAX_RESP_LEN_EXCEEDED 117
#define HTTP_R_MISSING_ASN1_ENCODING 110
#define HTTP_R_MISSING_CONTENT_TYPE 121
#define HTTP_R_MISSING_REDIRECT_LOCATION 111
#define HTTP_R_RECEIVED_ERROR 105
#define HTTP_R_RECEIVED_WRONG_HTTP_VERSION 106
#define HTTP_R_REDIRECTION_FROM_HTTPS_TO_HTTP 112
#define HTTP_R_REDIRECTION_NOT_ENABLED 116
#define HTTP_R_RESPONSE_LINE_TOO_LONG 113
#define HTTP_R_RESPONSE_PARSE_ERROR 104
#define HTTP_R_RESPONSE_TOO_MANY_HDRLINES 130
#define HTTP_R_RETRY_TIMEOUT 129
#define HTTP_R_SERVER_CANCELED_CONNECTION 127
#define HTTP_R_SOCK_NOT_SUPPORTED 122
#define HTTP_R_STATUS_CODE_UNSUPPORTED 114
#define HTTP_R_TLS_NOT_ENABLED 107
#define HTTP_R_TOO_MANY_REDIRECTIONS 115
#define HTTP_R_UNEXPECTED_CONTENT_TYPE 118
#endif
include/openssl/objectserr.h
-26
View File
@@ -1,26 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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
*/
#ifndef OPENSSL_OBJECTSERR_H
#define OPENSSL_OBJECTSERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
/*
* OBJ reason codes.
*/
#define OBJ_R_OID_EXISTS 102
#define OBJ_R_UNKNOWN_NID 101
#define OBJ_R_UNKNOWN_OBJECT_NAME 103
#endif
include/openssl/ocsperr.h
-51
View File
@@ -1,51 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-2021 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
*/
#ifndef OPENSSL_OCSPERR_H
#define OPENSSL_OCSPERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
#ifndef OPENSSL_NO_OCSP
/*
* OCSP reason codes.
*/
#define OCSP_R_CERTIFICATE_VERIFY_ERROR 101
#define OCSP_R_DIGEST_ERR 102
#define OCSP_R_DIGEST_NAME_ERR 106
#define OCSP_R_DIGEST_SIZE_ERR 107
#define OCSP_R_ERROR_IN_NEXTUPDATE_FIELD 122
#define OCSP_R_ERROR_IN_THISUPDATE_FIELD 123
#define OCSP_R_MISSING_OCSPSIGNING_USAGE 103
#define OCSP_R_NEXTUPDATE_BEFORE_THISUPDATE 124
#define OCSP_R_NOT_BASIC_RESPONSE 104
#define OCSP_R_NO_CERTIFICATES_IN_CHAIN 105
#define OCSP_R_NO_RESPONSE_DATA 108
#define OCSP_R_NO_REVOKED_TIME 109
#define OCSP_R_NO_SIGNER_KEY 130
#define OCSP_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 110
#define OCSP_R_REQUEST_NOT_SIGNED 128
#define OCSP_R_RESPONSE_CONTAINS_NO_REVOCATION_DATA 111
#define OCSP_R_ROOT_CA_NOT_TRUSTED 112
#define OCSP_R_SIGNATURE_FAILURE 117
#define OCSP_R_SIGNER_CERTIFICATE_NOT_FOUND 118
#define OCSP_R_STATUS_EXPIRED 125
#define OCSP_R_STATUS_NOT_YET_VALID 126
#define OCSP_R_STATUS_TOO_OLD 127
#define OCSP_R_UNKNOWN_MESSAGE_DIGEST 119
#define OCSP_R_UNKNOWN_NID 120
#define OCSP_R_UNSUPPORTED_REQUESTORNAME_TYPE 129
#endif
#endif
include/openssl/pemerr.h
-57
View File
@@ -1,57 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-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
*/
#ifndef OPENSSL_PEMERR_H
#define OPENSSL_PEMERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
/*
* PEM reason codes.
*/
#define PEM_R_BAD_BASE64_DECODE 100
#define PEM_R_BAD_DECRYPT 101
#define PEM_R_BAD_END_LINE 102
#define PEM_R_BAD_IV_CHARS 103
#define PEM_R_BAD_MAGIC_NUMBER 116
#define PEM_R_BAD_PASSWORD_READ 104
#define PEM_R_BAD_VERSION_NUMBER 117
#define PEM_R_BIO_WRITE_FAILURE 118
#define PEM_R_CIPHER_IS_NULL 127
#define PEM_R_ERROR_CONVERTING_PRIVATE_KEY 115
#define PEM_R_EXPECTING_DSS_KEY_BLOB 131
#define PEM_R_EXPECTING_PRIVATE_KEY_BLOB 119
#define PEM_R_EXPECTING_PUBLIC_KEY_BLOB 120
#define PEM_R_EXPECTING_RSA_KEY_BLOB 132
#define PEM_R_HEADER_TOO_LONG 128
#define PEM_R_INCONSISTENT_HEADER 121
#define PEM_R_KEYBLOB_HEADER_PARSE_ERROR 122
#define PEM_R_KEYBLOB_TOO_SHORT 123
#define PEM_R_MISSING_DEK_IV 129
#define PEM_R_NOT_DEK_INFO 105
#define PEM_R_NOT_ENCRYPTED 106
#define PEM_R_NOT_PROC_TYPE 107
#define PEM_R_NO_START_LINE 108
#define PEM_R_PROBLEMS_GETTING_PASSWORD 109
#define PEM_R_PVK_DATA_TOO_SHORT 124
#define PEM_R_PVK_TOO_SHORT 125
#define PEM_R_READ_KEY 111
#define PEM_R_SHORT_HEADER 112
#define PEM_R_UNEXPECTED_DEK_IV 130
#define PEM_R_UNSUPPORTED_CIPHER 113
#define PEM_R_UNSUPPORTED_ENCRYPTION 114
#define PEM_R_UNSUPPORTED_KEY_COMPONENTS 126
#define PEM_R_UNSUPPORTED_PUBLIC_KEY_TYPE 110
#define PEM_R_UNSUPPORTED_PVK_KEY_TYPE 133
#endif
include/openssl/pkcs12err.h
-45
View File
@@ -1,45 +0,0 @@
/*
* Generated by util/mkerr.pl DO NOT EDIT
* Copyright 1995-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
*/
#ifndef OPENSSL_PKCS12ERR_H
#define OPENSSL_PKCS12ERR_H
#pragma once
#include <openssl/opensslconf.h>
#include <openssl/symhacks.h>
#include <openssl/cryptoerr_legacy.h>
/*
* PKCS12 reason codes.
*/
#define PKCS12_R_CALLBACK_FAILED 115
#define PKCS12_R_CANT_PACK_STRUCTURE 100
#define PKCS12_R_CONTENT_TYPE_NOT_DATA 121
#define PKCS12_R_DECODE_ERROR 101
#define PKCS12_R_ENCODE_ERROR 102
#define PKCS12_R_ENCRYPT_ERROR 103
#define PKCS12_R_ERROR_SETTING_ENCRYPTED_DATA_TYPE 120
#define PKCS12_R_INVALID_NULL_ARGUMENT 104
#define PKCS12_R_INVALID_NULL_PKCS12_POINTER 105
#define PKCS12_R_INVALID_SALT_LENGTH 117
#define PKCS12_R_INVALID_TYPE 112
#define PKCS12_R_IV_GEN_ERROR 106
#define PKCS12_R_KEY_GEN_ERROR 107
#define PKCS12_R_MAC_ABSENT 108
#define PKCS12_R_MAC_GENERATION_ERROR 109
#define PKCS12_R_MAC_SETUP_ERROR 110
#define PKCS12_R_MAC_STRING_SET_ERROR 111
#define PKCS12_R_MAC_VERIFY_FAILURE 113
#define PKCS12_R_PARSE_ERROR 114
#define PKCS12_R_PKCS12_CIPHERFINAL_ERROR 116
#define PKCS12_R_UNKNOWN_DIGEST_ALGORITHM 118
#define PKCS12_R_UNSUPPORTED_PKCS12_MODE 119
#endif
Loaded 100 of 114 files, more files were not shown because too many files have changed in this diff. Show more