SecBSD
/
src
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

sync

This commit is contained in:
purplerain 2023-07-06 21:55:14 +00:00
parent f1b2576417
commit 2a351e0cdc
Signed by: purplerain
GPG Key ID: F42C07F07E2E35B7
347 changed files with 9596 additions and 5486 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
bin/pax/pax.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: pax.c,v 1.53 2019/06/28 13:34:59 deraadt Exp $ */
/* $OpenBSD: pax.c,v 1.54 2023/07/05 18:45:14 guenther Exp $ */
/* $NetBSD: pax.c,v 1.5 1996/03/26 23:54:20 mrg Exp $ */
/*-
@ -93,7 +93,7 @@ char *dirptr; /* destination dir in a copy */
char *argv0; /* root of argv[0] */
enum op_mode op_mode; /* what program are we acting as? */
sigset_t s_mask; /* signal mask for cleanup critical sect */
FILE *listf = stderr; /* file pointer to print file list to */
FILE *listf; /* file pointer to print file list to */
int listfd = STDERR_FILENO; /* fd matching listf, for sighandler output */
char *tempfile; /* tempfile to use for mkstemp(3) */
char *tempbase; /* basename of tempfile to use for mkstemp(3) */
@ -224,6 +224,8 @@ main(int argc, char **argv)
char *tmpdir;
size_t tdlen;
listf = stderr;
/*
* Keep a reference to cwd, so we can always come back home.
*/

6
bin/ps/ps.1
View File

@ -1,4 +1,4 @@
.\" $OpenBSD: ps.1,v 1.129 2022/10/13 21:37:05 jmc Exp $
.\" $OpenBSD: ps.1,v 1.130 2023/07/06 10:07:09 deraadt Exp $
.\" $NetBSD: ps.1,v 1.16 1996/03/21 01:36:28 jtc Exp $
.\"
.\" Copyright (c) 1980, 1990, 1991, 1993, 1994
@ -30,7 +30,7 @@
.\"
.\" @(#)ps.1 8.3 (Berkeley) 4/18/94
.\"
.Dd $Mdocdate: October 13 2022 $
.Dd $Mdocdate: July 6 2023 $
.Dt PS 1
.Os
.Sh NAME
@ -357,6 +357,8 @@ PS_PLEDGE 0x100000 process has called pledge(2)
PS_WXNEEDED 0x00200000 process allowed to violate W^X
PS_EXECPLEDGE 0x00400000 has exec pledges
PS_ORPHAN 0x00800000 process is on an orphan list
PS_CHROOT 0x01000000 process is chrooted
PS_NOBTCFI 0x02000000 no Branch Target CFI
.Ed
.It Cm re
Core residency time (in seconds; 127 = infinity).

3
distrib/sets/lists/comp/clang.amd64
View File

@ -70,6 +70,9 @@
./usr/include/c++/v1/__algorithm/pop_heap.h
./usr/include/c++/v1/__algorithm/prev_permutation.h
./usr/include/c++/v1/__algorithm/push_heap.h
./usr/include/c++/v1/__algorithm/ranges_find.h
./usr/include/c++/v1/__algorithm/ranges_find_if.h
./usr/include/c++/v1/__algorithm/ranges_find_if_not.h
./usr/include/c++/v1/__algorithm/remove.h
./usr/include/c++/v1/__algorithm/remove_copy.h
./usr/include/c++/v1/__algorithm/remove_copy_if.h

3
distrib/sets/lists/comp/clang.arm64
View File

@ -70,6 +70,9 @@
./usr/include/c++/v1/__algorithm/pop_heap.h
./usr/include/c++/v1/__algorithm/prev_permutation.h
./usr/include/c++/v1/__algorithm/push_heap.h
./usr/include/c++/v1/__algorithm/ranges_find.h
./usr/include/c++/v1/__algorithm/ranges_find_if.h
./usr/include/c++/v1/__algorithm/ranges_find_if_not.h
./usr/include/c++/v1/__algorithm/remove.h
./usr/include/c++/v1/__algorithm/remove_copy.h
./usr/include/c++/v1/__algorithm/remove_copy_if.h

3
distrib/sets/lists/comp/clang.armv7
View File

@ -68,6 +68,9 @@
./usr/include/c++/v1/__algorithm/pop_heap.h
./usr/include/c++/v1/__algorithm/prev_permutation.h
./usr/include/c++/v1/__algorithm/push_heap.h
./usr/include/c++/v1/__algorithm/ranges_find.h
./usr/include/c++/v1/__algorithm/ranges_find_if.h
./usr/include/c++/v1/__algorithm/ranges_find_if_not.h
./usr/include/c++/v1/__algorithm/remove.h
./usr/include/c++/v1/__algorithm/remove_copy.h
./usr/include/c++/v1/__algorithm/remove_copy_if.h

3
distrib/sets/lists/comp/clang.i386
View File

@ -68,6 +68,9 @@
./usr/include/c++/v1/__algorithm/pop_heap.h
./usr/include/c++/v1/__algorithm/prev_permutation.h
./usr/include/c++/v1/__algorithm/push_heap.h
./usr/include/c++/v1/__algorithm/ranges_find.h
./usr/include/c++/v1/__algorithm/ranges_find_if.h
./usr/include/c++/v1/__algorithm/ranges_find_if_not.h
./usr/include/c++/v1/__algorithm/remove.h
./usr/include/c++/v1/__algorithm/remove_copy.h
./usr/include/c++/v1/__algorithm/remove_copy_if.h

1
distrib/sets/lists/man/mi
View File

@ -1838,6 +1838,7 @@
./usr/share/man/man4/pwmfan.4
./usr/share/man/man4/pwmleds.4
./usr/share/man/man4/pwmreg.4
./usr/share/man/man4/qccpu.4
./usr/share/man/man4/qcdwusb.4
./usr/share/man/man4/qcgpio.4
./usr/share/man/man4/qciic.4

4
etc/root/root.mail
View File

@ -1,6 +1,6 @@
From purplerain@secbsd.org Wed Jun 7 00:00:00 UTC 2023
From purplerain@secbsd.org Thu Jul 6 00:00:00 UTC 2023
Return-Path: root
Date: Jun 7 00:00:00 UTC 2023
Date: Jul 6 00:00:00 UTC 2023
From: purplerain@secbsd.org (Purple Rain)
To: root
Subject: Welcome to SecBSD 1.3!

2
etc/skel/dot.version
View File

@ -1 +1 @@
# SecBSD 1.3-3cf4eea: Wed Jun 7 00:00:00 UTC 2023 (Quetzalcoatl)
# SecBSD 1.3-3c7d048: Thu Jul 6 00:00:00 UTC 2023 (Quetzalcoatl)

5
gnu/lib/libcxx/Makefile
View File

@ -1,4 +1,4 @@
# $OpenBSD: Makefile,v 1.5 2021/12/17 14:55:43 patrick Exp $
# $OpenBSD: Makefile,v 1.6 2023/07/05 15:34:52 robert Exp $
.include <bsd.own.mk>
@ -135,6 +135,9 @@ STD_HEADERS= \
__algorithm/pop_heap.h \
__algorithm/prev_permutation.h \
__algorithm/push_heap.h \
__algorithm/ranges_find.h \
__algorithm/ranges_find_if.h \
__algorithm/ranges_find_if_not.h \
__algorithm/remove_copy_if.h \
__algorithm/remove_copy.h \
__algorithm/remove_if.h \

63
gnu/llvm/libcxx/include/__algorithm/ranges_find.h Normal file
View File

@ -0,0 +1,63 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___ALGORITHM_RANGES_FIND_H
#define _LIBCPP___ALGORITHM_RANGES_FIND_H
#include <__algorithm/ranges_find_if.h>
#include <__config>
#include <__functional/identity.h>
#include <__functional/invoke.h>
#include <__functional/ranges_operations.h>
#include <__iterator/concepts.h>
#include <__iterator/projected.h>
#include <__ranges/access.h>
#include <__ranges/concepts.h>
#include <__ranges/dangling.h>
#include <__utility/forward.h>
#include <__utility/move.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
_LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges {
namespace __find {
struct __fn {
template <input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Tp, class _Proj = identity>
requires indirect_binary_predicate<ranges::equal_to, projected<_Ip, _Proj>, const _Tp*>
_LIBCPP_HIDE_FROM_ABI constexpr
_Ip operator()(_Ip __first, _Sp __last, const _Tp& __value, _Proj __proj = {}) const {
auto __pred = [&](auto&& __e) { return std::forward<decltype(__e)>(__e) == __value; };
return ranges::__find_if_impl(std::move(__first), std::move(__last), __pred, __proj);
}
template <input_range _Rp, class _Tp, class _Proj = identity>
requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rp>, _Proj>, const _Tp*>
_LIBCPP_HIDE_FROM_ABI constexpr
borrowed_iterator_t<_Rp> operator()(_Rp&& __r, const _Tp& __value, _Proj __proj = {}) const {
auto __pred = [&](auto&& __e) { return std::forward<decltype(__e)>(__e) == __value; };
return ranges::__find_if_impl(ranges::begin(__r), ranges::end(__r), __pred, __proj);
}
};
} // namespace __find
inline namespace __cpo {
inline constexpr auto find = __find::__fn{};
} // namespace __cpo
} // namespace ranges
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
#endif // _LIBCPP___ALGORITHM_RANGES_FIND_H

71
gnu/llvm/libcxx/include/__algorithm/ranges_find_if.h Normal file
View File

@ -0,0 +1,71 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___ALGORITHM_RANGES_FIND_IF_H
#define _LIBCPP___ALGORITHM_RANGES_FIND_IF_H
#include <__config>
#include <__functional/identity.h>
#include <__functional/invoke.h>
#include <__functional/ranges_operations.h>
#include <__iterator/concepts.h>
#include <__iterator/projected.h>
#include <__ranges/access.h>
#include <__ranges/concepts.h>
#include <__ranges/dangling.h>
#include <__utility/move.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
_LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges {
template <class _Ip, class _Sp, class _Pred, class _Proj>
_LIBCPP_HIDE_FROM_ABI static constexpr
_Ip __find_if_impl(_Ip __first, _Sp __last, _Pred& __pred, _Proj& __proj) {
for (; __first != __last; ++__first) {
if (std::invoke(__pred, std::invoke(__proj, *__first)))
break;
}
return __first;
}
namespace __find_if {
struct __fn {
template <input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Proj = identity,
indirect_unary_predicate<projected<_Ip, _Proj>> _Pred>
_LIBCPP_HIDE_FROM_ABI constexpr
_Ip operator()(_Ip __first, _Sp __last, _Pred __pred, _Proj __proj = {}) const {
return ranges::__find_if_impl(std::move(__first), std::move(__last), __pred, __proj);
}
template <input_range _Rp, class _Proj = identity,
indirect_unary_predicate<projected<iterator_t<_Rp>, _Proj>> _Pred>
_LIBCPP_HIDE_FROM_ABI constexpr
borrowed_iterator_t<_Rp> operator()(_Rp&& __r, _Pred __pred, _Proj __proj = {}) const {
return ranges::__find_if_impl(ranges::begin(__r), ranges::end(__r), __pred, __proj);
}
};
} // namespace __find_if
inline namespace __cpo {
inline constexpr auto find_if = __find_if::__fn{};
} // namespace __cpo
} // namespace ranges
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
#endif // _LIBCPP___ALGORITHM_RANGES_FIND_IF_H

63
gnu/llvm/libcxx/include/__algorithm/ranges_find_if_not.h Normal file
View File

@ -0,0 +1,63 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___ALGORITHM_RANGES_FIND_IF_NOT_H
#define _LIBCPP___ALGORITHM_RANGES_FIND_IF_NOT_H
#include <__algorithm/ranges_find_if.h>
#include <__config>
#include <__functional/identity.h>
#include <__functional/invoke.h>
#include <__functional/ranges_operations.h>
#include <__iterator/concepts.h>
#include <__iterator/projected.h>
#include <__ranges/access.h>
#include <__ranges/concepts.h>
#include <__ranges/dangling.h>
#include <__utility/forward.h>
#include <__utility/move.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
_LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges {
namespace __find_if_not {
struct __fn {
template <input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Proj = identity,
indirect_unary_predicate<projected<_Ip, _Proj>> _Pred>
_LIBCPP_HIDE_FROM_ABI constexpr
_Ip operator()(_Ip __first, _Sp __last, _Pred __pred, _Proj __proj = {}) const {
auto __pred2 = [&](auto&& __e) { return !std::invoke(__pred, std::forward<decltype(__e)>(__e)); };
return ranges::__find_if_impl(std::move(__first), std::move(__last), __pred2, __proj);
}
template <input_range _Rp, class _Proj = identity,
indirect_unary_predicate<projected<iterator_t<_Rp>, _Proj>> _Pred>
_LIBCPP_HIDE_FROM_ABI constexpr
borrowed_iterator_t<_Rp> operator()(_Rp&& __r, _Pred __pred, _Proj __proj = {}) const {
auto __pred2 = [&](auto&& __e) { return !std::invoke(__pred, std::forward<decltype(__e)>(__e)); };
return ranges::__find_if_impl(ranges::begin(__r), ranges::end(__r), __pred2, __proj);
}
};
} // namespace __find_if_not
inline namespace __cpo {
inline constexpr auto find_if_not = __find_if_not::__fn{};
} // namespace __cpo
} // namespace ranges
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
#endif // _LIBCPP___ALGORITHM_RANGES_FIND_IF_NOT_H

32
gnu/llvm/libcxx/include/algorithm
View File

@ -18,6 +18,35 @@
namespace std
{
namespace ranges {
template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
constexpr I find(I first, S last, const T& value, Proj proj = {}); // since C++20
template<input_range R, class T, class Proj = identity>
requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
constexpr borrowed_iterator_t<R>
find(R&& r, const T& value, Proj proj = {}); // since C++20
template<input_iterator I, sentinel_for<I> S, class Proj = identity,
indirect_unary_predicate<projected<I, Proj>> Pred>
constexpr I find_if(I first, S last, Pred pred, Proj proj = {}); // since C++20
template<input_range R, class Proj = identity,
indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
constexpr borrowed_iterator_t<R>
find_if(R&& r, Pred pred, Proj proj = {}); // since C++20
template<input_iterator I, sentinel_for<I> S, class Proj = identity,
indirect_unary_predicate<projected<I, Proj>> Pred>
constexpr I find_if_not(I first, S last, Pred pred, Proj proj = {}); // since C++20
template<input_range R, class Proj = identity,
indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
constexpr borrowed_iterator_t<R>
find_if_not(R&& r, Pred pred, Proj proj = {}); // since C++20
}
template <class InputIterator, class Predicate>
constexpr bool // constexpr in C++20
all_of(InputIterator first, InputIterator last, Predicate pred);
@ -720,6 +749,9 @@ template <class BidirectionalIterator, class Compare>
#include <__algorithm/pop_heap.h>
#include <__algorithm/prev_permutation.h>
#include <__algorithm/push_heap.h>
#include <__algorithm/ranges_find.h>
#include <__algorithm/ranges_find_if.h>
#include <__algorithm/ranges_find_if_not.h>
#include <__algorithm/remove.h>
#include <__algorithm/remove_copy.h>
#include <__algorithm/remove_copy_if.h>

3
gnu/llvm/libcxx/include/module.modulemap
View File

@ -279,6 +279,9 @@ module std [system] {
module pop_heap { private header "__algorithm/pop_heap.h" }
module prev_permutation { private header "__algorithm/prev_permutation.h" }
module push_heap { private header "__algorithm/push_heap.h" }
module ranges_find { private header "__algorithm/ranges_find.h" }
module ranges_find_if { private header "__algorithm/ranges_find_if.h" }
module ranges_find_if_not { private header "__algorithm/ranges_find_if_not.h" }
module remove { private header "__algorithm/remove.h" }
module remove_copy { private header "__algorithm/remove_copy.h" }
module remove_copy_if { private header "__algorithm/remove_copy_if.h" }

5
gnu/llvm/lld/docs/ld.lld.1
View File

@ -833,6 +833,11 @@ This is the default.
Create a
.Dv PT_OPENBSD_WXNEEDED
segment.
.Pp
.It Cm nobtcfi
Create a
.Dv PT_OPENBSD_NOBTCFI
segment.
.El
.El
.Sh IMPLEMENTATION NOTES

3
gnu/usr.bin/binutils-2.17/bfd/elf-bfd.h
View File

@ -1318,6 +1318,9 @@ struct elf_obj_tdata
/* TRUE if output program should be marked to request W^X permission */
bfd_boolean wxneeded;
/* TRUE if output program should be marked to stop branch target CFI enforcement */
bfd_boolean nobtcfi;
/* Symbol version definitions in external objects. */
Elf_Internal_Verdef *verdef;

28
gnu/usr.bin/binutils-2.17/bfd/elf.c
View File

@ -1102,6 +1102,7 @@ get_segment_type (unsigned int p_type)
case PT_GNU_RELRO: pt = "RELRO"; break;
case PT_OPENBSD_RANDOMIZE: pt = "OPENBSD_RANDOMIZE"; break;
case PT_OPENBSD_WXNEEDED: pt = "OPENBSD_WXNEEDED"; break;
case PT_OPENBSD_NOBTCFI: pt = "OPENBSD_NOBTCFI"; break;
case PT_OPENBSD_BOOTDATA: pt = "OPENBSD_BOOTDATA"; break;
case PT_OPENBSD_MUTABLE: pt = "OPENBSD_MUTABLE"; break;
default: pt = NULL; break;
@ -2646,6 +2647,10 @@ bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int index)
return _bfd_elf_make_section_from_phdr (abfd, hdr, index,
"openbsd_wxneeded");
case PT_OPENBSD_NOBTCFI:
return _bfd_elf_make_section_from_phdr (abfd, hdr, index,
"openbsd_nobtcfi");
case PT_OPENBSD_MUTABLE:
return _bfd_elf_make_section_from_phdr (abfd, hdr, index,
"openbsd_mutable");
@ -3981,7 +3986,22 @@ map_sections_to_segments (bfd *abfd)
goto error_return;
m->next = NULL;
m->p_type = PT_OPENBSD_WXNEEDED;
m->p_flags = 1;
m->p_flags = PF_X;
m->p_flags_valid = 1;
*pm = m;
pm = &m->next;
}
if (elf_tdata (abfd)->nobtcfi)
{
amt = sizeof (struct elf_segment_map);
m = bfd_zalloc (abfd, amt);
if (m == NULL)
goto error_return;
m->next = NULL;
m->p_type = PT_OPENBSD_NOBTCFI;
m->p_flags = PF_X;
m->p_flags_valid = 1;
*pm = m;
@ -4800,6 +4820,12 @@ get_program_header_size (bfd *abfd)
++segs;
}
if (elf_tdata (abfd)->nobtcfi)
{
/* We need a PT_OPENBSD_NOBTCFI segment. */
++segs;
}
for (s = abfd->sections; s != NULL; s = s->next)
{
if ((s->flags & SEC_LOAD) != 0

12
gnu/usr.bin/binutils-2.17/binutils/readelf.c
View File

@ -21,7 +21,7 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
02110-1301, USA. */
/* The difference between readelf and objdump:
Both programs are capable of displaying the contents of ELF format files,
@ -40,7 +40,7 @@
There is also the case that readelf can provide more information about an
ELF file than is provided by objdump. In particular it can display DWARF
debugging information which (at the moment) objdump cannot. */
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
@ -976,7 +976,7 @@ slurp_relr_relocs (FILE *file,
while ((val >>= 1) != 0)
{
addr += 4;
if (val & 1)
if (val & 1)
{
rels[j].r_offset = addr;
rels[j].r_info = ELF32_R_INFO(0, type);
@ -1041,7 +1041,7 @@ slurp_relr_relocs (FILE *file,
while ((val >>= 1) != 0)
{
addr += 8;
if (val & 1)
if (val & 1)
{
rels[j].r_offset = addr;
rels[j].r_info = ELF64_R_INFO(0, type);
@ -2278,7 +2278,7 @@ get_machine_flags (unsigned e_flags, unsigned e_machine)
char const *isa = _("unknown");
char const *mac = _("unknown mac");
char const *additional = NULL;
switch (e_flags & EF_M68K_ISA_MASK)
{
case EF_M68K_ISA_A_NODIV:
@ -2712,6 +2712,8 @@ get_segment_type (unsigned long p_type)
return "OPENBSD_BOOTDATA";
case PT_OPENBSD_MUTABLE:
return "OPENBSD_MUTABLE";
case PT_OPENBSD_NOBTCFI:
return "OPENBSD_NOBTCFI";
default:
if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))

3
gnu/usr.bin/binutils-2.17/include/bfdlink.h
View File

@ -270,6 +270,9 @@ struct bfd_link_info
/* TRUE if output program should be marked to request W^X permission */
unsigned int wxneeded: 1;
/* TRUE if output program should be marked to stop branch target CFI enforcement */
unsigned int nobtcfi: 1;
/* TRUE if ok to have version with no definition. */
unsigned int allow_undefined_version: 1;

3
gnu/usr.bin/binutils-2.17/include/elf/common.h
View File

@ -186,7 +186,7 @@
#define EM_BLACKFIN 106 /* ADI Blackfin */
#define EM_ALTERA_NIOS2 113 /* Altera Nios II soft-core processor */
#define EM_CRX 114 /* National Semiconductor CRX */
#define EM_AARCH64 183
#define EM_AARCH64 183
#define EM_RISCV 243
/* If it is necessary to assign new unofficial EM_* values, please pick large
@ -313,6 +313,7 @@
#define PT_OPENBSD_RANDOMIZE 0x65a3dbe6 /* Fill with random data. */
#define PT_OPENBSD_WXNEEDED 0x65a3dbe7 /* Program does W^X violations */
#define PT_OPENBSD_NOBTCFI 0x65a3dbe8 /* no branch target CFI */
#define PT_OPENBSD_BOOTDATA 0x65a41be6 /* Section for boot arguments */
#define PT_OPENBSD_MUTABLE 0x65a3dbe5 /* Like bss, but not immutable */

22
gnu/usr.bin/binutils-2.17/ld/emultempl/elf32.em
View File

@ -105,8 +105,8 @@ gld${EMULATION_NAME}_split_lib_name (name, pmaj, pmin)
*pmaj = -1;
*pmin = -1;
if (strncmp(lib, "lib", 3) == 0)
if (strncmp(lib, "lib", 3) == 0)
lib += 3;
s = lib;
@ -136,7 +136,7 @@ gld${EMULATION_NAME}_split_lib_name (name, pmaj, pmin)
s += 3;
}
/* lib[name].so.[M].[N] */
/* s ^ */
s += 1;
@ -173,12 +173,12 @@ gld${EMULATION_NAME}_search_dir_needed (dirlist, filename)
char *fnam, *fnam_alloc, *lib;
char *found = NULL;
int maj = -1, min = -1;
dlist_alloc = dlist = xstrdup(dirlist);
fnam_alloc = fnam = xstrdup(filename);
lib = gld${EMULATION_NAME}_split_lib_name(fnam, &maj, &min);
while (lib != NULL && found == NULL)
{
dir = strsep(&dlist, ":");
@ -188,7 +188,7 @@ gld${EMULATION_NAME}_search_dir_needed (dirlist, filename)
continue; /* skip dirlist of ...::... */
found = gld${EMULATION_NAME}_search_dir(dir, lib, maj, min);
}
free(dlist_alloc);
free(fnam_alloc);
return found;
@ -221,7 +221,7 @@ gld${EMULATION_NAME}_search_dir (dirname, filename, req_maj, req_min)
if (dir == NULL)
return NULL;
dirnamelen = strlen (dirname);
while ((entry = readdir (dir)) != NULL)
{
const char *s;
@ -263,13 +263,13 @@ gld${EMULATION_NAME}_search_dir (dirname, filename, req_maj, req_min)
found_maj = strtoul (entry->d_name + 7 + len, &eptr, 10);
/* do not support libN.so. or libN.so.X */
if (*eptr != '.' || ((entry->d_name + 3 + len) == eptr))
if (*eptr != '.' || ((entry->d_name + 3 + len) == eptr))
continue;
found_min = strtoul (eptr+1, &eptr1, 10);
/* do not support libN.so.X. or libN.so.X.Y.[anything] */
if (*eptr1 != '\0' || (eptr+1 == eptr1))
if (*eptr1 != '\0' || (eptr+1 == eptr1))
continue;
}
@ -2206,6 +2206,8 @@ cat >>e${EMULATION_NAME}.c <<EOF
link_info.relro = FALSE;
else if (strcmp (optarg, "wxneeded") == 0)
link_info.wxneeded = TRUE;
else if (strcmp (optarg, "nobtcfi") == 0)
link_info.nobtcfi = TRUE;
else if (strcmp (optarg, "notext") == 0)
link_info.allow_textrel = TRUE;
else if (strcmp (optarg, "text") == 0)

5
gnu/usr.bin/binutils-2.17/ld/ld.texinfo
View File

@ -1019,6 +1019,11 @@ Marks the executable with a @code{PT_OPENBSD_WXNEEDED} segment header,
indicating it is expected to perform W^X violating operations later
(such as calling mprotect(2) or mmap(2) with both PROT_WRITE and PROT_EXEC).
@item nobtcfi
Marks the executable with a @code{PT_OPENBSD_NOBTCFI} segment header,
indicating it is expected the binary is missing BTI/IBT instructions and
thus the system should not enforce them as required.
@end table
Other keywords are ignored for Solaris compatibility.

2
gnu/usr.bin/binutils-2.17/ld/ldgram.y
View File

@ -1095,6 +1095,8 @@ phdr_type:
$$ = exp_intop (0x65a3dbe6);
else if (strcmp (s, "PT_OPENBSD_WXNEEDED") == 0)
$$ = exp_intop (0x65a3dbe7);
else if (strcmp (s, "PT_OPENBSD_NOBTCFI") == 0)
$$ = exp_intop (0x65a3dbe8);
else if (strcmp (s, "PT_OPENBSD_BOOTDATA") == 0)
$$ = exp_intop (0x65a41be6);
else if (strcmp (s, "PT_OPENBSD_MUTABLE") == 0)

244
gnu/usr.bin/perl/cpan/Pod-Perldoc/corpus/perlfunc.pod
View File

@ -14,7 +14,7 @@ take more than one argument. Thus, a comma terminates the argument of
a unary operator, but merely separates the arguments of a list
operator. A unary operator generally provides scalar context to its
argument, while a list operator may provide either scalar or list
contexts for its arguments. If it does both, scalar arguments
contexts for its arguments. If it does both, scalar arguments
come first and list argument follow, and there can only ever
be one such list argument. For instance, splice() has three scalar
arguments followed by a list, whereas gethostbyname() has four scalar
@ -30,7 +30,7 @@ Commas should separate literal elements of the LIST.
Any function in the list below may be used either with or without
parentheses around its arguments. (The syntax descriptions omit the
parentheses.) If you use parentheses, the simple but occasionally
parentheses.) If you use parentheses, the simple but occasionally
surprising rule is this: It I<looks> like a function, therefore it I<is> a
function, and precedence doesn't matter. Otherwise it's a list
operator or unary operator, and precedence does matter. Whitespace
@ -175,7 +175,7 @@ C<break>, C<continue>, C<default>, C<given>, C<when>
Except for C<continue>, these are available only if you enable the
C<"switch"> feature or use the C<CORE::> prefix.
See L<feature> and L<perlsyn/"Switch statements">.
See L<feature> and L<perlsyn/"Switch statements">.
Alternately, include a C<use v5.10> or later to the current scope. In Perl
5.14 and earlier, C<continue> required the C<"switch"> feature, like the
other keywords.
@ -250,7 +250,7 @@ C<gmtime>, C<localtime>, C<time>, C<times>
=item Functions new in perl5
X<perl5>
C<abs>, C<bless>, C<break>, C<chomp>, C<chr>, C<continue>, C<default>,
C<abs>, C<bless>, C<break>, C<chomp>, C<chr>, C<continue>, C<default>,
C<exists>, C<formline>, C<given>, C<glob>, C<import>, C<lc>, C<lcfirst>,
C<lock>, C<map>, C<my>, C<no>, C<our>, C<prototype>, C<qr//>, C<qw//>, C<qx//>,
C<readline>, C<readpipe>, C<ref>, C<sub>*, C<sysopen>, C<tie>, C<tied>, C<uc>,
@ -297,7 +297,7 @@ L<perlport> and other available platform-specific documentation.
=head2 Alphabetical Listing of Perl Functions
=over
=over
=item -X FILEHANDLE
X<-r>X<-w>X<-x>X<-o>X<-R>X<-W>X<-X>X<-O>X<-e>X<-z>X<-s>X<-f>X<-d>X<-l>X<-p>
@ -310,7 +310,7 @@ X<-S>X<-b>X<-c>X<-t>X<-u>X<-g>X<-k>X<-T>X<-B>X<-M>X<-A>X<-C>
=item -X
A file test, where X is one of the letters listed below. This unary
operator takes one argument, either a filename, a filehandle, or a dirhandle,
operator takes one argument, either a filename, a filehandle, or a dirhandle,
and tests the associated file to see if something is true about it. If the
argument is omitted, tests C<$_>, except for C<-t>, which tests STDIN.
Unless otherwise documented, it returns C<1> for true and C<''> for false, or
@ -454,7 +454,7 @@ If VALUE is omitted, uses C<$_>.
=item accept NEWSOCKET,GENERICSOCKET
X<accept>
Accepts an incoming socket connect, just as accept(2)
Accepts an incoming socket connect, just as accept(2)
does. Returns the packed address if it succeeded, false otherwise.
See the example in L<perlipc/"Sockets: Client/Server Communication">.
@ -894,7 +894,7 @@ X<chr> X<character> X<ASCII> X<Unicode>
Returns the character represented by that NUMBER in the character set.
For example, C<chr(65)> is C<"A"> in either ASCII or Unicode, and
chr(0x263a) is a Unicode smiley face.
chr(0x263a) is a Unicode smiley face.
Negative values give the Unicode replacement character (chr(0xfffd)),
except under the L<bytes> pragma, where the low eight bits of the value
@ -1069,7 +1069,7 @@ to create the digest is visible as part of the digest. This ensures
crypt() will hash the new string with the same salt as the digest.
This allows your code to work with the standard L<crypt|/crypt> and
with more exotic implementations. In other words, assume
nothing about the returned string itself nor about how many bytes
nothing about the returned string itself nor about how many bytes
of SALT may matter.
Traditionally the result is a string of 13 bytes: two first bytes of
@ -1147,7 +1147,7 @@ sdbm(3).
If you don't have write access to the DBM file, you can only read hash
variables, not set them. If you want to test whether you can write,
either use file tests or try setting a dummy hash entry inside an C<eval>
either use file tests or try setting a dummy hash entry inside an C<eval>
to trap the error.
Note that functions such as C<keys> and C<values> may return huge lists
@ -1300,7 +1300,7 @@ And so do these:
delete @ARRAY[0 .. $#ARRAY];
But both are slower than assigning the empty list
or undefining %HASH or @ARRAY, which is the customary
or undefining %HASH or @ARRAY, which is the customary
way to empty out an aggregate:
%HASH = (); # completely empty %HASH
@ -1383,7 +1383,7 @@ You can also call C<die> with a reference argument, and if this is trapped
within an C<eval>, C<$@> contains that reference. This permits more
elaborate exception handling using objects that maintain arbitrary state
about the exception. Such a scheme is sometimes preferable to matching
particular string values of C<$@> with regular expressions. Because C<$@>
particular string values of C<$@> with regular expressions. Because C<$@>
is a global variable and C<eval> may be used within object implementations,
be careful that analyzing the error object doesn't replace the reference in
the global variable. It's easiest to make a local copy of the reference
@ -1410,7 +1410,7 @@ does its deed, by setting the C<$SIG{__DIE__}> hook. The associated
handler is called with the error text and can change the error
message, if it sees fit, by calling C<die> again. See
L<perlvar/%SIG> for details on setting C<%SIG> entries, and
L<"eval BLOCK"> for some examples. Although this feature was
L<"eval BLOCK"> for some examples. Although this feature was
to be run only right before your program was to exit, this is not
currently so: the C<$SIG{__DIE__}> hook is currently called
even inside eval()ed blocks/strings! If one wants the hook to do
@ -1595,7 +1595,7 @@ and if you haven't set C<@ARGV>, will read input from C<STDIN>;
see L<perlop/"I/O Operators">.
In a C<< while (<>) >> loop, C<eof> or C<eof(ARGV)> can be used to
detect the end of each file, whereas C<eof()> will detect the end
detect the end of each file, whereas C<eof()> will detect the end
of the very last file only. Examples:
# reset line numbering on each input file
@ -1616,7 +1616,7 @@ of the very last file only. Examples:
}
Practical hint: you almost never need to use C<eof> in Perl, because the
input operators typically return C<undef> when they run out of data or
input operators typically return C<undef> when they run out of data or
encounter an error.
=item eval EXPR
@ -1663,8 +1663,8 @@ the BLOCK.
In both forms, the value returned is the value of the last expression
evaluated inside the mini-program; a return statement may be also used, just
as with subroutines. The expression providing the return value is evaluated
in void, scalar, or list context, depending on the context of the C<eval>
itself. See L</wantarray> for more on how the evaluation context can be
in void, scalar, or list context, depending on the context of the C<eval>
itself. See L</wantarray> for more on how the evaluation context can be
determined.
If there is a syntax error or runtime error, or a C<die> statement is
@ -1754,7 +1754,7 @@ normally you I<would> like to use double quotes, except that in this
particular situation, you can just use symbolic references instead, as
in case 6.
Before Perl 5.14, the assignment to C<$@> occurred before restoration
Before Perl 5.14, the assignment to C<$@> occurred before restoration
of localised variables, which means that for your code to run on older
versions, a temporary is required if you want to mask some but not all
errors:
@ -2053,7 +2053,7 @@ Two potentially non-obvious but traditional C<flock> semantics are
that it waits indefinitely until the lock is granted, and that its locks
are B<merely advisory>. Such discretionary locks are more flexible, but
offer fewer guarantees. This means that programs that do not also use
C<flock> may modify files locked with C<flock>. See L<perlport>,
C<flock> may modify files locked with C<flock>. See L<perlport>,
your port's specific documentation, and your system-specific local manpages
for details. It's best to assume traditional behavior if you're writing
portable programs. (But if you're not, you should as always feel perfectly
@ -2305,7 +2305,7 @@ X<getpwuid> X<getgrgid> X<getservbyname> X<gethostbyaddr> X<getnetbyaddr>
X<getprotobynumber> X<getservbyport> X<getpwent> X<getgrent> X<gethostent>
X<getnetent> X<getprotoent> X<getservent> X<setpwent> X<setgrent> X<sethostent>
X<setnetent> X<setprotoent> X<setservent> X<endpwent> X<endgrent> X<endhostent>
X<endnetent> X<endprotoent> X<endservent>
X<endnetent> X<endprotoent> X<endservent>
=item getgrnam NAME
@ -2409,7 +2409,7 @@ field may be $change or $age, fields that have to do with password
aging. In some systems the $comment field may be $class. The $expire
field, if present, encodes the expiration period of the account or the
password. For the availability and the exact meaning of these fields
in your system, please consult getpwnam(3) and your system's
in your system, please consult getpwnam(3) and your system's
F<pwd.h> file. You can also find out from within Perl what your
$quota and $comment fields mean and whether you have the $expire field
by using the C<Config> module and the values C<d_pwquota>, C<d_pwage>,
@ -2564,7 +2564,7 @@ EXPR is omitted, C<$_> is used. The C<< <*.c> >> operator is discussed in
more detail in L<perlop/"I/O Operators">.
Note that C<glob> splits its arguments on whitespace and treats
each segment as separate pattern. As such, C<glob("*.c *.h")>
each segment as separate pattern. As such, C<glob("*.c *.h")>
matches all files with a F<.c> or F<.h> extension. The expression
C<glob(".* *")> matches all files in the current working directory.
If you want to glob filenames that might contain whitespace, you'll
@ -3329,7 +3329,7 @@ message queue ID into variable VAR with a maximum message size of
SIZE. Note that when a message is received, the message type as a
native long integer will be the first thing in VAR, followed by the
actual message. This packing may be opened with C<unpack("l! a*")>.
Taints the variable. Returns true if successful, false
Taints the variable. Returns true if successful, false
on error. See also L<perlipc/"SysV IPC"> and the documentation for
C<IPC::SysV> and C<IPC::SysV::Msg>.
@ -3430,11 +3430,11 @@ in octal), use sprintf() or printf():
$oct_perm_str = sprintf "%o", $perms;
The oct() function is commonly used when a string such as C<644> needs
to be converted into a file mode, for example. Although Perl
to be converted into a file mode, for example. Although Perl
automatically converts strings into numbers as needed, this automatic
conversion assumes base 10.
Leading white space is ignored without warning, as too are any trailing
Leading white space is ignored without warning, as too are any trailing
non-digits, such as a decimal point (C<oct> only handles non-negative
integers, not negative integers or floating point).
@ -3454,12 +3454,12 @@ FILEHANDLE.
Simple examples to open a file for reading:
open(my $fh, "<", "input.txt")
open(my $fh, "<", "input.txt")
or die "cannot open < input.txt: $!";
and for writing:
open(my $fh, ">", "output.txt")
open(my $fh, ">", "output.txt")
or die "cannot open > output.txt: $!";
(The following is a comprehensive reference to open(): for a gentler
@ -3473,7 +3473,7 @@ considered a symbolic reference, so C<use strict "refs"> should I<not> be
in effect.)
If EXPR is omitted, the global (package) scalar variable of the same
name as the FILEHANDLE contains the filename. (Note that lexical
name as the FILEHANDLE contains the filename. (Note that lexical
variables--those declared with C<my> or C<state>--will not work for this
purpose; so if you're using C<my> or C<state>, specify EXPR in your
call to open.)
@ -3488,7 +3488,7 @@ created if necessary.
You can put a C<+> in front of the C<< > >> or C<< < >> to
indicate that you want both read and write access to the file; thus
C<< +< >> is almost always preferred for read/write updates--the
C<< +< >> is almost always preferred for read/write updates--the
C<< +> >> mode would clobber the file first. You cant usually use
either read-write mode for updating textfiles, since they have
variable-length records. See the B<-i> switch in L<perlrun> for a
@ -3522,7 +3522,7 @@ C<open> with more than three arguments for non-pipe modes is not yet
defined, but experimental "layers" may give extra LIST arguments
meaning.
In the two-argument (and one-argument) form, opening C<< <- >>
In the two-argument (and one-argument) form, opening C<< <- >>
or C<-> opens STDIN and opening C<< >- >> opens STDOUT.
You may (and usually should) use the three-argument form of open to specify
@ -3553,12 +3553,12 @@ like Unix, Mac OS, and Plan 9, that end lines with a single
character and encode that character in C as C<"\n"> do not
need C<binmode>. The rest need it.
When opening a file, it's seldom a good idea to continue
When opening a file, it's seldom a good idea to continue
if the request failed, so C<open> is frequently used with
C<die>. Even if C<die> won't do what you want (say, in a CGI script,
where you want to format a suitable error message (but there are
modules that can help with that problem)) always check
the return value from opening a file.
the return value from opening a file.
As a special case the three-argument form with a read/write mode and the third
argument being C<undef>:
@ -3708,7 +3708,7 @@ and looking for the C<useperlio=> line. If C<useperlio> is C<define>, you
have PerlIO; otherwise you don't.
If you open a pipe on the command C<-> (that is, specify either C<|-> or C<-|>
with the one- or two-argument forms of C<open>),
with the one- or two-argument forms of C<open>),
an implicit C<fork> is done, so C<open> returns twice: in the parent
process it returns the pid
of the child process, and in the child process it returns (a defined) C<0>.
@ -3721,7 +3721,7 @@ For example, use either
or
$child_pid = open(TO_KID, "|-") // die "can't fork: $!";
followed by
followed by
if ($child_pid) {
# am the parent:
@ -3732,7 +3732,7 @@ followed by
# am the child; use STDIN/STDOUT normally
...
exit;
}
}
The filehandle behaves normally for the parent, but I/O to that
filehandle is piped from/to the STDOUT/STDIN of the child process.
@ -3757,7 +3757,7 @@ The following blocks are more or less equivalent:
The last two examples in each block show the pipe as "list form", which is
not yet supported on all platforms. A good rule of thumb is that if
your platform has a real C<fork()> (in other words, if your platform is
Unix, including Linux and MacOS X), you can use the list form. You would
Unix, including Linux and MacOS X), you can use the list form. You would
want to use the list form of the pipe so you can pass literal arguments
to the command without risk of the shell interpreting any shell metacharacters
in them. However, this also bars you from opening pipes to commands
@ -3855,7 +3855,7 @@ close that happens when the refcount on C<handle> does not
properly detect and report failures. I<Always> close the handle
yourself and inspect the return value.
close($handle)
close($handle)
|| warn "close failed: $!";
See L</seek> for some details about mixing reading and writing.
@ -3966,7 +3966,7 @@ given by the TEMPLATE. The resulting string is the concatenation of
the converted values. Typically, each converted value looks
like its machine-level representation. For example, on 32-bit machines
an integer may be represented by a sequence of 4 bytes, which will in
Perl be presented as a string that's 4 characters long.
Perl be presented as a string that's 4 characters long.
See L<perlpacktut> for an introduction to this function.
@ -4063,13 +4063,13 @@ TEMPLATE (the second column lists letters for which the modifier is valid):
< sSiIlLqQ Force little-endian byte-order on the type.
jJfFdDpP (The "little end" touches the construct.)
The C<< > >> and C<< < >> modifiers can also be used on C<()> groups
to force a particular byte-order on all components in that group,
The C<< > >> and C<< < >> modifiers can also be used on C<()> groups
to force a particular byte-order on all components in that group,
including all its subgroups.
The following rules apply:
=over
=over
=item *
@ -4081,21 +4081,21 @@ C<B>, C<h>, C<H>, C<@>, C<.>, C<x>, C<X>, and C<P>, where it means
something else, described below. Supplying a C<*> for the repeat count
instead of a number means to use however many items are left, except for:
=over
=over
=item *
=item *
C<@>, C<x>, and C<X>, where it is equivalent to C<0>.
=item *
=item *
<.>, where it means relative to the start of the string.
=item *
=item *
C<u>, where it is equivalent to 1 (or 45, which here is equivalent).
=back
=back
One can replace a numeric repeat count with a template letter enclosed in
brackets to use the packed byte length of the bracketed template for the
@ -4117,7 +4117,7 @@ of the innermost C<()> group.
When used with C<.>, the repeat count determines the starting position to
calculate the value offset as follows:
=over
=over
=item *
@ -4137,7 +4137,7 @@ bigger then the group level.
=back
The repeat count for C<u> is interpreted as the maximal number of bytes
to encode per line of output, with 0, 1 and 2 replaced by 45. The repeat
to encode per line of output, with 0, 1 and 2 replaced by 45. The repeat
count should not be more than 65.
=item *
@ -4174,7 +4174,7 @@ at the end. Similarly during unpacking, "extra" bits are ignored.
If the input string is longer than needed, remaining characters are ignored.
A C<*> for the repeat count uses all characters of the input field.
A C<*> for the repeat count uses all characters of the input field.
On unpacking, bits are converted to a string of C<0>s and C<1>s.
=item *
@ -4188,7 +4188,7 @@ bits of the input character, i.e., on C<ord($char)%16>. In particular,
characters C<"0"> and C<"1"> generate nybbles 0 and 1, as do bytes
C<"\000"> and C<"\001">. For characters C<"a".."f"> and C<"A".."F">, the result
is compatible with the usual hexadecimal digits, so that C<"a"> and
C<"A"> both generate the nybble C<0xA==10>. Use only these specific hex
C<"A"> both generate the nybble C<0xA==10>. Use only these specific hex
characters with this format.
Starting from the beginning of the template to pack(), each pair
@ -4250,7 +4250,7 @@ an explicit repeat count for pack, the packed string is adjusted to that
length. For example:
This code: gives this result:
unpack("W/a", "\004Gurusamy") ("Guru")
unpack("a3/A A*", "007 Bond J ") (" Bond", "J")
unpack("a3 x2 /A A*", "007: Bond, J.") ("Bond, J", ".")
@ -4274,10 +4274,10 @@ exactly 32 bits, although the native C<long> as seen by the local C compiler
may be larger. This is mainly an issue on 64-bit platforms. You can
see whether using C<!> makes any difference this way:
printf "format s is %d, s! is %d\n",
printf "format s is %d, s! is %d\n",
length pack("s"), length pack("s!");
printf "format l is %d, l! is %d\n",
printf "format l is %d, l! is %d\n",
length pack("l"), length pack("l!");
@ -4302,7 +4302,7 @@ or programmatically via the C<Config> module:
print $Config{longsize}, "\n";
print $Config{longlongsize}, "\n";
C<$Config{longlongsize}> is undefined on systems without
C<$Config{longlongsize}> is undefined on systems without
long long support.
=item *
@ -4318,7 +4318,7 @@ handled by the CPU registers) into bytes as
Basically, Intel and VAX CPUs are little-endian, while everybody else,
including Motorola m68k/88k, PPC, Sparc, HP PA, Power, and Cray, are
big-endian. Alpha and MIPS can be either: Digital/Compaq uses (well, used)
big-endian. Alpha and MIPS can be either: Digital/Compaq uses (well, used)
them in little-endian mode, but SGI/Cray uses them in big-endian mode.
The names I<big-endian> and I<little-endian> are comic references to the
@ -4334,7 +4334,7 @@ Some systems may have even weirder byte orders such as
You can determine your system endianness with this incantation:
printf("%#02x ", $_) for unpack("W*", pack L=>0x12345678);
printf("%#02x ", $_) for unpack("W*", pack L=>0x12345678);
The byteorder on the platform where Perl was built is also available
via L<Config>:
@ -4349,36 +4349,36 @@ or from the command line:
Byteorders C<"1234"> and C<"12345678"> are little-endian; C<"4321">
and C<"87654321"> are big-endian.
For portably packed integers, either use the formats C<n>, C<N>, C<v>,
For portably packed integers, either use the formats C<n>, C<N>, C<v>,
and C<V> or else use the C<< > >> and C<< < >> modifiers described
immediately below. See also L<perlport>.
=item *
Starting with Perl 5.9.2, integer and floating-point formats, along with
the C<p> and C<P> formats and C<()> groups, may all be followed by the
the C<p> and C<P> formats and C<()> groups, may all be followed by the
C<< > >> or C<< < >> endianness modifiers to respectively enforce big-
or little-endian byte-order. These modifiers are especially useful
given how C<n>, C<N>, C<v>, and C<V> don't cover signed integers,
or little-endian byte-order. These modifiers are especially useful
given how C<n>, C<N>, C<v>, and C<V> don't cover signed integers,
64-bit integers, or floating-point values.
Here are some concerns to keep in mind when using an endianness modifier:
=over
=item *
=item *
Exchanging signed integers between different platforms works only
Exchanging signed integers between different platforms works only
when all platforms store them in the same format. Most platforms store
signed integers in two's-complement notation, so usually this is not an issue.
=item *
=item *
The C<< > >> or C<< < >> modifiers can only be used on floating-point
formats on big- or little-endian machines. Otherwise, attempting to
use them raises an exception.
=item *
=item *
Forcing big- or little-endian byte-order on floating-point values for
data exchange can work only if all platforms use the same
@ -4388,7 +4388,7 @@ to use C<< > >> or C<< < >> on floating-point values can be useful,
but also dangerous if you don't know exactly what you're doing.
It is not a general way to portably store floating-point values.
=item *
=item *
When using C<< > >> or C<< < >> on a C<()> group, this affects
all types inside the group that accept byte-order modifiers,
@ -4412,7 +4412,7 @@ If you know I<exactly> what you're doing, you can use the C<< > >> or C<< < >>
modifiers to force big- or little-endian byte-order on floating-point values.
Because Perl uses doubles (or long doubles, if configured) internally for
all numeric calculation, converting from double into float and thence
all numeric calculation, converting from double into float and thence
to double again loses precision, so C<unpack("f", pack("f", $foo)>)
will not in general equal $foo.
@ -4421,25 +4421,25 @@ will not in general equal $foo.
Pack and unpack can operate in two modes: character mode (C<C0> mode) where
the packed string is processed per character, and UTF-8 mode (C<U0> mode)
where the packed string is processed in its UTF-8-encoded Unicode form on
a byte-by-byte basis. Character mode is the default unless the format string
starts with C<U>. You can always switch mode mid-format with an explicit
C<C0> or C<U0> in the format. This mode remains in effect until the next
a byte-by-byte basis. Character mode is the default unless the format string
starts with C<U>. You can always switch mode mid-format with an explicit
C<C0> or C<U0> in the format. This mode remains in effect until the next
mode change, or until the end of the C<()> group it (directly) applies to.
Using C<C0> to get Unicode characters while using C<U0> to get I<non>-Unicode
Using C<C0> to get Unicode characters while using C<U0> to get I<non>-Unicode
bytes is not necessarily obvious. Probably only the first of these
is what you want:
$ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
$ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
perl -CS -ne 'printf "%v04X\n", $_ for unpack("C0A*", $_)'
03B1.03C9
$ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
$ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
perl -CS -ne 'printf "%v02X\n", $_ for unpack("U0A*", $_)'
CE.B1.CF.89
$ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
$ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
perl -C0 -ne 'printf "%v02X\n", $_ for unpack("C0A*", $_)'
CE.B1.CF.89
$ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
$ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
perl -C0 -ne 'printf "%v02X\n", $_ for unpack("U0A*", $_)'
C3.8E.C2.B1.C3.8F.C2.89
@ -4450,7 +4450,7 @@ C<pack>/C<unpack> as a substitute for the L<Encode> module.
You must yourself do any alignment or padding by inserting, for example,
enough C<"x">es while packing. There is no way for pack() and unpack()
to know where characters are going to or coming from, so they
to know where characters are going to or coming from, so they
handle their output and input as flat sequences of characters.
=item *
@ -4472,7 +4472,7 @@ characters. For example, to pack() or unpack() a C structure like
struct {
char c; /* one signed, 8-bit character */
double d;
double d;
char cc[2];
}
@ -4602,9 +4602,9 @@ like C<STDOUT>, C<ARGV>, C<ENV>, and the punctuation variables.
A package statement affects dynamic variables only, including those
you've used C<local> on, but I<not> lexical variables, which are created
with C<my>, C<state>, or C<our>. Typically it would be the first
with C<my>, C<state>, or C<our>. Typically it would be the first
declaration in a file included by C<require> or C<use>. You can switch into a
package in more than one place, since this only determines which default
package in more than one place, since this only determines which default
symbol table the compiler uses for the rest of that block. You can refer to
identifiers in other packages than the current one by prefixing the identifier
with the package name and a double colon, as in C<$SomePack::var>
@ -4637,7 +4637,7 @@ L<perlipc/"Bidirectional Communication with Another Process">
for examples of such things.
On systems that support a close-on-exec flag on files, that flag is set
on all newly opened file descriptors whose C<fileno>s are I<higher> than
on all newly opened file descriptors whose C<fileno>s are I<higher> than
the current value of $^F (by default 2 for C<STDERR>). See L<perlvar/$^F>.
=item __PACKAGE__
@ -4887,7 +4887,7 @@ X<read> X<file, read>
Attempts to read LENGTH I<characters> of data into variable SCALAR
from the specified FILEHANDLE. Returns the number of characters
actually read, C<0> at end of file, or undef if there was an error (in
the latter case C<$!> is also set). SCALAR will be grown or shrunk
the latter case C<$!> is also set). SCALAR will be grown or shrunk
so that the last character actually read is the last character of the
scalar after the read.
@ -5039,7 +5039,7 @@ X<redo>
The C<redo> command restarts the loop block without evaluating the
conditional again. The C<continue> block, if any, is not executed. If
the LABEL is omitted, the command refers to the innermost enclosing
loop. Programs that want to lie to themselves about what was just input
loop. Programs that want to lie to themselves about what was just input
normally use this command:
# a simpleminded Pascal comment stripper
@ -5239,14 +5239,14 @@ Subroutine references are the simplest case. When the inclusion system
walks through @INC and encounters a subroutine, this subroutine gets
called with two parameters, the first a reference to itself, and the
second the name of the file to be included (e.g., "F<Foo/Bar.pm>"). The
subroutine should return either nothing or else a list of up to three
subroutine should return either nothing or else a list of up to three
values in the following order:
=over
=item 1
A filehandle, from which the file will be read.
A filehandle, from which the file will be read.
=item 2
@ -5268,7 +5268,7 @@ reference to the subroutine itself is passed in as C<$_[0]>.
If an empty list, C<undef>, or nothing that matches the first 3 values above
is returned, then C<require> looks at the remaining elements of @INC.
Note that this filehandle must be a real filehandle (strictly a typeglob
or reference to a typeglob, whether blessed or unblessed); tied filehandles
or reference to a typeglob, whether blessed or unblessed); tied filehandles
will be ignored and processing will stop there.
If the hook is an array reference, its first element must be a subroutine
@ -5325,7 +5325,7 @@ variables and reset C<??> searches so that they work again. The
expression is interpreted as a list of single characters (hyphens
allowed for ranges). All variables and arrays beginning with one of
those letters are reset to their pristine state. If the expression is
omitted, one-match searches (C<?pattern?>) are reset to match again.
omitted, one-match searches (C<?pattern?>) are reset to match again.
Only resets variables or searches in the current package. Always returns
1. Examples:
@ -5529,9 +5529,9 @@ X<select> X<filehandle, default>
Returns the currently selected filehandle. If FILEHANDLE is supplied,
sets the new current default filehandle for output. This has two
effects: first, a C<write> or a C<print> without a filehandle
effects: first, a C<write> or a C<print> without a filehandle
default to this FILEHANDLE. Second, references to variables related to
output will refer to this output channel.
output will refer to this output channel.
For example, to set the top-of-form format for more than one
output channel, you might do the following:
@ -5654,7 +5654,7 @@ X<semop>
Calls the System V IPC function semop(2) for semaphore operations
such as signalling and waiting. OPSTRING must be a packed array of
semop structures. Each semop structure can be generated with
C<pack("s!3", $semnum, $semop, $semflag)>. The length of OPSTRING
C<pack("s!3", $semnum, $semop, $semflag)>. The length of OPSTRING
implies the number of semaphore operations. Returns true if
successful, false on error. As an example, the
following code waits on semaphore $semnum of semaphore id $semid:
@ -5828,8 +5828,8 @@ X<sleep> X<pause>
=item sleep
Causes the script to sleep for (integer) EXPR seconds, or forever if no
argument is given. Returns the integer number of seconds actually slept.
Causes the script to sleep for (integer) EXPR seconds, or forever if no
argument is given. Returns the integer number of seconds actually slept.
May be interrupted if the process receives a signal such as C<SIGALRM>.
@ -5909,7 +5909,7 @@ In scalar context, the behaviour of C<sort()> is undefined.
If SUBNAME or BLOCK is omitted, C<sort>s in standard string comparison
order. If SUBNAME is specified, it gives the name of a subroutine
that returns an integer less than, equal to, or greater than C<0>,
depending on how the elements of the list are to be ordered. (The
depending on how the elements of the list are to be ordered. (The
C<< <=> >> and C<cmp> operators are extremely useful in such routines.)
SUBNAME may be a scalar variable name (unsubscripted), in which case
the value provides the name of (or a reference to) the actual
@ -5960,32 +5960,32 @@ Examples:
# sort lexically
@articles = sort @files;
# same thing, but with explicit sort routine
@articles = sort {$a cmp $b} @files;
# now case-insensitively
@articles = sort {uc($a) cmp uc($b)} @files;
# same thing in reversed order
@articles = sort {$b cmp $a} @files;
# sort numerically ascending
@articles = sort {$a <=> $b} @files;
# sort numerically descending
@articles = sort {$b <=> $a} @files;
# this sorts the %age hash by value instead of key
# using an in-line function
@eldest = sort { $age{$b} <=> $age{$a} } keys %age;
# sort using explicit subroutine name
sub byage {
$age{$a} <=> $age{$b}; # presuming numeric
}
@sortedclass = sort byage @class;
sub backwards { $b cmp $a }
@harry = qw(dog cat x Cain Abel);
@george = qw(gone chased yz Punished Axed);
@ -6033,14 +6033,14 @@ Examples:
# as a sort subroutine (including other package's subroutines)
package other;
sub backwards ($$) { $_[1] cmp $_[0]; } # $a and $b are not set here
package main;
@new = sort other::backwards @old;
# guarantee stability, regardless of algorithm
use sort 'stable';
@new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old;
# force use of mergesort (not portable outside Perl 5.8)
use sort '_mergesort'; # note discouraging _
@new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old;
@ -6273,8 +6273,8 @@ For example:
Perl does its own C<sprintf> formatting: it emulates the C
function sprintf(3), but doesn't use it except for floating-point
numbers, and even then only standard modifiers are allowed.
Non-standard extensions in your local sprintf(3) are
numbers, and even then only standard modifiers are allowed.
Non-standard extensions in your local sprintf(3) are
therefore unavailable from Perl.
Unlike C<printf>, C<sprintf> does not do what you probably mean when you
@ -6430,7 +6430,7 @@ For example:
printf '<%.1e>', 10; # prints "<1.0e+01>"
For "g" and "G", this specifies the maximum number of digits to show,
including those prior to the decimal point and those after it; for
including those prior to the decimal point and those after it; for
example:
# These examples are subject to system-specific variation.
@ -6501,7 +6501,7 @@ as supported by the compiler used to build Perl:
hh interpret integer as C type "char" or "unsigned char"
on Perl 5.14 or later
h interpret integer as C type "short" or "unsigned short"
j interpret integer as C type "intmax_t" on Perl 5.14
j interpret integer as C type "intmax_t" on Perl 5.14
or later, and only with a C99 compiler (unportable)
l interpret integer as C type "long" or "unsigned long"
q, L, or ll interpret integer as C type "long long", "unsigned long long",
@ -6511,7 +6511,7 @@ as supported by the compiler used to build Perl:
As of 5.14, none of these raises an exception if they are not supported on
your platform. However, if warnings are enabled, a warning of the
C<printf> warning class is issued on an unsupported conversion flag.
C<printf> warning class is issued on an unsupported conversion flag.
Should you instead prefer an exception, do this:
use warnings FATAL => "printf";
@ -6678,7 +6678,7 @@ X<stat> X<file, status> X<ctime>
=item stat
Returns a 13-element list giving the status info for a file, either
the file opened via FILEHANDLE or DIRHANDLE, or named by EXPR. If EXPR is
the file opened via FILEHANDLE or DIRHANDLE, or named by EXPR. If EXPR is
omitted, it stats C<$_> (not C<_>!). Returns the empty list if C<stat> fails. Typically
used as follows:
@ -6821,7 +6821,7 @@ lexical variables that are reinitialized each time their enclosing block
is entered.
See L<perlsub/"Persistent Private Variables"> for details.
C<state> variables are enabled only when the C<use feature "state"> pragma
C<state> variables are enabled only when the C<use feature "state"> pragma
is in effect, unless the keyword is written as C<CORE::state>.
See also L<feature>.
@ -7216,7 +7216,7 @@ possible failure modes by inspecting C<$?> like this:
Alternatively, you may inspect the value of C<${^CHILD_ERROR_NATIVE}>
with the C<W*()> calls from the POSIX module.
When C<system>'s arguments are executed indirectly by the shell,
When C<system>'s arguments are executed indirectly by the shell,
results and return codes are subject to its quirks.
See L<perlop/"`STRING`"> and L</exec> for details.
@ -7489,7 +7489,7 @@ even if you tell C<sysopen> to create a file with permissions C<0777>,
if your umask is C<0022>, then the file will actually be created with
permissions C<0755>. If your C<umask> were C<0027> (group can't
write; others can't read, write, or execute), then passing
C<sysopen> C<0666> would create a file with mode C<0640> (because
C<sysopen> C<0666> would create a file with mode C<0640> (because
C<0666 &~ 027> is C<0640>).
Here's some advice: supply a creation mode of C<0666> for regular
@ -7503,7 +7503,7 @@ kept private: mail files, web browser cookies, I<.rhosts> files, and
so on.
If umask(2) is not implemented on your system and you are trying to
restrict access for I<yourself> (i.e., C<< (EXPR & 0700) > 0 >>),
restrict access for I<yourself> (i.e., C<< (EXPR & 0700) > 0 >>),
raises an exception. If umask(2) is not implemented and you are
not trying to restrict access for yourself, returns C<undef>.
@ -7756,7 +7756,7 @@ through the end of the file).
Because C<use> takes effect at compile time, it doesn't respect the
ordinary flow control of the code being compiled. In particular, putting
a C<use> inside the false branch of a conditional doesn't prevent it
from being processed. If a module or pragma only needs to be loaded
from being processed. If a module or pragma only needs to be loaded
conditionally, this can be done using the L<if> pragma:
use if $] < 5.008, "utf8";
@ -7764,7 +7764,7 @@ conditionally, this can be done using the L<if> pragma:
There's a corresponding C<no> declaration that unimports meanings imported
by C<use>, i.e., it calls C<unimport Module LIST> instead of C<import>.
It behaves just as C<import> does with VERSION, an omitted or empty LIST,
It behaves just as C<import> does with VERSION, an omitted or empty LIST,
or no unimport method being found.
no integer;
@ -7795,7 +7795,7 @@ the user running the program:
$atime = $mtime = time;
utime $atime, $mtime, @ARGV;
Since Perl 5.7.2, if the first two elements of the list are C<undef>,
Since Perl 5.7.2, if the first two elements of the list are C<undef>,
the utime(2) syscall from your C library is called with a null second
argument. On most systems, this will set the file's access and
modification times to the current time (i.e., equivalent to the example
@ -7803,9 +7803,9 @@ above) and will work even on files you don't own provided you have write
permission:
for $file (@ARGV) {
utime(undef, undef, $file)
utime(undef, undef, $file)
|| warn "couldn't touch $file: $!";
}
}
Under NFS this will use the time of the NFS server, not the time of
the local machine. If there is a time synchronization problem, the
@ -7814,7 +7814,7 @@ touch(1) command will in fact normally use this form instead of the
one shown in the first example.
Passing only one of the first two elements as C<undef> is
equivalent to passing a 0 and will not have the effect
equivalent to passing a 0 and will not have the effect
described when both are C<undef>. This also triggers an
uninitialized warning.
@ -7904,7 +7904,7 @@ to try to write off the beginning of the string (i.e., negative OFFSET).
If the string happens to be encoded as UTF-8 internally (and thus has
the UTF8 flag set), this is ignored by C<vec>, and it operates on the
internal byte string, not the conceptual character string, even if you
only have characters with values less than 256.
only have characters with values less than 256.
Strings created with C<vec> can also be manipulated with the logical
operators C<|>, C<&>, C<^>, and C<~>. These operators will assume a bit
@ -7970,7 +7970,7 @@ Here is an example to illustrate how the bits actually fall in place:
.
__END__
Regardless of the machine architecture on which it runs, the
Regardless of the machine architecture on which it runs, the
example above should print the following table:
0 1 2 3
@ -8218,7 +8218,7 @@ X<when>
C<when> is analogous to the C<case> keyword in other languages. Used with a
C<foreach> loop or the experimental C<given> block, C<when> can be used in
Perl to implement C<switch>/C<case> like statements. Available as a
statement after Perl 5.10 and as a statement modifier after 5.14.
statement after Perl 5.10 and as a statement modifier after 5.14.
Here are three examples:
use v5.10;
@ -8237,7 +8237,7 @@ Here are three examples:
# require 5.14 for when as statement modifier
use v5.14;
foreach (@fruits) {
say "I like apples." when /apples?/;
say "I like apples." when /apples?/;
say "I don't like oranges." when /oranges?;
default { say "I don't like anything" }
}

16
gnu/usr.bin/perl/ext/Pod-Functions/Functions_pm.PL
View File

@ -169,7 +169,7 @@ or
perl /path/to/lib/Pod/Functions.pm
This will print a grouped list of Perl's functions, like the
This will print a grouped list of Perl's functions, like the
L<perlfunc/"Perl Functions by Category"> section.
=head1 DESCRIPTION
@ -190,12 +190,12 @@ The category can be a comma separated list.
=item %Flavor
In this hash each key represents a function and the value is a short
In this hash each key represents a function and the value is a short
description of that function.
=item %Type_Description
In this hash each key represents a category of functions and the value is
In this hash each key represents a category of functions and the value is
a short description of that category.
=item @Type_Order
@ -246,20 +246,20 @@ while (<DATA>) {
close DATA;
my( $typedesc, $list );
unless (caller) {
unless (caller) {
foreach my $type ( @Type_Order ) {
$list = join(", ", sort @{$Kinds{$type}});
$typedesc = $Type_Description{$type} . ":";
write;
}
}
}
format =
format =
^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
$typedesc
$typedesc
~~ ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
$typedesc
$typedesc
~~ ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
$list
.

6
gnu/usr.bin/perl/pod/perldiag.pod
View File

@ -7693,15 +7693,15 @@ are automatically rebound to the current values of such variables.
with alpha parts.
=item Verb pattern '%s' has a mandatory argument in regex; marked by
S<<-- HERE> in m/%s/
S<<-- HERE> in m/%s/
(F) You used a verb pattern that requires an argument. Supply an
argument or check that you are using the right verb.
=item Verb pattern '%s' may not have an argument in regex; marked by
S<<-- HERE> in m/%s/
S<<-- HERE> in m/%s/
(F) You used a verb pattern that is not allowed an argument. Remove the
(F) You used a verb pattern that is not allowed an argument. Remove the
argument or check that you are using the right verb.
=item Version control conflict marker

34
gnu/usr.bin/perl/pod/perlform.pod
View File

@ -31,8 +31,8 @@ Output record formats are declared as follows:
FORMLIST
.
If the name is omitted, format "STDOUT" is defined. A single "." in
column 1 is used to terminate a format. FORMLIST consists of a sequence
If the name is omitted, format "STDOUT" is defined. A single "." in
column 1 is used to terminate a format. FORMLIST consists of a sequence
of lines, each of which may be one of three types:
=over 4
@ -84,13 +84,13 @@ the various possibilities in detail.
=head2 Text Fields
X<format, text field>
The length of the field is supplied by padding out the field with multiple
The length of the field is supplied by padding out the field with multiple
"E<lt>", "E<gt>", or "|" characters to specify a non-numeric field with,
respectively, left justification, right justification, or centering.
respectively, left justification, right justification, or centering.
For a regular field, the value (up to the first newline) is taken and
printed according to the selected justification, truncating excess characters.
If you terminate a text field with "...", three dots will be shown if
the value is truncated. A special text field may be used to do rudimentary
the value is truncated. A special text field may be used to do rudimentary
multi-line text block filling; see L</Using Fill Mode> for details.
Example:
@ -133,10 +133,10 @@ line feed is chomped off, but all other characters are emitted verbatim.
=head2 The Field ^* for Variable-Width One-line-at-a-time Text
X<^*>
Like "@*", this is a variable-width field. The value supplied must be a
scalar variable. Perl puts the first line (up to the first "\n") of the
text into the field, and then chops off the front of the string so that
the next time the variable is referenced, more of the text can be printed.
Like "@*", this is a variable-width field. The value supplied must be a
scalar variable. Perl puts the first line (up to the first "\n") of the
text into the field, and then chops off the front of the string so that
the next time the variable is referenced, more of the text can be printed.
The variable will I<not> be restored.
Example:
@ -183,15 +183,15 @@ the variable is referenced, more of the text can be printed. (Yes, this
means that the variable itself is altered during execution of the write()
call, and is not restored.) The next portion of text is determined by
a crude line-breaking algorithm. You may use the carriage return character
(C<\r>) to force a line break. You can change which characters are legal
to break on by changing the variable C<$:> (that's
$FORMAT_LINE_BREAK_CHARACTERS if you're using the English module) to a
(C<\r>) to force a line break. You can change which characters are legal
to break on by changing the variable C<$:> (that's
$FORMAT_LINE_BREAK_CHARACTERS if you're using the English module) to a
list of the desired characters.
Normally you would use a sequence of fields in a vertical stack associated
with the same scalar variable to print out a block of text. You might wish
to end the final field with the text "...", which will appear in the output
if the text was too long to appear in its entirety.
Normally you would use a sequence of fields in a vertical stack associated
with the same scalar variable to print out a block of text. You might wish
to end the final field with the text "...", which will appear in the output
if the text was too long to appear in its entirety.
=head2 Suppressing Lines Where All Fields Are Void
@ -210,7 +210,7 @@ the line will be repeated until all the fields on the line are exhausted,
i.e. undefined. For special (caret) text fields this will occur sooner or
later, but if you use a text field of the at variety, the expression you
supply had better not give the same value every time forever! (C<shift(@f)>
is a simple example that would work.) Don't use a regular (at) numeric
is a simple example that would work.) Don't use a regular (at) numeric
field in such lines, because it will never go blank.

2
gnu/usr.bin/perl/regen/feature.pl
View File

@ -1,5 +1,5 @@
#!/usr/bin/perl
#
#
# Regenerate (overwriting only if changed):
#
# lib/feature.pm

6
lib/libc/stdlib/malloc.3
View File

@ -30,9 +30,9 @@
.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
.\" SUCH DAMAGE.
.\"
.\" $OpenBSD: malloc.3,v 1.136 2023/06/30 06:24:58 otto Exp $
.\" $OpenBSD: malloc.3,v 1.137 2023/07/01 18:35:14 otto Exp $
.\"
.Dd $Mdocdate: June 30 2023 $
.Dd $Mdocdate: July 1 2023 $
.Dt MALLOC 3
.Os
.Sh NAME
@ -325,7 +325,7 @@ Increase the junk level by one if it is smaller than 2.
Decrease the junk level by one if it is larger than 0.
Junking writes some junk bytes into the area allocated.
Junk is bytes of 0xdb when allocating;
freed allocations are filled with 0xdf.
small allocations are initially junked with 0xdf as are freed allocations.
By default the junk level is 1: after free,
small chunks are completely junked;
for pages the first part is junked.

8
lib/libc/uuid/uuid_compare.3
View File

@ -1,4 +1,4 @@
.\" $OpenBSD: uuid_compare.3,v 1.2 2020/11/14 10:35:58 jmc Exp $
.\" $OpenBSD: uuid_compare.3,v 1.3 2023/07/03 08:53:27 jasper Exp $
.\" $NetBSD: uuid.3,v 1.7 2008/05/02 18:11:05 martin Exp $
.\"
.\" Copyright (c) 2004 The NetBSD Foundation, Inc.
@ -55,7 +55,7 @@
.\"
.\" $FreeBSD: src/lib/libc/uuid/uuid.3,v 1.4 2003/08/08 19:12:28 marcel Exp $
.\"
.Dd $Mdocdate: November 14 2020 $
.Dd $Mdocdate: July 3 2023 $
.Dt UUID_COMPARE 3
.Os
.Sh NAME
@ -84,11 +84,11 @@
.Ft void
.Fn uuid_enc_le "void *buf" "const uuid_t *uuid"
.Ft void
.Fn uuid_dec_le "const void *buf" "uuid_t *"
.Fn uuid_dec_le "const void *buf" "uuid_t *uuid"
.Ft void
.Fn uuid_enc_be "void *buf" "const uuid_t *uuid"
.Ft void
.Fn uuid_dec_be "const void *buf" "uuid_t *"
.Fn uuid_dec_be "const void *buf" "uuid_t *uuid"
.Sh DESCRIPTION
These routines provide for the creation and manipulation of Universally
Unique Identifiers

9
lib/libcrypto/Makefile
View File

@ -1,4 +1,4 @@
# $OpenBSD: Makefile,v 1.133 2023/06/29 06:12:04 tb Exp $
# $OpenBSD: Makefile,v 1.136 2023/07/06 14:37:39 tb Exp $
LIB= crypto
LIBREBUILD=y
@ -195,6 +195,7 @@ SRCS+= bn_mont.c
SRCS+= bn_mul.c
SRCS+= bn_prime.c
SRCS+= bn_primitives.c
SRCS+= bn_print.c
SRCS+= bn_rand.c
SRCS+= bn_recp.c
SRCS+= bn_shift.c
@ -351,16 +352,14 @@ SRCS+= ecp_smpl.c
SRCS+= ecx_methods.c
# ecdh/
SRCS+= ecdh_kdf.c
SRCS+= ecdh.c
SRCS+= ech_err.c
SRCS+= ech_key.c
SRCS+= ech_lib.c
# ecdsa/
SRCS+= ecs_asn1.c
SRCS+= ecs_err.c
SRCS+= ecs_lib.c
SRCS+= ecs_ossl.c
SRCS+= ecdsa.c
# engine/
SRCS+= eng_all.c

374
lib/libcrypto/Symbols.namespace
View File

@ -889,3 +889,377 @@ _libre_X509v3_addr_validate_path
_libre_X509v3_asid_validate_resource_set
_libre_X509v3_addr_validate_resource_set
_libre_ERR_load_X509V3_strings
_libre_ChaCha_set_key
_libre_ChaCha_set_iv
_libre_ChaCha
_libre_CRYPTO_chacha_20
_libre_CRYPTO_xchacha_20
_libre_CRYPTO_hchacha_20
_libre_d2i_ASN1_SEQUENCE_ANY
_libre_i2d_ASN1_SEQUENCE_ANY
_libre_d2i_ASN1_SET_ANY
_libre_i2d_ASN1_SET_ANY
_libre_ASN1_TYPE_new
_libre_ASN1_TYPE_free
_libre_d2i_ASN1_TYPE
_libre_i2d_ASN1_TYPE
_libre_ASN1_TYPE_get
_libre_ASN1_TYPE_set
_libre_ASN1_TYPE_set1
_libre_ASN1_TYPE_cmp
_libre_ASN1_OBJECT_new
_libre_ASN1_OBJECT_free
_libre_i2d_ASN1_OBJECT
_libre_d2i_ASN1_OBJECT
_libre_ASN1_STRING_new
_libre_ASN1_STRING_free
_libre_ASN1_STRING_copy
_libre_ASN1_STRING_dup
_libre_ASN1_STRING_type_new
_libre_ASN1_STRING_cmp
_libre_ASN1_STRING_set
_libre_ASN1_STRING_set0
_libre_ASN1_STRING_length
_libre_ASN1_STRING_length_set
_libre_ASN1_STRING_type
_libre_ASN1_STRING_data
_libre_ASN1_STRING_get0_data
_libre_ASN1_BIT_STRING_new
_libre_ASN1_BIT_STRING_free
_libre_d2i_ASN1_BIT_STRING
_libre_i2d_ASN1_BIT_STRING
_libre_ASN1_BIT_STRING_set
_libre_ASN1_BIT_STRING_set_bit
_libre_ASN1_BIT_STRING_get_bit
_libre_ASN1_BIT_STRING_check
_libre_ASN1_BIT_STRING_name_print
_libre_ASN1_BIT_STRING_num_asc
_libre_ASN1_BIT_STRING_set_asc
_libre_ASN1_INTEGER_new
_libre_ASN1_INTEGER_free
_libre_d2i_ASN1_INTEGER
_libre_i2d_ASN1_INTEGER
_libre_d2i_ASN1_UINTEGER
_libre_ASN1_INTEGER_dup
_libre_ASN1_INTEGER_cmp
_libre_ASN1_ENUMERATED_new
_libre_ASN1_ENUMERATED_free
_libre_d2i_ASN1_ENUMERATED
_libre_i2d_ASN1_ENUMERATED
_libre_ASN1_UTCTIME_check
_libre_ASN1_UTCTIME_set
_libre_ASN1_UTCTIME_adj
_libre_ASN1_UTCTIME_set_string
_libre_ASN1_UTCTIME_cmp_time_t
_libre_ASN1_GENERALIZEDTIME_check
_libre_ASN1_GENERALIZEDTIME_set
_libre_ASN1_GENERALIZEDTIME_adj
_libre_ASN1_GENERALIZEDTIME_set_string
_libre_ASN1_OCTET_STRING_new
_libre_ASN1_OCTET_STRING_free
_libre_d2i_ASN1_OCTET_STRING
_libre_i2d_ASN1_OCTET_STRING
_libre_ASN1_OCTET_STRING_dup
_libre_ASN1_OCTET_STRING_cmp
_libre_ASN1_OCTET_STRING_set
_libre_ASN1_VISIBLESTRING_new
_libre_ASN1_VISIBLESTRING_free
_libre_d2i_ASN1_VISIBLESTRING
_libre_i2d_ASN1_VISIBLESTRING
_libre_ASN1_UNIVERSALSTRING_new
_libre_ASN1_UNIVERSALSTRING_free
_libre_d2i_ASN1_UNIVERSALSTRING
_libre_i2d_ASN1_UNIVERSALSTRING
_libre_ASN1_UTF8STRING_new
_libre_ASN1_UTF8STRING_free
_libre_d2i_ASN1_UTF8STRING
_libre_i2d_ASN1_UTF8STRING
_libre_ASN1_NULL_new
_libre_ASN1_NULL_free
_libre_d2i_ASN1_NULL
_libre_i2d_ASN1_NULL
_libre_ASN1_BMPSTRING_new
_libre_ASN1_BMPSTRING_free
_libre_d2i_ASN1_BMPSTRING
_libre_i2d_ASN1_BMPSTRING
_libre_ASN1_PRINTABLE_new
_libre_ASN1_PRINTABLE_free
_libre_d2i_ASN1_PRINTABLE
_libre_i2d_ASN1_PRINTABLE
_libre_DIRECTORYSTRING_new
_libre_DIRECTORYSTRING_free
_libre_d2i_DIRECTORYSTRING
_libre_i2d_DIRECTORYSTRING
_libre_DISPLAYTEXT_new
_libre_DISPLAYTEXT_free
_libre_d2i_DISPLAYTEXT
_libre_i2d_DISPLAYTEXT
_libre_ASN1_PRINTABLESTRING_new
_libre_ASN1_PRINTABLESTRING_free
_libre_d2i_ASN1_PRINTABLESTRING
_libre_i2d_ASN1_PRINTABLESTRING
_libre_ASN1_T61STRING_new
_libre_ASN1_T61STRING_free
_libre_d2i_ASN1_T61STRING
_libre_i2d_ASN1_T61STRING
_libre_ASN1_IA5STRING_new
_libre_ASN1_IA5STRING_free
_libre_d2i_ASN1_IA5STRING
_libre_i2d_ASN1_IA5STRING
_libre_ASN1_GENERALSTRING_new
_libre_ASN1_GENERALSTRING_free
_libre_d2i_ASN1_GENERALSTRING
_libre_i2d_ASN1_GENERALSTRING
_libre_ASN1_UTCTIME_new
_libre_ASN1_UTCTIME_free
_libre_d2i_ASN1_UTCTIME
_libre_i2d_ASN1_UTCTIME
_libre_ASN1_GENERALIZEDTIME_new
_libre_ASN1_GENERALIZEDTIME_free
_libre_d2i_ASN1_GENERALIZEDTIME
_libre_i2d_ASN1_GENERALIZEDTIME
_libre_ASN1_TIME_new
_libre_ASN1_TIME_free
_libre_d2i_ASN1_TIME
_libre_i2d_ASN1_TIME
_libre_ASN1_TIME_to_tm
_libre_ASN1_TIME_compare
_libre_ASN1_TIME_cmp_time_t
_libre_ASN1_TIME_normalize
_libre_ASN1_TIME_set_string_X509
_libre_ASN1_TIME_diff
_libre_ASN1_TIME_set
_libre_ASN1_TIME_set_tm
_libre_ASN1_TIME_adj
_libre_ASN1_TIME_check
_libre_ASN1_TIME_to_generalizedtime
_libre_ASN1_TIME_set_string
_libre_i2a_ASN1_INTEGER
_libre_a2i_ASN1_INTEGER
_libre_i2a_ASN1_ENUMERATED
_libre_a2i_ASN1_ENUMERATED
_libre_i2a_ASN1_OBJECT
_libre_a2i_ASN1_STRING
_libre_i2a_ASN1_STRING
_libre_i2t_ASN1_OBJECT
_libre_a2d_ASN1_OBJECT
_libre_ASN1_OBJECT_create
_libre_ASN1_INTEGER_get_uint64
_libre_ASN1_INTEGER_set_uint64
_libre_ASN1_INTEGER_get_int64
_libre_ASN1_INTEGER_set_int64
_libre_ASN1_INTEGER_set
_libre_ASN1_INTEGER_get
_libre_BN_to_ASN1_INTEGER
_libre_ASN1_INTEGER_to_BN
_libre_ASN1_ENUMERATED_get_int64
_libre_ASN1_ENUMERATED_set_int64
_libre_ASN1_ENUMERATED_set
_libre_ASN1_ENUMERATED_get
_libre_BN_to_ASN1_ENUMERATED
_libre_ASN1_ENUMERATED_to_BN
_libre_ASN1_PRINTABLE_type
_libre_ASN1_get_object
_libre_ASN1_put_object
_libre_ASN1_put_eoc
_libre_ASN1_object_size
_libre_ASN1_item_dup
_libre_ASN1_dup
_libre_ASN1_d2i_fp
_libre_ASN1_item_d2i_fp
_libre_ASN1_i2d_fp
_libre_ASN1_item_i2d_fp
_libre_ASN1_STRING_print_ex_fp
_libre_ASN1_STRING_to_UTF8
_libre_ASN1_d2i_bio
_libre_ASN1_item_d2i_bio
_libre_ASN1_i2d_bio
_libre_ASN1_item_i2d_bio
_libre_ASN1_UTCTIME_print
_libre_ASN1_GENERALIZEDTIME_print
_libre_ASN1_TIME_print
_libre_ASN1_STRING_print
_libre_ASN1_STRING_print_ex
_libre_ASN1_bn_print
_libre_ASN1_buf_print
_libre_ASN1_parse
_libre_ASN1_parse_dump
_libre_ASN1_tag2bit
_libre_ASN1_tag2str
_libre_ASN1_UNIVERSALSTRING_to_string
_libre_ASN1_TYPE_set_octetstring
_libre_ASN1_TYPE_get_octetstring
_libre_ASN1_TYPE_set_int_octetstring
_libre_ASN1_TYPE_get_int_octetstring
_libre_ASN1_item_pack
_libre_ASN1_item_unpack
_libre_ASN1_STRING_set_default_mask
_libre_ASN1_STRING_set_default_mask_asc
_libre_ASN1_STRING_get_default_mask
_libre_ASN1_mbstring_copy
_libre_ASN1_mbstring_ncopy
_libre_ASN1_STRING_set_by_NID
_libre_ASN1_STRING_TABLE_get
_libre_ASN1_STRING_TABLE_add
_libre_ASN1_STRING_TABLE_cleanup
_libre_ASN1_item_new
_libre_ASN1_item_free
_libre_ASN1_item_d2i
_libre_ASN1_item_i2d
_libre_ASN1_add_oid_module
_libre_ASN1_generate_nconf
_libre_ASN1_generate_v3
_libre_ASN1_item_print
_libre_ASN1_PCTX_new
_libre_ASN1_PCTX_free
_libre_ASN1_PCTX_get_flags
_libre_ASN1_PCTX_set_flags
_libre_ASN1_PCTX_get_nm_flags
_libre_ASN1_PCTX_set_nm_flags
_libre_ASN1_PCTX_get_cert_flags
_libre_ASN1_PCTX_set_cert_flags
_libre_ASN1_PCTX_get_oid_flags
_libre_ASN1_PCTX_set_oid_flags
_libre_ASN1_PCTX_get_str_flags
_libre_ASN1_PCTX_set_str_flags
_libre_BIO_f_asn1
_libre_SMIME_crlf_copy
_libre_SMIME_text
_libre_ERR_load_ASN1_strings
_libre_ASN1_time_parse
_libre_ASN1_time_tm_cmp
_libre_ASN1_item_ex_new
_libre_ASN1_item_ex_free
_libre_ASN1_template_new
_libre_ASN1_primitive_new
_libre_ASN1_template_free
_libre_ASN1_template_d2i
_libre_ASN1_item_ex_d2i
_libre_ASN1_item_ex_i2d
_libre_ASN1_template_i2d
_libre_ASN1_primitive_free
_libre_BIO_set_flags
_libre_BIO_test_flags
_libre_BIO_clear_flags
_libre_BIO_get_callback
_libre_BIO_set_callback
_libre_BIO_get_callback_ex
_libre_BIO_set_callback_ex
_libre_BIO_get_callback_arg
_libre_BIO_set_callback_arg
_libre_BIO_method_name
_libre_BIO_method_type
_libre_BIO_meth_new
_libre_BIO_meth_free
_libre_BIO_meth_get_write
_libre_BIO_meth_set_write
_libre_BIO_meth_get_read
_libre_BIO_meth_set_read
_libre_BIO_meth_get_puts
_libre_BIO_meth_set_puts
_libre_BIO_meth_get_gets
_libre_BIO_meth_set_gets
_libre_BIO_meth_get_ctrl
_libre_BIO_meth_set_ctrl
_libre_BIO_meth_get_create
_libre_BIO_meth_set_create
_libre_BIO_meth_get_destroy
_libre_BIO_meth_set_destroy
_libre_BIO_meth_get_callback_ctrl
_libre_BIO_meth_set_callback_ctrl
_libre_BIO_ctrl_pending
_libre_BIO_ctrl_wpending
_libre_BIO_ctrl_get_write_guarantee
_libre_BIO_ctrl_get_read_request
_libre_BIO_ctrl_reset_read_request
_libre_BIO_set_ex_data
_libre_BIO_get_ex_data
_libre_BIO_number_read
_libre_BIO_number_written
_libre_BIO_asn1_set_prefix
_libre_BIO_asn1_get_prefix
_libre_BIO_asn1_set_suffix
_libre_BIO_asn1_get_suffix
_libre_BIO_get_new_index
_libre_BIO_s_file
_libre_BIO_new_file
_libre_BIO_new_fp
_libre_BIO_new
_libre_BIO_set
_libre_BIO_free
_libre_BIO_up_ref
_libre_BIO_get_data
_libre_BIO_set_data
_libre_BIO_get_init
_libre_BIO_set_init
_libre_BIO_get_shutdown
_libre_BIO_set_shutdown
_libre_BIO_vfree
_libre_BIO_read
_libre_BIO_gets
_libre_BIO_write
_libre_BIO_puts
_libre_BIO_indent
_libre_BIO_ctrl
_libre_BIO_callback_ctrl
_libre_BIO_ptr_ctrl
_libre_BIO_int_ctrl
_libre_BIO_push
_libre_BIO_pop
_libre_BIO_free_all
_libre_BIO_find_type
_libre_BIO_next
_libre_BIO_set_next
_libre_BIO_get_retry_BIO
_libre_BIO_get_retry_reason
_libre_BIO_set_retry_reason
_libre_BIO_dup_chain
_libre_BIO_nread0
_libre_BIO_nread
_libre_BIO_nwrite0
_libre_BIO_nwrite
_libre_BIO_debug_callback
_libre_BIO_s_mem
_libre_BIO_new_mem_buf
_libre_BIO_s_socket
_libre_BIO_s_connect
_libre_BIO_s_accept
_libre_BIO_s_fd
_libre_BIO_s_log
_libre_BIO_s_bio
_libre_BIO_s_null
_libre_BIO_f_null
_libre_BIO_f_buffer
_libre_BIO_f_nbio_test
_libre_BIO_s_datagram
_libre_BIO_sock_should_retry
_libre_BIO_sock_non_fatal_error
_libre_BIO_dgram_non_fatal_error
_libre_BIO_fd_should_retry
_libre_BIO_fd_non_fatal_error
_libre_BIO_dump
_libre_BIO_dump_indent
_libre_BIO_dump_fp
_libre_BIO_dump_indent_fp
_libre_BIO_gethostbyname
_libre_BIO_sock_error
_libre_BIO_socket_ioctl
_libre_BIO_socket_nbio
_libre_BIO_get_port
_libre_BIO_get_host_ip
_libre_BIO_get_accept_socket
_libre_BIO_accept
_libre_BIO_sock_init
_libre_BIO_sock_cleanup
_libre_BIO_set_tcp_ndelay
_libre_BIO_new_socket
_libre_BIO_new_dgram
_libre_BIO_new_fd
_libre_BIO_new_connect
_libre_BIO_new_accept
_libre_BIO_copy_next_retry
_libre_BIO_printf
_libre_BIO_vprintf
_libre_BIO_snprintf
_libre_BIO_vsnprintf
_libre_ERR_load_BIO_strings

13
lib/libcrypto/asn1/a_bitstr.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: a_bitstr.c,v 1.38 2023/01/13 14:46:08 tb Exp $ */
/* $OpenBSD: a_bitstr.c,v 1.39 2023/07/05 21:23:36 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -79,12 +79,14 @@ ASN1_BIT_STRING_new(void)
{
return (ASN1_BIT_STRING *)ASN1_item_new(&ASN1_BIT_STRING_it);
}
LCRYPTO_ALIAS(ASN1_BIT_STRING_new);
void
ASN1_BIT_STRING_free(ASN1_BIT_STRING *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASN1_BIT_STRING_it);
}
LCRYPTO_ALIAS(ASN1_BIT_STRING_free);
static void
asn1_abs_clear_unused_bits(ASN1_BIT_STRING *abs)
@ -110,6 +112,7 @@ ASN1_BIT_STRING_set(ASN1_BIT_STRING *x, unsigned char *d, int len)
{
return ASN1_STRING_set(x, d, len);
}
LCRYPTO_ALIAS(ASN1_BIT_STRING_set);
int
ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value)
@ -144,6 +147,7 @@ ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value)
return (1);
}
LCRYPTO_ALIAS(ASN1_BIT_STRING_set_bit);
int
ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING *a, int n)
@ -156,6 +160,7 @@ ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING *a, int n)
return (0);
return ((a->data[w] & v) != 0);
}
LCRYPTO_ALIAS(ASN1_BIT_STRING_get_bit);
/*
* Checks if the given bit string contains only bits specified by
@ -182,6 +187,7 @@ ASN1_BIT_STRING_check(const ASN1_BIT_STRING *a, const unsigned char *flags,
}
return ok;
}
LCRYPTO_ALIAS(ASN1_BIT_STRING_check);
int
ASN1_BIT_STRING_name_print(BIO *out, ASN1_BIT_STRING *bs,
@ -202,6 +208,7 @@ ASN1_BIT_STRING_name_print(BIO *out, ASN1_BIT_STRING *bs,
BIO_puts(out, "\n");
return 1;
}
LCRYPTO_ALIAS(ASN1_BIT_STRING_name_print);
int
ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING *bs, const char *name, int value,
@ -218,6 +225,7 @@ ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING *bs, const char *name, int value,
}
return 1;
}
LCRYPTO_ALIAS(ASN1_BIT_STRING_set_asc);
int
ASN1_BIT_STRING_num_asc(const char *name, BIT_STRING_BITNAME *tbl)
@ -231,6 +239,7 @@ ASN1_BIT_STRING_num_asc(const char *name, BIT_STRING_BITNAME *tbl)
}
return -1;
}
LCRYPTO_ALIAS(ASN1_BIT_STRING_num_asc);
int
i2c_ASN1_BIT_STRING(ASN1_BIT_STRING *a, unsigned char **pp)
@ -388,6 +397,7 @@ i2d_ASN1_BIT_STRING(ASN1_BIT_STRING *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_BIT_STRING_it);
}
LCRYPTO_ALIAS(i2d_ASN1_BIT_STRING);
ASN1_BIT_STRING *
d2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a, const unsigned char **in, long len)
@ -395,3 +405,4 @@ d2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a, const unsigned char **in, long len)
return (ASN1_BIT_STRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_BIT_STRING_it);
}
LCRYPTO_ALIAS(d2i_ASN1_BIT_STRING);

14
lib/libcrypto/asn1/a_enum.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: a_enum.c,v 1.28 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: a_enum.c,v 1.29 2023/07/05 21:23:36 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -84,6 +84,7 @@ ASN1_ENUMERATED_new(void)
{
return (ASN1_ENUMERATED *)ASN1_item_new(&ASN1_ENUMERATED_it);
}
LCRYPTO_ALIAS(ASN1_ENUMERATED_new);
static void
asn1_aenum_clear(ASN1_ENUMERATED *aenum)
@ -100,6 +101,7 @@ ASN1_ENUMERATED_free(ASN1_ENUMERATED *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASN1_ENUMERATED_it);
}
LCRYPTO_ALIAS(ASN1_ENUMERATED_free);
int
ASN1_ENUMERATED_get_int64(int64_t *out_val, const ASN1_ENUMERATED *aenum)
@ -122,6 +124,7 @@ ASN1_ENUMERATED_get_int64(int64_t *out_val, const ASN1_ENUMERATED *aenum)
return asn1_aint_get_int64(&cbs, (aenum->type == V_ASN1_NEG_ENUMERATED),
out_val);
}
LCRYPTO_ALIAS(ASN1_ENUMERATED_get_int64);
int
ASN1_ENUMERATED_set_int64(ASN1_ENUMERATED *aenum, int64_t val)
@ -139,6 +142,7 @@ ASN1_ENUMERATED_set_int64(ASN1_ENUMERATED *aenum, int64_t val)
return asn1_aint_set_uint64(uval, &aenum->data, &aenum->length);
}
LCRYPTO_ALIAS(ASN1_ENUMERATED_set_int64);
long
ASN1_ENUMERATED_get(const ASN1_ENUMERATED *aenum)
@ -156,12 +160,14 @@ ASN1_ENUMERATED_get(const ASN1_ENUMERATED *aenum)
return (long)val;
}
LCRYPTO_ALIAS(ASN1_ENUMERATED_get);
int
ASN1_ENUMERATED_set(ASN1_ENUMERATED *aenum, long val)
{
return ASN1_ENUMERATED_set_int64(aenum, val);
}
LCRYPTO_ALIAS(ASN1_ENUMERATED_set);
ASN1_ENUMERATED *
BN_to_ASN1_ENUMERATED(const BIGNUM *bn, ASN1_ENUMERATED *ai)
@ -205,6 +211,7 @@ BN_to_ASN1_ENUMERATED(const BIGNUM *bn, ASN1_ENUMERATED *ai)
ASN1_ENUMERATED_free(ret);
return (NULL);
}
LCRYPTO_ALIAS(BN_to_ASN1_ENUMERATED);
BIGNUM *
ASN1_ENUMERATED_to_BN(const ASN1_ENUMERATED *ai, BIGNUM *bn)
@ -217,6 +224,7 @@ ASN1_ENUMERATED_to_BN(const ASN1_ENUMERATED *ai, BIGNUM *bn)
BN_set_negative(ret, 1);
return (ret);
}
LCRYPTO_ALIAS(ASN1_ENUMERATED_to_BN);
/* Based on a_int.c: equivalent ENUMERATED functions */
@ -253,6 +261,7 @@ i2a_ASN1_ENUMERATED(BIO *bp, const ASN1_ENUMERATED *a)
err:
return (-1);
}
LCRYPTO_ALIAS(i2a_ASN1_ENUMERATED);
int
a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size)
@ -344,6 +353,7 @@ a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size)
free(s);
return (ret);
}
LCRYPTO_ALIAS(a2i_ASN1_ENUMERATED);
int
c2i_ASN1_ENUMERATED_cbs(ASN1_ENUMERATED **out_aenum, CBS *cbs)
@ -372,6 +382,7 @@ i2d_ASN1_ENUMERATED(ASN1_ENUMERATED *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_ENUMERATED_it);
}
LCRYPTO_ALIAS(i2d_ASN1_ENUMERATED);
ASN1_ENUMERATED *
d2i_ASN1_ENUMERATED(ASN1_ENUMERATED **a, const unsigned char **in, long len)
@ -379,3 +390,4 @@ d2i_ASN1_ENUMERATED(ASN1_ENUMERATED **a, const unsigned char **in, long len)
return (ASN1_ENUMERATED *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_ENUMERATED_it);
}
LCRYPTO_ALIAS(d2i_ASN1_ENUMERATED);

19
lib/libcrypto/asn1/a_int.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: a_int.c,v 1.46 2022/08/28 17:49:25 jsing Exp $ */
/* $OpenBSD: a_int.c,v 1.47 2023/07/05 21:23:36 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -79,6 +79,7 @@ ASN1_INTEGER_new(void)
{
return (ASN1_INTEGER *)ASN1_item_new(&ASN1_INTEGER_it);
}
LCRYPTO_ALIAS(ASN1_INTEGER_new);
static void
asn1_aint_clear(ASN1_INTEGER *aint)
@ -95,6 +96,7 @@ ASN1_INTEGER_free(ASN1_INTEGER *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASN1_INTEGER_it);
}
LCRYPTO_ALIAS(ASN1_INTEGER_free);
static int
ASN1_INTEGER_valid(const ASN1_INTEGER *a)
@ -110,6 +112,7 @@ ASN1_INTEGER_dup(const ASN1_INTEGER *x)
return ASN1_STRING_dup(x);
}
LCRYPTO_ALIAS(ASN1_INTEGER_dup);
int
ASN1_INTEGER_cmp(const ASN1_INTEGER *a, const ASN1_INTEGER *b)
@ -125,6 +128,7 @@ ASN1_INTEGER_cmp(const ASN1_INTEGER *a, const ASN1_INTEGER *b)
return ret;
}
LCRYPTO_ALIAS(ASN1_INTEGER_cmp);
int
asn1_aint_get_uint64(CBS *cbs, uint64_t *out_val)
@ -248,6 +252,7 @@ ASN1_INTEGER_get_uint64(uint64_t *out_val, const ASN1_INTEGER *aint)
return 1;
}
LCRYPTO_ALIAS(ASN1_INTEGER_get_uint64);
int
ASN1_INTEGER_set_uint64(ASN1_INTEGER *aint, uint64_t val)
@ -256,6 +261,7 @@ ASN1_INTEGER_set_uint64(ASN1_INTEGER *aint, uint64_t val)
return asn1_aint_set_uint64(val, &aint->data, &aint->length);
}
LCRYPTO_ALIAS(ASN1_INTEGER_set_uint64);
int
ASN1_INTEGER_get_int64(int64_t *out_val, const ASN1_INTEGER *aint)
@ -278,6 +284,7 @@ ASN1_INTEGER_get_int64(int64_t *out_val, const ASN1_INTEGER *aint)
return asn1_aint_get_int64(&cbs, (aint->type == V_ASN1_NEG_INTEGER),
out_val);
}
LCRYPTO_ALIAS(ASN1_INTEGER_get_int64);
int
ASN1_INTEGER_set_int64(ASN1_INTEGER *aint, int64_t val)
@ -295,6 +302,7 @@ ASN1_INTEGER_set_int64(ASN1_INTEGER *aint, int64_t val)
return asn1_aint_set_uint64(uval, &aint->data, &aint->length);
}
LCRYPTO_ALIAS(ASN1_INTEGER_set_int64);
long
ASN1_INTEGER_get(const ASN1_INTEGER *aint)
@ -312,12 +320,14 @@ ASN1_INTEGER_get(const ASN1_INTEGER *aint)
return (long)val;
}
LCRYPTO_ALIAS(ASN1_INTEGER_get);
int
ASN1_INTEGER_set(ASN1_INTEGER *aint, long val)
{
return ASN1_INTEGER_set_int64(aint, val);
}
LCRYPTO_ALIAS(ASN1_INTEGER_set);
ASN1_INTEGER *
BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai)
@ -365,6 +375,7 @@ BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai)
ASN1_INTEGER_free(ret);
return (NULL);
}
LCRYPTO_ALIAS(BN_to_ASN1_INTEGER);
BIGNUM *
ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn)
@ -380,6 +391,7 @@ ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn)
BN_set_negative(ret, 1);
return (ret);
}
LCRYPTO_ALIAS(ASN1_INTEGER_to_BN);
int
i2a_ASN1_INTEGER(BIO *bp, const ASN1_INTEGER *a)
@ -420,6 +432,7 @@ i2a_ASN1_INTEGER(BIO *bp, const ASN1_INTEGER *a)
err:
return (-1);
}
LCRYPTO_ALIAS(i2a_ASN1_INTEGER);
int
a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size)
@ -509,6 +522,7 @@ a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size)
free(s);
return (ret);
}
LCRYPTO_ALIAS(a2i_ASN1_INTEGER);
static void
asn1_aint_twos_complement(uint8_t *data, size_t data_len)
@ -757,6 +771,7 @@ i2d_ASN1_INTEGER(ASN1_INTEGER *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_INTEGER_it);
}
LCRYPTO_ALIAS(i2d_ASN1_INTEGER);
ASN1_INTEGER *
d2i_ASN1_INTEGER(ASN1_INTEGER **a, const unsigned char **in, long len)
@ -764,6 +779,7 @@ d2i_ASN1_INTEGER(ASN1_INTEGER **a, const unsigned char **in, long len)
return (ASN1_INTEGER *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_INTEGER_it);
}
LCRYPTO_ALIAS(d2i_ASN1_INTEGER);
/* This is a version of d2i_ASN1_INTEGER that ignores the sign bit of
* ASN1 integers: some broken software can encode a positive INTEGER
@ -838,3 +854,4 @@ d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp, long length)
ASN1_INTEGER_free(ret);
return (NULL);
}
LCRYPTO_ALIAS(d2i_ASN1_UINTEGER);

4
lib/libcrypto/asn1/a_mbstr.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: a_mbstr.c,v 1.26 2022/12/26 07:18:51 jmc Exp $ */
/* $OpenBSD: a_mbstr.c,v 1.27 2023/07/05 21:23:36 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
@ -90,6 +90,7 @@ ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len,
{
return ASN1_mbstring_ncopy(out, in, len, inform, mask, 0, 0);
}
LCRYPTO_ALIAS(ASN1_mbstring_copy);
int
ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
@ -255,6 +256,7 @@ ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
}
return -1;
}
LCRYPTO_ALIAS(ASN1_mbstring_ncopy);
/* This function traverses a string and passes the value of each character
* to an optional function along with a void * argument.

10
lib/libcrypto/asn1/a_object.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: a_object.c,v 1.50 2023/05/23 11:51:12 tb Exp $ */
/* $OpenBSD: a_object.c,v 1.51 2023/07/05 21:23:36 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -87,6 +87,7 @@ ASN1_OBJECT_new(void)
return a;
}
LCRYPTO_ALIAS(ASN1_OBJECT_new);
void
ASN1_OBJECT_free(ASN1_OBJECT *a)
@ -106,6 +107,7 @@ ASN1_OBJECT_free(ASN1_OBJECT *a)
if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC)
free(a);
}
LCRYPTO_ALIAS(ASN1_OBJECT_free);
ASN1_OBJECT *
ASN1_OBJECT_create(int nid, unsigned char *data, int len,
@ -122,6 +124,7 @@ ASN1_OBJECT_create(int nid, unsigned char *data, int len,
ASN1_OBJECT_FLAG_DYNAMIC_DATA;
return (OBJ_dup(&o));
}
LCRYPTO_ALIAS(ASN1_OBJECT_create);
static int
oid_add_arc(CBB *cbb, uint64_t arc)
@ -367,6 +370,7 @@ a2d_ASN1_OBJECT(unsigned char *out, int out_len, const char *in, int in_len)
return ret;
}
LCRYPTO_ALIAS(a2d_ASN1_OBJECT);
static int
i2t_ASN1_OBJECT_oid(const ASN1_OBJECT *aobj, CBB *cbb)
@ -456,6 +460,7 @@ i2t_ASN1_OBJECT(char *buf, int buf_len, const ASN1_OBJECT *aobj)
{
return i2t_ASN1_OBJECT_internal(aobj, buf, buf_len, 0);
}
LCRYPTO_ALIAS(i2t_ASN1_OBJECT);
ASN1_OBJECT *
t2i_ASN1_OBJECT_internal(const char *oid)
@ -523,6 +528,7 @@ i2a_ASN1_OBJECT(BIO *bp, const ASN1_OBJECT *aobj)
return ret;
}
LCRYPTO_ALIAS(i2a_ASN1_OBJECT);
int
c2i_ASN1_OBJECT_cbs(ASN1_OBJECT **out_aobj, CBS *content)
@ -627,6 +633,7 @@ i2d_ASN1_OBJECT(const ASN1_OBJECT *a, unsigned char **pp)
*pp = p;
return (objsize);
}
LCRYPTO_ALIAS(i2d_ASN1_OBJECT);
ASN1_OBJECT *
d2i_ASN1_OBJECT(ASN1_OBJECT **out_aobj, const unsigned char **pp, long length)
@ -666,3 +673,4 @@ d2i_ASN1_OBJECT(ASN1_OBJECT **out_aobj, const unsigned char **pp, long length)
return aobj;
}
LCRYPTO_ALIAS(d2i_ASN1_OBJECT);

9
lib/libcrypto/asn1/a_octet.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: a_octet.c,v 1.11 2021/12/25 08:52:44 jsing Exp $ */
/* $OpenBSD: a_octet.c,v 1.12 2023/07/05 21:23:36 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -72,12 +72,14 @@ ASN1_OCTET_STRING_new(void)
{
return (ASN1_OCTET_STRING *)ASN1_item_new(&ASN1_OCTET_STRING_it);
}
LCRYPTO_ALIAS(ASN1_OCTET_STRING_new);
void
ASN1_OCTET_STRING_free(ASN1_OCTET_STRING *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASN1_OCTET_STRING_it);
}
LCRYPTO_ALIAS(ASN1_OCTET_STRING_free);
ASN1_OCTET_STRING *
@ -85,24 +87,28 @@ ASN1_OCTET_STRING_dup(const ASN1_OCTET_STRING *x)
{
return ASN1_STRING_dup(x);
}
LCRYPTO_ALIAS(ASN1_OCTET_STRING_dup);
int
ASN1_OCTET_STRING_cmp(const ASN1_OCTET_STRING *a, const ASN1_OCTET_STRING *b)
{
return ASN1_STRING_cmp(a, b);
}
LCRYPTO_ALIAS(ASN1_OCTET_STRING_cmp);
int
ASN1_OCTET_STRING_set(ASN1_OCTET_STRING *x, const unsigned char *d, int len)
{
return ASN1_STRING_set(x, d, len);
}
LCRYPTO_ALIAS(ASN1_OCTET_STRING_set);
int
i2d_ASN1_OCTET_STRING(ASN1_OCTET_STRING *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_OCTET_STRING_it);
}
LCRYPTO_ALIAS(i2d_ASN1_OCTET_STRING);
ASN1_OCTET_STRING *
d2i_ASN1_OCTET_STRING(ASN1_OCTET_STRING **a, const unsigned char **in, long len)
@ -110,3 +116,4 @@ d2i_ASN1_OCTET_STRING(ASN1_OCTET_STRING **a, const unsigned char **in, long len)
return (ASN1_OCTET_STRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_OCTET_STRING_it);
}
LCRYPTO_ALIAS(d2i_ASN1_OCTET_STRING);

5
lib/libcrypto/asn1/a_pkey.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: a_pkey.c,v 1.4 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: a_pkey.c,v 1.5 2023/07/05 21:23:36 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -123,6 +123,7 @@ d2i_PrivateKey(int type, EVP_PKEY **a, const unsigned char **pp, long length)
EVP_PKEY_free(ret);
return (NULL);
}
LCRYPTO_ALIAS(d2i_PrivateKey);
int
i2d_PrivateKey(EVP_PKEY *a, unsigned char **pp)
@ -139,6 +140,7 @@ i2d_PrivateKey(EVP_PKEY *a, unsigned char **pp)
ASN1error(ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE);
return (-1);
}
LCRYPTO_ALIAS(i2d_PrivateKey);
/* This works like d2i_PrivateKey() except it automatically works out the type */
@ -184,3 +186,4 @@ d2i_AutoPrivateKey(EVP_PKEY **a, const unsigned char **pp, long length)
sk_ASN1_TYPE_pop_free(inkey, ASN1_TYPE_free);
return d2i_PrivateKey(keytype, a, pp, length);
}
LCRYPTO_ALIAS(d2i_AutoPrivateKey);

4
lib/libcrypto/asn1/a_print.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: a_print.c,v 1.12 2023/03/12 11:49:02 tb Exp $ */
/* $OpenBSD: a_print.c,v 1.13 2023/07/05 21:23:36 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -94,6 +94,7 @@ ASN1_PRINTABLE_type(const unsigned char *s, int len)
return (V_ASN1_IA5STRING);
return (V_ASN1_PRINTABLESTRING);
}
LCRYPTO_ALIAS(ASN1_PRINTABLE_type);
int
ASN1_UNIVERSALSTRING_to_string(ASN1_UNIVERSALSTRING *s)
@ -123,3 +124,4 @@ ASN1_UNIVERSALSTRING_to_string(ASN1_UNIVERSALSTRING *s)
s->type = ASN1_PRINTABLE_type(s->data, s->length);
return (1);
}
LCRYPTO_ALIAS(ASN1_UNIVERSALSTRING_to_string);

4
lib/libcrypto/asn1/a_pubkey.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: a_pubkey.c,v 1.4 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: a_pubkey.c,v 1.5 2023/07/05 21:23:36 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -136,6 +136,7 @@ d2i_PublicKey(int type, EVP_PKEY **a, const unsigned char **pp, long length)
EVP_PKEY_free(ret);
return (NULL);
}
LCRYPTO_ALIAS(d2i_PublicKey);
int
i2d_PublicKey(EVP_PKEY *a, unsigned char **pp)
@ -158,3 +159,4 @@ i2d_PublicKey(EVP_PKEY *a, unsigned char **pp)
return (-1);
}
}
LCRYPTO_ALIAS(i2d_PublicKey);

6
lib/libcrypto/asn1/a_strex.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: a_strex.c,v 1.32 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: a_strex.c,v 1.33 2023/07/05 21:23:36 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2000.
*/
@ -570,6 +570,7 @@ X509_NAME_print_ex(BIO *out, const X509_NAME *nm, int indent,
return X509_NAME_print(out, nm, indent);
return do_name_ex(send_bio_chars, out, nm, indent, flags);
}
LCRYPTO_ALIAS(X509_NAME_print_ex);
int
X509_NAME_print_ex_fp(FILE *fp, const X509_NAME *nm, int indent,
@ -587,15 +588,18 @@ X509_NAME_print_ex_fp(FILE *fp, const X509_NAME *nm, int indent,
}
return do_name_ex(send_fp_chars, fp, nm, indent, flags);
}
LCRYPTO_ALIAS(X509_NAME_print_ex_fp);
int
ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long flags)
{
return do_print_ex(send_bio_chars, out, flags, str);
}
LCRYPTO_ALIAS(ASN1_STRING_print_ex);
int
ASN1_STRING_print_ex_fp(FILE *fp, const ASN1_STRING *str, unsigned long flags)
{
return do_print_ex(send_fp_chars, fp, flags, str);
}
LCRYPTO_ALIAS(ASN1_STRING_print_ex_fp);

19
lib/libcrypto/asn1/a_string.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: a_string.c,v 1.13 2022/11/28 07:50:47 tb Exp $ */
/* $OpenBSD: a_string.c,v 1.14 2023/07/05 21:23:36 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -70,6 +70,7 @@ ASN1_STRING_new(void)
{
return ASN1_STRING_type_new(V_ASN1_OCTET_STRING);
}
LCRYPTO_ALIAS(ASN1_STRING_new);
ASN1_STRING *
ASN1_STRING_type_new(int type)
@ -84,6 +85,7 @@ ASN1_STRING_type_new(int type)
return astr;
}
LCRYPTO_ALIAS(ASN1_STRING_type_new);
static void
ASN1_STRING_clear(ASN1_STRING *astr)
@ -106,6 +108,7 @@ ASN1_STRING_free(ASN1_STRING *astr)
free(astr);
}
LCRYPTO_ALIAS(ASN1_STRING_free);
int
ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b)
@ -121,6 +124,7 @@ ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b)
return (a->type - b->type);
}
LCRYPTO_ALIAS(ASN1_STRING_cmp);
int
ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *src)
@ -136,6 +140,7 @@ ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *src)
return 1;
}
LCRYPTO_ALIAS(ASN1_STRING_copy);
ASN1_STRING *
ASN1_STRING_dup(const ASN1_STRING *src)
@ -153,6 +158,7 @@ ASN1_STRING_dup(const ASN1_STRING *src)
}
return astr;
}
LCRYPTO_ALIAS(ASN1_STRING_dup);
int
ASN1_STRING_set(ASN1_STRING *astr, const void *_data, int len)
@ -189,6 +195,7 @@ ASN1_STRING_set(ASN1_STRING *astr, const void *_data, int len)
return 1;
}
LCRYPTO_ALIAS(ASN1_STRING_set);
void
ASN1_STRING_set0(ASN1_STRING *astr, void *data, int len)
@ -198,12 +205,14 @@ ASN1_STRING_set0(ASN1_STRING *astr, void *data, int len)
astr->data = data;
astr->length = len;
}
LCRYPTO_ALIAS(ASN1_STRING_set0);
int
ASN1_STRING_length(const ASN1_STRING *astr)
{
return astr->length;
}
LCRYPTO_ALIAS(ASN1_STRING_length);
void
ASN1_STRING_length_set(ASN1_STRING *astr, int len)
@ -211,24 +220,28 @@ ASN1_STRING_length_set(ASN1_STRING *astr, int len)
/* This is dangerous and unfixable. */
astr->length = len;
}
LCRYPTO_ALIAS(ASN1_STRING_length_set);
int
ASN1_STRING_type(const ASN1_STRING *astr)
{
return astr->type;
}
LCRYPTO_ALIAS(ASN1_STRING_type);
unsigned char *
ASN1_STRING_data(ASN1_STRING *astr)
{
return astr->data;
}
LCRYPTO_ALIAS(ASN1_STRING_data);
const unsigned char *
ASN1_STRING_get0_data(const ASN1_STRING *astr)
{
return astr->data;
}
LCRYPTO_ALIAS(ASN1_STRING_get0_data);
int
ASN1_STRING_print(BIO *bp, const ASN1_STRING *astr)
@ -262,6 +275,7 @@ ASN1_STRING_print(BIO *bp, const ASN1_STRING *astr)
return 1;
}
LCRYPTO_ALIAS(ASN1_STRING_print);
/*
* Utility function: convert any string type to UTF8, returns number of bytes
@ -304,6 +318,7 @@ ASN1_STRING_to_UTF8(unsigned char **out, const ASN1_STRING *in)
return ret;
}
LCRYPTO_ALIAS(ASN1_STRING_to_UTF8);
int
i2a_ASN1_STRING(BIO *bp, const ASN1_STRING *astr, int type)
@ -338,6 +353,7 @@ i2a_ASN1_STRING(BIO *bp, const ASN1_STRING *astr, int type)
err:
return -1;
}
LCRYPTO_ALIAS(i2a_ASN1_STRING);
int
a2i_ASN1_STRING(BIO *bp, ASN1_STRING *astr, char *buf, int size)
@ -429,3 +445,4 @@ a2i_ASN1_STRING(BIO *bp, ASN1_STRING *astr, char *buf, int size)
return ret;
}
LCRYPTO_ALIAS(a2i_ASN1_STRING);

163
lib/libcrypto/asn1/a_strnid.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: a_strnid.c,v 1.25 2021/12/13 17:55:53 schwarze Exp $ */
/* $OpenBSD: a_strnid.c,v 1.27 2023/07/05 21:23:36 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
@ -86,12 +86,14 @@ ASN1_STRING_set_default_mask(unsigned long mask)
{
global_mask = mask;
}
LCRYPTO_ALIAS(ASN1_STRING_set_default_mask);
unsigned long
ASN1_STRING_get_default_mask(void)
{
return global_mask;
}
LCRYPTO_ALIAS(ASN1_STRING_get_default_mask);
/*
* This function sets the default to various "flavours" of configuration
@ -134,6 +136,7 @@ ASN1_STRING_set_default_mask_asc(const char *p)
ASN1_STRING_set_default_mask(mask);
return 1;
}
LCRYPTO_ALIAS(ASN1_STRING_set_default_mask_asc);
/*
* The following function generates an ASN1_STRING based on limits in a table.
@ -166,6 +169,7 @@ ASN1_STRING_set_by_NID(ASN1_STRING **out, const unsigned char *in, int inlen,
return NULL;
return *out;
}
LCRYPTO_ALIAS(ASN1_STRING_set_by_NID);
/*
* Now the tables and helper functions for the string table:
@ -187,25 +191,139 @@ ASN1_STRING_set_by_NID(ASN1_STRING **out, const unsigned char *in, int inlen,
/* This table must be kept in NID order */
static const ASN1_STRING_TABLE tbl_standard[] = {
{NID_commonName, 1, ub_common_name, DIRSTRING_TYPE, 0},
{NID_countryName, 2, 2, B_ASN1_PRINTABLESTRING, STABLE_NO_MASK},
{NID_localityName, 1, ub_locality_name, DIRSTRING_TYPE, 0},
{NID_stateOrProvinceName, 1, ub_state_name, DIRSTRING_TYPE, 0},
{NID_organizationName, 1, ub_organization_name, DIRSTRING_TYPE, 0},
{NID_organizationalUnitName, 1, ub_organization_unit_name, DIRSTRING_TYPE, 0},
{NID_pkcs9_emailAddress, 1, ub_email_address, B_ASN1_IA5STRING, STABLE_NO_MASK},
{NID_pkcs9_unstructuredName, 1, -1, PKCS9STRING_TYPE, 0},
{NID_pkcs9_challengePassword, 1, -1, PKCS9STRING_TYPE, 0},
{NID_pkcs9_unstructuredAddress, 1, -1, DIRSTRING_TYPE, 0},
{NID_givenName, 1, ub_name, DIRSTRING_TYPE, 0},
{NID_surname, 1, ub_name, DIRSTRING_TYPE, 0},
{NID_initials, 1, ub_name, DIRSTRING_TYPE, 0},
{NID_serialNumber, 1, ub_serial_number, B_ASN1_PRINTABLESTRING, STABLE_NO_MASK},
{NID_friendlyName, -1, -1, B_ASN1_BMPSTRING, STABLE_NO_MASK},
{NID_name, 1, ub_name, DIRSTRING_TYPE, 0},
{NID_dnQualifier, -1, -1, B_ASN1_PRINTABLESTRING, STABLE_NO_MASK},
{NID_domainComponent, 1, -1, B_ASN1_IA5STRING, STABLE_NO_MASK},
{NID_ms_csp_name, -1, -1, B_ASN1_BMPSTRING, STABLE_NO_MASK}
{
.nid = NID_commonName,
.minsize = 1,
.maxsize = ub_common_name,
.mask = DIRSTRING_TYPE,
.flags = 0,
},
{
.nid = NID_countryName,
.minsize = 2,
.maxsize = 2,
.mask = B_ASN1_PRINTABLESTRING,
.flags = STABLE_NO_MASK,
},
{
.nid = NID_localityName,
.minsize = 1,
.maxsize = ub_locality_name,
.mask = DIRSTRING_TYPE,
.flags = 0,
},
{
.nid = NID_stateOrProvinceName,
.minsize = 1,
.maxsize = ub_state_name,
.mask = DIRSTRING_TYPE,
.flags = 0,
},
{
.nid = NID_organizationName,
.minsize = 1,
.maxsize = ub_organization_name,
.mask = DIRSTRING_TYPE,
.flags = 0,
},
{
.nid = NID_organizationalUnitName,
.minsize = 1,
.maxsize = ub_organization_unit_name,
.mask = DIRSTRING_TYPE,
.flags = 0,
},
{
.nid = NID_pkcs9_emailAddress,
.minsize = 1,
.maxsize = ub_email_address,
.mask = B_ASN1_IA5STRING,
.flags = STABLE_NO_MASK,
},
{
.nid = NID_pkcs9_unstructuredName,
.minsize = 1,
.maxsize = -1,
.mask = PKCS9STRING_TYPE,
.flags = 0,
},
{
.nid = NID_pkcs9_challengePassword,
.minsize = 1,
.maxsize = -1,
.mask = PKCS9STRING_TYPE,
.flags = 0,
},
{
.nid = NID_pkcs9_unstructuredAddress,
.minsize = 1,
.maxsize = -1,
.mask = DIRSTRING_TYPE,
.flags = 0,
},
{
.nid = NID_givenName,
.minsize = 1,
.maxsize = ub_name,
.mask = DIRSTRING_TYPE,
.flags = 0,
},
{
.nid = NID_surname,
.minsize = 1,
.maxsize = ub_name,
.mask = DIRSTRING_TYPE,
.flags = 0,
},
{
.nid = NID_initials,
.minsize = 1,
.maxsize = ub_name,
.mask = DIRSTRING_TYPE,
.flags = 0,
},
{
.nid = NID_serialNumber,
.minsize = 1,
.maxsize = ub_serial_number,
.mask = B_ASN1_PRINTABLESTRING,
.flags = STABLE_NO_MASK,
},
{
.nid = NID_friendlyName,
.minsize = -1,
.maxsize = -1,
.mask = B_ASN1_BMPSTRING,
.flags = STABLE_NO_MASK,
},
{
.nid = NID_name,
.minsize = 1,
.maxsize = ub_name,
.mask = DIRSTRING_TYPE,
.flags = 0,
},
{
.nid = NID_dnQualifier,
.minsize = -1,
.maxsize = -1,
.mask = B_ASN1_PRINTABLESTRING,
.flags = STABLE_NO_MASK,
},
{
.nid = NID_domainComponent,
.minsize = 1,
.maxsize = -1,
.mask = B_ASN1_IA5STRING,
.flags = STABLE_NO_MASK,
},
{
.nid = NID_ms_csp_name,
.minsize = -1,
.maxsize = -1,
.mask = B_ASN1_BMPSTRING,
.flags = STABLE_NO_MASK,
},
};
static int
@ -254,8 +372,9 @@ ASN1_STRING_TABLE_get(int nid)
return sk_ASN1_STRING_TABLE_value(stable, idx);
}
return OBJ_bsearch_table(&fnd, tbl_standard,
sizeof(tbl_standard)/sizeof(ASN1_STRING_TABLE));
sizeof(tbl_standard) / sizeof(tbl_standard[0]));
}
LCRYPTO_ALIAS(ASN1_STRING_TABLE_get);
/*
* Return a string table pointer which can be modified: either directly
@ -321,6 +440,7 @@ ASN1_STRING_TABLE_add(int nid, long minsize, long maxsize, unsigned long mask,
return 1;
}
LCRYPTO_ALIAS(ASN1_STRING_TABLE_add);
void
ASN1_STRING_TABLE_cleanup(void)
@ -333,6 +453,7 @@ ASN1_STRING_TABLE_cleanup(void)
stable = NULL;
sk_ASN1_STRING_TABLE_pop_free(tmp, st_free);
}
LCRYPTO_ALIAS(ASN1_STRING_TABLE_cleanup);
static void
st_free(ASN1_STRING_TABLE *tbl)

8
lib/libcrypto/asn1/a_time.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: a_time.c,v 1.36 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: a_time.c,v 1.37 2023/07/05 21:23:36 beck Exp $ */
/* ====================================================================
* Copyright (c) 1999 The OpenSSL Project. All rights reserved.
*
@ -84,12 +84,14 @@ ASN1_TIME_new(void)
{
return (ASN1_TIME *)ASN1_item_new(&ASN1_TIME_it);
}
LCRYPTO_ALIAS(ASN1_TIME_new);
void
ASN1_TIME_free(ASN1_TIME *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASN1_TIME_it);
}
LCRYPTO_ALIAS(ASN1_TIME_free);
int
ASN1_TIME_to_tm(const ASN1_TIME *s, struct tm *tm)
@ -104,6 +106,7 @@ ASN1_TIME_to_tm(const ASN1_TIME *s, struct tm *tm)
return asn1_time_time_t_to_tm(&now, tm);
}
LCRYPTO_ALIAS(ASN1_TIME_to_tm);
int
ASN1_TIME_diff(int *pday, int *psec, const ASN1_TIME *from, const ASN1_TIME *to)
@ -117,6 +120,7 @@ ASN1_TIME_diff(int *pday, int *psec, const ASN1_TIME *from, const ASN1_TIME *to)
return OPENSSL_gmtime_diff(pday, psec, &tm_from, &tm_to);
}
LCRYPTO_ALIAS(ASN1_TIME_diff);
ASN1_TIME *
d2i_ASN1_TIME(ASN1_TIME **a, const unsigned char **in, long len)
@ -124,9 +128,11 @@ d2i_ASN1_TIME(ASN1_TIME **a, const unsigned char **in, long len)
return (ASN1_TIME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_TIME_it);
}
LCRYPTO_ALIAS(d2i_ASN1_TIME);
int
i2d_ASN1_TIME(ASN1_TIME *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_TIME_it);
}
LCRYPTO_ALIAS(i2d_ASN1_TIME);

24
lib/libcrypto/asn1/a_time_tm.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: a_time_tm.c,v 1.27 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: a_time_tm.c,v 1.28 2023/07/05 21:23:36 beck Exp $ */
/*
* Copyright (c) 2015 Bob Beck <beck@openbsd.org>
*
@ -60,6 +60,7 @@ ASN1_time_tm_cmp(struct tm *tm1, struct tm *tm2)
return (1);
return 0;
}
LCRYPTO_ALIAS(ASN1_time_tm_cmp);
int
ASN1_time_tm_clamp_notafter(struct tm *tm)
@ -76,6 +77,7 @@ ASN1_time_tm_clamp_notafter(struct tm *tm)
#endif
return 1;
}
LCRYPTO_ALIAS(ASN1_time_tm_clamp_notafter);
/* Convert time to GeneralizedTime, X.690, 11.7. */
ASN1_TIME *
@ -344,6 +346,7 @@ ASN1_time_parse(const char *bytes, size_t len, struct tm *tm, int mode)
return -1;
}
LCRYPTO_ALIAS(ASN1_time_parse);
/*
* ASN1_TIME generic functions.
@ -404,6 +407,7 @@ ASN1_TIME_set(ASN1_TIME *s, time_t t)
{
return (ASN1_TIME_adj(s, t, 0, 0));
}
LCRYPTO_ALIAS(ASN1_TIME_set);
ASN1_TIME *
ASN1_TIME_set_tm(ASN1_TIME *s, struct tm *tm)
@ -414,12 +418,14 @@ ASN1_TIME_set_tm(ASN1_TIME *s, struct tm *tm)
return NULL;
return (ASN1_TIME_adj(s, t, 0, 0));
}
LCRYPTO_ALIAS(ASN1_TIME_set_tm);
ASN1_TIME *
ASN1_TIME_adj(ASN1_TIME *s, time_t t, int offset_day, long offset_sec)
{
return (ASN1_TIME_adj_internal(s, t, offset_day, offset_sec, RFC5280));
}
LCRYPTO_ALIAS(ASN1_TIME_adj);
int
ASN1_TIME_check(const ASN1_TIME *t)
@ -428,6 +434,7 @@ ASN1_TIME_check(const ASN1_TIME *t)
return (0);
return (t->type == ASN1_time_parse(t->data, t->length, NULL, t->type));
}
LCRYPTO_ALIAS(ASN1_TIME_check);
ASN1_GENERALIZEDTIME *
ASN1_TIME_to_generalizedtime(const ASN1_TIME *t, ASN1_GENERALIZEDTIME **out)
@ -450,12 +457,14 @@ ASN1_TIME_to_generalizedtime(const ASN1_TIME *t, ASN1_GENERALIZEDTIME **out)
return (agt);
}
LCRYPTO_ALIAS(ASN1_TIME_to_generalizedtime);
int
ASN1_TIME_set_string(ASN1_TIME *s, const char *str)
{
return (ASN1_TIME_set_string_internal(s, str, 0));
}
LCRYPTO_ALIAS(ASN1_TIME_set_string);
static int
ASN1_TIME_cmp_time_t_internal(const ASN1_TIME *s, time_t t2, int mode)
@ -500,6 +509,7 @@ ASN1_TIME_compare(const ASN1_TIME *t1, const ASN1_TIME *t2)
return ASN1_time_tm_cmp(&tm1, &tm2);
}
LCRYPTO_ALIAS(ASN1_TIME_compare);
int
ASN1_TIME_cmp_time_t(const ASN1_TIME *s, time_t t)
@ -511,6 +521,7 @@ ASN1_TIME_cmp_time_t(const ASN1_TIME *s, time_t t)
V_ASN1_GENERALIZEDTIME);
return -2;
}
LCRYPTO_ALIAS(ASN1_TIME_cmp_time_t);
/*
* ASN1_UTCTIME wrappers
@ -523,6 +534,7 @@ ASN1_UTCTIME_check(const ASN1_UTCTIME *d)
return (0);
return (d->type == ASN1_time_parse(d->data, d->length, NULL, d->type));
}
LCRYPTO_ALIAS(ASN1_UTCTIME_check);
int
ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str)
@ -531,12 +543,14 @@ ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str)
return (0);
return (ASN1_TIME_set_string_internal(s, str, V_ASN1_UTCTIME));
}
LCRYPTO_ALIAS(ASN1_UTCTIME_set_string);
ASN1_UTCTIME *
ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t)
{
return (ASN1_UTCTIME_adj(s, t, 0, 0));
}
LCRYPTO_ALIAS(ASN1_UTCTIME_set);
ASN1_UTCTIME *
ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t, int offset_day, long offset_sec)
@ -544,6 +558,7 @@ ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t, int offset_day, long offset_sec)
return (ASN1_TIME_adj_internal(s, t, offset_day, offset_sec,
V_ASN1_UTCTIME));
}
LCRYPTO_ALIAS(ASN1_UTCTIME_adj);
int
ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t)
@ -552,6 +567,7 @@ ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t)
return ASN1_TIME_cmp_time_t_internal(s, t, V_ASN1_UTCTIME);
return -2;
}
LCRYPTO_ALIAS(ASN1_UTCTIME_cmp_time_t);
/*
* ASN1_GENERALIZEDTIME wrappers
@ -564,6 +580,7 @@ ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *d)
return (0);
return (d->type == ASN1_time_parse(d->data, d->length, NULL, d->type));
}
LCRYPTO_ALIAS(ASN1_GENERALIZEDTIME_check);
int
ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str)
@ -572,12 +589,14 @@ ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str)
return (0);
return (ASN1_TIME_set_string_internal(s, str, V_ASN1_GENERALIZEDTIME));
}
LCRYPTO_ALIAS(ASN1_GENERALIZEDTIME_set_string);
ASN1_GENERALIZEDTIME *
ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s, time_t t)
{
return (ASN1_GENERALIZEDTIME_adj(s, t, 0, 0));
}
LCRYPTO_ALIAS(ASN1_GENERALIZEDTIME_set);
ASN1_GENERALIZEDTIME *
ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s, time_t t, int offset_day,
@ -586,6 +605,7 @@ ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s, time_t t, int offset_day,
return (ASN1_TIME_adj_internal(s, t, offset_day, offset_sec,
V_ASN1_GENERALIZEDTIME));
}
LCRYPTO_ALIAS(ASN1_GENERALIZEDTIME_adj);
int
ASN1_TIME_normalize(ASN1_TIME *t)
@ -596,9 +616,11 @@ ASN1_TIME_normalize(ASN1_TIME *t)
return 0;
return tm_to_rfc5280_time(&tm, t) != NULL;
}
LCRYPTO_ALIAS(ASN1_TIME_normalize);
int
ASN1_TIME_set_string_X509(ASN1_TIME *s, const char *str)
{
return ASN1_TIME_set_string_internal(s, str, RFC5280);
}
LCRYPTO_ALIAS(ASN1_TIME_set_string_X509);

14
lib/libcrypto/asn1/a_type.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: a_type.c,v 1.25 2023/03/11 14:05:02 jsing Exp $ */
/* $OpenBSD: a_type.c,v 1.26 2023/07/05 21:23:36 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -94,12 +94,14 @@ ASN1_TYPE_new(void)
{
return (ASN1_TYPE *)ASN1_item_new(&ASN1_ANY_it);
}
LCRYPTO_ALIAS(ASN1_TYPE_new);
void
ASN1_TYPE_free(ASN1_TYPE *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASN1_ANY_it);
}
LCRYPTO_ALIAS(ASN1_TYPE_free);
int
ASN1_TYPE_get(const ASN1_TYPE *a)
@ -113,6 +115,7 @@ ASN1_TYPE_get(const ASN1_TYPE *a)
return 0;
}
LCRYPTO_ALIAS(ASN1_TYPE_get);
void
ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value)
@ -127,6 +130,7 @@ ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value)
else
a->value.ptr = value;
}
LCRYPTO_ALIAS(ASN1_TYPE_set);
int
ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value)
@ -149,6 +153,7 @@ ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value)
}
return 1;
}
LCRYPTO_ALIAS(ASN1_TYPE_set1);
/* Returns 0 if they are equal, != 0 otherwise. */
int
@ -198,6 +203,7 @@ ASN1_TYPE_cmp(const ASN1_TYPE *a, const ASN1_TYPE *b)
return result;
}
LCRYPTO_ALIAS(ASN1_TYPE_cmp);
int
ASN1_TYPE_set_octetstring(ASN1_TYPE *a, const unsigned char *data, int len)
@ -213,6 +219,7 @@ ASN1_TYPE_set_octetstring(ASN1_TYPE *a, const unsigned char *data, int len)
ASN1_TYPE_set(a, V_ASN1_OCTET_STRING, os);
return (1);
}
LCRYPTO_ALIAS(ASN1_TYPE_set_octetstring);
int
ASN1_TYPE_get_octetstring(const ASN1_TYPE *a, unsigned char *data, int max_len)
@ -234,6 +241,7 @@ ASN1_TYPE_get_octetstring(const ASN1_TYPE *a, unsigned char *data, int max_len)
memcpy(data, p, num);
return (ret);
}
LCRYPTO_ALIAS(ASN1_TYPE_get_octetstring);
int
ASN1_TYPE_set_int_octetstring(ASN1_TYPE *at, long num, const unsigned char *data,
@ -265,6 +273,7 @@ ASN1_TYPE_set_int_octetstring(ASN1_TYPE *at, long num, const unsigned char *data
return ret;
}
LCRYPTO_ALIAS(ASN1_TYPE_set_int_octetstring);
int
ASN1_TYPE_get_int_octetstring(const ASN1_TYPE *at, long *num, unsigned char *data,
@ -300,6 +309,7 @@ ASN1_TYPE_get_int_octetstring(const ASN1_TYPE *at, long *num, unsigned char *dat
return ret;
}
LCRYPTO_ALIAS(ASN1_TYPE_get_int_octetstring);
ASN1_TYPE *
ASN1_TYPE_pack_sequence(const ASN1_ITEM *it, void *s, ASN1_TYPE **t)
@ -337,6 +347,7 @@ i2d_ASN1_TYPE(ASN1_TYPE *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_ANY_it);
}
LCRYPTO_ALIAS(i2d_ASN1_TYPE);
ASN1_TYPE *
d2i_ASN1_TYPE(ASN1_TYPE **a, const unsigned char **in, long len)
@ -344,3 +355,4 @@ d2i_ASN1_TYPE(ASN1_TYPE **a, const unsigned char **in, long len)
return (ASN1_TYPE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_ANY_it);
}
LCRYPTO_ALIAS(d2i_ASN1_TYPE);

22
lib/libcrypto/asn1/ameth_lib.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: ameth_lib.c,v 1.30 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: ameth_lib.c,v 1.31 2023/07/05 21:23:36 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2006.
*/
@ -120,6 +120,7 @@ EVP_PKEY_asn1_get_count(void)
return num;
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_get_count);
const EVP_PKEY_ASN1_METHOD *
EVP_PKEY_asn1_get0(int idx)
@ -135,6 +136,7 @@ EVP_PKEY_asn1_get0(int idx)
return sk_EVP_PKEY_ASN1_METHOD_value(asn1_app_methods, idx);
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_get0);
static const EVP_PKEY_ASN1_METHOD *
pkey_asn1_find(int pkey_id)
@ -183,6 +185,7 @@ EVP_PKEY_asn1_find(ENGINE **pe, int type)
}
return mp;
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_find);
const EVP_PKEY_ASN1_METHOD *
EVP_PKEY_asn1_find_str(ENGINE **pe, const char *str, int len)
@ -219,6 +222,7 @@ EVP_PKEY_asn1_find_str(ENGINE **pe, const char *str, int len)
}
return NULL;
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_find_str);
int
EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth)
@ -234,6 +238,7 @@ EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth)
return 1;
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_add0);
int
EVP_PKEY_asn1_add_alias(int to, int from)
@ -251,6 +256,7 @@ EVP_PKEY_asn1_add_alias(int to, int from)
}
return 1;
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_add_alias);
int
EVP_PKEY_asn1_get0_info(int *ppkey_id, int *ppkey_base_id, int *ppkey_flags,
@ -271,12 +277,14 @@ EVP_PKEY_asn1_get0_info(int *ppkey_id, int *ppkey_base_id, int *ppkey_flags,
*ppem_str = ameth->pem_str;
return 1;
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_get0_info);
const EVP_PKEY_ASN1_METHOD*
EVP_PKEY_get0_asn1(const EVP_PKEY *pkey)
{
return pkey->ameth;
}
LCRYPTO_ALIAS(EVP_PKEY_get0_asn1);
EVP_PKEY_ASN1_METHOD*
EVP_PKEY_asn1_new(int id, int flags, const char *pem_str, const char *info)
@ -306,6 +314,7 @@ EVP_PKEY_asn1_new(int id, int flags, const char *pem_str, const char *info)
EVP_PKEY_asn1_free(ameth);
return NULL;
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_new);
void
EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst, const EVP_PKEY_ASN1_METHOD *src)
@ -326,6 +335,7 @@ EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst, const EVP_PKEY_ASN1_METHOD *src)
dst->pem_str = preserve.pem_str;
dst->info = preserve.info;
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_copy);
void
EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth)
@ -336,6 +346,7 @@ EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth)
free(ameth);
}
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_free);
void
EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth,
@ -354,6 +365,7 @@ EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth,
ameth->pkey_size = pkey_size;
ameth->pkey_bits = pkey_bits;
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_set_public);
void
EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth,
@ -366,6 +378,7 @@ EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth,
ameth->priv_encode = priv_encode;
ameth->priv_print = priv_print;
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_set_private);
void
EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth,
@ -384,6 +397,7 @@ EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth,
ameth->param_cmp = param_cmp;
ameth->param_print = param_print;
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_set_param);
void
EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth,
@ -391,6 +405,7 @@ EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth,
{
ameth->pkey_free = pkey_free;
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_set_free);
void
EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth,
@ -398,6 +413,7 @@ EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth,
{
ameth->pkey_ctrl = pkey_ctrl;
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_set_ctrl);
void
EVP_PKEY_asn1_set_security_bits(EVP_PKEY_ASN1_METHOD *ameth,
@ -405,6 +421,7 @@ EVP_PKEY_asn1_set_security_bits(EVP_PKEY_ASN1_METHOD *ameth,
{
ameth->pkey_security_bits = pkey_security_bits;
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_set_security_bits);
void
EVP_PKEY_asn1_set_check(EVP_PKEY_ASN1_METHOD *ameth,
@ -412,6 +429,7 @@ EVP_PKEY_asn1_set_check(EVP_PKEY_ASN1_METHOD *ameth,
{
ameth->pkey_check = pkey_check;
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_set_check);
void
EVP_PKEY_asn1_set_public_check(EVP_PKEY_ASN1_METHOD *ameth,
@ -419,6 +437,7 @@ EVP_PKEY_asn1_set_public_check(EVP_PKEY_ASN1_METHOD *ameth,
{
ameth->pkey_public_check = pkey_public_check;
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_set_public_check);
void
EVP_PKEY_asn1_set_param_check(EVP_PKEY_ASN1_METHOD *ameth,
@ -426,3 +445,4 @@ EVP_PKEY_asn1_set_param_check(EVP_PKEY_ASN1_METHOD *ameth,
{
ameth->pkey_param_check = pkey_param_check;
}
LCRYPTO_ALIAS(EVP_PKEY_asn1_set_param_check);

3
lib/libcrypto/asn1/asn1_err.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: asn1_err.c,v 1.25 2022/08/29 06:48:58 jsing Exp $ */
/* $OpenBSD: asn1_err.c,v 1.26 2023/07/05 21:23:36 beck Exp $ */
/* ====================================================================
* Copyright (c) 1999-2011 The OpenSSL Project. All rights reserved.
*
@ -211,3 +211,4 @@ ERR_load_ASN1_strings(void)
}
#endif
}
LCRYPTO_ALIAS(ERR_load_ASN1_strings);

4
lib/libcrypto/asn1/asn1_gen.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: asn1_gen.c,v 1.20 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: asn1_gen.c,v 1.21 2023/07/05 21:23:36 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2002.
*/
@ -133,6 +133,7 @@ ASN1_generate_nconf(const char *str, CONF *nconf)
X509V3_set_nconf(&cnf, nconf);
return ASN1_generate_v3(str, &cnf);
}
LCRYPTO_ALIAS(ASN1_generate_nconf);
ASN1_TYPE *
ASN1_generate_v3(const char *str, X509V3_CTX *cnf)
@ -266,6 +267,7 @@ ASN1_generate_v3(const char *str, X509V3_CTX *cnf)
return ret;
}
LCRYPTO_ALIAS(ASN1_generate_v3);
static int
asn1_cb(const char *elem, int len, void *bitstr)

13
lib/libcrypto/asn1/asn1_item.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: asn1_item.c,v 1.14 2023/06/15 13:58:56 tb Exp $ */
/* $OpenBSD: asn1_item.c,v 1.15 2023/07/05 21:23:36 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -138,6 +138,7 @@ ASN1_item_digest(const ASN1_ITEM *it, const EVP_MD *type, void *asn,
free(str);
return (1);
}
LCRYPTO_ALIAS(ASN1_item_digest);
/*
* ASN1_ITEM version of ASN1_dup(): follows the same model except there's no
@ -166,6 +167,7 @@ ASN1_item_dup(const ASN1_ITEM *it, void *x)
free(b);
return (ret);
}
LCRYPTO_ALIAS(ASN1_item_dup);
/* Pack an ASN1 object into an ASN1_STRING. */
ASN1_STRING *
@ -200,6 +202,7 @@ ASN1_item_pack(void *obj, const ASN1_ITEM *it, ASN1_STRING **oct)
ASN1_STRING_free(octmp);
return NULL;
}
LCRYPTO_ALIAS(ASN1_item_pack);
/* Extract an ASN1 object from an ASN1_STRING. */
void *
@ -213,6 +216,7 @@ ASN1_item_unpack(const ASN1_STRING *oct, const ASN1_ITEM *it)
ASN1error(ASN1_R_DECODE_ERROR);
return ret;
}
LCRYPTO_ALIAS(ASN1_item_unpack);
int
ASN1_item_sign(const ASN1_ITEM *it, X509_ALGOR *algor1, X509_ALGOR *algor2,
@ -226,6 +230,7 @@ ASN1_item_sign(const ASN1_ITEM *it, X509_ALGOR *algor1, X509_ALGOR *algor2,
}
return ASN1_item_sign_ctx(it, algor1, algor2, signature, asn, &ctx);
}
LCRYPTO_ALIAS(ASN1_item_sign);
int
ASN1_item_sign_ctx(const ASN1_ITEM *it, X509_ALGOR *algor1, X509_ALGOR *algor2,
@ -335,6 +340,7 @@ ASN1_item_sign_ctx(const ASN1_ITEM *it, X509_ALGOR *algor1, X509_ALGOR *algor2,
return ret;
}
LCRYPTO_ALIAS(ASN1_item_sign_ctx);
int
ASN1_item_verify(const ASN1_ITEM *it, X509_ALGOR *a,
@ -420,6 +426,7 @@ ASN1_item_verify(const ASN1_ITEM *it, X509_ALGOR *a,
return ret;
}
LCRYPTO_ALIAS(ASN1_item_verify);
#define HEADER_SIZE 8
#define ASN1_CHUNK_INITIAL_SIZE (16 * 1024)
@ -586,6 +593,7 @@ ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x)
BUF_MEM_free(b);
return (ret);
}
LCRYPTO_ALIAS(ASN1_item_d2i_bio);
void *
ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x)
@ -602,6 +610,7 @@ ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x)
BIO_free(b);
return (ret);
}
LCRYPTO_ALIAS(ASN1_item_d2i_fp);
int
ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x)
@ -629,6 +638,7 @@ ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x)
free(b);
return (ret);
}
LCRYPTO_ALIAS(ASN1_item_i2d_bio);
int
ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, void *x)
@ -645,3 +655,4 @@ ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, void *x)
BIO_free(b);
return (ret);
}
LCRYPTO_ALIAS(ASN1_item_i2d_fp);

7
lib/libcrypto/asn1/asn1_old.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: asn1_old.c,v 1.3 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: asn1_old.c,v 1.4 2023/07/05 21:23:36 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -91,6 +91,7 @@ ASN1_dup(i2d_of_void *i2d, d2i_of_void *d2i, void *x)
free(b);
return (ret);
}
LCRYPTO_ALIAS(ASN1_dup);
void *
ASN1_d2i_fp(void *(*xnew)(void), d2i_of_void *d2i, FILE *in, void **x)
@ -107,6 +108,7 @@ ASN1_d2i_fp(void *(*xnew)(void), d2i_of_void *d2i, FILE *in, void **x)
BIO_free(b);
return (ret);
}
LCRYPTO_ALIAS(ASN1_d2i_fp);
void *
ASN1_d2i_bio(void *(*xnew)(void), d2i_of_void *d2i, BIO *in, void **x)
@ -128,6 +130,7 @@ ASN1_d2i_bio(void *(*xnew)(void), d2i_of_void *d2i, BIO *in, void **x)
BUF_MEM_free(b);
return (ret);
}
LCRYPTO_ALIAS(ASN1_d2i_bio);
int
ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, void *x)
@ -144,6 +147,7 @@ ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, void *x)
BIO_free(b);
return (ret);
}
LCRYPTO_ALIAS(ASN1_i2d_fp);
int
ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, unsigned char *x)
@ -176,5 +180,6 @@ ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, unsigned char *x)
free(b);
return (ret);
}
LCRYPTO_ALIAS(ASN1_i2d_bio);
#endif

6
lib/libcrypto/asn1/asn1_old_lib.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: asn1_old_lib.c,v 1.5 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: asn1_old_lib.c,v 1.6 2023/07/05 21:23:36 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -118,6 +118,7 @@ ASN1_get_object(const unsigned char **pp, long *plength, int *ptag,
return ret;
}
LCRYPTO_ALIAS(ASN1_get_object);
/* class 0 is constructed
* constructed == 2 for indefinite length constructed */
@ -151,6 +152,7 @@ ASN1_put_object(unsigned char **pp, int constructed, int length, int tag,
asn1_put_length(&p, length);
*pp = p;
}
LCRYPTO_ALIAS(ASN1_put_object);
int
ASN1_put_eoc(unsigned char **pp)
@ -162,6 +164,7 @@ ASN1_put_eoc(unsigned char **pp)
*pp = p;
return 2;
}
LCRYPTO_ALIAS(ASN1_put_eoc);
static void
asn1_put_length(unsigned char **pp, int length)
@ -210,3 +213,4 @@ ASN1_object_size(int constructed, int length, int tag)
}
return (ret);
}
LCRYPTO_ALIAS(ASN1_object_size);

4
lib/libcrypto/asn1/asn1_par.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: asn1_par.c,v 1.34 2022/02/12 03:07:24 jsing Exp $ */
/* $OpenBSD: asn1_par.c,v 1.35 2023/07/05 21:23:36 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -107,12 +107,14 @@ ASN1_parse(BIO *bp, const unsigned char *pp, long len, int indent)
{
return (asn1_parse2(bp, &pp, len, 0, 0, indent, 0));
}
LCRYPTO_ALIAS(ASN1_parse);
int
ASN1_parse_dump(BIO *bp, const unsigned char *pp, long len, int indent, int dump)
{
return (asn1_parse2(bp, &pp, len, 0, 0, indent, dump));
}
LCRYPTO_ALIAS(ASN1_parse_dump);
static int
asn1_parse2(BIO *bp, const unsigned char **pp, long length, int offset,

4
lib/libcrypto/asn1/asn1_types.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: asn1_types.c,v 1.2 2022/09/03 18:52:18 jsing Exp $ */
/* $OpenBSD: asn1_types.c,v 1.3 2023/07/05 21:23:36 beck Exp $ */
/*
* Copyright (c) 2021 Joel Sing <jsing@openbsd.org>
*
@ -287,6 +287,7 @@ ASN1_tag2bit(int tag)
return 0;
}
LCRYPTO_ALIAS(ASN1_tag2bit);
const char *
ASN1_tag2str(int tag)
@ -301,3 +302,4 @@ ASN1_tag2str(int tag)
return "(unknown)";
}
LCRYPTO_ALIAS(ASN1_tag2str);

4
lib/libcrypto/asn1/asn_mime.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: asn_mime.c,v 1.31 2023/04/19 16:36:34 tb Exp $ */
/* $OpenBSD: asn_mime.c,v 1.32 2023/07/05 21:23:36 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project.
*/
@ -565,6 +565,7 @@ SMIME_crlf_copy(BIO *in, BIO *out, int flags)
BIO_free(bf);
return 1;
}
LCRYPTO_ALIAS(SMIME_crlf_copy);
/* Strip off headers if they are text/plain */
int
@ -597,6 +598,7 @@ SMIME_text(BIO *in, BIO *out)
return 0;
return 1;
}
LCRYPTO_ALIAS(SMIME_text);
/*
* Split a multipart/XXX message body into component parts: result is

3
lib/libcrypto/asn1/asn_moid.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: asn_moid.c,v 1.15 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: asn_moid.c,v 1.16 2023/07/05 21:23:36 beck Exp $ */
/* Written by Stephen Henson (steve@openssl.org) for the OpenSSL
* project 2001.
*/
@ -105,6 +105,7 @@ ASN1_add_oid_module(void)
{
CONF_module_add("oid_section", oid_module_init, oid_module_finish);
}
LCRYPTO_ALIAS(ASN1_add_oid_module);
/* Create an OID based on a name value pair. Accept two formats.
* shortname = 1.2.3.4

7
lib/libcrypto/asn1/bio_asn1.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: bio_asn1.c,v 1.21 2023/03/25 10:45:20 tb Exp $ */
/* $OpenBSD: bio_asn1.c,v 1.22 2023/07/05 21:23:36 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project.
*/
@ -144,6 +144,7 @@ BIO_f_asn1(void)
{
return (&methods_asn1);
}
LCRYPTO_ALIAS(BIO_f_asn1);
static int
asn1_bio_new(BIO *b)
@ -470,21 +471,25 @@ BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix, asn1_ps_func *prefix_free)
{
return asn1_bio_set_ex(b, BIO_C_SET_PREFIX, prefix, prefix_free);
}
LCRYPTO_ALIAS(BIO_asn1_set_prefix);
int
BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix, asn1_ps_func **pprefix_free)
{
return asn1_bio_get_ex(b, BIO_C_GET_PREFIX, pprefix, pprefix_free);
}
LCRYPTO_ALIAS(BIO_asn1_get_prefix);
int
BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix, asn1_ps_func *suffix_free)
{
return asn1_bio_set_ex(b, BIO_C_SET_SUFFIX, suffix, suffix_free);
}
LCRYPTO_ALIAS(BIO_asn1_set_suffix);
int
BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix, asn1_ps_func **psuffix_free)
{
return asn1_bio_get_ex(b, BIO_C_GET_SUFFIX, psuffix, psuffix_free);
}
LCRYPTO_ALIAS(BIO_asn1_get_suffix);

8
lib/libcrypto/asn1/p5_pbe.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: p5_pbe.c,v 1.23 2021/12/25 13:17:48 jsing Exp $ */
/* $OpenBSD: p5_pbe.c,v 1.24 2023/07/05 21:23:36 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
@ -95,24 +95,28 @@ d2i_PBEPARAM(PBEPARAM **a, const unsigned char **in, long len)
return (PBEPARAM *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PBEPARAM_it);
}
LCRYPTO_ALIAS(d2i_PBEPARAM);
int
i2d_PBEPARAM(PBEPARAM *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PBEPARAM_it);
}
LCRYPTO_ALIAS(i2d_PBEPARAM);
PBEPARAM *
PBEPARAM_new(void)
{
return (PBEPARAM *)ASN1_item_new(&PBEPARAM_it);
}
LCRYPTO_ALIAS(PBEPARAM_new);
void
PBEPARAM_free(PBEPARAM *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PBEPARAM_it);
}
LCRYPTO_ALIAS(PBEPARAM_free);
/* Set an algorithm identifier for a PKCS#5 PBE algorithm */
@ -165,6 +169,7 @@ PKCS5_pbe_set0_algor(X509_ALGOR *algor, int alg, int iter,
ASN1_STRING_free(pbe_str);
return 0;
}
LCRYPTO_ALIAS(PKCS5_pbe_set0_algor);
/* Return an algorithm identifier for a PKCS#5 PBE algorithm */
@ -184,3 +189,4 @@ PKCS5_pbe_set(int alg, int iter, const unsigned char *salt, int saltlen)
X509_ALGOR_free(ret);
return NULL;
}
LCRYPTO_ALIAS(PKCS5_pbe_set);

13
lib/libcrypto/asn1/p5_pbev2.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: p5_pbev2.c,v 1.28 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: p5_pbev2.c,v 1.29 2023/07/05 21:23:36 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999-2004.
*/
@ -97,24 +97,28 @@ d2i_PBE2PARAM(PBE2PARAM **a, const unsigned char **in, long len)
return (PBE2PARAM *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PBE2PARAM_it);
}
LCRYPTO_ALIAS(d2i_PBE2PARAM);
int
i2d_PBE2PARAM(PBE2PARAM *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PBE2PARAM_it);
}
LCRYPTO_ALIAS(i2d_PBE2PARAM);
PBE2PARAM *
PBE2PARAM_new(void)
{
return (PBE2PARAM *)ASN1_item_new(&PBE2PARAM_it);
}
LCRYPTO_ALIAS(PBE2PARAM_new);
void
PBE2PARAM_free(PBE2PARAM *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PBE2PARAM_it);
}
LCRYPTO_ALIAS(PBE2PARAM_free);
static const ASN1_TEMPLATE PBKDF2PARAM_seq_tt[] = {
{
@ -157,24 +161,28 @@ d2i_PBKDF2PARAM(PBKDF2PARAM **a, const unsigned char **in, long len)
return (PBKDF2PARAM *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PBKDF2PARAM_it);
}
LCRYPTO_ALIAS(d2i_PBKDF2PARAM);
int
i2d_PBKDF2PARAM(PBKDF2PARAM *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PBKDF2PARAM_it);
}
LCRYPTO_ALIAS(i2d_PBKDF2PARAM);
PBKDF2PARAM *
PBKDF2PARAM_new(void)
{
return (PBKDF2PARAM *)ASN1_item_new(&PBKDF2PARAM_it);
}
LCRYPTO_ALIAS(PBKDF2PARAM_new);
void
PBKDF2PARAM_free(PBKDF2PARAM *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PBKDF2PARAM_it);
}
LCRYPTO_ALIAS(PBKDF2PARAM_free);
/* Return an algorithm identifier for a PKCS#5 v2.0 PBE algorithm:
* yes I know this is horrible!
@ -285,6 +293,7 @@ PKCS5_pbe2_set_iv(const EVP_CIPHER *cipher, int iter, unsigned char *salt,
return NULL;
}
LCRYPTO_ALIAS(PKCS5_pbe2_set_iv);
X509_ALGOR *
PKCS5_pbe2_set(const EVP_CIPHER *cipher, int iter, unsigned char *salt,
@ -292,6 +301,7 @@ PKCS5_pbe2_set(const EVP_CIPHER *cipher, int iter, unsigned char *salt,
{
return PKCS5_pbe2_set_iv(cipher, iter, salt, saltlen, NULL, -1);
}
LCRYPTO_ALIAS(PKCS5_pbe2_set);
X509_ALGOR *
PKCS5_pbkdf2_set(int iter, unsigned char *salt, int saltlen, int prf_nid,
@ -372,3 +382,4 @@ PKCS5_pbkdf2_set(int iter, unsigned char *salt, int saltlen, int prf_nid,
X509_ALGOR_free(keyfunc);
return NULL;
}
LCRYPTO_ALIAS(PKCS5_pbkdf2_set);

11
lib/libcrypto/asn1/p8_pkey.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: p8_pkey.c,v 1.21 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: p8_pkey.c,v 1.22 2023/07/05 21:23:36 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
@ -121,24 +121,28 @@ d2i_PKCS8_PRIV_KEY_INFO(PKCS8_PRIV_KEY_INFO **a, const unsigned char **in, long
return (PKCS8_PRIV_KEY_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&PKCS8_PRIV_KEY_INFO_it);
}
LCRYPTO_ALIAS(d2i_PKCS8_PRIV_KEY_INFO);
int
i2d_PKCS8_PRIV_KEY_INFO(PKCS8_PRIV_KEY_INFO *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS8_PRIV_KEY_INFO_it);
}
LCRYPTO_ALIAS(i2d_PKCS8_PRIV_KEY_INFO);
PKCS8_PRIV_KEY_INFO *
PKCS8_PRIV_KEY_INFO_new(void)
{
return (PKCS8_PRIV_KEY_INFO *)ASN1_item_new(&PKCS8_PRIV_KEY_INFO_it);
}
LCRYPTO_ALIAS(PKCS8_PRIV_KEY_INFO_new);
void
PKCS8_PRIV_KEY_INFO_free(PKCS8_PRIV_KEY_INFO *a)
{
ASN1_item_free((ASN1_VALUE *)a, &PKCS8_PRIV_KEY_INFO_it);
}
LCRYPTO_ALIAS(PKCS8_PRIV_KEY_INFO_free);
int
PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO *priv, ASN1_OBJECT *aobj, int version,
@ -154,6 +158,7 @@ PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO *priv, ASN1_OBJECT *aobj, int version,
ASN1_STRING_set0(priv->pkey, penc, penclen);
return 1;
}
LCRYPTO_ALIAS(PKCS8_pkey_set0);
int
PKCS8_pkey_get0(const ASN1_OBJECT **ppkalg, const unsigned char **pk,
@ -169,12 +174,14 @@ PKCS8_pkey_get0(const ASN1_OBJECT **ppkalg, const unsigned char **pk,
*pa = p8->pkeyalg;
return 1;
}
LCRYPTO_ALIAS(PKCS8_pkey_get0);
const STACK_OF(X509_ATTRIBUTE) *
PKCS8_pkey_get0_attrs(const PKCS8_PRIV_KEY_INFO *p8)
{
return p8->attributes;
}
LCRYPTO_ALIAS(PKCS8_pkey_get0_attrs);
int
PKCS8_pkey_add1_attr_by_NID(PKCS8_PRIV_KEY_INFO *p8, int nid, int type,
@ -185,4 +192,4 @@ PKCS8_pkey_add1_attr_by_NID(PKCS8_PRIV_KEY_INFO *p8, int nid, int type,
return 1;
return 0;
}
LCRYPTO_ALIAS(PKCS8_pkey_add1_attr_by_NID);

4
lib/libcrypto/asn1/t_crl.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: t_crl.c,v 1.21 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: t_crl.c,v 1.22 2023/07/05 21:23:36 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
@ -83,6 +83,7 @@ X509_CRL_print_fp(FILE *fp, X509_CRL *x)
BIO_free(b);
return (ret);
}
LCRYPTO_ALIAS(X509_CRL_print_fp);
int
X509_CRL_print(BIO *out, X509_CRL *x)
@ -143,3 +144,4 @@ X509_CRL_print(BIO *out, X509_CRL *x)
err:
return 0;
}
LCRYPTO_ALIAS(X509_CRL_print);

4
lib/libcrypto/asn1/t_pkey.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: t_pkey.c,v 1.19 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: t_pkey.c,v 1.20 2023/07/05 21:23:36 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -114,6 +114,7 @@ ASN1_bn_print(BIO *bp, const char *number, const BIGNUM *num,
}
return (1);
}
LCRYPTO_ALIAS(ASN1_bn_print);
#define ASN1_BUF_PRINT_WIDTH 15
#define ASN1_BUF_PRINT_MAX_INDENT 64
@ -143,3 +144,4 @@ ASN1_buf_print(BIO *bp, const unsigned char *buf, size_t buflen, int indent)
return 1;
}
LCRYPTO_ALIAS(ASN1_buf_print);

5
lib/libcrypto/asn1/t_req.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: t_req.c,v 1.24 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: t_req.c,v 1.25 2023/07/05 21:23:36 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -91,6 +91,7 @@ X509_REQ_print_fp(FILE *fp, X509_REQ *x)
BIO_free(b);
return (ret);
}
LCRYPTO_ALIAS(X509_REQ_print_fp);
int
X509_REQ_print_ex(BIO *bp, X509_REQ *x, unsigned long nmflags,
@ -254,9 +255,11 @@ X509_REQ_print_ex(BIO *bp, X509_REQ *x, unsigned long nmflags,
X509error(ERR_R_BUF_LIB);
return (0);
}
LCRYPTO_ALIAS(X509_REQ_print_ex);
int
X509_REQ_print(BIO *bp, X509_REQ *x)
{
return X509_REQ_print_ex(bp, x, XN_FLAG_COMPAT, X509_FLAG_COMPAT);
}
LCRYPTO_ALIAS(X509_REQ_print);

3
lib/libcrypto/asn1/t_spki.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: t_spki.c,v 1.14 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: t_spki.c,v 1.15 2023/07/05 21:23:36 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
@ -113,3 +113,4 @@ NETSCAPE_SPKI_print(BIO *out, NETSCAPE_SPKI *spki)
BIO_write(out, "\n", 1);
return 1;
}
LCRYPTO_ALIAS(NETSCAPE_SPKI_print);

13
lib/libcrypto/asn1/t_x509.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: t_x509.c,v 1.41 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: t_x509.c,v 1.42 2023/07/05 21:23:36 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -85,6 +85,7 @@ X509_print_fp(FILE *fp, X509 *x)
{
return X509_print_ex_fp(fp, x, XN_FLAG_COMPAT, X509_FLAG_COMPAT);
}
LCRYPTO_ALIAS(X509_print_fp);
int
X509_print_ex_fp(FILE *fp, X509 *x, unsigned long nmflag, unsigned long cflag)
@ -101,12 +102,14 @@ X509_print_ex_fp(FILE *fp, X509 *x, unsigned long nmflag, unsigned long cflag)
BIO_free(b);
return (ret);
}
LCRYPTO_ALIAS(X509_print_ex_fp);
int
X509_print(BIO *bp, X509 *x)
{
return X509_print_ex(bp, x, XN_FLAG_COMPAT, X509_FLAG_COMPAT);
}
LCRYPTO_ALIAS(X509_print);
int
X509_print_ex(BIO *bp, X509 *x, unsigned long nmflags, unsigned long cflag)
@ -250,6 +253,7 @@ X509_print_ex(BIO *bp, X509 *x, unsigned long nmflags, unsigned long cflag)
free(m);
return (ret);
}
LCRYPTO_ALIAS(X509_print_ex);
int
X509_ocspid_print(BIO *bp, X509 *x)
@ -301,6 +305,7 @@ X509_ocspid_print(BIO *bp, X509 *x)
free(der);
return (0);
}
LCRYPTO_ALIAS(X509_ocspid_print);
int
X509_signature_dump(BIO *bp, const ASN1_STRING *sig, int indent)
@ -326,6 +331,7 @@ X509_signature_dump(BIO *bp, const ASN1_STRING *sig, int indent)
return 1;
}
LCRYPTO_ALIAS(X509_signature_dump);
int
X509_signature_print(BIO *bp, const X509_ALGOR *sigalg, const ASN1_STRING *sig)
@ -352,6 +358,7 @@ X509_signature_print(BIO *bp, const X509_ALGOR *sigalg, const ASN1_STRING *sig)
return 0;
return 1;
}
LCRYPTO_ALIAS(X509_signature_print);
int
ASN1_TIME_print(BIO *bp, const ASN1_TIME *tm)
@ -363,6 +370,7 @@ ASN1_TIME_print(BIO *bp, const ASN1_TIME *tm)
BIO_write(bp, "Bad time value", 14);
return (0);
}
LCRYPTO_ALIAS(ASN1_TIME_print);
static const char *mon[12] = {
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
@ -422,6 +430,7 @@ ASN1_GENERALIZEDTIME_print(BIO *bp, const ASN1_GENERALIZEDTIME *tm)
BIO_write(bp, "Bad time value", 14);
return (0);
}
LCRYPTO_ALIAS(ASN1_GENERALIZEDTIME_print);
int
ASN1_UTCTIME_print(BIO *bp, const ASN1_UTCTIME *tm)
@ -465,6 +474,7 @@ ASN1_UTCTIME_print(BIO *bp, const ASN1_UTCTIME *tm)
BIO_write(bp, "Bad time value", 14);
return (0);
}
LCRYPTO_ALIAS(ASN1_UTCTIME_print);
int
X509_NAME_print(BIO *bp, const X509_NAME *name, int obase)
@ -510,3 +520,4 @@ X509_NAME_print(BIO *bp, const X509_NAME *name, int obase)
free(b);
return (ret);
}
LCRYPTO_ALIAS(X509_NAME_print);

3
lib/libcrypto/asn1/t_x509a.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: t_x509a.c,v 1.11 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: t_x509a.c,v 1.12 2023/07/05 21:23:36 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
@ -117,3 +117,4 @@ X509_CERT_AUX_print(BIO *out, X509_CERT_AUX *aux, int indent)
}
return 1;
}
LCRYPTO_ALIAS(X509_CERT_AUX_print);

5
lib/libcrypto/asn1/tasn_dec.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: tasn_dec.c,v 1.86 2023/04/30 16:46:49 job Exp $ */
/* $OpenBSD: tasn_dec.c,v 1.87 2023/07/05 21:23:36 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2000.
*/
@ -1237,6 +1237,7 @@ ASN1_item_d2i(ASN1_VALUE **pval, const unsigned char **in, long inlen,
return *pval;
}
LCRYPTO_ALIAS(ASN1_item_d2i);
int
ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long inlen,
@ -1256,6 +1257,7 @@ ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long inlen,
return ret;
}
LCRYPTO_ALIAS(ASN1_item_ex_d2i);
int
ASN1_template_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
@ -1273,3 +1275,4 @@ ASN1_template_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
return ret;
}
LCRYPTO_ALIAS(ASN1_template_d2i);

5
lib/libcrypto/asn1/tasn_enc.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: tasn_enc.c,v 1.31 2023/04/30 16:46:49 job Exp $ */
/* $OpenBSD: tasn_enc.c,v 1.32 2023/07/05 21:23:36 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2000.
*/
@ -92,6 +92,7 @@ ASN1_item_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it)
{
return asn1_item_flags_i2d(val, out, it, 0);
}
LCRYPTO_ALIAS(ASN1_item_i2d);
/* Encode an ASN1 item, this is use by the
* standard 'i2d' function. 'out' points to
@ -268,6 +269,7 @@ ASN1_item_ex_i2d(ASN1_VALUE **pval, unsigned char **out, const ASN1_ITEM *it,
}
return 0;
}
LCRYPTO_ALIAS(ASN1_item_ex_i2d);
int
ASN1_template_i2d(ASN1_VALUE **pval, unsigned char **out,
@ -275,6 +277,7 @@ ASN1_template_i2d(ASN1_VALUE **pval, unsigned char **out,
{
return asn1_template_ex_i2d(pval, out, tt, -1, 0);
}
LCRYPTO_ALIAS(ASN1_template_i2d);
static int
asn1_template_ex_i2d(ASN1_VALUE **pval, unsigned char **out,

6
lib/libcrypto/asn1/tasn_fre.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: tasn_fre.c,v 1.21 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: tasn_fre.c,v 1.22 2023/07/05 21:23:36 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2000.
*/
@ -73,12 +73,14 @@ ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it)
{
asn1_item_free(&val, it);
}
LCRYPTO_ALIAS(ASN1_item_free);
void
ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it)
{
asn1_item_free(pval, it);
}
LCRYPTO_ALIAS(ASN1_item_ex_free);
static void
asn1_item_free(ASN1_VALUE **pval, const ASN1_ITEM *it)
@ -183,6 +185,7 @@ ASN1_template_free(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt)
} else
asn1_item_free(pval, tt->item);
}
LCRYPTO_ALIAS(ASN1_template_free);
void
ASN1_primitive_free(ASN1_VALUE **pval, const ASN1_ITEM *it)
@ -239,3 +242,4 @@ ASN1_primitive_free(ASN1_VALUE **pval, const ASN1_ITEM *it)
}
*pval = NULL;
}
LCRYPTO_ALIAS(ASN1_primitive_free);

6
lib/libcrypto/asn1/tasn_new.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: tasn_new.c,v 1.23 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: tasn_new.c,v 1.24 2023/07/05 21:23:36 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2000.
*/
@ -79,6 +79,7 @@ ASN1_item_new(const ASN1_ITEM *it)
return ret;
return NULL;
}
LCRYPTO_ALIAS(ASN1_item_new);
/* Allocate an ASN1 structure */
@ -87,6 +88,7 @@ ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
{
return asn1_item_ex_new(pval, it);
}
LCRYPTO_ALIAS(ASN1_item_ex_new);
static int
asn1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
@ -246,6 +248,7 @@ ASN1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt)
done:
return ret;
}
LCRYPTO_ALIAS(ASN1_template_new);
static void
asn1_template_clear(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt)
@ -315,6 +318,7 @@ ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
return 1;
return 0;
}
LCRYPTO_ALIAS(ASN1_primitive_new);
static void
asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it)

15
lib/libcrypto/asn1/tasn_prn.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: tasn_prn.c,v 1.24 2023/04/17 08:43:16 tb Exp $ */
/* $OpenBSD: tasn_prn.c,v 1.25 2023/07/05 21:23:36 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2000.
*/
@ -88,72 +88,84 @@ ASN1_PCTX_new(void)
return p;
}
LCRYPTO_ALIAS(ASN1_PCTX_new);
void
ASN1_PCTX_free(ASN1_PCTX *p)
{
free(p);
}
LCRYPTO_ALIAS(ASN1_PCTX_free);
unsigned long
ASN1_PCTX_get_flags(const ASN1_PCTX *p)
{
return p->flags;
}
LCRYPTO_ALIAS(ASN1_PCTX_get_flags);
void
ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags)
{
p->flags = flags;
}
LCRYPTO_ALIAS(ASN1_PCTX_set_flags);
unsigned long
ASN1_PCTX_get_nm_flags(const ASN1_PCTX *p)
{
return p->nm_flags;
}
LCRYPTO_ALIAS(ASN1_PCTX_get_nm_flags);
void
ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags)
{
p->nm_flags = flags;
}
LCRYPTO_ALIAS(ASN1_PCTX_set_nm_flags);
unsigned long
ASN1_PCTX_get_cert_flags(const ASN1_PCTX *p)
{
return p->cert_flags;
}
LCRYPTO_ALIAS(ASN1_PCTX_get_cert_flags);
void
ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags)
{
p->cert_flags = flags;
}
LCRYPTO_ALIAS(ASN1_PCTX_set_cert_flags);
unsigned long
ASN1_PCTX_get_oid_flags(const ASN1_PCTX *p)
{
return p->oid_flags;
}
LCRYPTO_ALIAS(ASN1_PCTX_get_oid_flags);
void
ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags)
{
p->oid_flags = flags;
}
LCRYPTO_ALIAS(ASN1_PCTX_set_oid_flags);
unsigned long
ASN1_PCTX_get_str_flags(const ASN1_PCTX *p)
{
return p->str_flags;
}
LCRYPTO_ALIAS(ASN1_PCTX_get_str_flags);
void
ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags)
{
p->str_flags = flags;
}
LCRYPTO_ALIAS(ASN1_PCTX_set_str_flags);
/* Main print routines */
@ -186,6 +198,7 @@ ASN1_item_print(BIO *out, ASN1_VALUE *ifld, int indent, const ASN1_ITEM *it,
return asn1_item_print_ctx(out, &ifld, indent, it, NULL, sname,
0, pctx);
}
LCRYPTO_ALIAS(ASN1_item_print);
static int
asn1_item_print_ctx(BIO *out, ASN1_VALUE **fld, int indent, const ASN1_ITEM *it,

62
lib/libcrypto/asn1/tasn_typ.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: tasn_typ.c,v 1.17 2021/12/26 15:20:21 tb Exp $ */
/* $OpenBSD: tasn_typ.c,v 1.18 2023/07/05 21:23:37 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2000.
*/
@ -73,24 +73,28 @@ d2i_ASN1_NULL(ASN1_NULL **a, const unsigned char **in, long len)
return (ASN1_NULL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_NULL_it);
}
LCRYPTO_ALIAS(d2i_ASN1_NULL);
int
i2d_ASN1_NULL(ASN1_NULL *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_NULL_it);
}
LCRYPTO_ALIAS(i2d_ASN1_NULL);
ASN1_NULL *
ASN1_NULL_new(void)
{
return (ASN1_NULL *)ASN1_item_new(&ASN1_NULL_it);
}
LCRYPTO_ALIAS(ASN1_NULL_new);
void
ASN1_NULL_free(ASN1_NULL *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASN1_NULL_it);
}
LCRYPTO_ALIAS(ASN1_NULL_free);
const ASN1_ITEM ASN1_UTF8STRING_it = {
@ -105,24 +109,28 @@ d2i_ASN1_UTF8STRING(ASN1_UTF8STRING **a, const unsigned char **in, long len)
return (ASN1_UTF8STRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_UTF8STRING_it);
}
LCRYPTO_ALIAS(d2i_ASN1_UTF8STRING);
int
i2d_ASN1_UTF8STRING(ASN1_UTF8STRING *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_UTF8STRING_it);
}
LCRYPTO_ALIAS(i2d_ASN1_UTF8STRING);
ASN1_UTF8STRING *
ASN1_UTF8STRING_new(void)
{
return (ASN1_UTF8STRING *)ASN1_item_new(&ASN1_UTF8STRING_it);
}
LCRYPTO_ALIAS(ASN1_UTF8STRING_new);
void
ASN1_UTF8STRING_free(ASN1_UTF8STRING *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASN1_UTF8STRING_it);
}
LCRYPTO_ALIAS(ASN1_UTF8STRING_free);
const ASN1_ITEM ASN1_PRINTABLESTRING_it = {
@ -138,24 +146,28 @@ d2i_ASN1_PRINTABLESTRING(ASN1_PRINTABLESTRING **a, const unsigned char **in,
return (ASN1_PRINTABLESTRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_PRINTABLESTRING_it);
}
LCRYPTO_ALIAS(d2i_ASN1_PRINTABLESTRING);
int
i2d_ASN1_PRINTABLESTRING(ASN1_PRINTABLESTRING *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_PRINTABLESTRING_it);
}
LCRYPTO_ALIAS(i2d_ASN1_PRINTABLESTRING);
ASN1_PRINTABLESTRING *
ASN1_PRINTABLESTRING_new(void)
{
return (ASN1_PRINTABLESTRING *)ASN1_item_new(&ASN1_PRINTABLESTRING_it);
}
LCRYPTO_ALIAS(ASN1_PRINTABLESTRING_new);
void
ASN1_PRINTABLESTRING_free(ASN1_PRINTABLESTRING *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASN1_PRINTABLESTRING_it);
}
LCRYPTO_ALIAS(ASN1_PRINTABLESTRING_free);
const ASN1_ITEM ASN1_T61STRING_it = {
@ -170,24 +182,28 @@ d2i_ASN1_T61STRING(ASN1_T61STRING **a, const unsigned char **in, long len)
return (ASN1_T61STRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_T61STRING_it);
}
LCRYPTO_ALIAS(d2i_ASN1_T61STRING);
int
i2d_ASN1_T61STRING(ASN1_T61STRING *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_T61STRING_it);
}
LCRYPTO_ALIAS(i2d_ASN1_T61STRING);
ASN1_T61STRING *
ASN1_T61STRING_new(void)
{
return (ASN1_T61STRING *)ASN1_item_new(&ASN1_T61STRING_it);
}
LCRYPTO_ALIAS(ASN1_T61STRING_new);
void
ASN1_T61STRING_free(ASN1_T61STRING *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASN1_T61STRING_it);
}
LCRYPTO_ALIAS(ASN1_T61STRING_free);
const ASN1_ITEM ASN1_IA5STRING_it = {
@ -202,24 +218,28 @@ d2i_ASN1_IA5STRING(ASN1_IA5STRING **a, const unsigned char **in, long len)
return (ASN1_IA5STRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_IA5STRING_it);
}
LCRYPTO_ALIAS(d2i_ASN1_IA5STRING);
int
i2d_ASN1_IA5STRING(ASN1_IA5STRING *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_IA5STRING_it);
}
LCRYPTO_ALIAS(i2d_ASN1_IA5STRING);
ASN1_IA5STRING *
ASN1_IA5STRING_new(void)
{
return (ASN1_IA5STRING *)ASN1_item_new(&ASN1_IA5STRING_it);
}
LCRYPTO_ALIAS(ASN1_IA5STRING_new);
void
ASN1_IA5STRING_free(ASN1_IA5STRING *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASN1_IA5STRING_it);
}
LCRYPTO_ALIAS(ASN1_IA5STRING_free);
const ASN1_ITEM ASN1_GENERALSTRING_it = {
@ -235,24 +255,28 @@ d2i_ASN1_GENERALSTRING(ASN1_GENERALSTRING **a, const unsigned char **in,
return (ASN1_GENERALSTRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_GENERALSTRING_it);
}
LCRYPTO_ALIAS(d2i_ASN1_GENERALSTRING);
int
i2d_ASN1_GENERALSTRING(ASN1_GENERALSTRING *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_GENERALSTRING_it);
}
LCRYPTO_ALIAS(i2d_ASN1_GENERALSTRING);
ASN1_GENERALSTRING *
ASN1_GENERALSTRING_new(void)
{
return (ASN1_GENERALSTRING *)ASN1_item_new(&ASN1_GENERALSTRING_it);
}
LCRYPTO_ALIAS(ASN1_GENERALSTRING_new);
void
ASN1_GENERALSTRING_free(ASN1_GENERALSTRING *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASN1_GENERALSTRING_it);
}
LCRYPTO_ALIAS(ASN1_GENERALSTRING_free);
const ASN1_ITEM ASN1_UTCTIME_it = {
@ -267,24 +291,28 @@ d2i_ASN1_UTCTIME(ASN1_UTCTIME **a, const unsigned char **in, long len)
return (ASN1_UTCTIME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_UTCTIME_it);
}
LCRYPTO_ALIAS(d2i_ASN1_UTCTIME);
int
i2d_ASN1_UTCTIME(ASN1_UTCTIME *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_UTCTIME_it);
}
LCRYPTO_ALIAS(i2d_ASN1_UTCTIME);
ASN1_UTCTIME *
ASN1_UTCTIME_new(void)
{
return (ASN1_UTCTIME *)ASN1_item_new(&ASN1_UTCTIME_it);
}
LCRYPTO_ALIAS(ASN1_UTCTIME_new);
void
ASN1_UTCTIME_free(ASN1_UTCTIME *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASN1_UTCTIME_it);
}
LCRYPTO_ALIAS(ASN1_UTCTIME_free);
const ASN1_ITEM ASN1_GENERALIZEDTIME_it = {
@ -300,24 +328,28 @@ d2i_ASN1_GENERALIZEDTIME(ASN1_GENERALIZEDTIME **a, const unsigned char **in,
return (ASN1_GENERALIZEDTIME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_GENERALIZEDTIME_it);
}
LCRYPTO_ALIAS(d2i_ASN1_GENERALIZEDTIME);
int
i2d_ASN1_GENERALIZEDTIME(ASN1_GENERALIZEDTIME *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_GENERALIZEDTIME_it);
}
LCRYPTO_ALIAS(i2d_ASN1_GENERALIZEDTIME);
ASN1_GENERALIZEDTIME *
ASN1_GENERALIZEDTIME_new(void)
{
return (ASN1_GENERALIZEDTIME *)ASN1_item_new(&ASN1_GENERALIZEDTIME_it);
}
LCRYPTO_ALIAS(ASN1_GENERALIZEDTIME_new);
void
ASN1_GENERALIZEDTIME_free(ASN1_GENERALIZEDTIME *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASN1_GENERALIZEDTIME_it);
}
LCRYPTO_ALIAS(ASN1_GENERALIZEDTIME_free);
const ASN1_ITEM ASN1_VISIBLESTRING_it = {
@ -333,24 +365,28 @@ d2i_ASN1_VISIBLESTRING(ASN1_VISIBLESTRING **a, const unsigned char **in,
return (ASN1_VISIBLESTRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_VISIBLESTRING_it);
}
LCRYPTO_ALIAS(d2i_ASN1_VISIBLESTRING);
int
i2d_ASN1_VISIBLESTRING(ASN1_VISIBLESTRING *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_VISIBLESTRING_it);
}
LCRYPTO_ALIAS(i2d_ASN1_VISIBLESTRING);
ASN1_VISIBLESTRING *
ASN1_VISIBLESTRING_new(void)
{
return (ASN1_VISIBLESTRING *)ASN1_item_new(&ASN1_VISIBLESTRING_it);
}
LCRYPTO_ALIAS(ASN1_VISIBLESTRING_new);
void
ASN1_VISIBLESTRING_free(ASN1_VISIBLESTRING *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASN1_VISIBLESTRING_it);
}
LCRYPTO_ALIAS(ASN1_VISIBLESTRING_free);
const ASN1_ITEM ASN1_UNIVERSALSTRING_it = {
@ -366,24 +402,28 @@ d2i_ASN1_UNIVERSALSTRING(ASN1_UNIVERSALSTRING **a, const unsigned char **in,
return (ASN1_UNIVERSALSTRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_UNIVERSALSTRING_it);
}
LCRYPTO_ALIAS(d2i_ASN1_UNIVERSALSTRING);
int
i2d_ASN1_UNIVERSALSTRING(ASN1_UNIVERSALSTRING *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_UNIVERSALSTRING_it);
}
LCRYPTO_ALIAS(i2d_ASN1_UNIVERSALSTRING);
ASN1_UNIVERSALSTRING *
ASN1_UNIVERSALSTRING_new(void)
{
return (ASN1_UNIVERSALSTRING *)ASN1_item_new(&ASN1_UNIVERSALSTRING_it);
}
LCRYPTO_ALIAS(ASN1_UNIVERSALSTRING_new);
void
ASN1_UNIVERSALSTRING_free(ASN1_UNIVERSALSTRING *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASN1_UNIVERSALSTRING_it);
}
LCRYPTO_ALIAS(ASN1_UNIVERSALSTRING_free);
const ASN1_ITEM ASN1_BMPSTRING_it = {
@ -398,24 +438,28 @@ d2i_ASN1_BMPSTRING(ASN1_BMPSTRING **a, const unsigned char **in, long len)
return (ASN1_BMPSTRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_BMPSTRING_it);
}
LCRYPTO_ALIAS(d2i_ASN1_BMPSTRING);
int
i2d_ASN1_BMPSTRING(ASN1_BMPSTRING *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_BMPSTRING_it);
}
LCRYPTO_ALIAS(i2d_ASN1_BMPSTRING);
ASN1_BMPSTRING *
ASN1_BMPSTRING_new(void)
{
return (ASN1_BMPSTRING *)ASN1_item_new(&ASN1_BMPSTRING_it);
}
LCRYPTO_ALIAS(ASN1_BMPSTRING_new);
void
ASN1_BMPSTRING_free(ASN1_BMPSTRING *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASN1_BMPSTRING_it);
}
LCRYPTO_ALIAS(ASN1_BMPSTRING_free);
const ASN1_ITEM ASN1_ANY_it = {
.itype = ASN1_ITYPE_PRIMITIVE,
@ -452,24 +496,28 @@ d2i_ASN1_PRINTABLE(ASN1_STRING **a, const unsigned char **in, long len)
return (ASN1_STRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_PRINTABLE_it);
}
LCRYPTO_ALIAS(d2i_ASN1_PRINTABLE);
int
i2d_ASN1_PRINTABLE(ASN1_STRING *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_PRINTABLE_it);
}
LCRYPTO_ALIAS(i2d_ASN1_PRINTABLE);
ASN1_STRING *
ASN1_PRINTABLE_new(void)
{
return (ASN1_STRING *)ASN1_item_new(&ASN1_PRINTABLE_it);
}
LCRYPTO_ALIAS(ASN1_PRINTABLE_new);
void
ASN1_PRINTABLE_free(ASN1_STRING *a)
{
ASN1_item_free((ASN1_VALUE *)a, &ASN1_PRINTABLE_it);
}
LCRYPTO_ALIAS(ASN1_PRINTABLE_free);
const ASN1_ITEM DISPLAYTEXT_it = {
@ -488,24 +536,28 @@ d2i_DISPLAYTEXT(ASN1_STRING **a, const unsigned char **in, long len)
return (ASN1_STRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&DISPLAYTEXT_it);
}
LCRYPTO_ALIAS(d2i_DISPLAYTEXT);
int
i2d_DISPLAYTEXT(ASN1_STRING *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &DISPLAYTEXT_it);
}
LCRYPTO_ALIAS(i2d_DISPLAYTEXT);
ASN1_STRING *
DISPLAYTEXT_new(void)
{
return (ASN1_STRING *)ASN1_item_new(&DISPLAYTEXT_it);
}
LCRYPTO_ALIAS(DISPLAYTEXT_new);
void
DISPLAYTEXT_free(ASN1_STRING *a)
{
ASN1_item_free((ASN1_VALUE *)a, &DISPLAYTEXT_it);
}
LCRYPTO_ALIAS(DISPLAYTEXT_free);
const ASN1_ITEM DIRECTORYSTRING_it = {
@ -524,24 +576,28 @@ d2i_DIRECTORYSTRING(ASN1_STRING **a, const unsigned char **in, long len)
return (ASN1_STRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&DIRECTORYSTRING_it);
}
LCRYPTO_ALIAS(d2i_DIRECTORYSTRING);
int
i2d_DIRECTORYSTRING(ASN1_STRING *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &DIRECTORYSTRING_it);
}
LCRYPTO_ALIAS(i2d_DIRECTORYSTRING);
ASN1_STRING *
DIRECTORYSTRING_new(void)
{
return (ASN1_STRING *)ASN1_item_new(&DIRECTORYSTRING_it);
}
LCRYPTO_ALIAS(DIRECTORYSTRING_new);
void
DIRECTORYSTRING_free(ASN1_STRING *a)
{
ASN1_item_free((ASN1_VALUE *)a, &DIRECTORYSTRING_it);
}
LCRYPTO_ALIAS(DIRECTORYSTRING_free);
/* Three separate BOOLEAN type: normal, DEFAULT TRUE and DEFAULT FALSE */
@ -640,12 +696,14 @@ d2i_ASN1_SEQUENCE_ANY(ASN1_SEQUENCE_ANY **a, const unsigned char **in, long len)
return (ASN1_SEQUENCE_ANY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_SEQUENCE_ANY_it);
}
LCRYPTO_ALIAS(d2i_ASN1_SEQUENCE_ANY);
int
i2d_ASN1_SEQUENCE_ANY(const ASN1_SEQUENCE_ANY *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_SEQUENCE_ANY_it);
}
LCRYPTO_ALIAS(i2d_ASN1_SEQUENCE_ANY);
ASN1_SEQUENCE_ANY *
d2i_ASN1_SET_ANY(ASN1_SEQUENCE_ANY **a, const unsigned char **in, long len)
@ -653,9 +711,11 @@ d2i_ASN1_SET_ANY(ASN1_SEQUENCE_ANY **a, const unsigned char **in, long len)
return (ASN1_SEQUENCE_ANY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&ASN1_SET_ANY_it);
}
LCRYPTO_ALIAS(d2i_ASN1_SET_ANY);
int
i2d_ASN1_SET_ANY(const ASN1_SEQUENCE_ANY *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_SET_ANY_it);
}
LCRYPTO_ALIAS(i2d_ASN1_SET_ANY);

13
lib/libcrypto/asn1/x_algor.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: x_algor.c,v 1.23 2021/12/12 14:27:20 tb Exp $ */
/* $OpenBSD: x_algor.c,v 1.24 2023/07/05 21:23:37 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2000.
*/
@ -109,24 +109,28 @@ d2i_X509_ALGOR(X509_ALGOR **a, const unsigned char **in, long len)
return (X509_ALGOR *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_ALGOR_it);
}
LCRYPTO_ALIAS(d2i_X509_ALGOR);
int
i2d_X509_ALGOR(X509_ALGOR *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_ALGOR_it);
}
LCRYPTO_ALIAS(i2d_X509_ALGOR);
X509_ALGOR *
X509_ALGOR_new(void)
{
return (X509_ALGOR *)ASN1_item_new(&X509_ALGOR_it);
}
LCRYPTO_ALIAS(X509_ALGOR_new);
void
X509_ALGOR_free(X509_ALGOR *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_ALGOR_it);
}
LCRYPTO_ALIAS(X509_ALGOR_free);
X509_ALGORS *
d2i_X509_ALGORS(X509_ALGORS **a, const unsigned char **in, long len)
@ -134,18 +138,21 @@ d2i_X509_ALGORS(X509_ALGORS **a, const unsigned char **in, long len)
return (X509_ALGORS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_ALGORS_it);
}
LCRYPTO_ALIAS(d2i_X509_ALGORS);
int
i2d_X509_ALGORS(X509_ALGORS *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_ALGORS_it);
}
LCRYPTO_ALIAS(i2d_X509_ALGORS);
X509_ALGOR *
X509_ALGOR_dup(X509_ALGOR *x)
{
return ASN1_item_dup(&X509_ALGOR_it, x);
}
LCRYPTO_ALIAS(X509_ALGOR_dup);
int
X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype, void *pval)
@ -174,6 +181,7 @@ X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype, void *pval)
ASN1_TYPE_set(alg->parameter, ptype, pval);
return 1;
}
LCRYPTO_ALIAS(X509_ALGOR_set0);
void
X509_ALGOR_get0(const ASN1_OBJECT **paobj, int *pptype, const void **ppval,
@ -191,6 +199,7 @@ X509_ALGOR_get0(const ASN1_OBJECT **paobj, int *pptype, const void **ppval,
*ppval = algor->parameter->value.ptr;
}
}
LCRYPTO_ALIAS(X509_ALGOR_get0);
/* Set up an X509_ALGOR DigestAlgorithmIdentifier from an EVP_MD */
@ -204,6 +213,7 @@ X509_ALGOR_set_md(X509_ALGOR *alg, const EVP_MD *md)
X509_ALGOR_set0(alg, OBJ_nid2obj(EVP_MD_type(md)), param_type, NULL);
}
LCRYPTO_ALIAS(X509_ALGOR_set_md);
/* Returns 0 if they are equal, != 0 otherwise. */
int
@ -218,3 +228,4 @@ X509_ALGOR_cmp(const X509_ALGOR *a, const X509_ALGOR *b)
}
return(rv);
}
LCRYPTO_ALIAS(X509_ALGOR_cmp);

8
lib/libcrypto/asn1/x_attrib.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: x_attrib.c,v 1.18 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: x_attrib.c,v 1.19 2023/07/05 21:23:37 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -111,30 +111,35 @@ d2i_X509_ATTRIBUTE(X509_ATTRIBUTE **a, const unsigned char **in, long len)
return (X509_ATTRIBUTE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_ATTRIBUTE_it);
}
LCRYPTO_ALIAS(d2i_X509_ATTRIBUTE);
int
i2d_X509_ATTRIBUTE(X509_ATTRIBUTE *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_ATTRIBUTE_it);
}
LCRYPTO_ALIAS(i2d_X509_ATTRIBUTE);
X509_ATTRIBUTE *
X509_ATTRIBUTE_new(void)
{
return (X509_ATTRIBUTE *)ASN1_item_new(&X509_ATTRIBUTE_it);
}
LCRYPTO_ALIAS(X509_ATTRIBUTE_new);
void
X509_ATTRIBUTE_free(X509_ATTRIBUTE *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_ATTRIBUTE_it);
}
LCRYPTO_ALIAS(X509_ATTRIBUTE_free);
X509_ATTRIBUTE *
X509_ATTRIBUTE_dup(X509_ATTRIBUTE *x)
{
return ASN1_item_dup(&X509_ATTRIBUTE_it, x);
}
LCRYPTO_ALIAS(X509_ATTRIBUTE_dup);
X509_ATTRIBUTE *
X509_ATTRIBUTE_create(int nid, int atrtype, void *value)
@ -163,3 +168,4 @@ X509_ATTRIBUTE_create(int nid, int atrtype, void *value)
ASN1_TYPE_free(val);
return (NULL);
}
LCRYPTO_ALIAS(X509_ATTRIBUTE_create);

36
lib/libcrypto/asn1/x_crl.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: x_crl.c,v 1.39 2022/12/26 16:00:36 tb Exp $ */
/* $OpenBSD: x_crl.c,v 1.40 2023/07/05 21:23:37 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -442,30 +442,35 @@ d2i_X509_REVOKED(X509_REVOKED **a, const unsigned char **in, long len)
return (X509_REVOKED *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_REVOKED_it);
}
LCRYPTO_ALIAS(d2i_X509_REVOKED);
int
i2d_X509_REVOKED(X509_REVOKED *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_REVOKED_it);
}
LCRYPTO_ALIAS(i2d_X509_REVOKED);
X509_REVOKED *
X509_REVOKED_new(void)
{
return (X509_REVOKED *)ASN1_item_new(&X509_REVOKED_it);
}
LCRYPTO_ALIAS(X509_REVOKED_new);
void
X509_REVOKED_free(X509_REVOKED *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_REVOKED_it);
}
LCRYPTO_ALIAS(X509_REVOKED_free);
X509_REVOKED *
X509_REVOKED_dup(X509_REVOKED *a)
{
return ASN1_item_dup(&X509_REVOKED_it, a);
}
LCRYPTO_ALIAS(X509_REVOKED_dup);
X509_CRL_INFO *
d2i_X509_CRL_INFO(X509_CRL_INFO **a, const unsigned char **in, long len)
@ -473,24 +478,28 @@ d2i_X509_CRL_INFO(X509_CRL_INFO **a, const unsigned char **in, long len)
return (X509_CRL_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_CRL_INFO_it);
}
LCRYPTO_ALIAS(d2i_X509_CRL_INFO);
int
i2d_X509_CRL_INFO(X509_CRL_INFO *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_CRL_INFO_it);
}
LCRYPTO_ALIAS(i2d_X509_CRL_INFO);
X509_CRL_INFO *
X509_CRL_INFO_new(void)
{
return (X509_CRL_INFO *)ASN1_item_new(&X509_CRL_INFO_it);
}
LCRYPTO_ALIAS(X509_CRL_INFO_new);
void
X509_CRL_INFO_free(X509_CRL_INFO *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_CRL_INFO_it);
}
LCRYPTO_ALIAS(X509_CRL_INFO_free);
X509_CRL *
d2i_X509_CRL(X509_CRL **a, const unsigned char **in, long len)
@ -498,30 +507,35 @@ d2i_X509_CRL(X509_CRL **a, const unsigned char **in, long len)
return (X509_CRL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_CRL_it);
}
LCRYPTO_ALIAS(d2i_X509_CRL);
int
i2d_X509_CRL(X509_CRL *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_CRL_it);
}
LCRYPTO_ALIAS(i2d_X509_CRL);
X509_CRL *
X509_CRL_new(void)
{
return (X509_CRL *)ASN1_item_new(&X509_CRL_it);
}
LCRYPTO_ALIAS(X509_CRL_new);
void
X509_CRL_free(X509_CRL *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_CRL_it);
}
LCRYPTO_ALIAS(X509_CRL_free);
X509_CRL *
X509_CRL_dup(X509_CRL *x)
{
return ASN1_item_dup(&X509_CRL_it, x);
}
LCRYPTO_ALIAS(X509_CRL_dup);
static int
X509_REVOKED_cmp(const X509_REVOKED * const *a, const X509_REVOKED * const *b)
@ -544,6 +558,7 @@ X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev)
inf->enc.modified = 1;
return 1;
}
LCRYPTO_ALIAS(X509_CRL_add0_revoked);
int
X509_CRL_verify(X509_CRL *crl, EVP_PKEY *r)
@ -552,6 +567,7 @@ X509_CRL_verify(X509_CRL *crl, EVP_PKEY *r)
return crl->meth->crl_verify(crl, r);
return 0;
}
LCRYPTO_ALIAS(X509_CRL_verify);
int
X509_CRL_get0_by_serial(X509_CRL *crl, X509_REVOKED **ret,
@ -561,6 +577,7 @@ X509_CRL_get0_by_serial(X509_CRL *crl, X509_REVOKED **ret,
return crl->meth->crl_lookup(crl, ret, serial, NULL);
return 0;
}
LCRYPTO_ALIAS(X509_CRL_get0_by_serial);
int
X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x)
@ -570,6 +587,7 @@ X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x)
X509_get_serialNumber(x), X509_get_issuer_name(x));
return 0;
}
LCRYPTO_ALIAS(X509_CRL_get0_by_cert);
static int
def_crl_verify(X509_CRL *crl, EVP_PKEY *r)
@ -648,6 +666,7 @@ X509_CRL_set_default_method(const X509_CRL_METHOD *meth)
else
default_crl_method = meth;
}
LCRYPTO_ALIAS(X509_CRL_set_default_method);
X509_CRL_METHOD *
X509_CRL_METHOD_new(int (*crl_init)(X509_CRL *crl),
@ -669,6 +688,7 @@ X509_CRL_METHOD_new(int (*crl_init)(X509_CRL *crl),
return m;
}
LCRYPTO_ALIAS(X509_CRL_METHOD_new);
void
X509_CRL_METHOD_free(X509_CRL_METHOD *m)
@ -679,72 +699,84 @@ X509_CRL_METHOD_free(X509_CRL_METHOD *m)
return;
free(m);
}
LCRYPTO_ALIAS(X509_CRL_METHOD_free);
void
X509_CRL_set_meth_data(X509_CRL *crl, void *dat)
{
crl->meth_data = dat;
}
LCRYPTO_ALIAS(X509_CRL_set_meth_data);
void *
X509_CRL_get_meth_data(X509_CRL *crl)
{
return crl->meth_data;
}
LCRYPTO_ALIAS(X509_CRL_get_meth_data);
int
X509_CRL_get_signature_nid(const X509_CRL *crl)
{
return OBJ_obj2nid(crl->sig_alg->algorithm);
}
LCRYPTO_ALIAS(X509_CRL_get_signature_nid);
const STACK_OF(X509_EXTENSION) *
X509_CRL_get0_extensions(const X509_CRL *crl)
{
return crl->crl->extensions;
}
LCRYPTO_ALIAS(X509_CRL_get0_extensions);
long
X509_CRL_get_version(const X509_CRL *crl)
{
return ASN1_INTEGER_get(crl->crl->version);
}
LCRYPTO_ALIAS(X509_CRL_get_version);
const ASN1_TIME *
X509_CRL_get0_lastUpdate(const X509_CRL *crl)
{
return crl->crl->lastUpdate;
}
LCRYPTO_ALIAS(X509_CRL_get0_lastUpdate);
ASN1_TIME *
X509_CRL_get_lastUpdate(X509_CRL *crl)
{
return crl->crl->lastUpdate;
}
LCRYPTO_ALIAS(X509_CRL_get_lastUpdate);
const ASN1_TIME *
X509_CRL_get0_nextUpdate(const X509_CRL *crl)
{
return crl->crl->nextUpdate;
}
LCRYPTO_ALIAS(X509_CRL_get0_nextUpdate);
ASN1_TIME *
X509_CRL_get_nextUpdate(X509_CRL *crl)
{
return crl->crl->nextUpdate;
}
LCRYPTO_ALIAS(X509_CRL_get_nextUpdate);
X509_NAME *
X509_CRL_get_issuer(const X509_CRL *crl)
{
return crl->crl->issuer;
}
LCRYPTO_ALIAS(X509_CRL_get_issuer);
STACK_OF(X509_REVOKED) *
X509_CRL_get_REVOKED(X509_CRL *crl)
{
return crl->crl->revoked;
}
LCRYPTO_ALIAS(X509_CRL_get_REVOKED);
void
X509_CRL_get0_signature(const X509_CRL *crl, const ASN1_BIT_STRING **psig,
@ -755,9 +787,11 @@ X509_CRL_get0_signature(const X509_CRL *crl, const ASN1_BIT_STRING **psig,
if (palg != NULL)
*palg = crl->sig_alg;
}
LCRYPTO_ALIAS(X509_CRL_get0_signature);
const X509_ALGOR *
X509_CRL_get0_tbs_sigalg(const X509_CRL *crl)
{
return crl->crl->sig_alg;
}
LCRYPTO_ALIAS(X509_CRL_get0_tbs_sigalg);

9
lib/libcrypto/asn1/x_exten.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: x_exten.c,v 1.18 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: x_exten.c,v 1.19 2023/07/05 21:23:37 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 2000.
*/
@ -116,24 +116,28 @@ d2i_X509_EXTENSION(X509_EXTENSION **a, const unsigned char **in, long len)
return (X509_EXTENSION *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_EXTENSION_it);
}
LCRYPTO_ALIAS(d2i_X509_EXTENSION);
int
i2d_X509_EXTENSION(X509_EXTENSION *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_EXTENSION_it);
}
LCRYPTO_ALIAS(i2d_X509_EXTENSION);
X509_EXTENSION *
X509_EXTENSION_new(void)
{
return (X509_EXTENSION *)ASN1_item_new(&X509_EXTENSION_it);
}
LCRYPTO_ALIAS(X509_EXTENSION_new);
void
X509_EXTENSION_free(X509_EXTENSION *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_EXTENSION_it);
}
LCRYPTO_ALIAS(X509_EXTENSION_free);
X509_EXTENSIONS *
d2i_X509_EXTENSIONS(X509_EXTENSIONS **a, const unsigned char **in, long len)
@ -141,15 +145,18 @@ d2i_X509_EXTENSIONS(X509_EXTENSIONS **a, const unsigned char **in, long len)
return (X509_EXTENSIONS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_EXTENSIONS_it);
}
LCRYPTO_ALIAS(d2i_X509_EXTENSIONS);
int
i2d_X509_EXTENSIONS(X509_EXTENSIONS *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_EXTENSIONS_it);
}
LCRYPTO_ALIAS(i2d_X509_EXTENSIONS);
X509_EXTENSION *
X509_EXTENSION_dup(X509_EXTENSION *x)
{
return ASN1_item_dup(&X509_EXTENSION_it, x);
}
LCRYPTO_ALIAS(X509_EXTENSION_dup);

4
lib/libcrypto/asn1/x_info.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: x_info.c,v 1.18 2020/09/03 17:29:05 tb Exp $ */
/* $OpenBSD: x_info.c,v 1.19 2023/07/05 21:23:37 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -75,6 +75,7 @@ X509_INFO_new(void)
return ret;
}
LCRYPTO_ALIAS(X509_INFO_new);
void
X509_INFO_free(X509_INFO *x)
@ -92,3 +93,4 @@ X509_INFO_free(X509_INFO *x)
free(x);
}
LCRYPTO_ALIAS(X509_INFO_free);

14
lib/libcrypto/asn1/x_name.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: x_name.c,v 1.38 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: x_name.c,v 1.39 2023/07/05 21:23:37 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -117,30 +117,35 @@ d2i_X509_NAME_ENTRY(X509_NAME_ENTRY **a, const unsigned char **in, long len)
return (X509_NAME_ENTRY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_NAME_ENTRY_it);
}
LCRYPTO_ALIAS(d2i_X509_NAME_ENTRY);
int
i2d_X509_NAME_ENTRY(X509_NAME_ENTRY *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_NAME_ENTRY_it);
}
LCRYPTO_ALIAS(i2d_X509_NAME_ENTRY);
X509_NAME_ENTRY *
X509_NAME_ENTRY_new(void)
{
return (X509_NAME_ENTRY *)ASN1_item_new(&X509_NAME_ENTRY_it);
}
LCRYPTO_ALIAS(X509_NAME_ENTRY_new);
void
X509_NAME_ENTRY_free(X509_NAME_ENTRY *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_NAME_ENTRY_it);
}
LCRYPTO_ALIAS(X509_NAME_ENTRY_free);
X509_NAME_ENTRY *
X509_NAME_ENTRY_dup(X509_NAME_ENTRY *x)
{
return ASN1_item_dup(&X509_NAME_ENTRY_it, x);
}
LCRYPTO_ALIAS(X509_NAME_ENTRY_dup);
/* For the "Name" type we need a SEQUENCE OF { SET OF X509_NAME_ENTRY }
* so declare two template wrappers for this
@ -214,30 +219,35 @@ d2i_X509_NAME(X509_NAME **a, const unsigned char **in, long len)
return (X509_NAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_NAME_it);
}
LCRYPTO_ALIAS(d2i_X509_NAME);
int
i2d_X509_NAME(X509_NAME *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_NAME_it);
}
LCRYPTO_ALIAS(i2d_X509_NAME);
X509_NAME *
X509_NAME_new(void)
{
return (X509_NAME *)ASN1_item_new(&X509_NAME_it);
}
LCRYPTO_ALIAS(X509_NAME_new);
void
X509_NAME_free(X509_NAME *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_NAME_it);
}
LCRYPTO_ALIAS(X509_NAME_free);
X509_NAME *
X509_NAME_dup(X509_NAME *x)
{
return ASN1_item_dup(&X509_NAME_it, x);
}
LCRYPTO_ALIAS(X509_NAME_dup);
static int
x509_name_ex_new(ASN1_VALUE **val, const ASN1_ITEM *it)
@ -635,6 +645,7 @@ X509_NAME_set(X509_NAME **xn, X509_NAME *name)
*xn = name;
return 1;
}
LCRYPTO_ALIAS(X509_NAME_set);
int
X509_NAME_get0_der(X509_NAME *nm, const unsigned char **pder, size_t *pderlen)
@ -648,3 +659,4 @@ X509_NAME_get0_der(X509_NAME *nm, const unsigned char **pder, size_t *pderlen)
*pderlen = nm->bytes->length;
return 1;
}
LCRYPTO_ALIAS(X509_NAME_get0_der);

4
lib/libcrypto/asn1/x_pkey.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: x_pkey.c,v 1.21 2021/12/25 13:17:48 jsing Exp $ */
/* $OpenBSD: x_pkey.c,v 1.22 2023/07/05 21:23:37 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -98,6 +98,7 @@ X509_PKEY_new(void)
}
return NULL;
}
LCRYPTO_ALIAS(X509_PKEY_new);
void
X509_PKEY_free(X509_PKEY *x)
@ -119,3 +120,4 @@ X509_PKEY_free(X509_PKEY *x)
free(x->key_data);
free(x);
}
LCRYPTO_ALIAS(X509_PKEY_free);

35
lib/libcrypto/asn1/x_pubkey.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: x_pubkey.c,v 1.33 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: x_pubkey.c,v 1.34 2023/07/05 21:23:37 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -118,24 +118,28 @@ d2i_X509_PUBKEY(X509_PUBKEY **a, const unsigned char **in, long len)
return (X509_PUBKEY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_PUBKEY_it);
}
LCRYPTO_ALIAS(d2i_X509_PUBKEY);
int
i2d_X509_PUBKEY(X509_PUBKEY *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_PUBKEY_it);
}
LCRYPTO_ALIAS(i2d_X509_PUBKEY);
X509_PUBKEY *
X509_PUBKEY_new(void)
{
return (X509_PUBKEY *)ASN1_item_new(&X509_PUBKEY_it);
}
LCRYPTO_ALIAS(X509_PUBKEY_new);
void
X509_PUBKEY_free(X509_PUBKEY *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_PUBKEY_it);
}
LCRYPTO_ALIAS(X509_PUBKEY_free);
int
X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)
@ -174,6 +178,7 @@ X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)
X509_PUBKEY_free(pk);
return 0;
}
LCRYPTO_ALIAS(X509_PUBKEY_set);
EVP_PKEY *
X509_PUBKEY_get0(X509_PUBKEY *key)
@ -226,6 +231,7 @@ X509_PUBKEY_get0(X509_PUBKEY *key)
EVP_PKEY_free(ret);
return (NULL);
}
LCRYPTO_ALIAS(X509_PUBKEY_get0);
EVP_PKEY *
X509_PUBKEY_get(X509_PUBKEY *key)
@ -239,6 +245,7 @@ X509_PUBKEY_get(X509_PUBKEY *key)
return pkey;
}
LCRYPTO_ALIAS(X509_PUBKEY_get);
/*
* Decode an X509_PUBKEY into the specified key type.
@ -403,12 +410,14 @@ d2i_PUBKEY(EVP_PKEY **pkey, const unsigned char **in, long len)
return (EVP_PKEY *)ASN1_item_d2i((ASN1_VALUE **)pkey, in, len,
&EVP_PKEY_PUBKEY_it);
}
LCRYPTO_ALIAS(d2i_PUBKEY);
int
i2d_PUBKEY(EVP_PKEY *pkey, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)pkey, out, &EVP_PKEY_PUBKEY_it);
}
LCRYPTO_ALIAS(i2d_PUBKEY);
EVP_PKEY *
d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **pkey)
@ -416,12 +425,14 @@ d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **pkey)
return (EVP_PKEY *)ASN1_item_d2i_bio(&EVP_PKEY_PUBKEY_it, bp,
(ASN1_VALUE **)pkey);
}
LCRYPTO_ALIAS(d2i_PUBKEY_bio);
int
i2d_PUBKEY_bio(BIO *bp, EVP_PKEY *pkey)
{
return ASN1_item_i2d_bio(&EVP_PKEY_PUBKEY_it, bp, (ASN1_VALUE *)pkey);
}
LCRYPTO_ALIAS(i2d_PUBKEY_bio);
EVP_PKEY *
d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **pkey)
@ -429,12 +440,14 @@ d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **pkey)
return (EVP_PKEY *)ASN1_item_d2i_fp(&EVP_PKEY_PUBKEY_it, fp,
(ASN1_VALUE **)pkey);
}
LCRYPTO_ALIAS(d2i_PUBKEY_fp);
int
i2d_PUBKEY_fp(FILE *fp, EVP_PKEY *pkey)
{
return ASN1_item_i2d_fp(&EVP_PKEY_PUBKEY_it, fp, (ASN1_VALUE *)pkey);
}
LCRYPTO_ALIAS(i2d_PUBKEY_fp);
/*
* The following are equivalents but which return RSA and DSA keys.
@ -497,36 +510,42 @@ d2i_RSA_PUBKEY(RSA **rsa, const unsigned char **in, long len)
return (RSA *)ASN1_item_d2i((ASN1_VALUE **)rsa, in, len,
&RSA_PUBKEY_it);
}
LCRYPTO_ALIAS(d2i_RSA_PUBKEY);
int
i2d_RSA_PUBKEY(RSA *rsa, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)rsa, out, &RSA_PUBKEY_it);
}
LCRYPTO_ALIAS(i2d_RSA_PUBKEY);
RSA *
d2i_RSA_PUBKEY_bio(BIO *bp, RSA **rsa)
{
return (RSA *)ASN1_item_d2i_bio(&RSA_PUBKEY_it, bp, (ASN1_VALUE **)rsa);
}
LCRYPTO_ALIAS(d2i_RSA_PUBKEY_bio);
int
i2d_RSA_PUBKEY_bio(BIO *bp, RSA *rsa)
{
return ASN1_item_i2d_bio(&RSA_PUBKEY_it, bp, (ASN1_VALUE *)rsa);
}
LCRYPTO_ALIAS(i2d_RSA_PUBKEY_bio);
RSA *
d2i_RSA_PUBKEY_fp(FILE *fp, RSA **rsa)
{
return (RSA *)ASN1_item_d2i_fp(&RSA_PUBKEY_it, fp, (ASN1_VALUE **)rsa);
}
LCRYPTO_ALIAS(d2i_RSA_PUBKEY_fp);
int
i2d_RSA_PUBKEY_fp(FILE *fp, RSA *rsa)
{
return ASN1_item_i2d_fp(&RSA_PUBKEY_it, fp, (ASN1_VALUE *)rsa);
}
LCRYPTO_ALIAS(i2d_RSA_PUBKEY_fp);
#endif
#ifndef OPENSSL_NO_DSA
@ -587,36 +606,42 @@ d2i_DSA_PUBKEY(DSA **dsa, const unsigned char **in, long len)
return (DSA *)ASN1_item_d2i((ASN1_VALUE **)dsa, in, len,
&DSA_PUBKEY_it);
}
LCRYPTO_ALIAS(d2i_DSA_PUBKEY);
int
i2d_DSA_PUBKEY(DSA *dsa, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)dsa, out, &DSA_PUBKEY_it);
}
LCRYPTO_ALIAS(i2d_DSA_PUBKEY);
DSA *
d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa)
{
return (DSA *)ASN1_item_d2i_bio(&DSA_PUBKEY_it, bp, (ASN1_VALUE **)dsa);
}
LCRYPTO_ALIAS(d2i_DSA_PUBKEY_bio);
int
i2d_DSA_PUBKEY_bio(BIO *bp, DSA *dsa)
{
return ASN1_item_i2d_bio(&DSA_PUBKEY_it, bp, (ASN1_VALUE *)dsa);
}
LCRYPTO_ALIAS(i2d_DSA_PUBKEY_bio);
DSA *
d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa)
{
return (DSA *)ASN1_item_d2i_fp(&DSA_PUBKEY_it, fp, (ASN1_VALUE **)dsa);
}
LCRYPTO_ALIAS(d2i_DSA_PUBKEY_fp);
int
i2d_DSA_PUBKEY_fp(FILE *fp, DSA *dsa)
{
return ASN1_item_i2d_fp(&DSA_PUBKEY_it, fp, (ASN1_VALUE *)dsa);
}
LCRYPTO_ALIAS(i2d_DSA_PUBKEY_fp);
#endif
@ -678,36 +703,42 @@ d2i_EC_PUBKEY(EC_KEY **ec, const unsigned char **in, long len)
return (EC_KEY *)ASN1_item_d2i((ASN1_VALUE **)ec, in, len,
&EC_PUBKEY_it);
}
LCRYPTO_ALIAS(d2i_EC_PUBKEY);
int
i2d_EC_PUBKEY(EC_KEY *ec, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)ec, out, &EC_PUBKEY_it);
}
LCRYPTO_ALIAS(i2d_EC_PUBKEY);
EC_KEY *
d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **ec)
{
return (EC_KEY *)ASN1_item_d2i_bio(&EC_PUBKEY_it, bp, (ASN1_VALUE **)ec);
}
LCRYPTO_ALIAS(d2i_EC_PUBKEY_bio);
int
i2d_EC_PUBKEY_bio(BIO *bp, EC_KEY *ec)
{
return ASN1_item_i2d_bio(&EC_PUBKEY_it, bp, (ASN1_VALUE *)ec);
}
LCRYPTO_ALIAS(i2d_EC_PUBKEY_bio);
EC_KEY *
d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **ec)
{
return (EC_KEY *)ASN1_item_d2i_fp(&EC_PUBKEY_it, fp, (ASN1_VALUE **)ec);
}
LCRYPTO_ALIAS(d2i_EC_PUBKEY_fp);
int
i2d_EC_PUBKEY_fp(FILE *fp, EC_KEY *ec)
{
return ASN1_item_i2d_fp(&EC_PUBKEY_it, fp, (ASN1_VALUE *)ec);
}
LCRYPTO_ALIAS(i2d_EC_PUBKEY_fp);
#endif
int
@ -724,6 +755,7 @@ X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj, int ptype,
return asn1_abs_set_unused_bits(pub->public_key, 0);
}
LCRYPTO_ALIAS(X509_PUBKEY_set0_param);
int
X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg, const unsigned char **pk,
@ -739,3 +771,4 @@ X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg, const unsigned char **pk,
*pa = pub->algor;
return 1;
}
LCRYPTO_ALIAS(X509_PUBKEY_get0_param);

13
lib/libcrypto/asn1/x_req.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: x_req.c,v 1.19 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: x_req.c,v 1.20 2023/07/05 21:23:37 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -143,24 +143,28 @@ d2i_X509_REQ_INFO(X509_REQ_INFO **a, const unsigned char **in, long len)
return (X509_REQ_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_REQ_INFO_it);
}
LCRYPTO_ALIAS(d2i_X509_REQ_INFO);
int
i2d_X509_REQ_INFO(X509_REQ_INFO *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_REQ_INFO_it);
}
LCRYPTO_ALIAS(i2d_X509_REQ_INFO);
X509_REQ_INFO *
X509_REQ_INFO_new(void)
{
return (X509_REQ_INFO *)ASN1_item_new(&X509_REQ_INFO_it);
}
LCRYPTO_ALIAS(X509_REQ_INFO_new);
void
X509_REQ_INFO_free(X509_REQ_INFO *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_REQ_INFO_it);
}
LCRYPTO_ALIAS(X509_REQ_INFO_free);
static const ASN1_AUX X509_REQ_aux = {
.app_data = NULL,
@ -203,36 +207,42 @@ d2i_X509_REQ(X509_REQ **a, const unsigned char **in, long len)
return (X509_REQ *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_REQ_it);
}
LCRYPTO_ALIAS(d2i_X509_REQ);
int
i2d_X509_REQ(X509_REQ *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_REQ_it);
}
LCRYPTO_ALIAS(i2d_X509_REQ);
X509_REQ *
X509_REQ_new(void)
{
return (X509_REQ *)ASN1_item_new(&X509_REQ_it);
}
LCRYPTO_ALIAS(X509_REQ_new);
void
X509_REQ_free(X509_REQ *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_REQ_it);
}
LCRYPTO_ALIAS(X509_REQ_free);
X509_REQ *
X509_REQ_dup(X509_REQ *x)
{
return ASN1_item_dup(&X509_REQ_it, x);
}
LCRYPTO_ALIAS(X509_REQ_dup);
int
X509_REQ_get_signature_nid(const X509_REQ *req)
{
return OBJ_obj2nid(req->sig_alg->algorithm);
}
LCRYPTO_ALIAS(X509_REQ_get_signature_nid);
void
X509_REQ_get0_signature(const X509_REQ *req, const ASN1_BIT_STRING **psig,
@ -243,3 +253,4 @@ X509_REQ_get0_signature(const X509_REQ *req, const ASN1_BIT_STRING **psig,
if (palg != NULL)
*palg = req->sig_alg;
}
LCRYPTO_ALIAS(X509_REQ_get0_signature);

8
lib/libcrypto/asn1/x_sig.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: x_sig.c,v 1.14 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: x_sig.c,v 1.15 2023/07/05 21:23:37 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -92,24 +92,28 @@ d2i_X509_SIG(X509_SIG **a, const unsigned char **in, long len)
return (X509_SIG *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_SIG_it);
}
LCRYPTO_ALIAS(d2i_X509_SIG);
int
i2d_X509_SIG(X509_SIG *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_SIG_it);
}
LCRYPTO_ALIAS(i2d_X509_SIG);
X509_SIG *
X509_SIG_new(void)
{
return (X509_SIG *)ASN1_item_new(&X509_SIG_it);
}
LCRYPTO_ALIAS(X509_SIG_new);
void
X509_SIG_free(X509_SIG *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_SIG_it);
}
LCRYPTO_ALIAS(X509_SIG_free);
void
X509_SIG_get0(const X509_SIG *sig, const X509_ALGOR **palg,
@ -120,6 +124,7 @@ X509_SIG_get0(const X509_SIG *sig, const X509_ALGOR **palg,
if (pdigest != NULL)
*pdigest = sig->digest;
}
LCRYPTO_ALIAS(X509_SIG_get0);
void
X509_SIG_getm(X509_SIG *sig, X509_ALGOR **palg, ASN1_OCTET_STRING **pdigest)
@ -129,3 +134,4 @@ X509_SIG_getm(X509_SIG *sig, X509_ALGOR **palg, ASN1_OCTET_STRING **pdigest)
if (pdigest != NULL)
*pdigest = sig->digest;
}
LCRYPTO_ALIAS(X509_SIG_getm);

10
lib/libcrypto/asn1/x_spki.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: x_spki.c,v 1.11 2015/02/11 04:00:39 jsing Exp $ */
/* $OpenBSD: x_spki.c,v 1.12 2023/07/05 21:23:37 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -94,24 +94,28 @@ d2i_NETSCAPE_SPKAC(NETSCAPE_SPKAC **a, const unsigned char **in, long len)
return (NETSCAPE_SPKAC *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&NETSCAPE_SPKAC_it);
}
LCRYPTO_ALIAS(d2i_NETSCAPE_SPKAC);
int
i2d_NETSCAPE_SPKAC(NETSCAPE_SPKAC *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &NETSCAPE_SPKAC_it);
}
LCRYPTO_ALIAS(i2d_NETSCAPE_SPKAC);
NETSCAPE_SPKAC *
NETSCAPE_SPKAC_new(void)
{
return (NETSCAPE_SPKAC *)ASN1_item_new(&NETSCAPE_SPKAC_it);
}
LCRYPTO_ALIAS(NETSCAPE_SPKAC_new);
void
NETSCAPE_SPKAC_free(NETSCAPE_SPKAC *a)
{
ASN1_item_free((ASN1_VALUE *)a, &NETSCAPE_SPKAC_it);
}
LCRYPTO_ALIAS(NETSCAPE_SPKAC_free);
static const ASN1_TEMPLATE NETSCAPE_SPKI_seq_tt[] = {
{
@ -154,21 +158,25 @@ d2i_NETSCAPE_SPKI(NETSCAPE_SPKI **a, const unsigned char **in, long len)
return (NETSCAPE_SPKI *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&NETSCAPE_SPKI_it);
}
LCRYPTO_ALIAS(d2i_NETSCAPE_SPKI);
int
i2d_NETSCAPE_SPKI(NETSCAPE_SPKI *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &NETSCAPE_SPKI_it);
}
LCRYPTO_ALIAS(i2d_NETSCAPE_SPKI);
NETSCAPE_SPKI *
NETSCAPE_SPKI_new(void)
{
return (NETSCAPE_SPKI *)ASN1_item_new(&NETSCAPE_SPKI_it);
}
LCRYPTO_ALIAS(NETSCAPE_SPKI_new);
void
NETSCAPE_SPKI_free(NETSCAPE_SPKI *a)
{
ASN1_item_free((ASN1_VALUE *)a, &NETSCAPE_SPKI_it);
}
LCRYPTO_ALIAS(NETSCAPE_SPKI_free);

6
lib/libcrypto/asn1/x_val.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: x_val.c,v 1.11 2015/02/11 04:00:39 jsing Exp $ */
/* $OpenBSD: x_val.c,v 1.12 2023/07/05 21:23:37 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -90,21 +90,25 @@ d2i_X509_VAL(X509_VAL **a, const unsigned char **in, long len)
return (X509_VAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_VAL_it);
}
LCRYPTO_ALIAS(d2i_X509_VAL);
int
i2d_X509_VAL(X509_VAL *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_VAL_it);
}
LCRYPTO_ALIAS(i2d_X509_VAL);
X509_VAL *
X509_VAL_new(void)
{
return (X509_VAL *)ASN1_item_new(&X509_VAL_it);
}
LCRYPTO_ALIAS(X509_VAL_new);
void
X509_VAL_free(X509_VAL *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_VAL_it);
}
LCRYPTO_ALIAS(X509_VAL_free);

19
lib/libcrypto/asn1/x_x509.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: x_x509.c,v 1.35 2023/04/28 16:30:14 tb Exp $ */
/* $OpenBSD: x_x509.c,v 1.36 2023/07/05 21:23:37 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -149,24 +149,28 @@ d2i_X509_CINF(X509_CINF **a, const unsigned char **in, long len)
return (X509_CINF *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_CINF_it);
}
LCRYPTO_ALIAS(d2i_X509_CINF);
int
i2d_X509_CINF(X509_CINF *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_CINF_it);
}
LCRYPTO_ALIAS(i2d_X509_CINF);
X509_CINF *
X509_CINF_new(void)
{
return (X509_CINF *)ASN1_item_new(&X509_CINF_it);
}
LCRYPTO_ALIAS(X509_CINF_new);
void
X509_CINF_free(X509_CINF *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_CINF_it);
}
LCRYPTO_ALIAS(X509_CINF_free);
/* X509 top level structure needs a bit of customisation */
static int
@ -259,30 +263,35 @@ d2i_X509(X509 **a, const unsigned char **in, long len)
return (X509 *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_it);
}
LCRYPTO_ALIAS(d2i_X509);
int
i2d_X509(X509 *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_it);
}
LCRYPTO_ALIAS(i2d_X509);
X509 *
X509_new(void)
{
return (X509 *)ASN1_item_new(&X509_it);
}
LCRYPTO_ALIAS(X509_new);
void
X509_free(X509 *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_it);
}
LCRYPTO_ALIAS(X509_free);
X509 *
X509_dup(X509 *x)
{
return ASN1_item_dup(&X509_it, x);
}
LCRYPTO_ALIAS(X509_dup);
int
X509_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
@ -291,18 +300,21 @@ X509_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509, argl, argp,
new_func, dup_func, free_func);
}
LCRYPTO_ALIAS(X509_get_ex_new_index);
int
X509_set_ex_data(X509 *r, int idx, void *arg)
{
return (CRYPTO_set_ex_data(&r->ex_data, idx, arg));
}
LCRYPTO_ALIAS(X509_set_ex_data);
void *
X509_get_ex_data(X509 *r, int idx)
{
return (CRYPTO_get_ex_data(&r->ex_data, idx));
}
LCRYPTO_ALIAS(X509_get_ex_data);
/* X509_AUX ASN1 routines. X509_AUX is the name given to
* a certificate with extra info tagged on the end. Since these
@ -340,6 +352,7 @@ d2i_X509_AUX(X509 **a, const unsigned char **pp, long length)
X509_free(ret);
return NULL;
}
LCRYPTO_ALIAS(d2i_X509_AUX);
int
i2d_X509_AUX(X509 *a, unsigned char **pp)
@ -351,6 +364,7 @@ i2d_X509_AUX(X509 *a, unsigned char **pp)
length += i2d_X509_CERT_AUX(a->aux, pp);
return length;
}
LCRYPTO_ALIAS(i2d_X509_AUX);
int
i2d_re_X509_tbs(X509 *x, unsigned char **pp)
@ -358,6 +372,7 @@ i2d_re_X509_tbs(X509 *x, unsigned char **pp)
x->cert_info->enc.modified = 1;
return i2d_X509_CINF(x->cert_info, pp);
}
LCRYPTO_ALIAS(i2d_re_X509_tbs);
void
X509_get0_signature(const ASN1_BIT_STRING **psig, const X509_ALGOR **palg,
@ -368,9 +383,11 @@ X509_get0_signature(const ASN1_BIT_STRING **psig, const X509_ALGOR **palg,
if (palg != NULL)
*palg = x->sig_alg;
}
LCRYPTO_ALIAS(X509_get0_signature);
int
X509_get_signature_nid(const X509 *x)
{
return OBJ_obj2nid(x->sig_alg->algorithm);
}
LCRYPTO_ALIAS(X509_get_signature_nid);

14
lib/libcrypto/asn1/x_x509a.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: x_x509a.c,v 1.19 2022/11/26 16:08:50 tb Exp $ */
/* $OpenBSD: x_x509a.c,v 1.20 2023/07/05 21:23:37 beck Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
* project 1999.
*/
@ -126,24 +126,28 @@ d2i_X509_CERT_AUX(X509_CERT_AUX **a, const unsigned char **in, long len)
return (X509_CERT_AUX *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
&X509_CERT_AUX_it);
}
LCRYPTO_ALIAS(d2i_X509_CERT_AUX);
int
i2d_X509_CERT_AUX(X509_CERT_AUX *a, unsigned char **out)
{
return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_CERT_AUX_it);
}
LCRYPTO_ALIAS(i2d_X509_CERT_AUX);
X509_CERT_AUX *
X509_CERT_AUX_new(void)
{
return (X509_CERT_AUX *)ASN1_item_new(&X509_CERT_AUX_it);
}
LCRYPTO_ALIAS(X509_CERT_AUX_new);
void
X509_CERT_AUX_free(X509_CERT_AUX *a)
{
ASN1_item_free((ASN1_VALUE *)a, &X509_CERT_AUX_it);
}
LCRYPTO_ALIAS(X509_CERT_AUX_free);
static X509_CERT_AUX *
aux_get(X509 *x)
@ -172,6 +176,7 @@ X509_alias_set1(X509 *x, const unsigned char *name, int len)
return 0;
return ASN1_STRING_set(aux->alias, name, len);
}
LCRYPTO_ALIAS(X509_alias_set1);
int
X509_keyid_set1(X509 *x, const unsigned char *id, int len)
@ -190,6 +195,7 @@ X509_keyid_set1(X509 *x, const unsigned char *id, int len)
return 0;
return ASN1_STRING_set(aux->keyid, id, len);
}
LCRYPTO_ALIAS(X509_keyid_set1);
unsigned char *
X509_alias_get0(X509 *x, int *len)
@ -200,6 +206,7 @@ X509_alias_get0(X509 *x, int *len)
*len = x->aux->alias->length;
return x->aux->alias->data;
}
LCRYPTO_ALIAS(X509_alias_get0);
unsigned char *
X509_keyid_get0(X509 *x, int *len)
@ -210,6 +217,7 @@ X509_keyid_get0(X509 *x, int *len)
*len = x->aux->keyid->length;
return x->aux->keyid->data;
}
LCRYPTO_ALIAS(X509_keyid_get0);
int
X509_add1_trust_object(X509 *x, const ASN1_OBJECT *obj)
@ -232,6 +240,7 @@ X509_add1_trust_object(X509 *x, const ASN1_OBJECT *obj)
ASN1_OBJECT_free(objtmp);
return 0;
}
LCRYPTO_ALIAS(X509_add1_trust_object);
int
X509_add1_reject_object(X509 *x, const ASN1_OBJECT *obj)
@ -254,6 +263,7 @@ X509_add1_reject_object(X509 *x, const ASN1_OBJECT *obj)
ASN1_OBJECT_free(objtmp);
return 0;
}
LCRYPTO_ALIAS(X509_add1_reject_object);
void
X509_trust_clear(X509 *x)
@ -263,6 +273,7 @@ X509_trust_clear(X509 *x)
x->aux->trust = NULL;
}
}
LCRYPTO_ALIAS(X509_trust_clear);
void
X509_reject_clear(X509 *x)
@ -272,3 +283,4 @@ X509_reject_clear(X509 *x)
x->aux->reject = NULL;
}
}
LCRYPTO_ALIAS(X509_reject_clear);

8
lib/libcrypto/bio/b_dump.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: b_dump.c,v 1.23 2022/10/17 18:26:41 jsing Exp $ */
/* $OpenBSD: b_dump.c,v 1.24 2023/07/05 21:23:37 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -75,6 +75,7 @@ BIO_dump_cb(int (*cb)(const void *data, size_t len, void *u),
{
return BIO_dump_indent_cb(cb, u, s, len, 0);
}
LCRYPTO_ALIAS(BIO_dump_cb);
int
BIO_dump_indent_cb(int (*cb)(const void *data, size_t len, void *u),
@ -148,6 +149,7 @@ BIO_dump_indent_cb(int (*cb)(const void *data, size_t len, void *u),
#endif
return (ret);
}
LCRYPTO_ALIAS(BIO_dump_indent_cb);
static int
write_fp(const void *data, size_t len, void *fp)
@ -160,12 +162,14 @@ BIO_dump_fp(FILE *fp, const char *s, int len)
{
return BIO_dump_cb(write_fp, fp, s, len);
}
LCRYPTO_ALIAS(BIO_dump_fp);
int
BIO_dump_indent_fp(FILE *fp, const char *s, int len, int indent)
{
return BIO_dump_indent_cb(write_fp, fp, s, len, indent);
}
LCRYPTO_ALIAS(BIO_dump_indent_fp);
static int
write_bio(const void *data, size_t len, void *bp)
@ -178,9 +182,11 @@ BIO_dump(BIO *bp, const char *s, int len)
{
return BIO_dump_cb(write_bio, bp, s, len);
}
LCRYPTO_ALIAS(BIO_dump);
int
BIO_dump_indent(BIO *bp, const char *s, int len, int indent)
{
return BIO_dump_indent_cb(write_bio, bp, s, len, indent);
}
LCRYPTO_ALIAS(BIO_dump_indent);

5
lib/libcrypto/bio/b_posix.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: b_posix.c,v 1.2 2018/03/17 16:20:01 beck Exp $ */
/* $OpenBSD: b_posix.c,v 1.3 2023/07/05 21:23:37 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -72,11 +72,13 @@ BIO_sock_init(void)
return (0);
return (1);
}
LCRYPTO_ALIAS(BIO_sock_init);
void
BIO_sock_cleanup(void)
{
}
LCRYPTO_ALIAS(BIO_sock_cleanup);
int
BIO_socket_nbio(int s, int mode)
@ -88,3 +90,4 @@ BIO_socket_nbio(int s, int mode)
return (fcntl(s, F_SETFL, flags & ~O_NONBLOCK) != -1);
return (1);
}
LCRYPTO_ALIAS(BIO_socket_nbio);

7
lib/libcrypto/bio/b_print.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: b_print.c,v 1.26 2019/06/28 05:47:57 deraadt Exp $ */
/* $OpenBSD: b_print.c,v 1.27 2023/07/05 21:23:37 beck Exp $ */
/* Theo de Raadt places this file in the public domain. */
@ -15,6 +15,7 @@ BIO_printf(BIO *bio, const char *format, ...)
va_end(args);
return (ret);
}
LCRYPTO_ALIAS(BIO_printf);
#ifdef HAVE_FUNOPEN
static int
@ -39,6 +40,7 @@ BIO_vprintf(BIO *bio, const char *format, va_list args)
fail:
return (ret);
}
LCRYPTO_ALIAS(BIO_vprintf);
#else /* !HAVE_FUNOPEN */
@ -55,6 +57,7 @@ BIO_vprintf(BIO *bio, const char *format, va_list args)
free(buf);
return (ret);
}
LCRYPTO_ALIAS(BIO_vprintf);
#endif /* HAVE_FUNOPEN */
@ -92,6 +95,7 @@ BIO_snprintf(char *buf, size_t n, const char *format, ...)
return (-1);
return (ret);
}
LCRYPTO_ALIAS(BIO_snprintf);
int
BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
@ -104,3 +108,4 @@ BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
return (-1);
return (ret);
}
LCRYPTO_ALIAS(BIO_vsnprintf);

10
lib/libcrypto/bio/b_sock.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: b_sock.c,v 1.70 2022/12/22 20:13:45 schwarze Exp $ */
/* $OpenBSD: b_sock.c,v 1.71 2023/07/05 21:23:37 beck Exp $ */
/*
* Copyright (c) 2017 Bob Beck <beck@openbsd.org>
*
@ -62,6 +62,7 @@ BIO_get_host_ip(const char *str, unsigned char *ip)
freeaddrinfo(res);
return (1);
}
LCRYPTO_ALIAS(BIO_get_host_ip);
int
BIO_get_port(const char *str, unsigned short *port_ptr)
@ -89,6 +90,7 @@ BIO_get_port(const char *str, unsigned short *port_ptr)
freeaddrinfo(res);
return (1);
}
LCRYPTO_ALIAS(BIO_get_port);
int
BIO_sock_error(int sock)
@ -101,12 +103,14 @@ BIO_sock_error(int sock)
return (1);
return (err);
}
LCRYPTO_ALIAS(BIO_sock_error);
struct hostent *
BIO_gethostbyname(const char *name)
{
return gethostbyname(name);
}
LCRYPTO_ALIAS(BIO_gethostbyname);
int
BIO_socket_ioctl(int fd, long type, void *arg)
@ -118,6 +122,7 @@ BIO_socket_ioctl(int fd, long type, void *arg)
SYSerror(errno);
return (ret);
}
LCRYPTO_ALIAS(BIO_socket_ioctl);
int
BIO_get_accept_socket(char *host, int bind_mode)
@ -203,6 +208,7 @@ err:
}
return (s);
}
LCRYPTO_ALIAS(BIO_get_accept_socket);
int
BIO_accept(int sock, char **addr)
@ -245,9 +251,11 @@ BIO_accept(int sock, char **addr)
end:
return (ret);
}
LCRYPTO_ALIAS(BIO_accept);
int
BIO_set_tcp_ndelay(int s, int on)
{
return (setsockopt(s, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on)) == 0);
}
LCRYPTO_ALIAS(BIO_set_tcp_ndelay);

3
lib/libcrypto/bio/bf_buff.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: bf_buff.c,v 1.27 2022/01/14 08:40:57 tb Exp $ */
/* $OpenBSD: bf_buff.c,v 1.28 2023/07/05 21:23:37 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -93,6 +93,7 @@ BIO_f_buffer(void)
{
return (&methods_buffer);
}
LCRYPTO_ALIAS(BIO_f_buffer);
static int
buffer_new(BIO *bi)

3
lib/libcrypto/bio/bf_nbio.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: bf_nbio.c,v 1.22 2022/01/14 08:40:57 tb Exp $ */
/* $OpenBSD: bf_nbio.c,v 1.23 2023/07/05 21:23:37 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -100,6 +100,7 @@ BIO_f_nbio_test(void)
{
return (&methods_nbiof);
}
LCRYPTO_ALIAS(BIO_f_nbio_test);
static int
nbiof_new(BIO *bi)

3
lib/libcrypto/bio/bf_null.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: bf_null.c,v 1.14 2022/01/14 08:40:57 tb Exp $ */
/* $OpenBSD: bf_null.c,v 1.15 2023/07/05 21:23:37 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -93,6 +93,7 @@ BIO_f_null(void)
{
return (&methods_nullf);
}
LCRYPTO_ALIAS(BIO_f_null);
static int
nullf_new(BIO *bi)

42
lib/libcrypto/bio/bio.h
View File

@ -1,4 +1,4 @@
/* $OpenBSD: bio.h,v 1.56 2022/09/11 17:26:03 tb Exp $ */
/* $OpenBSD: bio.h,v 1.58 2023/07/05 19:25:01 tb Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -255,7 +255,7 @@ void BIO_clear_flags(BIO *b, int flags);
* the BIO_CB_RETURN flag indicates if it is after the call.
*/
#define BIO_CB_RETURN 0x80
#define BIO_CB_return(a) ((a)|BIO_CB_RETURN))
#define BIO_CB_return(a) ((a)|BIO_CB_RETURN)
#define BIO_cb_pre(a) (!((a)&BIO_CB_RETURN))
#define BIO_cb_post(a) ((a)&BIO_CB_RETURN)
@ -536,17 +536,13 @@ unsigned long BIO_number_read(BIO *bio);
unsigned long BIO_number_written(BIO *bio);
/* For BIO_f_asn1() */
int
BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix,
int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix,
asn1_ps_func *prefix_free);
int
BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix,
int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix,
asn1_ps_func **pprefix_free);
int
BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix,
int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix,
asn1_ps_func *suffix_free);
int
BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix,
int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix,
asn1_ps_func **psuffix_free);
int BIO_get_new_index(void);
@ -667,20 +663,30 @@ void BIO_copy_next_retry(BIO *b);
/*long BIO_ghbn_ctrl(int cmd,int iarg,char *parg);*/
int
BIO_printf(BIO *bio, const char *format, ...)
/* Needed for libressl-portable. */
#ifndef __MINGW_PRINTF_FORMAT
int BIO_printf(BIO *bio, const char *format, ...)
__attribute__((__format__(__printf__, 2, 3), __nonnull__(2)));
int
BIO_vprintf(BIO *bio, const char *format, va_list args)
int BIO_vprintf(BIO *bio, const char *format, va_list args)
__attribute__((__format__(__printf__, 2, 0), __nonnull__(2)));
int
BIO_snprintf(char *buf, size_t n, const char *format, ...)
int BIO_snprintf(char *buf, size_t n, const char *format, ...)
__attribute__((__deprecated__, __format__(__printf__, 3, 4),
__nonnull__(3)));
int
BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
__attribute__((__deprecated__, __format__(__printf__, 3, 0),
__nonnull__(3)));
#else
int BIO_printf(BIO *bio, const char *format, ...)
__attribute__((__format__(__MINGW_PRINTF_FORMAT, 2, 3), __nonnull__(2)));
int BIO_vprintf(BIO *bio, const char *format, va_list args)
__attribute__((__format__(__MINGW_PRINTF_FORMAT, 2, 0), __nonnull__(2)));
int BIO_snprintf(char *buf, size_t n, const char *format, ...)
__attribute__((__deprecated__, __format__(__MINGW_PRINTF_FORMAT, 3, 4),
__nonnull__(3)));
int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
__attribute__((__deprecated__, __format__(__MINGW_PRINTF_FORMAT, 3, 0),
__nonnull__(3)));
#endif
void ERR_load_BIO_strings(void);

3
lib/libcrypto/bio/bio_cb.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: bio_cb.c,v 1.18 2022/01/07 09:02:17 tb Exp $ */
/* $OpenBSD: bio_cb.c,v 1.19 2023/07/05 21:23:37 beck Exp $ */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
@ -153,3 +153,4 @@ BIO_debug_callback(BIO *bio, int cmd, const char *argp, int argi, long argl,
fputs(buf, stderr);
return (r);
}
LCRYPTO_ALIAS(BIO_debug_callback);

3
lib/libcrypto/bio/bio_err.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: bio_err.c,v 1.19 2022/07/12 14:42:48 kn Exp $ */
/* $OpenBSD: bio_err.c,v 1.20 2023/07/05 21:23:37 beck Exp $ */
/* ====================================================================
* Copyright (c) 1999-2011 The OpenSSL Project. All rights reserved.
*
@ -117,3 +117,4 @@ ERR_load_BIO_strings(void)
}
#endif
}
LCRYPTO_ALIAS(ERR_load_BIO_strings);

52
lib/libcrypto/bio/bio_lib.c
View File

@ -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);

20
lib/libcrypto/bio/bio_meth.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: bio_meth.c,v 1.8 2022/01/14 08:40:57 tb Exp $ */
/* $OpenBSD: bio_meth.c,v 1.9 2023/07/05 21:23:37 beck Exp $ */
/*
* Copyright (c) 2018 Theo Buehler <tb@openbsd.org>
*
@ -34,18 +34,21 @@ BIO_meth_new(int type, const char *name)
return biom;
}
LCRYPTO_ALIAS(BIO_meth_new);
void
BIO_meth_free(BIO_METHOD *biom)
{
free(biom);
}
LCRYPTO_ALIAS(BIO_meth_free);
int
(*BIO_meth_get_write(const BIO_METHOD *biom))(BIO *, const char *, int)
{
return biom->bwrite;
}
LCRYPTO_ALIAS(BIO_meth_get_write);
int
BIO_meth_set_write(BIO_METHOD *biom, int (*write)(BIO *, const char *, int))
@ -53,12 +56,14 @@ BIO_meth_set_write(BIO_METHOD *biom, int (*write)(BIO *, const char *, int))
biom->bwrite = write;
return 1;
}
LCRYPTO_ALIAS(BIO_meth_set_write);
int
(*BIO_meth_get_read(const BIO_METHOD *biom))(BIO *, char *, int)
{
return biom->bread;
}
LCRYPTO_ALIAS(BIO_meth_get_read);
int
BIO_meth_set_read(BIO_METHOD *biom, int (*read)(BIO *, char *, int))
@ -66,12 +71,14 @@ BIO_meth_set_read(BIO_METHOD *biom, int (*read)(BIO *, char *, int))
biom->bread = read;
return 1;
}
LCRYPTO_ALIAS(BIO_meth_set_read);
int
(*BIO_meth_get_puts(const BIO_METHOD *biom))(BIO *, const char *)
{
return biom->bputs;
}
LCRYPTO_ALIAS(BIO_meth_get_puts);
int
BIO_meth_set_puts(BIO_METHOD *biom, int (*puts)(BIO *, const char *))
@ -79,12 +86,14 @@ BIO_meth_set_puts(BIO_METHOD *biom, int (*puts)(BIO *, const char *))
biom->bputs = puts;
return 1;
}
LCRYPTO_ALIAS(BIO_meth_set_puts);
int
(*BIO_meth_get_gets(const BIO_METHOD *biom))(BIO *, char *, int)
{
return biom->bgets;
}
LCRYPTO_ALIAS(BIO_meth_get_gets);
int
BIO_meth_set_gets(BIO_METHOD *biom, int (*gets)(BIO *, char *, int))
@ -92,12 +101,14 @@ BIO_meth_set_gets(BIO_METHOD *biom, int (*gets)(BIO *, char *, int))
biom->bgets = gets;
return 1;
}
LCRYPTO_ALIAS(BIO_meth_set_gets);
long
(*BIO_meth_get_ctrl(const BIO_METHOD *biom))(BIO *, int, long, void *)
{
return biom->ctrl;
}
LCRYPTO_ALIAS(BIO_meth_get_ctrl);
int
BIO_meth_set_ctrl(BIO_METHOD *biom, long (*ctrl)(BIO *, int, long, void *))
@ -105,12 +116,14 @@ BIO_meth_set_ctrl(BIO_METHOD *biom, long (*ctrl)(BIO *, int, long, void *))
biom->ctrl = ctrl;
return 1;
}
LCRYPTO_ALIAS(BIO_meth_set_ctrl);
int
(*BIO_meth_get_create(const BIO_METHOD *biom))(BIO *)
{
return biom->create;
}
LCRYPTO_ALIAS(BIO_meth_get_create);
int
BIO_meth_set_create(BIO_METHOD *biom, int (*create)(BIO *))
@ -118,12 +131,14 @@ BIO_meth_set_create(BIO_METHOD *biom, int (*create)(BIO *))
biom->create = create;
return 1;
}
LCRYPTO_ALIAS(BIO_meth_set_create);
int
(*BIO_meth_get_destroy(const BIO_METHOD *biom))(BIO *)
{
return biom->destroy;
}
LCRYPTO_ALIAS(BIO_meth_get_destroy);
int
BIO_meth_set_destroy(BIO_METHOD *biom, int (*destroy)(BIO *))
@ -131,12 +146,14 @@ BIO_meth_set_destroy(BIO_METHOD *biom, int (*destroy)(BIO *))
biom->destroy = destroy;
return 1;
}
LCRYPTO_ALIAS(BIO_meth_set_destroy);
long
(*BIO_meth_get_callback_ctrl(const BIO_METHOD *biom))(BIO *, int, BIO_info_cb *)
{
return biom->callback_ctrl;
}
LCRYPTO_ALIAS(BIO_meth_get_callback_ctrl);
int
BIO_meth_set_callback_ctrl(BIO_METHOD *biom,
@ -145,3 +162,4 @@ BIO_meth_set_callback_ctrl(BIO_METHOD *biom,
biom->callback_ctrl = callback_ctrl;
return 1;
}
LCRYPTO_ALIAS(BIO_meth_set_callback_ctrl);

Some files were not shown because too many files have changed in this diff Show More