Bernd Eggink

Get link target

Where does a symbolic link point to? This sounds like a silly question, as the target can easily be shown using the command ls -l. However, things aren't always that simple. The target shown by this command is the the direct target, which again may be a symbolic link, pointing to another link, and so on. Actually any file name can represent a link chain of arbitrary length. Which real file this chain eventually points to can't be deduced from the ls output.

Many systems provide a command readlink, which, if called with the option -e, prints the final link target. If your system lacks this command, you can try the following function getlink. Usage:

getlink [-l] path

Without an option, it prints the direct target, similar to ls -l. If path is not a link, the parameter itself is printed. With option -l, the link chain starting with path is followed to its end and the final target is printed. The return code is 0 if all targets exist, 1 otherwise.

All paths are printed in normalized form, i.e. they don't contain components consisting of one ore two dots. ^[1]

function getlink # ([-l] path)
{
    # Print path of the file a symbolic link is pointing to.
    # Options: 
    #   -l: follow link chain, print last target.
    #   no option: print first target unchanged.
    # Returns: 0 if all path components exist, 1 otherwise


    typeset dir file last link opt oldPWD=$PWD ret=0

    # debugging
    #
    #trap 'set +x' EXIT
    #PS4='+\W:$LINENO: '
    #set -x

    (( OPTIND = 1 ))

    while getopts "l" opt
    do
        case $opt in
        (l)     last=1
                ;;
        esac
    done

    shift $(( OPTIND - 1 ))

    file=$1

    # make absolute

    [[ $file != /* ]] && file=$PWD/$file

    # normalize

    typeset comp IFSold=$IFS i m n
    
    IFS=/               # split
    comp=($file)        
    IFS=$IFSold

    n=${#comp[*]}
    m=0

    for (( i = 0; i < n; ++i ))
    do                  
        [[ ! ${comp[i]} ]] && continue

        if [[ ${comp[i]} == . ]]
        then              
            unset comp[i] 
        elif [[ ${comp[i]} == .. ]]
        then              
            unset comp[i] 
                          
            for (( j = i - 1; j > 0; --j ))           
            do
                [[ ${comp[j]} ]] &&
                {       
                    unset comp[j]
                    break
                }   
            done
        else
            (( ++m ))
        fi 
    done

    # concatenate normalized components 

    file=

    if (( m > 0 ))
    then
        for c in ${comp[*]}
        do  
            file+="/$c"
        done        
    else
        printf "/\n"
        return 0
    fi

    # get link

    typeset lnk=

    if [[ $last ]]              # last link
    then
        while true
        do
            # Does the file exist?

            [[ ! -e $file ]] && 
            {
                # no, print path and return 1

                printf "%s\n" "$file"
                return 1
            }
            
            # split path into dir and name

            dir=$(dirname "$file")  # dir
            file=${file##*/}        # filename

            # enter dir (physical)

            command cd -P "$dir"

            # is file a symbolic link?

            [[ ! -h $file ]] && break   # no
            
            # yes, get target from ls output

            link=$(command ls -l -- "$file"; printf x)
            link=${link%$'\nx'}
            remove="$file -> "
            file=${link#*"$remove"}
        done

        printf "%s\n" "$PWD/$file"
        command cd $oldPWD
    elif [[ ! -h $file ]]       # 1st link
    then
        printf "%s\n" "$file"
    else
        link=$(ls -l "$file")
        printf "%s\n" "${link##*-> }"
    fi

    return $ret
}

typeset -fc getlink

^[1] Thanks to Greg Wooledge for some hints how to handle unsane file names like 'a->b' or names with trailing newlines