Bernd Eggink

Linkziel ausgeben

Wohin zeigt ein symbolischer Link? Dumme Frage, könnte man denken, schließlich lässt sich das Ziel mit ls -l anzeigen. Doch so einfach ist es nicht immer. Angezeigt wird mit diesem Kommando nur das unmittelbare Ziel. Das kann aber ebenfalls ein symbolischer Link sein, der wieder auf einen Link zeigt usw.; tatsächlich kann sich hinter jedem Dateinamen eine beliebig lange Verweiskette verbergen. Welcher Pfadname am Ende dieser Kette steht, ist der ls-Ausgabe nicht zu entnehmen.

Auf vielen System gibt es dafür ein Kommando readlink, das mit der Option -e aufgerufen das Endziel ausgibt. Ansonsten hilft die folgende Funktion getlink, die. Aufruf:

getlink [-l] pfad

Ohne Option gibt sie das unmittelbare Verweisziel unverändert aus, ähnlich wie ls -l. Wenn pfad kein Link ist, wird der Parameter selber ausgegeben. Bei Angabe von -l verfolgt sie die bei pfad beginnende Verweiskette bis zu ihrem Ende und gibt das letzte Ziel aus ^[1]. Der Returncode ist 0, wenn alle Verweisziele existieren, sonst 1.

Alle Pfade werden in normalisierter Form ausgegeben, d.h. sie enthalten keine Komponente .. oder . mehr.

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] Dank an Greg Wooledge für einige Hinweise, wie sich selbst krankhafte Dateinamen wie 'a->b' oder solche mit anhängenden Zeilenvorschüben behandeln lassen