lib/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2025-08-08 17:42:12 +03:00
Code Activity

Tue Jun 18 17:56:44 1996 Roland McGrath <roland@delasyd.gnu.ai.mit.edu>

Browse Source 
* stdlib/test-canon.c: New test program contributed by David Mosberger.
	* stdlib/Makefile (tests): Add test-canon.
	* stdlib/canonicalize.c: Rewritten by David Mosberger.
This commit is contained in:
Roland McGrath
1996-06-18 22:01:27 +00:00
parent 1c719dd82c
commit 394f4f179e
3 changed files with 299 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

254
stdlib/canonicalize.c
View File

@@ -17,174 +17,152 @@ License along with the GNU C Library; see the file COPYING.LIB. If
not, write to the Free Software Foundation, Inc., 675 Mass Ave,
Cambridge, MA 02139, USA. */
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <errno.h>
/* Return the canonical absolute name of file NAME. The last file name
component need not exist, and may be a symlink to a nonexistent file.
If RESOLVED is null, the result is malloc'd; otherwise, if the canonical
name is PATH_MAX chars or more, returns null with `errno' set to
ENAMETOOLONG; if the name fits in fewer than PATH_MAX chars, returns the
name in RESOLVED. */
/* Return the canonical absolute name of file NAME. A canonical name
does not contain any `.', `..' components nor any repeated path
separators ('/') or symlinks. All path components must exist. If
RESOLVED is null, the result is malloc'd; otherwise, if the
canonical name is PATH_MAX chars or more, returns null with `errno'
set to ENAMETOOLONG; if the name fits in fewer than PATH_MAX chars,
returns the name in RESOLVED. If the name cannot be resolved and
RESOLVED is non-NULL, it contains the path of the first component
that cannot be resolved. If the path can be resolved, RESOLVED
holds the same value as the value returned. */
static char *
canonicalize (const char *name, char *resolved)
{
struct stat st;
const char *p;
char *rpath, *dest, *extra_buf = NULL;
const char *start, *end, *rpath_limit;
long int path_max;
char *result, *dir, *end;
size_t namelen;
int num_links = 0;
if (! resolved)
path_max = 0;
else
{
#ifdef PATH_MAX
path_max = PATH_MAX;
path_max = PATH_MAX;
#else
path_max = pathconf (name, _PC_PATH_MAX);
if (path_max <= 0)
path_max = 1024;
path_max = pathconf (name, _PC_PATH_MAX);
if (path_max <= 0)
path_max = 1024;
#endif
}
p = strrchr (name, '/');
if (!p)
rpath = resolved;
rpath_limit = rpath + path_max;
if (!resolved)
rpath = malloc (path_max);
strcpy (rpath, "/");
if (name[0] != '/' && !getcwd (rpath, path_max))
goto error;
dest = rpath + strlen (rpath);
for (start = end = name; *start; start = end)
{
dir = (char *) ".";
p = name;
}
else
{
if (p++ == name)
dir = (char *) "/";
else
struct stat st;
int n;
/* skip sequence of multiple path-separators: */
while (*start == '/') ++start;
/* find end of path component: */
for (end = start; *end && *end != '/'; ++end);
if (end - start == 0)
break;
else if (strncmp (start, ".", end - start) == 0)
/* nothing */;
else if (strncmp (start, "..", end - start) == 0) {
/* back up to previous component, ignore if at root already: */
if (dest > rpath + 1)
while ((--dest)[-1] != '/');
} else
{
dir = __alloca (p - name);
memcpy (dir, name, p - name - 1);
dir[p - name] = '\0';
}
}
size_t new_size;
result = __canonicalize_directory_name_internal (dir, resolved, path_max);
if (!result)
return NULL;
if (dest[-1] != '/')
*dest++ = '/';
/* Reconstruct the file name in the canonicalized directory. */
namelen = strlen (name);
end = strchr (result, '\0');
if (resolved)
{
/* Make sure the name is not too long. */
if (end - result + namelen > path_max)
{
errno = ENAMETOOLONG;
return NULL;
}
}
else
{
/* The name is dynamically allocated. Extend it. */
char *new = realloc (result, end - result + namelen + 1);
if (! new)
{
free (result);
return NULL;
}
end = new + (end - result);
result = new;
}
memcpy (end, name, namelen + 1);
while (__lstat (result, &st) == 0 && S_ISLNK (st.st_mode))
{
/* The file is a symlink. Read its contents. */
ssize_t n;
read_link_contents:
n = readlink (result, end,
resolved ? result + path_max - end : namelen + 1);
if (n < 0)
/* Error reading the link contents. */
return NULL;
if (end[0] == '/')
{
/* Absolute symlink. */
if (resolved ? (end + n < result + path_max) : (n < namelen + 1))
if (dest + (end - start) >= rpath_limit)
{
/* It fit in our buffer, so we have the whole thing. */
memcpy (result, end, n);
result[n] = '\0';
}
else if (resolved)
{
/* It didn't fit in the remainder of the buffer. Either it
fits in the entire buffer, or it doesn't. Copy back the
unresolved name onto the canonical directory and try once
more. */
memcpy (end, name, namelen + 1);
n = readlink (result, result, path_max);
if (n < 0)
return NULL;
if (n == path_max)
if (resolved)
{
errno = ENAMETOOLONG;
return NULL;
goto error;
}
result[n] = '\0';
new_size = rpath_limit - rpath;
if (end - start + 1 > path_max)
new_size += end - start + 1;
else
new_size += path_max;
rpath = realloc (rpath, new_size);
rpath_limit = rpath + new_size;
if (!rpath)
return NULL;
}
memcpy (dest, start, end - start);
dest += end - start;
*dest = '\0';
if (__lstat (rpath, &st) < 0)
goto error;
if (S_ISLNK (st.st_mode))
{
char * buf = __alloca(path_max);
if (++num_links > MAXSYMLINKS)
{
errno = ELOOP;
goto error;
}
n = readlink (rpath, buf, path_max);
if (n < 0)
goto error;
buf[n] = '\0';
if (!extra_buf)
extra_buf = __alloca (path_max);
if (n + strlen (end) >= path_max)
{
errno = ENAMETOOLONG;
goto error;
}
/* careful here, end may be a pointer into extra_buf... */
strcat (buf, end);
strcpy (extra_buf, buf);
name = end = extra_buf;
if (buf[0] == '/')
dest = rpath + 1; /* it's an absolute symlink */
else
/* back up to previous component, ignore if at root already: */
if (dest > rpath + 1)
while ((--dest)[-1] != '/');
}
else
/* Try again with a bigger buffer. */
goto extend_buffer;
/* Check the resolved name for being a symlink too. */
continue;
num_links = 0;
}
if (resolved)
{
if (end + n == result + path_max)
{
/* The link contents we read fill the buffer completely.
There may be even more to read, and there is certainly no
space for the null terminator. */
errno = ENAMETOOLONG;
return NULL;
}
}
else if (n == namelen + 1)
extend_buffer:
{
/* The name buffer is dynamically allocated. Extend it. */
char *new;
/* Copy back the unresolved name onto the canonical directory. */
memcpy (end, name, namelen + 1);
/* Make more space for readlink. */
namelen *= 2;
new = realloc (result, end - result + namelen + 1);
if (! new)
{
free (result);
return NULL;
}
end = new + (end - result);
result = new;
goto read_link_contents;
}
/* Terminate the string; readlink does not. */
end[n] = '\0';
}
if (dest > rpath + 1 && dest[-1] == '/')
--dest;
*dest = '\0';
return rpath;
return result;
error:
if (!resolved)
free (rpath);
return NULL;
}
weak_alias (canonicalize, realpath)