LCRYPTO_ALIAS() and LSSL_ALIAS() contained a trailing semicolon.
This does not conform to style(9), breaks editors and ctags and
(most importantly) my workflow. Fix this by neutering them with
asm("") so that -Wpedantic doesn't complain. There's precedent
in libc's namespace.h
fix suggested by & ok jsing
-/* $OpenBSD: crypto_namespace.h,v 1.1 2022/11/11 11:25:18 beck Exp $ */
+/* $OpenBSD: crypto_namespace.h,v 1.2 2023/02/16 08:38:17 tb Exp $ */
/*
* Copyright (c) 2016 Philip Guenther <guenther@openbsd.org>
*
# define LCRYPTO_USED(x) __attribute__((visibility("hidden"))) \
typeof(x) x asm("_lcry_"#x)
# define LCRYPTO_ALIAS1(pre,x) asm(".global "#pre#x"; "#pre#x" = _lcry_"#x)
-# define LCRYPTO_ALIAS(x) LCRYPTO_ALIAS1(,x); LCRYPTO_ALIAS1(_libre_,x);
+# define LCRYPTO_ALIAS(x) LCRYPTO_ALIAS1(,x); LCRYPTO_ALIAS1(_libre_,x)
#else
# define LCRYPTO_USED(x) typeof(x) x asm("_libre_"#x)
#endif
# define LCRYPTO_UNUSED(x)
# define LCRYPTO_USED(x)
# define LCRYPTO_ALIAS1(pre,x)
-# define LCRYPTO_ALIAS(x)
+# define LCRYPTO_ALIAS(x) asm("")
#endif
#endif /* _LIBCRYPTO_CRYPTO_NAMESPACE_H_ */
-/* $OpenBSD: hmac.c,v 1.30 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: hmac.c,v 1.31 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
err:
return 0;
}
-LCRYPTO_ALIAS(HMAC_Init_ex)
+LCRYPTO_ALIAS(HMAC_Init_ex);
int
HMAC_Init(HMAC_CTX *ctx, const void *key, int len, const EVP_MD *md)
return EVP_DigestUpdate(&ctx->md_ctx, data, len);
}
-LCRYPTO_ALIAS(HMAC_Update)
+LCRYPTO_ALIAS(HMAC_Update);
int
HMAC_Final(HMAC_CTX *ctx, unsigned char *md, unsigned int *len)
err:
return 0;
}
-LCRYPTO_ALIAS(HMAC_Final)
+LCRYPTO_ALIAS(HMAC_Final);
HMAC_CTX *
HMAC_CTX_new(void)
return ctx;
}
-LCRYPTO_ALIAS(HMAC_CTX_new)
+LCRYPTO_ALIAS(HMAC_CTX_new);
void
HMAC_CTX_free(HMAC_CTX *ctx)
free(ctx);
}
-LCRYPTO_ALIAS(HMAC_CTX_free)
+LCRYPTO_ALIAS(HMAC_CTX_free);
int
HMAC_CTX_reset(HMAC_CTX *ctx)
err:
return 0;
}
-LCRYPTO_ALIAS(HMAC_CTX_copy)
+LCRYPTO_ALIAS(HMAC_CTX_copy);
void
HMAC_CTX_cleanup(HMAC_CTX *ctx)
EVP_MD_CTX_set_flags(&ctx->o_ctx, flags);
EVP_MD_CTX_set_flags(&ctx->md_ctx, flags);
}
-LCRYPTO_ALIAS(HMAC_CTX_set_flags)
+LCRYPTO_ALIAS(HMAC_CTX_set_flags);
const EVP_MD *
HMAC_CTX_get_md(const HMAC_CTX *ctx)
{
return ctx->md;
}
-LCRYPTO_ALIAS(HMAC_CTX_get_md)
+LCRYPTO_ALIAS(HMAC_CTX_get_md);
unsigned char *
HMAC(const EVP_MD *evp_md, const void *key, int key_len, const unsigned char *d,
HMAC_CTX_cleanup(&c);
return NULL;
}
-LCRYPTO_ALIAS(HMAC)
+LCRYPTO_ALIAS(HMAC);
-/* $OpenBSD: p12_add.c,v 1.21 2022/11/12 13:03:28 beck Exp $ */
+/* $OpenBSD: p12_add.c,v 1.22 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
safebag->type = OBJ_nid2obj(nid2);
return safebag;
}
-LCRYPTO_ALIAS(PKCS12_item_pack_safebag)
+LCRYPTO_ALIAS(PKCS12_item_pack_safebag);
/* Turn a stack of SAFEBAGS into a PKCS#7 data Contentinfo */
PKCS7 *
PKCS7_free(p7);
return NULL;
}
-LCRYPTO_ALIAS(PKCS12_pack_p7data)
+LCRYPTO_ALIAS(PKCS12_pack_p7data);
/* Unpack SAFEBAGS from PKCS#7 data ContentInfo */
STACK_OF(PKCS12_SAFEBAG) *
}
return ASN1_item_unpack(p7->d.data, &PKCS12_SAFEBAGS_it);
}
-LCRYPTO_ALIAS(PKCS12_unpack_p7data)
+LCRYPTO_ALIAS(PKCS12_unpack_p7data);
/* Turn a stack of SAFEBAGS into a PKCS#7 encrypted data ContentInfo */
PKCS7_free(p7);
return NULL;
}
-LCRYPTO_ALIAS(PKCS12_pack_p7encdata)
+LCRYPTO_ALIAS(PKCS12_pack_p7encdata);
STACK_OF(PKCS12_SAFEBAG) *
PKCS12_unpack_p7encdata(PKCS7 *p7, const char *pass, int passlen)
&PKCS12_SAFEBAGS_it, pass, passlen,
p7->d.encrypted->enc_data->enc_data, 1);
}
-LCRYPTO_ALIAS(PKCS12_unpack_p7encdata)
+LCRYPTO_ALIAS(PKCS12_unpack_p7encdata);
PKCS8_PRIV_KEY_INFO *
PKCS12_decrypt_skey(const PKCS12_SAFEBAG *bag, const char *pass, int passlen)
{
return PKCS8_decrypt(bag->value.shkeybag, pass, passlen);
}
-LCRYPTO_ALIAS(PKCS12_decrypt_skey)
+LCRYPTO_ALIAS(PKCS12_decrypt_skey);
int
PKCS12_pack_authsafes(PKCS12 *p12, STACK_OF(PKCS7) *safes)
return 1;
return 0;
}
-LCRYPTO_ALIAS(PKCS12_pack_authsafes)
+LCRYPTO_ALIAS(PKCS12_pack_authsafes);
STACK_OF(PKCS7) *
PKCS12_unpack_authsafes(const PKCS12 *p12)
return ASN1_item_unpack(p12->authsafes->d.data,
&PKCS12_AUTHSAFES_it);
}
-LCRYPTO_ALIAS(PKCS12_unpack_authsafes)
+LCRYPTO_ALIAS(PKCS12_unpack_authsafes);
-/* $OpenBSD: p12_asn.c,v 1.13 2022/11/12 13:03:28 beck Exp $ */
+/* $OpenBSD: p12_asn.c,v 1.14 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return (PKCS12 *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PKCS12_it);
}
-LCRYPTO_ALIAS(d2i_PKCS12)
+LCRYPTO_ALIAS(d2i_PKCS12);
int
i2d_PKCS12(PKCS12 *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_it);
}
-LCRYPTO_ALIAS(i2d_PKCS12)
+LCRYPTO_ALIAS(i2d_PKCS12);
PKCS12 *
PKCS12_new(void)
{
return (PKCS12 *)ASN1_item_new(&PKCS12_it);
}
-LCRYPTO_ALIAS(PKCS12_new)
+LCRYPTO_ALIAS(PKCS12_new);
void
PKCS12_free(PKCS12 *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PKCS12_it);
}
-LCRYPTO_ALIAS(PKCS12_free)
+LCRYPTO_ALIAS(PKCS12_free);
static const ASN1_TEMPLATE PKCS12_MAC_DATA_seq_tt[] = {
{
return (PKCS12_MAC_DATA *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PKCS12_MAC_DATA_it);
}
-LCRYPTO_ALIAS(d2i_PKCS12_MAC_DATA)
+LCRYPTO_ALIAS(d2i_PKCS12_MAC_DATA);
int
i2d_PKCS12_MAC_DATA(PKCS12_MAC_DATA *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_MAC_DATA_it);
}
-LCRYPTO_ALIAS(i2d_PKCS12_MAC_DATA)
+LCRYPTO_ALIAS(i2d_PKCS12_MAC_DATA);
PKCS12_MAC_DATA *
PKCS12_MAC_DATA_new(void)
{
return (PKCS12_MAC_DATA *)ASN1_item_new(&PKCS12_MAC_DATA_it);
}
-LCRYPTO_ALIAS(PKCS12_MAC_DATA_new)
+LCRYPTO_ALIAS(PKCS12_MAC_DATA_new);
void
PKCS12_MAC_DATA_free(PKCS12_MAC_DATA *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PKCS12_MAC_DATA_it);
}
-LCRYPTO_ALIAS(PKCS12_MAC_DATA_free)
+LCRYPTO_ALIAS(PKCS12_MAC_DATA_free);
static const ASN1_TEMPLATE bag_default_tt = {
.flags = ASN1_TFLG_EXPLICIT,
return (PKCS12_BAGS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PKCS12_BAGS_it);
}
-LCRYPTO_ALIAS(d2i_PKCS12_BAGS)
+LCRYPTO_ALIAS(d2i_PKCS12_BAGS);
int
i2d_PKCS12_BAGS(PKCS12_BAGS *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_BAGS_it);
}
-LCRYPTO_ALIAS(i2d_PKCS12_BAGS)
+LCRYPTO_ALIAS(i2d_PKCS12_BAGS);
PKCS12_BAGS *
PKCS12_BAGS_new(void)
{
return (PKCS12_BAGS *)ASN1_item_new(&PKCS12_BAGS_it);
}
-LCRYPTO_ALIAS(PKCS12_BAGS_new)
+LCRYPTO_ALIAS(PKCS12_BAGS_new);
void
PKCS12_BAGS_free(PKCS12_BAGS *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PKCS12_BAGS_it);
}
-LCRYPTO_ALIAS(PKCS12_BAGS_free)
+LCRYPTO_ALIAS(PKCS12_BAGS_free);
static const ASN1_TEMPLATE safebag_default_tt = {
.flags = ASN1_TFLG_EXPLICIT,
return (PKCS12_SAFEBAG *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PKCS12_SAFEBAG_it);
}
-LCRYPTO_ALIAS(d2i_PKCS12_SAFEBAG)
+LCRYPTO_ALIAS(d2i_PKCS12_SAFEBAG);
int
i2d_PKCS12_SAFEBAG(PKCS12_SAFEBAG *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_SAFEBAG_it);
}
-LCRYPTO_ALIAS(i2d_PKCS12_SAFEBAG)
+LCRYPTO_ALIAS(i2d_PKCS12_SAFEBAG);
PKCS12_SAFEBAG *
PKCS12_SAFEBAG_new(void)
{
return (PKCS12_SAFEBAG *)ASN1_item_new(&PKCS12_SAFEBAG_it);
}
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_new)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_new);
void
PKCS12_SAFEBAG_free(PKCS12_SAFEBAG *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PKCS12_SAFEBAG_it);
}
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_free)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_free);
/* SEQUENCE OF SafeBag */
static const ASN1_TEMPLATE PKCS12_SAFEBAGS_item_tt = {
-/* $OpenBSD: p12_attr.c,v 1.19 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p12_attr.c,v 1.20 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
else
return 0;
}
-LCRYPTO_ALIAS(PKCS12_add_localkeyid)
+LCRYPTO_ALIAS(PKCS12_add_localkeyid);
/* Add key usage to PKCS#8 structure */
return PKCS8_pkey_add1_attr_by_NID(p8, NID_key_usage, V_ASN1_BIT_STRING,
&us_val, 1);
}
-LCRYPTO_ALIAS(PKCS8_add_keyusage)
+LCRYPTO_ALIAS(PKCS8_add_keyusage);
/* Add a friendlyname to a safebag */
else
return 0;
}
-LCRYPTO_ALIAS(PKCS12_add_friendlyname_asc)
+LCRYPTO_ALIAS(PKCS12_add_friendlyname_asc);
int
else
return 0;
}
-LCRYPTO_ALIAS(PKCS12_add_friendlyname_uni)
+LCRYPTO_ALIAS(PKCS12_add_friendlyname_uni);
int
PKCS12_add_CSPName_asc(PKCS12_SAFEBAG *bag, const char *name, int namelen)
else
return 0;
}
-LCRYPTO_ALIAS(PKCS12_add_CSPName_asc)
+LCRYPTO_ALIAS(PKCS12_add_CSPName_asc);
ASN1_TYPE *
PKCS12_get_attr_gen(const STACK_OF(X509_ATTRIBUTE) *attrs, int attr_nid)
}
return NULL;
}
-LCRYPTO_ALIAS(PKCS12_get_attr_gen)
+LCRYPTO_ALIAS(PKCS12_get_attr_gen);
char *
PKCS12_get_friendlyname(PKCS12_SAFEBAG *bag)
return OPENSSL_uni2asc(atype->value.bmpstring->data,
atype->value.bmpstring->length);
}
-LCRYPTO_ALIAS(PKCS12_get_friendlyname)
+LCRYPTO_ALIAS(PKCS12_get_friendlyname);
const STACK_OF(X509_ATTRIBUTE) *
PKCS12_SAFEBAG_get0_attrs(const PKCS12_SAFEBAG *bag)
{
return bag->attrib;
}
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_attrs)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_attrs);
-/* $OpenBSD: p12_crpt.c,v 1.16 2022/11/12 13:03:28 beck Exp $ */
+/* $OpenBSD: p12_crpt.c,v 1.17 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
PKCS12_PBE_add(void)
{
}
-LCRYPTO_ALIAS(PKCS12_PBE_add)
+LCRYPTO_ALIAS(PKCS12_PBE_add);
int
PKCS12_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
explicit_bzero(iv, EVP_MAX_IV_LENGTH);
return ret;
}
-LCRYPTO_ALIAS(PKCS12_PBE_keyivgen)
+LCRYPTO_ALIAS(PKCS12_PBE_keyivgen);
-/* $OpenBSD: p12_crt.c,v 1.22 2023/01/24 09:48:57 job Exp $ */
+/* $OpenBSD: p12_crt.c,v 1.23 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project.
*/
sk_PKCS12_SAFEBAG_pop_free(bags, PKCS12_SAFEBAG_free);
return NULL;
}
-LCRYPTO_ALIAS(PKCS12_create)
+LCRYPTO_ALIAS(PKCS12_create);
PKCS12_SAFEBAG *
PKCS12_add_cert(STACK_OF(PKCS12_SAFEBAG) **pbags, X509 *cert)
return NULL;
}
-LCRYPTO_ALIAS(PKCS12_add_cert)
+LCRYPTO_ALIAS(PKCS12_add_cert);
PKCS12_SAFEBAG *
PKCS12_add_key(STACK_OF(PKCS12_SAFEBAG) **pbags, EVP_PKEY *key, int key_usage,
return NULL;
}
-LCRYPTO_ALIAS(PKCS12_add_key)
+LCRYPTO_ALIAS(PKCS12_add_key);
int
PKCS12_add_safe(STACK_OF(PKCS7) **psafes, STACK_OF(PKCS12_SAFEBAG) *bags,
return 0;
}
-LCRYPTO_ALIAS(PKCS12_add_safe)
+LCRYPTO_ALIAS(PKCS12_add_safe);
static int
pkcs12_add_bag(STACK_OF(PKCS12_SAFEBAG) **pbags, PKCS12_SAFEBAG *bag)
return p12;
}
-LCRYPTO_ALIAS(PKCS12_add_safes)
+LCRYPTO_ALIAS(PKCS12_add_safes);
-/* $OpenBSD: p12_decr.c,v 1.23 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p12_decr.c,v 1.24 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return out;
}
-LCRYPTO_ALIAS(PKCS12_pbe_crypt)
+LCRYPTO_ALIAS(PKCS12_pbe_crypt);
/* Decrypt an OCTET STRING and decode ASN1 structure
* if zbuf set zero buffer after use.
free(out);
return ret;
}
-LCRYPTO_ALIAS(PKCS12_item_decrypt_d2i)
+LCRYPTO_ALIAS(PKCS12_item_decrypt_d2i);
/* Encode ASN1 structure and encrypt, return OCTET STRING
* if zbuf set zero encoding.
ASN1_OCTET_STRING_free(oct);
return NULL;
}
-LCRYPTO_ALIAS(PKCS12_item_i2d_encrypt)
+LCRYPTO_ALIAS(PKCS12_item_i2d_encrypt);
IMPLEMENT_PKCS12_STACK_OF(PKCS7)
-/* $OpenBSD: p12_init.c,v 1.15 2022/11/12 13:03:28 beck Exp $ */
+/* $OpenBSD: p12_init.c,v 1.16 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
PKCS12_free(pkcs12);
return NULL;
}
-LCRYPTO_ALIAS(PKCS12_init)
+LCRYPTO_ALIAS(PKCS12_init);
-/* $OpenBSD: p12_key.c,v 1.33 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p12_key.c,v 1.34 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
freezero(unipass, uniplen);
return ret;
}
-LCRYPTO_ALIAS(PKCS12_key_gen_asc)
+LCRYPTO_ALIAS(PKCS12_key_gen_asc);
int
PKCS12_key_gen_uni(unsigned char *pass, int passlen, unsigned char *salt,
return ret;
}
-LCRYPTO_ALIAS(PKCS12_key_gen_uni)
+LCRYPTO_ALIAS(PKCS12_key_gen_uni);
-/* $OpenBSD: p12_kiss.c,v 1.26 2022/11/12 13:03:28 beck Exp $ */
+/* $OpenBSD: p12_kiss.c,v 1.27 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return 0;
}
-LCRYPTO_ALIAS(PKCS12_parse)
+LCRYPTO_ALIAS(PKCS12_parse);
/* Parse the outer PKCS#12 structure */
-/* $OpenBSD: p12_mutl.c,v 1.34 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p12_mutl.c,v 1.35 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
{
return p12->mac != NULL;
}
-LCRYPTO_ALIAS(PKCS12_mac_present)
+LCRYPTO_ALIAS(PKCS12_mac_present);
void
PKCS12_get0_mac(const ASN1_OCTET_STRING **pmac, const X509_ALGOR **pmacalg,
if (piter != NULL)
*piter = p12->mac->iter;
}
-LCRYPTO_ALIAS(PKCS12_get0_mac)
+LCRYPTO_ALIAS(PKCS12_get0_mac);
/* Generate a MAC */
int
return ret;
}
-LCRYPTO_ALIAS(PKCS12_gen_mac)
+LCRYPTO_ALIAS(PKCS12_gen_mac);
/* Verify the mac */
int
return 0;
return 1;
}
-LCRYPTO_ALIAS(PKCS12_verify_mac)
+LCRYPTO_ALIAS(PKCS12_verify_mac);
/* Set a mac */
}
return 1;
}
-LCRYPTO_ALIAS(PKCS12_set_mac)
+LCRYPTO_ALIAS(PKCS12_set_mac);
/* Set up a mac structure */
int
return 1;
}
-LCRYPTO_ALIAS(PKCS12_setup_mac)
+LCRYPTO_ALIAS(PKCS12_setup_mac);
#endif
-/* $OpenBSD: p12_npas.c,v 1.17 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p12_npas.c,v 1.18 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return 1;
}
-LCRYPTO_ALIAS(PKCS12_newpass)
+LCRYPTO_ALIAS(PKCS12_newpass);
/* Parse the outer PKCS#12 structure */
-/* $OpenBSD: p12_p8d.c,v 1.10 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p12_p8d.c,v 1.11 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2001.
*/
return PKCS12_item_decrypt_d2i(p8->algor,
&PKCS8_PRIV_KEY_INFO_it, pass, passlen, p8->digest, 1);
}
-LCRYPTO_ALIAS(PKCS8_decrypt)
+LCRYPTO_ALIAS(PKCS8_decrypt);
-/* $OpenBSD: p12_p8e.c,v 1.11 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p12_p8e.c,v 1.12 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2001.
*/
X509_SIG_free(p8);
return NULL;
}
-LCRYPTO_ALIAS(PKCS8_encrypt)
+LCRYPTO_ALIAS(PKCS8_encrypt);
-/* $OpenBSD: p12_sbag.c,v 1.7 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p12_sbag.c,v 1.8 2023/02/16 08:38:17 tb Exp $ */
/*
* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
* 1999-2018.
{
return PKCS12_get_attr_gen(bag->attrib, attr_nid);
}
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_attr)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_attr);
ASN1_TYPE *
PKCS8_get_attr(PKCS8_PRIV_KEY_INFO *p8, int attr_nid)
{
return PKCS12_get_attr_gen(p8->attributes, attr_nid);
}
-LCRYPTO_ALIAS(PKCS8_get_attr)
+LCRYPTO_ALIAS(PKCS8_get_attr);
const PKCS8_PRIV_KEY_INFO *
PKCS12_SAFEBAG_get0_p8inf(const PKCS12_SAFEBAG *bag)
return bag->value.keybag;
}
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_p8inf)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_p8inf);
const X509_SIG *
PKCS12_SAFEBAG_get0_pkcs8(const PKCS12_SAFEBAG *bag)
return bag->value.shkeybag;
}
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_pkcs8)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_pkcs8);
const STACK_OF(PKCS12_SAFEBAG) *
PKCS12_SAFEBAG_get0_safes(const PKCS12_SAFEBAG *bag)
return bag->value.safes;
}
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_safes)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_safes);
const ASN1_OBJECT *
PKCS12_SAFEBAG_get0_type(const PKCS12_SAFEBAG *bag)
{
return bag->type;
}
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_type)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_type);
int
PKCS12_SAFEBAG_get_nid(const PKCS12_SAFEBAG *bag)
{
return OBJ_obj2nid(bag->type);
}
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get_nid)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get_nid);
int
PKCS12_SAFEBAG_get_bag_nid(const PKCS12_SAFEBAG *bag)
return -1;
}
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get_bag_nid)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get_bag_nid);
X509 *
PKCS12_SAFEBAG_get1_cert(const PKCS12_SAFEBAG *bag)
return NULL;
return ASN1_item_unpack(bag->value.bag->value.octet, &X509_it);
}
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get1_cert)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get1_cert);
X509_CRL *
PKCS12_SAFEBAG_get1_crl(const PKCS12_SAFEBAG *bag)
return NULL;
return ASN1_item_unpack(bag->value.bag->value.octet, &X509_CRL_it);
}
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get1_crl)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get1_crl);
PKCS12_SAFEBAG *
PKCS12_SAFEBAG_create_cert(X509 *x509)
return PKCS12_item_pack_safebag(x509, &X509_it,
NID_x509Certificate, NID_certBag);
}
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_create_cert)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_create_cert);
PKCS12_SAFEBAG *
PKCS12_SAFEBAG_create_crl(X509_CRL *crl)
return PKCS12_item_pack_safebag(crl, &X509_CRL_it,
NID_x509Crl, NID_crlBag);
}
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_create_crl)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_create_crl);
/* Turn PKCS8 object into a keybag */
return bag;
}
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_create0_p8inf)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_create0_p8inf);
/* Turn PKCS8 object into a shrouded keybag */
return bag;
}
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_create0_pkcs8)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_create0_pkcs8);
PKCS12_SAFEBAG *
PKCS12_SAFEBAG_create_pkcs8_encrypt(int pbe_nid, const char *pass, int passlen,
return bag;
}
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_create_pkcs8_encrypt)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_create_pkcs8_encrypt);
-/* $OpenBSD: p12_utl.c,v 1.20 2022/11/12 13:03:28 beck Exp $ */
+/* $OpenBSD: p12_utl.c,v 1.21 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
*uni = unitmp;
return unitmp;
}
-LCRYPTO_ALIAS(OPENSSL_asc2uni)
+LCRYPTO_ALIAS(OPENSSL_asc2uni);
char *
OPENSSL_uni2asc(const unsigned char *uni, int unilen)
asctmp[asclen - 1] = '\0';
return asctmp;
}
-LCRYPTO_ALIAS(OPENSSL_uni2asc)
+LCRYPTO_ALIAS(OPENSSL_uni2asc);
int
i2d_PKCS12_bio(BIO *bp, PKCS12 *p12)
{
return ASN1_item_i2d_bio(&PKCS12_it, bp, p12);
}
-LCRYPTO_ALIAS(i2d_PKCS12_bio)
+LCRYPTO_ALIAS(i2d_PKCS12_bio);
int
i2d_PKCS12_fp(FILE *fp, PKCS12 *p12)
{
return ASN1_item_i2d_fp(&PKCS12_it, fp, p12);
}
-LCRYPTO_ALIAS(i2d_PKCS12_fp)
+LCRYPTO_ALIAS(i2d_PKCS12_fp);
PKCS12 *
d2i_PKCS12_bio(BIO *bp, PKCS12 **p12)
{
return ASN1_item_d2i_bio(&PKCS12_it, bp, p12);
}
-LCRYPTO_ALIAS(d2i_PKCS12_bio)
+LCRYPTO_ALIAS(d2i_PKCS12_bio);
PKCS12 *
d2i_PKCS12_fp(FILE *fp, PKCS12 **p12)
{
return ASN1_item_d2i_fp(&PKCS12_it, fp, p12);
}
-LCRYPTO_ALIAS(d2i_PKCS12_fp)
+LCRYPTO_ALIAS(d2i_PKCS12_fp);
-/* $OpenBSD: pk12err.c,v 1.13 2022/11/12 13:03:28 beck Exp $ */
+/* $OpenBSD: pk12err.c,v 1.14 2023/02/16 08:38:17 tb Exp $ */
/* ====================================================================
* Copyright (c) 1999-2006 The OpenSSL Project. All rights reserved.
*
}
#endif
}
-LCRYPTO_ALIAS(ERR_load_PKCS12_strings)
+LCRYPTO_ALIAS(ERR_load_PKCS12_strings);
-/* $OpenBSD: bio_pk7.c,v 1.6 2022/11/12 12:11:14 beck Exp $ */
+/* $OpenBSD: bio_pk7.c,v 1.7 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project.
*/
{
return BIO_new_NDEF(out, (ASN1_VALUE *)p7, &PKCS7_it);
}
-LCRYPTO_ALIAS(BIO_new_PKCS7)
+LCRYPTO_ALIAS(BIO_new_PKCS7);
-/* $OpenBSD: pk7_asn1.c,v 1.14 2022/11/12 12:11:14 beck Exp $ */
+/* $OpenBSD: pk7_asn1.c,v 1.15 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2000.
*/
return (PKCS7 *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PKCS7_it);
}
-LCRYPTO_ALIAS(d2i_PKCS7)
+LCRYPTO_ALIAS(d2i_PKCS7);
int
i2d_PKCS7(PKCS7 *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_it);
}
-LCRYPTO_ALIAS(i2d_PKCS7)
+LCRYPTO_ALIAS(i2d_PKCS7);
PKCS7 *
PKCS7_new(void)
{
return (PKCS7 *)ASN1_item_new(&PKCS7_it);
}
-LCRYPTO_ALIAS(PKCS7_new)
+LCRYPTO_ALIAS(PKCS7_new);
void
PKCS7_free(PKCS7 *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PKCS7_it);
}
-LCRYPTO_ALIAS(PKCS7_free)
+LCRYPTO_ALIAS(PKCS7_free);
int
i2d_PKCS7_NDEF(PKCS7 *a, unsigned char **out)
{
return ASN1_item_ndef_i2d((ASN1_VALUE *)a, out, &PKCS7_it);
}
-LCRYPTO_ALIAS(i2d_PKCS7_NDEF)
+LCRYPTO_ALIAS(i2d_PKCS7_NDEF);
PKCS7 *
PKCS7_dup(PKCS7 *x)
{
return ASN1_item_dup(&PKCS7_it, x);
}
-LCRYPTO_ALIAS(PKCS7_dup)
+LCRYPTO_ALIAS(PKCS7_dup);
static const ASN1_TEMPLATE PKCS7_SIGNED_seq_tt[] = {
{
return (PKCS7_SIGNED *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PKCS7_SIGNED_it);
}
-LCRYPTO_ALIAS(d2i_PKCS7_SIGNED)
+LCRYPTO_ALIAS(d2i_PKCS7_SIGNED);
int
i2d_PKCS7_SIGNED(PKCS7_SIGNED *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_SIGNED_it);
}
-LCRYPTO_ALIAS(i2d_PKCS7_SIGNED)
+LCRYPTO_ALIAS(i2d_PKCS7_SIGNED);
PKCS7_SIGNED *
PKCS7_SIGNED_new(void)
{
return (PKCS7_SIGNED *)ASN1_item_new(&PKCS7_SIGNED_it);
}
-LCRYPTO_ALIAS(PKCS7_SIGNED_new)
+LCRYPTO_ALIAS(PKCS7_SIGNED_new);
void
PKCS7_SIGNED_free(PKCS7_SIGNED *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PKCS7_SIGNED_it);
}
-LCRYPTO_ALIAS(PKCS7_SIGNED_free)
+LCRYPTO_ALIAS(PKCS7_SIGNED_free);
/* Minor tweak to operation: free up EVP_PKEY */
static int
return (PKCS7_SIGNER_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PKCS7_SIGNER_INFO_it);
}
-LCRYPTO_ALIAS(d2i_PKCS7_SIGNER_INFO)
+LCRYPTO_ALIAS(d2i_PKCS7_SIGNER_INFO);
int
i2d_PKCS7_SIGNER_INFO(PKCS7_SIGNER_INFO *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_SIGNER_INFO_it);
}
-LCRYPTO_ALIAS(i2d_PKCS7_SIGNER_INFO)
+LCRYPTO_ALIAS(i2d_PKCS7_SIGNER_INFO);
PKCS7_SIGNER_INFO *
PKCS7_SIGNER_INFO_new(void)
{
return (PKCS7_SIGNER_INFO *)ASN1_item_new(&PKCS7_SIGNER_INFO_it);
}
-LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_new)
+LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_new);
void
PKCS7_SIGNER_INFO_free(PKCS7_SIGNER_INFO *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PKCS7_SIGNER_INFO_it);
}
-LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_free)
+LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_free);
static const ASN1_TEMPLATE PKCS7_ISSUER_AND_SERIAL_seq_tt[] = {
{
return (PKCS7_ISSUER_AND_SERIAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PKCS7_ISSUER_AND_SERIAL_it);
}
-LCRYPTO_ALIAS(d2i_PKCS7_ISSUER_AND_SERIAL)
+LCRYPTO_ALIAS(d2i_PKCS7_ISSUER_AND_SERIAL);
int
i2d_PKCS7_ISSUER_AND_SERIAL(PKCS7_ISSUER_AND_SERIAL *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ISSUER_AND_SERIAL_it);
}
-LCRYPTO_ALIAS(i2d_PKCS7_ISSUER_AND_SERIAL)
+LCRYPTO_ALIAS(i2d_PKCS7_ISSUER_AND_SERIAL);
PKCS7_ISSUER_AND_SERIAL *
PKCS7_ISSUER_AND_SERIAL_new(void)
{
return (PKCS7_ISSUER_AND_SERIAL *)ASN1_item_new(&PKCS7_ISSUER_AND_SERIAL_it);
}
-LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_new)
+LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_new);
void
PKCS7_ISSUER_AND_SERIAL_free(PKCS7_ISSUER_AND_SERIAL *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ISSUER_AND_SERIAL_it);
}
-LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_free)
+LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_free);
static const ASN1_TEMPLATE PKCS7_ENVELOPE_seq_tt[] = {
{
return (PKCS7_ENVELOPE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PKCS7_ENVELOPE_it);
}
-LCRYPTO_ALIAS(d2i_PKCS7_ENVELOPE)
+LCRYPTO_ALIAS(d2i_PKCS7_ENVELOPE);
int
i2d_PKCS7_ENVELOPE(PKCS7_ENVELOPE *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ENVELOPE_it);
}
-LCRYPTO_ALIAS(i2d_PKCS7_ENVELOPE)
+LCRYPTO_ALIAS(i2d_PKCS7_ENVELOPE);
PKCS7_ENVELOPE *
PKCS7_ENVELOPE_new(void)
{
return (PKCS7_ENVELOPE *)ASN1_item_new(&PKCS7_ENVELOPE_it);
}
-LCRYPTO_ALIAS(PKCS7_ENVELOPE_new)
+LCRYPTO_ALIAS(PKCS7_ENVELOPE_new);
void
PKCS7_ENVELOPE_free(PKCS7_ENVELOPE *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ENVELOPE_it);
}
-LCRYPTO_ALIAS(PKCS7_ENVELOPE_free)
+LCRYPTO_ALIAS(PKCS7_ENVELOPE_free);
/* Minor tweak to operation: free up X509 */
static int
return (PKCS7_RECIP_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PKCS7_RECIP_INFO_it);
}
-LCRYPTO_ALIAS(d2i_PKCS7_RECIP_INFO)
+LCRYPTO_ALIAS(d2i_PKCS7_RECIP_INFO);
int
i2d_PKCS7_RECIP_INFO(PKCS7_RECIP_INFO *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_RECIP_INFO_it);
}
-LCRYPTO_ALIAS(i2d_PKCS7_RECIP_INFO)
+LCRYPTO_ALIAS(i2d_PKCS7_RECIP_INFO);
PKCS7_RECIP_INFO *
PKCS7_RECIP_INFO_new(void)
{
return (PKCS7_RECIP_INFO *)ASN1_item_new(&PKCS7_RECIP_INFO_it);
}
-LCRYPTO_ALIAS(PKCS7_RECIP_INFO_new)
+LCRYPTO_ALIAS(PKCS7_RECIP_INFO_new);
void
PKCS7_RECIP_INFO_free(PKCS7_RECIP_INFO *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PKCS7_RECIP_INFO_it);
}
-LCRYPTO_ALIAS(PKCS7_RECIP_INFO_free)
+LCRYPTO_ALIAS(PKCS7_RECIP_INFO_free);
static const ASN1_TEMPLATE PKCS7_ENC_CONTENT_seq_tt[] = {
{
return (PKCS7_ENC_CONTENT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PKCS7_ENC_CONTENT_it);
}
-LCRYPTO_ALIAS(d2i_PKCS7_ENC_CONTENT)
+LCRYPTO_ALIAS(d2i_PKCS7_ENC_CONTENT);
int
i2d_PKCS7_ENC_CONTENT(PKCS7_ENC_CONTENT *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ENC_CONTENT_it);
}
-LCRYPTO_ALIAS(i2d_PKCS7_ENC_CONTENT)
+LCRYPTO_ALIAS(i2d_PKCS7_ENC_CONTENT);
PKCS7_ENC_CONTENT *
PKCS7_ENC_CONTENT_new(void)
{
return (PKCS7_ENC_CONTENT *)ASN1_item_new(&PKCS7_ENC_CONTENT_it);
}
-LCRYPTO_ALIAS(PKCS7_ENC_CONTENT_new)
+LCRYPTO_ALIAS(PKCS7_ENC_CONTENT_new);
void
PKCS7_ENC_CONTENT_free(PKCS7_ENC_CONTENT *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ENC_CONTENT_it);
}
-LCRYPTO_ALIAS(PKCS7_ENC_CONTENT_free)
+LCRYPTO_ALIAS(PKCS7_ENC_CONTENT_free);
static const ASN1_TEMPLATE PKCS7_SIGN_ENVELOPE_seq_tt[] = {
{
return (PKCS7_SIGN_ENVELOPE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PKCS7_SIGN_ENVELOPE_it);
}
-LCRYPTO_ALIAS(d2i_PKCS7_SIGN_ENVELOPE)
+LCRYPTO_ALIAS(d2i_PKCS7_SIGN_ENVELOPE);
int
i2d_PKCS7_SIGN_ENVELOPE(PKCS7_SIGN_ENVELOPE *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_SIGN_ENVELOPE_it);
}
-LCRYPTO_ALIAS(i2d_PKCS7_SIGN_ENVELOPE)
+LCRYPTO_ALIAS(i2d_PKCS7_SIGN_ENVELOPE);
PKCS7_SIGN_ENVELOPE *
PKCS7_SIGN_ENVELOPE_new(void)
{
return (PKCS7_SIGN_ENVELOPE *)ASN1_item_new(&PKCS7_SIGN_ENVELOPE_it);
}
-LCRYPTO_ALIAS(PKCS7_SIGN_ENVELOPE_new)
+LCRYPTO_ALIAS(PKCS7_SIGN_ENVELOPE_new);
void
PKCS7_SIGN_ENVELOPE_free(PKCS7_SIGN_ENVELOPE *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PKCS7_SIGN_ENVELOPE_it);
}
-LCRYPTO_ALIAS(PKCS7_SIGN_ENVELOPE_free)
+LCRYPTO_ALIAS(PKCS7_SIGN_ENVELOPE_free);
static const ASN1_TEMPLATE PKCS7_ENCRYPT_seq_tt[] = {
{
return (PKCS7_ENCRYPT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PKCS7_ENCRYPT_it);
}
-LCRYPTO_ALIAS(d2i_PKCS7_ENCRYPT)
+LCRYPTO_ALIAS(d2i_PKCS7_ENCRYPT);
int
i2d_PKCS7_ENCRYPT(PKCS7_ENCRYPT *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ENCRYPT_it);
}
-LCRYPTO_ALIAS(i2d_PKCS7_ENCRYPT)
+LCRYPTO_ALIAS(i2d_PKCS7_ENCRYPT);
PKCS7_ENCRYPT *
PKCS7_ENCRYPT_new(void)
{
return (PKCS7_ENCRYPT *)ASN1_item_new(&PKCS7_ENCRYPT_it);
}
-LCRYPTO_ALIAS(PKCS7_ENCRYPT_new)
+LCRYPTO_ALIAS(PKCS7_ENCRYPT_new);
void
PKCS7_ENCRYPT_free(PKCS7_ENCRYPT *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ENCRYPT_it);
}
-LCRYPTO_ALIAS(PKCS7_ENCRYPT_free)
+LCRYPTO_ALIAS(PKCS7_ENCRYPT_free);
static const ASN1_TEMPLATE PKCS7_DIGEST_seq_tt[] = {
{
return (PKCS7_DIGEST *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PKCS7_DIGEST_it);
}
-LCRYPTO_ALIAS(d2i_PKCS7_DIGEST)
+LCRYPTO_ALIAS(d2i_PKCS7_DIGEST);
int
i2d_PKCS7_DIGEST(PKCS7_DIGEST *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_DIGEST_it);
}
-LCRYPTO_ALIAS(i2d_PKCS7_DIGEST)
+LCRYPTO_ALIAS(i2d_PKCS7_DIGEST);
PKCS7_DIGEST *
PKCS7_DIGEST_new(void)
{
return (PKCS7_DIGEST *)ASN1_item_new(&PKCS7_DIGEST_it);
}
-LCRYPTO_ALIAS(PKCS7_DIGEST_new)
+LCRYPTO_ALIAS(PKCS7_DIGEST_new);
void
PKCS7_DIGEST_free(PKCS7_DIGEST *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PKCS7_DIGEST_it);
}
-LCRYPTO_ALIAS(PKCS7_DIGEST_free)
+LCRYPTO_ALIAS(PKCS7_DIGEST_free);
/* Specials for authenticated attributes */
return ASN1_item_print(out, (ASN1_VALUE *)x, indent,
&PKCS7_it, pctx);
}
-LCRYPTO_ALIAS(PKCS7_print_ctx)
+LCRYPTO_ALIAS(PKCS7_print_ctx);
PKCS7 *
d2i_PKCS7_bio(BIO *bp, PKCS7 **p7)
{
return ASN1_item_d2i_bio(&PKCS7_it, bp, p7);
}
-LCRYPTO_ALIAS(d2i_PKCS7_bio)
+LCRYPTO_ALIAS(d2i_PKCS7_bio);
int
i2d_PKCS7_bio(BIO *bp, PKCS7 *p7)
{
return ASN1_item_i2d_bio(&PKCS7_it, bp, p7);
}
-LCRYPTO_ALIAS(i2d_PKCS7_bio)
+LCRYPTO_ALIAS(i2d_PKCS7_bio);
PKCS7 *
d2i_PKCS7_fp(FILE *fp, PKCS7 **p7)
{
return ASN1_item_d2i_fp(&PKCS7_it, fp, p7);
}
-LCRYPTO_ALIAS(d2i_PKCS7_fp)
+LCRYPTO_ALIAS(d2i_PKCS7_fp);
int
i2d_PKCS7_fp(FILE *fp, PKCS7 *p7)
{
return ASN1_item_i2d_fp(&PKCS7_it, fp, p7);
}
-LCRYPTO_ALIAS(i2d_PKCS7_fp)
+LCRYPTO_ALIAS(i2d_PKCS7_fp);
int
PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data,
return(ASN1_item_digest(&PKCS7_ISSUER_AND_SERIAL_it, type,
(char *)data, md, len));
}
-LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_digest)
+LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_digest);
-/* $OpenBSD: pk7_attr.c,v 1.13 2022/11/12 12:11:14 beck Exp $ */
+/* $OpenBSD: pk7_attr.c,v 1.14 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2001.
*/
return PKCS7_add_signed_attribute(si, NID_SMIMECapabilities,
V_ASN1_SEQUENCE, seq);
}
-LCRYPTO_ALIAS(PKCS7_add_attrib_smimecap)
+LCRYPTO_ALIAS(PKCS7_add_attrib_smimecap);
STACK_OF(X509_ALGOR) *
PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si)
ASN1_item_d2i(NULL, &p, cap->value.sequence->length,
&X509_ALGORS_it);
}
-LCRYPTO_ALIAS(PKCS7_get_smimecap)
+LCRYPTO_ALIAS(PKCS7_get_smimecap);
/* Basic smime-capabilities OID and optional integer arg */
int
X509_ALGOR_free(alg);
return 0;
}
-LCRYPTO_ALIAS(PKCS7_simple_smimecap)
+LCRYPTO_ALIAS(PKCS7_simple_smimecap);
int
PKCS7_add_attrib_content_type(PKCS7_SIGNER_INFO *si, ASN1_OBJECT *coid)
return PKCS7_add_signed_attribute(si, NID_pkcs9_contentType,
V_ASN1_OBJECT, coid);
}
-LCRYPTO_ALIAS(PKCS7_add_attrib_content_type)
+LCRYPTO_ALIAS(PKCS7_add_attrib_content_type);
int
PKCS7_add0_attrib_signing_time(PKCS7_SIGNER_INFO *si, ASN1_TIME *t)
return PKCS7_add_signed_attribute(si, NID_pkcs9_signingTime,
V_ASN1_UTCTIME, t);
}
-LCRYPTO_ALIAS(PKCS7_add0_attrib_signing_time)
+LCRYPTO_ALIAS(PKCS7_add0_attrib_signing_time);
int
PKCS7_add1_attrib_digest(PKCS7_SIGNER_INFO *si, const unsigned char *md,
}
return 1;
}
-LCRYPTO_ALIAS(PKCS7_add1_attrib_digest)
+LCRYPTO_ALIAS(PKCS7_add1_attrib_digest);
-/* $OpenBSD: pk7_doit.c,v 1.50 2022/12/26 07:18:52 jmc Exp $ */
+/* $OpenBSD: pk7_doit.c,v 1.51 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
}
return (out);
}
-LCRYPTO_ALIAS(PKCS7_dataInit)
+LCRYPTO_ALIAS(PKCS7_dataInit);
static int
pkcs7_cmp_ri(PKCS7_RECIP_INFO *ri, X509 *pcert)
}
return (out);
}
-LCRYPTO_ALIAS(PKCS7_dataDecode)
+LCRYPTO_ALIAS(PKCS7_dataDecode);
static BIO *
PKCS7_find_digest(EVP_MD_CTX **pmd, BIO *bio, int nid)
EVP_MD_CTX_cleanup(&ctx_tmp);
return (ret);
}
-LCRYPTO_ALIAS(PKCS7_dataFinal)
+LCRYPTO_ALIAS(PKCS7_dataFinal);
int
PKCS7_SIGNER_INFO_sign(PKCS7_SIGNER_INFO *si)
EVP_MD_CTX_cleanup(&mctx);
return 0;
}
-LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_sign)
+LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_sign);
int
PKCS7_dataVerify(X509_STORE *cert_store, X509_STORE_CTX *ctx, BIO *bio,
return ret;
}
-LCRYPTO_ALIAS(PKCS7_dataVerify)
+LCRYPTO_ALIAS(PKCS7_dataVerify);
int
PKCS7_signatureVerify(BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si, X509 *x509)
EVP_MD_CTX_cleanup(&mdc_tmp);
return (ret);
}
-LCRYPTO_ALIAS(PKCS7_signatureVerify)
+LCRYPTO_ALIAS(PKCS7_signatureVerify);
PKCS7_ISSUER_AND_SERIAL *
PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx)
ri = sk_PKCS7_RECIP_INFO_value(rsk, idx);
return (ri->issuer_and_serial);
}
-LCRYPTO_ALIAS(PKCS7_get_issuer_and_serial)
+LCRYPTO_ALIAS(PKCS7_get_issuer_and_serial);
ASN1_TYPE *
PKCS7_get_signed_attribute(PKCS7_SIGNER_INFO *si, int nid)
{
return (get_attribute(si->auth_attr, nid));
}
-LCRYPTO_ALIAS(PKCS7_get_signed_attribute)
+LCRYPTO_ALIAS(PKCS7_get_signed_attribute);
ASN1_TYPE *
PKCS7_get_attribute(PKCS7_SIGNER_INFO *si, int nid)
{
return (get_attribute(si->unauth_attr, nid));
}
-LCRYPTO_ALIAS(PKCS7_get_attribute)
+LCRYPTO_ALIAS(PKCS7_get_attribute);
static ASN1_TYPE *
get_attribute(STACK_OF(X509_ATTRIBUTE) *sk, int nid)
return NULL;
return astype->value.octet_string;
}
-LCRYPTO_ALIAS(PKCS7_digest_from_attributes)
+LCRYPTO_ALIAS(PKCS7_digest_from_attributes);
int
PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si,
}
return (1);
}
-LCRYPTO_ALIAS(PKCS7_set_signed_attributes)
+LCRYPTO_ALIAS(PKCS7_set_signed_attributes);
int
PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si, STACK_OF(X509_ATTRIBUTE) *sk)
}
return (1);
}
-LCRYPTO_ALIAS(PKCS7_set_attributes)
+LCRYPTO_ALIAS(PKCS7_set_attributes);
int
PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype,
{
return (add_attribute(&(p7si->auth_attr), nid, atrtype, value));
}
-LCRYPTO_ALIAS(PKCS7_add_signed_attribute)
+LCRYPTO_ALIAS(PKCS7_add_signed_attribute);
int
PKCS7_add_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype, void *value)
{
return (add_attribute(&(p7si->unauth_attr), nid, atrtype, value));
}
-LCRYPTO_ALIAS(PKCS7_add_attribute)
+LCRYPTO_ALIAS(PKCS7_add_attribute);
static int
add_attribute(STACK_OF(X509_ATTRIBUTE) **sk, int nid, int atrtype, void *value)
-/* $OpenBSD: pk7_lib.c,v 1.25 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: pk7_lib.c,v 1.26 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
}
return (ret);
}
-LCRYPTO_ALIAS(PKCS7_ctrl)
+LCRYPTO_ALIAS(PKCS7_ctrl);
int
PKCS7_content_new(PKCS7 *p7, int type)
PKCS7_free(ret);
return (0);
}
-LCRYPTO_ALIAS(PKCS7_content_new)
+LCRYPTO_ALIAS(PKCS7_content_new);
int
PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data)
err:
return (0);
}
-LCRYPTO_ALIAS(PKCS7_set_content)
+LCRYPTO_ALIAS(PKCS7_set_content);
int
PKCS7_set_type(PKCS7 *p7, int type)
err:
return (0);
}
-LCRYPTO_ALIAS(PKCS7_set_type)
+LCRYPTO_ALIAS(PKCS7_set_type);
int
PKCS7_set0_type_other(PKCS7 *p7, int type, ASN1_TYPE *other)
p7->d.other = other;
return 1;
}
-LCRYPTO_ALIAS(PKCS7_set0_type_other)
+LCRYPTO_ALIAS(PKCS7_set0_type_other);
int
PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *psi)
return 0;
return (1);
}
-LCRYPTO_ALIAS(PKCS7_add_signer)
+LCRYPTO_ALIAS(PKCS7_add_signer);
int
PKCS7_add_certificate(PKCS7 *p7, X509 *x509)
}
return (1);
}
-LCRYPTO_ALIAS(PKCS7_add_certificate)
+LCRYPTO_ALIAS(PKCS7_add_certificate);
int
PKCS7_add_crl(PKCS7 *p7, X509_CRL *crl)
}
return (1);
}
-LCRYPTO_ALIAS(PKCS7_add_crl)
+LCRYPTO_ALIAS(PKCS7_add_crl);
int
PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey,
err:
return 0;
}
-LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_set)
+LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_set);
PKCS7_SIGNER_INFO *
PKCS7_add_signature(PKCS7 *p7, X509 *x509, EVP_PKEY *pkey, const EVP_MD *dgst)
PKCS7_SIGNER_INFO_free(si);
return (NULL);
}
-LCRYPTO_ALIAS(PKCS7_add_signature)
+LCRYPTO_ALIAS(PKCS7_add_signature);
int
PKCS7_set_digest(PKCS7 *p7, const EVP_MD *md)
PKCS7error(PKCS7_R_WRONG_CONTENT_TYPE);
return 1;
}
-LCRYPTO_ALIAS(PKCS7_set_digest)
+LCRYPTO_ALIAS(PKCS7_set_digest);
STACK_OF(PKCS7_SIGNER_INFO) *
PKCS7_get_signer_info(PKCS7 *p7)
} else
return (NULL);
}
-LCRYPTO_ALIAS(PKCS7_get_signer_info)
+LCRYPTO_ALIAS(PKCS7_get_signer_info);
void
PKCS7_SIGNER_INFO_get0_algs(PKCS7_SIGNER_INFO *si, EVP_PKEY **pk,
if (psig)
*psig = si->digest_enc_alg;
}
-LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_get0_algs)
+LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_get0_algs);
void
PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO *ri, X509_ALGOR **penc)
if (penc)
*penc = ri->key_enc_algor;
}
-LCRYPTO_ALIAS(PKCS7_RECIP_INFO_get0_alg)
+LCRYPTO_ALIAS(PKCS7_RECIP_INFO_get0_alg);
PKCS7_RECIP_INFO *
PKCS7_add_recipient(PKCS7 *p7, X509 *x509)
PKCS7_RECIP_INFO_free(ri);
return NULL;
}
-LCRYPTO_ALIAS(PKCS7_add_recipient)
+LCRYPTO_ALIAS(PKCS7_add_recipient);
int
PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri)
return 0;
return (1);
}
-LCRYPTO_ALIAS(PKCS7_add_recipient_info)
+LCRYPTO_ALIAS(PKCS7_add_recipient_info);
int
PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509)
EVP_PKEY_free(pkey);
return 0;
}
-LCRYPTO_ALIAS(PKCS7_RECIP_INFO_set)
+LCRYPTO_ALIAS(PKCS7_RECIP_INFO_set);
X509 *
PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si)
else
return (NULL);
}
-LCRYPTO_ALIAS(PKCS7_cert_from_signer_info)
+LCRYPTO_ALIAS(PKCS7_cert_from_signer_info);
int
PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher)
ec->cipher = cipher;
return 1;
}
-LCRYPTO_ALIAS(PKCS7_set_cipher)
+LCRYPTO_ALIAS(PKCS7_set_cipher);
int
PKCS7_stream(unsigned char ***boundary, PKCS7 *p7)
return 1;
}
-LCRYPTO_ALIAS(PKCS7_stream)
+LCRYPTO_ALIAS(PKCS7_stream);
-/* $OpenBSD: pk7_mime.c,v 1.14 2022/11/12 12:11:14 beck Exp $ */
+/* $OpenBSD: pk7_mime.c,v 1.15 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project.
*/
return i2d_ASN1_bio_stream(out, (ASN1_VALUE *)p7, in, flags,
&PKCS7_it);
}
-LCRYPTO_ALIAS(i2d_PKCS7_bio_stream)
+LCRYPTO_ALIAS(i2d_PKCS7_bio_stream);
int
PEM_write_bio_PKCS7_stream(BIO *out, PKCS7 *p7, BIO *in, int flags)
return PEM_write_bio_ASN1_stream(out, (ASN1_VALUE *) p7, in, flags,
"PKCS7", &PKCS7_it);
}
-LCRYPTO_ALIAS(PEM_write_bio_PKCS7_stream)
+LCRYPTO_ALIAS(PEM_write_bio_PKCS7_stream);
int
SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags)
return SMIME_write_ASN1(bio, (ASN1_VALUE *)p7, data, flags,
ctype_nid, NID_undef, mdalgs, &PKCS7_it);
}
-LCRYPTO_ALIAS(SMIME_write_PKCS7)
+LCRYPTO_ALIAS(SMIME_write_PKCS7);
PKCS7 *
SMIME_read_PKCS7(BIO *bio, BIO **bcont)
{
return (PKCS7 *)SMIME_read_ASN1(bio, bcont, &PKCS7_it);
}
-LCRYPTO_ALIAS(SMIME_read_PKCS7)
+LCRYPTO_ALIAS(SMIME_read_PKCS7);
-/* $OpenBSD: pk7_smime.c,v 1.25 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: pk7_smime.c,v 1.26 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project.
*/
PKCS7_free(p7);
return NULL;
}
-LCRYPTO_ALIAS(PKCS7_sign)
+LCRYPTO_ALIAS(PKCS7_sign);
int
PKCS7_final(PKCS7 *p7, BIO *data, int flags)
return ret;
}
-LCRYPTO_ALIAS(PKCS7_final)
+LCRYPTO_ALIAS(PKCS7_final);
/* Check to see if a cipher exists and if so add S/MIME capabilities */
sk_X509_ALGOR_pop_free(smcap, X509_ALGOR_free);
return NULL;
}
-LCRYPTO_ALIAS(PKCS7_sign_add_signer)
+LCRYPTO_ALIAS(PKCS7_sign_add_signer);
/* Search for a digest matching SignerInfo digest type and if found
* copy across.
return ret;
}
-LCRYPTO_ALIAS(PKCS7_verify)
+LCRYPTO_ALIAS(PKCS7_verify);
STACK_OF(X509) *
PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs, int flags)
}
return signers;
}
-LCRYPTO_ALIAS(PKCS7_get0_signers)
+LCRYPTO_ALIAS(PKCS7_get0_signers);
/* Build a complete PKCS#7 enveloped data */
PKCS7_free(p7);
return NULL;
}
-LCRYPTO_ALIAS(PKCS7_encrypt)
+LCRYPTO_ALIAS(PKCS7_encrypt);
int
PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, int flags)
return ret;
}
}
-LCRYPTO_ALIAS(PKCS7_decrypt)
+LCRYPTO_ALIAS(PKCS7_decrypt);
-/* $OpenBSD: pkcs7err.c,v 1.14 2022/11/12 12:11:14 beck Exp $ */
+/* $OpenBSD: pkcs7err.c,v 1.15 2023/02/16 08:38:17 tb Exp $ */
/* ====================================================================
* Copyright (c) 1999-2007 The OpenSSL Project. All rights reserved.
*
}
#endif
}
-LCRYPTO_ALIAS(ERR_load_PKCS7_strings)
+LCRYPTO_ALIAS(ERR_load_PKCS7_strings);
-/* $OpenBSD: stack.c,v 1.21 2022/11/11 19:18:55 beck Exp $ */
+/* $OpenBSD: stack.c,v 1.22 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return old;
}
-LCRYPTO_ALIAS(sk_set_cmp_func)
+LCRYPTO_ALIAS(sk_set_cmp_func);
_STACK *
sk_dup(_STACK *sk)
sk_free(ret);
return (NULL);
}
-LCRYPTO_ALIAS(sk_dup)
+LCRYPTO_ALIAS(sk_dup);
_STACK *
sk_new_null(void)
{
return sk_new((int (*)(const void *, const void *))0);
}
-LCRYPTO_ALIAS(sk_new_null)
+LCRYPTO_ALIAS(sk_new_null);
_STACK *
sk_new(int (*c)(const void *, const void *))
free(ret);
return (NULL);
}
-LCRYPTO_ALIAS(sk_new)
+LCRYPTO_ALIAS(sk_new);
int
sk_insert(_STACK *st, void *data, int loc)
st->sorted = 0;
return (st->num);
}
-LCRYPTO_ALIAS(sk_insert)
+LCRYPTO_ALIAS(sk_insert);
void *
sk_delete_ptr(_STACK *st, void *p)
return (sk_delete(st, i));
return (NULL);
}
-LCRYPTO_ALIAS(sk_delete_ptr)
+LCRYPTO_ALIAS(sk_delete_ptr);
void *
sk_delete(_STACK *st, int loc)
st->num--;
return (ret);
}
-LCRYPTO_ALIAS(sk_delete)
+LCRYPTO_ALIAS(sk_delete);
static int
internal_find(_STACK *st, void *data, int ret_val_options)
{
return internal_find(st, data, OBJ_BSEARCH_FIRST_VALUE_ON_MATCH);
}
-LCRYPTO_ALIAS(sk_find)
+LCRYPTO_ALIAS(sk_find);
int
sk_find_ex(_STACK *st, void *data)
{
return internal_find(st, data, OBJ_BSEARCH_VALUE_ON_NOMATCH);
}
-LCRYPTO_ALIAS(sk_find_ex)
+LCRYPTO_ALIAS(sk_find_ex);
int
sk_push(_STACK *st, void *data)
{
return (sk_insert(st, data, st->num));
}
-LCRYPTO_ALIAS(sk_push)
+LCRYPTO_ALIAS(sk_push);
int
sk_unshift(_STACK *st, void *data)
{
return (sk_insert(st, data, 0));
}
-LCRYPTO_ALIAS(sk_unshift)
+LCRYPTO_ALIAS(sk_unshift);
void *
sk_shift(_STACK *st)
return (NULL);
return (sk_delete(st, 0));
}
-LCRYPTO_ALIAS(sk_shift)
+LCRYPTO_ALIAS(sk_shift);
void *
sk_pop(_STACK *st)
return (NULL);
return (sk_delete(st, st->num - 1));
}
-LCRYPTO_ALIAS(sk_pop)
+LCRYPTO_ALIAS(sk_pop);
void
sk_zero(_STACK *st)
memset(st->data, 0, sizeof(st->data)*st->num);
st->num = 0;
}
-LCRYPTO_ALIAS(sk_zero)
+LCRYPTO_ALIAS(sk_zero);
void
sk_pop_free(_STACK *st, void (*func)(void *))
func(st->data[i]);
sk_free(st);
}
-LCRYPTO_ALIAS(sk_pop_free)
+LCRYPTO_ALIAS(sk_pop_free);
void
sk_free(_STACK *st)
free(st->data);
free(st);
}
-LCRYPTO_ALIAS(sk_free)
+LCRYPTO_ALIAS(sk_free);
int
sk_num(const _STACK *st)
return -1;
return st->num;
}
-LCRYPTO_ALIAS(sk_num)
+LCRYPTO_ALIAS(sk_num);
void *
sk_value(const _STACK *st, int i)
return NULL;
return st->data[i];
}
-LCRYPTO_ALIAS(sk_value)
+LCRYPTO_ALIAS(sk_value);
void *
sk_set(_STACK *st, int i, void *value)
st->sorted = 0;
return (st->data[i] = value);
}
-LCRYPTO_ALIAS(sk_set)
+LCRYPTO_ALIAS(sk_set);
void
sk_sort(_STACK *st)
st->sorted = 1;
}
}
-LCRYPTO_ALIAS(sk_sort)
+LCRYPTO_ALIAS(sk_sort);
int
sk_is_sorted(const _STACK *st)
return 1;
return st->sorted;
}
-LCRYPTO_ALIAS(sk_is_sorted)
+LCRYPTO_ALIAS(sk_is_sorted);
-/* $OpenBSD: ui_err.c,v 1.11 2022/11/12 13:16:10 beck Exp $ */
+/* $OpenBSD: ui_err.c,v 1.12 2023/02/16 08:38:17 tb Exp $ */
/* ====================================================================
* Copyright (c) 1999-2006 The OpenSSL Project. All rights reserved.
*
}
#endif
}
-LCRYPTO_ALIAS(ERR_load_UI_strings)
+LCRYPTO_ALIAS(ERR_load_UI_strings);
-/* $OpenBSD: ui_lib.c,v 1.50 2022/12/23 02:31:56 jsing Exp $ */
+/* $OpenBSD: ui_lib.c,v 1.51 2023/02/16 08:38:17 tb Exp $ */
/* Written by Richard Levitte (richard@levitte.org) for the OpenSSL
* project 2001.
*/
{
return (UI_new_method(NULL));
}
-LCRYPTO_ALIAS(UI_new)
+LCRYPTO_ALIAS(UI_new);
UI *
UI_new_method(const UI_METHOD *method)
return ret;
}
-LCRYPTO_ALIAS(UI_new_method)
+LCRYPTO_ALIAS(UI_new_method);
static void
free_string(UI_STRING *uis)
CRYPTO_free_ex_data(CRYPTO_EX_INDEX_UI, ui, &ui->ex_data);
free(ui);
}
-LCRYPTO_ALIAS(UI_free)
+LCRYPTO_ALIAS(UI_free);
static int
allocate_string_stack(UI *ui)
return general_allocate_string(ui, prompt, 0, UIT_PROMPT, flags,
result_buf, minsize, maxsize, NULL);
}
-LCRYPTO_ALIAS(UI_add_input_string)
+LCRYPTO_ALIAS(UI_add_input_string);
/* Same as UI_add_input_string(), excepts it takes a copy of the prompt. */
int
return general_allocate_string(ui, prompt, 1, UIT_PROMPT, flags,
result_buf, minsize, maxsize, NULL);
}
-LCRYPTO_ALIAS(UI_dup_input_string)
+LCRYPTO_ALIAS(UI_dup_input_string);
int
UI_add_verify_string(UI *ui, const char *prompt, int flags, char *result_buf,
return general_allocate_string(ui, prompt, 0, UIT_VERIFY, flags,
result_buf, minsize, maxsize, test_buf);
}
-LCRYPTO_ALIAS(UI_add_verify_string)
+LCRYPTO_ALIAS(UI_add_verify_string);
int
UI_dup_verify_string(UI *ui, const char *prompt, int flags,
return general_allocate_string(ui, prompt, 1, UIT_VERIFY, flags,
result_buf, minsize, maxsize, test_buf);
}
-LCRYPTO_ALIAS(UI_dup_verify_string)
+LCRYPTO_ALIAS(UI_dup_verify_string);
int
UI_add_input_boolean(UI *ui, const char *prompt, const char *action_desc,
return general_allocate_boolean(ui, prompt, action_desc, ok_chars,
cancel_chars, 0, UIT_BOOLEAN, flags, result_buf);
}
-LCRYPTO_ALIAS(UI_add_input_boolean)
+LCRYPTO_ALIAS(UI_add_input_boolean);
int
UI_dup_input_boolean(UI *ui, const char *prompt, const char *action_desc,
return general_allocate_boolean(ui, prompt, action_desc, ok_chars,
cancel_chars, 1, UIT_BOOLEAN, flags, result_buf);
}
-LCRYPTO_ALIAS(UI_dup_input_boolean)
+LCRYPTO_ALIAS(UI_dup_input_boolean);
int
UI_add_info_string(UI *ui, const char *text)
return general_allocate_string(ui, text, 0, UIT_INFO, 0, NULL, 0, 0,
NULL);
}
-LCRYPTO_ALIAS(UI_add_info_string)
+LCRYPTO_ALIAS(UI_add_info_string);
int
UI_dup_info_string(UI *ui, const char *text)
return general_allocate_string(ui, text, 1, UIT_INFO, 0, NULL, 0, 0,
NULL);
}
-LCRYPTO_ALIAS(UI_dup_info_string)
+LCRYPTO_ALIAS(UI_dup_info_string);
int
UI_add_error_string(UI *ui, const char *text)
return general_allocate_string(ui, text, 0, UIT_ERROR, 0, NULL, 0, 0,
NULL);
}
-LCRYPTO_ALIAS(UI_add_error_string)
+LCRYPTO_ALIAS(UI_add_error_string);
int
UI_dup_error_string(UI *ui, const char *text)
return general_allocate_string(ui, text, 1, UIT_ERROR, 0, NULL, 0, 0,
NULL);
}
-LCRYPTO_ALIAS(UI_dup_error_string)
+LCRYPTO_ALIAS(UI_dup_error_string);
char *
UI_construct_prompt(UI *ui, const char *object_desc, const char *object_name)
return prompt;
}
-LCRYPTO_ALIAS(UI_construct_prompt)
+LCRYPTO_ALIAS(UI_construct_prompt);
void *
UI_add_user_data(UI *ui, void *user_data)
return old_data;
}
-LCRYPTO_ALIAS(UI_add_user_data)
+LCRYPTO_ALIAS(UI_add_user_data);
void *
UI_get0_user_data(UI *ui)
{
return ui->user_data;
}
-LCRYPTO_ALIAS(UI_get0_user_data)
+LCRYPTO_ALIAS(UI_get0_user_data);
const char *
UI_get0_result(UI *ui, int i)
}
return UI_get0_result_string(sk_UI_STRING_value(ui->strings, i));
}
-LCRYPTO_ALIAS(UI_get0_result)
+LCRYPTO_ALIAS(UI_get0_result);
static int
print_error(const char *str, size_t len, void *arg)
return -1;
return ok;
}
-LCRYPTO_ALIAS(UI_process)
+LCRYPTO_ALIAS(UI_process);
int
UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f) (void))
UIerror(UI_R_UNKNOWN_CONTROL_COMMAND);
return -1;
}
-LCRYPTO_ALIAS(UI_ctrl)
+LCRYPTO_ALIAS(UI_ctrl);
int
UI_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_UI, argl, argp,
new_func, dup_func, free_func);
}
-LCRYPTO_ALIAS(UI_get_ex_new_index)
+LCRYPTO_ALIAS(UI_get_ex_new_index);
int
UI_set_ex_data(UI *r, int idx, void *arg)
{
return (CRYPTO_set_ex_data(&r->ex_data, idx, arg));
}
-LCRYPTO_ALIAS(UI_set_ex_data)
+LCRYPTO_ALIAS(UI_set_ex_data);
void *
UI_get_ex_data(UI *r, int idx)
{
return (CRYPTO_get_ex_data(&r->ex_data, idx));
}
-LCRYPTO_ALIAS(UI_get_ex_data)
+LCRYPTO_ALIAS(UI_get_ex_data);
void
UI_set_default_method(const UI_METHOD *method)
{
default_UI_meth = method;
}
-LCRYPTO_ALIAS(UI_set_default_method)
+LCRYPTO_ALIAS(UI_set_default_method);
const UI_METHOD *
UI_get_default_method(void)
return default_UI_meth;
}
-LCRYPTO_ALIAS(UI_get_default_method)
+LCRYPTO_ALIAS(UI_get_default_method);
const UI_METHOD *
UI_get_method(UI *ui)
{
return ui->meth;
}
-LCRYPTO_ALIAS(UI_get_method)
+LCRYPTO_ALIAS(UI_get_method);
const UI_METHOD *
UI_set_method(UI *ui, const UI_METHOD *method)
return ui->meth;
}
-LCRYPTO_ALIAS(UI_set_method)
+LCRYPTO_ALIAS(UI_set_method);
UI_METHOD *
UI_create_method(const char *name)
return NULL;
}
-LCRYPTO_ALIAS(UI_create_method)
+LCRYPTO_ALIAS(UI_create_method);
void
UI_destroy_method(UI_METHOD *method)
free(method->name);
free(method);
}
-LCRYPTO_ALIAS(UI_destroy_method)
+LCRYPTO_ALIAS(UI_destroy_method);
int
UI_method_set_opener(UI_METHOD *method, int (*opener)(UI *ui))
return 0;
}
-LCRYPTO_ALIAS(UI_method_set_opener)
+LCRYPTO_ALIAS(UI_method_set_opener);
int
UI_method_set_writer(UI_METHOD *method, int (*writer)(UI *ui, UI_STRING *uis))
return 0;
}
-LCRYPTO_ALIAS(UI_method_set_writer)
+LCRYPTO_ALIAS(UI_method_set_writer);
int
UI_method_set_flusher(UI_METHOD *method, int (*flusher)(UI *ui))
return 0;
}
-LCRYPTO_ALIAS(UI_method_set_flusher)
+LCRYPTO_ALIAS(UI_method_set_flusher);
int
UI_method_set_reader(UI_METHOD *method, int (*reader)(UI *ui, UI_STRING *uis))
return 0;
}
-LCRYPTO_ALIAS(UI_method_set_reader)
+LCRYPTO_ALIAS(UI_method_set_reader);
int
UI_method_set_closer(UI_METHOD *method, int (*closer)(UI *ui))
return 0;
}
-LCRYPTO_ALIAS(UI_method_set_closer)
+LCRYPTO_ALIAS(UI_method_set_closer);
int
UI_method_set_prompt_constructor(UI_METHOD *method,
return 0;
}
-LCRYPTO_ALIAS(UI_method_set_prompt_constructor)
+LCRYPTO_ALIAS(UI_method_set_prompt_constructor);
int
(*UI_method_get_opener(const UI_METHOD * method))(UI *)
return method->ui_open_session;
}
-LCRYPTO_ALIAS(UI_method_get_opener)
+LCRYPTO_ALIAS(UI_method_get_opener);
int
(*UI_method_get_writer(const UI_METHOD *method))(UI *, UI_STRING *)
return method->ui_write_string;
}
-LCRYPTO_ALIAS(UI_method_get_writer)
+LCRYPTO_ALIAS(UI_method_get_writer);
int
(*UI_method_get_flusher(const UI_METHOD *method)) (UI *)
return method->ui_flush;
}
-LCRYPTO_ALIAS(UI_method_get_flusher)
+LCRYPTO_ALIAS(UI_method_get_flusher);
int
(*UI_method_get_reader(const UI_METHOD *method))(UI *, UI_STRING *)
return method->ui_read_string;
}
-LCRYPTO_ALIAS(UI_method_get_reader)
+LCRYPTO_ALIAS(UI_method_get_reader);
int
(*UI_method_get_closer(const UI_METHOD *method))(UI *)
return method->ui_close_session;
}
-LCRYPTO_ALIAS(UI_method_get_closer)
+LCRYPTO_ALIAS(UI_method_get_closer);
char *
(*UI_method_get_prompt_constructor(const UI_METHOD *method))(UI *, const char *,
return method->ui_construct_prompt;
}
-LCRYPTO_ALIAS(UI_method_get_prompt_constructor)
+LCRYPTO_ALIAS(UI_method_get_prompt_constructor);
enum UI_string_types
UI_get_string_type(UI_STRING *uis)
return uis->type;
}
-LCRYPTO_ALIAS(UI_get_string_type)
+LCRYPTO_ALIAS(UI_get_string_type);
int
UI_get_input_flags(UI_STRING *uis)
return uis->input_flags;
}
-LCRYPTO_ALIAS(UI_get_input_flags)
+LCRYPTO_ALIAS(UI_get_input_flags);
const char *
UI_get0_output_string(UI_STRING *uis)
return uis->out_string;
}
-LCRYPTO_ALIAS(UI_get0_output_string)
+LCRYPTO_ALIAS(UI_get0_output_string);
const char *
UI_get0_action_string(UI_STRING *uis)
return NULL;
}
}
-LCRYPTO_ALIAS(UI_get0_action_string)
+LCRYPTO_ALIAS(UI_get0_action_string);
const char *
UI_get0_result_string(UI_STRING *uis)
return NULL;
}
}
-LCRYPTO_ALIAS(UI_get0_result_string)
+LCRYPTO_ALIAS(UI_get0_result_string);
const char *
UI_get0_test_string(UI_STRING *uis)
return NULL;
}
}
-LCRYPTO_ALIAS(UI_get0_test_string)
+LCRYPTO_ALIAS(UI_get0_test_string);
int
UI_get_result_minsize(UI_STRING *uis)
return -1;
}
}
-LCRYPTO_ALIAS(UI_get_result_minsize)
+LCRYPTO_ALIAS(UI_get_result_minsize);
int
UI_get_result_maxsize(UI_STRING *uis)
return -1;
}
}
-LCRYPTO_ALIAS(UI_get_result_maxsize)
+LCRYPTO_ALIAS(UI_get_result_maxsize);
int
UI_set_result(UI *ui, UI_STRING *uis, const char *result)
}
return 0;
}
-LCRYPTO_ALIAS(UI_set_result)
+LCRYPTO_ALIAS(UI_set_result);
-/* $OpenBSD: ui_null.c,v 1.1 2022/12/17 21:59:39 tb Exp $ */
+/* $OpenBSD: ui_null.c,v 1.2 2023/02/16 08:38:17 tb Exp $ */
/*
* Written by Theo Buehler. Public domain.
{
return &ui_null;
}
-LCRYPTO_ALIAS(UI_null)
+LCRYPTO_ALIAS(UI_null);
-/* $OpenBSD: ui_openssl.c,v 1.27 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: ui_openssl.c,v 1.28 2023/02/16 08:38:17 tb Exp $ */
/* Written by Richard Levitte (richard@levitte.org) and others
* for the OpenSSL project 2001.
*/
{
return &ui_openssl;
}
-LCRYPTO_ALIAS(UI_OpenSSL)
+LCRYPTO_ALIAS(UI_OpenSSL);
/* The following function makes sure that info and error strings are printed
before any prompt. */
-/* $OpenBSD: ui_util.c,v 1.13 2022/12/23 02:20:28 jsing Exp $ */
+/* $OpenBSD: ui_util.c,v 1.14 2023/02/16 08:38:17 tb Exp $ */
/* ====================================================================
* Copyright (c) 2001-2002 The OpenSSL Project. All rights reserved.
*
explicit_bzero(buff, BUFSIZ);
return (ret);
}
-LCRYPTO_ALIAS(UI_UTIL_read_pw_string)
+LCRYPTO_ALIAS(UI_UTIL_read_pw_string);
int
UI_UTIL_read_pw(char *buf, char *buff, int size, const char *prompt, int verify)
ok = 0;
return (ok);
}
-LCRYPTO_ALIAS(UI_UTIL_read_pw)
+LCRYPTO_ALIAS(UI_UTIL_read_pw);
-/* $OpenBSD: by_dir.c,v 1.43 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: by_dir.c,v 1.44 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
{
return &x509_dir_lookup;
}
-LCRYPTO_ALIAS(X509_LOOKUP_hash_dir)
+LCRYPTO_ALIAS(X509_LOOKUP_hash_dir);
static int
dir_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp, long argl,
-/* $OpenBSD: by_file.c,v 1.27 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: by_file.c,v 1.28 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
{
return &x509_file_lookup;
}
-LCRYPTO_ALIAS(X509_LOOKUP_file)
+LCRYPTO_ALIAS(X509_LOOKUP_file);
static int
by_file_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp, long argl,
BIO_free(in);
return ret;
}
-LCRYPTO_ALIAS(X509_load_cert_file)
+LCRYPTO_ALIAS(X509_load_cert_file);
int
X509_load_crl_file(X509_LOOKUP *ctx, const char *file, int type)
BIO_free(in);
return ret;
}
-LCRYPTO_ALIAS(X509_load_crl_file)
+LCRYPTO_ALIAS(X509_load_crl_file);
int
X509_load_cert_crl_file(X509_LOOKUP *ctx, const char *file, int type)
sk_X509_INFO_pop_free(inf, X509_INFO_free);
return count;
}
-LCRYPTO_ALIAS(X509_load_cert_crl_file)
+LCRYPTO_ALIAS(X509_load_cert_crl_file);
-/* $OpenBSD: by_mem.c,v 1.7 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: by_mem.c,v 1.8 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
{
return (&x509_mem_lookup);
}
-LCRYPTO_ALIAS(X509_LOOKUP_mem)
+LCRYPTO_ALIAS(X509_LOOKUP_mem);
static int
by_mem_ctrl(X509_LOOKUP *lu, int cmd, const char *buf,
-/* $OpenBSD: pcy_lib.c,v 1.2 2022/11/14 17:48:49 beck Exp $ */
+/* $OpenBSD: pcy_lib.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2004.
*/
return 0;
return tree->nlevel;
}
-LCRYPTO_ALIAS(X509_policy_tree_level_count)
+LCRYPTO_ALIAS(X509_policy_tree_level_count);
X509_POLICY_LEVEL *
X509_policy_tree_get0_level(const X509_POLICY_TREE *tree, int i)
return NULL;
return tree->levels + i;
}
-LCRYPTO_ALIAS(X509_policy_tree_get0_level)
+LCRYPTO_ALIAS(X509_policy_tree_get0_level);
STACK_OF(X509_POLICY_NODE) *
X509_policy_tree_get0_policies(const X509_POLICY_TREE *tree)
return NULL;
return tree->auth_policies;
}
-LCRYPTO_ALIAS(X509_policy_tree_get0_policies)
+LCRYPTO_ALIAS(X509_policy_tree_get0_policies);
STACK_OF(X509_POLICY_NODE) *
X509_policy_tree_get0_user_policies(const X509_POLICY_TREE *tree)
else
return tree->user_policies;
}
-LCRYPTO_ALIAS(X509_policy_tree_get0_user_policies)
+LCRYPTO_ALIAS(X509_policy_tree_get0_user_policies);
/* X509_POLICY_LEVEL stuff */
n += sk_X509_POLICY_NODE_num(level->nodes);
return n;
}
-LCRYPTO_ALIAS(X509_policy_level_node_count)
+LCRYPTO_ALIAS(X509_policy_level_node_count);
X509_POLICY_NODE *
X509_policy_level_get0_node(X509_POLICY_LEVEL *level, int i)
}
return sk_X509_POLICY_NODE_value(level->nodes, i);
}
-LCRYPTO_ALIAS(X509_policy_level_get0_node)
+LCRYPTO_ALIAS(X509_policy_level_get0_node);
/* X509_POLICY_NODE stuff */
return NULL;
return node->data->valid_policy;
}
-LCRYPTO_ALIAS(X509_policy_node_get0_policy)
+LCRYPTO_ALIAS(X509_policy_node_get0_policy);
STACK_OF(POLICYQUALINFO) *
X509_policy_node_get0_qualifiers(const X509_POLICY_NODE *node)
return NULL;
return node->data->qualifier_set;
}
-LCRYPTO_ALIAS(X509_policy_node_get0_qualifiers)
+LCRYPTO_ALIAS(X509_policy_node_get0_qualifiers);
const X509_POLICY_NODE *
X509_policy_node_get0_parent(const X509_POLICY_NODE *node)
return NULL;
return node->parent;
}
-LCRYPTO_ALIAS(X509_policy_node_get0_parent)
+LCRYPTO_ALIAS(X509_policy_node_get0_parent);
-/* $OpenBSD: pcy_tree.c,v 1.5 2022/12/26 07:18:53 jmc Exp $ */
+/* $OpenBSD: pcy_tree.c,v 1.6 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2004.
*/
free(tree->levels);
free(tree);
}
-LCRYPTO_ALIAS(X509_policy_tree_free)
+LCRYPTO_ALIAS(X509_policy_tree_free);
/* Application policy checking function.
* Return codes:
return 0;
}
-LCRYPTO_ALIAS(X509_policy_check)
+LCRYPTO_ALIAS(X509_policy_check);
-/* $OpenBSD: x509_addr.c,v 1.85 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: x509_addr.c,v 1.86 2023/02/16 08:38:17 tb Exp $ */
/*
* Contributed to the OpenSSL Project by the American Registry for
* Internet Numbers ("ARIN").
return (IPAddressRange *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&IPAddressRange_it);
}
-LCRYPTO_ALIAS(d2i_IPAddressRange)
+LCRYPTO_ALIAS(d2i_IPAddressRange);
int
i2d_IPAddressRange(IPAddressRange *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressRange_it);
}
-LCRYPTO_ALIAS(i2d_IPAddressRange)
+LCRYPTO_ALIAS(i2d_IPAddressRange);
IPAddressRange *
IPAddressRange_new(void)
{
return (IPAddressRange *)ASN1_item_new(&IPAddressRange_it);
}
-LCRYPTO_ALIAS(IPAddressRange_new)
+LCRYPTO_ALIAS(IPAddressRange_new);
void
IPAddressRange_free(IPAddressRange *a)
{
ASN1_item_free((ASN1_VALUE *)a, &IPAddressRange_it);
}
-LCRYPTO_ALIAS(IPAddressRange_free)
+LCRYPTO_ALIAS(IPAddressRange_free);
IPAddressOrRange *
d2i_IPAddressOrRange(IPAddressOrRange **a, const unsigned char **in, long len)
return (IPAddressOrRange *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&IPAddressOrRange_it);
}
-LCRYPTO_ALIAS(d2i_IPAddressOrRange)
+LCRYPTO_ALIAS(d2i_IPAddressOrRange);
int
i2d_IPAddressOrRange(IPAddressOrRange *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressOrRange_it);
}
-LCRYPTO_ALIAS(i2d_IPAddressOrRange)
+LCRYPTO_ALIAS(i2d_IPAddressOrRange);
IPAddressOrRange *
IPAddressOrRange_new(void)
{
return (IPAddressOrRange *)ASN1_item_new(&IPAddressOrRange_it);
}
-LCRYPTO_ALIAS(IPAddressOrRange_new)
+LCRYPTO_ALIAS(IPAddressOrRange_new);
void
IPAddressOrRange_free(IPAddressOrRange *a)
{
ASN1_item_free((ASN1_VALUE *)a, &IPAddressOrRange_it);
}
-LCRYPTO_ALIAS(IPAddressOrRange_free)
+LCRYPTO_ALIAS(IPAddressOrRange_free);
IPAddressChoice *
d2i_IPAddressChoice(IPAddressChoice **a, const unsigned char **in, long len)
return (IPAddressChoice *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&IPAddressChoice_it);
}
-LCRYPTO_ALIAS(d2i_IPAddressChoice)
+LCRYPTO_ALIAS(d2i_IPAddressChoice);
int
i2d_IPAddressChoice(IPAddressChoice *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressChoice_it);
}
-LCRYPTO_ALIAS(i2d_IPAddressChoice)
+LCRYPTO_ALIAS(i2d_IPAddressChoice);
IPAddressChoice *
IPAddressChoice_new(void)
{
return (IPAddressChoice *)ASN1_item_new(&IPAddressChoice_it);
}
-LCRYPTO_ALIAS(IPAddressChoice_new)
+LCRYPTO_ALIAS(IPAddressChoice_new);
void
IPAddressChoice_free(IPAddressChoice *a)
{
ASN1_item_free((ASN1_VALUE *)a, &IPAddressChoice_it);
}
-LCRYPTO_ALIAS(IPAddressChoice_free)
+LCRYPTO_ALIAS(IPAddressChoice_free);
IPAddressFamily *
d2i_IPAddressFamily(IPAddressFamily **a, const unsigned char **in, long len)
return (IPAddressFamily *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&IPAddressFamily_it);
}
-LCRYPTO_ALIAS(d2i_IPAddressFamily)
+LCRYPTO_ALIAS(d2i_IPAddressFamily);
int
i2d_IPAddressFamily(IPAddressFamily *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressFamily_it);
}
-LCRYPTO_ALIAS(i2d_IPAddressFamily)
+LCRYPTO_ALIAS(i2d_IPAddressFamily);
IPAddressFamily *
IPAddressFamily_new(void)
{
return (IPAddressFamily *)ASN1_item_new(&IPAddressFamily_it);
}
-LCRYPTO_ALIAS(IPAddressFamily_new)
+LCRYPTO_ALIAS(IPAddressFamily_new);
void
IPAddressFamily_free(IPAddressFamily *a)
{
ASN1_item_free((ASN1_VALUE *)a, &IPAddressFamily_it);
}
-LCRYPTO_ALIAS(IPAddressFamily_free)
+LCRYPTO_ALIAS(IPAddressFamily_free);
/*
* Convenience accessors for IPAddressFamily.
return afi;
}
-LCRYPTO_ALIAS(X509v3_addr_get_afi)
+LCRYPTO_ALIAS(X509v3_addr_get_afi);
/*
* Expand the bitstring form (RFC 3779, section 2.1.2) of an address into
return IPAddressFamily_set_inheritance(af);
}
-LCRYPTO_ALIAS(X509v3_addr_add_inherit)
+LCRYPTO_ALIAS(X509v3_addr_add_inherit);
/*
* Construct an IPAddressOrRange sequence, or return an existing one.
return 1;
}
-LCRYPTO_ALIAS(X509v3_addr_add_prefix)
+LCRYPTO_ALIAS(X509v3_addr_add_prefix);
/*
* Add a range.
return 1;
}
-LCRYPTO_ALIAS(X509v3_addr_add_range)
+LCRYPTO_ALIAS(X509v3_addr_add_range);
static int
extract_min_max_bitstr(IPAddressOrRange *aor, ASN1_BIT_STRING **out_min,
return afi_len;
}
-LCRYPTO_ALIAS(X509v3_addr_get_range)
+LCRYPTO_ALIAS(X509v3_addr_get_range);
/*
* Check whether an IPAddrBLocks is in canonical form.
*/
return 1;
}
-LCRYPTO_ALIAS(X509v3_addr_is_canonical)
+LCRYPTO_ALIAS(X509v3_addr_is_canonical);
/*
* Whack an IPAddressOrRanges into canonical form.
return X509v3_addr_is_canonical(addr);
}
-LCRYPTO_ALIAS(X509v3_addr_canonize)
+LCRYPTO_ALIAS(X509v3_addr_canonize);
/*
* v2i handler for the IPAddrBlocks extension.
return 0;
}
-LCRYPTO_ALIAS(X509v3_addr_inherits)
+LCRYPTO_ALIAS(X509v3_addr_inherits);
/*
* Figure out whether parent contains child.
}
return 1;
}
-LCRYPTO_ALIAS(X509v3_addr_subset)
+LCRYPTO_ALIAS(X509v3_addr_subset);
static int
verify_error(X509_STORE_CTX *ctx, X509 *cert, int error, int depth)
}
return addr_validate_path_internal(ctx, ctx->chain, NULL);
}
-LCRYPTO_ALIAS(X509v3_addr_validate_path)
+LCRYPTO_ALIAS(X509v3_addr_validate_path);
/*
* RFC 3779 2.3 path validation of an extension.
return 0;
return addr_validate_path_internal(NULL, chain, ext);
}
-LCRYPTO_ALIAS(X509v3_addr_validate_resource_set)
+LCRYPTO_ALIAS(X509v3_addr_validate_resource_set);
#endif /* OPENSSL_NO_RFC3779 */
-/* $OpenBSD: x509_akeya.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_akeya.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return (AUTHORITY_KEYID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&AUTHORITY_KEYID_it);
}
-LCRYPTO_ALIAS(d2i_AUTHORITY_KEYID)
+LCRYPTO_ALIAS(d2i_AUTHORITY_KEYID);
int
i2d_AUTHORITY_KEYID(AUTHORITY_KEYID *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &AUTHORITY_KEYID_it);
}
-LCRYPTO_ALIAS(i2d_AUTHORITY_KEYID)
+LCRYPTO_ALIAS(i2d_AUTHORITY_KEYID);
AUTHORITY_KEYID *
AUTHORITY_KEYID_new(void)
{
return (AUTHORITY_KEYID *)ASN1_item_new(&AUTHORITY_KEYID_it);
}
-LCRYPTO_ALIAS(AUTHORITY_KEYID_new)
+LCRYPTO_ALIAS(AUTHORITY_KEYID_new);
void
AUTHORITY_KEYID_free(AUTHORITY_KEYID *a)
{
ASN1_item_free((ASN1_VALUE *)a, &AUTHORITY_KEYID_it);
}
-LCRYPTO_ALIAS(AUTHORITY_KEYID_free)
+LCRYPTO_ALIAS(AUTHORITY_KEYID_free);
-/* $OpenBSD: x509_alt.c,v 1.14 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_alt.c,v 1.15 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project.
*/
return NULL;
}
-LCRYPTO_ALIAS(i2v_GENERAL_NAMES)
+LCRYPTO_ALIAS(i2v_GENERAL_NAMES);
STACK_OF(CONF_VALUE) *
i2v_GENERAL_NAME(X509V3_EXT_METHOD *method, GENERAL_NAME *gen,
return NULL;
}
-LCRYPTO_ALIAS(i2v_GENERAL_NAME)
+LCRYPTO_ALIAS(i2v_GENERAL_NAME);
int
GENERAL_NAME_print(BIO *out, GENERAL_NAME *gen)
}
return 1;
}
-LCRYPTO_ALIAS(GENERAL_NAME_print)
+LCRYPTO_ALIAS(GENERAL_NAME_print);
static GENERAL_NAMES *
v2i_issuer_alt(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
return NULL;
}
-LCRYPTO_ALIAS(v2i_GENERAL_NAMES)
+LCRYPTO_ALIAS(v2i_GENERAL_NAMES);
GENERAL_NAME *
v2i_GENERAL_NAME(const X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
{
return v2i_GENERAL_NAME_ex(NULL, method, ctx, cnf, 0);
}
-LCRYPTO_ALIAS(v2i_GENERAL_NAME)
+LCRYPTO_ALIAS(v2i_GENERAL_NAME);
GENERAL_NAME *
a2i_GENERAL_NAME(GENERAL_NAME *out, const X509V3_EXT_METHOD *method,
GENERAL_NAME_free(gen);
return NULL;
}
-LCRYPTO_ALIAS(a2i_GENERAL_NAME)
+LCRYPTO_ALIAS(a2i_GENERAL_NAME);
GENERAL_NAME *
v2i_GENERAL_NAME_ex(GENERAL_NAME *out, const X509V3_EXT_METHOD *method,
GENERAL_NAME_free(ret);
return NULL;
}
-LCRYPTO_ALIAS(v2i_GENERAL_NAME_ex)
+LCRYPTO_ALIAS(v2i_GENERAL_NAME_ex);
static int
do_othername(GENERAL_NAME *gen, const char *value, X509V3_CTX *ctx)
-/* $OpenBSD: x509_asid.c,v 1.38 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: x509_asid.c,v 1.39 2023/02/16 08:38:17 tb Exp $ */
/*
* Contributed to the OpenSSL Project by the American Registry for
* Internet Numbers ("ARIN").
return (ASRange *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASRange_it);
}
-LCRYPTO_ALIAS(d2i_ASRange)
+LCRYPTO_ALIAS(d2i_ASRange);
int
i2d_ASRange(ASRange *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASRange_it);
}
-LCRYPTO_ALIAS(i2d_ASRange)
+LCRYPTO_ALIAS(i2d_ASRange);
ASRange *
ASRange_new(void)
{
return (ASRange *)ASN1_item_new(&ASRange_it);
}
-LCRYPTO_ALIAS(ASRange_new)
+LCRYPTO_ALIAS(ASRange_new);
void
ASRange_free(ASRange *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASRange_it);
}
-LCRYPTO_ALIAS(ASRange_free)
+LCRYPTO_ALIAS(ASRange_free);
ASIdOrRange *
d2i_ASIdOrRange(ASIdOrRange **a, const unsigned char **in, long len)
return (ASIdOrRange *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASIdOrRange_it);
}
-LCRYPTO_ALIAS(d2i_ASIdOrRange)
+LCRYPTO_ALIAS(d2i_ASIdOrRange);
int
i2d_ASIdOrRange(ASIdOrRange *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASIdOrRange_it);
}
-LCRYPTO_ALIAS(i2d_ASIdOrRange)
+LCRYPTO_ALIAS(i2d_ASIdOrRange);
ASIdOrRange *
ASIdOrRange_new(void)
{
return (ASIdOrRange *)ASN1_item_new(&ASIdOrRange_it);
}
-LCRYPTO_ALIAS(ASIdOrRange_new)
+LCRYPTO_ALIAS(ASIdOrRange_new);
void
ASIdOrRange_free(ASIdOrRange *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASIdOrRange_it);
}
-LCRYPTO_ALIAS(ASIdOrRange_free)
+LCRYPTO_ALIAS(ASIdOrRange_free);
ASIdentifierChoice *
d2i_ASIdentifierChoice(ASIdentifierChoice **a, const unsigned char **in,
return (ASIdentifierChoice *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASIdentifierChoice_it);
}
-LCRYPTO_ALIAS(d2i_ASIdentifierChoice)
+LCRYPTO_ALIAS(d2i_ASIdentifierChoice);
int
i2d_ASIdentifierChoice(ASIdentifierChoice *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASIdentifierChoice_it);
}
-LCRYPTO_ALIAS(i2d_ASIdentifierChoice)
+LCRYPTO_ALIAS(i2d_ASIdentifierChoice);
ASIdentifierChoice *
ASIdentifierChoice_new(void)
{
return (ASIdentifierChoice *)ASN1_item_new(&ASIdentifierChoice_it);
}
-LCRYPTO_ALIAS(ASIdentifierChoice_new)
+LCRYPTO_ALIAS(ASIdentifierChoice_new);
void
ASIdentifierChoice_free(ASIdentifierChoice *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASIdentifierChoice_it);
}
-LCRYPTO_ALIAS(ASIdentifierChoice_free)
+LCRYPTO_ALIAS(ASIdentifierChoice_free);
ASIdentifiers *
d2i_ASIdentifiers(ASIdentifiers **a, const unsigned char **in, long len)
return (ASIdentifiers *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASIdentifiers_it);
}
-LCRYPTO_ALIAS(d2i_ASIdentifiers)
+LCRYPTO_ALIAS(d2i_ASIdentifiers);
int
i2d_ASIdentifiers(ASIdentifiers *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASIdentifiers_it);
}
-LCRYPTO_ALIAS(i2d_ASIdentifiers)
+LCRYPTO_ALIAS(i2d_ASIdentifiers);
ASIdentifiers *
ASIdentifiers_new(void)
{
return (ASIdentifiers *)ASN1_item_new(&ASIdentifiers_it);
}
-LCRYPTO_ALIAS(ASIdentifiers_new)
+LCRYPTO_ALIAS(ASIdentifiers_new);
void
ASIdentifiers_free(ASIdentifiers *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASIdentifiers_it);
}
-LCRYPTO_ALIAS(ASIdentifiers_free)
+LCRYPTO_ALIAS(ASIdentifiers_free);
/*
* i2r method for an ASIdentifierChoice.
}
return (*choice)->type == ASIdentifierChoice_inherit;
}
-LCRYPTO_ALIAS(X509v3_asid_add_inherit)
+LCRYPTO_ALIAS(X509v3_asid_add_inherit);
/*
* Add an ID or range to an ASIdentifierChoice.
ASIdOrRange_free(aor);
return 0;
}
-LCRYPTO_ALIAS(X509v3_asid_add_id_or_range)
+LCRYPTO_ALIAS(X509v3_asid_add_id_or_range);
/*
* Extract min and max values from an ASIdOrRange.
(ASIdentifierChoice_is_canonical(asid->asnum) &&
ASIdentifierChoice_is_canonical(asid->rdi)));
}
-LCRYPTO_ALIAS(X509v3_asid_is_canonical)
+LCRYPTO_ALIAS(X509v3_asid_is_canonical);
/*
* Whack an ASIdentifierChoice into canonical form.
return ASIdentifierChoice_canonize(asid->rdi);
}
-LCRYPTO_ALIAS(X509v3_asid_canonize)
+LCRYPTO_ALIAS(X509v3_asid_canonize);
/*
* v2i method for an ASIdentifier extension.
return 0;
}
-LCRYPTO_ALIAS(X509v3_asid_inherits)
+LCRYPTO_ALIAS(X509v3_asid_inherits);
/*
* Figure out whether parent contains child.
return 1;
}
-LCRYPTO_ALIAS(X509v3_asid_subset)
+LCRYPTO_ALIAS(X509v3_asid_subset);
/*
* Validation error handling via callback.
}
return asid_validate_path_internal(ctx, ctx->chain, NULL);
}
-LCRYPTO_ALIAS(X509v3_asid_validate_path)
+LCRYPTO_ALIAS(X509v3_asid_validate_path);
/*
* RFC 3779 3.3 path validation of an extension.
return 0;
return asid_validate_path_internal(NULL, chain, ext);
}
-LCRYPTO_ALIAS(X509v3_asid_validate_resource_set)
+LCRYPTO_ALIAS(X509v3_asid_validate_resource_set);
#endif /* OPENSSL_NO_RFC3779 */
-/* $OpenBSD: x509_att.c,v 1.21 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: x509_att.c,v 1.22 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
{
return sk_X509_ATTRIBUTE_num(x);
}
-LCRYPTO_ALIAS(X509at_get_attr_count)
+LCRYPTO_ALIAS(X509at_get_attr_count);
int
X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid, int lastpos)
return (-2);
return (X509at_get_attr_by_OBJ(x, obj, lastpos));
}
-LCRYPTO_ALIAS(X509at_get_attr_by_NID)
+LCRYPTO_ALIAS(X509at_get_attr_by_NID);
int
X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk,
}
return (-1);
}
-LCRYPTO_ALIAS(X509at_get_attr_by_OBJ)
+LCRYPTO_ALIAS(X509at_get_attr_by_OBJ);
X509_ATTRIBUTE *
X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc)
else
return sk_X509_ATTRIBUTE_value(x, loc);
}
-LCRYPTO_ALIAS(X509at_get_attr)
+LCRYPTO_ALIAS(X509at_get_attr);
X509_ATTRIBUTE *
X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc)
ret = sk_X509_ATTRIBUTE_delete(x, loc);
return (ret);
}
-LCRYPTO_ALIAS(X509at_delete_attr)
+LCRYPTO_ALIAS(X509at_delete_attr);
STACK_OF(X509_ATTRIBUTE) *
X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x, X509_ATTRIBUTE *attr)
sk_X509_ATTRIBUTE_free(sk);
return (NULL);
}
-LCRYPTO_ALIAS(X509at_add1_attr)
+LCRYPTO_ALIAS(X509at_add1_attr);
STACK_OF(X509_ATTRIBUTE) *
X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) **x, const ASN1_OBJECT *obj,
X509_ATTRIBUTE_free(attr);
return ret;
}
-LCRYPTO_ALIAS(X509at_add1_attr_by_OBJ)
+LCRYPTO_ALIAS(X509at_add1_attr_by_OBJ);
STACK_OF(X509_ATTRIBUTE) *
X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) **x, int nid, int type,
X509_ATTRIBUTE_free(attr);
return ret;
}
-LCRYPTO_ALIAS(X509at_add1_attr_by_NID)
+LCRYPTO_ALIAS(X509at_add1_attr_by_NID);
STACK_OF(X509_ATTRIBUTE) *
X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) **x, const char *attrname,
X509_ATTRIBUTE_free(attr);
return ret;
}
-LCRYPTO_ALIAS(X509at_add1_attr_by_txt)
+LCRYPTO_ALIAS(X509at_add1_attr_by_txt);
void *
X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x, const ASN1_OBJECT *obj,
return NULL;
return X509_ATTRIBUTE_get0_data(at, 0, type, NULL);
}
-LCRYPTO_ALIAS(X509at_get0_data_by_OBJ)
+LCRYPTO_ALIAS(X509at_get0_data_by_OBJ);
X509_ATTRIBUTE *
X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid, int atrtype,
ASN1_OBJECT_free(obj);
return (ret);
}
-LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_NID)
+LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_NID);
X509_ATTRIBUTE *
X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr, const ASN1_OBJECT *obj,
X509_ATTRIBUTE_free(ret);
return (NULL);
}
-LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_OBJ)
+LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_OBJ);
X509_ATTRIBUTE *
X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr, const char *atrname,
ASN1_OBJECT_free(obj);
return nattr;
}
-LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_txt)
+LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_txt);
int
X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj)
attr->object = OBJ_dup(obj);
return attr->object != NULL;
}
-LCRYPTO_ALIAS(X509_ATTRIBUTE_set1_object)
+LCRYPTO_ALIAS(X509_ATTRIBUTE_set1_object);
int
X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype, const void *data,
X509error(ERR_R_MALLOC_FAILURE);
return 0;
}
-LCRYPTO_ALIAS(X509_ATTRIBUTE_set1_data)
+LCRYPTO_ALIAS(X509_ATTRIBUTE_set1_data);
int
X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr)
return sk_ASN1_TYPE_num(attr->set);
}
-LCRYPTO_ALIAS(X509_ATTRIBUTE_count)
+LCRYPTO_ALIAS(X509_ATTRIBUTE_count);
ASN1_OBJECT *
X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr)
return (NULL);
return (attr->object);
}
-LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_object)
+LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_object);
void *
X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, int atrtype, void *data)
}
return ttmp->value.ptr;
}
-LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_data)
+LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_data);
ASN1_TYPE *
X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx)
return sk_ASN1_TYPE_value(attr->set, idx);
}
-LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_type)
+LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_type);
-/* $OpenBSD: x509_bcons.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_bcons.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return (BASIC_CONSTRAINTS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&BASIC_CONSTRAINTS_it);
}
-LCRYPTO_ALIAS(d2i_BASIC_CONSTRAINTS)
+LCRYPTO_ALIAS(d2i_BASIC_CONSTRAINTS);
int
i2d_BASIC_CONSTRAINTS(BASIC_CONSTRAINTS *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &BASIC_CONSTRAINTS_it);
}
-LCRYPTO_ALIAS(i2d_BASIC_CONSTRAINTS)
+LCRYPTO_ALIAS(i2d_BASIC_CONSTRAINTS);
BASIC_CONSTRAINTS *
BASIC_CONSTRAINTS_new(void)
{
return (BASIC_CONSTRAINTS *)ASN1_item_new(&BASIC_CONSTRAINTS_it);
}
-LCRYPTO_ALIAS(BASIC_CONSTRAINTS_new)
+LCRYPTO_ALIAS(BASIC_CONSTRAINTS_new);
void
BASIC_CONSTRAINTS_free(BASIC_CONSTRAINTS *a)
{
ASN1_item_free((ASN1_VALUE *)a, &BASIC_CONSTRAINTS_it);
}
-LCRYPTO_ALIAS(BASIC_CONSTRAINTS_free)
+LCRYPTO_ALIAS(BASIC_CONSTRAINTS_free);
static STACK_OF(CONF_VALUE) *
-/* $OpenBSD: x509_bitst.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_bitst.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return NULL;
}
-LCRYPTO_ALIAS(i2v_ASN1_BIT_STRING)
+LCRYPTO_ALIAS(i2v_ASN1_BIT_STRING);
ASN1_BIT_STRING *
v2i_ASN1_BIT_STRING(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
}
return bs;
}
-LCRYPTO_ALIAS(v2i_ASN1_BIT_STRING)
+LCRYPTO_ALIAS(v2i_ASN1_BIT_STRING);
-/* $OpenBSD: x509_cmp.c,v 1.41 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: x509_cmp.c,v 1.42 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (i);
return (X509_NAME_cmp(ai->issuer, bi->issuer));
}
-LCRYPTO_ALIAS(X509_issuer_and_serial_cmp)
+LCRYPTO_ALIAS(X509_issuer_and_serial_cmp);
#ifndef OPENSSL_NO_MD5
unsigned long
free(f);
return (ret);
}
-LCRYPTO_ALIAS(X509_issuer_and_serial_hash)
+LCRYPTO_ALIAS(X509_issuer_and_serial_hash);
#endif
int
{
return (X509_NAME_cmp(a->cert_info->issuer, b->cert_info->issuer));
}
-LCRYPTO_ALIAS(X509_issuer_name_cmp)
+LCRYPTO_ALIAS(X509_issuer_name_cmp);
int
X509_subject_name_cmp(const X509 *a, const X509 *b)
{
return (X509_NAME_cmp(a->cert_info->subject, b->cert_info->subject));
}
-LCRYPTO_ALIAS(X509_subject_name_cmp)
+LCRYPTO_ALIAS(X509_subject_name_cmp);
int
X509_CRL_cmp(const X509_CRL *a, const X509_CRL *b)
{
return (X509_NAME_cmp(a->crl->issuer, b->crl->issuer));
}
-LCRYPTO_ALIAS(X509_CRL_cmp)
+LCRYPTO_ALIAS(X509_CRL_cmp);
#ifndef OPENSSL_NO_SHA
int
{
return memcmp(a->hash, b->hash, X509_CRL_HASH_LEN);
}
-LCRYPTO_ALIAS(X509_CRL_match)
+LCRYPTO_ALIAS(X509_CRL_match);
#endif
X509_NAME *
{
return (a->cert_info->issuer);
}
-LCRYPTO_ALIAS(X509_get_issuer_name)
+LCRYPTO_ALIAS(X509_get_issuer_name);
unsigned long
X509_issuer_name_hash(X509 *x)
{
return (X509_NAME_hash(x->cert_info->issuer));
}
-LCRYPTO_ALIAS(X509_issuer_name_hash)
+LCRYPTO_ALIAS(X509_issuer_name_hash);
#ifndef OPENSSL_NO_MD5
unsigned long
{
return (X509_NAME_hash_old(x->cert_info->issuer));
}
-LCRYPTO_ALIAS(X509_issuer_name_hash_old)
+LCRYPTO_ALIAS(X509_issuer_name_hash_old);
#endif
X509_NAME *
{
return (a->cert_info->subject);
}
-LCRYPTO_ALIAS(X509_get_subject_name)
+LCRYPTO_ALIAS(X509_get_subject_name);
ASN1_INTEGER *
X509_get_serialNumber(X509 *a)
{
return (a->cert_info->serialNumber);
}
-LCRYPTO_ALIAS(X509_get_serialNumber)
+LCRYPTO_ALIAS(X509_get_serialNumber);
const ASN1_INTEGER *
X509_get0_serialNumber(const X509 *a)
{
return (a->cert_info->serialNumber);
}
-LCRYPTO_ALIAS(X509_get0_serialNumber)
+LCRYPTO_ALIAS(X509_get0_serialNumber);
unsigned long
X509_subject_name_hash(X509 *x)
{
return (X509_NAME_hash(x->cert_info->subject));
}
-LCRYPTO_ALIAS(X509_subject_name_hash)
+LCRYPTO_ALIAS(X509_subject_name_hash);
#ifndef OPENSSL_NO_MD5
unsigned long
{
return (X509_NAME_hash_old(x->cert_info->subject));
}
-LCRYPTO_ALIAS(X509_subject_name_hash_old)
+LCRYPTO_ALIAS(X509_subject_name_hash_old);
#endif
#ifndef OPENSSL_NO_SHA
return memcmp(a->hash, b->hash, X509_CERT_HASH_LEN);
}
-LCRYPTO_ALIAS(X509_cmp)
+LCRYPTO_ALIAS(X509_cmp);
#endif
int
return ret;
return memcmp(a->canon_enc, b->canon_enc, a->canon_enclen);
}
-LCRYPTO_ALIAS(X509_NAME_cmp)
+LCRYPTO_ALIAS(X509_NAME_cmp);
unsigned long
X509_NAME_hash(X509_NAME *x)
0xffffffffL;
return (ret);
}
-LCRYPTO_ALIAS(X509_NAME_hash)
+LCRYPTO_ALIAS(X509_NAME_hash);
#ifndef OPENSSL_NO_MD5
return (ret);
}
-LCRYPTO_ALIAS(X509_NAME_hash_old)
+LCRYPTO_ALIAS(X509_NAME_hash_old);
#endif
/* Search a stack of X509 for a match */
}
return (NULL);
}
-LCRYPTO_ALIAS(X509_find_by_issuer_and_serial)
+LCRYPTO_ALIAS(X509_find_by_issuer_and_serial);
X509 *
X509_find_by_subject(STACK_OF(X509) *sk, X509_NAME *name)
}
return (NULL);
}
-LCRYPTO_ALIAS(X509_find_by_subject)
+LCRYPTO_ALIAS(X509_find_by_subject);
EVP_PKEY *
X509_get_pubkey(X509 *x)
return (NULL);
return (X509_PUBKEY_get(x->cert_info->key));
}
-LCRYPTO_ALIAS(X509_get_pubkey)
+LCRYPTO_ALIAS(X509_get_pubkey);
EVP_PKEY *
X509_get0_pubkey(const X509 *x)
return (NULL);
return (X509_PUBKEY_get0(x->cert_info->key));
}
-LCRYPTO_ALIAS(X509_get0_pubkey)
+LCRYPTO_ALIAS(X509_get0_pubkey);
ASN1_BIT_STRING *
X509_get0_pubkey_bitstr(const X509 *x)
return NULL;
return x->cert_info->key->public_key;
}
-LCRYPTO_ALIAS(X509_get0_pubkey_bitstr)
+LCRYPTO_ALIAS(X509_get0_pubkey_bitstr);
int
X509_check_private_key(const X509 *x, const EVP_PKEY *k)
return 1;
return 0;
}
-LCRYPTO_ALIAS(X509_check_private_key)
+LCRYPTO_ALIAS(X509_check_private_key);
/*
* Not strictly speaking an "up_ref" as a STACK doesn't have a reference
return ret;
}
-LCRYPTO_ALIAS(X509_chain_up_ref)
+LCRYPTO_ALIAS(X509_chain_up_ref);
-/* $OpenBSD: x509_conf.c,v 1.4 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: x509_conf.c,v 1.5 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
}
return ret;
}
-LCRYPTO_ALIAS(X509V3_EXT_nconf)
+LCRYPTO_ALIAS(X509V3_EXT_nconf);
/* CONF *conf: Config file */
/* char *value: Value */
value, crit, ext_type, ctx);
return do_ext_nconf(conf, ctx, ext_nid, crit, value);
}
-LCRYPTO_ALIAS(X509V3_EXT_nconf_nid)
+LCRYPTO_ALIAS(X509V3_EXT_nconf_nid);
/* CONF *conf: Config file */
/* char *value: Value */
}
return do_ext_i2d(method, ext_nid, crit, ext_struc);
}
-LCRYPTO_ALIAS(X509V3_EXT_i2d)
+LCRYPTO_ALIAS(X509V3_EXT_i2d);
/* Check the extension string for critical flag */
static int
}
return 1;
}
-LCRYPTO_ALIAS(X509V3_EXT_add_nconf_sk)
+LCRYPTO_ALIAS(X509V3_EXT_add_nconf_sk);
/* Convenience functions to add extensions to a certificate, CRL and request */
sk = &cert->cert_info->extensions;
return X509V3_EXT_add_nconf_sk(conf, ctx, section, sk);
}
-LCRYPTO_ALIAS(X509V3_EXT_add_nconf)
+LCRYPTO_ALIAS(X509V3_EXT_add_nconf);
/* Same as above but for a CRL */
sk = &crl->crl->extensions;
return X509V3_EXT_add_nconf_sk(conf, ctx, section, sk);
}
-LCRYPTO_ALIAS(X509V3_EXT_CRL_add_nconf)
+LCRYPTO_ALIAS(X509V3_EXT_CRL_add_nconf);
/* Add extensions to certificate request */
sk_X509_EXTENSION_pop_free(extlist, X509_EXTENSION_free);
return i;
}
-LCRYPTO_ALIAS(X509V3_EXT_REQ_add_nconf)
+LCRYPTO_ALIAS(X509V3_EXT_REQ_add_nconf);
/* Config database functions */
}
return ctx->db_meth->get_string(ctx->db, name, section);
}
-LCRYPTO_ALIAS(X509V3_get_string)
+LCRYPTO_ALIAS(X509V3_get_string);
STACK_OF(CONF_VALUE) *
X509V3_get_section(X509V3_CTX *ctx, const char *section)
}
return ctx->db_meth->get_section(ctx->db, section);
}
-LCRYPTO_ALIAS(X509V3_get_section)
+LCRYPTO_ALIAS(X509V3_get_section);
void
X509V3_string_free(X509V3_CTX *ctx, char *str)
if (ctx->db_meth->free_string)
ctx->db_meth->free_string(ctx->db, str);
}
-LCRYPTO_ALIAS(X509V3_string_free)
+LCRYPTO_ALIAS(X509V3_string_free);
void
X509V3_section_free(X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *section)
if (ctx->db_meth->free_section)
ctx->db_meth->free_section(ctx->db, section);
}
-LCRYPTO_ALIAS(X509V3_section_free)
+LCRYPTO_ALIAS(X509V3_section_free);
static char *
nconf_get_string(void *db, const char *section, const char *value)
ctx->db_meth = &nconf_method;
ctx->db = conf;
}
-LCRYPTO_ALIAS(X509V3_set_nconf)
+LCRYPTO_ALIAS(X509V3_set_nconf);
void
X509V3_set_ctx(X509V3_CTX *ctx, X509 *issuer, X509 *subj, X509_REQ *req,
ctx->subject_req = req;
ctx->flags = flags;
}
-LCRYPTO_ALIAS(X509V3_set_ctx)
+LCRYPTO_ALIAS(X509V3_set_ctx);
/* Old conf compatibility functions */
CONF_set_nconf(&ctmp, conf);
return X509V3_EXT_nconf(&ctmp, ctx, name, value);
}
-LCRYPTO_ALIAS(X509V3_EXT_conf)
+LCRYPTO_ALIAS(X509V3_EXT_conf);
/* LHASH *conf: Config file */
/* char *value: Value */
CONF_set_nconf(&ctmp, conf);
return X509V3_EXT_nconf_nid(&ctmp, ctx, ext_nid, value);
}
-LCRYPTO_ALIAS(X509V3_EXT_conf_nid)
+LCRYPTO_ALIAS(X509V3_EXT_conf_nid);
static char *
conf_lhash_get_string(void *db, const char *section, const char *value)
ctx->db_meth = &conf_lhash_method;
ctx->db = lhash;
}
-LCRYPTO_ALIAS(X509V3_set_conf_lhash)
+LCRYPTO_ALIAS(X509V3_set_conf_lhash);
int
X509V3_EXT_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
CONF_set_nconf(&ctmp, conf);
return X509V3_EXT_add_nconf(&ctmp, ctx, section, cert);
}
-LCRYPTO_ALIAS(X509V3_EXT_add_conf)
+LCRYPTO_ALIAS(X509V3_EXT_add_conf);
/* Same as above but for a CRL */
CONF_set_nconf(&ctmp, conf);
return X509V3_EXT_CRL_add_nconf(&ctmp, ctx, section, crl);
}
-LCRYPTO_ALIAS(X509V3_EXT_CRL_add_conf)
+LCRYPTO_ALIAS(X509V3_EXT_CRL_add_conf);
/* Add extensions to certificate request */
CONF_set_nconf(&ctmp, conf);
return X509V3_EXT_REQ_add_nconf(&ctmp, ctx, section, req);
}
-LCRYPTO_ALIAS(X509V3_EXT_REQ_add_conf)
+LCRYPTO_ALIAS(X509V3_EXT_REQ_add_conf);
-/* $OpenBSD: x509_cpols.c,v 1.6 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: x509_cpols.c,v 1.7 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return (CERTIFICATEPOLICIES *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&CERTIFICATEPOLICIES_it);
}
-LCRYPTO_ALIAS(d2i_CERTIFICATEPOLICIES)
+LCRYPTO_ALIAS(d2i_CERTIFICATEPOLICIES);
int
i2d_CERTIFICATEPOLICIES(CERTIFICATEPOLICIES *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &CERTIFICATEPOLICIES_it);
}
-LCRYPTO_ALIAS(i2d_CERTIFICATEPOLICIES)
+LCRYPTO_ALIAS(i2d_CERTIFICATEPOLICIES);
CERTIFICATEPOLICIES *
CERTIFICATEPOLICIES_new(void)
{
return (CERTIFICATEPOLICIES *)ASN1_item_new(&CERTIFICATEPOLICIES_it);
}
-LCRYPTO_ALIAS(CERTIFICATEPOLICIES_new)
+LCRYPTO_ALIAS(CERTIFICATEPOLICIES_new);
void
CERTIFICATEPOLICIES_free(CERTIFICATEPOLICIES *a)
{
ASN1_item_free((ASN1_VALUE *)a, &CERTIFICATEPOLICIES_it);
}
-LCRYPTO_ALIAS(CERTIFICATEPOLICIES_free)
+LCRYPTO_ALIAS(CERTIFICATEPOLICIES_free);
static const ASN1_TEMPLATE POLICYINFO_seq_tt[] = {
{
return (POLICYINFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&POLICYINFO_it);
}
-LCRYPTO_ALIAS(d2i_POLICYINFO)
+LCRYPTO_ALIAS(d2i_POLICYINFO);
int
i2d_POLICYINFO(POLICYINFO *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &POLICYINFO_it);
}
-LCRYPTO_ALIAS(i2d_POLICYINFO)
+LCRYPTO_ALIAS(i2d_POLICYINFO);
POLICYINFO *
POLICYINFO_new(void)
{
return (POLICYINFO *)ASN1_item_new(&POLICYINFO_it);
}
-LCRYPTO_ALIAS(POLICYINFO_new)
+LCRYPTO_ALIAS(POLICYINFO_new);
void
POLICYINFO_free(POLICYINFO *a)
{
ASN1_item_free((ASN1_VALUE *)a, &POLICYINFO_it);
}
-LCRYPTO_ALIAS(POLICYINFO_free)
+LCRYPTO_ALIAS(POLICYINFO_free);
static const ASN1_TEMPLATE policydefault_tt = {
.flags = 0,
return (POLICYQUALINFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&POLICYQUALINFO_it);
}
-LCRYPTO_ALIAS(d2i_POLICYQUALINFO)
+LCRYPTO_ALIAS(d2i_POLICYQUALINFO);
int
i2d_POLICYQUALINFO(POLICYQUALINFO *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &POLICYQUALINFO_it);
}
-LCRYPTO_ALIAS(i2d_POLICYQUALINFO)
+LCRYPTO_ALIAS(i2d_POLICYQUALINFO);
POLICYQUALINFO *
POLICYQUALINFO_new(void)
{
return (POLICYQUALINFO *)ASN1_item_new(&POLICYQUALINFO_it);
}
-LCRYPTO_ALIAS(POLICYQUALINFO_new)
+LCRYPTO_ALIAS(POLICYQUALINFO_new);
void
POLICYQUALINFO_free(POLICYQUALINFO *a)
{
ASN1_item_free((ASN1_VALUE *)a, &POLICYQUALINFO_it);
}
-LCRYPTO_ALIAS(POLICYQUALINFO_free)
+LCRYPTO_ALIAS(POLICYQUALINFO_free);
static const ASN1_TEMPLATE USERNOTICE_seq_tt[] = {
{
return (USERNOTICE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&USERNOTICE_it);
}
-LCRYPTO_ALIAS(d2i_USERNOTICE)
+LCRYPTO_ALIAS(d2i_USERNOTICE);
int
i2d_USERNOTICE(USERNOTICE *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &USERNOTICE_it);
}
-LCRYPTO_ALIAS(i2d_USERNOTICE)
+LCRYPTO_ALIAS(i2d_USERNOTICE);
USERNOTICE *
USERNOTICE_new(void)
{
return (USERNOTICE *)ASN1_item_new(&USERNOTICE_it);
}
-LCRYPTO_ALIAS(USERNOTICE_new)
+LCRYPTO_ALIAS(USERNOTICE_new);
void
USERNOTICE_free(USERNOTICE *a)
{
ASN1_item_free((ASN1_VALUE *)a, &USERNOTICE_it);
}
-LCRYPTO_ALIAS(USERNOTICE_free)
+LCRYPTO_ALIAS(USERNOTICE_free);
static const ASN1_TEMPLATE NOTICEREF_seq_tt[] = {
{
return (NOTICEREF *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&NOTICEREF_it);
}
-LCRYPTO_ALIAS(d2i_NOTICEREF)
+LCRYPTO_ALIAS(d2i_NOTICEREF);
int
i2d_NOTICEREF(NOTICEREF *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &NOTICEREF_it);
}
-LCRYPTO_ALIAS(i2d_NOTICEREF)
+LCRYPTO_ALIAS(i2d_NOTICEREF);
NOTICEREF *
NOTICEREF_new(void)
{
return (NOTICEREF *)ASN1_item_new(&NOTICEREF_it);
}
-LCRYPTO_ALIAS(NOTICEREF_new)
+LCRYPTO_ALIAS(NOTICEREF_new);
void
NOTICEREF_free(NOTICEREF *a)
{
ASN1_item_free((ASN1_VALUE *)a, &NOTICEREF_it);
}
-LCRYPTO_ALIAS(NOTICEREF_free)
+LCRYPTO_ALIAS(NOTICEREF_free);
static STACK_OF(POLICYINFO) *
r2i_certpol(X509V3_EXT_METHOD *method, X509V3_CTX *ctx, char *value)
else
BIO_printf(out, "%*sNo Qualifiers\n", indent + 2, "");
}
-LCRYPTO_ALIAS(X509_POLICY_NODE_print)
+LCRYPTO_ALIAS(X509_POLICY_NODE_print);
-/* $OpenBSD: x509_crld.c,v 1.4 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: x509_crld.c,v 1.5 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return (DIST_POINT_NAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&DIST_POINT_NAME_it);
}
-LCRYPTO_ALIAS(d2i_DIST_POINT_NAME)
+LCRYPTO_ALIAS(d2i_DIST_POINT_NAME);
int
i2d_DIST_POINT_NAME(DIST_POINT_NAME *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &DIST_POINT_NAME_it);
}
-LCRYPTO_ALIAS(i2d_DIST_POINT_NAME)
+LCRYPTO_ALIAS(i2d_DIST_POINT_NAME);
DIST_POINT_NAME *
DIST_POINT_NAME_new(void)
{
return (DIST_POINT_NAME *)ASN1_item_new(&DIST_POINT_NAME_it);
}
-LCRYPTO_ALIAS(DIST_POINT_NAME_new)
+LCRYPTO_ALIAS(DIST_POINT_NAME_new);
void
DIST_POINT_NAME_free(DIST_POINT_NAME *a)
{
ASN1_item_free((ASN1_VALUE *)a, &DIST_POINT_NAME_it);
}
-LCRYPTO_ALIAS(DIST_POINT_NAME_free)
+LCRYPTO_ALIAS(DIST_POINT_NAME_free);
static const ASN1_TEMPLATE DIST_POINT_seq_tt[] = {
{
return (DIST_POINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&DIST_POINT_it);
}
-LCRYPTO_ALIAS(d2i_DIST_POINT)
+LCRYPTO_ALIAS(d2i_DIST_POINT);
int
i2d_DIST_POINT(DIST_POINT *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &DIST_POINT_it);
}
-LCRYPTO_ALIAS(i2d_DIST_POINT)
+LCRYPTO_ALIAS(i2d_DIST_POINT);
DIST_POINT *
DIST_POINT_new(void)
{
return (DIST_POINT *)ASN1_item_new(&DIST_POINT_it);
}
-LCRYPTO_ALIAS(DIST_POINT_new)
+LCRYPTO_ALIAS(DIST_POINT_new);
void
DIST_POINT_free(DIST_POINT *a)
{
ASN1_item_free((ASN1_VALUE *)a, &DIST_POINT_it);
}
-LCRYPTO_ALIAS(DIST_POINT_free)
+LCRYPTO_ALIAS(DIST_POINT_free);
static const ASN1_TEMPLATE CRL_DIST_POINTS_item_tt = {
.flags = ASN1_TFLG_SEQUENCE_OF,
return (CRL_DIST_POINTS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&CRL_DIST_POINTS_it);
}
-LCRYPTO_ALIAS(d2i_CRL_DIST_POINTS)
+LCRYPTO_ALIAS(d2i_CRL_DIST_POINTS);
int
i2d_CRL_DIST_POINTS(CRL_DIST_POINTS *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &CRL_DIST_POINTS_it);
}
-LCRYPTO_ALIAS(i2d_CRL_DIST_POINTS)
+LCRYPTO_ALIAS(i2d_CRL_DIST_POINTS);
CRL_DIST_POINTS *
CRL_DIST_POINTS_new(void)
{
return (CRL_DIST_POINTS *)ASN1_item_new(&CRL_DIST_POINTS_it);
}
-LCRYPTO_ALIAS(CRL_DIST_POINTS_new)
+LCRYPTO_ALIAS(CRL_DIST_POINTS_new);
void
CRL_DIST_POINTS_free(CRL_DIST_POINTS *a)
{
ASN1_item_free((ASN1_VALUE *)a, &CRL_DIST_POINTS_it);
}
-LCRYPTO_ALIAS(CRL_DIST_POINTS_free)
+LCRYPTO_ALIAS(CRL_DIST_POINTS_free);
static const ASN1_TEMPLATE ISSUING_DIST_POINT_seq_tt[] = {
{
return (ISSUING_DIST_POINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ISSUING_DIST_POINT_it);
}
-LCRYPTO_ALIAS(d2i_ISSUING_DIST_POINT)
+LCRYPTO_ALIAS(d2i_ISSUING_DIST_POINT);
int
i2d_ISSUING_DIST_POINT(ISSUING_DIST_POINT *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ISSUING_DIST_POINT_it);
}
-LCRYPTO_ALIAS(i2d_ISSUING_DIST_POINT)
+LCRYPTO_ALIAS(i2d_ISSUING_DIST_POINT);
ISSUING_DIST_POINT *
ISSUING_DIST_POINT_new(void)
{
return (ISSUING_DIST_POINT *)ASN1_item_new(&ISSUING_DIST_POINT_it);
}
-LCRYPTO_ALIAS(ISSUING_DIST_POINT_new)
+LCRYPTO_ALIAS(ISSUING_DIST_POINT_new);
void
ISSUING_DIST_POINT_free(ISSUING_DIST_POINT *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ISSUING_DIST_POINT_it);
}
-LCRYPTO_ALIAS(ISSUING_DIST_POINT_free)
+LCRYPTO_ALIAS(ISSUING_DIST_POINT_free);
static int i2r_idp(const X509V3_EXT_METHOD *method, void *pidp, BIO *out,
int indent);
}
return 1;
}
-LCRYPTO_ALIAS(DIST_POINT_set_dpname)
+LCRYPTO_ALIAS(DIST_POINT_set_dpname);
-/* $OpenBSD: x509_d2.c,v 1.11 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_d2.c,v 1.12 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (1);
}
-LCRYPTO_ALIAS(X509_STORE_set_default_paths)
+LCRYPTO_ALIAS(X509_STORE_set_default_paths);
int
X509_STORE_load_locations(X509_STORE *ctx, const char *file, const char *path)
return (0);
return (1);
}
-LCRYPTO_ALIAS(X509_STORE_load_locations)
+LCRYPTO_ALIAS(X509_STORE_load_locations);
int
X509_STORE_load_mem(X509_STORE *ctx, void *buf, int len)
return (1);
}
-LCRYPTO_ALIAS(X509_STORE_load_mem)
+LCRYPTO_ALIAS(X509_STORE_load_mem);
-/* $OpenBSD: x509_def.c,v 1.6 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_def.c,v 1.7 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
{
return (X509_PRIVATE_DIR);
}
-LCRYPTO_ALIAS(X509_get_default_private_dir)
+LCRYPTO_ALIAS(X509_get_default_private_dir);
const char *
X509_get_default_cert_area(void)
{
return (X509_CERT_AREA);
}
-LCRYPTO_ALIAS(X509_get_default_cert_area)
+LCRYPTO_ALIAS(X509_get_default_cert_area);
const char *
X509_get_default_cert_dir(void)
{
return (X509_CERT_DIR);
}
-LCRYPTO_ALIAS(X509_get_default_cert_dir)
+LCRYPTO_ALIAS(X509_get_default_cert_dir);
const char *
X509_get_default_cert_file(void)
{
return (X509_CERT_FILE);
}
-LCRYPTO_ALIAS(X509_get_default_cert_file)
+LCRYPTO_ALIAS(X509_get_default_cert_file);
const char *
X509_get_default_cert_dir_env(void)
{
return (X509_CERT_DIR_EVP);
}
-LCRYPTO_ALIAS(X509_get_default_cert_dir_env)
+LCRYPTO_ALIAS(X509_get_default_cert_dir_env);
const char *
X509_get_default_cert_file_env(void)
{
return (X509_CERT_FILE_EVP);
}
-LCRYPTO_ALIAS(X509_get_default_cert_file_env)
+LCRYPTO_ALIAS(X509_get_default_cert_file_env);
-/* $OpenBSD: x509_enum.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_enum.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
}
return i2s_ASN1_ENUMERATED(method, e);
}
-LCRYPTO_ALIAS(i2s_ASN1_ENUMERATED_TABLE)
+LCRYPTO_ALIAS(i2s_ASN1_ENUMERATED_TABLE);
-/* $OpenBSD: x509_err.c,v 1.18 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_err.c,v 1.19 2023/02/16 08:38:17 tb Exp $ */
/* ====================================================================
* Copyright (c) 1999-2006 The OpenSSL Project. All rights reserved.
*
}
#endif
}
-LCRYPTO_ALIAS(ERR_load_X509_strings)
+LCRYPTO_ALIAS(ERR_load_X509_strings);
void
}
#endif
}
-LCRYPTO_ALIAS(ERR_load_X509V3_strings)
+LCRYPTO_ALIAS(ERR_load_X509V3_strings);
-/* $OpenBSD: x509_ext.c,v 1.15 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: x509_ext.c,v 1.16 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
{
return (X509v3_get_ext_count(x->crl->extensions));
}
-LCRYPTO_ALIAS(X509_CRL_get_ext_count)
+LCRYPTO_ALIAS(X509_CRL_get_ext_count);
int
X509_CRL_get_ext_by_NID(const X509_CRL *x, int nid, int lastpos)
{
return (X509v3_get_ext_by_NID(x->crl->extensions, nid, lastpos));
}
-LCRYPTO_ALIAS(X509_CRL_get_ext_by_NID)
+LCRYPTO_ALIAS(X509_CRL_get_ext_by_NID);
int
X509_CRL_get_ext_by_OBJ(const X509_CRL *x, const ASN1_OBJECT *obj, int lastpos)
{
return (X509v3_get_ext_by_OBJ(x->crl->extensions, obj, lastpos));
}
-LCRYPTO_ALIAS(X509_CRL_get_ext_by_OBJ)
+LCRYPTO_ALIAS(X509_CRL_get_ext_by_OBJ);
int
X509_CRL_get_ext_by_critical(const X509_CRL *x, int crit, int lastpos)
{
return (X509v3_get_ext_by_critical(x->crl->extensions, crit, lastpos));
}
-LCRYPTO_ALIAS(X509_CRL_get_ext_by_critical)
+LCRYPTO_ALIAS(X509_CRL_get_ext_by_critical);
X509_EXTENSION *
X509_CRL_get_ext(const X509_CRL *x, int loc)
{
return (X509v3_get_ext(x->crl->extensions, loc));
}
-LCRYPTO_ALIAS(X509_CRL_get_ext)
+LCRYPTO_ALIAS(X509_CRL_get_ext);
X509_EXTENSION *
X509_CRL_delete_ext(X509_CRL *x, int loc)
{
return (X509v3_delete_ext(x->crl->extensions, loc));
}
-LCRYPTO_ALIAS(X509_CRL_delete_ext)
+LCRYPTO_ALIAS(X509_CRL_delete_ext);
void *
X509_CRL_get_ext_d2i(const X509_CRL *x, int nid, int *crit, int *idx)
{
return X509V3_get_d2i(x->crl->extensions, nid, crit, idx);
}
-LCRYPTO_ALIAS(X509_CRL_get_ext_d2i)
+LCRYPTO_ALIAS(X509_CRL_get_ext_d2i);
int
X509_CRL_add1_ext_i2d(X509_CRL *x, int nid, void *value, int crit,
{
return X509V3_add1_i2d(&x->crl->extensions, nid, value, crit, flags);
}
-LCRYPTO_ALIAS(X509_CRL_add1_ext_i2d)
+LCRYPTO_ALIAS(X509_CRL_add1_ext_i2d);
int
X509_CRL_add_ext(X509_CRL *x, X509_EXTENSION *ex, int loc)
{
return (X509v3_add_ext(&(x->crl->extensions), ex, loc) != NULL);
}
-LCRYPTO_ALIAS(X509_CRL_add_ext)
+LCRYPTO_ALIAS(X509_CRL_add_ext);
int
X509_get_ext_count(const X509 *x)
{
return (X509v3_get_ext_count(x->cert_info->extensions));
}
-LCRYPTO_ALIAS(X509_get_ext_count)
+LCRYPTO_ALIAS(X509_get_ext_count);
int
X509_get_ext_by_NID(const X509 *x, int nid, int lastpos)
{
return (X509v3_get_ext_by_NID(x->cert_info->extensions, nid, lastpos));
}
-LCRYPTO_ALIAS(X509_get_ext_by_NID)
+LCRYPTO_ALIAS(X509_get_ext_by_NID);
int
X509_get_ext_by_OBJ(const X509 *x, const ASN1_OBJECT *obj, int lastpos)
{
return (X509v3_get_ext_by_OBJ(x->cert_info->extensions, obj, lastpos));
}
-LCRYPTO_ALIAS(X509_get_ext_by_OBJ)
+LCRYPTO_ALIAS(X509_get_ext_by_OBJ);
int
X509_get_ext_by_critical(const X509 *x, int crit, int lastpos)
return (X509v3_get_ext_by_critical(x->cert_info->extensions, crit,
lastpos));
}
-LCRYPTO_ALIAS(X509_get_ext_by_critical)
+LCRYPTO_ALIAS(X509_get_ext_by_critical);
X509_EXTENSION *
X509_get_ext(const X509 *x, int loc)
{
return (X509v3_get_ext(x->cert_info->extensions, loc));
}
-LCRYPTO_ALIAS(X509_get_ext)
+LCRYPTO_ALIAS(X509_get_ext);
X509_EXTENSION *
X509_delete_ext(X509 *x, int loc)
{
return (X509v3_delete_ext(x->cert_info->extensions, loc));
}
-LCRYPTO_ALIAS(X509_delete_ext)
+LCRYPTO_ALIAS(X509_delete_ext);
int
X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc)
{
return (X509v3_add_ext(&(x->cert_info->extensions), ex, loc) != NULL);
}
-LCRYPTO_ALIAS(X509_add_ext)
+LCRYPTO_ALIAS(X509_add_ext);
void *
X509_get_ext_d2i(const X509 *x, int nid, int *crit, int *idx)
{
return X509V3_get_d2i(x->cert_info->extensions, nid, crit, idx);
}
-LCRYPTO_ALIAS(X509_get_ext_d2i)
+LCRYPTO_ALIAS(X509_get_ext_d2i);
int
X509_add1_ext_i2d(X509 *x, int nid, void *value, int crit, unsigned long flags)
return X509V3_add1_i2d(&x->cert_info->extensions, nid, value, crit,
flags);
}
-LCRYPTO_ALIAS(X509_add1_ext_i2d)
+LCRYPTO_ALIAS(X509_add1_ext_i2d);
int
X509_REVOKED_get_ext_count(const X509_REVOKED *x)
{
return (X509v3_get_ext_count(x->extensions));
}
-LCRYPTO_ALIAS(X509_REVOKED_get_ext_count)
+LCRYPTO_ALIAS(X509_REVOKED_get_ext_count);
int
X509_REVOKED_get_ext_by_NID(const X509_REVOKED *x, int nid, int lastpos)
{
return (X509v3_get_ext_by_NID(x->extensions, nid, lastpos));
}
-LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_NID)
+LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_NID);
int
X509_REVOKED_get_ext_by_OBJ(const X509_REVOKED *x, const ASN1_OBJECT *obj,
{
return (X509v3_get_ext_by_OBJ(x->extensions, obj, lastpos));
}
-LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_OBJ)
+LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_OBJ);
int
X509_REVOKED_get_ext_by_critical(const X509_REVOKED *x, int crit, int lastpos)
{
return (X509v3_get_ext_by_critical(x->extensions, crit, lastpos));
}
-LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_critical)
+LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_critical);
X509_EXTENSION *
X509_REVOKED_get_ext(const X509_REVOKED *x, int loc)
{
return (X509v3_get_ext(x->extensions, loc));
}
-LCRYPTO_ALIAS(X509_REVOKED_get_ext)
+LCRYPTO_ALIAS(X509_REVOKED_get_ext);
X509_EXTENSION *
X509_REVOKED_delete_ext(X509_REVOKED *x, int loc)
{
return (X509v3_delete_ext(x->extensions, loc));
}
-LCRYPTO_ALIAS(X509_REVOKED_delete_ext)
+LCRYPTO_ALIAS(X509_REVOKED_delete_ext);
int
X509_REVOKED_add_ext(X509_REVOKED *x, X509_EXTENSION *ex, int loc)
{
return (X509v3_add_ext(&(x->extensions), ex, loc) != NULL);
}
-LCRYPTO_ALIAS(X509_REVOKED_add_ext)
+LCRYPTO_ALIAS(X509_REVOKED_add_ext);
void *
X509_REVOKED_get_ext_d2i(const X509_REVOKED *x, int nid, int *crit, int *idx)
{
return X509V3_get_d2i(x->extensions, nid, crit, idx);
}
-LCRYPTO_ALIAS(X509_REVOKED_get_ext_d2i)
+LCRYPTO_ALIAS(X509_REVOKED_get_ext_d2i);
int
X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit,
{
return X509V3_add1_i2d(&x->extensions, nid, value, crit, flags);
}
-LCRYPTO_ALIAS(X509_REVOKED_add1_ext_i2d)
+LCRYPTO_ALIAS(X509_REVOKED_add1_ext_i2d);
-/* $OpenBSD: x509_extku.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_extku.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return (EXTENDED_KEY_USAGE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&EXTENDED_KEY_USAGE_it);
}
-LCRYPTO_ALIAS(d2i_EXTENDED_KEY_USAGE)
+LCRYPTO_ALIAS(d2i_EXTENDED_KEY_USAGE);
int
i2d_EXTENDED_KEY_USAGE(EXTENDED_KEY_USAGE *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &EXTENDED_KEY_USAGE_it);
}
-LCRYPTO_ALIAS(i2d_EXTENDED_KEY_USAGE)
+LCRYPTO_ALIAS(i2d_EXTENDED_KEY_USAGE);
EXTENDED_KEY_USAGE *
EXTENDED_KEY_USAGE_new(void)
{
return (EXTENDED_KEY_USAGE *)ASN1_item_new(&EXTENDED_KEY_USAGE_it);
}
-LCRYPTO_ALIAS(EXTENDED_KEY_USAGE_new)
+LCRYPTO_ALIAS(EXTENDED_KEY_USAGE_new);
void
EXTENDED_KEY_USAGE_free(EXTENDED_KEY_USAGE *a)
{
ASN1_item_free((ASN1_VALUE *)a, &EXTENDED_KEY_USAGE_it);
}
-LCRYPTO_ALIAS(EXTENDED_KEY_USAGE_free)
+LCRYPTO_ALIAS(EXTENDED_KEY_USAGE_free);
static STACK_OF(CONF_VALUE) *
i2v_EXTENDED_KEY_USAGE(const X509V3_EXT_METHOD *method, void *a,
-/* $OpenBSD: x509_genn.c,v 1.4 2023/02/07 15:46:58 tb Exp $ */
+/* $OpenBSD: x509_genn.c,v 1.5 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return (OTHERNAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&OTHERNAME_it);
}
-LCRYPTO_ALIAS(d2i_OTHERNAME)
+LCRYPTO_ALIAS(d2i_OTHERNAME);
int
i2d_OTHERNAME(OTHERNAME *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &OTHERNAME_it);
}
-LCRYPTO_ALIAS(i2d_OTHERNAME)
+LCRYPTO_ALIAS(i2d_OTHERNAME);
OTHERNAME *
OTHERNAME_new(void)
{
return (OTHERNAME *)ASN1_item_new(&OTHERNAME_it);
}
-LCRYPTO_ALIAS(OTHERNAME_new)
+LCRYPTO_ALIAS(OTHERNAME_new);
void
OTHERNAME_free(OTHERNAME *a)
{
ASN1_item_free((ASN1_VALUE *)a, &OTHERNAME_it);
}
-LCRYPTO_ALIAS(OTHERNAME_free)
+LCRYPTO_ALIAS(OTHERNAME_free);
/* Uses explicit tagging since DIRECTORYSTRING is a CHOICE type */
static const ASN1_TEMPLATE EDIPARTYNAME_seq_tt[] = {
return (EDIPARTYNAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&EDIPARTYNAME_it);
}
-LCRYPTO_ALIAS(d2i_EDIPARTYNAME)
+LCRYPTO_ALIAS(d2i_EDIPARTYNAME);
int
i2d_EDIPARTYNAME(EDIPARTYNAME *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &EDIPARTYNAME_it);
}
-LCRYPTO_ALIAS(i2d_EDIPARTYNAME)
+LCRYPTO_ALIAS(i2d_EDIPARTYNAME);
EDIPARTYNAME *
EDIPARTYNAME_new(void)
{
return (EDIPARTYNAME *)ASN1_item_new(&EDIPARTYNAME_it);
}
-LCRYPTO_ALIAS(EDIPARTYNAME_new)
+LCRYPTO_ALIAS(EDIPARTYNAME_new);
void
EDIPARTYNAME_free(EDIPARTYNAME *a)
{
ASN1_item_free((ASN1_VALUE *)a, &EDIPARTYNAME_it);
}
-LCRYPTO_ALIAS(EDIPARTYNAME_free)
+LCRYPTO_ALIAS(EDIPARTYNAME_free);
static const ASN1_TEMPLATE GENERAL_NAME_ch_tt[] = {
{
return (GENERAL_NAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&GENERAL_NAME_it);
}
-LCRYPTO_ALIAS(d2i_GENERAL_NAME)
+LCRYPTO_ALIAS(d2i_GENERAL_NAME);
int
i2d_GENERAL_NAME(GENERAL_NAME *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &GENERAL_NAME_it);
}
-LCRYPTO_ALIAS(i2d_GENERAL_NAME)
+LCRYPTO_ALIAS(i2d_GENERAL_NAME);
GENERAL_NAME *
GENERAL_NAME_new(void)
{
return (GENERAL_NAME *)ASN1_item_new(&GENERAL_NAME_it);
}
-LCRYPTO_ALIAS(GENERAL_NAME_new)
+LCRYPTO_ALIAS(GENERAL_NAME_new);
void
GENERAL_NAME_free(GENERAL_NAME *a)
{
ASN1_item_free((ASN1_VALUE *)a, &GENERAL_NAME_it);
}
-LCRYPTO_ALIAS(GENERAL_NAME_free)
+LCRYPTO_ALIAS(GENERAL_NAME_free);
static const ASN1_TEMPLATE GENERAL_NAMES_item_tt = {
.flags = ASN1_TFLG_SEQUENCE_OF,
return (GENERAL_NAMES *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&GENERAL_NAMES_it);
}
-LCRYPTO_ALIAS(d2i_GENERAL_NAMES)
+LCRYPTO_ALIAS(d2i_GENERAL_NAMES);
int
i2d_GENERAL_NAMES(GENERAL_NAMES *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &GENERAL_NAMES_it);
}
-LCRYPTO_ALIAS(i2d_GENERAL_NAMES)
+LCRYPTO_ALIAS(i2d_GENERAL_NAMES);
GENERAL_NAMES *
GENERAL_NAMES_new(void)
{
return (GENERAL_NAMES *)ASN1_item_new(&GENERAL_NAMES_it);
}
-LCRYPTO_ALIAS(GENERAL_NAMES_new)
+LCRYPTO_ALIAS(GENERAL_NAMES_new);
void
GENERAL_NAMES_free(GENERAL_NAMES *a)
{
ASN1_item_free((ASN1_VALUE *)a, &GENERAL_NAMES_it);
}
-LCRYPTO_ALIAS(GENERAL_NAMES_free)
+LCRYPTO_ALIAS(GENERAL_NAMES_free);
GENERAL_NAME *
GENERAL_NAME_dup(GENERAL_NAME *a)
{
return ASN1_item_dup(&GENERAL_NAME_it, a);
}
-LCRYPTO_ALIAS(GENERAL_NAME_dup)
+LCRYPTO_ALIAS(GENERAL_NAME_dup);
static int
EDIPARTYNAME_cmp(const EDIPARTYNAME *a, const EDIPARTYNAME *b)
}
return result;
}
-LCRYPTO_ALIAS(GENERAL_NAME_cmp)
+LCRYPTO_ALIAS(GENERAL_NAME_cmp);
/* Returns 0 if they are equal, != 0 otherwise. */
int
result = ASN1_TYPE_cmp(a->value, b->value);
return result;
}
-LCRYPTO_ALIAS(OTHERNAME_cmp)
+LCRYPTO_ALIAS(OTHERNAME_cmp);
void
GENERAL_NAME_set0_value(GENERAL_NAME *a, int type, void *value)
}
a->type = type;
}
-LCRYPTO_ALIAS(GENERAL_NAME_set0_value)
+LCRYPTO_ALIAS(GENERAL_NAME_set0_value);
void *
GENERAL_NAME_get0_value(GENERAL_NAME *a, int *ptype)
return NULL;
}
}
-LCRYPTO_ALIAS(GENERAL_NAME_get0_value)
+LCRYPTO_ALIAS(GENERAL_NAME_get0_value);
int
GENERAL_NAME_set0_othername(GENERAL_NAME *gen, ASN1_OBJECT *oid,
GENERAL_NAME_set0_value(gen, GEN_OTHERNAME, oth);
return 1;
}
-LCRYPTO_ALIAS(GENERAL_NAME_set0_othername)
+LCRYPTO_ALIAS(GENERAL_NAME_set0_othername);
int
GENERAL_NAME_get0_otherName(GENERAL_NAME *gen, ASN1_OBJECT **poid,
*pvalue = gen->d.otherName->value;
return 1;
}
-LCRYPTO_ALIAS(GENERAL_NAME_get0_otherName)
+LCRYPTO_ALIAS(GENERAL_NAME_get0_otherName);
-/* $OpenBSD: x509_info.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_info.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return (ACCESS_DESCRIPTION *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ACCESS_DESCRIPTION_it);
}
-LCRYPTO_ALIAS(d2i_ACCESS_DESCRIPTION)
+LCRYPTO_ALIAS(d2i_ACCESS_DESCRIPTION);
int
i2d_ACCESS_DESCRIPTION(ACCESS_DESCRIPTION *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ACCESS_DESCRIPTION_it);
}
-LCRYPTO_ALIAS(i2d_ACCESS_DESCRIPTION)
+LCRYPTO_ALIAS(i2d_ACCESS_DESCRIPTION);
ACCESS_DESCRIPTION *
ACCESS_DESCRIPTION_new(void)
{
return (ACCESS_DESCRIPTION *)ASN1_item_new(&ACCESS_DESCRIPTION_it);
}
-LCRYPTO_ALIAS(ACCESS_DESCRIPTION_new)
+LCRYPTO_ALIAS(ACCESS_DESCRIPTION_new);
void
ACCESS_DESCRIPTION_free(ACCESS_DESCRIPTION *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ACCESS_DESCRIPTION_it);
}
-LCRYPTO_ALIAS(ACCESS_DESCRIPTION_free)
+LCRYPTO_ALIAS(ACCESS_DESCRIPTION_free);
static const ASN1_TEMPLATE AUTHORITY_INFO_ACCESS_item_tt = {
.flags = ASN1_TFLG_SEQUENCE_OF,
return (AUTHORITY_INFO_ACCESS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&AUTHORITY_INFO_ACCESS_it);
}
-LCRYPTO_ALIAS(d2i_AUTHORITY_INFO_ACCESS)
+LCRYPTO_ALIAS(d2i_AUTHORITY_INFO_ACCESS);
int
i2d_AUTHORITY_INFO_ACCESS(AUTHORITY_INFO_ACCESS *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &AUTHORITY_INFO_ACCESS_it);
}
-LCRYPTO_ALIAS(i2d_AUTHORITY_INFO_ACCESS)
+LCRYPTO_ALIAS(i2d_AUTHORITY_INFO_ACCESS);
AUTHORITY_INFO_ACCESS *
AUTHORITY_INFO_ACCESS_new(void)
{
return (AUTHORITY_INFO_ACCESS *)ASN1_item_new(&AUTHORITY_INFO_ACCESS_it);
}
-LCRYPTO_ALIAS(AUTHORITY_INFO_ACCESS_new)
+LCRYPTO_ALIAS(AUTHORITY_INFO_ACCESS_new);
void
AUTHORITY_INFO_ACCESS_free(AUTHORITY_INFO_ACCESS *a)
{
ASN1_item_free((ASN1_VALUE *)a, &AUTHORITY_INFO_ACCESS_it);
}
-LCRYPTO_ALIAS(AUTHORITY_INFO_ACCESS_free)
+LCRYPTO_ALIAS(AUTHORITY_INFO_ACCESS_free);
static STACK_OF(CONF_VALUE) *
i2v_AUTHORITY_INFO_ACCESS(X509V3_EXT_METHOD *method,
i2a_ASN1_OBJECT(bp, a->method);
return 2;
}
-LCRYPTO_ALIAS(i2a_ACCESS_DESCRIPTION)
+LCRYPTO_ALIAS(i2a_ACCESS_DESCRIPTION);
-/* $OpenBSD: x509_lib.c,v 1.6 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: x509_lib.c,v 1.7 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
}
return 1;
}
-LCRYPTO_ALIAS(X509V3_EXT_add)
+LCRYPTO_ALIAS(X509V3_EXT_add);
static int
ext_cmp(const X509V3_EXT_METHOD * const *a, const X509V3_EXT_METHOD * const *b)
return NULL;
return sk_X509V3_EXT_METHOD_value(ext_list, idx);
}
-LCRYPTO_ALIAS(X509V3_EXT_get_nid)
+LCRYPTO_ALIAS(X509V3_EXT_get_nid);
const X509V3_EXT_METHOD *
X509V3_EXT_get(X509_EXTENSION *ext)
return NULL;
return X509V3_EXT_get_nid(nid);
}
-LCRYPTO_ALIAS(X509V3_EXT_get)
+LCRYPTO_ALIAS(X509V3_EXT_get);
int
X509V3_EXT_add_list(X509V3_EXT_METHOD *extlist)
return 0;
return 1;
}
-LCRYPTO_ALIAS(X509V3_EXT_add_list)
+LCRYPTO_ALIAS(X509V3_EXT_add_list);
int
X509V3_EXT_add_alias(int nid_to, int nid_from)
}
return 1;
}
-LCRYPTO_ALIAS(X509V3_EXT_add_alias)
+LCRYPTO_ALIAS(X509V3_EXT_add_alias);
void
X509V3_EXT_cleanup(void)
sk_X509V3_EXT_METHOD_pop_free(ext_list, ext_list_free);
ext_list = NULL;
}
-LCRYPTO_ALIAS(X509V3_EXT_cleanup)
+LCRYPTO_ALIAS(X509V3_EXT_cleanup);
static void
ext_list_free(X509V3_EXT_METHOD *ext)
{
return 1;
}
-LCRYPTO_ALIAS(X509V3_add_standard_extensions)
+LCRYPTO_ALIAS(X509V3_add_standard_extensions);
/* Return an extension internal structure */
method->it);
return method->d2i(NULL, &p, ext->value->length);
}
-LCRYPTO_ALIAS(X509V3_EXT_d2i)
+LCRYPTO_ALIAS(X509V3_EXT_d2i);
/* Get critical flag and decoded version of extension from a NID.
* The "idx" variable returns the last found extension and can
*crit = -1;
return NULL;
}
-LCRYPTO_ALIAS(X509V3_get_d2i)
+LCRYPTO_ALIAS(X509V3_get_d2i);
/* This function is a general extension append, replace and delete utility.
* The precise operation is governed by the 'flags' value. The 'crit' and
X509V3error(errcode);
return 0;
}
-LCRYPTO_ALIAS(X509V3_add1_i2d)
+LCRYPTO_ALIAS(X509V3_add1_i2d);
-/* $OpenBSD: x509_lu.c,v 1.57 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: x509_lu.c,v 1.58 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return lu;
}
-LCRYPTO_ALIAS(X509_LOOKUP_new)
+LCRYPTO_ALIAS(X509_LOOKUP_new);
void
X509_LOOKUP_free(X509_LOOKUP *ctx)
ctx->method->free(ctx);
free(ctx);
}
-LCRYPTO_ALIAS(X509_LOOKUP_free)
+LCRYPTO_ALIAS(X509_LOOKUP_free);
int
X509_LOOKUP_init(X509_LOOKUP *ctx)
return 1;
return ctx->method->init(ctx);
}
-LCRYPTO_ALIAS(X509_LOOKUP_init)
+LCRYPTO_ALIAS(X509_LOOKUP_init);
int
X509_LOOKUP_shutdown(X509_LOOKUP *ctx)
return 1;
return ctx->method->shutdown(ctx);
}
-LCRYPTO_ALIAS(X509_LOOKUP_shutdown)
+LCRYPTO_ALIAS(X509_LOOKUP_shutdown);
int
X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, long argl,
return 1;
return ctx->method->ctrl(ctx, cmd, argc, argl, ret);
}
-LCRYPTO_ALIAS(X509_LOOKUP_ctrl)
+LCRYPTO_ALIAS(X509_LOOKUP_ctrl);
int
X509_LOOKUP_by_subject(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, X509_NAME *name,
return 0;
return ctx->method->get_by_subject(ctx, type, name, ret);
}
-LCRYPTO_ALIAS(X509_LOOKUP_by_subject)
+LCRYPTO_ALIAS(X509_LOOKUP_by_subject);
int
X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
return 0;
return ctx->method->get_by_issuer_serial(ctx, type, name, serial, ret);
}
-LCRYPTO_ALIAS(X509_LOOKUP_by_issuer_serial)
+LCRYPTO_ALIAS(X509_LOOKUP_by_issuer_serial);
int
X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
return 0;
return ctx->method->get_by_fingerprint(ctx, type, bytes, len, ret);
}
-LCRYPTO_ALIAS(X509_LOOKUP_by_fingerprint)
+LCRYPTO_ALIAS(X509_LOOKUP_by_fingerprint);
int
X509_LOOKUP_by_alias(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, const char *str,
return 0;
return ctx->method->get_by_alias(ctx, type, str, len, ret);
}
-LCRYPTO_ALIAS(X509_LOOKUP_by_alias)
+LCRYPTO_ALIAS(X509_LOOKUP_by_alias);
static int
x509_object_cmp(const X509_OBJECT * const *a, const X509_OBJECT * const *b)
return NULL;
}
-LCRYPTO_ALIAS(X509_STORE_new)
+LCRYPTO_ALIAS(X509_STORE_new);
X509_OBJECT *
X509_OBJECT_new(void)
return obj;
}
-LCRYPTO_ALIAS(X509_OBJECT_new)
+LCRYPTO_ALIAS(X509_OBJECT_new);
void
X509_OBJECT_free(X509_OBJECT *a)
free(a);
}
-LCRYPTO_ALIAS(X509_OBJECT_free)
+LCRYPTO_ALIAS(X509_OBJECT_free);
void
X509_STORE_free(X509_STORE *store)
X509_VERIFY_PARAM_free(store->param);
free(store);
}
-LCRYPTO_ALIAS(X509_STORE_free)
+LCRYPTO_ALIAS(X509_STORE_free);
int
X509_STORE_up_ref(X509_STORE *store)
{
return CRYPTO_add(&store->references, 1, CRYPTO_LOCK_X509_STORE) > 1;
}
-LCRYPTO_ALIAS(X509_STORE_up_ref)
+LCRYPTO_ALIAS(X509_STORE_up_ref);
X509_LOOKUP *
X509_STORE_add_lookup(X509_STORE *store, X509_LOOKUP_METHOD *method)
return lu;
}
-LCRYPTO_ALIAS(X509_STORE_add_lookup)
+LCRYPTO_ALIAS(X509_STORE_add_lookup);
X509_OBJECT *
X509_STORE_CTX_get_obj_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type,
return obj;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get_obj_by_subject)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_obj_by_subject);
int
X509_STORE_CTX_get_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type,
return 1;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get_by_subject)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_by_subject);
/* Add obj to the store. Takes ownership of obj. */
static int
return X509_STORE_add_object(store, obj);
}
-LCRYPTO_ALIAS(X509_STORE_add_cert)
+LCRYPTO_ALIAS(X509_STORE_add_cert);
int
X509_STORE_add_crl(X509_STORE *store, X509_CRL *x)
return X509_STORE_add_object(store, obj);
}
-LCRYPTO_ALIAS(X509_STORE_add_crl)
+LCRYPTO_ALIAS(X509_STORE_add_crl);
int
X509_OBJECT_up_ref_count(X509_OBJECT *a)
}
return 1;
}
-LCRYPTO_ALIAS(X509_OBJECT_up_ref_count)
+LCRYPTO_ALIAS(X509_OBJECT_up_ref_count);
X509_LOOKUP_TYPE
X509_OBJECT_get_type(const X509_OBJECT *a)
{
return a->type;
}
-LCRYPTO_ALIAS(X509_OBJECT_get_type)
+LCRYPTO_ALIAS(X509_OBJECT_get_type);
static int
x509_object_idx_cnt(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type,
{
return x509_object_idx_cnt(h, type, name, NULL);
}
-LCRYPTO_ALIAS(X509_OBJECT_idx_by_subject)
+LCRYPTO_ALIAS(X509_OBJECT_idx_by_subject);
X509_OBJECT *
X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type,
return NULL;
return sk_X509_OBJECT_value(h, idx);
}
-LCRYPTO_ALIAS(X509_OBJECT_retrieve_by_subject)
+LCRYPTO_ALIAS(X509_OBJECT_retrieve_by_subject);
X509 *
X509_OBJECT_get0_X509(const X509_OBJECT *xo)
return xo->data.x509;
return NULL;
}
-LCRYPTO_ALIAS(X509_OBJECT_get0_X509)
+LCRYPTO_ALIAS(X509_OBJECT_get0_X509);
X509_CRL *
X509_OBJECT_get0_X509_CRL(X509_OBJECT *xo)
return xo->data.crl;
return NULL;
}
-LCRYPTO_ALIAS(X509_OBJECT_get0_X509_CRL)
+LCRYPTO_ALIAS(X509_OBJECT_get0_X509_CRL);
static STACK_OF(X509) *
X509_get1_certs_from_cache(X509_STORE *store, X509_NAME *name)
return X509_get1_certs_from_cache(store, name);
}
-LCRYPTO_ALIAS(X509_STORE_get1_certs)
+LCRYPTO_ALIAS(X509_STORE_get1_certs);
STACK_OF(X509_CRL) *
X509_STORE_get1_crls(X509_STORE_CTX *ctx, X509_NAME *name)
sk_X509_CRL_pop_free(sk, X509_CRL_free);
return NULL;
}
-LCRYPTO_ALIAS(X509_STORE_get1_crls)
+LCRYPTO_ALIAS(X509_STORE_get1_crls);
X509_OBJECT *
X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h, X509_OBJECT *x)
}
return NULL;
}
-LCRYPTO_ALIAS(X509_OBJECT_retrieve_match)
+LCRYPTO_ALIAS(X509_OBJECT_retrieve_match);
/* Try to get issuer certificate from store. Due to limitations
* of the API this can only retrieve a single certificate matching
CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
return ret;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get1_issuer)
+LCRYPTO_ALIAS(X509_STORE_CTX_get1_issuer);
STACK_OF(X509_OBJECT) *
X509_STORE_get0_objects(X509_STORE *xs)
{
return xs->objs;
}
-LCRYPTO_ALIAS(X509_STORE_get0_objects)
+LCRYPTO_ALIAS(X509_STORE_get0_objects);
void *
X509_STORE_get_ex_data(X509_STORE *xs, int idx)
{
return CRYPTO_get_ex_data(&xs->ex_data, idx);
}
-LCRYPTO_ALIAS(X509_STORE_get_ex_data)
+LCRYPTO_ALIAS(X509_STORE_get_ex_data);
int
X509_STORE_set_ex_data(X509_STORE *xs, int idx, void *data)
{
return CRYPTO_set_ex_data(&xs->ex_data, idx, data);
}
-LCRYPTO_ALIAS(X509_STORE_set_ex_data)
+LCRYPTO_ALIAS(X509_STORE_set_ex_data);
int
X509_STORE_set_flags(X509_STORE *ctx, unsigned long flags)
{
return X509_VERIFY_PARAM_set_flags(ctx->param, flags);
}
-LCRYPTO_ALIAS(X509_STORE_set_flags)
+LCRYPTO_ALIAS(X509_STORE_set_flags);
int
X509_STORE_set_depth(X509_STORE *ctx, int depth)
X509_VERIFY_PARAM_set_depth(ctx->param, depth);
return 1;
}
-LCRYPTO_ALIAS(X509_STORE_set_depth)
+LCRYPTO_ALIAS(X509_STORE_set_depth);
int
X509_STORE_set_purpose(X509_STORE *ctx, int purpose)
{
return X509_VERIFY_PARAM_set_purpose(ctx->param, purpose);
}
-LCRYPTO_ALIAS(X509_STORE_set_purpose)
+LCRYPTO_ALIAS(X509_STORE_set_purpose);
int
X509_STORE_set_trust(X509_STORE *ctx, int trust)
{
return X509_VERIFY_PARAM_set_trust(ctx->param, trust);
}
-LCRYPTO_ALIAS(X509_STORE_set_trust)
+LCRYPTO_ALIAS(X509_STORE_set_trust);
int
X509_STORE_set1_param(X509_STORE *ctx, X509_VERIFY_PARAM *param)
{
return X509_VERIFY_PARAM_set1(ctx->param, param);
}
-LCRYPTO_ALIAS(X509_STORE_set1_param)
+LCRYPTO_ALIAS(X509_STORE_set1_param);
X509_VERIFY_PARAM *
X509_STORE_get0_param(X509_STORE *ctx)
{
return ctx->param;
}
-LCRYPTO_ALIAS(X509_STORE_get0_param)
+LCRYPTO_ALIAS(X509_STORE_get0_param);
void
X509_STORE_set_verify(X509_STORE *store, X509_STORE_CTX_verify_fn verify)
{
store->verify = verify;
}
-LCRYPTO_ALIAS(X509_STORE_set_verify)
+LCRYPTO_ALIAS(X509_STORE_set_verify);
X509_STORE_CTX_verify_fn
X509_STORE_get_verify(X509_STORE *store)
{
return store->verify;
}
-LCRYPTO_ALIAS(X509_STORE_get_verify)
+LCRYPTO_ALIAS(X509_STORE_get_verify);
void
X509_STORE_set_verify_cb(X509_STORE *store, X509_STORE_CTX_verify_cb verify_cb)
{
store->verify_cb = verify_cb;
}
-LCRYPTO_ALIAS(X509_STORE_set_verify_cb)
+LCRYPTO_ALIAS(X509_STORE_set_verify_cb);
X509_STORE_CTX_verify_cb
X509_STORE_get_verify_cb(X509_STORE *store)
{
return store->verify_cb;
}
-LCRYPTO_ALIAS(X509_STORE_get_verify_cb)
+LCRYPTO_ALIAS(X509_STORE_get_verify_cb);
-/* $OpenBSD: x509_ncons.c,v 1.8 2022/12/26 07:18:53 jmc Exp $ */
+/* $OpenBSD: x509_ncons.c,v 1.9 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project.
*/
{
return (GENERAL_SUBTREE*)ASN1_item_new(&GENERAL_SUBTREE_it);
}
-LCRYPTO_ALIAS(GENERAL_SUBTREE_new)
+LCRYPTO_ALIAS(GENERAL_SUBTREE_new);
void
GENERAL_SUBTREE_free(GENERAL_SUBTREE *a)
{
ASN1_item_free((ASN1_VALUE *)a, &GENERAL_SUBTREE_it);
}
-LCRYPTO_ALIAS(GENERAL_SUBTREE_free)
+LCRYPTO_ALIAS(GENERAL_SUBTREE_free);
NAME_CONSTRAINTS *
NAME_CONSTRAINTS_new(void)
{
return (NAME_CONSTRAINTS*)ASN1_item_new(&NAME_CONSTRAINTS_it);
}
-LCRYPTO_ALIAS(NAME_CONSTRAINTS_new)
+LCRYPTO_ALIAS(NAME_CONSTRAINTS_new);
void
NAME_CONSTRAINTS_free(NAME_CONSTRAINTS *a)
{
ASN1_item_free((ASN1_VALUE *)a, &NAME_CONSTRAINTS_it);
}
-LCRYPTO_ALIAS(NAME_CONSTRAINTS_free)
+LCRYPTO_ALIAS(NAME_CONSTRAINTS_free);
static void *
v2i_NAME_CONSTRAINTS(const X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
}
return X509_V_OK;
}
-LCRYPTO_ALIAS(NAME_CONSTRAINTS_check)
+LCRYPTO_ALIAS(NAME_CONSTRAINTS_check);
static int
nc_match(GENERAL_NAME *gen, NAME_CONSTRAINTS *nc)
{
-/* $OpenBSD: x509_obj.c,v 1.21 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509_obj.c,v 1.22 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
BUF_MEM_free(b);
return (NULL);
}
-LCRYPTO_ALIAS(X509_NAME_oneline)
+LCRYPTO_ALIAS(X509_NAME_oneline);
-/* $OpenBSD: x509_pcia.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_pcia.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
/* Contributed to the OpenSSL Project 2004
* by Richard Levitte (richard@levitte.org)
*/
return (PROXY_POLICY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PROXY_POLICY_it);
}
-LCRYPTO_ALIAS(d2i_PROXY_POLICY)
+LCRYPTO_ALIAS(d2i_PROXY_POLICY);
int
i2d_PROXY_POLICY(PROXY_POLICY *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PROXY_POLICY_it);
}
-LCRYPTO_ALIAS(i2d_PROXY_POLICY)
+LCRYPTO_ALIAS(i2d_PROXY_POLICY);
PROXY_POLICY *
PROXY_POLICY_new(void)
{
return (PROXY_POLICY *)ASN1_item_new(&PROXY_POLICY_it);
}
-LCRYPTO_ALIAS(PROXY_POLICY_new)
+LCRYPTO_ALIAS(PROXY_POLICY_new);
void
PROXY_POLICY_free(PROXY_POLICY *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PROXY_POLICY_it);
}
-LCRYPTO_ALIAS(PROXY_POLICY_free)
+LCRYPTO_ALIAS(PROXY_POLICY_free);
static const ASN1_TEMPLATE PROXY_CERT_INFO_EXTENSION_seq_tt[] = {
{
return (PROXY_CERT_INFO_EXTENSION *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PROXY_CERT_INFO_EXTENSION_it);
}
-LCRYPTO_ALIAS(d2i_PROXY_CERT_INFO_EXTENSION)
+LCRYPTO_ALIAS(d2i_PROXY_CERT_INFO_EXTENSION);
int
i2d_PROXY_CERT_INFO_EXTENSION(PROXY_CERT_INFO_EXTENSION *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PROXY_CERT_INFO_EXTENSION_it);
}
-LCRYPTO_ALIAS(i2d_PROXY_CERT_INFO_EXTENSION)
+LCRYPTO_ALIAS(i2d_PROXY_CERT_INFO_EXTENSION);
PROXY_CERT_INFO_EXTENSION *
PROXY_CERT_INFO_EXTENSION_new(void)
{
return (PROXY_CERT_INFO_EXTENSION *)ASN1_item_new(&PROXY_CERT_INFO_EXTENSION_it);
}
-LCRYPTO_ALIAS(PROXY_CERT_INFO_EXTENSION_new)
+LCRYPTO_ALIAS(PROXY_CERT_INFO_EXTENSION_new);
void
PROXY_CERT_INFO_EXTENSION_free(PROXY_CERT_INFO_EXTENSION *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PROXY_CERT_INFO_EXTENSION_it);
}
-LCRYPTO_ALIAS(PROXY_CERT_INFO_EXTENSION_free)
+LCRYPTO_ALIAS(PROXY_CERT_INFO_EXTENSION_free);
-/* $OpenBSD: x509_pcons.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_pcons.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project.
*/
{
return (POLICY_CONSTRAINTS*)ASN1_item_new(&POLICY_CONSTRAINTS_it);
}
-LCRYPTO_ALIAS(POLICY_CONSTRAINTS_new)
+LCRYPTO_ALIAS(POLICY_CONSTRAINTS_new);
void
POLICY_CONSTRAINTS_free(POLICY_CONSTRAINTS *a)
{
ASN1_item_free((ASN1_VALUE *)a, &POLICY_CONSTRAINTS_it);
}
-LCRYPTO_ALIAS(POLICY_CONSTRAINTS_free)
+LCRYPTO_ALIAS(POLICY_CONSTRAINTS_free);
static STACK_OF(CONF_VALUE) *
i2v_POLICY_CONSTRAINTS(const X509V3_EXT_METHOD *method, void *a,
-/* $OpenBSD: x509_pku.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_pku.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return (PKEY_USAGE_PERIOD *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PKEY_USAGE_PERIOD_it);
}
-LCRYPTO_ALIAS(d2i_PKEY_USAGE_PERIOD)
+LCRYPTO_ALIAS(d2i_PKEY_USAGE_PERIOD);
int
i2d_PKEY_USAGE_PERIOD(PKEY_USAGE_PERIOD *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKEY_USAGE_PERIOD_it);
}
-LCRYPTO_ALIAS(i2d_PKEY_USAGE_PERIOD)
+LCRYPTO_ALIAS(i2d_PKEY_USAGE_PERIOD);
PKEY_USAGE_PERIOD *
PKEY_USAGE_PERIOD_new(void)
{
return (PKEY_USAGE_PERIOD *)ASN1_item_new(&PKEY_USAGE_PERIOD_it);
}
-LCRYPTO_ALIAS(PKEY_USAGE_PERIOD_new)
+LCRYPTO_ALIAS(PKEY_USAGE_PERIOD_new);
void
PKEY_USAGE_PERIOD_free(PKEY_USAGE_PERIOD *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PKEY_USAGE_PERIOD_it);
}
-LCRYPTO_ALIAS(PKEY_USAGE_PERIOD_free)
+LCRYPTO_ALIAS(PKEY_USAGE_PERIOD_free);
static int
i2r_PKEY_USAGE_PERIOD(X509V3_EXT_METHOD *method, PKEY_USAGE_PERIOD *usage,
-/* $OpenBSD: x509_pmaps.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_pmaps.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project.
*/
{
return (POLICY_MAPPING*)ASN1_item_new(&POLICY_MAPPING_it);
}
-LCRYPTO_ALIAS(POLICY_MAPPING_new)
+LCRYPTO_ALIAS(POLICY_MAPPING_new);
void
POLICY_MAPPING_free(POLICY_MAPPING *a)
{
ASN1_item_free((ASN1_VALUE *)a, &POLICY_MAPPING_it);
}
-LCRYPTO_ALIAS(POLICY_MAPPING_free)
+LCRYPTO_ALIAS(POLICY_MAPPING_free);
static STACK_OF(CONF_VALUE) *
i2v_POLICY_MAPPINGS(const X509V3_EXT_METHOD *method, void *a,
-/* $OpenBSD: x509_prn.c,v 1.4 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509_prn.c,v 1.5 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
BIO_puts(out, "\n");
}
}
-LCRYPTO_ALIAS(X509V3_EXT_val_prn)
+LCRYPTO_ALIAS(X509V3_EXT_val_prn);
/* Main routine: print out a general extension */
method->ext_free(ext_str);
return ok;
}
-LCRYPTO_ALIAS(X509V3_EXT_print)
+LCRYPTO_ALIAS(X509V3_EXT_print);
int
X509V3_extensions_print(BIO *bp, const char *title,
}
return 1;
}
-LCRYPTO_ALIAS(X509V3_extensions_print)
+LCRYPTO_ALIAS(X509V3_extensions_print);
static int
unknown_ext_print(BIO *out, X509_EXTENSION *ext, unsigned long flag,
BIO_free(bio_tmp);
return ret;
}
-LCRYPTO_ALIAS(X509V3_EXT_print_fp)
+LCRYPTO_ALIAS(X509V3_EXT_print_fp);
-/* $OpenBSD: x509_purp.c,v 1.19 2023/01/20 22:00:47 job Exp $ */
+/* $OpenBSD: x509_purp.c,v 1.20 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2001.
*/
pt = X509_PURPOSE_get0(idx);
return pt->check_purpose(pt, x, ca);
}
-LCRYPTO_ALIAS(X509_check_purpose)
+LCRYPTO_ALIAS(X509_check_purpose);
int
X509_PURPOSE_set(int *p, int purpose)
*p = purpose;
return 1;
}
-LCRYPTO_ALIAS(X509_PURPOSE_set)
+LCRYPTO_ALIAS(X509_PURPOSE_set);
int
X509_PURPOSE_get_count(void)
return X509_PURPOSE_COUNT;
return sk_X509_PURPOSE_num(xptable) + X509_PURPOSE_COUNT;
}
-LCRYPTO_ALIAS(X509_PURPOSE_get_count)
+LCRYPTO_ALIAS(X509_PURPOSE_get_count);
X509_PURPOSE *
X509_PURPOSE_get0(int idx)
return xstandard + idx;
return sk_X509_PURPOSE_value(xptable, idx - X509_PURPOSE_COUNT);
}
-LCRYPTO_ALIAS(X509_PURPOSE_get0)
+LCRYPTO_ALIAS(X509_PURPOSE_get0);
int
X509_PURPOSE_get_by_sname(const char *sname)
}
return -1;
}
-LCRYPTO_ALIAS(X509_PURPOSE_get_by_sname)
+LCRYPTO_ALIAS(X509_PURPOSE_get_by_sname);
int
X509_PURPOSE_get_by_id(int purpose)
return -1;
return idx + X509_PURPOSE_COUNT;
}
-LCRYPTO_ALIAS(X509_PURPOSE_get_by_id)
+LCRYPTO_ALIAS(X509_PURPOSE_get_by_id);
int
X509_PURPOSE_add(int id, int trust, int flags,
X509V3error(ERR_R_MALLOC_FAILURE);
return 0;
}
-LCRYPTO_ALIAS(X509_PURPOSE_add)
+LCRYPTO_ALIAS(X509_PURPOSE_add);
static void
xptable_free(X509_PURPOSE *p)
sk_X509_PURPOSE_pop_free(xptable, xptable_free);
xptable = NULL;
}
-LCRYPTO_ALIAS(X509_PURPOSE_cleanup)
+LCRYPTO_ALIAS(X509_PURPOSE_cleanup);
int
X509_PURPOSE_get_id(const X509_PURPOSE *xp)
{
return xp->purpose;
}
-LCRYPTO_ALIAS(X509_PURPOSE_get_id)
+LCRYPTO_ALIAS(X509_PURPOSE_get_id);
char *
X509_PURPOSE_get0_name(const X509_PURPOSE *xp)
{
return xp->name;
}
-LCRYPTO_ALIAS(X509_PURPOSE_get0_name)
+LCRYPTO_ALIAS(X509_PURPOSE_get0_name);
char *
X509_PURPOSE_get0_sname(const X509_PURPOSE *xp)
{
return xp->sname;
}
-LCRYPTO_ALIAS(X509_PURPOSE_get0_sname)
+LCRYPTO_ALIAS(X509_PURPOSE_get0_sname);
int
X509_PURPOSE_get_trust(const X509_PURPOSE *xp)
{
return xp->trust;
}
-LCRYPTO_ALIAS(X509_PURPOSE_get_trust)
+LCRYPTO_ALIAS(X509_PURPOSE_get_trust);
static int
nid_cmp(const int *a, const int *b)
return 1;
return 0;
}
-LCRYPTO_ALIAS(X509_supported_extension)
+LCRYPTO_ALIAS(X509_supported_extension);
static void
setup_dp(X509 *x, DIST_POINT *dp)
return check_ca(x);
}
-LCRYPTO_ALIAS(X509_check_ca)
+LCRYPTO_ALIAS(X509_check_ca);
/* Check SSL CA: common checks for SSL client and server */
static int
return X509_V_ERR_KEYUSAGE_NO_CERTSIGN;
return X509_V_OK;
}
-LCRYPTO_ALIAS(X509_check_issued)
+LCRYPTO_ALIAS(X509_check_issued);
int
X509_check_akid(X509 *issuer, AUTHORITY_KEYID *akid)
}
return X509_V_OK;
}
-LCRYPTO_ALIAS(X509_check_akid)
+LCRYPTO_ALIAS(X509_check_akid);
uint32_t
X509_get_extension_flags(X509 *x)
return x->ex_flags;
}
-LCRYPTO_ALIAS(X509_get_extension_flags)
+LCRYPTO_ALIAS(X509_get_extension_flags);
uint32_t
X509_get_key_usage(X509 *x)
return UINT32_MAX;
}
-LCRYPTO_ALIAS(X509_get_key_usage)
+LCRYPTO_ALIAS(X509_get_key_usage);
uint32_t
X509_get_extended_key_usage(X509 *x)
return UINT32_MAX;
}
-LCRYPTO_ALIAS(X509_get_extended_key_usage)
+LCRYPTO_ALIAS(X509_get_extended_key_usage);
-/* $OpenBSD: x509_r2x.c,v 1.15 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509_r2x.c,v 1.16 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
X509_free(ret);
return NULL;
}
-LCRYPTO_ALIAS(X509_REQ_to_X509)
+LCRYPTO_ALIAS(X509_REQ_to_X509);
-/* $OpenBSD: x509_req.c,v 1.31 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509_req.c,v 1.32 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
X509_REQ_free(ret);
return (NULL);
}
-LCRYPTO_ALIAS(X509_to_X509_REQ)
+LCRYPTO_ALIAS(X509_to_X509_REQ);
EVP_PKEY *
X509_REQ_get_pubkey(X509_REQ *req)
return (NULL);
return (X509_PUBKEY_get(req->req_info->pubkey));
}
-LCRYPTO_ALIAS(X509_REQ_get_pubkey)
+LCRYPTO_ALIAS(X509_REQ_get_pubkey);
EVP_PKEY *
X509_REQ_get0_pubkey(X509_REQ *req)
return NULL;
return X509_PUBKEY_get0(req->req_info->pubkey);
}
-LCRYPTO_ALIAS(X509_REQ_get0_pubkey)
+LCRYPTO_ALIAS(X509_REQ_get0_pubkey);
int
X509_REQ_check_private_key(X509_REQ *x, EVP_PKEY *k)
return (ok);
}
-LCRYPTO_ALIAS(X509_REQ_check_private_key)
+LCRYPTO_ALIAS(X509_REQ_check_private_key);
/* It seems several organisations had the same idea of including a list of
* extensions in a certificate request. There are at least two OIDs that are
return 1;
}
}
-LCRYPTO_ALIAS(X509_REQ_extension_nid)
+LCRYPTO_ALIAS(X509_REQ_extension_nid);
int *
X509_REQ_get_extension_nids(void)
{
return ext_nids;
}
-LCRYPTO_ALIAS(X509_REQ_get_extension_nids)
+LCRYPTO_ALIAS(X509_REQ_get_extension_nids);
void
X509_REQ_set_extension_nids(int *nids)
{
ext_nids = nids;
}
-LCRYPTO_ALIAS(X509_REQ_set_extension_nids)
+LCRYPTO_ALIAS(X509_REQ_set_extension_nids);
STACK_OF(X509_EXTENSION) *
X509_REQ_get_extensions(X509_REQ *req)
p = ext->value.sequence->data;
return d2i_X509_EXTENSIONS(NULL, &p, ext->value.sequence->length);
}
-LCRYPTO_ALIAS(X509_REQ_get_extensions)
+LCRYPTO_ALIAS(X509_REQ_get_extensions);
/*
* Add a STACK_OF extensions to a certificate request: allow alternative OIDs
return rv;
}
-LCRYPTO_ALIAS(X509_REQ_add_extensions_nid)
+LCRYPTO_ALIAS(X509_REQ_add_extensions_nid);
/* This is the normal usage: use the "official" OID */
int
{
return X509_REQ_add_extensions_nid(req, exts, NID_ext_req);
}
-LCRYPTO_ALIAS(X509_REQ_add_extensions)
+LCRYPTO_ALIAS(X509_REQ_add_extensions);
/* Request attribute functions */
{
return X509at_get_attr_count(req->req_info->attributes);
}
-LCRYPTO_ALIAS(X509_REQ_get_attr_count)
+LCRYPTO_ALIAS(X509_REQ_get_attr_count);
int
X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, int lastpos)
{
return X509at_get_attr_by_NID(req->req_info->attributes, nid, lastpos);
}
-LCRYPTO_ALIAS(X509_REQ_get_attr_by_NID)
+LCRYPTO_ALIAS(X509_REQ_get_attr_by_NID);
int
X509_REQ_get_attr_by_OBJ(const X509_REQ *req, const ASN1_OBJECT *obj,
{
return X509at_get_attr_by_OBJ(req->req_info->attributes, obj, lastpos);
}
-LCRYPTO_ALIAS(X509_REQ_get_attr_by_OBJ)
+LCRYPTO_ALIAS(X509_REQ_get_attr_by_OBJ);
X509_ATTRIBUTE *
X509_REQ_get_attr(const X509_REQ *req, int loc)
{
return X509at_get_attr(req->req_info->attributes, loc);
}
-LCRYPTO_ALIAS(X509_REQ_get_attr)
+LCRYPTO_ALIAS(X509_REQ_get_attr);
X509_ATTRIBUTE *
X509_REQ_delete_attr(X509_REQ *req, int loc)
{
return X509at_delete_attr(req->req_info->attributes, loc);
}
-LCRYPTO_ALIAS(X509_REQ_delete_attr)
+LCRYPTO_ALIAS(X509_REQ_delete_attr);
int
X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr)
return 1;
return 0;
}
-LCRYPTO_ALIAS(X509_REQ_add1_attr)
+LCRYPTO_ALIAS(X509_REQ_add1_attr);
int
X509_REQ_add1_attr_by_OBJ(X509_REQ *req, const ASN1_OBJECT *obj, int type,
return 1;
return 0;
}
-LCRYPTO_ALIAS(X509_REQ_add1_attr_by_OBJ)
+LCRYPTO_ALIAS(X509_REQ_add1_attr_by_OBJ);
int
X509_REQ_add1_attr_by_NID(X509_REQ *req, int nid, int type,
return 1;
return 0;
}
-LCRYPTO_ALIAS(X509_REQ_add1_attr_by_NID)
+LCRYPTO_ALIAS(X509_REQ_add1_attr_by_NID);
int
X509_REQ_add1_attr_by_txt(X509_REQ *req, const char *attrname, int type,
return 1;
return 0;
}
-LCRYPTO_ALIAS(X509_REQ_add1_attr_by_txt)
+LCRYPTO_ALIAS(X509_REQ_add1_attr_by_txt);
int
i2d_re_X509_REQ_tbs(X509_REQ *req, unsigned char **pp)
req->req_info->enc.modified = 1;
return i2d_X509_REQ_INFO(req->req_info, pp);
}
-LCRYPTO_ALIAS(i2d_re_X509_REQ_tbs)
+LCRYPTO_ALIAS(i2d_re_X509_REQ_tbs);
-/* $OpenBSD: x509_set.c,v 1.22 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509_set.c,v 1.23 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
{
return x->cert_info->extensions;
}
-LCRYPTO_ALIAS(X509_get0_extensions)
+LCRYPTO_ALIAS(X509_get0_extensions);
const X509_ALGOR *
X509_get0_tbs_sigalg(const X509 *x)
{
return x->cert_info->signature;
}
-LCRYPTO_ALIAS(X509_get0_tbs_sigalg)
+LCRYPTO_ALIAS(X509_get0_tbs_sigalg);
int
X509_set_version(X509 *x, long version)
}
return (ASN1_INTEGER_set(x->cert_info->version, version));
}
-LCRYPTO_ALIAS(X509_set_version)
+LCRYPTO_ALIAS(X509_set_version);
long
X509_get_version(const X509 *x)
{
return ASN1_INTEGER_get(x->cert_info->version);
}
-LCRYPTO_ALIAS(X509_get_version)
+LCRYPTO_ALIAS(X509_get_version);
int
X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial)
}
return (in != NULL);
}
-LCRYPTO_ALIAS(X509_set_serialNumber)
+LCRYPTO_ALIAS(X509_set_serialNumber);
int
X509_set_issuer_name(X509 *x, X509_NAME *name)
return (0);
return (X509_NAME_set(&x->cert_info->issuer, name));
}
-LCRYPTO_ALIAS(X509_set_issuer_name)
+LCRYPTO_ALIAS(X509_set_issuer_name);
int
X509_set_subject_name(X509 *x, X509_NAME *name)
return (0);
return (X509_NAME_set(&x->cert_info->subject, name));
}
-LCRYPTO_ALIAS(X509_set_subject_name)
+LCRYPTO_ALIAS(X509_set_subject_name);
const ASN1_TIME *
X509_get0_notBefore(const X509 *x)
{
return X509_getm_notBefore(x);
}
-LCRYPTO_ALIAS(X509_get0_notBefore)
+LCRYPTO_ALIAS(X509_get0_notBefore);
ASN1_TIME *
X509_getm_notBefore(const X509 *x)
return (NULL);
return x->cert_info->validity->notBefore;
}
-LCRYPTO_ALIAS(X509_getm_notBefore)
+LCRYPTO_ALIAS(X509_getm_notBefore);
int
X509_set_notBefore(X509 *x, const ASN1_TIME *tm)
}
return (in != NULL);
}
-LCRYPTO_ALIAS(X509_set_notBefore)
+LCRYPTO_ALIAS(X509_set_notBefore);
int
X509_set1_notBefore(X509 *x, const ASN1_TIME *tm)
{
return X509_set_notBefore(x, tm);
}
-LCRYPTO_ALIAS(X509_set1_notBefore)
+LCRYPTO_ALIAS(X509_set1_notBefore);
const ASN1_TIME *
X509_get0_notAfter(const X509 *x)
{
return X509_getm_notAfter(x);
}
-LCRYPTO_ALIAS(X509_get0_notAfter)
+LCRYPTO_ALIAS(X509_get0_notAfter);
ASN1_TIME *
X509_getm_notAfter(const X509 *x)
return (NULL);
return x->cert_info->validity->notAfter;
}
-LCRYPTO_ALIAS(X509_getm_notAfter)
+LCRYPTO_ALIAS(X509_getm_notAfter);
int
X509_set_notAfter(X509 *x, const ASN1_TIME *tm)
}
return (in != NULL);
}
-LCRYPTO_ALIAS(X509_set_notAfter)
+LCRYPTO_ALIAS(X509_set_notAfter);
int
X509_set1_notAfter(X509 *x, const ASN1_TIME *tm)
{
return X509_set_notAfter(x, tm);
}
-LCRYPTO_ALIAS(X509_set1_notAfter)
+LCRYPTO_ALIAS(X509_set1_notAfter);
int
X509_set_pubkey(X509 *x, EVP_PKEY *pkey)
return (0);
return (X509_PUBKEY_set(&(x->cert_info->key), pkey));
}
-LCRYPTO_ALIAS(X509_set_pubkey)
+LCRYPTO_ALIAS(X509_set_pubkey);
int
X509_get_signature_type(const X509 *x)
{
return EVP_PKEY_type(OBJ_obj2nid(x->sig_alg->algorithm));
}
-LCRYPTO_ALIAS(X509_get_signature_type)
+LCRYPTO_ALIAS(X509_get_signature_type);
X509_PUBKEY *
X509_get_X509_PUBKEY(const X509 *x)
{
return x->cert_info->key;
}
-LCRYPTO_ALIAS(X509_get_X509_PUBKEY)
+LCRYPTO_ALIAS(X509_get_X509_PUBKEY);
-/* $OpenBSD: x509_skey.c,v 1.4 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509_skey.c,v 1.5 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
{
return hex_to_string(oct->data, oct->length);
}
-LCRYPTO_ALIAS(i2s_ASN1_OCTET_STRING)
+LCRYPTO_ALIAS(i2s_ASN1_OCTET_STRING);
ASN1_OCTET_STRING *
s2i_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
return oct;
}
-LCRYPTO_ALIAS(s2i_ASN1_OCTET_STRING)
+LCRYPTO_ALIAS(s2i_ASN1_OCTET_STRING);
static ASN1_OCTET_STRING *
s2i_skey_id(X509V3_EXT_METHOD *method, X509V3_CTX *ctx, char *str)
-/* $OpenBSD: x509_sxnet.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_sxnet.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return (SXNETID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&SXNETID_it);
}
-LCRYPTO_ALIAS(d2i_SXNETID)
+LCRYPTO_ALIAS(d2i_SXNETID);
int
i2d_SXNETID(SXNETID *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &SXNETID_it);
}
-LCRYPTO_ALIAS(i2d_SXNETID)
+LCRYPTO_ALIAS(i2d_SXNETID);
SXNETID *
SXNETID_new(void)
{
return (SXNETID *)ASN1_item_new(&SXNETID_it);
}
-LCRYPTO_ALIAS(SXNETID_new)
+LCRYPTO_ALIAS(SXNETID_new);
void
SXNETID_free(SXNETID *a)
{
ASN1_item_free((ASN1_VALUE *)a, &SXNETID_it);
}
-LCRYPTO_ALIAS(SXNETID_free)
+LCRYPTO_ALIAS(SXNETID_free);
static const ASN1_TEMPLATE SXNET_seq_tt[] = {
{
return (SXNET *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&SXNET_it);
}
-LCRYPTO_ALIAS(d2i_SXNET)
+LCRYPTO_ALIAS(d2i_SXNET);
int
i2d_SXNET(SXNET *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &SXNET_it);
}
-LCRYPTO_ALIAS(i2d_SXNET)
+LCRYPTO_ALIAS(i2d_SXNET);
SXNET *
SXNET_new(void)
{
return (SXNET *)ASN1_item_new(&SXNET_it);
}
-LCRYPTO_ALIAS(SXNET_new)
+LCRYPTO_ALIAS(SXNET_new);
void
SXNET_free(SXNET *a)
{
ASN1_item_free((ASN1_VALUE *)a, &SXNET_it);
}
-LCRYPTO_ALIAS(SXNET_free)
+LCRYPTO_ALIAS(SXNET_free);
static int
sxnet_i2r(X509V3_EXT_METHOD *method, SXNET *sx, BIO *out, int indent)
}
return SXNET_add_id_INTEGER(psx, izone, user, userlen);
}
-LCRYPTO_ALIAS(SXNET_add_id_asc)
+LCRYPTO_ALIAS(SXNET_add_id_asc);
/* Add an id given the zone as an unsigned long */
}
return SXNET_add_id_INTEGER(psx, izone, user, userlen);
}
-LCRYPTO_ALIAS(SXNET_add_id_ulong)
+LCRYPTO_ALIAS(SXNET_add_id_ulong);
/* Add an id given the zone as an ASN1_INTEGER.
* Note this version uses the passed integer and doesn't make a copy so don't
*psx = NULL;
return 0;
}
-LCRYPTO_ALIAS(SXNET_add_id_INTEGER)
+LCRYPTO_ALIAS(SXNET_add_id_INTEGER);
ASN1_OCTET_STRING *
SXNET_get_id_asc(SXNET *sx, const char *zone)
ASN1_INTEGER_free(izone);
return oct;
}
-LCRYPTO_ALIAS(SXNET_get_id_asc)
+LCRYPTO_ALIAS(SXNET_get_id_asc);
ASN1_OCTET_STRING *
SXNET_get_id_ulong(SXNET *sx, unsigned long lzone)
ASN1_INTEGER_free(izone);
return oct;
}
-LCRYPTO_ALIAS(SXNET_get_id_ulong)
+LCRYPTO_ALIAS(SXNET_get_id_ulong);
ASN1_OCTET_STRING *
SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone)
}
return NULL;
}
-LCRYPTO_ALIAS(SXNET_get_id_INTEGER)
+LCRYPTO_ALIAS(SXNET_get_id_INTEGER);
-/* $OpenBSD: x509_trs.c,v 1.30 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509_trs.c,v 1.31 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
default_trust = trust;
return oldtrust;
}
-LCRYPTO_ALIAS(X509_TRUST_set_default)
+LCRYPTO_ALIAS(X509_TRUST_set_default);
int
X509_check_trust(X509 *x, int id, int flags)
pt = X509_TRUST_get0(idx);
return pt->check_trust(pt, x, flags);
}
-LCRYPTO_ALIAS(X509_check_trust)
+LCRYPTO_ALIAS(X509_check_trust);
int
X509_TRUST_get_count(void)
return X509_TRUST_COUNT;
return sk_X509_TRUST_num(trtable) + X509_TRUST_COUNT;
}
-LCRYPTO_ALIAS(X509_TRUST_get_count)
+LCRYPTO_ALIAS(X509_TRUST_get_count);
X509_TRUST *
X509_TRUST_get0(int idx)
return trstandard + idx;
return sk_X509_TRUST_value(trtable, idx - X509_TRUST_COUNT);
}
-LCRYPTO_ALIAS(X509_TRUST_get0)
+LCRYPTO_ALIAS(X509_TRUST_get0);
int
X509_TRUST_get_by_id(int id)
return -1;
return idx + X509_TRUST_COUNT;
}
-LCRYPTO_ALIAS(X509_TRUST_get_by_id)
+LCRYPTO_ALIAS(X509_TRUST_get_by_id);
int
X509_TRUST_set(int *t, int trust)
*t = trust;
return 1;
}
-LCRYPTO_ALIAS(X509_TRUST_set)
+LCRYPTO_ALIAS(X509_TRUST_set);
int
X509_TRUST_add(int id, int flags, int (*ck)(X509_TRUST *, X509 *, int),
X509error(ERR_R_MALLOC_FAILURE);
return 0;
}
-LCRYPTO_ALIAS(X509_TRUST_add)
+LCRYPTO_ALIAS(X509_TRUST_add);
static void
trtable_free(X509_TRUST *p)
sk_X509_TRUST_pop_free(trtable, trtable_free);
trtable = NULL;
}
-LCRYPTO_ALIAS(X509_TRUST_cleanup)
+LCRYPTO_ALIAS(X509_TRUST_cleanup);
int
X509_TRUST_get_flags(const X509_TRUST *xp)
{
return xp->flags;
}
-LCRYPTO_ALIAS(X509_TRUST_get_flags)
+LCRYPTO_ALIAS(X509_TRUST_get_flags);
char *
X509_TRUST_get0_name(const X509_TRUST *xp)
{
return xp->name;
}
-LCRYPTO_ALIAS(X509_TRUST_get0_name)
+LCRYPTO_ALIAS(X509_TRUST_get0_name);
int
X509_TRUST_get_trust(const X509_TRUST *xp)
{
return xp->trust;
}
-LCRYPTO_ALIAS(X509_TRUST_get_trust)
+LCRYPTO_ALIAS(X509_TRUST_get_trust);
static int
trust_1oidany(X509_TRUST *trust, X509 *x, int flags)
-/* $OpenBSD: x509_txt.c,v 1.27 2022/11/29 12:23:43 tb Exp $ */
+/* $OpenBSD: x509_txt.c,v 1.28 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return "Unknown certificate verification error";
}
}
-LCRYPTO_ALIAS(X509_verify_cert_error_string)
+LCRYPTO_ALIAS(X509_verify_cert_error_string);
-/* $OpenBSD: x509_utl.c,v 1.5 2022/12/26 07:18:53 jmc Exp $ */
+/* $OpenBSD: x509_utl.c,v 1.6 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project.
*/
}
return 0;
}
-LCRYPTO_ALIAS(X509V3_add_value)
+LCRYPTO_ALIAS(X509V3_add_value);
int
X509V3_add_value_uchar(const char *name, const unsigned char *value,
{
return X509V3_add_value(name, (const char *)value, extlist);
}
-LCRYPTO_ALIAS(X509V3_add_value_uchar)
+LCRYPTO_ALIAS(X509V3_add_value_uchar);
/* Free function for STACK_OF(CONF_VALUE) */
free(conf->section);
free(conf);
}
-LCRYPTO_ALIAS(X509V3_conf_free)
+LCRYPTO_ALIAS(X509V3_conf_free);
int
X509V3_add_value_bool(const char *name, int asn1_bool,
return X509V3_add_value(name, "TRUE", extlist);
return X509V3_add_value(name, "FALSE", extlist);
}
-LCRYPTO_ALIAS(X509V3_add_value_bool)
+LCRYPTO_ALIAS(X509V3_add_value_bool);
int
X509V3_add_value_bool_nf(const char *name, int asn1_bool,
return X509V3_add_value(name, "TRUE", extlist);
return 1;
}
-LCRYPTO_ALIAS(X509V3_add_value_bool_nf)
+LCRYPTO_ALIAS(X509V3_add_value_bool_nf);
char *
bn_to_string(const BIGNUM *bn)
BN_free(bntmp);
return strtmp;
}
-LCRYPTO_ALIAS(i2s_ASN1_ENUMERATED)
+LCRYPTO_ALIAS(i2s_ASN1_ENUMERATED);
char *
i2s_ASN1_INTEGER(X509V3_EXT_METHOD *method, const ASN1_INTEGER *a)
BN_free(bntmp);
return strtmp;
}
-LCRYPTO_ALIAS(i2s_ASN1_INTEGER)
+LCRYPTO_ALIAS(i2s_ASN1_INTEGER);
ASN1_INTEGER *
s2i_ASN1_INTEGER(X509V3_EXT_METHOD *method, const char *value)
aint->type |= V_ASN1_NEG;
return aint;
}
-LCRYPTO_ALIAS(s2i_ASN1_INTEGER)
+LCRYPTO_ALIAS(s2i_ASN1_INTEGER);
int
X509V3_add_value_int(const char *name, const ASN1_INTEGER *aint,
free(strtmp);
return ret;
}
-LCRYPTO_ALIAS(X509V3_add_value_int)
+LCRYPTO_ALIAS(X509V3_add_value_int);
int
X509V3_get_value_bool(const CONF_VALUE *value, int *asn1_bool)
X509V3_conf_err(value);
return 0;
}
-LCRYPTO_ALIAS(X509V3_get_value_bool)
+LCRYPTO_ALIAS(X509V3_get_value_bool);
int
X509V3_get_value_int(const CONF_VALUE *value, ASN1_INTEGER **aint)
*aint = itmp;
return 1;
}
-LCRYPTO_ALIAS(X509V3_get_value_int)
+LCRYPTO_ALIAS(X509V3_get_value_int);
#define HDR_NAME 1
#define HDR_VALUE 2
return NULL;
}
-LCRYPTO_ALIAS(X509V3_parse_list)
+LCRYPTO_ALIAS(X509V3_parse_list);
/* Delete leading and trailing spaces from a string */
static char *
q[-1] = 0;
return tmp;
}
-LCRYPTO_ALIAS(hex_to_string)
+LCRYPTO_ALIAS(hex_to_string);
/* Give a string of hex digits convert to
* a buffer
X509V3error(X509V3_R_ILLEGAL_HEX_DIGIT);
return NULL;
}
-LCRYPTO_ALIAS(string_to_hex)
+LCRYPTO_ALIAS(string_to_hex);
/* V2I name comparison function: returns zero if 'name' matches
* cmp or cmp.*
sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
return ret;
}
-LCRYPTO_ALIAS(X509_get1_email)
+LCRYPTO_ALIAS(X509_get1_email);
STACK_OF(OPENSSL_STRING) *
X509_get1_ocsp(X509 *x)
AUTHORITY_INFO_ACCESS_free(info);
return ret;
}
-LCRYPTO_ALIAS(X509_get1_ocsp)
+LCRYPTO_ALIAS(X509_get1_ocsp);
STACK_OF(OPENSSL_STRING) *
X509_REQ_get1_email(X509_REQ *x)
sk_X509_EXTENSION_pop_free(exts, X509_EXTENSION_free);
return ret;
}
-LCRYPTO_ALIAS(X509_REQ_get1_email)
+LCRYPTO_ALIAS(X509_REQ_get1_email);
static STACK_OF(OPENSSL_STRING) *
{
sk_OPENSSL_STRING_pop_free(sk, str_free);
}
-LCRYPTO_ALIAS(X509_email_free)
+LCRYPTO_ALIAS(X509_email_free);
typedef int (*equal_fn)(const unsigned char *pattern, size_t pattern_len,
const unsigned char *subject, size_t subject_len, unsigned int flags);
return -2;
return do_x509_check(x, chk, chklen, flags, GEN_DNS, peername);
}
-LCRYPTO_ALIAS(X509_check_host)
+LCRYPTO_ALIAS(X509_check_host);
int
X509_check_email(X509 *x, const char *chk, size_t chklen, unsigned int flags)
return -2;
return do_x509_check(x, chk, chklen, flags, GEN_EMAIL, NULL);
}
-LCRYPTO_ALIAS(X509_check_email)
+LCRYPTO_ALIAS(X509_check_email);
int
X509_check_ip(X509 *x, const unsigned char *chk, size_t chklen,
return -2;
return do_x509_check(x, (char *)chk, chklen, flags, GEN_IPADD, NULL);
}
-LCRYPTO_ALIAS(X509_check_ip)
+LCRYPTO_ALIAS(X509_check_ip);
int
X509_check_ip_asc(X509 *x, const char *ipasc, unsigned int flags)
return -2;
return do_x509_check(x, (char *)ipout, iplen, flags, GEN_IPADD, NULL);
}
-LCRYPTO_ALIAS(X509_check_ip_asc)
+LCRYPTO_ALIAS(X509_check_ip_asc);
/* Convert IP addresses both IPv4 and IPv6 into an
* OCTET STRING compatible with RFC3280.
}
return ret;
}
-LCRYPTO_ALIAS(a2i_IPADDRESS)
+LCRYPTO_ALIAS(a2i_IPADDRESS);
ASN1_OCTET_STRING *
a2i_IPADDRESS_NC(const char *ipasc)
ASN1_OCTET_STRING_free(ret);
return NULL;
}
-LCRYPTO_ALIAS(a2i_IPADDRESS_NC)
+LCRYPTO_ALIAS(a2i_IPADDRESS_NC);
int
return 4;
}
}
-LCRYPTO_ALIAS(a2i_ipadd)
+LCRYPTO_ALIAS(a2i_ipadd);
static int
ipv4_from_asc(unsigned char *v4, const char *in)
}
return 1;
}
-LCRYPTO_ALIAS(X509V3_NAME_from_section)
+LCRYPTO_ALIAS(X509V3_NAME_from_section);
-/* $OpenBSD: x509_v3.c,v 1.20 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509_v3.c,v 1.21 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (0);
return (sk_X509_EXTENSION_num(x));
}
-LCRYPTO_ALIAS(X509v3_get_ext_count)
+LCRYPTO_ALIAS(X509v3_get_ext_count);
int
X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x, int nid, int lastpos)
return (-2);
return (X509v3_get_ext_by_OBJ(x, obj, lastpos));
}
-LCRYPTO_ALIAS(X509v3_get_ext_by_NID)
+LCRYPTO_ALIAS(X509v3_get_ext_by_NID);
int
X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *sk,
}
return (-1);
}
-LCRYPTO_ALIAS(X509v3_get_ext_by_OBJ)
+LCRYPTO_ALIAS(X509v3_get_ext_by_OBJ);
int
X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) *sk, int crit,
}
return (-1);
}
-LCRYPTO_ALIAS(X509v3_get_ext_by_critical)
+LCRYPTO_ALIAS(X509v3_get_ext_by_critical);
X509_EXTENSION *
X509v3_get_ext(const STACK_OF(X509_EXTENSION) *x, int loc)
else
return sk_X509_EXTENSION_value(x, loc);
}
-LCRYPTO_ALIAS(X509v3_get_ext)
+LCRYPTO_ALIAS(X509v3_get_ext);
X509_EXTENSION *
X509v3_delete_ext(STACK_OF(X509_EXTENSION) *x, int loc)
ret = sk_X509_EXTENSION_delete(x, loc);
return (ret);
}
-LCRYPTO_ALIAS(X509v3_delete_ext)
+LCRYPTO_ALIAS(X509v3_delete_ext);
STACK_OF(X509_EXTENSION) *
X509v3_add_ext(STACK_OF(X509_EXTENSION) **x, X509_EXTENSION *ex, int loc)
sk_X509_EXTENSION_free(sk);
return (NULL);
}
-LCRYPTO_ALIAS(X509v3_add_ext)
+LCRYPTO_ALIAS(X509v3_add_ext);
X509_EXTENSION *
X509_EXTENSION_create_by_NID(X509_EXTENSION **ex, int nid, int crit,
ASN1_OBJECT_free(obj);
return (ret);
}
-LCRYPTO_ALIAS(X509_EXTENSION_create_by_NID)
+LCRYPTO_ALIAS(X509_EXTENSION_create_by_NID);
X509_EXTENSION *
X509_EXTENSION_create_by_OBJ(X509_EXTENSION **ex, const ASN1_OBJECT *obj,
X509_EXTENSION_free(ret);
return (NULL);
}
-LCRYPTO_ALIAS(X509_EXTENSION_create_by_OBJ)
+LCRYPTO_ALIAS(X509_EXTENSION_create_by_OBJ);
int
X509_EXTENSION_set_object(X509_EXTENSION *ex, const ASN1_OBJECT *obj)
ex->object = OBJ_dup(obj);
return ex->object != NULL;
}
-LCRYPTO_ALIAS(X509_EXTENSION_set_object)
+LCRYPTO_ALIAS(X509_EXTENSION_set_object);
int
X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit)
ex->critical = (crit) ? 0xFF : -1;
return (1);
}
-LCRYPTO_ALIAS(X509_EXTENSION_set_critical)
+LCRYPTO_ALIAS(X509_EXTENSION_set_critical);
int
X509_EXTENSION_set_data(X509_EXTENSION *ex, ASN1_OCTET_STRING *data)
return (0);
return (1);
}
-LCRYPTO_ALIAS(X509_EXTENSION_set_data)
+LCRYPTO_ALIAS(X509_EXTENSION_set_data);
ASN1_OBJECT *
X509_EXTENSION_get_object(X509_EXTENSION *ex)
return (NULL);
return (ex->object);
}
-LCRYPTO_ALIAS(X509_EXTENSION_get_object)
+LCRYPTO_ALIAS(X509_EXTENSION_get_object);
ASN1_OCTET_STRING *
X509_EXTENSION_get_data(X509_EXTENSION *ex)
return (NULL);
return (ex->value);
}
-LCRYPTO_ALIAS(X509_EXTENSION_get_data)
+LCRYPTO_ALIAS(X509_EXTENSION_get_data);
int
X509_EXTENSION_get_critical(const X509_EXTENSION *ex)
return 1;
return 0;
}
-LCRYPTO_ALIAS(X509_EXTENSION_get_critical)
+LCRYPTO_ALIAS(X509_EXTENSION_get_critical);
-/* $OpenBSD: x509_vfy.c,v 1.110 2022/12/26 07:18:53 jmc Exp $ */
+/* $OpenBSD: x509_vfy.c,v 1.111 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
/* if we succeed we have a chain in ctx->chain */
return (chain_count > 0 && ctx->chain != NULL);
}
-LCRYPTO_ALIAS(X509_verify_cert)
+LCRYPTO_ALIAS(X509_verify_cert);
/* Given a STACK_OF(X509) find the issuer of cert (if any)
*/
{
return X509_cmp_time(ctm, NULL);
}
-LCRYPTO_ALIAS(X509_cmp_current_time)
+LCRYPTO_ALIAS(X509_cmp_current_time);
/*
* Compare a possibly unvalidated ASN1_TIME string against a time_t
{
return X509_cmp_time_internal(ctm, cmp_time, 0);
}
-LCRYPTO_ALIAS(X509_cmp_time)
+LCRYPTO_ALIAS(X509_cmp_time);
ASN1_TIME *
{
return X509_time_adj(s, adj, NULL);
}
-LCRYPTO_ALIAS(X509_gmtime_adj)
+LCRYPTO_ALIAS(X509_gmtime_adj);
ASN1_TIME *
X509_time_adj(ASN1_TIME *s, long offset_sec, time_t *in_time)
{
return X509_time_adj_ex(s, 0, offset_sec, in_time);
}
-LCRYPTO_ALIAS(X509_time_adj)
+LCRYPTO_ALIAS(X509_time_adj);
ASN1_TIME *
X509_time_adj_ex(ASN1_TIME *s, int offset_day, long offset_sec, time_t *in_time)
return ASN1_TIME_adj(s, t, offset_day, offset_sec);
}
-LCRYPTO_ALIAS(X509_time_adj_ex)
+LCRYPTO_ALIAS(X509_time_adj_ex);
int
X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain)
return 0;
return 1;
}
-LCRYPTO_ALIAS(X509_get_pubkey_parameters)
+LCRYPTO_ALIAS(X509_get_pubkey_parameters);
int
X509_STORE_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509_STORE_CTX,
argl, argp, new_func, dup_func, free_func);
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get_ex_new_index)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_ex_new_index);
int
X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx, int idx, void *data)
{
return CRYPTO_set_ex_data(&ctx->ex_data, idx, data);
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set_ex_data)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_ex_data);
void *
X509_STORE_CTX_get_ex_data(X509_STORE_CTX *ctx, int idx)
{
return CRYPTO_get_ex_data(&ctx->ex_data, idx);
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get_ex_data)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_ex_data);
int
X509_STORE_CTX_get_error(X509_STORE_CTX *ctx)
{
return ctx->error;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get_error)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_error);
void
X509_STORE_CTX_set_error(X509_STORE_CTX *ctx, int err)
{
ctx->error = err;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set_error)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_error);
int
X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx)
{
return ctx->error_depth;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get_error_depth)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_error_depth);
void
X509_STORE_CTX_set_error_depth(X509_STORE_CTX *ctx, int depth)
{
ctx->error_depth = depth;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set_error_depth)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_error_depth);
X509 *
X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx)
{
return ctx->current_cert;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get_current_cert)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_current_cert);
void
X509_STORE_CTX_set_current_cert(X509_STORE_CTX *ctx, X509 *x)
{
ctx->current_cert = x;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set_current_cert)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_current_cert);
STACK_OF(X509) *
X509_STORE_CTX_get_chain(X509_STORE_CTX *ctx)
{
return ctx->chain;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get_chain)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_chain);
STACK_OF(X509) *
X509_STORE_CTX_get0_chain(X509_STORE_CTX *xs)
{
return xs->chain;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get0_chain)
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_chain);
STACK_OF(X509) *
X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx)
}
return chain;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get1_chain)
+LCRYPTO_ALIAS(X509_STORE_CTX_get1_chain);
X509 *
X509_STORE_CTX_get0_current_issuer(X509_STORE_CTX *ctx)
{
return ctx->current_issuer;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get0_current_issuer)
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_current_issuer);
X509_CRL *
X509_STORE_CTX_get0_current_crl(X509_STORE_CTX *ctx)
{
return ctx->current_crl;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get0_current_crl)
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_current_crl);
X509_STORE_CTX *
X509_STORE_CTX_get0_parent_ctx(X509_STORE_CTX *ctx)
{
return ctx->parent;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get0_parent_ctx)
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_parent_ctx);
X509_STORE *
X509_STORE_CTX_get0_store(X509_STORE_CTX *xs)
{
return xs->store;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get0_store)
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_store);
void
X509_STORE_CTX_set_cert(X509_STORE_CTX *ctx, X509 *x)
{
ctx->cert = x;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set_cert)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_cert);
void
X509_STORE_CTX_set_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
{
ctx->untrusted = sk;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set_chain)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_chain);
void
X509_STORE_CTX_set0_crls(X509_STORE_CTX *ctx, STACK_OF(X509_CRL) *sk)
{
ctx->crls = sk;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set0_crls)
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_crls);
int
X509_STORE_CTX_set_purpose(X509_STORE_CTX *ctx, int purpose)
{
return X509_STORE_CTX_purpose_inherit(ctx, 0, purpose, 0);
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set_purpose)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_purpose);
int
X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust)
{
return X509_STORE_CTX_purpose_inherit(ctx, 0, 0, trust);
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set_trust)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_trust);
/* This function is used to set the X509_STORE_CTX purpose and trust
* values. This is intended to be used when another structure has its
ctx->param->trust = trust;
return 1;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_purpose_inherit)
+LCRYPTO_ALIAS(X509_STORE_CTX_purpose_inherit);
X509_STORE_CTX *
X509_STORE_CTX_new(void)
}
return ctx;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_new)
+LCRYPTO_ALIAS(X509_STORE_CTX_new);
void
X509_STORE_CTX_free(X509_STORE_CTX *ctx)
X509_STORE_CTX_cleanup(ctx);
free(ctx);
}
-LCRYPTO_ALIAS(X509_STORE_CTX_free)
+LCRYPTO_ALIAS(X509_STORE_CTX_free);
int
X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509,
}
return 1;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_init)
+LCRYPTO_ALIAS(X509_STORE_CTX_init);
/* Set alternative lookup method: just a STACK of trusted certificates.
* This avoids X509_STORE nastiness where it isn't needed.
ctx->other_ctx = sk;
ctx->get_issuer = get_issuer_sk;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_trusted_stack)
+LCRYPTO_ALIAS(X509_STORE_CTX_trusted_stack);
void
X509_STORE_CTX_set0_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
{
X509_STORE_CTX_trusted_stack(ctx, sk);
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set0_trusted_stack)
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_trusted_stack);
void
X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx)
ctx, &(ctx->ex_data));
memset(&ctx->ex_data, 0, sizeof(CRYPTO_EX_DATA));
}
-LCRYPTO_ALIAS(X509_STORE_CTX_cleanup)
+LCRYPTO_ALIAS(X509_STORE_CTX_cleanup);
void
X509_STORE_CTX_set_depth(X509_STORE_CTX *ctx, int depth)
{
X509_VERIFY_PARAM_set_depth(ctx->param, depth);
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set_depth)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_depth);
void
X509_STORE_CTX_set_flags(X509_STORE_CTX *ctx, unsigned long flags)
{
X509_VERIFY_PARAM_set_flags(ctx->param, flags);
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set_flags)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_flags);
void
X509_STORE_CTX_set_time(X509_STORE_CTX *ctx, unsigned long flags, time_t t)
{
X509_VERIFY_PARAM_set_time(ctx->param, t);
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set_time)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_time);
int
(*X509_STORE_CTX_get_verify_cb(X509_STORE_CTX *ctx))(int, X509_STORE_CTX *)
{
return ctx->verify_cb;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get_verify_cb)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_verify_cb);
void
X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx,
{
ctx->verify_cb = verify_cb;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set_verify_cb)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_verify_cb);
int
(*X509_STORE_CTX_get_verify(X509_STORE_CTX *ctx))(X509_STORE_CTX *)
{
return ctx->verify;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get_verify)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_verify);
void
X509_STORE_CTX_set_verify(X509_STORE_CTX *ctx, int (*verify)(X509_STORE_CTX *))
{
ctx->verify = verify;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set_verify)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_verify);
X509_STORE_CTX_check_issued_fn
X509_STORE_get_check_issued(X509_STORE *store)
{
return store->check_issued;
}
-LCRYPTO_ALIAS(X509_STORE_get_check_issued)
+LCRYPTO_ALIAS(X509_STORE_get_check_issued);
void
X509_STORE_set_check_issued(X509_STORE *store,
{
store->check_issued = check_issued;
}
-LCRYPTO_ALIAS(X509_STORE_set_check_issued)
+LCRYPTO_ALIAS(X509_STORE_set_check_issued);
X509_STORE_CTX_check_issued_fn
X509_STORE_CTX_get_check_issued(X509_STORE_CTX *ctx)
{
return ctx->check_issued;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get_check_issued)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_check_issued);
X509 *
X509_STORE_CTX_get0_cert(X509_STORE_CTX *ctx)
{
return ctx->cert;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get0_cert)
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_cert);
STACK_OF(X509) *
X509_STORE_CTX_get0_untrusted(X509_STORE_CTX *ctx)
{
return ctx->untrusted;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get0_untrusted)
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_untrusted);
void
X509_STORE_CTX_set0_untrusted(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
{
ctx->untrusted = sk;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set0_untrusted)
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_untrusted);
void
X509_STORE_CTX_set0_verified_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
sk_X509_pop_free(ctx->chain, X509_free);
ctx->chain = sk;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set0_verified_chain)
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_verified_chain);
X509_POLICY_TREE *
X509_STORE_CTX_get0_policy_tree(X509_STORE_CTX *ctx)
{
return ctx->tree;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get0_policy_tree)
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_policy_tree);
int
X509_STORE_CTX_get_explicit_policy(X509_STORE_CTX *ctx)
{
return ctx->explicit_policy;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get_explicit_policy)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_explicit_policy);
int
X509_STORE_CTX_get_num_untrusted(X509_STORE_CTX *ctx)
{
return ctx->num_untrusted;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get_num_untrusted)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_num_untrusted);
int
X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name)
return 0;
return X509_VERIFY_PARAM_inherit(ctx->param, param);
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set_default)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_default);
X509_VERIFY_PARAM *
X509_STORE_CTX_get0_param(X509_STORE_CTX *ctx)
{
return ctx->param;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_get0_param)
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_param);
void
X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param)
X509_VERIFY_PARAM_free(ctx->param);
ctx->param = param;
}
-LCRYPTO_ALIAS(X509_STORE_CTX_set0_param)
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_param);
/*
* Check if |bits| are adequate for |security level|.
-/* $OpenBSD: x509_vpm.c,v 1.32 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509_vpm.c,v 1.33 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2004.
*/
x509_verify_param_zero(param);
return param;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_new)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_new);
void
X509_VERIFY_PARAM_free(X509_VERIFY_PARAM *param)
free(param->id);
free(param);
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_free)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_free);
/*
* This function determines how parameters are "inherited" from one structure
return 1;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_inherit)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_inherit);
int
X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM *to, const X509_VERIFY_PARAM *from)
to->inh_flags = save_flags;
return ret;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1);
static int
x509_param_set1_internal(char **pdest, size_t *pdestlen, const char *src,
return 1;
return 0;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_name)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_name);
int
X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM *param, unsigned long flags)
param->flags |= X509_V_FLAG_POLICY_CHECK;
return 1;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_flags)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_flags);
int
X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM *param, unsigned long flags)
param->flags &= ~flags;
return 1;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_clear_flags)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_clear_flags);
unsigned long
X509_VERIFY_PARAM_get_flags(X509_VERIFY_PARAM *param)
{
return param->flags;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_flags)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_flags);
int
X509_VERIFY_PARAM_set_purpose(X509_VERIFY_PARAM *param, int purpose)
{
return X509_PURPOSE_set(¶m->purpose, purpose);
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_purpose)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_purpose);
int
X509_VERIFY_PARAM_set_trust(X509_VERIFY_PARAM *param, int trust)
{
return X509_TRUST_set(¶m->trust, trust);
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_trust)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_trust);
void
X509_VERIFY_PARAM_set_depth(X509_VERIFY_PARAM *param, int depth)
{
param->depth = depth;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_depth)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_depth);
void
X509_VERIFY_PARAM_set_auth_level(X509_VERIFY_PARAM *param, int auth_level)
{
param->security_level = auth_level;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_auth_level)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_auth_level);
time_t
X509_VERIFY_PARAM_get_time(const X509_VERIFY_PARAM *param)
{
return param->check_time;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_time)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_time);
void
X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM *param, time_t t)
param->check_time = t;
param->flags |= X509_V_FLAG_USE_CHECK_TIME;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_time)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_time);
int
X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM *param, ASN1_OBJECT *policy)
return 0;
return 1;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_add0_policy)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_add0_policy);
int
X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM *param,
param->flags |= X509_V_FLAG_POLICY_CHECK;
return 1;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_policies)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_policies);
int
X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM *param,
param->id->poisoned = 1;
return 0;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_host)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_host);
int
X509_VERIFY_PARAM_add1_host(X509_VERIFY_PARAM *param,
param->id->poisoned = 1;
return 0;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_add1_host)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_add1_host);
void
X509_VERIFY_PARAM_set_hostflags(X509_VERIFY_PARAM *param, unsigned int flags)
{
param->id->hostflags = flags;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_hostflags)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_hostflags);
char *
X509_VERIFY_PARAM_get0_peername(X509_VERIFY_PARAM *param)
{
return param->id->peername;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0_peername)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0_peername);
int
X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM *param, const char *email,
param->id->poisoned = 1;
return 0;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_email)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_email);
int
X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM *param, const unsigned char *ip,
param->id->poisoned = 1;
return 0;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_ip)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_ip);
int
X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM *param, const char *ipasc)
iplen = (size_t)a2i_ipadd(ipout, ipasc);
return X509_VERIFY_PARAM_set1_ip(param, ipout, iplen);
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_ip_asc)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_ip_asc);
int
X509_VERIFY_PARAM_get_depth(const X509_VERIFY_PARAM *param)
{
return param->depth;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_depth)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_depth);
const char *
X509_VERIFY_PARAM_get0_name(const X509_VERIFY_PARAM *param)
{
return param->name;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0_name)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0_name);
static const X509_VERIFY_PARAM_ID _empty_id = { NULL };
return 0;
return 1;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_add0_table)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_add0_table);
int
X509_VERIFY_PARAM_get_count(void)
num += sk_X509_VERIFY_PARAM_num(param_table);
return num;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_count)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_count);
const X509_VERIFY_PARAM *
X509_VERIFY_PARAM_get0(int id)
return default_table + id;
return sk_X509_VERIFY_PARAM_value(param_table, id - num);
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0);
const X509_VERIFY_PARAM *
X509_VERIFY_PARAM_lookup(const char *name)
}
return NULL;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_lookup)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_lookup);
void
X509_VERIFY_PARAM_table_cleanup(void)
X509_VERIFY_PARAM_free);
param_table = NULL;
}
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_table_cleanup)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_table_cleanup);
-/* $OpenBSD: x509cset.c,v 1.18 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509cset.c,v 1.19 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2001.
*/
int refs = CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509_CRL);
return (refs > 1) ? 1 : 0;
}
-LCRYPTO_ALIAS(X509_CRL_up_ref)
+LCRYPTO_ALIAS(X509_CRL_up_ref);
int
X509_CRL_set_version(X509_CRL *x, long version)
}
return (ASN1_INTEGER_set(x->crl->version, version));
}
-LCRYPTO_ALIAS(X509_CRL_set_version)
+LCRYPTO_ALIAS(X509_CRL_set_version);
int
X509_CRL_set_issuer_name(X509_CRL *x, X509_NAME *name)
return (0);
return (X509_NAME_set(&x->crl->issuer, name));
}
-LCRYPTO_ALIAS(X509_CRL_set_issuer_name)
+LCRYPTO_ALIAS(X509_CRL_set_issuer_name);
int
X509_CRL_set_lastUpdate(X509_CRL *x, const ASN1_TIME *tm)
}
return (in != NULL);
}
-LCRYPTO_ALIAS(X509_CRL_set_lastUpdate)
+LCRYPTO_ALIAS(X509_CRL_set_lastUpdate);
int
X509_CRL_set1_lastUpdate(X509_CRL *x, const ASN1_TIME *tm)
{
return X509_CRL_set_lastUpdate(x, tm);
}
-LCRYPTO_ALIAS(X509_CRL_set1_lastUpdate)
+LCRYPTO_ALIAS(X509_CRL_set1_lastUpdate);
int
X509_CRL_set_nextUpdate(X509_CRL *x, const ASN1_TIME *tm)
}
return (in != NULL);
}
-LCRYPTO_ALIAS(X509_CRL_set_nextUpdate)
+LCRYPTO_ALIAS(X509_CRL_set_nextUpdate);
int
X509_CRL_set1_nextUpdate(X509_CRL *x, const ASN1_TIME *tm)
{
return X509_CRL_set_nextUpdate(x, tm);
}
-LCRYPTO_ALIAS(X509_CRL_set1_nextUpdate)
+LCRYPTO_ALIAS(X509_CRL_set1_nextUpdate);
int
X509_CRL_sort(X509_CRL *c)
c->crl->enc.modified = 1;
return 1;
}
-LCRYPTO_ALIAS(X509_CRL_sort)
+LCRYPTO_ALIAS(X509_CRL_sort);
const STACK_OF(X509_EXTENSION) *
X509_REVOKED_get0_extensions(const X509_REVOKED *x)
{
return x->extensions;
}
-LCRYPTO_ALIAS(X509_REVOKED_get0_extensions)
+LCRYPTO_ALIAS(X509_REVOKED_get0_extensions);
const ASN1_TIME *
X509_REVOKED_get0_revocationDate(const X509_REVOKED *x)
{
return x->revocationDate;
}
-LCRYPTO_ALIAS(X509_REVOKED_get0_revocationDate)
+LCRYPTO_ALIAS(X509_REVOKED_get0_revocationDate);
const ASN1_INTEGER *
X509_REVOKED_get0_serialNumber(const X509_REVOKED *x)
{
return x->serialNumber;
}
-LCRYPTO_ALIAS(X509_REVOKED_get0_serialNumber)
+LCRYPTO_ALIAS(X509_REVOKED_get0_serialNumber);
int
X509_REVOKED_set_revocationDate(X509_REVOKED *x, ASN1_TIME *tm)
}
return (in != NULL);
}
-LCRYPTO_ALIAS(X509_REVOKED_set_revocationDate)
+LCRYPTO_ALIAS(X509_REVOKED_set_revocationDate);
int
X509_REVOKED_set_serialNumber(X509_REVOKED *x, ASN1_INTEGER *serial)
}
return (in != NULL);
}
-LCRYPTO_ALIAS(X509_REVOKED_set_serialNumber)
+LCRYPTO_ALIAS(X509_REVOKED_set_serialNumber);
int
i2d_re_X509_CRL_tbs(X509_CRL *crl, unsigned char **pp)
crl->crl->enc.modified = 1;
return i2d_X509_CRL_INFO(crl->crl, pp);
}
-LCRYPTO_ALIAS(i2d_re_X509_CRL_tbs)
+LCRYPTO_ALIAS(i2d_re_X509_CRL_tbs);
-/* $OpenBSD: x509name.c,v 1.30 2022/12/26 07:18:53 jmc Exp $ */
+/* $OpenBSD: x509name.c,v 1.31 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
return (-1);
return (X509_NAME_get_text_by_OBJ(name, obj, buf, len));
}
-LCRYPTO_ALIAS(X509_NAME_get_text_by_NID)
+LCRYPTO_ALIAS(X509_NAME_get_text_by_NID);
int
X509_NAME_get_text_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, char *buf,
}
return (i);
}
-LCRYPTO_ALIAS(X509_NAME_get_text_by_OBJ)
+LCRYPTO_ALIAS(X509_NAME_get_text_by_OBJ);
int
X509_NAME_entry_count(const X509_NAME *name)
return (0);
return (sk_X509_NAME_ENTRY_num(name->entries));
}
-LCRYPTO_ALIAS(X509_NAME_entry_count)
+LCRYPTO_ALIAS(X509_NAME_entry_count);
int
X509_NAME_get_index_by_NID(const X509_NAME *name, int nid, int lastpos)
return (-2);
return (X509_NAME_get_index_by_OBJ(name, obj, lastpos));
}
-LCRYPTO_ALIAS(X509_NAME_get_index_by_NID)
+LCRYPTO_ALIAS(X509_NAME_get_index_by_NID);
/* NOTE: you should be passing -1, not 0 as lastpos */
int
}
return (-1);
}
-LCRYPTO_ALIAS(X509_NAME_get_index_by_OBJ)
+LCRYPTO_ALIAS(X509_NAME_get_index_by_OBJ);
X509_NAME_ENTRY *
X509_NAME_get_entry(const X509_NAME *name, int loc)
else
return (sk_X509_NAME_ENTRY_value(name->entries, loc));
}
-LCRYPTO_ALIAS(X509_NAME_get_entry)
+LCRYPTO_ALIAS(X509_NAME_get_entry);
X509_NAME_ENTRY *
X509_NAME_delete_entry(X509_NAME *name, int loc)
sk_X509_NAME_ENTRY_value(sk, i)->set--;
return (ret);
}
-LCRYPTO_ALIAS(X509_NAME_delete_entry)
+LCRYPTO_ALIAS(X509_NAME_delete_entry);
int
X509_NAME_add_entry_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, int type,
X509_NAME_ENTRY_free(ne);
return ret;
}
-LCRYPTO_ALIAS(X509_NAME_add_entry_by_OBJ)
+LCRYPTO_ALIAS(X509_NAME_add_entry_by_OBJ);
int
X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type,
X509_NAME_ENTRY_free(ne);
return ret;
}
-LCRYPTO_ALIAS(X509_NAME_add_entry_by_NID)
+LCRYPTO_ALIAS(X509_NAME_add_entry_by_NID);
int
X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type,
X509_NAME_ENTRY_free(ne);
return ret;
}
-LCRYPTO_ALIAS(X509_NAME_add_entry_by_txt)
+LCRYPTO_ALIAS(X509_NAME_add_entry_by_txt);
/* if set is -1, append to previous set, 0 'a new one', and 1,
* prepend to the guy we are about to stomp on. */
X509_NAME_ENTRY_free(new_name);
return (0);
}
-LCRYPTO_ALIAS(X509_NAME_add_entry)
+LCRYPTO_ALIAS(X509_NAME_add_entry);
X509_NAME_ENTRY *
X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne,
ASN1_OBJECT_free(obj);
return nentry;
}
-LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_txt)
+LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_txt);
X509_NAME_ENTRY *
X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid, int type,
ASN1_OBJECT_free(obj);
return nentry;
}
-LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_NID)
+LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_NID);
X509_NAME_ENTRY *
X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne, const ASN1_OBJECT *obj,
X509_NAME_ENTRY_free(ret);
return (NULL);
}
-LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_OBJ)
+LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_OBJ);
int
X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, const ASN1_OBJECT *obj)
ne->object = OBJ_dup(obj);
return ((ne->object == NULL) ? 0 : 1);
}
-LCRYPTO_ALIAS(X509_NAME_ENTRY_set_object)
+LCRYPTO_ALIAS(X509_NAME_ENTRY_set_object);
int
X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type,
}
return (1);
}
-LCRYPTO_ALIAS(X509_NAME_ENTRY_set_data)
+LCRYPTO_ALIAS(X509_NAME_ENTRY_set_data);
ASN1_OBJECT *
X509_NAME_ENTRY_get_object(const X509_NAME_ENTRY *ne)
return (NULL);
return (ne->object);
}
-LCRYPTO_ALIAS(X509_NAME_ENTRY_get_object)
+LCRYPTO_ALIAS(X509_NAME_ENTRY_get_object);
ASN1_STRING *
X509_NAME_ENTRY_get_data(const X509_NAME_ENTRY *ne)
return (NULL);
return (ne->value);
}
-LCRYPTO_ALIAS(X509_NAME_ENTRY_get_data)
+LCRYPTO_ALIAS(X509_NAME_ENTRY_get_data);
int
X509_NAME_ENTRY_set(const X509_NAME_ENTRY *ne)
{
return (ne->set);
}
-LCRYPTO_ALIAS(X509_NAME_ENTRY_set)
+LCRYPTO_ALIAS(X509_NAME_ENTRY_set);
-/* $OpenBSD: x509rset.c,v 1.11 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509rset.c,v 1.12 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
x->req_info->enc.modified = 1;
return (ASN1_INTEGER_set(x->req_info->version, version));
}
-LCRYPTO_ALIAS(X509_REQ_set_version)
+LCRYPTO_ALIAS(X509_REQ_set_version);
long
X509_REQ_get_version(const X509_REQ *x)
{
return ASN1_INTEGER_get(x->req_info->version);
}
-LCRYPTO_ALIAS(X509_REQ_get_version)
+LCRYPTO_ALIAS(X509_REQ_get_version);
int
X509_REQ_set_subject_name(X509_REQ *x, X509_NAME *name)
x->req_info->enc.modified = 1;
return (X509_NAME_set(&x->req_info->subject, name));
}
-LCRYPTO_ALIAS(X509_REQ_set_subject_name)
+LCRYPTO_ALIAS(X509_REQ_set_subject_name);
X509_NAME *
X509_REQ_get_subject_name(const X509_REQ *x)
{
return x->req_info->subject;
}
-LCRYPTO_ALIAS(X509_REQ_get_subject_name)
+LCRYPTO_ALIAS(X509_REQ_get_subject_name);
int
X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey)
x->req_info->enc.modified = 1;
return (X509_PUBKEY_set(&x->req_info->pubkey, pkey));
}
-LCRYPTO_ALIAS(X509_REQ_set_pubkey)
+LCRYPTO_ALIAS(X509_REQ_set_pubkey);
-/* $OpenBSD: x509spki.c,v 1.15 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509spki.c,v 1.16 2023/02/16 08:38:17 tb Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
return (0);
return (X509_PUBKEY_set(&(x->spkac->pubkey), pkey));
}
-LCRYPTO_ALIAS(NETSCAPE_SPKI_set_pubkey)
+LCRYPTO_ALIAS(NETSCAPE_SPKI_set_pubkey);
EVP_PKEY *
NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x)
return (NULL);
return (X509_PUBKEY_get(x->spkac->pubkey));
}
-LCRYPTO_ALIAS(NETSCAPE_SPKI_get_pubkey)
+LCRYPTO_ALIAS(NETSCAPE_SPKI_get_pubkey);
/* Load a Netscape SPKI from a base64 encoded string */
free(spki_der);
return spki;
}
-LCRYPTO_ALIAS(NETSCAPE_SPKI_b64_decode)
+LCRYPTO_ALIAS(NETSCAPE_SPKI_b64_decode);
/* Generate a base64 encoded string from an SPKI */
free(der_spki);
return b64_str;
}
-LCRYPTO_ALIAS(NETSCAPE_SPKI_b64_encode)
+LCRYPTO_ALIAS(NETSCAPE_SPKI_b64_encode);
-/* $OpenBSD: x509type.c,v 1.17 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509type.c,v 1.18 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
ret |= EVP_PKT_EXP;
return (ret);
}
-LCRYPTO_ALIAS(X509_certificate_type)
+LCRYPTO_ALIAS(X509_certificate_type);
-/* $OpenBSD: x_all.c,v 1.29 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x_all.c,v 1.30 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
{
return ASN1_item_d2i_bio(&X509_it, bp, x509);
}
-LCRYPTO_ALIAS(d2i_X509_bio)
+LCRYPTO_ALIAS(d2i_X509_bio);
int
i2d_X509_bio(BIO *bp, X509 *x509)
{
return ASN1_item_i2d_bio(&X509_it, bp, x509);
}
-LCRYPTO_ALIAS(i2d_X509_bio)
+LCRYPTO_ALIAS(i2d_X509_bio);
X509 *
d2i_X509_fp(FILE *fp, X509 **x509)
{
return ASN1_item_d2i_fp(&X509_it, fp, x509);
}
-LCRYPTO_ALIAS(d2i_X509_fp)
+LCRYPTO_ALIAS(d2i_X509_fp);
int
i2d_X509_fp(FILE *fp, X509 *x509)
{
return ASN1_item_i2d_fp(&X509_it, fp, x509);
}
-LCRYPTO_ALIAS(i2d_X509_fp)
+LCRYPTO_ALIAS(i2d_X509_fp);
X509_CRL *
d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl)
{
return ASN1_item_d2i_bio(&X509_CRL_it, bp, crl);
}
-LCRYPTO_ALIAS(d2i_X509_CRL_bio)
+LCRYPTO_ALIAS(d2i_X509_CRL_bio);
int
i2d_X509_CRL_bio(BIO *bp, X509_CRL *crl)
{
return ASN1_item_i2d_bio(&X509_CRL_it, bp, crl);
}
-LCRYPTO_ALIAS(i2d_X509_CRL_bio)
+LCRYPTO_ALIAS(i2d_X509_CRL_bio);
X509_CRL *
d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl)
{
return ASN1_item_d2i_fp(&X509_CRL_it, fp, crl);
}
-LCRYPTO_ALIAS(d2i_X509_CRL_fp)
+LCRYPTO_ALIAS(d2i_X509_CRL_fp);
int
i2d_X509_CRL_fp(FILE *fp, X509_CRL *crl)
{
return ASN1_item_i2d_fp(&X509_CRL_it, fp, crl);
}
-LCRYPTO_ALIAS(i2d_X509_CRL_fp)
+LCRYPTO_ALIAS(i2d_X509_CRL_fp);
X509_REQ *
d2i_X509_REQ_bio(BIO *bp, X509_REQ **req)
{
return ASN1_item_d2i_bio(&X509_REQ_it, bp, req);
}
-LCRYPTO_ALIAS(d2i_X509_REQ_bio)
+LCRYPTO_ALIAS(d2i_X509_REQ_bio);
int
i2d_X509_REQ_bio(BIO *bp, X509_REQ *req)
{
return ASN1_item_i2d_bio(&X509_REQ_it, bp, req);
}
-LCRYPTO_ALIAS(i2d_X509_REQ_bio)
+LCRYPTO_ALIAS(i2d_X509_REQ_bio);
X509_REQ *
d2i_X509_REQ_fp(FILE *fp, X509_REQ **req)
{
return ASN1_item_d2i_fp(&X509_REQ_it, fp, req);
}
-LCRYPTO_ALIAS(d2i_X509_REQ_fp)
+LCRYPTO_ALIAS(d2i_X509_REQ_fp);
int
i2d_X509_REQ_fp(FILE *fp, X509_REQ *req)
{
return ASN1_item_i2d_fp(&X509_REQ_it, fp, req);
}
-LCRYPTO_ALIAS(i2d_X509_REQ_fp)
+LCRYPTO_ALIAS(i2d_X509_REQ_fp);
#ifndef OPENSSL_NO_RSA
RSA *
{
return ASN1_item_d2i_bio(&RSAPrivateKey_it, bp, rsa);
}
-LCRYPTO_ALIAS(d2i_RSAPrivateKey_bio)
+LCRYPTO_ALIAS(d2i_RSAPrivateKey_bio);
int
i2d_RSAPrivateKey_bio(BIO *bp, RSA *rsa)
{
return ASN1_item_i2d_bio(&RSAPrivateKey_it, bp, rsa);
}
-LCRYPTO_ALIAS(i2d_RSAPrivateKey_bio)
+LCRYPTO_ALIAS(i2d_RSAPrivateKey_bio);
RSA *
d2i_RSAPrivateKey_fp(FILE *fp, RSA **rsa)
{
return ASN1_item_d2i_fp(&RSAPrivateKey_it, fp, rsa);
}
-LCRYPTO_ALIAS(d2i_RSAPrivateKey_fp)
+LCRYPTO_ALIAS(d2i_RSAPrivateKey_fp);
int
i2d_RSAPrivateKey_fp(FILE *fp, RSA *rsa)
{
return ASN1_item_i2d_fp(&RSAPrivateKey_it, fp, rsa);
}
-LCRYPTO_ALIAS(i2d_RSAPrivateKey_fp)
+LCRYPTO_ALIAS(i2d_RSAPrivateKey_fp);
RSA *
d2i_RSAPublicKey_bio(BIO *bp, RSA **rsa)
{
return ASN1_item_d2i_bio(&RSAPublicKey_it, bp, rsa);
}
-LCRYPTO_ALIAS(d2i_RSAPublicKey_bio)
+LCRYPTO_ALIAS(d2i_RSAPublicKey_bio);
int
i2d_RSAPublicKey_bio(BIO *bp, RSA *rsa)
{
return ASN1_item_i2d_bio(&RSAPublicKey_it, bp, rsa);
}
-LCRYPTO_ALIAS(i2d_RSAPublicKey_bio)
+LCRYPTO_ALIAS(i2d_RSAPublicKey_bio);
RSA *
d2i_RSAPublicKey_fp(FILE *fp, RSA **rsa)
{
return ASN1_item_d2i_fp(&RSAPublicKey_it, fp, rsa);
}
-LCRYPTO_ALIAS(d2i_RSAPublicKey_fp)
+LCRYPTO_ALIAS(d2i_RSAPublicKey_fp);
int
i2d_RSAPublicKey_fp(FILE *fp, RSA *rsa)
{
return ASN1_item_i2d_fp(&RSAPublicKey_it, fp, rsa);
}
-LCRYPTO_ALIAS(i2d_RSAPublicKey_fp)
+LCRYPTO_ALIAS(i2d_RSAPublicKey_fp);
#endif
#ifndef OPENSSL_NO_DSA
{
return ASN1_item_d2i_bio(&DSAPrivateKey_it, bp, dsa);
}
-LCRYPTO_ALIAS(d2i_DSAPrivateKey_bio)
+LCRYPTO_ALIAS(d2i_DSAPrivateKey_bio);
int
i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa)
{
return ASN1_item_i2d_bio(&DSAPrivateKey_it, bp, dsa);
}
-LCRYPTO_ALIAS(i2d_DSAPrivateKey_bio)
+LCRYPTO_ALIAS(i2d_DSAPrivateKey_bio);
DSA *
d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa)
{
return ASN1_item_d2i_fp(&DSAPrivateKey_it, fp, dsa);
}
-LCRYPTO_ALIAS(d2i_DSAPrivateKey_fp)
+LCRYPTO_ALIAS(d2i_DSAPrivateKey_fp);
int
i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa)
{
return ASN1_item_i2d_fp(&DSAPrivateKey_it, fp, dsa);
}
-LCRYPTO_ALIAS(i2d_DSAPrivateKey_fp)
+LCRYPTO_ALIAS(i2d_DSAPrivateKey_fp);
#endif
#ifndef OPENSSL_NO_EC
{
return ASN1_d2i_bio_of(EC_KEY, EC_KEY_new, d2i_ECPrivateKey, bp, eckey);
}
-LCRYPTO_ALIAS(d2i_ECPrivateKey_bio)
+LCRYPTO_ALIAS(d2i_ECPrivateKey_bio);
int
i2d_ECPrivateKey_bio(BIO *bp, EC_KEY *eckey)
{
return ASN1_i2d_bio_of(EC_KEY, i2d_ECPrivateKey, bp, eckey);
}
-LCRYPTO_ALIAS(i2d_ECPrivateKey_bio)
+LCRYPTO_ALIAS(i2d_ECPrivateKey_bio);
EC_KEY *
d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey)
{
return ASN1_d2i_fp_of(EC_KEY, EC_KEY_new, d2i_ECPrivateKey, fp, eckey);
}
-LCRYPTO_ALIAS(d2i_ECPrivateKey_fp)
+LCRYPTO_ALIAS(d2i_ECPrivateKey_fp);
int
i2d_ECPrivateKey_fp(FILE *fp, EC_KEY *eckey)
{
return ASN1_i2d_fp_of(EC_KEY, i2d_ECPrivateKey, fp, eckey);
}
-LCRYPTO_ALIAS(i2d_ECPrivateKey_fp)
+LCRYPTO_ALIAS(i2d_ECPrivateKey_fp);
#endif
X509_SIG *
{
return ASN1_item_d2i_bio(&X509_SIG_it, bp, p8);
}
-LCRYPTO_ALIAS(d2i_PKCS8_bio)
+LCRYPTO_ALIAS(d2i_PKCS8_bio);
int
i2d_PKCS8_bio(BIO *bp, X509_SIG *p8)
{
return ASN1_item_i2d_bio(&X509_SIG_it, bp, p8);
}
-LCRYPTO_ALIAS(i2d_PKCS8_bio)
+LCRYPTO_ALIAS(i2d_PKCS8_bio);
X509_SIG *
d2i_PKCS8_fp(FILE *fp, X509_SIG **p8)
{
return ASN1_item_d2i_fp(&X509_SIG_it, fp, p8);
}
-LCRYPTO_ALIAS(d2i_PKCS8_fp)
+LCRYPTO_ALIAS(d2i_PKCS8_fp);
int
i2d_PKCS8_fp(FILE *fp, X509_SIG *p8)
{
return ASN1_item_i2d_fp(&X509_SIG_it, fp, p8);
}
-LCRYPTO_ALIAS(i2d_PKCS8_fp)
+LCRYPTO_ALIAS(i2d_PKCS8_fp);
PKCS8_PRIV_KEY_INFO *
d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO **p8inf)
return ASN1_item_d2i_bio(&PKCS8_PRIV_KEY_INFO_it, bp,
p8inf);
}
-LCRYPTO_ALIAS(d2i_PKCS8_PRIV_KEY_INFO_bio)
+LCRYPTO_ALIAS(d2i_PKCS8_PRIV_KEY_INFO_bio);
int
i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO *p8inf)
return ASN1_item_i2d_bio(&PKCS8_PRIV_KEY_INFO_it, bp,
p8inf);
}
-LCRYPTO_ALIAS(i2d_PKCS8_PRIV_KEY_INFO_bio)
+LCRYPTO_ALIAS(i2d_PKCS8_PRIV_KEY_INFO_bio);
PKCS8_PRIV_KEY_INFO *
d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO **p8inf)
return ASN1_item_d2i_fp(&PKCS8_PRIV_KEY_INFO_it, fp,
p8inf);
}
-LCRYPTO_ALIAS(d2i_PKCS8_PRIV_KEY_INFO_fp)
+LCRYPTO_ALIAS(d2i_PKCS8_PRIV_KEY_INFO_fp);
int
i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO *p8inf)
return ASN1_item_i2d_fp(&PKCS8_PRIV_KEY_INFO_it, fp,
p8inf);
}
-LCRYPTO_ALIAS(i2d_PKCS8_PRIV_KEY_INFO_fp)
+LCRYPTO_ALIAS(i2d_PKCS8_PRIV_KEY_INFO_fp);
EVP_PKEY *
d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a)
return ASN1_d2i_bio_of(EVP_PKEY, EVP_PKEY_new, d2i_AutoPrivateKey,
bp, a);
}
-LCRYPTO_ALIAS(d2i_PrivateKey_bio)
+LCRYPTO_ALIAS(d2i_PrivateKey_bio);
int
i2d_PrivateKey_bio(BIO *bp, EVP_PKEY *pkey)
{
return ASN1_i2d_bio_of(EVP_PKEY, i2d_PrivateKey, bp, pkey);
}
-LCRYPTO_ALIAS(i2d_PrivateKey_bio)
+LCRYPTO_ALIAS(i2d_PrivateKey_bio);
EVP_PKEY *
d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a)
return ASN1_d2i_fp_of(EVP_PKEY, EVP_PKEY_new, d2i_AutoPrivateKey,
fp, a);
}
-LCRYPTO_ALIAS(d2i_PrivateKey_fp)
+LCRYPTO_ALIAS(d2i_PrivateKey_fp);
int
i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *pkey)
{
return ASN1_i2d_fp_of(EVP_PKEY, i2d_PrivateKey, fp, pkey);
}
-LCRYPTO_ALIAS(i2d_PrivateKey_fp)
+LCRYPTO_ALIAS(i2d_PrivateKey_fp);
int
i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key)
PKCS8_PRIV_KEY_INFO_free(p8inf);
return ret;
}
-LCRYPTO_ALIAS(i2d_PKCS8PrivateKeyInfo_bio)
+LCRYPTO_ALIAS(i2d_PKCS8PrivateKeyInfo_bio);
int
i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key)
PKCS8_PRIV_KEY_INFO_free(p8inf);
return ret;
}
-LCRYPTO_ALIAS(i2d_PKCS8PrivateKeyInfo_fp)
+LCRYPTO_ALIAS(i2d_PKCS8PrivateKeyInfo_fp);
int
X509_verify(X509 *a, EVP_PKEY *r)
return (ASN1_item_verify(&X509_CINF_it, a->sig_alg,
a->signature, a->cert_info, r));
}
-LCRYPTO_ALIAS(X509_verify)
+LCRYPTO_ALIAS(X509_verify);
int
X509_REQ_verify(X509_REQ *a, EVP_PKEY *r)
return (ASN1_item_verify(&X509_REQ_INFO_it,
a->sig_alg, a->signature, a->req_info, r));
}
-LCRYPTO_ALIAS(X509_REQ_verify)
+LCRYPTO_ALIAS(X509_REQ_verify);
int
NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r)
return (ASN1_item_verify(&NETSCAPE_SPKAC_it,
a->sig_algor, a->signature, a->spkac, r));
}
-LCRYPTO_ALIAS(NETSCAPE_SPKI_verify)
+LCRYPTO_ALIAS(NETSCAPE_SPKI_verify);
int
X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md)
x->cert_info->signature, x->sig_alg, x->signature,
x->cert_info, pkey, md));
}
-LCRYPTO_ALIAS(X509_sign)
+LCRYPTO_ALIAS(X509_sign);
int
X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx)
x->cert_info->signature, x->sig_alg, x->signature,
x->cert_info, ctx);
}
-LCRYPTO_ALIAS(X509_sign_ctx)
+LCRYPTO_ALIAS(X509_sign_ctx);
int
X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md)
return (ASN1_item_sign(&X509_REQ_INFO_it,
x->sig_alg, NULL, x->signature, x->req_info, pkey, md));
}
-LCRYPTO_ALIAS(X509_REQ_sign)
+LCRYPTO_ALIAS(X509_REQ_sign);
int
X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx)
return ASN1_item_sign_ctx(&X509_REQ_INFO_it,
x->sig_alg, NULL, x->signature, x->req_info, ctx);
}
-LCRYPTO_ALIAS(X509_REQ_sign_ctx)
+LCRYPTO_ALIAS(X509_REQ_sign_ctx);
int
X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md)
return(ASN1_item_sign(&X509_CRL_INFO_it, x->crl->sig_alg,
x->sig_alg, x->signature, x->crl, pkey, md));
}
-LCRYPTO_ALIAS(X509_CRL_sign)
+LCRYPTO_ALIAS(X509_CRL_sign);
int
X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx)
return ASN1_item_sign_ctx(&X509_CRL_INFO_it,
x->crl->sig_alg, x->sig_alg, x->signature, x->crl, ctx);
}
-LCRYPTO_ALIAS(X509_CRL_sign_ctx)
+LCRYPTO_ALIAS(X509_CRL_sign_ctx);
int
NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md)
return (ASN1_item_sign(&NETSCAPE_SPKAC_it,
x->sig_algor, NULL, x->signature, x->spkac, pkey, md));
}
-LCRYPTO_ALIAS(NETSCAPE_SPKI_sign)
+LCRYPTO_ALIAS(NETSCAPE_SPKI_sign);
int
X509_pubkey_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
return 0;
return EVP_Digest(key->data, key->length, md, len, type, NULL);
}
-LCRYPTO_ALIAS(X509_pubkey_digest)
+LCRYPTO_ALIAS(X509_pubkey_digest);
int
X509_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
return (ASN1_item_digest(&X509_it, type, (char *)data,
md, len));
}
-LCRYPTO_ALIAS(X509_digest)
+LCRYPTO_ALIAS(X509_digest);
int
X509_CRL_digest(const X509_CRL *data, const EVP_MD *type, unsigned char *md,
return (ASN1_item_digest(&X509_CRL_it, type, (char *)data,
md, len));
}
-LCRYPTO_ALIAS(X509_CRL_digest)
+LCRYPTO_ALIAS(X509_CRL_digest);
int
X509_REQ_digest(const X509_REQ *data, const EVP_MD *type, unsigned char *md,
return (ASN1_item_digest(&X509_REQ_it, type, (char *)data,
md, len));
}
-LCRYPTO_ALIAS(X509_REQ_digest)
+LCRYPTO_ALIAS(X509_REQ_digest);
int
X509_NAME_digest(const X509_NAME *data, const EVP_MD *type, unsigned char *md,
return (ASN1_item_digest(&X509_NAME_it, type, (char *)data,
md, len));
}
-LCRYPTO_ALIAS(X509_NAME_digest)
+LCRYPTO_ALIAS(X509_NAME_digest);
int
X509_up_ref(X509 *x)
int i = CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);
return i > 1 ? 1 : 0;
}
-LCRYPTO_ALIAS(X509_up_ref)
+LCRYPTO_ALIAS(X509_up_ref);
-/* $OpenBSD: bio_ssl.c,v 1.37 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: bio_ssl.c,v 1.38 2023/02/16 08:38:17 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
{
return (&methods_sslp);
}
-LSSL_ALIAS(BIO_f_ssl)
+LSSL_ALIAS(BIO_f_ssl);
static int
ssl_new(BIO *bi)
BIO_free(ssl);
return (NULL);
}
-LSSL_ALIAS(BIO_new_ssl_connect)
+LSSL_ALIAS(BIO_new_ssl_connect);
BIO *
BIO_new_ssl(SSL_CTX *ctx, int client)
BIO_free(ret);
return (NULL);
}
-LSSL_ALIAS(BIO_new_ssl)
+LSSL_ALIAS(BIO_new_ssl);
int
BIO_ssl_copy_session_id(BIO *t, BIO *f)
-/* $OpenBSD: ssl_namespace.h,v 1.1 2022/11/11 11:25:18 beck Exp $ */
+/* $OpenBSD: ssl_namespace.h,v 1.2 2023/02/16 08:38:17 tb Exp $ */
/*
* Copyright (c) 2016 Philip Guenther <guenther@openbsd.org>
*
#define LSSL_UNUSED(x) typeof(x) x __attribute__((deprecated))
#define LSSL_USED(x) __attribute__((visibility("hidden"))) \
typeof(x) x asm("_lssl_"#x)
-#define LSSL_ALIAS(x) asm(".global "#x"; "#x" = _lssl_"#x);
+#define LSSL_ALIAS(x) asm(".global "#x"; "#x" = _lssl_"#x)
#else
#define LSSL_UNUSED(x)
#define LSSL_USED(x)
-#define LSSL_ALIAS(x)
+#define LSSL_ALIAS(x) asm("")
#endif
#endif /* _LIBSSL_SSL_NAMESPACE_H_ */
projects / openbsd / commitdiff