WEBVTT

0:00:08.220000 --> 0:00:13.860000
 First, the other thing we pick up with
 IPv6 is we get a simplified header.

0:00:13.860000 --> 0:00:17.960000
 Now don't misunderstand and before I
 even bring up the image here, I want

0:00:17.960000 --> 0:00:22.480000
 to make sure we're clear on one very
 important word here and it's not

0:00:22.480000 --> 0:00:23.980000
 IPv6 and it's not header.

0:00:23.980000 --> 0:00:28.220000
 So I think you can figure
 out which one it is.

0:00:28.220000 --> 0:00:32.640000
 It's simplified header,
 not shorter.

0:00:32.640000 --> 0:00:34.480000
 Nobody ever said shorter.

0:00:34.480000 --> 0:00:43.680000
 You're not going to put two 128-bit
 addresses into an IPv6 header where

0:00:43.680000 --> 0:00:46.800000
 an IPv4 header only has
 32-bit addresses.

0:00:46.800000 --> 0:00:51.500000
 That's not going to happen without
 making the header larger.

0:00:51.500000 --> 0:00:54.940000
 So here it is. The header
 is definitely larger.

0:00:54.940000 --> 0:01:00.320000
 We have the IPv4 header on the left,
 the IPv6 header on the right and

0:01:00.320000 --> 0:01:06.920000
 as you can see, there's a little legend
 down there telling us which fields

0:01:06.920000 --> 0:01:11.480000
 have been kept and if you notice, there's
 only three fields that have

0:01:11.480000 --> 0:01:15.940000
 been kept unchanged from IPv4 to
 IPv6 and that's the version.

0:01:15.940000 --> 0:01:20.540000
 Now notice it says
 the field was kept.

0:01:20.540000 --> 0:01:23.080000
 Okay. Even just the name.

0:01:23.080000 --> 0:01:26.400000
 But not necessarily the contents.

0:01:26.400000 --> 0:01:31.100000
 In other words, version is of course
 going to flip from four to six.

0:01:31.100000 --> 0:01:35.620000
 So it doesn't have the same contents
 as far as the value.

0:01:35.620000 --> 0:01:39.560000
 I mean contents being version, yes,
 but it's going to switch the version

0:01:39.560000 --> 0:01:45.740000
 number. If you look at the IPv4, the
 next header is the IHL, which is

0:01:45.740000 --> 0:01:48.140000
 the IP header length.

0:01:48.140000 --> 0:01:52.980000
 Now, the reason for the header length
 is if you look down and we're going

0:01:52.980000 --> 0:01:57.520000
 to have to jump ahead just a little
 bit here to the bottom of the IPv4

0:01:57.520000 --> 0:02:01.940000
 header there where it says
 options and padding.

0:02:01.940000 --> 0:02:03.560000
 Well here's the problem.

0:02:03.560000 --> 0:02:09.800000
 The IPv4 header had available options
 in it that you could set and not

0:02:09.800000 --> 0:02:12.060000
 too many people used and we're
 not going to get into all that.

0:02:12.060000 --> 0:02:13.460000
 This is not an IPv4 class.

0:02:13.460000 --> 0:02:17.900000
 But there were available options
 and here became the question.

0:02:17.900000 --> 0:02:19.460000
 Are there options?

0:02:19.460000 --> 0:02:20.900000
 Aren't there options?

0:02:20.900000 --> 0:02:22.760000
 There's a reason we
 call them options.

0:02:22.760000 --> 0:02:24.420000
 It's because they're optional.

0:02:24.420000 --> 0:02:31.000000
 So how is the router who's just receiving
 10101010101, you know, a stream

0:02:31.000000 --> 0:02:36.420000
 of binary ones and zeros, how is he
 supposed to know, are there options

0:02:36.420000 --> 0:02:37.640000
 or aren't there?

0:02:37.640000 --> 0:02:41.900000
 What am I expecting to see after
 the destination address?

0:02:41.900000 --> 0:02:49.280000
 Should it be the start of the TCP or UDP
 header or are there options there?

0:02:49.280000 --> 0:02:51.780000
 What's there? I don't know.

0:02:51.780000 --> 0:02:55.460000
 And that's what the IP header
 length was used for.

0:02:55.460000 --> 0:02:59.380000
 Was to indicate whether options were
 there and let the receiving device

0:02:59.380000 --> 0:03:03.960000
 know, hey, do I need
 to look for options?

0:03:03.960000 --> 0:03:06.240000
 How long is this header?

0:03:06.240000 --> 0:03:09.520000
 And I know I'm making a big deal out
 of this, but I want you to understand

0:03:09.520000 --> 0:03:15.380000
 something. This is a big part of what
 we mean by a simplified header.

0:03:15.380000 --> 0:03:19.400000
 By not putting the options,
 look at the IPv6 header.

0:03:19.400000 --> 0:03:23.100000
 Also the fact that these are all in red,
 which means that they were killed

0:03:23.100000 --> 0:03:25.720000
 when we go to IPv6.

0:03:25.720000 --> 0:03:29.420000
 IPv6, they decided to handle
 this differently.

0:03:29.420000 --> 0:03:31.060000
 They said, okay, you know what?

0:03:31.060000 --> 0:03:34.860000
 The IPv6 header is going
 to be a fixed length.

0:03:34.860000 --> 0:03:38.680000
 What you see on the right
 is not variable.

0:03:38.680000 --> 0:03:43.420000
 Yes, it becomes 40 bytes
 instead of 20 bytes.

0:03:43.420000 --> 0:03:48.060000
 But the fact of the matter is, and when
 I say 20 bytes for the IPv4 header,

0:03:48.060000 --> 0:03:52.120000
 I'm also not including
 options in the padding.

0:03:52.120000 --> 0:03:55.320000
 And the reason for the padding, by the
 way, is the IP header has to land

0:03:55.320000 --> 0:03:56.980000
 on a 4-byte boundary.

0:03:56.980000 --> 0:04:00.740000
 So if the options were only 2 bytes,
 then you'd have 2 bytes of padding

0:04:00.740000 --> 0:04:14.800000
 and so on. Now, for the IPv6, it becomes
 longer, like we said, it becomes

0:04:14.800000 --> 0:04:17.580000
 40 bytes, but the fact of the
 matter is there's no options.

0:04:17.580000 --> 0:04:21.880000
 So if there's no options, there's
 no question how long's the header?

0:04:21.880000 --> 0:04:23.460000
 Let me help you out.

0:04:23.460000 --> 0:04:27.100000
 The first header, the IP, the first
 header on the first packet is going

0:04:27.100000 --> 0:04:31.300000
 to be 40 bytes. On the second packet,
 it's going to be 40 bytes.

0:04:31.300000 --> 0:04:37.560000
 And on the 897 millionth packet,
 it's going to be 40 bytes.

0:04:37.560000 --> 0:04:44.180000
 I don't need a header telling me how
 long, oh, yeah, the header is, if

0:04:44.180000 --> 0:04:46.600000
 it's always the same length.

0:04:46.600000 --> 0:04:52.700000
 So by making the IPv6 header a fixed
 header length, that does two things.

0:04:52.700000 --> 0:04:56.600000
 It eliminates the overhead of the IHL,
 which I know you're looking at

0:04:56.600000 --> 0:04:59.760000
 it and you're going to go and look
 not really very big anyway.

0:04:59.760000 --> 0:05:04.900000
 Agreed. It's not really necessarily about
 the packet efficiency and eliminating

0:05:04.900000 --> 0:05:12.960000
 the header. It's much, much more about
 saving once again the CPU on the

0:05:12.960000 --> 0:05:14.600000
 receiving device.

0:05:14.600000 --> 0:05:20.080000
 He doesn't have to look at that, process
 it, just to figure out, oh, this

0:05:20.080000 --> 0:05:29.700000
 header doesn't have packets out there,
 don't have the options on them.

0:05:29.700000 --> 0:05:36.620000
 So we had this header for really very,
 very minimal use and it just slowed

0:05:36.620000 --> 0:05:37.820000
 everything down.

0:05:37.820000 --> 0:05:46.000000
 So step one, make it a fixed header
 length and get rid of that header,

0:05:46.000000 --> 0:05:47.840000
 the header length field.

0:05:47.840000 --> 0:05:51.760000
 Next of course is the
 type of service field.

0:05:51.760000 --> 0:06:00.260000
 Type of service field or the toss byte
 is used for quality of service.

0:06:00.260000 --> 0:06:03.300000
 And that does not change in IPv6.

0:06:03.300000 --> 0:06:07.660000
 Notice that that field is in blue and
 what that means is that the name

0:06:07.660000 --> 0:06:10.680000
 and position have changed.

0:06:10.680000 --> 0:06:15.560000
 Okay. Position of course because it's
 right after version and name because

0:06:15.560000 --> 0:06:19.580000
 they decided to call it traffic class
 instead of type of service.

0:06:19.580000 --> 0:06:24.140000
 So it got a minor, I'm not going to spend
 a lot of time on that one, minor

0:06:24.140000 --> 0:06:26.920000
 facelift, that was about it.

0:06:26.920000 --> 0:06:31.580000
 The next header on the IPv4 side, I'm
 just going to compare the four to

0:06:31.580000 --> 0:06:36.100000
 six and then we'll hit that little
 unique guy up there, the new one on

0:06:36.100000 --> 0:06:38.120000
 IPv6 towards the end there.

0:06:38.120000 --> 0:06:43.020000
 But total length is the next one on
 IPv4 and again, this is so you know

0:06:43.020000 --> 0:06:45.420000
 how much was actually
 in the payload.

0:06:45.420000 --> 0:06:49.480000
 Well, this one they just modified because
 you know total length would

0:06:49.480000 --> 0:06:53.060000
 have been the total length of the entire
 layer three frame and then the

0:06:53.060000 --> 0:06:56.520000
 IHL was the length of the
 actual header itself.

0:06:56.520000 --> 0:07:01.080000
 Well, since our headers are fixed size,
 we don't need the IHL but we do

0:07:01.080000 --> 0:07:04.760000
 still have to know how long the payload
 is because that can of course

0:07:04.760000 --> 0:07:07.800000
 vary depending on your
 application and so on.

0:07:07.800000 --> 0:07:13.700000
 So again, it moved because they put flow
 label in there on the IPv6 side.

0:07:13.700000 --> 0:07:18.060000
 So it moved to after flow label on the
 right, we call it payload length

0:07:18.060000 --> 0:07:23.380000
 now, serves the exact same purpose
 and the exact same function.

0:07:23.380000 --> 0:07:31.520000
 Now back to the IPv4 side, we have a
 section here of three headers that

0:07:31.520000 --> 0:07:32.940000
 all go together.

0:07:32.940000 --> 0:07:38.000000
 The identification, the flags
 and the fragment offset.

0:07:38.000000 --> 0:07:42.920000
 Okay. Now basically what these three
 headers were pretty much used for

0:07:42.920000 --> 0:07:47.560000
 and flags is a little bit trickier
 but really identification fragment

0:07:47.560000 --> 0:07:52.960000
 offset. This was to if you had to do
 packet fragmentation, so if a packet

0:07:52.960000 --> 0:08:00.480000
 was too large for the MTU or the maximum
 transfer unit on a segment, then

0:08:00.480000 --> 0:08:03.820000
 we'd have to break that packet
 up into smaller chunks.

0:08:03.820000 --> 0:08:05.840000
 Well, that's great.

0:08:05.840000 --> 0:08:09.700000
 Take a big packet, chop it up,
 send it through the wire.

0:08:09.700000 --> 0:08:13.940000
 It's going to come out the other side
 and on the other side, it generally

0:08:13.940000 --> 0:08:17.260000
 helps if we can put
 it back together.

0:08:17.260000 --> 0:08:20.060000
 So we needed really
 two of these fields.

0:08:20.060000 --> 0:08:25.260000
 Now one of the flags is used to indicate
 that fragmentation has occurred.

0:08:25.260000 --> 0:08:32.400000
 Okay. So let the receiver know, hey,
 this packet is part of a fragment.

0:08:32.400000 --> 0:08:38.220000
 Then how would it know which fragments
 go back together to form the complete

0:08:38.220000 --> 0:08:42.440000
 packet again? Well, that's where
 the identification field came in.

0:08:42.440000 --> 0:08:46.740000
 So you would end up, if it made three
 fragments, you would end up with

0:08:46.740000 --> 0:08:50.600000
 three packets that had the same number
 in the identification field.

0:08:50.600000 --> 0:08:54.340000
 So it would know, okay, so these are
 the three pieces that make up the

0:08:54.340000 --> 0:08:55.440000
 original packet.

0:08:55.440000 --> 0:09:01.720000
 Then, over on the far right there of
 the IPv4 header, the fragment offset,

0:09:01.720000 --> 0:09:07.380000
 that's what told us which fragment
 of that packet this was.

0:09:07.380000 --> 0:09:12.940000
 So it was just an offset in bytes from
 immediately after the IP header,

0:09:12.940000 --> 0:09:15.760000
 how far is this fragment?

0:09:15.760000 --> 0:09:20.960000
 So it could reassemble the
 layer for and up payload.

0:09:20.960000 --> 0:09:25.600000
 So, if you notice, all three
 of those fields are in red.

0:09:25.600000 --> 0:09:33.200000
 They are gone. Now, does that mean
 we can't do fragmentation in IPv6?

0:09:33.200000 --> 0:09:37.860000
 This is one of those fun answers.

0:09:37.860000 --> 0:09:40.880000
 Sort of, but no, let's see.

0:09:40.880000 --> 0:09:47.520000
 What it means is that no interim device
 in the middle can do fragmentation

0:09:47.520000 --> 0:09:53.720000
 in IPv6. Okay. There are still
 fragmentation headers.

0:09:53.720000 --> 0:09:57.620000
 We're going to get to those on
 our next slide here coming up.

0:09:57.620000 --> 0:10:02.920000
 But the point is, you
 shouldn't have to.

0:10:02.920000 --> 0:10:05.320000
 I think that's the biggest thing.

0:10:05.320000 --> 0:10:09.300000
 We're going to talk about some things
 as we go here through this lesson.

0:10:09.300000 --> 0:10:12.720000
 But just to give you a little bit of
 a heads up, one of them is something

0:10:12.720000 --> 0:10:16.380000
 called path MTU discovery.

0:10:16.380000 --> 0:10:24.100000
 Basically, IPv6 will discover the full MTU
 on the entire path to the destination

0:10:24.100000 --> 0:10:27.060000
 before it starts sending.

0:10:27.060000 --> 0:10:32.160000
 So if there's a tunnel or something
 in the middle that makes your normal

0:10:32.160000 --> 0:10:40.240000
 1500 byte MTU only be allowed to be
 1460 bytes or something like that,

0:10:40.240000 --> 0:10:46.480000
 then what it comes down to is your sender,
 so your Windows machine, Linux,

0:10:46.480000 --> 0:10:51.680000
 Mac, whatever it is, it's going to
 know that before it starts sending

0:10:51.680000 --> 0:10:55.900000
 frames. So the fact of the matter is
 it should just generate the frames

0:10:55.900000 --> 0:11:00.020000
 at 1460 to begin with.

0:11:00.020000 --> 0:11:04.760000
 So if it's generating the frames at the
 appropriate size, then there should

0:11:04.760000 --> 0:11:09.140000
 be no reason in the world for anybody
 in the middle to have to fragment.

0:11:09.140000 --> 0:11:14.220000
 Because we already know how large of
 a frame or packet actually will fit

0:11:14.220000 --> 0:11:16.320000
 through our entire network.

0:11:16.320000 --> 0:11:20.200000
 So if all of those mechanisms are working
 correctly, then there should

0:11:20.200000 --> 0:11:22.340000
 never be a need for fragmentation.


0:11:22.340000 --> 0:11:27.520000
 That's part of why when they designed
 IPv6, we actually said that path

0:11:27.520000 --> 0:11:35.300000
 MTU discovery should be built in on
 running and working pretty much as

0:11:35.300000 --> 0:11:41.220000
 a requirement. If it's not, you can have
 connectivity problems with IPv6.

0:11:41.220000 --> 0:11:46.700000
 So it really pretty much needs to be
 on and enabled because we don't have

0:11:46.700000 --> 0:11:51.000000
 fragmentation flags and
 such readily available.

0:11:51.000000 --> 0:11:54.900000
 Now we can do it, but again, only the
 sender can do it, only the originating

0:11:54.900000 --> 0:12:00.960000
 machine. And if you read through the documentation,
 I'm one of those people,

0:12:00.960000 --> 0:12:03.900000
 I read it and go, yep,
 got all that, right?

0:12:03.900000 --> 0:12:07.080000
 And then I sit there and I ponder,
 you know, and I say, okay, well, if

0:12:07.080000 --> 0:12:14.840000
 the sending machine knows that the path
 MTU is, you know, 1460, why would

0:12:14.840000 --> 0:12:16.840000
 it ever have to actually fragment?


0:12:16.840000 --> 0:12:18.220000
 It should just be generating.

0:12:18.220000 --> 0:12:21.360000
 The only thing I've come up with is I
 guess if you had, you know, a really

0:12:21.360000 --> 0:12:26.100000
 badly written application or something,
 I suppose, that just always sent

0:12:26.100000 --> 0:12:27.920000
 at 1500 bytes, no matter what.

0:12:27.920000 --> 0:12:31.800000
 And then the underlying operating system,
 when it goes, you know, it goes

0:12:31.800000 --> 0:12:36.920000
 to put the packets in, goes, I
 can't do that and it fragments.

0:12:36.920000 --> 0:12:43.540000
 But I would find it to be incredibly
 rare in an IPv6 environment, okay?

0:12:43.540000 --> 0:12:52.180000
 All right, so over to the time to live
 field in IPv6, of course, the TTL.

0:12:52.180000 --> 0:12:55.480000
 This is, of course, to, and it's, this
 is another one that's a lot of

0:12:55.480000 --> 0:12:59.380000
 fun to listen to how people say
 things sometimes, you know.

0:12:59.380000 --> 0:13:03.400000
 The question I love to ask is
 what is the TTL field for?

0:13:03.400000 --> 0:13:09.660000
 And an answer I get so many times
 is it's to prevent loops in IPv4.

0:13:09.660000 --> 0:13:12.140000
 Like, oh, I so wish that was true.


0:13:12.140000 --> 0:13:14.920000
 It's not to prevent loops in IPv4.


0:13:14.920000 --> 0:13:21.460000
 It's if there is a loop to prevent the
 packet from looping indefinitely

0:13:21.460000 --> 0:13:26.320000
 and ultimately get removed
 from the wire.

0:13:26.320000 --> 0:13:30.660000
 To actually prevent the loops in IPv4,
 hopefully you're running a routing

0:13:30.660000 --> 0:13:33.420000
 protocol that has loop prevention.


0:13:33.420000 --> 0:13:36.020000
 So, but, you know,
 should that fail?

0:13:36.020000 --> 0:13:39.620000
 You know, there's certainly things you
 can do with routing protocols to

0:13:39.620000 --> 0:13:42.060000
 make the loop prevention
 not work correctly.

0:13:42.060000 --> 0:13:45.860000
 It's relatively easy to do.

0:13:45.860000 --> 0:13:47.700000
 That's what the TTL is for.

0:13:47.700000 --> 0:13:49.660000
 And again, we're not going to
 spend a ton of time on it.

0:13:49.660000 --> 0:13:52.500000
 It's the exact same field.

0:13:52.500000 --> 0:13:54.640000
 IPv6, except they renamed it.

0:13:54.640000 --> 0:13:56.500000
 So it's no longer time to live.

0:13:56.500000 --> 0:14:00.140000
 If you look over to the right there,
 it's now called hop limit.

0:14:00.140000 --> 0:14:05.240000
 And we have the same sort of thing
 going on with the protocol.

0:14:05.240000 --> 0:14:14.720000
 The protocol is basically to
 tell you what's next, right?

0:14:14.720000 --> 0:14:20.440000
 TCP, UDP, OSPF, EIGRP, GRE.

0:14:20.440000 --> 0:14:25.400000
 Any of the things that run directly
 on top of IP without running inside

0:14:25.400000 --> 0:14:30.520000
 of TCP or UDP. Now, if it's an application
 inside of TCP or UDP, then

0:14:30.520000 --> 0:14:34.300000
 of course it comes down to port number
 to know what application everything

0:14:34.300000 --> 0:14:38.780000
 goes to. But this is just for the layer
 three header to be able to identify

0:14:38.780000 --> 0:14:40.580000
 the layer four header.

0:14:40.580000 --> 0:14:46.040000
 Now, if you look to the right, notice
 that they renamed that to next header.

0:14:46.040000 --> 0:14:59.000000
 Now, could that next header still be
 OSPF, EIGRP, UDP, TCP, of course.

0:14:59.000000 --> 0:15:03.700000
 But the reason they changed it from
 protocol to next header, that name

0:15:03.700000 --> 0:15:06.940000
 will become clear I think
 on the next slide, okay?

0:15:06.940000 --> 0:15:11.900000
 Because the next header could
 be another IPv6 header.

0:15:11.900000 --> 0:15:15.120000
 It may not be TCP or UDP yet.

0:15:15.120000 --> 0:15:19.260000
 IPv6 may just have more than
 it needs to tell you, okay?

0:15:19.260000 --> 0:15:21.600000
 So that's why they changed
 the name of that one.

0:15:21.600000 --> 0:15:25.380000
 Now, back to the left again,
 header checksum.

0:15:25.380000 --> 0:15:30.660000
 This sort of comes down, I think
 a little bit to history here.

0:15:30.660000 --> 0:15:35.040000
 You got to remember that IPv4 was developed
 by the Department of Defense,

0:15:35.040000 --> 0:15:37.960000
 the DARPA project and all
 that kind of fun stuff.

0:15:37.960000 --> 0:15:43.940000
 And when it was written,
 there was no standard.

0:15:43.940000 --> 0:15:48.020000
 It wasn't running on the OSI
 model or anything like that.

0:15:48.020000 --> 0:15:50.420000
 In fact, they called
 it the DoD model.

0:15:50.420000 --> 0:15:54.460000
 And if anybody's recently come through
 CCNA, I know I'm probably giving

0:15:54.460000 --> 0:15:56.740000
 you horrible flashbacks
 or something here.

0:15:56.740000 --> 0:16:01.720000
 But the fact of the matter is, the problem
 with the DoD model that this

0:16:01.720000 --> 0:16:10.260000
 was built on is that it was not as
 much as the network connectivity.

0:16:10.260000 --> 0:16:12.760000
 And it depends what documents you
 look at, what they named it.

0:16:12.760000 --> 0:16:16.800000
 But basically what I'm trying to get
 at is there was no specification

0:16:16.800000 --> 0:16:22.280000
 to say that layer two should
 be doing error checking.

0:16:22.280000 --> 0:16:28.140000
 Well, if layer two is not doing error
 checking, then they had the attitude

0:16:28.140000 --> 0:16:32.080000
 of, well then IPv4,
 better check itself.

0:16:32.080000 --> 0:16:36.200000
 So let's put in this header check sum
 to make sure that the IPv4 header

0:16:36.200000 --> 0:16:38.000000
 didn't get corrupted.

0:16:38.000000 --> 0:16:41.420000
 Okay, great. But now move forward.


0:16:41.420000 --> 0:16:45.520000
 We get the OSI model and we get all
 of these standards for layer two.

0:16:45.520000 --> 0:16:48.360000
 And they all have something
 in common.

0:16:48.360000 --> 0:16:53.420000
 If you're talking about Ethernet, PPP,
 Frame Relay, even all the way to

0:16:53.420000 --> 0:16:58.880000
 x.25, ISDN, all of these, they
 all had one thing in common.

0:16:58.880000 --> 0:17:02.560000
 It may have only been one thing in common,
 but they had one thing in common.

0:17:02.560000 --> 0:17:05.280000
 They all did error checking.

0:17:05.280000 --> 0:17:09.440000
 Now some of them went so far as to
 do correcting as far as, you know,

0:17:09.440000 --> 0:17:13.440000
 maybe even trying to fix the problem,
 some just checked for the error.

0:17:13.440000 --> 0:17:15.940000
 But either way, they all
 did error checking.

0:17:15.940000 --> 0:17:21.120000
 So if layer two is already checking the
 entire frame to make sure it hasn't

0:17:21.120000 --> 0:17:26.020000
 been corrupted in transit, then why
 in the world should the layer three

0:17:26.020000 --> 0:17:29.160000
 header be checking itself?

0:17:29.160000 --> 0:17:30.740000
 There's no need for that.

0:17:30.740000 --> 0:17:34.600000
 So as you can see on
 the right, it's gone.

0:17:34.600000 --> 0:17:42.120000
 One less calculation that the receiving
 router has to do once again.

0:17:42.120000 --> 0:17:44.760000
 Okay, so again, good thing.

0:17:44.760000 --> 0:17:47.420000
 Save CPU, you notice a trend here.


0:17:47.420000 --> 0:17:52.460000
 With the IHL gone, the header check
 sum gone, broadcast's gone.

0:17:52.460000 --> 0:17:55.740000
 Yes, our header gets longer.

0:17:55.740000 --> 0:18:01.940000
 However, it really saves a
 lot of CPU on the devices.

0:18:01.940000 --> 0:18:07.620000
 Now all of that said and truth be told,
 I don't know, on today's devices,

0:18:07.620000 --> 0:18:12.100000
 do we really think it makes that
 much of a difference on the CPU?

0:18:12.100000 --> 0:18:15.680000
 I don't know. We could call
 that a political discussion.

0:18:15.680000 --> 0:18:17.960000
 I'm not going to get into.

0:18:17.960000 --> 0:18:20.500000
 I'm just going to
 stick with facts.

0:18:20.500000 --> 0:18:29.840000
 Okay, it does take less CPU to process
 IPv6 frames than it does IPv4.

0:18:29.840000 --> 0:18:35.200000
 Okay, whether that makes any difference
 on today's equipment, who's to

0:18:35.200000 --> 0:18:40.460000
 say? In fact, if you look at packet
 forwarding statistics for a lot of

0:18:40.460000 --> 0:18:44.640000
 the devices, you'll actually find that
 a lot of the devices actually forward

0:18:44.640000 --> 0:18:48.660000
 IPv4 traffic faster than IPv6.

0:18:48.660000 --> 0:18:50.700000
 If you look at the spec sheets.

0:18:50.700000 --> 0:18:55.180000
 And I think a lot of that has to do with
 optimization and CPU prioritization

0:18:55.180000 --> 0:18:57.720000
 within the devices and
 such at this point.

0:18:57.720000 --> 0:19:06.840000
 I mean, I can tell you from a pure technical
 standpoint, IPv6 processing

0:19:06.840000 --> 0:19:10.640000
 should be faster than IPv4.

0:19:10.640000 --> 0:19:14.940000
 But I can also tell you on a realistic
 side that again, if you look at

0:19:14.940000 --> 0:19:20.120000
 device specifications, that's not the
 case right now for a lot of equipment.

0:19:20.120000 --> 0:19:25.560000
 Okay, some of it is equal, but a lot of
 it, IPv6 processing is just slower.

0:19:25.560000 --> 0:19:30.100000
 And I think for some devices, not mostly
 not Cisco, but I think for a

0:19:30.100000 --> 0:19:33.480000
 lot of devices that could just come down
 to the fact that a lot of devices

0:19:33.480000 --> 0:19:40.800000
 are implementing all of this
 in the application there yet.

0:19:40.800000 --> 0:19:43.840000
 So we'll see this
 change, of course.

0:19:43.840000 --> 0:19:47.780000
 But for right now, just watch the specs
 on the devices you're going to

0:19:47.780000 --> 0:19:53.280000
 use because they may in fact have
 slower IPv6 forwarding rates.

0:19:53.280000 --> 0:19:57.380000
 All right, I think I already covered
 the options in padding at the bottom

0:19:57.380000 --> 0:20:00.980000
 there, as far as the
 IPv4 header goes.

0:20:00.980000 --> 0:20:05.640000
 And of course, the other two are the
 source and destination address.

0:20:05.640000 --> 0:20:07.280000
 None of this would
 work without that.

0:20:07.280000 --> 0:20:12.980000
 And of course, those are the fields
 that get much larger in IPv6.

0:20:12.980000 --> 0:20:16.200000
 I'm sure you already know, I mean,
 I have a slide coming up on it.

0:20:16.200000 --> 0:20:20.420000
 But if you're even watching this, I'm
 sure you're already aware of the

0:20:20.420000 --> 0:20:23.500000
 fact that we go to
 128-bit address.

0:20:23.500000 --> 0:20:30.340000
 Okay, so that means we are now
 talking about 16 octets.

0:20:30.340000 --> 0:20:34.280000
 Essentially, we don't call them octets
 anymore, we call them fields because

0:20:34.280000 --> 0:20:37.040000
 we break them up into
 16-bit fields.

0:20:37.040000 --> 0:20:40.520000
 But you understand the point I'm trying
 to make is that, you know, they

0:20:40.520000 --> 0:20:48.120000
 are four times just bitwise, they
 are four times the size of IPv4.

0:20:48.120000 --> 0:20:51.940000
 Well, that doesn't fit in a header
 without the source and destination

0:20:51.940000 --> 0:20:54.520000
 addresses getting four
 times the size.

0:20:54.520000 --> 0:20:56.520000
 So that's, you know, there it is.

0:20:56.520000 --> 0:20:58.120000
 You can see it there.

0:20:58.120000 --> 0:20:59.860000
 And of course, they
 just get bigger.

