Início / unix / Perguntas / 420328
Accepted
sci9
Asked: 2018-01-29 19:58:46 +0800 CST

Bash: extrai uma das quatro seções de um endereço IPv4

  • 772

Podemos usar a sintaxe ${var##pattern}e ${var%%pattern}para extrair a última e a primeira seção de um endereço IPv4:

IP=109.96.77.15
echo IP: $IP
echo 'Extract the first section using ${var%%pattern}: ' ${IP%%.*}
echo 'Extract the last section using ${var##pattern}: ' ${IP##*.}

Como podemos extrair a segunda ou terceira seção de um endereço IPv4 usando a expansão de parâmetros?

Aqui está minha solução: eu uso um array e altero a variável IFS.

:~/bin$ IP=109.96.77.15
:~/bin$ IFS=. read -a ArrIP<<<"$IP"
:~/bin$ echo ${ArrIP[1]}
    96
:~/bin$ printf "%s\n" "${ArrIP[@]}"
    109
    96
    77
    15

Também escrevi algumas soluções usando os comandos awk, sede .cut

Agora, minha pergunta é: existe uma solução mais simples baseada na expansão de parâmetros que não use alteração de array e IFS?

bash shell

10 respostas

  1. Best Answer

    Assumindo o valor padrão do IFS, você extrai cada octeto em sua própria variável com:

    read A B C D <<<"${IP//./ }"

    Ou em um array com:

    A=(${IP//./ })
    • 18

  2. Percebo que você pediu especificamente uma solução que NÃO redefiniu temporariamente IFS, mas tenho uma solução doce e simples que você não cobriu, então aqui vai:

    IFS=. ; set -- $IP

    Esse comando curto colocará os elementos do seu endereço IP nos parâmetros posicionais $1 do shell , $2, $3, $4. No entanto, você provavelmente desejará primeiro salvar o original IFSe restaurá-lo posteriormente.

    Quem sabe? Talvez você reconsidere e aceite esta resposta por sua brevidade e eficiência.

    (Isto foi previamente dado incorretamente como IFS=. set -- $IP)

    • 8

  3. Sua declaração de problema pode ser um pouco mais liberal do que você pretendia. Correndo o risco de explorar uma brecha, aqui está a solução a que Muru aludiu :

    first=${IP%%.*}
last3=${IP#*.}
second=${last3%%.*}
last2=${last3#*.}
third=${last2%.*}
fourth=${last2#*.}
echo "$IP -> $first, $second, $third, $fourth"

    Isso é um tanto desajeitado. Ele define duas variáveis ​​descartáveis ​​e não é prontamente adaptado para lidar com mais seções (por exemplo, para um endereço MAC ou IPv6).  A resposta de Sergiy Kolodyazhnyy me inspirou a generalizar o que foi dito acima para isso:

    slice="$IP"
count=1
while [ "$count" -le 4 ]
do
    declare sec"$count"="${slice%%.*}"
    slice="${slice#*.}"
    count=$((count+1))
done

    Isso define sec1, sec2, sec3e sec4, que podem ser verificados com

    printf 'Section 1: %s\n' "$sec1"
printf 'Section 2: %s\n' "$sec2"
printf 'Section 3: %s\n' "$sec3"
printf 'Section 4: %s\n' "$sec4"
    • O whileloop deve ser fácil de entender — itera quatro vezes.
    • Sergiy escolheu slicecomo nome para uma variável que ocupa o lugar de last3e last2na minha primeira solução (acima).
    • declare sec"$count"="value"é uma maneira de atribuir a sec1, e quando é sec2, e . É um pouco como , mas mais seguro.sec3sec4count1234eval
    • O value, "${slice%%.*}", é análogo aos valores que minha resposta original atribui a first, seconde third.
    • 7

  4. Não é o mais fácil , mas você pode fazer algo como:

    $ IP=109.96.77.15
$ echo "$((${-+"(${IP//./"+256*("}))))"}&255))"
109
$ echo "$((${-+"(${IP//./"+256*("}))))"}>>8&255))"
96
$ echo "$((${-+"(${IP//./"+256*("}))))"}>>16&255))"
77
$ echo "$((${-+"(${IP//./"+256*("}))))"}>>24&255))"
15

    Isso deve funcionar em ksh93 (de onde ${var//pattern/replacement}vem esse operador), bash4.3+, busybox sh, e yash, embora, é claro , em , existam abordagens muito mais simples . Em versões mais antigas de , você precisaria remover as aspas internas. Ele também funciona com as aspas internas removidas na maioria dos outros shells, mas não no ksh93.mkshzshzshbash

    Isso pressupõe que $IPcontém uma representação quad-decimal válida de um endereço IPv4 (embora isso também funcione para representações quad-hexadecimais como 0x6d.0x60.0x4d.0xf(e até octal em alguns shells), mas produziria os valores em decimal). Se o conteúdo $IPvier de uma fonte não confiável, isso equivaleria a uma vulnerabilidade de injeção de comando.

    Basicamente, como vamos substituindo every .in $IPpor +256*(, acabamos avaliando:

     $(( (109+256*(96+256*(77+256*(15))))>> x &255 ))

    Portanto, estamos construindo um inteiro de 32 bits a partir desses 4 bytes, como um endereço IPv4 é (embora com os bytes invertidos)¹ e, em seguida, usando os >>operadores &bit a bit para extrair os bytes relevantes.

    Usamos o ${param+value}operador padrão (aqui no $-qual é garantido que sempre será definido) em vez de apenas valueporque, caso contrário, o analisador aritmético reclamaria sobre parênteses incompatíveis. O shell aqui pode encontrar o fechamento ))para a abertura $((e, em seguida, realizar as expansões internas que resultarão na expressão aritmética a ser avaliada.

    Em $(((${IP//./"+256*("}))))&255))vez disso, o shell trataria o segundo e o terceiro s como o )fechamento e relataria um erro de sintaxe.))$((

    No ksh93, você também pode fazer:

    $ echo "${IP/@(*).@(*).@(*).@(*)/\2}"
96

    bash, mksh, zsh copiaram o ${var/pattern/replacement}operador de ksh93, mas não a parte de manipulação do grupo de captura. zsho suporta com uma sintaxe diferente:

    $ setopt extendedglob # for (#b)
$ echo ${IP/(#b)(*).(*).(*).(*)/$match[2]}'
96

    bashoferece suporte a alguma forma de manipulação de grupo de captura em seu operador de correspondência regexp , mas não em ${var/pattern/replacement}.

    POSIXLY, você usaria:

    (IFS=.; set -o noglob; set -- $IP; printf '%s\n' "$2")

    O noglobpara evitar surpresas ruins para valores de $IPcomo 10.*.*.*, o subshell para limitar o escopo dessas alterações para opções e $IFS.

    ¹ Um endereço IPv4 é apenas um inteiro de 32 bits e 127.0.0.1, por exemplo, é apenas uma das muitas (embora a mais comum) representações textuais. Esse mesmo endereço IPv4 típico da interface de loopback também pode ser representado como 0x7f000001 ou 127.1 (talvez mais apropriado aqui para dizer que é o 1endereço na rede 127.0/8 classe A), ou 0177.0.1, ou as outras combinações de 1 a 4 números expressos como octal, decimal ou hexadecimal. Você pode passar todos eles para ping, por exemplo, e verá que todos farão ping no localhost.

    Se você não se importa com o efeito colateral de definir uma variável temporária arbitrária (aqui $n), em bashou ksh93ou zsh -o octalzeroesou lksh -o posix, você pode simplesmente converter todas essas representações de volta para um inteiro de 32 bits com:

    $((n=32,(${IP//./"<<(n-=8))+("})))

    E então extraia todos os componentes com >>/ &combinações como acima.

    $ IP=0x7f000001
$ echo "$((n=32,(${IP//./"<<(n-=8))+("})))"
2130706433
$ IP=127.1
$ echo "$((n=32,(${IP//./"<<(n-=8))+("})))"
2130706433
$ echo "$((n=32,((${IP//./"<<(n-=8))+("}))>>24&255))"
127
$ perl -MSocket -le 'print unpack("L>", inet_aton("127.0.0.1"))'
2130706433

    mkshusa números inteiros de 32 bits assinados para suas expressões aritméticas, você pode usá $((# n=32,...))-los para forçar o uso de números de 32 bits não assinados (e a posixopção de reconhecer constantes octais).

    • 5

  5. Com zsh, você pode aninhar substituições de parâmetros:

    $ ip=12.34.56.78
$ echo ${${ip%.*}##*.}
56
$ echo ${${ip#*.}%%.*}
34

    Isso não é possível no bash.

    • 4

  6. Claro, vamos jogar o jogo do elefante.

    $ ipsplit() { local IFS=.; ip=(.$*); }
$ ipsplit 10.1.2.3
$ echo ${ip[1]}
10

    ou

    $ ipsplit() { local IFS=.; echo $*; }
$ set -- `ipsplit 10.1.2.3`
$ echo $1
10
    • 4

  7. Com IP=12.34.56.78.

    IFS=. read a b c d <<<"$IP"

    E

    #!/bin/bash
IP=$1

regex="(${IP//\./)\.(})"
[[ $IP =~ $regex ]]
echo "${BASH_REMATCH[@]:1}"

    Descrição:

    Uso de expansão de parâmetro ${IP// }para converter cada ponto no ip em um parêntese de abertura, um ponto e um parêntese de fechamento. Adicionando um parêntese inicial e um parêntese de fechamento, obtemos:

    regex=(12)\.(34)\.(56)\.(78)

    que criará quatro parênteses de captura para a correspondência regex na sintaxe de teste:

    [[ $IP =~ $regex ]]

    Isso permite a impressão da matriz BASH_REMATCH sem o primeiro componente (toda a correspondência de regex):

    echo "${BASH_REMATCH[@]:1}"

    A quantidade de parênteses é ajustada automaticamente para a string correspondente. Portanto, isso corresponderá a um MAC ou a um EUI-64 de um endereço IPv6, apesar de terem comprimentos diferentes:

    #!/bin/bash
IP=$1

regex="(${IP//:/):(})"
[[ $IP =~ $regex ]]
echo "${BASH_REMATCH[@]:1}"

    Usando isso:

    $ ./script 00:0C:29:0C:47:D5
00 0C 29 0C 47 D5

$ ./script 00:0C:29:FF:FE:0C:47:D5
00 0C 29 FF FE 0C 47 D5
    • 4

  8. Aqui está uma pequena solução feita com POSIX /bin/sh(no meu caso dash), uma função que usa repetidamente a expansão de parâmetros (portanto, não IFSaqui) e pipes nomeados, e inclui nogloba opção pelos motivos mencionados na resposta de Stephane .

    #!/bin/sh
set -o noglob
get_ip_sections(){
    slice="$1"
    count=0
    while [ -n "${slice}" ] && [ "$count" -ne 4 ]
    do
        num="${slice%%.*}"
        printf '%s ' "${num}"
        slice="${slice#*${num}.}"
        count=$((count+1))
    done
}

ip="109.96.77.15"
named_pipe="/tmp/ip_stuff.fifo"
mkfifo "${named_pipe}"
get_ip_sections "$ip" > "${named_pipe}" &
read sec1 sec2 sec3 sec4 < "${named_pipe}"
printf 'Actual ip:%s\n' "${ip}"
printf 'Section 1:%s\n' "${sec1}"
printf 'Section 3:%s\n' "${sec3}"
rm  "${named_pipe}"

    Isso funciona assim:

    $ ./get_ip_sections.sh 
Actual ip:109.96.77.15
Section 1:109
Section 3:77

    E com ipmudou para109.*.*.*

    $ ./get_ip_sections.sh 
Actual ip:109.*.*.*
Section 1:109
Section 3:*

    O loop mantendo o contador de 4 iterações é responsável por 4 seções de um endereço IPv4 válido, enquanto acrobacias com pipes nomeados representam a necessidade de usar mais seções de endereço IP dentro do script, em vez de ter variáveis ​​presas em um subshell de um loop.

    • 3

  9. Por que não usar uma solução simples com o awk?

    $ IP="192.168.1.1" $ echo $IP | awk -F '.' '{ print $1" "$2" "$3" "$4;}'

    Resultado $ 192 168 1 1

    • 0 
  10. $ ip_=192.168.2.3

$ echo $ip_ 

192.168.2.3

$ echo $ip_ |cut -d "." -f 1

192
    • -2

relate perguntas