logo

utils-std

Collection of commonly available Unix tools git clone https://anongit.hacktivis.me/git/utils-std.git/

offline_realpath.c (3199B)

    

  1. // Based on the realpath(3) function from musl
  2. // Copyright © 2005-2020 Rich Felker, et al.
  3. // SPDX-License-Identifier: MIT
  5. #define _POSIX_C_SOURCE 200809L
  6. #include "fs.h"
  7. #include "strchrnul.h"
  9. #include <errno.h>
  10. #include <limits.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <unistd.h>
  15. static size_t
  16. slash_len(const char *s)
  17. {
  18. 	const char *s0 = s;
  19. 	while(*s == '/')
  20. 		s++;
  21. 	return s - s0;
  22. }
  24. // realpath(3) but without checking for symlinks
  25. char *
  26. offline_realpath(const char *restrict filename, char *restrict resolved)
  27. {
  28. 	char stack[PATH_MAX + 1];
  29. 	char output[PATH_MAX];
  30. 	size_t p, q, l, l0, nup = 0;
  31. 	int check_dir = 0;
  33. 	if(!filename)
  34. 	{
  35. 		errno = EINVAL;
  36. 		return 0;
  37. 	}
  38. 	l = strnlen(filename, sizeof stack);
  39. 	if(!l)
  40. 	{
  41. 		errno = ENOENT;
  42. 		return 0;
  43. 	}
  44. 	if(l >= PATH_MAX) goto toolong;
  45. 	p = sizeof stack - l - 1;
  46. 	q = 0;
  47. 	memcpy(stack + p, filename, l + 1);
  49. 	/* Main loop. Each iteration pops the next part from stack of
  50. 	 * remaining path components and consumes any slashes that follow.
  51. 	 * If not a link, it's moved to output; if a link, contents are
  52. 	 * pushed to the stack. */
  53. 	for(;; p += slash_len(stack + p))
  54. 	{
  55. 		/* If stack starts with /, the whole component is / or //
  56. 		 * and the output state must be reset. */
  57. 		if(stack[p] == '/')
  58. 		{
  59. 			check_dir = 0;
  60. 			nup = 0;
  61. 			q = 0;
  62. 			output[q++] = '/';
  63. 			p++;
  64. 			/* Initial // is special. */
  65. 			if(stack[p] == '/' && stack[p + 1] != '/') output[q++] = '/';
  66. 			continue;
  67. 		}
  69. 		char *z = utils_strchrnul(stack + p, '/');
  70. 		l0 = l = z - (stack + p);
  72. 		if(!l && !check_dir) break;
  74. 		/* Skip any . component but preserve check_dir status. */
  75. 		if(l == 1 && stack[p] == '.')
  76. 		{
  77. 			p += l;
  78. 			continue;
  79. 		}
  81. 		/* Copy next component onto output at least temporarily, to
  82. 		 * call readlink, but wait to advance output position until
  83. 		 * determining it's not a link. */
  84. 		if(q && output[q - 1] != '/')
  85. 		{
  86. 			if(!p) goto toolong;
  87. 			stack[--p] = '/';
  88. 			l++;
  89. 		}
  90. 		if(q + l >= PATH_MAX) goto toolong;
  91. 		memcpy(output + q, stack + p, l);
  92. 		output[q + l] = 0;
  93. 		p += l;
  95. 		int up = 0;
  96. 		if(l0 == 2 && stack[p - 2] == '.' && stack[p - 1] == '.')
  97. 		{
  98. 			up = 1;
  99. 			/* Any non-.. path components we could cancel start
  100. 			 * after nup repetitions of the 3-byte string "../";
  101. 			 * if there are none, accumulate .. components to
  102. 			 * later apply to cwd, if needed. */
  103. 			if(q <= 3 * nup)
  104. 			{
  105. 				nup++;
  106. 				q += l;
  107. 				continue;
  108. 			}
  109. 		}
  110. 		check_dir = 0;
  111. 		if(up)
  112. 		{
  113. 			while(q && output[q - 1] != '/')
  114. 				q--;
  115. 			if(q > 1 && (q > 2 || output[0] != '/')) q--;
  116. 			continue;
  117. 		}
  118. 		if(l0) q += l;
  119. 		check_dir = stack[p];
  120. 	}
  122. 	output[q] = 0;
  124. 	if(output[0] != '/')
  125. 	{
  126. 		if(!getcwd(stack, sizeof stack)) return 0;
  127. 		l = strlen(stack);
  128. 		/* Cancel any initial .. components. */
  129. 		p = 0;
  130. 		while(nup--)
  131. 		{
  132. 			while(l > 1 && stack[l - 1] != '/')
  133. 				l--;
  134. 			if(l > 1) l--;
  135. 			p += 2;
  136. 			if(p < q) p++;
  137. 		}
  138. 		if(q - p && stack[l - 1] != '/') stack[l++] = '/';
  139. 		if(l + (q - p) + 1 >= PATH_MAX) goto toolong;
  140. 		memmove(output + l, output + p, q - p + 1);
  141. 		memcpy(output, stack, l);
  142. 		q = l + q - p;
  143. 	}
  145. 	if(resolved)
  146. 		return memcpy(resolved, output, q + 1);
  147. 	else
  148. 		return strdup(output);
  150. toolong:
  151. 	errno = ENAMETOOLONG;
  152. 	return 0;
  153. }