Wie lese ich eine IP-Adresse rückwärts?

Wenn wir diesen String haben ( IP-Adresse ):192.168.1.1

Wie kann ich das ( DNS-Reverse-Record-Formular ) aus dieser Zeichenfolge ableiten , damit es wie 1.1.168.192.in-addr.arpamit einem Shell-Skript angezeigt wird ?

Sie können es mit AWK tun . Es gibt schönere Möglichkeiten, dies zu tun, aber ich denke, dies ist die einfachste.

echo '192.168.1.1' | awk 'BEGIN{FS="."}{print $4"."$3"."$2"."$1".in-addr.arpa"}'

Dadurch wird die Reihenfolge der IP-Adresse umgekehrt.

Um ein paar Tastenanschläge zu sparen, wie Mikel vorgeschlagen hat, können wir die obere Aussage weiter verkürzen:

echo '192.168.1.1' | awk -F . '{print $4"."$3"."$2"."$1".in-addr.arpa"}'

ODER

echo '192.168.1.1' | awk -F. '{print $4"."$3"."$2"."$1".in-addr.arpa"}'

ODER

echo '192.168.1.1' | awk -F. -vOFS=. '{print $4,$3,$2,$1,"in-addr.arpa"}'

AWK ist ziemlich flexibel. :)

Gerade für Neugier Wert ... mit tacvon coreutils GNU: Da eine Variable ipin der Form 192.168.1.1dann

$(printf %s "$ip." | tac -s.)in-addr.arpa

dh

$ ip=192.168.1.1
$ rr=$(printf %s "$ip." | tac -s.)in-addr.arpa
$ echo "$rr"
1.1.168.192.in-addr.arpa

Wenn Sie nur verwenden möchten Shell ( zsh, ksh93, bash), hier ist eine andere Art und Weise:

IFS=. read w x y z <<<'192.168.1.1'
printf '%d.%d.%d.%d.in-addr.arpa.' "$z" "$y" "$x" "$w"

Oder in einfacher alter Schale:

echo '192.168.1.1' | { IFS=. read w x y z; echo "$z.$y.$w.$x.in-addr.arpa."; }

Einfach mit Perl, also:

$ echo 192.168.1.1|perl -nle 'print join ".",reverse(split /\./,$_)'
1.1.168.192

Um es abzurunden, Ruby:

ruby -r ipaddr -e 'puts IPAddr.new(ARGV.first).reverse' 192.168.1.1

Welches auch IPv6 unterstützt

2607:F8B0:4000:080A:0000:0000:0000:2000
=> 0.0.0.2.0.0.0.0.0.0.0.0.0.0.0.0.a.0.8.0.0.0.0.4.0.b.8.f.7.0.6.2.ip6.arpa

Durch GNU sed,

sed -r 's/^([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3})$/\4.\3.\2.\1.in-addr.arpa/g' file

Es kehrt jedes IPv4-Adressformat um.

Beispiel:

$ echo '192.168.1.1' | sed -r 's/^([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3})$/\4.\3.\2.\1.in-addr.arpa/g'
1.1.168.192.in-addr.arpa

$ echo '192.1.1.1' | sed -r 's/^([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3})$/\4.\3.\2.\1.in-addr.arpa/g'
1.1.1.192.in-addr.arpa

$ echo '1.1.1.1' | sed -r 's/^([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3})$/\4.\3.\2.\1.in-addr.arpa/g'
1.1.1.1.in-addr.arpa

$ sed -r 's/^([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3})$/\4.\3.\2.\1.in-addr.arpa/g' <<< '192.168.189.23'
23.189.168.192.in-addr.arpa

Verwenden der Standardbibliothek von Python :

>>> ipaddress.ip_address('192.168.1.1').reverse_pointer
'1.1.168.192.in-addr.arpa'

Mit zsh:

$ ip=192.168.1.1
$ echo ${(j:.:)${(s:.:Oa)ip}}.in-addr.arpa
1.1.168.192.in-addr.arpa

Das sind variable Erweiterungsflags:

• s:.:: s plit auf.
• Oa: Reverse o rder der ein rray
• j:.:: J oin auf.

Eine andere Möglichkeit ist die Verwendung des Befehlszeilentools "dig" mit der Option "-x".

Es führt tatsächlich eine Anfrage für den PTR-Eintrag durch, aber wenn Sie nach "PTR" filtern, werden eine kommentierte Zeile (die Anfrage) und möglicherweise einige Antworten angezeigt.

Die Verwendung von "dig" kann nützlich sein, um den PTR-Namen schnell zu schreiben, ohne ein kleines Skript schreiben zu müssen. Besonders, wenn Sie es interaktiv benötigen (um das Ergebnis auszuschneiden und einzufügen). Es funktioniert auch auf IPv6.

Wenn Sie möchten, dass es auch mit IPv6 funktioniert , können Sie verwenden dig -x.

Beispielsweise:

$ dig -x 194.68.208.240 | egrep '^;.*PTR$' | cut -c 2- | awk '{print $1}'
240.208.68.194.in-addr.arpa.

$ dig -x 2001:db8:dc61:2a61::1 | egrep '^;.*PTR$' | cut -c 2- | awk '{print $1}'
1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.6.a.2.1.6.c.d.8.b.d.0.1.0.0.2.ip6.arpa.

In Python

 a = "192.168.1.122"
 import re
 m = re.search(r'(\d+)\.(\d+)\.(\d+)\.(\d+)',a)
 ip = m.group(4),m.group(3),m.group(2),m.group(1)
 '.'.join(ip) + ".in-addr.arpa"
 '122.1.168.192.in-addr.arpa'

IFS=. ; set -- ${0+192.168.1.2}
printf %b. $4 $3 $2 $1 in-addr.arpa\\c

IFS=. ; printf %s\\n \
    in-addr.arpa ${0+192.168.1.2} |    
sed '1!G;$s/\n/./gp;h;d'

IFS=. ; printf '[%b.] ' \
    ${0+192.168.1.2.]PPPPP\\c} |dc
echo in-addr.arpa

$ while read ip
while> do
while> n=( $(echo $ip) ) && echo "${n[4]}"'.'"${n[3]}"'.'"${n[2]}"'.'"${n[1]}"'.'"in-addr.arpa"
while> done
192.168.1.2
2.1.168.192.in-addr.arpa

Auf diese Weise können Sie eine Adresse eingeben und die Eingabetaste für Ihr Ergebnis drücken.

Mit hostBefehl von dnsutils:

$ host -t ptr 192.168.1.1 | cut -d' ' -f 2
1.1.168.192.in-addr.arpa.

Angenommen, eine Variable enthält die IP: ip=192.168.2.1 . Wenn der Wert einer neuen Variablen $()zugewiesen werden muss, schließen Sie einfach eine beliebige Lösung ein und weisen Sie diese der Variablen zu rr=$(...).

Einige Lösungen sind möglich:

Einfachstes Die : printf 'arpa.in-addr.%s.' "$ip" | tac -s.
meisten Schalen : IFS=. eval 'set -- $ip'; echo "$4.$3.$2.$1.in-addr.arpa"
Einige Schalen : IFS=. read d c b a <<<"$ip"; printf %s "$a.$b.$c.$d.in-addr.arpa."
awk : echo "$ip" | awk -F. '{OFS=FS;print $4,$3,$2,$1,"in-addr.arpa"}'
sed : echo "$ip" | sed -E 's/([^.]+)\.([^.]+)\.([^.]+)\.([^.]+)$/\4.\3.\2.\1.in-addr.arpa./'
sed : echo "arpa.in-addr.$ip" | sed 'y/./\n/' | sed 'G;$s/\n/./gp;h;d'
perl : echo "$ip" | perl -F\\. -lane '$,=".";print( join(".",(reverse @F),"in-addr.arpa"))'
dig : dig -x "$ip" | awk -F '[; \t]+' '/^;.*PTR$/{print($2)}'
Host: host -t ptr 192.168.2.1 | cut -d' ' -f2

Sowohl dig- als auch host-Lösungen funktionieren mit IPv6.

#!/bin/bash
# script file name reverseip.sh
if [ -z $1 ] || [ "help" == $1 ]
then
echo 'Convert a full ipv4 or ipv6 address to arpa notation'
echo "usage:"
echo ./reverseip.sh "help"
echo ./reverseip.sh "ipv4 address format: xxxx.xxxx.xxxx.xxxx"
echo ./reverseip.sh "ipv6 address format: xxxx:xxxx:xxxx:xxxx::xxxx"
echo "examples:"
echo ./reverseip.sh 216.58.207.35
echo ./reverseip.sh 2a00:1450:4001:824::2003
exit
fi

# if ip address passed containing ':'
if [[ $1 = *':'* ]];
then
# invert ipv6 address e.g.: 2a00:1450:4001:824::2003 to 3.0.0.2.0.0.0.0.0.0.0.0.0.0.0.0.4.2.8.0.1.0.0.4.0.5.4.1.0.0.a.2.
# @see lsowen https://gist.github.com/lsowen/4447d916fd19cbb7fce4
echo "$1" | awk -F: 'BEGIN {OFS=""; }{addCount = 9 - NF; for(i=1; i<=NF;i++){if(length($i) == 0){ for(j=1;j<=addCount;j++){$i = ($i "0000");} } else { $i = substr(("0000" $i), length($i)+5-4);}}; print}' | rev | sed -e "s/./&./g" | echo "$(</dev/stdin)ip6.arpa."
else
# invert ipv6 address e.g.: 216.58.207.35 to 35.207.58.216.in-addr.arpa
# @see Stéphane Chazelas /unix/132779/how-to-read-an-ip-address-backwards
echo $(printf %s "$1." | tac -s.)in-addr.arpa
fi

Eine kürzere Alternative zu mattbiancos Antwort mit weniger Werkzeugen, aber mit pcregrep, könnte sein:

$ dig -x 194.68.208.240 | pcregrep -o1 '^;(\S+)\s+IN\s+PTR$'
240.208.68.194.in-addr.arpa.

$ dig -x 2001:db8:dc61:2a61::1 | pcregrep -o1 '^;(\S+)\s+IN\s+PTR$'
1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.6.a.2.1.6.c.d.8.b.d.0.1.0.0.2.ip6.arpa.

Verwenden Sie folgende einzeilige Shell:

echo '192.168.1.1' | tr '.' '\n' | tac | paste -s -d '.' -