diff options
Diffstat (limited to '')
| -rw-r--r-- | netwerk/sctp/src/user_environment.c | 384 |
1 files changed, 384 insertions, 0 deletions
diff --git a/netwerk/sctp/src/user_environment.c b/netwerk/sctp/src/user_environment.c new file mode 100644 index 0000000000..3deb3ef0d4 --- /dev/null +++ b/netwerk/sctp/src/user_environment.c @@ -0,0 +1,384 @@ +/*- + * Copyright (c) 2009-2010 Brad Penoff + * Copyright (c) 2009-2010 Humaira Kamal + * Copyright (c) 2011-2012 Irene Ruengeler + * Copyright (c) 2011-2012 Michael Tuexen + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* __Userspace__ */ + +#if defined(_WIN32) +#if !defined(_CRT_RAND_S) && !defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) +#define _CRT_RAND_S +#endif +#else +#include <stdint.h> +#include <netinet/sctp_os_userspace.h> +#endif +#ifdef INVARIANTS +#include <netinet/sctp_pcb.h> +#endif +#include <user_environment.h> +#include <sys/types.h> +/* #include <sys/param.h> defines MIN */ +#if !defined(MIN) +#define MIN(arg1,arg2) ((arg1) < (arg2) ? (arg1) : (arg2)) +#endif + +#define uHZ 1000 + +/* See user_include/user_environment.h for comments about these variables */ +int maxsockets = 25600; +int hz = uHZ; +int ip_defttl = 64; +int ipport_firstauto = 49152, ipport_lastauto = 65535; +int nmbclusters = 65536; + +/* Source ip_output.c. extern'd in ip_var.h */ +u_short ip_id = 0; /*__Userspace__ TODO Should it be initialized to zero? */ + +/* used in user_include/user_atomic.h in order to make the operations + * defined there truly atomic + */ +userland_mutex_t atomic_mtx; + +/* If the entropy device is not loaded, make a token effort to + * provide _some_ kind of randomness. This should only be used + * inside other RNG's, like arc4random(9). + */ +#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) +#include <string.h> + +void +init_random(void) +{ + return; +} + +void +read_random(void *buf, size_t size) +{ + memset(buf, 'A', size); + return; +} + +void +finish_random(void) +{ + return; +} +/* This define can be used to optionally use OpenSSL's random number utility, + * which is capable of bypassing the chromium sandbox which normally would + * prevent opening files, including /dev/urandom. + */ +#elif defined(SCTP_USE_OPENSSL_RAND) +#include <openssl/rand.h> + +/* Requiring BoringSSL because it guarantees that RAND_bytes will succeed. */ +#ifndef OPENSSL_IS_BORINGSSL +#error Only BoringSSL is supported with SCTP_USE_OPENSSL_RAND. +#endif + +void +init_random(void) +{ + return; +} + +void +read_random(void *buf, size_t size) +{ + RAND_bytes((uint8_t *)buf, size); + return; +} + +void +finish_random(void) +{ + return; +} +#elif defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__) || defined(__Bitrig__) +#include <stdlib.h> + +void +init_random(void) +{ + return; +} + +void +read_random(void *buf, size_t size) +{ + arc4random_buf(buf, size); + return; +} + +void +finish_random(void) +{ + return; +} +#elif defined(_WIN32) +#include <stdlib.h> + +void +init_random(void) +{ + return; +} + +void +read_random(void *buf, size_t size) +{ + unsigned int randval; + size_t position, remaining; + + position = 0; + while (position < size) { + if (rand_s(&randval) == 0) { + remaining = MIN(size - position, sizeof(unsigned int)); + memcpy((char *)buf + position, &randval, remaining); + position += sizeof(unsigned int); + } + } + return; +} + +void +finish_random(void) +{ + return; +} +#elif (defined(__ANDROID__) && (__ANDROID_API__ < 28)) || defined(__QNX__) || defined(__EMSCRIPTEN__) +#include <fcntl.h> + +static int fd = -1; + +void +init_random(void) +{ + fd = open("/dev/urandom", O_RDONLY); + return; +} + +void +read_random(void *buf, size_t size) +{ + size_t position; + ssize_t n; + + position = 0; + while (position < size) { + n = read(fd, (char *)buf + position, size - position); + if (n > 0) { + position += n; + } + } + return; +} + +void +finish_random(void) +{ + close(fd); + return; +} +#elif defined(__ANDROID__) && (__ANDROID_API__ >= 28) +#include <sys/random.h> + +void +init_random(void) +{ + return; +} + +void +read_random(void *buf, size_t size) +{ + size_t position; + ssize_t n; + + position = 0; + while (position < size) { + n = getrandom((char *)buf + position, size - position, 0); + if (n > 0) { + position += n; + } + } + return; +} + +void +finish_random(void) +{ + return; +} +#elif defined(__linux__) +#include <fcntl.h> +#include <unistd.h> +#include <sys/syscall.h> + +#if defined(__has_feature) +#if __has_feature(memory_sanitizer) +void __msan_unpoison(void *, size_t); +#endif +#endif + +#ifdef __NR_getrandom +#if !defined(GRND_NONBLOCK) +#define GRND_NONBLOCK 1 +#endif +static int getrandom_available = 0; +#endif +static int fd = -1; + +void +init_random(void) +{ +#ifdef __NR_getrandom + char dummy; + ssize_t n = syscall(__NR_getrandom, &dummy, sizeof(dummy), GRND_NONBLOCK); + if (n > 0 || errno == EINTR || errno == EAGAIN) { + /* Either getrandom succeeded, was interrupted or is waiting for entropy; + * all of which mean the syscall is available. + */ + getrandom_available = 1; + } else { +#ifdef INVARIANTS + if (errno != ENOSYS) { + panic("getrandom syscall returned unexpected error: %d", errno); + } +#endif + /* If the syscall isn't available, fall back to /dev/urandom. */ +#endif + fd = open("/dev/urandom", O_RDONLY); +#ifdef __NR_getrandom + } +#endif + return; +} + +void +read_random(void *buf, size_t size) +{ + size_t position; + ssize_t n; + + position = 0; + while (position < size) { +#ifdef __NR_getrandom + if (getrandom_available) { + /* Using syscall directly because getrandom isn't present in glibc < 2.25. + */ + n = syscall(__NR_getrandom, (char *)buf + position, size - position, 0); + if (n > 0) { +#if defined(__has_feature) +#if __has_feature(memory_sanitizer) + /* Need to do this because MSan doesn't realize that syscall has + * initialized the output buffer. + */ + __msan_unpoison(buf + position, n); +#endif +#endif + position += n; + } else if (errno != EINTR && errno != EAGAIN) { +#ifdef INVARIANTS + panic("getrandom syscall returned unexpected error: %d", errno); +#endif + } + } else +#endif /* __NR_getrandom */ + { + n = read(fd, (char *)buf + position, size - position); + if (n > 0) { + position += n; + } + } + } + return; +} + +void +finish_random(void) +{ + if (fd != -1) { + close(fd); + } + return; +} +#elif defined(__Fuchsia__) +#include <zircon/syscalls.h> + +void +init_random(void) +{ + return; +} + +void +read_random(void *buf, size_t size) +{ + zx_cprng_draw(buf, size); + return; +} + +void +finish_random(void) +{ + return; +} +#elif defined(__native_client__) +#include <nacl/nacl_random.h> + +void +init_random(void) +{ + return; +} + +void +read_random(void *buf, size_t size) +{ + size_t position; + size_t n; + + position = 0; + while (position < size) { + if (nacl_secure_random((char *)buf + position, size - position, &n) == 0) + position += n; + } + } + return; +} + +void +finish_random(void) +{ + return; +} +#else +#error "Unknown platform. Please provide platform specific RNG." +#endif |