[thirdparty/glibc.git] / stdlib / test-canon.c

/* Test program for returning the canonical absolute name of a given file.
   Copyright (C) 1996-2024 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/>.  */

/* This file must be run from within a directory called "stdlib".  */

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/param.h>
#include <sys/stat.h>

#include <support/xunistd.h>

/* Prototype for our test function.  */
extern int do_test (int argc, char *argv[]);
#include <test-skeleton.c>

#ifndef PATH_MAX
# define PATH_MAX 4096
#endif
static char	cwd[PATH_MAX];
static size_t	cwd_len;

struct {
  const char *	name;
  const char *	value;
} symlinks[] = {
  {"SYMLINK_LOOP",	"SYMLINK_LOOP"},
  {"SYMLINK_1",		"."},
  {"SYMLINK_2",		"//////./../../etc"},
  {"SYMLINK_3",		"SYMLINK_1"},
  {"SYMLINK_4",		"SYMLINK_2"},
  {"SYMLINK_5",		"doesNotExist"},
};

struct {
  const char * in, * out, * resolved;
  int error;
} tests[] = {
  /*  0 */
  {"/",					"/"},
  {"/////////////////////////////////",	"/"},
  {"/.././.././.././..///",		"/"},
  {"/etc",				"/etc"},
  {"/etc/../etc",			"/etc"},
  /*  5 */
  {"/doesNotExist/../etc",		0, "/doesNotExist", ENOENT},
  {"./././././././././.",		"."},
  {"/etc/.//doesNotExist",		0, "/etc/doesNotExist", ENOENT},
  {"./doesExist",			"./doesExist"},
  {"./doesExist/",			"./doesExist"},
  /* 10 */
  {"./doesExist/../doesExist",		"./doesExist"},
  {"foobar",				0, "./foobar", ENOENT},
  {".",					"."},
  {"./foobar",				0, "./foobar", ENOENT},
  {"SYMLINK_LOOP",			0, "./SYMLINK_LOOP", ELOOP},
  /* 15 */
  {"./SYMLINK_LOOP",			0, "./SYMLINK_LOOP", ELOOP},
  {"SYMLINK_1",				"."},
  {"SYMLINK_1/foobar",			0, "./foobar", ENOENT},
  {"SYMLINK_2",				"/etc"},
  {"SYMLINK_3",				"."},
  /* 20 */
  {"SYMLINK_4",				"/etc"},
  {"../stdlib/SYMLINK_1",		"."},
  {"../stdlib/SYMLINK_2",		"/etc"},
  {"../stdlib/SYMLINK_3",		"."},
  {"../stdlib/SYMLINK_4",		"/etc"},
  /* 25 */
  {"./SYMLINK_5",			0, "./doesNotExist", ENOENT},
  {"SYMLINK_5",				0, "./doesNotExist", ENOENT},
  {"SYMLINK_5/foobar",			0, "./doesNotExist", ENOENT},
  {"doesExist/../../stdlib/doesExist",	"./doesExist"},
  {"doesExist/.././../stdlib/.",	"."},
  /* 30 */
  {"./doesExist/someFile/",		0, "./doesExist/someFile", ENOTDIR},
  {"./doesExist/someFile/..",		0, "./doesExist/someFile", ENOTDIR},
};


static int
check_path (const char * result, const char * expected)
{
  int good;

  if (!result)
    return (expected == NULL);

  if (!expected)
    return 0;

  if (expected[0] == '.' && (expected[1] == '/' || expected[1] == '\0'))
    good = (strncmp (result, cwd, cwd_len) == 0
	    && strcmp (result + cwd_len, expected + 1) == 0);
  else
    good = (strcmp (expected, result) == 0);

  return good;
}


int
do_test (int argc, char ** argv)
{
  char * result;
  int i, errors = 0;
  char buf[PATH_MAX];

  if (getcwd (cwd, sizeof (buf)))
    cwd_len = strlen (cwd);
  else
    {
      printf ("%s: current working directory couldn't be retrieved\n", argv[0]);
      ++errors;
    }

  errno = 0;
  if (realpath (NULL, buf) != NULL || errno != EINVAL)
    {
      printf ("%s: expected return value NULL and errno set to EINVAL"
	      " for realpath(NULL,...)\n", argv[0]);
      ++errors;
    }

#if 0
  /* This is now allowed.  The test is invalid.  */
  errno = 0;
  if (realpath ("/", NULL) != NULL || errno != EINVAL)
    {
      printf ("%s: expected return value NULL and errno set to EINVAL"
	      " for realpath(...,NULL)\n", argv[0]);
      ++errors;
    }
#endif

  errno = 0;
  if (realpath ("", buf) != NULL || errno != ENOENT)
    {
      printf ("%s: expected return value NULL and set errno to ENOENT"
	      " for realpath(\"\",...)\n", argv[0]);
      ++errors;
    }

  for (i = 0; i < (int) (sizeof (symlinks) / sizeof (symlinks[0])); ++i)
    xsymlink (symlinks[i].value, symlinks[i].name);

  int has_dir = mkdir ("doesExist", 0777) == 0;

  int fd = has_dir ? creat ("doesExist/someFile", 0777) : -1;

  for (i = 0; i < (int) (sizeof (tests) / sizeof (tests[0])); ++i)
    {
      buf[0] = '\0';
      result = realpath (tests[i].in, buf);

      if (!check_path (result, tests[i].out))
	{
	  printf ("%s: flunked test %d (expected `%s', got `%s')\n",
		  argv[0], i, tests[i].out ? tests[i].out : "NULL",
		  result ? result : "NULL");
	  ++errors;
	  continue;
	}

      /* Verify buf contents if the call succeeded or failed with ENOENT.  */
      if ((result != NULL || errno == ENOENT)
	  && !check_path (buf, tests[i].out ? tests[i].out : tests[i].resolved))
	{
	  printf ("%s: flunked test %d (expected resolved `%s', got `%s')\n",
		  argv[0], i, tests[i].out ? tests[i].out : tests[i].resolved,
		  buf);
	  ++errors;
	  continue;
	}

      if (!tests[i].out && errno != tests[i].error)
	{
	  printf ("%s: flunked test %d (expected errno %d, got %d)\n",
		  argv[0], i, tests[i].error, errno);
	  ++errors;
	  continue;
	}

      char *result2 = realpath (tests[i].in, NULL);
      if ((result2 == NULL && result != NULL)
	  || (result2 != NULL && strcmp (result, result2) != 0))
	{
	  printf ("\
%s: realpath(..., NULL) produced different result than realpath(..., buf): '%s' vs '%s'\n",
		  argv[0], result2, result);
	  ++errors;
	}
      free (result2);
    }

  if (!getcwd (buf, sizeof (buf)))
    {
      printf ("%s: current working directory couldn't be retrieved\n", argv[0]);
      ++errors;
    }

  if (strcmp (buf, cwd))
    {
      printf ("%s: current working directory changed from %s to %s\n",
	      argv[0], cwd, buf);
      ++errors;
    }

  if (fd >= 0)
    {
      close (fd);
      unlink ("doesExist/someFile");
    }

  if (has_dir)
    rmdir ("doesExist");

  for (i = 0; i < (int) (sizeof (symlinks) / sizeof (symlinks[0])); ++i)
    unlink (symlinks[i].name);

  if (errors != 0)
    {
      printf ("%d errors.\n", errors);
      return EXIT_FAILURE;
    }

  puts ("No errors.");
  return EXIT_SUCCESS;
}
Commit	Line	Data
394f4f17	1	/* Test program for returning the canonical absolute name of a given file.
dff8da6b	2	Copyright (C) 1996-2024 Free Software Foundation, Inc.
c84142e8	3	This file is part of the GNU C Library.
c84142e8 UD	4
c84142e8 UD	5	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	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.
c84142e8 UD	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
41bdb6e2	13	Lesser General Public License for more details.
c84142e8	14
41bdb6e2	15	You should have received a copy of the GNU Lesser General Public
59ba27a6	16	License along with the GNU C Library; if not, see
5a82c748	17	<https://www.gnu.org/licenses/>. */
394f4f17 RM	18
	19	/* This file must be run from within a directory called "stdlib". */
	20
	21	#include <errno.h>
	22	#include <fcntl.h>
	23	#include <stdio.h>
	24	#include <stdlib.h>
	25	#include <string.h>
	26	#include <unistd.h>
	27	#include <sys/param.h>
ceaa9889	28	#include <sys/stat.h>
394f4f17	29
f6a532fb FB	30	#include <support/xunistd.h>
f6a532fb FB	31
e25054c4 AJ	32	/* Prototype for our test function. */
	33	extern int do_test (int argc, char *argv[]);
	34	#include <test-skeleton.c>
	35
a3f4b50b UD	36	#ifndef PATH_MAX
	37	# define PATH_MAX 4096
	38	#endif
2303f5fd	39	static char cwd[PATH_MAX];
394f4f17 RM	40	static size_t cwd_len;
	41
	42	struct {
	43	const char * name;
	44	const char * value;
	45	} symlinks[] = {
	46	{"SYMLINK_LOOP", "SYMLINK_LOOP"},
	47	{"SYMLINK_1", "."},
	48	{"SYMLINK_2", "//////./../../etc"},
	49	{"SYMLINK_3", "SYMLINK_1"},
	50	{"SYMLINK_4", "SYMLINK_2"},
	51	{"SYMLINK_5", "doesNotExist"},
	52	};
	53
	54	struct {
	55	const char * in, * out, * resolved;
ec4b0518	56	int error;
394f4f17 RM	57	} tests[] = {
	58	/* 0 */
	59	{"/", "/"},
	60	{"/////////////////////////////////", "/"},
	61	{"/.././.././.././..///", "/"},
	62	{"/etc", "/etc"},
e25054c4	63	{"/etc/../etc", "/etc"},
394f4f17 RM	64	/* 5 */
	65	{"/doesNotExist/../etc", 0, "/doesNotExist", ENOENT},
	66	{"./././././././././.", "."},
	67	{"/etc/.//doesNotExist", 0, "/etc/doesNotExist", ENOENT},
	68	{"./doesExist", "./doesExist"},
	69	{"./doesExist/", "./doesExist"},
	70	/* 10 */
	71	{"./doesExist/../doesExist", "./doesExist"},
	72	{"foobar", 0, "./foobar", ENOENT},
	73	{".", "."},
	74	{"./foobar", 0, "./foobar", ENOENT},
	75	{"SYMLINK_LOOP", 0, "./SYMLINK_LOOP", ELOOP},
	76	/* 15 */
	77	{"./SYMLINK_LOOP", 0, "./SYMLINK_LOOP", ELOOP},
	78	{"SYMLINK_1", "."},
	79	{"SYMLINK_1/foobar", 0, "./foobar", ENOENT},
	80	{"SYMLINK_2", "/etc"},
	81	{"SYMLINK_3", "."},
	82	/* 20 */
	83	{"SYMLINK_4", "/etc"},
	84	{"../stdlib/SYMLINK_1", "."},
	85	{"../stdlib/SYMLINK_2", "/etc"},
	86	{"../stdlib/SYMLINK_3", "."},
	87	{"../stdlib/SYMLINK_4", "/etc"},
	88	/* 25 */
	89	{"./SYMLINK_5", 0, "./doesNotExist", ENOENT},
	90	{"SYMLINK_5", 0, "./doesNotExist", ENOENT},
	91	{"SYMLINK_5/foobar", 0, "./doesNotExist", ENOENT},
	92	{"doesExist/../../stdlib/doesExist", "./doesExist"},
0f888d8e UD	93	{"doesExist/.././../stdlib/.", "."},
	94	/* 30 */
	95	{"./doesExist/someFile/", 0, "./doesExist/someFile", ENOTDIR},
	96	{"./doesExist/someFile/..", 0, "./doesExist/someFile", ENOTDIR},
394f4f17 RM	97	};
	98
	99
cf3141a5	100	static int
394f4f17 RM	101	check_path (const char * result, const char * expected)
	102	{
	103	int good;
	104
	105	if (!result)
	106	return (expected == NULL);
	107
	108	if (!expected)
	109	return 0;
	110
	111	if (expected[0] == '.' && (expected[1] == '/' \|\| expected[1] == '\0'))
	112	good = (strncmp (result, cwd, cwd_len) == 0
	113	&& strcmp (result + cwd_len, expected + 1) == 0);
	114	else
	115	good = (strcmp (expected, result) == 0);
	116
	117	return good;
	118	}
	119
	120
d68171ed	121	int
e25054c4	122	do_test (int argc, char ** argv)
394f4f17 RM	123	{
394f4f17 RM	124	char * result;
0f888d8e	125	int i, errors = 0;
394f4f17 RM	126	char buf[PATH_MAX];
394f4f17 RM	127
29e25f6f FB	128	if (getcwd (cwd, sizeof (buf)))
	129	cwd_len = strlen (cwd);
	130	else
	131	{
	132	printf ("%s: current working directory couldn't be retrieved\n", argv[0]);
	133	++errors;
	134	}
394f4f17	135
86187531 UD	136	errno = 0;
	137	if (realpath (NULL, buf) != NULL \|\| errno != EINVAL)
	138	{
	139	printf ("%s: expected return value NULL and errno set to EINVAL"
	140	" for realpath(NULL,...)\n", argv[0]);
	141	++errors;
	142	}
	143
f7501ae6 UD	144	#if 0
f7501ae6 UD	145	/* This is now allowed. The test is invalid. */
86187531 UD	146	errno = 0;
	147	if (realpath ("/", NULL) != NULL \|\| errno != EINVAL)
	148	{
	149	printf ("%s: expected return value NULL and errno set to EINVAL"
	150	" for realpath(...,NULL)\n", argv[0]);
	151	++errors;
	152	}
f7501ae6	153	#endif
86187531 UD	154
	155	errno = 0;
	156	if (realpath ("", buf) != NULL \|\| errno != ENOENT)
	157	{
cc3fa755	158	printf ("%s: expected return value NULL and set errno to ENOENT"
86187531 UD	159	" for realpath(\"\",...)\n", argv[0]);
	160	++errors;
	161	}
	162
d68171ed	163	for (i = 0; i < (int) (sizeof (symlinks) / sizeof (symlinks[0])); ++i)
f6a532fb	164	xsymlink (symlinks[i].value, symlinks[i].name);
394f4f17	165
0f888d8e UD	166	int has_dir = mkdir ("doesExist", 0777) == 0;
	167
	168	int fd = has_dir ? creat ("doesExist/someFile", 0777) : -1;
394f4f17	169
d68171ed	170	for (i = 0; i < (int) (sizeof (tests) / sizeof (tests[0])); ++i)
394f4f17 RM	171	{
	172	buf[0] = '\0';
	173	result = realpath (tests[i].in, buf);
	174
	175	if (!check_path (result, tests[i].out))
	176	{
	177	printf ("%s: flunked test %d (expected `%s', got `%s')\n",
	178	argv[0], i, tests[i].out ? tests[i].out : "NULL",
	179	result ? result : "NULL");
	180	++errors;
	181	continue;
	182	}
	183
b4165554 SP	184	/* Verify buf contents if the call succeeded or failed with ENOENT. */
b4165554 SP	185	if ((result != NULL \|\| errno == ENOENT)
949ad78a	186	&& !check_path (buf, tests[i].out ? tests[i].out : tests[i].resolved))
394f4f17 RM	187	{
	188	printf ("%s: flunked test %d (expected resolved `%s', got `%s')\n",
	189	argv[0], i, tests[i].out ? tests[i].out : tests[i].resolved,
	190	buf);
	191	++errors;
	192	continue;
	193	}
	194
ec4b0518	195	if (!tests[i].out && errno != tests[i].error)
394f4f17 RM	196	{
394f4f17 RM	197	printf ("%s: flunked test %d (expected errno %d, got %d)\n",
d68171ed	198	argv[0], i, tests[i].error, errno);
394f4f17 RM	199	++errors;
	200	continue;
	201	}
71b1675e UD	202
	203	char *result2 = realpath (tests[i].in, NULL);
	204	if ((result2 == NULL && result != NULL)
	205	\|\| (result2 != NULL && strcmp (result, result2) != 0))
	206	{
	207	printf ("\
	208	%s: realpath(..., NULL) produced different result than realpath(..., buf): '%s' vs '%s'\n",
	209	argv[0], result2, result);
	210	++errors;
	211	}
	212	free (result2);
394f4f17 RM	213	}
394f4f17 RM	214
29e25f6f FB	215	if (!getcwd (buf, sizeof (buf)))
	216	{
	217	printf ("%s: current working directory couldn't be retrieved\n", argv[0]);
	218	++errors;
	219	}
	220
394f4f17 RM	221	if (strcmp (buf, cwd))
	222	{
	223	printf ("%s: current working directory changed from %s to %s\n",
	224	argv[0], cwd, buf);
	225	++errors;
	226	}
	227
	228	if (fd >= 0)
a1260d92 UD	229	{
	230	close (fd);
	231	unlink ("doesExist/someFile");
	232	}
0f888d8e UD	233
	234	if (has_dir)
	235	rmdir ("doesExist");
394f4f17	236
d68171ed	237	for (i = 0; i < (int) (sizeof (symlinks) / sizeof (symlinks[0])); ++i)
394f4f17 RM	238	unlink (symlinks[i].name);
394f4f17 RM	239
d68171ed	240	if (errors != 0)
394f4f17 RM	241	{
394f4f17 RM	242	printf ("%d errors.\n", errors);
e25054c4	243	return EXIT_FAILURE;
394f4f17	244	}
d68171ed UD	245
	246	puts ("No errors.");
	247	return EXIT_SUCCESS;
394f4f17	248	}