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::'









share|improve this question





















  • 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










  • 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















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::'









share|improve this question





















  • 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










  • 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













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::'









share|improve this question













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






share|improve this question













share|improve this question











share|improve this question




share|improve this question










asked Nov 9 at 19:44









Cmarv

375




375











  • 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










  • 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

















  • 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










  • 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
















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













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.






share|improve this answer




















  • thanks for explaining and providing a solution !!
    – Cmarv
    Nov 9 at 20:03










Your Answer






StackExchange.ifUsing("editor", function ()
StackExchange.using("externalEditor", function ()
StackExchange.using("snippets", function ()
StackExchange.snippets.init();
);
);
, "code-snippets");

StackExchange.ready(function()
var channelOptions =
tags: "".split(" "),
id: "1"
;
initTagRenderer("".split(" "), "".split(" "), channelOptions);

StackExchange.using("externalEditor", function()
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled)
StackExchange.using("snippets", function()
createEditor();
);

else
createEditor();

);

function createEditor()
StackExchange.prepareEditor(
heartbeatType: 'answer',
convertImagesToLinks: true,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: 10,
bindNavPrevention: true,
postfix: "",
imageUploader:
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
,
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
);



);













 

draft saved


draft discarded


















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

























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.






share|improve this answer




















  • thanks for explaining and providing a solution !!
    – Cmarv
    Nov 9 at 20:03














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.






share|improve this answer




















  • thanks for explaining and providing a solution !!
    – Cmarv
    Nov 9 at 20:03












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.






share|improve this answer












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.







share|improve this answer












share|improve this answer



share|improve this answer










answered Nov 9 at 20:00









Willem Van Onsem

140k16132224




140k16132224











  • 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




thanks for explaining and providing a solution !!
– Cmarv
Nov 9 at 20:03

















 

draft saved


draft discarded















































 


draft saved


draft discarded














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





















































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







Popular posts from this blog

Use pre created SQLite database for Android project in kotlin

Darth Vader #20

Ondo