So let's kick off our discussion of IS-IS support for IPv6
by just doing a quick review of some basic IPv6 principles.
So we'll start off with taking a look at how
to do some address conversions.
Just in case at some point we need
to convert addresses from say decimal to binary or binary
to hex, since IPv6 uses hexadecimal for its addressing,
this could be a useful skill.
Then we'll take a look at IPv6 addressing,
we'll go over how it's formatted,
and the most important part is how to properly shorten
the addresses.
We don't want to have to type in 128-bit address
every time we put these into the routers.
So we need to know how to shorten them
but shorten them in a way that we won't actually
alter the address itself.
So it has to be shortened properly.
Then let's wrap up with a quick discussion
of neighbor discovery.
IPv6 doesn't use ARP or address resolution protocol
like IPv4 does, rather it uses neighbor discovery.
So we'll do an overview of that as well.
So let's jump in and start by doing some decimal to hex
and hex to binary conversions so we understand
how these numbers correlate.
So to start off with, we will do some decimal
to binary conversion.
And we have a conversion chart over here
just for convenience that just lists out the binary values
from the least significant bit which
is the one over here going over to the most
significant bit which, of course, is represented by 128.
So the way we take a decimal number say 137
and we convert this to binary, is
we simply look at each digit in our conversion chart
and we ask if that's greater than the number
we want to convert.
So for example in this case, 137 is greater than 128.
So we would simply put a one in this spot
and subtract 128 from the value that we're trying to convert.
The answer here, of course, is 9.
And then we look over and we look at this 64 value.
Is there a 64 in 9?
And, of course, the answer to this is going to be no.
So this is a zero.
Neither is there a 32 or a 16.
Now, of course, there's an 8.
And, of course, we don't really have to spell this out.
At this point the math is fairly simple.
But just for completeness, this, of course,
is going to come down to the one.
So what we end up with here is 137 in binary is 10001001.
So it's simply a matter of subtracting each value that's
in the original number.
And, of course, to convert it back
we would do exactly the opposite.
Let's say we simply had a value of 11011001.
To convert that back, we would simply take the first value
128, we would add the next value which, of course, is 64,
this is going to be 192.
Then we add 16 to that, 208.
We add 8 to that, which is 216.
And then we add 1 to that.
And our grand total here is 217.
So 11011001 would be 217 in decimal.
So next up let's take a look at converting this
from binary to hex.
So in this case, we'll just use the same number.
I just drove the 217 up here to clear up some space.
To convert this to hex, what we're essentially going to do
is split the number in half.
So we're going to take our binary number
and split it like this, and then we're
going to convert this section of the number based off
of this part of the scale.
So in other words, this is going to become a one,
this would be the two, this would be the four,
this would be the eight.
So if we take our 8 plus our 4, of course, that's 12, plus 1,
we end up with 13 for the left side of this number.
For the other side, this is fairly straightforward,
we only have an 8 and a 1.
So this side simply becomes 9.
Now 9 fits, of course, in a single digit.
So part of our answer here is going
to be that this is going to be a 9.
13, of course, gets a little bit more interesting.
Once we get past single digits, of course, what we have to do
is use a slightly different conversion chart.
So what we have are the values of 10, 11, 12, 13, 14, and 15.
And these, of course, are going to convert
to A, B, C, D, E, and F.
So in this case, since we're talking about a 13,
it's going to be this entry right here.
And that means that our final answer for our conversion
is going to be D9.
So what we see is this value that's 217 in decimal
is D9 in hex.
The big thing to remember with hexadecimal, when you're
going to convert it back to binary,
is you want to treat the two digits separately and then
remember to convert them on the scale of dealing
with four bits at a time meaning we're only
going to be dealing with the values of 1, 2, 4, and 8.
So now let's talk about how we use this hexadecimal
in our addressing.
So a couple of things to keep in mind.
First is, of course, IPv6 addresses are 128 bits.
So this makes them exponentially larger than the 32 bits
we have in IPv4.
This is a very very large number.
We split this up when we're entering it into devices
into 816-bit hex fields.
These hex fields will be separated by a colon.
So for example, we could have something like DB8:100:13:4
and so on.
The important thing here is these addresses can be
and in fact will be by the devices themselves shortened.
Now, we have some rules for shortening these.
First, any consecutive zeros can be eliminated.
But we can only do this once.
This is done with double colons in the address.
So for example, I could say 2001::1 could be a valid IPv6
address.
I'm eliminating a ton of zeros between these two colons.
The way this works is the devices
will split the address right between the colons,
move the front part to the left of the field,
move the right section to the right side of the field,
and fill in x number of zeros however
many zeroes it takes to make this 128 bits.
So you could eliminate two fields
of zeros, four fields of zeros.
In this example, I eliminated six fields of zeros.
The other rule for shortening these addresses
is that leading zeros can be eliminated in any given field.
Now, this one you might have noticed,
I do just out of habit.
I already did it numerous times on our examples here.
There should have been a zero in front of this,
there should have been a zero right here,
there should have been two zeros in here,
there should have been three zeros in here.
So I already did it when I was just writing out the numbers.
There should have been three zeros over here as well,
but I just eliminated them because there's no difference.
And if you think about it in terms
of something say like your paycheck,
if your paycheck is going to be--
we'll just make this real easy.
Let's say your paycheck is $1000, well,
you're not going to really care if instead of $1,000
your company gives you 001000.
You wouldn't really care if your paycheck said this,
because that's still 1000.
When you go to deposit your check
or in the bank looks at this they're
going to go oh, yeah, well, that's interesting and all.
But yeah, we don't care about that.
That doesn't change the value.
However, you might care a whole lot at least
I probably would if instead they eliminated trailing zeros
and instead gave you $10.
I'm sure like me you would be sitting there going, excuse me,
where are the rest of my digits.
The bank might be OK with this, your company
may be OK with this, I'm guessing
you probably wouldn't be.
So what I'm trying to point out here,
of course, is that leading zeros really don't mean anything
but trailing zeros are critical.
You see if we look at this field right up
here as an example, that's supposed to be 100,
or we could say 100.
Well, if I eliminated trailing zeros,
it would become a 10 or maybe just a 1 by itself.
Leading zeros don't matter, trailing zeros matter a lot.
We can only eliminate leading zeros in a field.
But, again, those can be eliminated with no problems.
So let's look at this other example.
If we look at our rules here, the 2001
would have to stay a 2001, then we could eliminate this zero.
So this would become DB8.
We could eliminate this zero.
So, again, this would become 100.
Then we could eliminate this field, this field,
and this field just by doing double colons.
We could drop this zero and make this just 118.
And, of course, the last one we can drop these three fields
and just make it a 1.
So that's the proper way to shorten an IPv6 address.
Now, something else to discuss about IPv6
addressing is a new type of addressing
that we have in IPv6 called Link Local Addresses.
Now, there's some special things about these addresses.
First, they are from a given known range of addresses.
So they're all from the FE80/10 address range.
Also, since they are linked local,
they are not ratable, that's what
the word local is implying that this traffic can't
leave this segment.
Now, that brings up an interesting side effect
on our devices which can actually be quite useful.
Since they're not routable well, that
means that all of the interfaces on a router can be the same.
Meaning use the same address.
So if I had a router, for example,
and I had we'll just make it easy,
we'll just have three interfaces off of it,
that means that I can have the address on this interface be
FE80::1.
This interface could be FE80::1.
And this one could be FE80::1.
And this can be very handy particularly if this is say,
router one because we can use this then
to identify the device.
Now, of course, if there's a router
on the other end of this circuit, any of these cables
it would have to have a different address.
That's what we're saying with this fourth point over here
that addresses on the same link must be unique.
So that means that I could not put another router down here
and try to give it the address FE80::1 because that would be
on the same segment.
So in order for this to be valid,
I would have to make it a two or well,
anything else, anything other than a one.
Also, this is a quick note.
Our iOS XE devices do support something called IPv6
scoped address architecture.
This is referenced in RFC 4007.
It's not a very popular implementation.
I would just be aware that iOS XE supports it.
And finally, as we mentioned during the introduction,
IPv6 does not support ARP, which is address resolution
protocol used by IPv4, rather we use something
called neighbor discovery.
The job here is still to do layer 3 to layer 2 address
translation.
However, this is now part of ICMPv6.
Depending how well you remember IPv4,
you may remember that ARP was actually
a completely separate protocol.
It's not part of the IP stack.
With IPv6 it is.
It's been moved into ICMP.
Now, for neighbor discovery, it uses a type 135 ICMP message.
For the neighbor advertisement, which
is essentially the answer to the request, this uses type 136.
Something else that's built into neighbor discovery that's
a little bit unique to IPv6 is something
called a router advertisement.
Routers actually advertise themselves
onto the network in IPv6.
Again, this is essentially part of neighbor discovery.
It's also part of ICMP version 6.
But this uses type 134.
So we'll see some of this stuff in use
as we move through the rest of the videos in this skill.
In this video, we jumped in and got what
I'm hoping is a review on IPv6.
So we started off by looking at how
to do some address conversions from decimal to hex and hex
to binary, and all that fun stuff.
And then we took a look at the IPv6 addresses themselves.
How to shorten them properly, we talked a little bit
about link local addressing.
And then, of course, we wrapped up here
with our discussion of neighbor discovery
which is what we use in IPv6 instead of ARP.
I hope this has been informative for you
and I'd like to thank you for viewing.