musl_c23_compat.c

Go to the documentation of this file.

 
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <wchar.h>
#include <limits.h>
 
// Declare musl's actual strto* functions using asm labels to bypass glibc's C23
// header redirect (e.g. strtoul → __isoc23_strtoul), which would cause infinite
// recursion since this file IS the __isoc23_* implementation.
extern long musl_strtol(const char *, char **, int) __asm__("strtol");
extern long long musl_strtoll(const char *, char **, int) __asm__("strtoll");
extern unsigned long musl_strtoul(const char *, char **, int) __asm__("strtoul");
extern unsigned long long musl_strtoull(const char *, char **, int) __asm__("strtoull");
 
long __isoc23_strtol(const char *str, char **endptr, int base) {
  return musl_strtol(str, endptr, base);
}
 
long long __isoc23_strtoll(const char *str, char **endptr, int base) {
  return musl_strtoll(str, endptr, base);
}
 
unsigned long __isoc23_strtoul(const char *str, char **endptr, int base) {
  return musl_strtoul(str, endptr, base);
}
 
unsigned long long __isoc23_strtoull(const char *str, char **endptr, int base) {
  return musl_strtoull(str, endptr, base);
}
 
long __isoc23_wcstol(const wchar_t *str, wchar_t **endptr, int base) {
  return wcstol(str, endptr, base);
}
 
long long __isoc23_wcstoll(const wchar_t *str, wchar_t **endptr, int base) {
  return wcstoll(str, endptr, base);
}
 
unsigned long __isoc23_wcstoul(const wchar_t *str, wchar_t **endptr, int base) {
  return wcstoul(str, endptr, base);
}
 
unsigned long long __isoc23_wcstoull(const wchar_t *str, wchar_t **endptr, int base) {
  return wcstoull(str, endptr, base);
}
 
int __isoc23_scanf(const char *format, ...) {
  va_list args;
  va_start(args, format);
  int result = vscanf(format, args);
  va_end(args);
  return result;
}
 
int __isoc23_fscanf(FILE *stream, const char *format, ...) {
  va_list args;
  va_start(args, format);
  int result = vfscanf(stream, format, args);
  va_end(args);
  return result;
}
 
int __isoc23_sscanf(const char *str, const char *format, ...) {
  va_list args;
  va_start(args, format);
  int result = vsscanf(str, format, args);
  va_end(args);
  return result;
}
 
int __isoc23_vscanf(const char *format, va_list args) {
  return vscanf(format, args);
}
 
int __isoc23_vfscanf(FILE *stream, const char *format, va_list args) {
  return vfscanf(stream, format, args);
}
 
int __isoc23_vsscanf(const char *str, const char *format, va_list args) {
  return vsscanf(str, format, args);
}
 
int __isoc23_wscanf(const wchar_t *format, ...) {
  va_list args;
  va_start(args, format);
  int result = vwscanf(format, args);
  va_end(args);
  return result;
}
 
int __isoc23_fwscanf(FILE *stream, const wchar_t *format, ...) {
  va_list args;
  va_start(args, format);
  int result = vfwscanf(stream, format, args);
  va_end(args);
  return result;
}
 
int __isoc23_swscanf(const wchar_t *str, const wchar_t *format, ...) {
  va_list args;
  va_start(args, format);
  int result = vswscanf(str, format, args);
  va_end(args);
  return result;
}
 
int __isoc23_vwscanf(const wchar_t *format, va_list args) {
  return vwscanf(format, args);
}
 
int __isoc23_vfwscanf(FILE *stream, const wchar_t *format, va_list args) {
  return vfwscanf(stream, format, args);
}
 
int __isoc23_vswscanf(const wchar_t *str, const wchar_t *format, va_list args) {
  return vswscanf(str, format, args);
}
 
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/syscall.h>
 
void arc4random_buf(void *buf, size_t nbytes) {
  if (nbytes == 0 || buf == NULL) {
    return;
  }
 
/* Prefer getrandom syscall: available in Linux 3.17+, no file descriptor needed */
#ifdef SYS_getrandom
  long result = syscall(SYS_getrandom, buf, nbytes, 0);
  if (result == (long)nbytes) {
    return;
  }
#endif
 
  /* Fallback to /dev/urandom device */
  int fd = open("/dev/urandom", O_RDONLY);
  if (fd >= 0) {
    ssize_t n = read(fd, buf, nbytes);
    close(fd);
    if (n == (ssize_t)nbytes) {
      return;
    }
  }
 
  /* Fatal error: unable to obtain random bytes */
  abort();
}
 
int initstate_r(unsigned int seed, char *statebuf, size_t statelen, struct random_data *buf) {
  (void)seed;
  // Validate parameters match glibc interface
  if (!statebuf || !buf || statelen < 32) {
    return -1;
  }
 
  // Initialize buffer (though random_r() doesn't actually use it)
  memset(statebuf, 0, statelen);
 
  return 0;
}
 
int random_r(struct random_data *restrict buf, int32_t *restrict result) {
  if (buf == NULL || result == NULL) {
    return -1;
  }
 
  /* Obtain cryptographically secure random bytes from kernel */
  uint32_t random_bytes;
  arc4random_buf(&random_bytes, sizeof(random_bytes));
 
  /* Convert to 31-bit positive integer matching glibc behavior
     glibc's random_r returns values in range [0, 2^31) */
  *result = (int32_t)((random_bytes >> 1) & 0x7FFFFFFF);
 
  return 0;
}