If neither utility readlink, nor realpath is available (I think today mostly from GNU coreutils?), what can I use in POSIX shell scripting to resolve a relative path?
There is a realpath C function, though. So maybe one of the other utilities uses it secretly?
There is a
realpathC function, though. So maybe one of the other utilities uses it secretly?
From the top of my head, I'm not aware any of those utilities reference the realpath function in their specification.
What I know is that test for directory entries often returns true when a pathname is resolved to an existing directory entry ¹ + x.
Peeking into the implementation in dash(git.kernel.org), it uses lstat64/stat64.
This may suffice for directories (test -d pathname) to cd into them and return the resolved pathname with pwd.
For cd, CDPATH should be unset or empty², and the operand should not be the hyphen-minus "-".³
([ -d "$1" ] && [ '-' != "$1" ] && CDPATH= cd -P -- "$1" && pwd -P)
Example: Return a directories absolute, normalized and physical pathname, null if it does not resolve to a directory.
If it is an issue to exclude the hyphen-minus ("-") as pathname, an alternative is to set the operand to "./-" for this specific case.
¹ cf. test; ² cf. cd step 5 description, ³ cf. cd "-" operand
As I could read, you're already aware of dirname and basename, perhaps also about how to check if [a] symlink [(symbolic link)] is broken or doesn't exist Unix&Linux, and if not, see there if it is of interest in the context of this answers' test usage, e.g. to differentiate on a test -d pathname exit status of 1.
Since posting the question, I came up with the following workaround:
#!/bin/sh
realpath() (
file=
path=$1
[ -d "$path" ] || {
file=/$(basename -- "$path")
path=$(dirname -- "$path")
}
{
path=$(cd -- "$path" && pwd)$file
} || exit $?
printf %s\\n "/${path#"${path%%[!/]*}"}"
)
Warning: Obviously, I haven't been able to test this much so far! Always looking for feedback. If you see something, please leave a comment.
Also, I'm sure someone else has had the same idea before and has solved it much better, especially for edge cases and with extensive testing. Please post a link if you know more.
The above shell function realpath is a replacement for GNU coreutils realpath -s --, see https://www.gnu.org/software/coreutils/manual/html_node/realpath-invocation.html. Which means that there is no resolving of symbolic links. (Which is also not necessary if we're only interested in resolving a relative path.)
#!/bin/sh
Use shebang for POSIX shell.
realpath() (
Run the function in a subshell, i.e. realpath() (...) instead of realpath() {...}, so we don't overwrite possibly existing variables file and path. (POSIX shell doesn't support local variables.)
file=
path=$1
Define variables. Initially assume that the path given by argument $1 is an existing directory. (Which is important, because the last component of the path might be . or .., which is the relative part of the path that we want to eliminate.)
[ -d "$path" ] || {
file=/$(basename -- "$path")
path=$(dirname -- "$path")
}
In case the function argument was not a path to an existing directory as previously assumed, we have to adjust $path. To quote from man realpath:
Print the resolved absolute file name; all but the last component must exist
So it doesn't really matter if $file (the "last component") is actually an existing file or a non-existing file or folder - we'll just cut it from $path for now (and append it again, eventually).
{
path=$(cd -- "$path" && pwd)$file
This is where the "trick" happens: To resolve any relative paths, we just let cd resolve them for us and use pwd to print the directory where we end up. This new path is being saved in $path. Also, we don't have to worry about accidentally actually changing our cwd because 2.6.3 Command Substitution runs in a subshell. $file gets appended at the end.
} || exit $?
This line is the reason for the {...} code block around the variable assignment from the previous line. In case the user provided a faulty path (e.g. more than just the last component doesn't exist), cd (from inside the command substitution) should fail and print an error message to stderr (e.g. "can't cd to ...") and exit with an error code > 0. This will also be the error code for the command substitution subshell. To access this error code as $?, the variable assignment gets wrapped by {...}. So in case the {...} block fails, we exit the function and propagate the same non-zero error code.
printf %s\\n "/${path#"${path%%[!/]*}"}"
Because of edge cases like // or /a where a doesn't exist, we would end up with result // or //a. So 2.6.2 Parameter Expansion is being used to remove all leading slashes from $path, before prepending a single slash for the final output.
Here are some tests that I ran:
for path in / // /// . .. "$HOME/." "$HOME/.." "*" --help /tmp /notexisting
do
if [ "$(realpath "$path")" != "$(/usr/bin/realpath -s -- "$path")" ]
then
printf %s\\n "$path"
fi
done