| /* pathphys.c -- return pathname with all symlinks expanded. */ |
| |
| /* Copyright (C) 2000 Free Software Foundation, Inc. |
| |
| This file is part of GNU Bash, the Bourne Again SHell. |
| |
| Bash is free software: you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation, either version 3 of the License, or |
| (at your option) any later version. |
| |
| Bash 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 General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with Bash. If not, see <http://www.gnu.org/licenses/>. |
| */ |
| |
| #include <config.h> |
| |
| #include <bashtypes.h> |
| #if defined (HAVE_SYS_PARAM_H) |
| # include <sys/param.h> |
| #endif |
| #include <posixstat.h> |
| |
| #if defined (HAVE_UNISTD_H) |
| # include <unistd.h> |
| #endif |
| |
| #include <filecntl.h> |
| #include <bashansi.h> |
| #include <stdio.h> |
| #include <chartypes.h> |
| #include <errno.h> |
| |
| #include "shell.h" |
| |
| #if !defined (MAXSYMLINKS) |
| # define MAXSYMLINKS 32 |
| #endif |
| |
| #if !defined (errno) |
| extern int errno; |
| #endif /* !errno */ |
| |
| extern char *get_working_directory __P((char *)); |
| |
| static int |
| _path_readlink (path, buf, bufsiz) |
| char *path; |
| char *buf; |
| int bufsiz; |
| { |
| #ifdef HAVE_READLINK |
| return readlink (path, buf, bufsiz); |
| #else |
| errno = EINVAL; |
| return -1; |
| #endif |
| } |
| |
| /* Look for ROOTEDPATH, PATHSEP, DIRSEP, and ISDIRSEP in ../../general.h */ |
| |
| #define DOUBLE_SLASH(p) ((p[0] == '/') && (p[1] == '/') && p[2] != '/') |
| |
| /* |
| * Return PATH with all symlinks expanded in newly-allocated memory. |
| * This always gets an absolute pathname. |
| */ |
| |
| char * |
| sh_physpath (path, flags) |
| char *path; |
| int flags; |
| { |
| char tbuf[PATH_MAX+1], linkbuf[PATH_MAX+1]; |
| char *result, *p, *q, *qsave, *qbase, *workpath; |
| int double_slash_path, linklen, nlink; |
| |
| linklen = strlen (path); |
| |
| #if 0 |
| /* First sanity check -- punt immediately if the name is too long. */ |
| if (linklen >= PATH_MAX) |
| return (savestring (path)); |
| #endif |
| |
| nlink = 0; |
| q = result = (char *)xmalloc (PATH_MAX + 1); |
| |
| /* Even if we get something longer than PATH_MAX, we might be able to |
| shorten it, so we try. */ |
| if (linklen >= PATH_MAX) |
| workpath = savestring (path); |
| else |
| { |
| workpath = (char *)xmalloc (PATH_MAX + 1); |
| strcpy (workpath, path); |
| } |
| |
| /* This always gets an absolute pathname. */ |
| |
| /* POSIX.2 says to leave a leading `//' alone. On cygwin, we skip over any |
| leading `x:' (dos drive name). */ |
| #if defined (__CYGWIN__) |
| qbase = (ISALPHA((unsigned char)workpath[0]) && workpath[1] == ':') ? workpath + 3 : workpath + 1; |
| #else |
| qbase = workpath + 1; |
| #endif |
| double_slash_path = DOUBLE_SLASH (workpath); |
| qbase += double_slash_path; |
| |
| for (p = workpath; p < qbase; ) |
| *q++ = *p++; |
| qbase = q; |
| |
| /* |
| * invariants: |
| * qbase points to the portion of the result path we want to modify |
| * p points at beginning of path element we're considering. |
| * q points just past the last path element we wrote (no slash). |
| * |
| * XXX -- need to fix error checking for too-long pathnames |
| */ |
| |
| while (*p) |
| { |
| if (ISDIRSEP(p[0])) /* null element */ |
| p++; |
| else if(p[0] == '.' && PATHSEP(p[1])) /* . and ./ */ |
| p += 1; /* don't count the separator in case it is nul */ |
| else if (p[0] == '.' && p[1] == '.' && PATHSEP(p[2])) /* .. and ../ */ |
| { |
| p += 2; /* skip `..' */ |
| if (q > qbase) |
| { |
| while (--q > qbase && ISDIRSEP(*q) == 0) |
| ; |
| } |
| } |
| else /* real path element */ |
| { |
| /* add separator if not at start of work portion of result */ |
| qsave = q; |
| if (q != qbase) |
| *q++ = DIRSEP; |
| while (*p && (ISDIRSEP(*p) == 0)) |
| { |
| if (q - result >= PATH_MAX) |
| { |
| #ifdef ENAMETOOLONG |
| errno = ENAMETOOLONG; |
| #else |
| errno = EINVAL; |
| #endif |
| goto error; |
| } |
| |
| *q++ = *p++; |
| } |
| |
| *q = '\0'; |
| |
| linklen = _path_readlink (result, linkbuf, PATH_MAX); |
| if (linklen < 0) /* if errno == EINVAL, it's not a symlink */ |
| { |
| if (errno != EINVAL) |
| goto error; |
| continue; |
| } |
| |
| /* It's a symlink, and the value is in LINKBUF. */ |
| nlink++; |
| if (nlink > MAXSYMLINKS) |
| { |
| #ifdef ELOOP |
| errno = ELOOP; |
| #else |
| errno = EINVAL; |
| #endif |
| error: |
| free (result); |
| free (workpath); |
| return ((char *)NULL); |
| } |
| |
| linkbuf[linklen] = '\0'; |
| |
| /* If the new path length would overrun PATH_MAX, punt now. */ |
| if ((strlen (p) + linklen + 2) >= PATH_MAX) |
| { |
| #ifdef ENAMETOOLONG |
| errno = ENAMETOOLONG; |
| #else |
| errno = EINVAL; |
| #endif |
| goto error; |
| } |
| |
| /* Form the new pathname by copying the link value to a temporary |
| buffer and appending the rest of `workpath'. Reset p to point |
| to the start of the rest of the path. If the link value is an |
| absolute pathname, reset p, q, and qbase. If not, reset p |
| and q. */ |
| strcpy (tbuf, linkbuf); |
| tbuf[linklen] = '/'; |
| strcpy (tbuf + linklen, p); |
| strcpy (workpath, tbuf); |
| |
| if (ABSPATH(linkbuf)) |
| { |
| q = result; |
| /* Duplicating some code here... */ |
| #if defined (__CYGWIN__) |
| qbase = (ISALPHA((unsigned char)workpath[0]) && workpath[1] == ':') ? workpath + 3 : workpath + 1; |
| #else |
| qbase = workpath + 1; |
| #endif |
| double_slash_path = DOUBLE_SLASH (workpath); |
| qbase += double_slash_path; |
| |
| for (p = workpath; p < qbase; ) |
| *q++ = *p++; |
| qbase = q; |
| } |
| else |
| { |
| p = workpath; |
| q = qsave; |
| } |
| } |
| } |
| |
| *q = '\0'; |
| free (workpath); |
| |
| /* If the result starts with `//', but the original path does not, we |
| can turn the // into /. Because of how we set `qbase', this should never |
| be true, but it's a sanity check. */ |
| if (DOUBLE_SLASH(result) && double_slash_path == 0) |
| { |
| if (result[2] == '\0') /* short-circuit for bare `//' */ |
| result[1] = '\0'; |
| else |
| strcpy (result, result + 1); |
| } |
| |
| return (result); |
| } |
| |
| char * |
| sh_realpath (pathname, resolved) |
| const char *pathname; |
| char *resolved; |
| { |
| char *tdir, *wd; |
| |
| if (pathname == 0 || *pathname == '\0') |
| { |
| errno = (pathname == 0) ? EINVAL : ENOENT; |
| return ((char *)NULL); |
| } |
| |
| if (ABSPATH (pathname) == 0) |
| { |
| wd = get_working_directory ("sh_realpath"); |
| if (wd == 0) |
| return ((char *)NULL); |
| tdir = sh_makepath (wd, (char *)pathname, 0); |
| free (wd); |
| } |
| else |
| tdir = savestring (pathname); |
| |
| wd = sh_physpath (tdir, 0); |
| free (tdir); |
| |
| if (resolved == 0) |
| return (wd); |
| |
| if (wd) |
| { |
| strncpy (resolved, wd, PATH_MAX - 1); |
| resolved[PATH_MAX - 1] = '\0'; |
| free (wd); |
| return resolved; |
| } |
| else |
| { |
| resolved[0] = '\0'; |
| return wd; |
| } |
| } |