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

Podemos usar a sintaxe ${var##pattern}e ${var%%pattern}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 uma matriz 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 tenho escrito algumas soluções que utilizam os awk, sede cutcomandos.

Agora, minha pergunta é: Existe uma solução mais simples com base na expansão de parâmetros que não usa mudança de matriz e IFS?

Supondo que o valor padrão do IFS você extraia cada octeto em sua própria variável com:

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

Ou em uma matriz com:

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

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

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

Isso é um pouco 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 exposto acima:

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, o que pode ser verificado 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 o nome de uma variável que substitui last3e last2na minha primeira solução (acima).
• declare sec"$count"="value"é uma maneira de atribuir a sec1, sec2, sec3e sec4 quando counté 1, 2, 3e 4. É um pouco parecido eval, mas mais seguro.
• A value, "${slice%%.*}", é análogo ao valoriza meus cessionários resposta original para first, seconde third.

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

IFS=. ; set -- $IP

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

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

(Isso foi fornecido incorretamente anteriormente como IFS=. set -- $IP)

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 no ksh93 (onde esse ${var//pattern/replacement}operador vem), bash4.3+, busybox sh, yash, mkshe zsh, embora, naturalmente , em zsh, existem abordagens muito mais simples . Nas versões anteriores bash, você precisaria remover as aspas internas. Também funciona com as aspas internas removidas na maioria dos outros shells, mas não no ksh93.

Isso pressupõe que $IPcontenha 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 estamos substituindo cada .no $IPcom +256*(, acabamos avaliação:

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

Então, nós estamos construindo um inteiro de 32 bit fora dessas 4 bytes como um endereço IPv4 em última análise, é (embora com os bytes invertida) ¹ 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 seja sempre definido) em vez de apenas valueporque, caso contrário, o analisador aritmético reclamaria de parênteses incompatíveis. O shell aqui pode encontrar o fechamento ))para a abertura $((e , em seguida, executar as expansões dentro que irá resultar na expressão aritmética para avaliar.

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

No ksh93, você também pode:

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

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

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

bashsuporta 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")

Para noglobevitar surpresas ruins para valores de $IPlike 10.*.*.*, o subshell para limitar o escopo dessas alterações às opções e $IFS.

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

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 em um número 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,...))-lo para forçar o uso de números de 32 bits não assinados (e a posixopção para reconhecer constantes octais).

Com o 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.

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

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:

O uso da 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 de regex na sintaxe de teste:

[[ $IP =~ $regex ]]

Isso permite a impressão da matriz BASH_REMATCH sem o primeiro componente (toda a regex corresponde):

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

A quantidade de parênteses é ajustada automaticamente para a sequência correspondente. Portanto, isso corresponderá a um MAC ou a EUI-64 de um endereço IPv6, apesar de serem de tamanho diferente:

#!/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

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 (então não IFSaqui) e pipes nomeados, e inclui a noglobopçã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 da seguinte maneira:

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

E com ipalterado para109.*.*.*

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

O contador de manutenção de loops de 4 iterações é responsável por 4 seções de um endereço IPv4 válido, enquanto as acrobacias com pipes nomeados são necessárias para usar ainda mais as seções do endereço IP no script, em vez de ter variáveis ​​presas no subshell de um loop.

Por que não usar 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

$ ip_=192.168.2.3

$ echo $ip_ 

192.168.2.3

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

192