Como saber o nível de um symlink no linux?

Question

Por exemplo, se um symlink

a -> b
b -> c
c -> d

digamos, o nível de link simbólico de a é 3.

Então, existe algum utilitário para obter essa informação? E também quero obter os detalhes de expansão de um link simbólico, que mostrará algo como:

1. /abc/xyz is expanded to /abc/xy/z (lrwx--x--x root root)
2. /abc/xy/z is expanded to /abc/xy-1.3.2/z (lrwx--x--x root root)
3. /abc/xy-1.3.2/z is expanded to /abc/xy-1.3.2/z-4.6 (lrwx--x--x root root)
4. /abc/xy-1.3.2/z-4.6 is expanded to /storage/121/43/z_4_6 (lrwx--x--x root root)
5. /storage/121/43/z_4_6 is expanded to /media/kitty_3135/43/z_4_6 (lrwx--x--x root root)

Para que eu possa diagnosticar com os links simbólicos. Alguma idéia?

    

Answer 1

Esta função Bash recursiva irá imprimir a cadeia de links e contar mais o diagnóstico:

chain() { local link target; if [[ -z $_chain ]]; then unset _chain_count _expansion; _chain="$1"; fi; link=$(stat --printf=%N $1); while [[ $link =~ \-\> ]]; do target="${link##*\'}"; target="${target%\'}"; _chain+=" -> $target"; ((_chain_count++)); _expansion+="$_chain_count. $1 is expanded to $target $(stat --printf="(%A %U %G)" $target)"$'\n'; chain "$target"; return; done; echo "$_chain ($_chain_count)"; echo "$_expansion"; unset _chain _chain_count _expansion; }

Requer stat . Para obter mais informações e uma versão que usa readlink em vez de stat , consulte minha resposta aqui (o recurso de contagem precisaria ser adicionado, mas adicionar as permissões e proprietário / grupo seria um pouco mais desafiador).

Para isso:

a
b -> a
c -> b
d -> c

A saída de chain d seria:

d -> c -> b -> a (3)
1. d is expanded to c (lrwxrwxrwx username groupname)
2. c is expanded to b (lrwxrwxrwx username groupname)
3. b is expanded to a (-rw-r--r-- root root)

Aqui está uma versão mais legível da função:

chain ()
{
    local link target;
    if [[ -z $_chain ]]; then
        unset _chain_count _expansion;
        _chain="$1";
    fi;
    link=$(stat --printf=%N $1);
    while [[ $link =~ \-\> ]]; do
        target="${link##*\'}";
        target="${target%\'}";
        _chain+=" -> $target";
        ((_chain_count++));
        _expansion+="$_chain_count. $1 is expanded to $target $(stat --printf="(%A %U %G)" $target)"$'\n';
        chain "$target";
        return;
    done;
    echo "$_chain ($_chain_count)";
    echo "$_expansion";
    unset _chain _chain_count _expansion
}

    

Answer 2

Isso é realmente complicado, em geral, já que você pode ter um symlink como:

ln -s ../symlink/xyz pqr

onde 'symlink' é um link simbólico de tamanho arbitrário. Eu tenho um programa que faz o mesmo trabalho que realpath() , mas que também verifica a segurança de todos os links simbólicos a caminho. Como tal, pode ser usado para responder à sua pergunta. E alguns de seus scripts de teste podem ser usados para validar seus cálculos.

Este é um desses testes:

#!/bin/ksh
#
# @(#)$Id: realpathtest.sh,v 1.4 2008/04/14 19:36:54 jleffler Exp $
#
# Create confusing path names

base=${1:-"./rpt"}

mkdir -p $base/elsewhere/confused $base/elsewhere/hidden \
         $base/other/place $base/elsewhere/private

(
cd $base
[ -h link ] || ln -s elsewhere/confused link
[ -h some ] || ln -s other/place some
)
(
cd $base/elsewhere/confused
[ -h mischief ] || ln -s ../hidden mischief
[ -h where    ] || ln -s ../private where
)
(
cd $base/other/place
[ -h dubious  ] || ln -s ../../link/mischief dubious
[ -h doubtful ] || ln -s ../../link/where doubtful
)
(
cd $base/elsewhere/private
echo "What is the real pathname for $base/some/doubtful/file?" > file
)
(
cd $base/elsewhere/hidden
[ -h file ] || ln -s name file
echo "What is the real pathname for $base/some/dubious/file?" > name
)

for name in \
    $base/some/dubious/file \
    $base/some/doubtful/file \
    $base/elsewhere/confused/mischief/file \
    $base/elsewhere/confused/where/file
do
    if realpath $name
    then cat $(realpath -s $name)
    fi
done

Entre em contato comigo se você quiser a origem do programa 'realpath' ou 'linkpath' (veja meu perfil); . O programa 'realpath' não é uma ciência de foguetes - basicamente chama realpath() para cada argumento que é dado. Há consideravelmente mais esforço envolvido na análise do conjunto completo de links.

    

Answer 3

Eu realmente não sei sobre um utilitário. Você pode roteirizar com facilidade. Adicionar alguma saída stat ou ls pode fazer o resto do caminho.

#!/bin/sh

level=0
file=$1
while [ -h "$file" ]
do
    previous="$file"
    file='readlink "$file"'
    level=$(($level+1))
    echo "$level". "$previous -> $file"
done

Usando isso em alguns links criados no meu homedir eu recebo:

$ ./test.sh link2
1. link2 -> link1
2. link1 -> Test.java