Hide symbols in asn1 and bio

ok jsing@

1 files changed, 51 insertions, 1 deletions

diff --git a/src/lib/libcrypto/bio/bio_lib.c b/src/lib/libcrypto/bio/bio_lib.c
index d14507884b..31127cb444 100644
--- a/src/lib/libcrypto/bio/bio_lib.c
+++ b/src/lib/libcrypto/bio/bio_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: bio_lib.c,v 1.44 2023/03/15 06:14:02 tb Exp $ */
+/* $OpenBSD: bio_lib.c,v 1.45 2023/07/05 21:23:37 beck Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -129,6 +129,7 @@ BIO_get_new_index(void)
 
         return index;
 }
+LCRYPTO_ALIAS(BIO_get_new_index);
 
 BIO *
 BIO_new(const BIO_METHOD *method)
@@ -147,6 +148,7 @@ BIO_new(const BIO_METHOD *method)
         }
         return (ret);
 }
+LCRYPTO_ALIAS(BIO_new);
 
 int
 BIO_set(BIO *bio, const BIO_METHOD *method)
@@ -176,6 +178,7 @@ BIO_set(BIO *bio, const BIO_METHOD *method)
         }
         return (1);
 }
+LCRYPTO_ALIAS(BIO_set);
 
 int
 BIO_free(BIO *a)
@@ -201,12 +204,14 @@ BIO_free(BIO *a)
         free(a);
         return (1);
 }
+LCRYPTO_ALIAS(BIO_free);
 
 void
 BIO_vfree(BIO *a)
 {
         BIO_free(a);
 }
+LCRYPTO_ALIAS(BIO_vfree);
 
 int
 BIO_up_ref(BIO *bio)
@@ -214,108 +219,126 @@ BIO_up_ref(BIO *bio)
         int refs = CRYPTO_add(&bio->references, 1, CRYPTO_LOCK_BIO);
         return (refs > 1) ? 1 : 0;
 }
+LCRYPTO_ALIAS(BIO_up_ref);
 
 void *
 BIO_get_data(BIO *a)
 {
         return (a->ptr);
 }
+LCRYPTO_ALIAS(BIO_get_data);
 
 void
 BIO_set_data(BIO *a, void *ptr)
 {
         a->ptr = ptr;
 }
+LCRYPTO_ALIAS(BIO_set_data);
 
 int
 BIO_get_init(BIO *a)
 {
         return a->init;
 }
+LCRYPTO_ALIAS(BIO_get_init);
 
 void
 BIO_set_init(BIO *a, int init)
 {
         a->init = init;
 }
+LCRYPTO_ALIAS(BIO_set_init);
 
 int
 BIO_get_shutdown(BIO *a)
 {
         return (a->shutdown);
 }
+LCRYPTO_ALIAS(BIO_get_shutdown);
 
 void
 BIO_set_shutdown(BIO *a, int shut)
 {
         a->shutdown = shut;
 }
+LCRYPTO_ALIAS(BIO_set_shutdown);
 
 void
 BIO_clear_flags(BIO *b, int flags)
 {
         b->flags &= ~flags;
 }
+LCRYPTO_ALIAS(BIO_clear_flags);
 
 int
 BIO_test_flags(const BIO *b, int flags)
 {
         return (b->flags & flags);
 }
+LCRYPTO_ALIAS(BIO_test_flags);
 
 void
 BIO_set_flags(BIO *b, int flags)
 {
         b->flags |= flags;
 }
+LCRYPTO_ALIAS(BIO_set_flags);
 
 BIO_callback_fn
 BIO_get_callback(const BIO *b)
 {
         return b->callback;
 }
+LCRYPTO_ALIAS(BIO_get_callback);
 
 void
 BIO_set_callback(BIO *b, BIO_callback_fn cb)
 {
         b->callback = cb;
 }
+LCRYPTO_ALIAS(BIO_set_callback);
 
 BIO_callback_fn_ex
 BIO_get_callback_ex(const BIO *b)
 {
         return b->callback_ex;
 }
+LCRYPTO_ALIAS(BIO_get_callback_ex);
 
 void
 BIO_set_callback_ex(BIO *b, BIO_callback_fn_ex cb)
 {
         b->callback_ex = cb;
 }
+LCRYPTO_ALIAS(BIO_set_callback_ex);
 
 void
 BIO_set_callback_arg(BIO *b, char *arg)
 {
         b->cb_arg = arg;
 }
+LCRYPTO_ALIAS(BIO_set_callback_arg);
 
 char *
 BIO_get_callback_arg(const BIO *b)
 {
         return b->cb_arg;
 }
+LCRYPTO_ALIAS(BIO_get_callback_arg);
 
 const char *
 BIO_method_name(const BIO *b)
 {
         return b->method->name;
 }
+LCRYPTO_ALIAS(BIO_method_name);
 
 int
 BIO_method_type(const BIO *b)
 {
         return b->method->type;
 }
+LCRYPTO_ALIAS(BIO_method_type);
 
 int
 BIO_read(BIO *b, void *out, int outl)
@@ -373,6 +396,7 @@ BIO_read(BIO *b, void *out, int outl)
 
         return (ret);
 }
+LCRYPTO_ALIAS(BIO_read);
 
 int
 BIO_write(BIO *b, const void *in, int inl)
@@ -429,6 +453,7 @@ BIO_write(BIO *b, const void *in, int inl)
 
         return (ret);
 }
+LCRYPTO_ALIAS(BIO_write);
 
 int
 BIO_puts(BIO *b, const char *in)
@@ -473,6 +498,7 @@ BIO_puts(BIO *b, const char *in)
 
         return (ret);
 }
+LCRYPTO_ALIAS(BIO_puts);
 
 int
 BIO_gets(BIO *b, char *in, int inl)
@@ -515,6 +541,7 @@ BIO_gets(BIO *b, char *in, int inl)
 
         return (ret);
 }
+LCRYPTO_ALIAS(BIO_gets);
 
 int
 BIO_indent(BIO *b, int indent, int max)
@@ -528,6 +555,7 @@ BIO_indent(BIO *b, int indent, int max)
                         return 0;
         return 1;
 }
+LCRYPTO_ALIAS(BIO_indent);
 
 long
 BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg)
@@ -537,6 +565,7 @@ BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg)
         i = iarg;
         return (BIO_ctrl(b, cmd, larg, (char *)&i));
 }
+LCRYPTO_ALIAS(BIO_int_ctrl);
 
 char *
 BIO_ptr_ctrl(BIO *b, int cmd, long larg)
@@ -548,6 +577,7 @@ BIO_ptr_ctrl(BIO *b, int cmd, long larg)
         else
                 return (p);
 }
+LCRYPTO_ALIAS(BIO_ptr_ctrl);
 
 long
 BIO_ctrl(BIO *b, int cmd, long larg, void *parg)
@@ -577,6 +607,7 @@ BIO_ctrl(BIO *b, int cmd, long larg, void *parg)
 
         return (ret);
 }
+LCRYPTO_ALIAS(BIO_ctrl);
 
 long
 BIO_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp)
@@ -607,6 +638,7 @@ BIO_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp)
 
         return (ret);
 }
+LCRYPTO_ALIAS(BIO_callback_ctrl);
 
 /* It is unfortunate to duplicate in functions what the BIO_(w)pending macros
  * do; but those macros have inappropriate return type, and for interfacing
@@ -616,12 +648,14 @@ BIO_ctrl_pending(BIO *bio)
 {
         return BIO_ctrl(bio, BIO_CTRL_PENDING, 0, NULL);
 }
+LCRYPTO_ALIAS(BIO_ctrl_pending);
 
 size_t
 BIO_ctrl_wpending(BIO *bio)
 {
         return BIO_ctrl(bio, BIO_CTRL_WPENDING, 0, NULL);
 }
+LCRYPTO_ALIAS(BIO_ctrl_wpending);
 
 
 /*
@@ -649,6 +683,7 @@ BIO_push(BIO *b, BIO *bio)
         BIO_ctrl(b, BIO_CTRL_PUSH, 0, lb);
         return (b);
 }
+LCRYPTO_ALIAS(BIO_push);
 
 /* Remove the first and return the rest */
 BIO *
@@ -671,6 +706,7 @@ BIO_pop(BIO *b)
         b->prev_bio = NULL;
         return (ret);
 }
+LCRYPTO_ALIAS(BIO_pop);
 
 BIO *
 BIO_get_retry_BIO(BIO *bio, int *reason)
@@ -690,18 +726,21 @@ BIO_get_retry_BIO(BIO *bio, int *reason)
                 *reason = last->retry_reason;
         return (last);
 }
+LCRYPTO_ALIAS(BIO_get_retry_BIO);
 
 int
 BIO_get_retry_reason(BIO *bio)
 {
         return (bio->retry_reason);
 }
+LCRYPTO_ALIAS(BIO_get_retry_reason);
 
 void
 BIO_set_retry_reason(BIO *bio, int reason)
 {
         bio->retry_reason = reason;
 }
+LCRYPTO_ALIAS(BIO_set_retry_reason);
 
 BIO *
 BIO_find_type(BIO *bio, int type)
@@ -724,6 +763,7 @@ BIO_find_type(BIO *bio, int type)
         } while (bio != NULL);
         return (NULL);
 }
+LCRYPTO_ALIAS(BIO_find_type);
 
 BIO *
 BIO_next(BIO *b)
@@ -732,6 +772,7 @@ BIO_next(BIO *b)
                 return NULL;
         return b->next_bio;
 }
+LCRYPTO_ALIAS(BIO_next);
 
 /*
  * Two chains "bio -> oldtail" and "oldhead -> next" become
@@ -753,6 +794,7 @@ BIO_set_next(BIO *bio, BIO *next)
         if (next != NULL)
                 next->prev_bio = bio;
 }
+LCRYPTO_ALIAS(BIO_set_next);
 
 void
 BIO_free_all(BIO *bio)
@@ -770,6 +812,7 @@ BIO_free_all(BIO *bio)
                         break;
         }
 }
+LCRYPTO_ALIAS(BIO_free_all);
 
 BIO *
 BIO_dup_chain(BIO *in)
@@ -813,6 +856,7 @@ err:
         return (NULL);
 
 }
+LCRYPTO_ALIAS(BIO_dup_chain);
 
 void
 BIO_copy_next_retry(BIO *b)
@@ -820,6 +864,7 @@ BIO_copy_next_retry(BIO *b)
         BIO_set_flags(b, BIO_get_retry_flags(b->next_bio));
         b->retry_reason = b->next_bio->retry_reason;
 }
+LCRYPTO_ALIAS(BIO_copy_next_retry);
 
 int
 BIO_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
@@ -828,18 +873,21 @@ BIO_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
         return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_BIO, argl, argp,
             new_func, dup_func, free_func);
 }
+LCRYPTO_ALIAS(BIO_get_ex_new_index);
 
 int
 BIO_set_ex_data(BIO *bio, int idx, void *data)
 {
         return (CRYPTO_set_ex_data(&(bio->ex_data), idx, data));
 }
+LCRYPTO_ALIAS(BIO_set_ex_data);
 
 void *
 BIO_get_ex_data(BIO *bio, int idx)
 {
         return (CRYPTO_get_ex_data(&(bio->ex_data), idx));
 }
+LCRYPTO_ALIAS(BIO_get_ex_data);
 
 unsigned long
 BIO_number_read(BIO *bio)
@@ -848,6 +896,7 @@ BIO_number_read(BIO *bio)
                 return bio->num_read;
         return 0;
 }
+LCRYPTO_ALIAS(BIO_number_read);
 
 unsigned long
 BIO_number_written(BIO *bio)
@@ -856,3 +905,4 @@ BIO_number_written(BIO *bio)
                 return bio->num_write;
         return 0;
 }
+LCRYPTO_ALIAS(BIO_number_written);