Ipv6 address format from struct.unpack
up vote
1
down vote
favorite
What would be the way to unpack and map to ipv6 address. I'm currently doing the following
In [3]: struct.unpack("!h",'*x00')
Out[3]: (10752,)
In [5]: ipaddress.IPv6Address(10752)
Out[5]: IPv6Address(u'::2a00')
but of course the end result i wish for is 2a00:: , i was expecting IPv6Address to return it but i'm missing something.
What i'm currently doing is unpacking as sting then to hex and append :: .
In [14]: struct.unpack("!2s",'*x00')
Out[14]: ('*x00',)
In [15]: '*x00'.encode("hex")
Out[15]: '2a00'
then append to hex and append
In [16]: '*x00'.encode("hex")+'::'
Out[16]: '2a00::'
python struct
add a comment |
up vote
1
down vote
favorite
What would be the way to unpack and map to ipv6 address. I'm currently doing the following
In [3]: struct.unpack("!h",'*x00')
Out[3]: (10752,)
In [5]: ipaddress.IPv6Address(10752)
Out[5]: IPv6Address(u'::2a00')
but of course the end result i wish for is 2a00:: , i was expecting IPv6Address to return it but i'm missing something.
What i'm currently doing is unpacking as sting then to hex and append :: .
In [14]: struct.unpack("!2s",'*x00')
Out[14]: ('*x00',)
In [15]: '*x00'.encode("hex")
Out[15]: '2a00'
then append to hex and append
In [16]: '*x00'.encode("hex")+'::'
Out[16]: '2a00::'
python struct
I'm not following why you expect2a00
, that would be55827575822966466661959896531774472192
(so shift it with 112 bits) that maps on2a00::
, since you could say that an IP address is "little endian"
– Willem Van Onsem
Nov 9 at 19:48
thanks for that. was hopping rather than expecting to be honest.what would be the way to shift this ? any module i can use.
– Cmarv
Nov 9 at 19:54
Just use binary operators, soipaddress.IPv6Address(10752<<112)
, but note that this trick will only work for numbers up to 2^16 (65'536), since otherwise the value is "too large".
– Willem Van Onsem
Nov 9 at 19:55
add a comment |
up vote
1
down vote
favorite
up vote
1
down vote
favorite
What would be the way to unpack and map to ipv6 address. I'm currently doing the following
In [3]: struct.unpack("!h",'*x00')
Out[3]: (10752,)
In [5]: ipaddress.IPv6Address(10752)
Out[5]: IPv6Address(u'::2a00')
but of course the end result i wish for is 2a00:: , i was expecting IPv6Address to return it but i'm missing something.
What i'm currently doing is unpacking as sting then to hex and append :: .
In [14]: struct.unpack("!2s",'*x00')
Out[14]: ('*x00',)
In [15]: '*x00'.encode("hex")
Out[15]: '2a00'
then append to hex and append
In [16]: '*x00'.encode("hex")+'::'
Out[16]: '2a00::'
python struct
What would be the way to unpack and map to ipv6 address. I'm currently doing the following
In [3]: struct.unpack("!h",'*x00')
Out[3]: (10752,)
In [5]: ipaddress.IPv6Address(10752)
Out[5]: IPv6Address(u'::2a00')
but of course the end result i wish for is 2a00:: , i was expecting IPv6Address to return it but i'm missing something.
What i'm currently doing is unpacking as sting then to hex and append :: .
In [14]: struct.unpack("!2s",'*x00')
Out[14]: ('*x00',)
In [15]: '*x00'.encode("hex")
Out[15]: '2a00'
then append to hex and append
In [16]: '*x00'.encode("hex")+'::'
Out[16]: '2a00::'
python struct
python struct
asked Nov 9 at 19:44
Cmarv
375
375
I'm not following why you expect2a00
, that would be55827575822966466661959896531774472192
(so shift it with 112 bits) that maps on2a00::
, since you could say that an IP address is "little endian"
– Willem Van Onsem
Nov 9 at 19:48
thanks for that. was hopping rather than expecting to be honest.what would be the way to shift this ? any module i can use.
– Cmarv
Nov 9 at 19:54
Just use binary operators, soipaddress.IPv6Address(10752<<112)
, but note that this trick will only work for numbers up to 2^16 (65'536), since otherwise the value is "too large".
– Willem Van Onsem
Nov 9 at 19:55
add a comment |
I'm not following why you expect2a00
, that would be55827575822966466661959896531774472192
(so shift it with 112 bits) that maps on2a00::
, since you could say that an IP address is "little endian"
– Willem Van Onsem
Nov 9 at 19:48
thanks for that. was hopping rather than expecting to be honest.what would be the way to shift this ? any module i can use.
– Cmarv
Nov 9 at 19:54
Just use binary operators, soipaddress.IPv6Address(10752<<112)
, but note that this trick will only work for numbers up to 2^16 (65'536), since otherwise the value is "too large".
– Willem Van Onsem
Nov 9 at 19:55
I'm not following why you expect
2a00
, that would be 55827575822966466661959896531774472192
(so shift it with 112 bits) that maps on 2a00::
, since you could say that an IP address is "little endian"– Willem Van Onsem
Nov 9 at 19:48
I'm not following why you expect
2a00
, that would be 55827575822966466661959896531774472192
(so shift it with 112 bits) that maps on 2a00::
, since you could say that an IP address is "little endian"– Willem Van Onsem
Nov 9 at 19:48
thanks for that. was hopping rather than expecting to be honest.what would be the way to shift this ? any module i can use.
– Cmarv
Nov 9 at 19:54
thanks for that. was hopping rather than expecting to be honest.what would be the way to shift this ? any module i can use.
– Cmarv
Nov 9 at 19:54
Just use binary operators, so
ipaddress.IPv6Address(10752<<112)
, but note that this trick will only work for numbers up to 2^16 (65'536), since otherwise the value is "too large".– Willem Van Onsem
Nov 9 at 19:55
Just use binary operators, so
ipaddress.IPv6Address(10752<<112)
, but note that this trick will only work for numbers up to 2^16 (65'536), since otherwise the value is "too large".– Willem Van Onsem
Nov 9 at 19:55
add a comment |
1 Answer
1
active
oldest
votes
up vote
2
down vote
accepted
The IP adress converts what we could see as a binary number into a 128-bit representation with hexadecimal numbers (and some other logic to compress zero sequenes).
The number 10752
is equivalent to:
00 00 00 00 00 00 00 (hex)
00 00 00 00 00 2a 00
00000000 00000000 00000000 00000000 00000000 00000000 00000000 (bin)
00000000 00000000 00000000 00000000 00000000 00101010 00000000
or thus with colons in between:
0000:0000:0000:0000:0000:0000:0000:2a00
and this is actually what you get. IPv6 addresses use double colons to strip of sequences of zero.
If we shift the value however 112 places up (128-16), we thus get:
2a 00 00 00 00 00 00 (hex)
00 00 00 00 00 00 00
00101010 00000000 00000000 00000000 00000000 00000000 00000000 (bin)
00000000 00000000 00000000 00000000 00000000 00000000 00000000
which is thus:
2a00:0000:0000:0000:0000:0000:0000:0000
so we can obtain the desired output with:
>>> ipaddress.IPv6Address(10752<<112)
IPv6Address('2a00::')
Note that the above however will only work if the data is less than 216=65'536, since otherwise it takes more than 16 bits, and then the value is too large to get represented by an IPv6 address.
thanks for explaining and providing a solution !!
– Cmarv
Nov 9 at 20:03
add a comment |
1 Answer
1
active
oldest
votes
1 Answer
1
active
oldest
votes
active
oldest
votes
active
oldest
votes
up vote
2
down vote
accepted
The IP adress converts what we could see as a binary number into a 128-bit representation with hexadecimal numbers (and some other logic to compress zero sequenes).
The number 10752
is equivalent to:
00 00 00 00 00 00 00 (hex)
00 00 00 00 00 2a 00
00000000 00000000 00000000 00000000 00000000 00000000 00000000 (bin)
00000000 00000000 00000000 00000000 00000000 00101010 00000000
or thus with colons in between:
0000:0000:0000:0000:0000:0000:0000:2a00
and this is actually what you get. IPv6 addresses use double colons to strip of sequences of zero.
If we shift the value however 112 places up (128-16), we thus get:
2a 00 00 00 00 00 00 (hex)
00 00 00 00 00 00 00
00101010 00000000 00000000 00000000 00000000 00000000 00000000 (bin)
00000000 00000000 00000000 00000000 00000000 00000000 00000000
which is thus:
2a00:0000:0000:0000:0000:0000:0000:0000
so we can obtain the desired output with:
>>> ipaddress.IPv6Address(10752<<112)
IPv6Address('2a00::')
Note that the above however will only work if the data is less than 216=65'536, since otherwise it takes more than 16 bits, and then the value is too large to get represented by an IPv6 address.
thanks for explaining and providing a solution !!
– Cmarv
Nov 9 at 20:03
add a comment |
up vote
2
down vote
accepted
The IP adress converts what we could see as a binary number into a 128-bit representation with hexadecimal numbers (and some other logic to compress zero sequenes).
The number 10752
is equivalent to:
00 00 00 00 00 00 00 (hex)
00 00 00 00 00 2a 00
00000000 00000000 00000000 00000000 00000000 00000000 00000000 (bin)
00000000 00000000 00000000 00000000 00000000 00101010 00000000
or thus with colons in between:
0000:0000:0000:0000:0000:0000:0000:2a00
and this is actually what you get. IPv6 addresses use double colons to strip of sequences of zero.
If we shift the value however 112 places up (128-16), we thus get:
2a 00 00 00 00 00 00 (hex)
00 00 00 00 00 00 00
00101010 00000000 00000000 00000000 00000000 00000000 00000000 (bin)
00000000 00000000 00000000 00000000 00000000 00000000 00000000
which is thus:
2a00:0000:0000:0000:0000:0000:0000:0000
so we can obtain the desired output with:
>>> ipaddress.IPv6Address(10752<<112)
IPv6Address('2a00::')
Note that the above however will only work if the data is less than 216=65'536, since otherwise it takes more than 16 bits, and then the value is too large to get represented by an IPv6 address.
thanks for explaining and providing a solution !!
– Cmarv
Nov 9 at 20:03
add a comment |
up vote
2
down vote
accepted
up vote
2
down vote
accepted
The IP adress converts what we could see as a binary number into a 128-bit representation with hexadecimal numbers (and some other logic to compress zero sequenes).
The number 10752
is equivalent to:
00 00 00 00 00 00 00 (hex)
00 00 00 00 00 2a 00
00000000 00000000 00000000 00000000 00000000 00000000 00000000 (bin)
00000000 00000000 00000000 00000000 00000000 00101010 00000000
or thus with colons in between:
0000:0000:0000:0000:0000:0000:0000:2a00
and this is actually what you get. IPv6 addresses use double colons to strip of sequences of zero.
If we shift the value however 112 places up (128-16), we thus get:
2a 00 00 00 00 00 00 (hex)
00 00 00 00 00 00 00
00101010 00000000 00000000 00000000 00000000 00000000 00000000 (bin)
00000000 00000000 00000000 00000000 00000000 00000000 00000000
which is thus:
2a00:0000:0000:0000:0000:0000:0000:0000
so we can obtain the desired output with:
>>> ipaddress.IPv6Address(10752<<112)
IPv6Address('2a00::')
Note that the above however will only work if the data is less than 216=65'536, since otherwise it takes more than 16 bits, and then the value is too large to get represented by an IPv6 address.
The IP adress converts what we could see as a binary number into a 128-bit representation with hexadecimal numbers (and some other logic to compress zero sequenes).
The number 10752
is equivalent to:
00 00 00 00 00 00 00 (hex)
00 00 00 00 00 2a 00
00000000 00000000 00000000 00000000 00000000 00000000 00000000 (bin)
00000000 00000000 00000000 00000000 00000000 00101010 00000000
or thus with colons in between:
0000:0000:0000:0000:0000:0000:0000:2a00
and this is actually what you get. IPv6 addresses use double colons to strip of sequences of zero.
If we shift the value however 112 places up (128-16), we thus get:
2a 00 00 00 00 00 00 (hex)
00 00 00 00 00 00 00
00101010 00000000 00000000 00000000 00000000 00000000 00000000 (bin)
00000000 00000000 00000000 00000000 00000000 00000000 00000000
which is thus:
2a00:0000:0000:0000:0000:0000:0000:0000
so we can obtain the desired output with:
>>> ipaddress.IPv6Address(10752<<112)
IPv6Address('2a00::')
Note that the above however will only work if the data is less than 216=65'536, since otherwise it takes more than 16 bits, and then the value is too large to get represented by an IPv6 address.
answered Nov 9 at 20:00
Willem Van Onsem
140k16132224
140k16132224
thanks for explaining and providing a solution !!
– Cmarv
Nov 9 at 20:03
add a comment |
thanks for explaining and providing a solution !!
– Cmarv
Nov 9 at 20:03
thanks for explaining and providing a solution !!
– Cmarv
Nov 9 at 20:03
thanks for explaining and providing a solution !!
– Cmarv
Nov 9 at 20:03
add a comment |
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function ()
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f53232339%2fipv6-address-format-from-struct-unpack%23new-answer', 'question_page');
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
I'm not following why you expect
2a00
, that would be55827575822966466661959896531774472192
(so shift it with 112 bits) that maps on2a00::
, since you could say that an IP address is "little endian"– Willem Van Onsem
Nov 9 at 19:48
thanks for that. was hopping rather than expecting to be honest.what would be the way to shift this ? any module i can use.
– Cmarv
Nov 9 at 19:54
Just use binary operators, so
ipaddress.IPv6Address(10752<<112)
, but note that this trick will only work for numbers up to 2^16 (65'536), since otherwise the value is "too large".– Willem Van Onsem
Nov 9 at 19:55