mirror of
https://github.com/openssl/openssl.git
synced 2024-12-03 05:41:46 +08:00
e077455e9e
Since OPENSSL_malloc() and friends report ERR_R_MALLOC_FAILURE, and
at least handle the file name and line number they are called from,
there's no need to report ERR_R_MALLOC_FAILURE where they are called
directly, or when SSLfatal() and RLAYERfatal() is used, the reason
`ERR_R_MALLOC_FAILURE` is changed to `ERR_R_CRYPTO_LIB`.
There were a number of places where `ERR_R_MALLOC_FAILURE` was reported
even though it was a function from a different sub-system that was
called. Those places are changed to report ERR_R_{lib}_LIB, where
{lib} is the name of that sub-system.
Some of them are tricky to get right, as we have a lot of functions
that belong in the ASN1 sub-system, and all the `sk_` calls or from
the CRYPTO sub-system.
Some extra adaptation was necessary where there were custom OPENSSL_malloc()
wrappers, and some bugs are fixed alongside these changes.
Reviewed-by: Tomas Mraz <tomas@openssl.org>
Reviewed-by: Hugo Landau <hlandau@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/19301)
135 lines
3.2 KiB
C
135 lines
3.2 KiB
C
/*
|
|
* Copyright 2015-2022 The OpenSSL Project Authors. All Rights Reserved.
|
|
*
|
|
* Licensed under the Apache License 2.0 (the "License"). You may not use
|
|
* this file except in compliance with the License. You can obtain a copy
|
|
* in the file LICENSE in the source distribution or at
|
|
* https://www.openssl.org/source/license.html
|
|
*/
|
|
|
|
/* This must be the first #include file */
|
|
#include "../async_local.h"
|
|
|
|
#ifdef ASYNC_POSIX
|
|
|
|
# include <stddef.h>
|
|
# include <unistd.h>
|
|
# include <openssl/err.h>
|
|
# include <openssl/crypto.h>
|
|
|
|
#define STACKSIZE 32768
|
|
|
|
static CRYPTO_RWLOCK *async_mem_lock;
|
|
|
|
static void *async_stack_alloc(size_t *num);
|
|
static void async_stack_free(void *addr);
|
|
|
|
int async_local_init(void)
|
|
{
|
|
async_mem_lock = CRYPTO_THREAD_lock_new();
|
|
return async_mem_lock != NULL;
|
|
}
|
|
|
|
void async_local_deinit(void)
|
|
{
|
|
CRYPTO_THREAD_lock_free(async_mem_lock);
|
|
}
|
|
|
|
static int allow_customize = 1;
|
|
static ASYNC_stack_alloc_fn stack_alloc_impl = async_stack_alloc;
|
|
static ASYNC_stack_free_fn stack_free_impl = async_stack_free;
|
|
|
|
int ASYNC_is_capable(void)
|
|
{
|
|
ucontext_t ctx;
|
|
|
|
/*
|
|
* Some platforms provide getcontext() but it does not work (notably
|
|
* MacOSX PPC64). Check for a working getcontext();
|
|
*/
|
|
return getcontext(&ctx) == 0;
|
|
}
|
|
|
|
int ASYNC_set_mem_functions(ASYNC_stack_alloc_fn alloc_fn,
|
|
ASYNC_stack_free_fn free_fn)
|
|
{
|
|
OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL);
|
|
|
|
if (!CRYPTO_THREAD_write_lock(async_mem_lock))
|
|
return 0;
|
|
if (!allow_customize) {
|
|
CRYPTO_THREAD_unlock(async_mem_lock);
|
|
return 0;
|
|
}
|
|
CRYPTO_THREAD_unlock(async_mem_lock);
|
|
|
|
if (alloc_fn != NULL)
|
|
stack_alloc_impl = alloc_fn;
|
|
if (free_fn != NULL)
|
|
stack_free_impl = free_fn;
|
|
return 1;
|
|
}
|
|
|
|
void ASYNC_get_mem_functions(ASYNC_stack_alloc_fn *alloc_fn,
|
|
ASYNC_stack_free_fn *free_fn)
|
|
{
|
|
if (alloc_fn != NULL)
|
|
*alloc_fn = stack_alloc_impl;
|
|
if (free_fn != NULL)
|
|
*free_fn = stack_free_impl;
|
|
}
|
|
|
|
static void *async_stack_alloc(size_t *num)
|
|
{
|
|
return OPENSSL_malloc(*num);
|
|
}
|
|
|
|
static void async_stack_free(void *addr)
|
|
{
|
|
OPENSSL_free(addr);
|
|
}
|
|
|
|
void async_local_cleanup(void)
|
|
{
|
|
}
|
|
|
|
int async_fibre_makecontext(async_fibre *fibre)
|
|
{
|
|
#ifndef USE_SWAPCONTEXT
|
|
fibre->env_init = 0;
|
|
#endif
|
|
if (getcontext(&fibre->fibre) == 0) {
|
|
size_t num = STACKSIZE;
|
|
|
|
/*
|
|
* Disallow customisation after the first
|
|
* stack is allocated.
|
|
*/
|
|
if (allow_customize) {
|
|
if (!CRYPTO_THREAD_write_lock(async_mem_lock))
|
|
return 0;
|
|
allow_customize = 0;
|
|
CRYPTO_THREAD_unlock(async_mem_lock);
|
|
}
|
|
|
|
fibre->fibre.uc_stack.ss_sp = stack_alloc_impl(&num);
|
|
if (fibre->fibre.uc_stack.ss_sp != NULL) {
|
|
fibre->fibre.uc_stack.ss_size = num;
|
|
fibre->fibre.uc_link = NULL;
|
|
makecontext(&fibre->fibre, async_start_func, 0);
|
|
return 1;
|
|
}
|
|
} else {
|
|
fibre->fibre.uc_stack.ss_sp = NULL;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void async_fibre_free(async_fibre *fibre)
|
|
{
|
|
stack_free_impl(fibre->fibre.uc_stack.ss_sp);
|
|
fibre->fibre.uc_stack.ss_sp = NULL;
|
|
}
|
|
|
|
#endif
|