diff options
author | Richard Levitte <levitte@openssl.org> | 2022-10-03 07:10:34 +0200 |
---|---|---|
committer | Richard Levitte <levitte@openssl.org> | 2022-10-06 08:01:09 +0200 |
commit | 82d28c6b3cbd8074faaa34cc2ce57dacc580792f (patch) | |
tree | ee3ec2399066e8e508512d4e4c7eb6342f44c3a9 /crypto/sleep.c | |
parent | a8572674f12ceb39f7e66ccbaa8918b922c76739 (diff) |
Rename ossl_sleep() to OSSL_sleep() and make it public
ossl_sleep() was implemented as a static inline function in internal/e_os.h,
using usleep() on Unix and Sleep() on Windows. So far well and good.
However, it also has a fallback implementation for systems that do not have
usleep() or Sleep(), and that implementation happens to use ossl_time_now(),
which is a normal function, private to libcrypto, and is judged to be too
complex to sanely make into a static inline function.
This fallback creates a problem, because we do use ossl_sleep() in apps/ and
a few test programs in test/, and when they are linked with libcrypto in
shared library form, ossl_time_now() can't be found, since it's not publicly
exposed.
Something needs to give, and the easiest, and hopefully sanest answer is to
make ossl_sleep() a publicly exposed function, which requires a slight name
change.
Documentation and 'make update' result included.
Reviewed-by: Paul Dale <pauli@openssl.org>
Reviewed-by: Matt Caswell <matt@openssl.org>
Reviewed-by: Tim Hudson <tjh@openssl.org>
Reviewed-by: Dmitry Belyavskiy <beldmit@gmail.com>
(Merged from https://github.com/openssl/openssl/pull/19330)
Diffstat (limited to 'crypto/sleep.c')
-rw-r--r-- | crypto/sleep.c | 110 |
1 files changed, 110 insertions, 0 deletions
diff --git a/crypto/sleep.c b/crypto/sleep.c new file mode 100644 index 0000000000..1554d936cf --- /dev/null +++ b/crypto/sleep.c @@ -0,0 +1,110 @@ +/* + * Copyright 2022 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html + */ + +#include <openssl/crypto.h> +#include "internal/e_os.h" + +/* system-specific variants defining OSSL_sleep() */ +#if defined(OPENSSL_SYS_UNIX) || defined(__DJGPP__) + +void OSSL_sleep(uint64_t millis) +{ +# ifdef OPENSSL_SYS_VXWORKS + struct timespec ts; + + ts.tv_sec = (long int) (millis / 1000); + ts.tv_nsec = (long int) (millis % 1000) * 1000000ul; + nanosleep(&ts, NULL); +# elif defined(__TANDEM) +# if !defined(_REENTRANT) +# include <cextdecs.h(PROCESS_DELAY_)> + + /* HPNS does not support usleep for non threaded apps */ + PROCESS_DELAY_(millis * 1000); +# elif defined(_SPT_MODEL_) +# include <spthread.h> +# include <spt_extensions.h> + + usleep(millis * 1000); +# else + usleep(millis * 1000); +# endif +# else + usleep(millis * 1000); +# endif +} +#elif defined(_WIN32) +# include <windows.h> + +void OSSL_sleep(uint64_t millis) +{ + /* + * Windows' Sleep() takes a DWORD argument, which is smaller than + * a uint64_t, so we need to split the two to shut the compiler up. + */ + DWORD dword_times; + DWORD i; + + dword_times = (DWORD)(millis >> (8 * sizeof(DWORD))); + millis &= (DWORD)-1; + if (dword_times > 0) { + for (i = dword_times; i-- > 0;) + Sleep((DWORD)-1); + /* + * The loop above slept 1 millisec less on each iteration than it + * should, this compensates by sleeping as many milliseconds as there + * were iterations. Yes, this is nit picky! + */ + Sleep(dword_times); + } + + /* Now, sleep the remaining milliseconds */ + Sleep((DWORD)(millis)); +} +#else +/* Fallback to a busy wait */ +# include "internal/time.h" + +static void ossl_sleep_secs(uint64_t secs) +{ + /* + * sleep() takes an unsigned int argument, which is smaller than + * a uint64_t, so it needs to be called in smaller increments. + */ + unsigned int uint_times; + unsigned int i; + + uint_times = (unsigned int)(secs >> (8 * sizeof(unsigned int))); + if (uint_times > 0) { + for (i = uint_times; i-- > 0;) + sleep((unsigned int)-1); + /* + * The loop above slept 1 second less on each iteration than it + * should, this compensates by sleeping as many seconds as there were + * iterations. Yes, this is nit picky! + */ + sleep(uint_times); + } +} + +static void ossl_sleep_millis(uint64_t millis) +{ + const OSSL_TIME finish + = ossl_time_add(ossl_time_now(), ossl_ms2time(millis)); + + while (ossl_time_compare(ossl_time_now(), finish) < 0) + /* busy wait */ ; +} + +void OSSL_sleep(uint64_t millis) +{ + ossl_sleep_secs(millis / 1000); + ossl_sleep_millis(millis % 1000); +} +#endif /* defined(OPENSSL_SYS_UNIX) || defined(__DJGPP__) */ |