# How to find IPv6 Prefix

(Rene Molenaar) #1

This topic is to discuss the following lesson:

0 Likes

very simple explanation yet so informative. thank you

0 Likes

(Simon F) #3

The best I’ve seen on this, without straying into

geeksville and losing me.

0 Likes

(Diana M) #4

Very simple, thank you, for the explanation

0 Likes

(Reg S) #5

One more example would’ve been nice Very useful though

0 Likes

(Scott P) #6

Hey Rene,

Could you explain how we determine where to cut off the end of the prefix? (see image attached)

1 Like

(Rene Molenaar) #7

Hi Scott,

There’s no image

Rene

0 Likes

(Angel A) #8

Hello Rene,

I really appreciate your explanations. they are very intuitive as well a 4 year old could understand, though at times I feel like an infant when trying to wrap my head around some of the terminology.

Appreciate the help!

Angel Acosta

0 Likes

(Rene Molenaar) #9

Thanks Angel! My goal is to make it as simple as possible

The more time you spend at this, the easier it becomes…before you know it you feel like a guru =)

0 Likes

(Srikanth V) #10

Hi Rene,

Could you please let me know how many continuous hextet of '0’s should be there to be replaced by a ‘:’.

Thank you.

0 Likes

(Lazaros Agapides) #11

Hello Srikanth.

Whenever you have two or more groups of four 0’s, you can replace them with ‘::’ So for example, if you have `2001:0db8:85a3:0000:0000:8a2e:0370:7334` it can be rewritten as `2001:0db8:85a3::8a2e:0370:7334`.

If however you have only one group of four 0’s such as in `2001:db8:0000:1:1:1:1:1` it is never replaced with a :: but just with a single 0 like this: `2001:db8:0:1:1:1:1:1`.

Note also that this two-colon replacement may only be applied once in an address, because multiple occurrences would create an ambiguous representation. For example, `2001:0000:0000:0000:1:0000:0000:1` could be rendered as `2001::1:0:0:1` or `2001:0:0:0:1::1` but not as `2001::1::1`

I hope this has been helpful!

Laz

0 Likes

(Brian C) #12

I approve.

I actually had a sigh of relief because this made sense and was easy to understand. Felt a bit of pride that I was able to still remember how to do Hex to Dec!!

IPV6 is a booger but this lesson was helpful with dealing with prefixes!

1 Like

(Zeko a) #13

Beautiful EXPLAINATION thank u

0 Likes

(Mahamane B) #14

Can you show us again how you determine the 53rd bit from here?Thanks

0 Likes

(Mahamane B) #15

how do you calculate this please?

0 Likes

(Lazaros Agapides) #16

Hello Mahamane

If you were to look at an IPv6 address in binary, then you can count each and every bit in the address until you get to the 53rd bit and you would know where to split the address between host and network. However, because IPv6 addresses are expressed in hexadecimal, individual bits are not visible and cannot be separated appropriately. This is because a single hex digit contains within it four bits. So a digit of A for example cannot be visibly split if the prefix indicates a split somewhere within it.

For this reason, it is rare to have a prefix that would split a hex digit due to the fact that it is awkward and difficult to work with, so it is best to be avoided.

I hope this has been helpful!

Laz

0 Likes

(Hugues R) #17

Hello Laz,
I want to make sure that I understand this paragraph:
Can you confirm that the example provided:
2001: 1234: abcd: 5678: 9877: 3322: 5541: aabb / 53
gave the following host pool:
from 2001: 1234: abcd: 5000 ::
to 2001: 1234: abcd: 57ff: ffff: ffff: ffff: ffff
without broadcast reserved (obviously) … and without reserved address of subnet ?
…and can you confirm also that it would never be a CCNA question ?

0 Likes

(Lazaros Agapides) #18

Hello Hugues

For this specific example: 2001: 1234: abcd: 5678: 9877: 3322: 5541: aabb / 53 it helps to look at some parts using binary. The first three sets of four hexadecimal digits correspond to the first 40 bits which are:

`2001:1234:abcd`

If we use binary to represent the next set of four hexadecimal digits we get the following, with the location of the prefix indicated with a pipe or ‘|’ character:

`2001:1234:abcd:0101 0|000 0000 0000`

Now if we set all the bits of the host section to 1 we get:

`2001:1234:abcd:0101 0|111 1111 1111`

Converting that back to hexadecimal we get:

`2001:1234:abcd:57ff`

And if we add all the rest of the host section we do indeed get:

`2001:1234:abcd:57ff:ffff:ffff:ffff:ffff`

So we do confirm that your estimation is correct.