[thirdparty/glibc.git] / elf / dl-misc.c

/* Miscellaneous support functions for dynamic linker
   Copyright (C) 1997-2025 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <https://www.gnu.org/licenses/>.  */

#include <_itoa.h>
#include <fcntl.h>
#include <ldsodefs.h>
#include <link.h>
#include <not-cancel.h>
#include <stdint.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>

/* Read the whole contents of FILE into new mmap'd space with given
   protections.  *SIZEP gets the size of the file.  On error MAP_FAILED
   is returned.  */

void *
_dl_sysdep_read_whole_file (const char *file, size_t *sizep, int prot)
{
  void *result = MAP_FAILED;
  struct __stat64_t64 st;
  int fd = __open64_nocancel (file, O_RDONLY | O_CLOEXEC);
  if (fd >= 0)
    {
      if (__fstat64_time64 (fd, &st) >= 0)
	{
	  *sizep = st.st_size;

	  /* No need to map the file if it is empty.  */
	  if (*sizep != 0)
	    /* Map a copy of the file contents.  */
	    result = __mmap (NULL, *sizep, prot,
#ifdef MAP_COPY
			     MAP_COPY
#else
			     MAP_PRIVATE
#endif
#ifdef MAP_FILE
			     | MAP_FILE
#endif
			     , fd, 0);
	}
      __close_nocancel (fd);
    }
  return result;
}

/* Test whether given NAME matches any of the names of the given object.  */
int
_dl_name_match_p (const char *name, const struct link_map *map)
{
  if (strcmp (name, map->l_name) == 0)
    return 1;

  struct libname_list *runp = map->l_libname;

  while (runp != NULL)
    if (strcmp (name, runp->name) == 0)
      return 1;
    else
      runp = runp->next;

  return 0;
}

unsigned long int
_dl_higher_prime_number (unsigned long int n)
{
  /* These are primes that are near, but slightly smaller than, a
     power of two.  */
  static const uint32_t primes[] = {
    UINT32_C (7),
    UINT32_C (13),
    UINT32_C (31),
    UINT32_C (61),
    UINT32_C (127),
    UINT32_C (251),
    UINT32_C (509),
    UINT32_C (1021),
    UINT32_C (2039),
    UINT32_C (4093),
    UINT32_C (8191),
    UINT32_C (16381),
    UINT32_C (32749),
    UINT32_C (65521),
    UINT32_C (131071),
    UINT32_C (262139),
    UINT32_C (524287),
    UINT32_C (1048573),
    UINT32_C (2097143),
    UINT32_C (4194301),
    UINT32_C (8388593),
    UINT32_C (16777213),
    UINT32_C (33554393),
    UINT32_C (67108859),
    UINT32_C (134217689),
    UINT32_C (268435399),
    UINT32_C (536870909),
    UINT32_C (1073741789),
    UINT32_C (2147483647),
				       /* 4294967291L */
    UINT32_C (2147483647) + UINT32_C (2147483644)
  };

  const uint32_t *low = &primes[0];
  const uint32_t *high = &primes[sizeof (primes) / sizeof (primes[0])];

  while (low != high)
    {
      const uint32_t *mid = low + (high - low) / 2;
      if (n > *mid)
       low = mid + 1;
      else
       high = mid;
    }

#if 0
  /* If we've run out of primes, abort.  */
  if (n > *low)
    {
      fprintf (stderr, "Cannot find prime bigger than %lu\n", n);
      abort ();
    }
#endif

  return *low;
}

/* A stripped down strtoul-like implementation for very early use.  It
   does not set errno if the result is outside bounds because it may get
   called before errno may have been set up.  */

uint64_t
_dl_strtoul (const char *nptr, char **endptr)
{
  uint64_t result = 0;
  bool positive = true;
  unsigned max_digit;

  while (*nptr == ' ' || *nptr == '\t')
    ++nptr;

  if (*nptr == '-')
    {
      positive = false;
      ++nptr;
    }
  else if (*nptr == '+')
    ++nptr;

  if (*nptr < '0' || *nptr > '9')
    {
      if (endptr != NULL)
	*endptr = (char *) nptr;
      return 0UL;
    }

  uint64_t cutoff = (UINT64_MAX * 2UL + 1UL) / 10;
  uint64_t cutlim = (UINT64_MAX * 2UL + 1UL) % 10;

  int base = 10;
  max_digit = 9;
  if (*nptr == '0')
    {
      if (nptr[1] == 'x' || nptr[1] == 'X')
	{
	  base = 16;
	  nptr += 2;
	  cutoff = (UINT64_MAX * 2UL + 1UL) / 16;
	  cutlim = (UINT64_MAX * 2UL + 1UL) % 16;
	}
      else
	{
	  base = 8;
	  max_digit = 7;
	  cutoff = (UINT64_MAX * 2UL + 1UL) / 8;
	  cutlim = (UINT64_MAX * 2UL + 1UL) % 8;
	}
    }

  while (1)
    {
      int digval;
      if (*nptr >= '0' && *nptr <= '0' + max_digit)
        digval = *nptr - '0';
      else if (base == 16)
        {
	  if (*nptr >= 'a' && *nptr <= 'f')
	    digval = *nptr - 'a' + 10;
	  else if (*nptr >= 'A' && *nptr <= 'F')
	    digval = *nptr - 'A' + 10;
	  else
	    break;
	}
      else
        break;

      if (result > cutoff || (result == cutoff && digval > cutlim))
	{
	  if (endptr != NULL)
	    *endptr = (char *) nptr;
	  return UINT64_MAX;
	}
      result *= base;
      result += digval;
      ++nptr;
    }

  if (endptr != NULL)
    *endptr = (char *) nptr;

  /* Avoid 64-bit multiplication.  */
  if (!positive)
    result = -result;

  return result;
}
Commit	Line	Data
	1	/* Miscellaneous support functions for dynamic linker
	2	Copyright (C) 1997-2025 Free Software Foundation, Inc.
	3	This file is part of the GNU C Library.
	4
	5	The GNU C Library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	The GNU C Library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with the GNU C Library; if not, see
	17	<https://www.gnu.org/licenses/>. */
	18
	19	#include <_itoa.h>
	20	#include <fcntl.h>
	21	#include <ldsodefs.h>
	22	#include <link.h>
	23	#include <not-cancel.h>
	24	#include <stdint.h>
	25	#include <stdlib.h>
	26	#include <sys/mman.h>
	27	#include <sys/stat.h>
	28	#include <unistd.h>
	29
	30	/* Read the whole contents of FILE into new mmap'd space with given
	31	protections. *SIZEP gets the size of the file. On error MAP_FAILED
	32	is returned. */
	33
	34	void *
	35	_dl_sysdep_read_whole_file (const char file, size_t sizep, int prot)
	36	{
	37	void *result = MAP_FAILED;
	38	struct __stat64_t64 st;
	39	int fd = __open64_nocancel (file, O_RDONLY \| O_CLOEXEC);
	40	if (fd >= 0)
	41	{
	42	if (__fstat64_time64 (fd, &st) >= 0)
	43	{
	44	*sizep = st.st_size;
	45
	46	/* No need to map the file if it is empty. */
	47	if (*sizep != 0)
	48	/* Map a copy of the file contents. */
	49	result = __mmap (NULL, *sizep, prot,
	50	#ifdef MAP_COPY
	51	MAP_COPY
	52	#else
	53	MAP_PRIVATE
	54	#endif
	55	#ifdef MAP_FILE
	56	\| MAP_FILE
	57	#endif
	58	, fd, 0);
	59	}
	60	__close_nocancel (fd);
	61	}
	62	return result;
	63	}
	64
	65	/* Test whether given NAME matches any of the names of the given object. */
	66	int
	67	_dl_name_match_p (const char name, const struct link_map map)
	68	{
	69	if (strcmp (name, map->l_name) == 0)
	70	return 1;
	71
	72	struct libname_list *runp = map->l_libname;
	73
	74	while (runp != NULL)
	75	if (strcmp (name, runp->name) == 0)
	76	return 1;
	77	else
	78	runp = runp->next;
	79
	80	return 0;
	81	}
	82
	83	unsigned long int
	84	_dl_higher_prime_number (unsigned long int n)
	85	{
	86	/* These are primes that are near, but slightly smaller than, a
	87	power of two. */
	88	static const uint32_t primes[] = {
	89	UINT32_C (7),
	90	UINT32_C (13),
	91	UINT32_C (31),
	92	UINT32_C (61),
	93	UINT32_C (127),
	94	UINT32_C (251),
	95	UINT32_C (509),
	96	UINT32_C (1021),
	97	UINT32_C (2039),
	98	UINT32_C (4093),
	99	UINT32_C (8191),
	100	UINT32_C (16381),
	101	UINT32_C (32749),
	102	UINT32_C (65521),
	103	UINT32_C (131071),
	104	UINT32_C (262139),
	105	UINT32_C (524287),
	106	UINT32_C (1048573),
	107	UINT32_C (2097143),
	108	UINT32_C (4194301),
	109	UINT32_C (8388593),
	110	UINT32_C (16777213),
	111	UINT32_C (33554393),
	112	UINT32_C (67108859),
	113	UINT32_C (134217689),
	114	UINT32_C (268435399),
	115	UINT32_C (536870909),
	116	UINT32_C (1073741789),
	117	UINT32_C (2147483647),
	118	/* 4294967291L */
	119	UINT32_C (2147483647) + UINT32_C (2147483644)
	120	};
	121
	122	const uint32_t *low = &primes[0];
	123	const uint32_t *high = &primes[sizeof (primes) / sizeof (primes[0])];
	124
	125	while (low != high)
	126	{
	127	const uint32_t *mid = low + (high - low) / 2;
	128	if (n > *mid)
	129	low = mid + 1;
	130	else
	131	high = mid;
	132	}
	133
	134	#if 0
	135	/* If we've run out of primes, abort. */
	136	if (n > *low)
	137	{
	138	fprintf (stderr, "Cannot find prime bigger than %lu\n", n);
	139	abort ();
	140	}
	141	#endif
	142
	143	return *low;
	144	}
	145
	146	/* A stripped down strtoul-like implementation for very early use. It
	147	does not set errno if the result is outside bounds because it may get
	148	called before errno may have been set up. */
	149
	150	uint64_t
	151	_dl_strtoul (const char nptr, char *endptr)
	152	{
	153	uint64_t result = 0;
	154	bool positive = true;
	155	unsigned max_digit;
	156
	157	while (nptr == ' ' \|\| nptr == '\t')
	158	++nptr;
	159
	160	if (*nptr == '-')
	161	{
	162	positive = false;
	163	++nptr;
	164	}
	165	else if (*nptr == '+')
	166	++nptr;
	167
	168	if (nptr < '0' \|\| nptr > '9')
	169	{
	170	if (endptr != NULL)
	171	endptr = (char ) nptr;
	172	return 0UL;
	173	}
	174
	175	uint64_t cutoff = (UINT64_MAX * 2UL + 1UL) / 10;
	176	uint64_t cutlim = (UINT64_MAX * 2UL + 1UL) % 10;
	177
	178	int base = 10;
	179	max_digit = 9;
	180	if (*nptr == '0')
	181	{
	182	if (nptr[1] == 'x' \|\| nptr[1] == 'X')
	183	{
	184	base = 16;
	185	nptr += 2;
	186	cutoff = (UINT64_MAX * 2UL + 1UL) / 16;
	187	cutlim = (UINT64_MAX * 2UL + 1UL) % 16;
	188	}
	189	else
	190	{
	191	base = 8;
	192	max_digit = 7;
	193	cutoff = (UINT64_MAX * 2UL + 1UL) / 8;
	194	cutlim = (UINT64_MAX * 2UL + 1UL) % 8;
	195	}
	196	}
	197
	198	while (1)
	199	{
	200	int digval;
	201	if (nptr >= '0' && nptr <= '0' + max_digit)
	202	digval = *nptr - '0';
	203	else if (base == 16)
	204	{
	205	if (nptr >= 'a' && nptr <= 'f')
	206	digval = *nptr - 'a' + 10;
	207	else if (nptr >= 'A' && nptr <= 'F')
	208	digval = *nptr - 'A' + 10;
	209	else
	210	break;
	211	}
	212	else
	213	break;
	214
	215	if (result > cutoff \|\| (result == cutoff && digval > cutlim))
	216	{
	217	if (endptr != NULL)
	218	endptr = (char ) nptr;
	219	return UINT64_MAX;
	220	}
	221	result *= base;
	222	result += digval;
	223	++nptr;
	224	}
	225
	226	if (endptr != NULL)
	227	endptr = (char ) nptr;
	228
	229	/* Avoid 64-bit multiplication. */
	230	if (!positive)
	231	result = -result;
	232
	233	return result;
	234	}