musl_c23_compat.c File Reference

🔄 musl C23 compatibility wrappers for __isoc23_* symbol aliases (glibc 2.38+ compatibility) More...

Go to the source code of this file.

Functions
long	musl_strtol (const char *, extern long long musl_strtoll(const char char **, int)
long long	__isoc23_strtoll (const char *str, char **endptr, int base)
	Convert string to long long (C23 compatible)
unsigned long	__isoc23_strtoul (const char *str, char **endptr, int base)
	Convert string to unsigned long (C23 compatible)
unsigned long long	__isoc23_strtoull (const char *str, char **endptr, int base)
	Convert string to unsigned long long (C23 compatible)
long	__isoc23_wcstol (const wchar_t *str, wchar_t **endptr, int base)
	Wide string to integer conversion.
long long	__isoc23_wcstoll (const wchar_t *str, wchar_t **endptr, int base)
	Convert wide string to long long (C23 compatible)
unsigned long	__isoc23_wcstoul (const wchar_t *str, wchar_t **endptr, int base)
	Convert wide string to unsigned long (C23 compatible)
unsigned long long	__isoc23_wcstoull (const wchar_t *str, wchar_t **endptr, int base)
	Convert wide string to unsigned long long (C23 compatible)
int	__isoc23_scanf (const char *format,...)
	Formatted input functions.
int	__isoc23_fscanf (FILE *stream, const char *format,...)
	Read formatted input from file stream (C23 compatible)
int	__isoc23_sscanf (const char *str, const char *format,...)
	Read formatted input from string (C23 compatible)
int	__isoc23_vscanf (const char *format, va_list args)
	Read formatted input from stdin (va_list variant, C23 compatible)
int	__isoc23_vfscanf (FILE *stream, const char *format, va_list args)
	Read formatted input from file stream (va_list variant, C23 compatible)
int	__isoc23_vsscanf (const char *str, const char *format, va_list args)
	Read formatted input from string (va_list variant, C23 compatible)
int	__isoc23_wscanf (const wchar_t *format,...)
	Wide character formatted input functions.
int	__isoc23_fwscanf (FILE *stream, const wchar_t *format,...)
	Read formatted wide input from file stream (C23 compatible)
int	__isoc23_swscanf (const wchar_t *str, const wchar_t *format,...)
	Read formatted wide input from string (C23 compatible)
int	__isoc23_vwscanf (const wchar_t *format, va_list args)
	Read formatted wide input from stdin (va_list variant, C23 compatible)
int	__isoc23_vfwscanf (FILE *stream, const wchar_t *format, va_list args)
	Read formatted wide input from file stream (va_list variant, C23 compatible)
int	__isoc23_vswscanf (const wchar_t *str, const wchar_t *format, va_list args)
	Read formatted wide input from string (va_list variant, C23 compatible)
void	arc4random_buf (void *buf, size_t nbytes)
	glibc-specific random functions for expat and fontconfig compatibility
int	initstate_r (unsigned int seed, char *statebuf, size_t statelen, struct random_data *buf)
	Initialize reentrant random state (glibc compatibility stub for musl)
int	random_r (struct random_data *restrict buf, int32_t *restrict result)
	Generate cryptographically secure random number (glibc compatibility stub for musl)

Detailed Description

🔄 musl C23 compatibility wrappers for __isoc23_* symbol aliases (glibc 2.38+ compatibility)

Note: These aliases provide the base functionality but don't implement the full C23 binary literal support (0b/0B prefix) until musl adds native support.

References:

• https://reviews.llvm.org/D158943
• https://groups.google.com/g/osv-dev/c/zDx0qThbtEE

Definition in file musl_c23_compat.c.

Function Documentation

__isoc23_fscanf()

int __isoc23_fscanf	(	FILE *	stream,
		const char *	format,
			...
	)

Read formatted input from file stream (C23 compatible)

Parameters

stream	File stream
format	Format string
...	Variable arguments

Returns

Number of successfully read items

Definition at line 129 of file musl_c23_compat.c.

                                                           {
  va_list args;
  va_start(args, format);
  int result = vfscanf(stream, format, args);
  va_end(args);
  return result;
}

References args.

__isoc23_fwscanf()

int __isoc23_fwscanf	(	FILE *	stream,
		const wchar_t *	format,
			...
	)

Read formatted wide input from file stream (C23 compatible)

Parameters

stream	File stream
format	Format string
...	Variable arguments

Returns

Number of successfully read items

Definition at line 209 of file musl_c23_compat.c.

                                                               {
  va_list args;
  va_start(args, format);
  int result = vfwscanf(stream, format, args);
  va_end(args);
  return result;
}

References args.

__isoc23_sscanf()

int __isoc23_sscanf	(	const char *	str,
		const char *	format,
			...
	)

Read formatted input from string (C23 compatible)

Parameters

str	Input string
format	Format string
...	Variable arguments

Returns

Number of successfully read items

Definition at line 144 of file musl_c23_compat.c.

                                                              {
  va_list args;
  va_start(args, format);
  int result = vsscanf(str, format, args);
  va_end(args);
  return result;
}

References args.

__isoc23_strtoll()

long long __isoc23_strtoll	(	const char *	str,
		char **	endptr,
		int	base
	)

Convert string to long long (C23 compatible)

Definition at line 38 of file musl_c23_compat.c.

                                                                     {
  return musl_strtoll(str, endptr, base);
}

__isoc23_strtoul()

unsigned long __isoc23_strtoul	(	const char *	str,
		char **	endptr,
		int	base
	)

Convert string to unsigned long (C23 compatible)

Definition at line 45 of file musl_c23_compat.c.

                                                                         {
  return musl_strtoul(str, endptr, base);
}

__isoc23_strtoull()

unsigned long long __isoc23_strtoull	(	const char *	str,
		char **	endptr,
		int	base
	)

Convert string to unsigned long long (C23 compatible)

Definition at line 52 of file musl_c23_compat.c.

                                                                               {
  return musl_strtoull(str, endptr, base);
}

__isoc23_swscanf()

int __isoc23_swscanf	(	const wchar_t *	str,
		const wchar_t *	format,
			...
	)

Read formatted wide input from string (C23 compatible)

Parameters

str	Input string
format	Format string
...	Variable arguments

Returns

Number of successfully read items

Definition at line 224 of file musl_c23_compat.c.

                                                                     {
  va_list args;
  va_start(args, format);
  int result = vswscanf(str, format, args);
  va_end(args);
  return result;
}

References args.

__isoc23_vfscanf()

int __isoc23_vfscanf	(	FILE *	stream,
		const char *	format,
		va_list	args
	)

Read formatted input from file stream (va_list variant, C23 compatible)

Parameters

stream	File stream
format	Format string
args	Variable argument list

Returns

Number of successfully read items

Definition at line 169 of file musl_c23_compat.c.

                                                                     {
  return vfscanf(stream, format, args);
}

References args.

__isoc23_vfwscanf()

int __isoc23_vfwscanf	(	FILE *	stream,
		const wchar_t *	format,
		va_list	args
	)

Read formatted wide input from file stream (va_list variant, C23 compatible)

Parameters

stream	File stream
format	Format string
args	Variable argument list

Returns

Number of successfully read items

Definition at line 249 of file musl_c23_compat.c.

                                                                         {
  return vfwscanf(stream, format, args);
}

References args.

__isoc23_vscanf()

int __isoc23_vscanf	(	const char *	format,
		va_list	args
	)

Read formatted input from stdin (va_list variant, C23 compatible)

Parameters

format	Format string
args	Variable argument list

Returns

Number of successfully read items

Definition at line 158 of file musl_c23_compat.c.

                                                      {
  return vscanf(format, args);
}

References args.

__isoc23_vsscanf()

int __isoc23_vsscanf	(	const char *	str,
		const char *	format,
		va_list	args
	)

Read formatted input from string (va_list variant, C23 compatible)

Parameters

str	Input string
format	Format string
args	Variable argument list

Returns

Number of successfully read items

Definition at line 180 of file musl_c23_compat.c.

                                                                        {
  return vsscanf(str, format, args);
}

References args.

__isoc23_vswscanf()

int __isoc23_vswscanf	(	const wchar_t *	str,
		const wchar_t *	format,
		va_list	args
	)

Read formatted wide input from string (va_list variant, C23 compatible)

Parameters

str	Input string
format	Format string
args	Variable argument list

Returns

Number of successfully read items

Definition at line 260 of file musl_c23_compat.c.

                                                                               {
  return vswscanf(str, format, args);
}

References args.

__isoc23_vwscanf()

int __isoc23_vwscanf	(	const wchar_t *	format,
		va_list	args
	)

Read formatted wide input from stdin (va_list variant, C23 compatible)

Parameters

format	Format string
args	Variable argument list

Returns

Number of successfully read items

Definition at line 238 of file musl_c23_compat.c.

                                                          {
  return vwscanf(format, args);
}

References args.

__isoc23_wcstoll()

long long __isoc23_wcstoll	(	const wchar_t *	str,
		wchar_t **	endptr,
		int	base
	)

Convert wide string to long long (C23 compatible)

Parameters

str	Wide string to convert
endptr	Pointer to first non-digit character (optional)
base	Numeric base (0-36)

Returns

Converted value

Definition at line 78 of file musl_c23_compat.c.

                                                                           {
  return wcstoll(str, endptr, base);
}

__isoc23_wcstoul()

unsigned long __isoc23_wcstoul	(	const wchar_t *	str,
		wchar_t **	endptr,
		int	base
	)

Convert wide string to unsigned long (C23 compatible)

Parameters

str	Wide string to convert
endptr	Pointer to first non-digit character (optional)
base	Numeric base (0-36)

Returns

Converted value

Definition at line 89 of file musl_c23_compat.c.

                                                                               {
  return wcstoul(str, endptr, base);
}

__isoc23_wcstoull()

unsigned long long __isoc23_wcstoull	(	const wchar_t *	str,
		wchar_t **	endptr,
		int	base
	)

Convert wide string to unsigned long long (C23 compatible)

Parameters

str	Wide string to convert
endptr	Pointer to first non-digit character (optional)
base	Numeric base (0-36)

Returns

Converted value

Definition at line 100 of file musl_c23_compat.c.

                                                                                     {
  return wcstoull(str, endptr, base);
}

initstate_r()

int initstate_r	(	unsigned int	seed,
		char *	statebuf,
		size_t	statelen,
		struct random_data *	buf
	)

Initialize reentrant random state (glibc compatibility stub for musl)

musl doesn't provide this glibc-specific reentrant random function. Used by fontconfig for thread-local hash seeding during initialization.

Design Notes

This is a stub implementation (doesn't maintain stateful PRNG state) for these reasons:

• fontconfig only calls this once per thread during startup (not in hot loops)
• The performance difference between a syscall and PRNG state lookup is negligible at initialization time
• Implementing a correct PRNG is complex; using kernel randomness is simpler and more reliable than maintaining application-level state

Why the state buffer is not used

• glibc's stateful design (storing PRNG state in statebuf) is an optimization for applications that call random_r() thousands of times
• fontconfig doesn't fit that pattern; it just needs a few random values at init
• Maintaining thread-local state would require either TLS allocation or synchronization
• Not worth the complexity for initialization-time randomness

Thread Safety

Thread-safe by design:

• Each thread can have its own buf/statebuf
• Each thread's random_r() calls arc4random_buf(), which is atomic at kernel level
• No shared mutable state means no synchronization needed

Parameters

seed	Seed value (ignored; random_r() uses arc4random_buf())
statebuf	State buffer (validated but not used)
statelen	Length of state buffer (must be >= 32)
buf	Random data structure (validated but not used)

Returns

0 on success, -1 if parameters invalid

Definition at line 346 of file musl_c23_compat.c.

                                                                                             {
  (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;
}

musl_strtol()

long musl_strtol ( const char *  , extern long long musl_strtoll(const char  char **, int    )

extern

Definition at line 23 of file musl_c23_compat.c.

                                                               {
  return musl_strtol(str, endptr, base);
}

random_r()

int random_r	(	struct random_data *restrict	buf,
		int32_t *restrict	result
	)

Generate cryptographically secure random number (glibc compatibility stub for musl)

musl doesn't provide this glibc-specific reentrant random function. Used by fontconfig to generate thread-safe random numbers without shared state.

Design

• Ignores the state buffer (buf) entirely
• Each call invokes arc4random_buf() to get fresh random bytes from kernel
• Thread-safe because arc4random_buf() uses atomic syscalls/device reads
• No per-thread PRNG state to maintain or synchronize

Why stateless design

• fontconfig's usage pattern doesn't warrant state management (see initstate_r())
• Stateless design trades a syscall per call for simplicity and correctness
• Kernel randomness is reliable; application-level PRNG state would need testing
• See initstate_r() for full rationale on not maintaining state

Parameters

buf	Random data structure (ignored; present for glibc API compatibility)
result	Pointer to store generated random value in range [0, 2^31)

Returns

0 on success, -1 if buf or result is NULL

Definition at line 383 of file musl_c23_compat.c.

                                                                         {
  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;
}

References arc4random_buf().