Data Communication - N10-008 CompTIA Network+ : 1.1

Summary

This script explains the concept of PDUs or protocol data units in networking, detailing how data is encapsulated and transferred across the network within Ethernet frames, IP packets, TCP/UDP segments, and DLC frames. It discusses the importance of headers for data processing, the role of control flags in TCP and IP headers, and the impact of MTU on data fragmentation. The script also covers methods to determine MTU size using the ping utility, emphasizing the need for optimizing network communication to avoid fragmentation and improve throughput.

Takeaways

• 📦 PDUs, or Protocol Data Units, are the fundamental units of data transmission in a network, encapsulating data for transfer from one device to another.
• 🔌 Ethernet frames are a type of PDU used in local area networks, encapsulating data regardless of its content for transmission between MAC addresses.
• 🌐 At the IP layer (Layer 3), data is sent across the network from one IP address to another, with the IP layer not concerned about the data's content.
• 📚 The OSI model illustrates the encapsulation process, with each layer adding its own header to the data, from the application down to the physical layer.
• 🔄 Encapsulation involves adding headers to data at each OSI layer, while decapsulation is the reverse process, removing headers to access the application data.
• 🌀 TCP and UDP are transport layer protocols (Layer 4) that add their headers to the data, with TCP providing reliable, ordered delivery and UDP offering faster, connectionless service.
• 📈 Control flags within TCP and UDP headers, such as SYN, PSH, RST, and FIN, dictate how data should be processed and managed during transmission.
• 🔍 The maximum transmission unit (MTU) determines the largest size of data that can be sent over a network without fragmentation, affecting network efficiency.
• 🧩 Fragmentation occurs when data exceeds the MTU, requiring the data to be split into smaller packets, which can slow down network traffic and require reassembly at the destination.
• 🛠️ Tools like the ping utility can be used to test MTU sizes by sending packets with the 'Don't Fragment' bit set to determine the largest unfragmented packet size.
• 🔄 The process of determining MTU can be complex, especially in networks with multiple hops, and may require manual configuration if ICMP is filtered.

Q & A

What is a PDU or protocol data unit in the context of networking?

A PDU, or protocol data unit, is a single unit of data that is transmitted across a network. It is used to encapsulate data at various layers of the OSI model, allowing it to be sent from one device to another.

Why are Ethernet frames used in data transmission?

Ethernet frames are used to encapsulate all the data that needs to be sent from one MAC address to another on the network. Ethernet doesn't concern itself with the content of the frame, only that it is transmitted correctly.

What is the role of the IP layer in data transmission?

The IP layer, also known as layer 3, is responsible for sending data across the network from one IP address to another. It encapsulates the data within an IP packet without concern for the type of data it contains.

How does TCP or UDP data relate to the IP layer?

TCP (Transmission Control Protocol) and UDP (User Datagram Protocol) data are encapsulated within the IP layer. The IP layer is unaware of the specifics of the data it carries, focusing only on moving the data from one IP address to another.

What is the purpose of encapsulation in the OSI model?

Encapsulation in the OSI model is the process of adding headers to data at each layer as it moves down the stack. This process allows the data to be properly formatted and addressed for transmission across the network.

Can you explain the decapsulating process in networking?

Decapsulation is the reverse process of encapsulation. It involves the removal of headers from data as it moves up the OSI model at the receiving device, allowing the device to access the original application data.

What are the functions of TCP flags in data transmission?

TCP flags are control bits within the TCP header that provide instructions on how the data should be processed as it travels through the network. Flags like SYN, ACK, PSH, RST, and FIN have specific meanings that affect the flow and state of the data transmission.

What is the significance of the MTU in networking?

The Maximum Transmission Unit (MTU) is the largest size of a data packet that can be transmitted over a network without needing to be fragmented. It is important for optimizing network communication and avoiding the overhead associated with fragmentation.

Why is it important to know the MTU value in a network?

Knowing the MTU value is important because it helps in ensuring that data packets are not unnecessarily fragmented, which can slow down network traffic and reduce throughput. It also helps in avoiding issues when data needs to be sent over networks with different MTU settings.

What is the 'Don't Fragment' bit in IP headers, and why is it used?

The 'Don't Fragment' bit in IP headers is a flag that, when set, indicates that the data should not be fragmented as it travels through the network. It is used to ensure that the data packet remains intact or to prevent fragmentation when the network cannot handle the packet size.

How can the ping utility be used to test the MTU of a network?

The ping utility can be used with the '-f' flag to set the 'Don't Fragment' bit and the '-l' flag to specify the length of the data in bytes. This can help determine the largest packet size that can be sent across the network without fragmentation.

Outlines

00:00

🔌 Understanding PDUs and Data Encapsulation

This paragraph explains the concept of a Protocol Data Unit (PDU), which is a fundamental unit of data transmission in a network. It discusses how data is encapsulated at various layers of the OSI model, including Ethernet frames, IP packets, TCP segments, and UDP datagrams. The process of encapsulation involves adding headers at each layer to facilitate the transfer of data from one device to another across the network. The paragraph also describes the de-encapsulation process at the destination device, which involves removing the headers to access the application data. The importance of headers in conveying control information is highlighted, with an example of how the TCP header includes flags that guide the processing of data within the network.

05:02

📋 Control Flags and Network Communication Efficiency

The second paragraph delves into the specifics of control flags within TCP and IP headers, which are crucial for managing data flow and processing within a network. It explains how flags such as SYN, PSH, RST, and FIN within the TCP header can affect network communication. The paragraph also touches on IP header flags related to data fragmentation, the role of the Maximum Transmission Unit (MTU) in determining the size of data packets that can be sent without fragmentation, and the impact of network architecture on MTU values. The importance of optimizing network communication to avoid fragmentation is emphasized, as it can improve throughput and reduce the overhead associated with reassembling fragmented data packets.

10:03

🌐 Testing Network MTU and Fragmentation

The final paragraph focuses on practical methods for testing the Maximum Transmission Unit (MTU) of a network, which is essential for understanding the network's capacity to handle data packets without fragmentation. It describes how to use the ping utility with the Don't Fragment (DF) bit set to determine the MTU by sending specific sizes of data and observing whether they can traverse the network without needing to be fragmented. The example provided demonstrates how to use the ping command with the -f and -l flags in Windows to test the MTU to Google's DNS server. The paragraph explains the implications of setting the DF bit and the potential for receiving ICMP messages if the data size exceeds the network's MTU, highlighting the need to adjust MTU settings in scenarios like VPN usage.

Keywords

💡PDU

PDU, or Protocol Data Unit, is a fundamental concept in networking that refers to the data structure used at different layers of the OSI model for transmission. In the video, PDUs are described as units of data being transferred across the network, encapsulating various types of data such as Ethernet frames, IP packets, TCP segments, and UDP datagrams. The concept of PDUs is central to understanding how data moves within a network, as it highlights the process of data encapsulation and transmission at different layers.

💡Ethernet

Ethernet is a widely used technology in local area networks (LANs) for data transmission. The script mentions Ethernet as a means of sending data within an Ethernet frame from one device to another, based on their MAC addresses. Ethernet frames encapsulate the data and control information necessary for the data to be sent across the network. The video uses Ethernet as an example to illustrate the process of data encapsulation at the data link layer of the OSI model.

💡IP Layer

The IP layer, also known as layer 3 of the OSI model, is responsible for the transmission of data packets across different networks from one IP address to another. The script explains that the IP layer does not concern itself with the content of the data but focuses on routing the data to its destination. IP packets are a key concept in the video, as they encapsulate data from the transport layer and include essential information for routing and fragmentation.

💡TCP

TCP, or Transmission Control Protocol, is a transport layer protocol that provides reliable, ordered, and error-checked delivery of a stream of data between applications. The video script discusses TCP headers and segments, emphasizing how TCP ensures data integrity and order through mechanisms like sequence numbers and acknowledgments. TCP is a critical component in the process of data encapsulation and transmission, as it adds reliability to the data transfer process.

💡UDP

UDP, or User Datagram Protocol, is another transport layer protocol that is used for sending messages without establishing a connection between the communication partners. Unlike TCP, UDP is connectionless and does not guarantee data integrity or order. The script mentions UDP datagrams as part of the data encapsulation process, illustrating an alternative to TCP when reliability is not a primary concern.

💡Encapsulation

Encapsulation in networking refers to the process of wrapping data with necessary headers and trailers as it moves down the OSI model layers. The script describes encapsulation as the method by which application data is packaged with TCP, IP, and Ethernet headers before being sent over the network. This process is essential for the video's theme, as it shows how data is prepared for transmission and how each layer contributes to the overall data packet structure.

💡Decapsulation

Decapsulation is the reverse process of encapsulation, where the headers are removed as data moves up the OSI model layers towards its final destination. The video script explains that the destination device decapsulates the data by removing the Ethernet frame header, IP header, and TCP header to access the application data. Decapsulation is crucial for understanding how data is processed and made usable once it reaches its destination.

💡OSI Model

The OSI, or Open Systems Interconnection, model is a framework used to understand how data is transmitted in a network. The script provides an illustrated view of how data is encapsulated and decapsulated at each layer of the OSI model. The OSI model is central to the video's narrative, as it structures the explanation of data transmission processes and the role of each layer in that process.

💡TCP Flags

TCP flags are control bits within the TCP header that provide instructions on how to process the data during transmission. The script discusses various TCP flags such as SYN (synchronization), PSH (push), RST (reset), and FIN (finish), explaining their roles in controlling the flow and state of a TCP connection. TCP flags are a key concept in the video, as they illustrate the control mechanisms within the TCP protocol.

💡MTU

MTU, or Maximum Transmission Unit, refers to the largest size of a data packet that can be transmitted over a network without needing to be fragmented. The script explains the importance of MTU in network design and how it affects data transmission, especially in scenarios involving network tunnels or VPNs. MTU is a critical concept in the video, as it relates to network efficiency and the need to avoid fragmentation for optimal data flow.

💡Fragmentation

Fragmentation is the process of dividing a large data packet into smaller pieces so that it can traverse networks with smaller MTUs. The script describes how fragmentation can occur when the size of the data exceeds the MTU of a network and how it can impact network performance. Fragmentation is an important concept in the video, as it demonstrates the challenges in data transmission and the need for network optimization.

💡ICMP

ICMP, or Internet Control Message Protocol, is used by network devices to communicate error messages and operational information. The script mentions ICMP in the context of MTU discovery and the potential issues that can arise if ICMP is filtered, preventing automated MTU determination. ICMP is relevant to the video's theme, as it highlights the protocols involved in network communication and error handling.

💡VPN

A VPN, or Virtual Private Network, is a technology that creates a secure, encrypted connection over a public network. The script discusses the impact of VPNs on MTU settings, as VPN tunnels may require different MTU values to function correctly. VPNs are mentioned in the video to illustrate the need for proper MTU configuration in various networking scenarios.

Highlights

PDU, or protocol data unit, is essential for moving data across the network.

PDUs are sometimes referred to as transmission units.

Ethernet sends data within an Ethernet frame from one device to another.

Ethernet does not care about the content inside the frame, only the encapsulation.

Layer 3, or the IP layer, sends data from one IP address to another, regardless of the content.

TCP and UDP are types of data that can be encapsulated within an IP packet.

TCP and UDP headers are part of the encapsulation process in network communication.

Data encapsulation in the OSI model involves layers 5, 6, and 7 for application data.

TCP protocol is used to transport application data across the network.

IP header is added for sending TCP data and application data from one IP address to another.

DLC, or data link control, layer 2 frame header is used in Ethernet for encapsulating data.

Encapsulation and decapsulation processes are crucial for network interoperability.

Application data is encapsulated with TCP header, IP header, and frame header for transmission.

Decapsulation involves removing frame headers and IP headers to access the application data.

TCP flags like SYN, PSH, RST, and FIN control how data is processed in the network.

IP header flags deal with data fragmentation and are crucial for network efficiency.

Maximum Transmission Unit (MTU) determines the maximum size of data that can be sent without fragmentation.

Fragmentation of data can slow down network traffic and is undesirable.

MTU value is important for optimizing network communication and avoiding fragmentation.

Testing MTU using the ping utility can help determine the maximum data size that can be sent without fragmentation.

Transcripts

Getting data moved from one part of the network

to the other relies on something called

a PDU, or a protocol data unit.

Sometimes you'll hear these referred to

as transmission units, because we're

taking a little bit of data and transferring it

across the network as a single unit.

For example, if we're running Ethernet,

we know that Ethernet is going to send everything

within an Ethernet frame from one device or MAC address

on the network to another MAC address that's on the network.

Ethernet, though, doesn't care what's

on the inside of this particular frame.

It's simply encapsulating all of the data that

may be underneath it and sending that across the network.

A similar thing happens at the next layer up with layer 3,

or the IP layer, where everything within the IP layer

is being sent across the network from one IP address

to the other.

Inside of that IP packet is UDP data, TCP data,

or some other type of data, but IP doesn't

care what's on the inside.

It simply knows that it's moving data

across the network from one IP address to another.

And where there is a TCP header or UDP header,

there's probably going to be a TCP segment, or what

we call a UDP datagram within that particular part

of the packet.

Here's an illustrated view of how

this operates at each layer of the OSI model,

and how data is encapsulated between each one

of those parts.

For example, let's start with using an application.

We're sending data within our application,

such as a web browser, and we need

to get that data sent from the web server to the web client.

That application data exists at OSI layers

5, 6, and 7, or what we will generically

call the application layers.

To be able to send that application data,

we need to transport it across the network using the TCP

protocol, so we'll put a TCP header right

in front of that application data

and send it across using that OSI layer 4,

or transport layer.

We have to have an IP address that

is able to send this TCP data and the application data that

might be inside of it, so we need

to add an IP header so that we can send information

from one IP address to another IP address.

And lastly, over Ethernet, we need

to have a DLC, or data link control, layer 2 frame header.

And in many cases, there's also a frame trailer

to indicate where the end of this frame might be.

The layer 2 frame header encapsulates

all of the information within.

So inside of this frame will be an IP header, a TCP header,

and ultimately, the application data

that we would like to send to the other side of the network.

Let's expand this view to show both the sending and receiving

device, and view the way the network might

interoperate with all of this.

So there's our application data at OSI layers 5, 6, and 7.

On the left side is the source address

that's sending this data, and we somehow

want to get that application data

to this destination device on the other side of the network.

We'll start by encapsulating this data by

including a TCP header, an IP header, and ultimately,

the frame header and frame trailer.

That information is going to be sent across the network, where

it will then be received by the destination device.

The destination device, though, needs the application data

that's inside--

it doesn't need all of this other information.

So it will begin decapsulating this information-- removing

the frame headers, removing the IP header,

and ultimately removing the TCP header

so that it can then access the application data.

And finally, we've been able to transfer this data

from the source device through the encapsulation

process, the decapsulation process,

and finally be able to receive the application

data at the destination.

Here's another way to visualize how

this data is being encapsulated and decapsulated on both sides.

We can start with our layer 5 through 7 application, data

such as HTTPS, IMAP email information, or SSH terminal

screens, where we're then going to take all of that

and encapsulate it within some type of layer for protocol.

This is commonly TCP or UDP.

We will then encapsulate the layer 4 traffic

within layer 3--

which, these days, is commonly IP traffic--

And then finally, layer 2 information on Ethernet.

That would be a media access control address or MAC address,

and that encapsulates all of this data within it.

In previous views of this data, we

mentioned that there's header information that

precedes the data associated with these layers.

And the header information is important

because it tells the rest of the data how

it should be processed.

For example, on layer 4, we have TCP data.

And within the TCP header, such as we have here,

there's information called a TCP flag.

This helps us understand how we can process this data as it's

going through the network.

This control information is setting

bits that are within the header of this packet,

and each one of those bits has a particular definition.

This means that the device that's receiving this data

can interpret those bits and understand how

to process the data properly.

We call these bits control flags,

and we can identify whether a flag has

been turned on or turned off, and then

decide how these particular flags can affect the data flow.

For example, we can look at the flags

in this particular protocol decode

and we can see that one flag has been set to 1.

That means the data that's contained within this TCP

part of the packet is acknowledgment data that

has been set.

You can see a number of different flags.

For example, if the SYN flag is set,

that means that there's a synchronization of sequence

numbers that's occurring.

If the push flag, or PSH flag, has been set,

it pushes the data to the application

without buffering anything else that might be incoming.

There's also a reset flag, or RST,

that resets the connection, and a FIN flag

that designates that this is the last packet that

will be sent by the sender.

By turning on or off different flags,

we can change how a device may interpret

the rest of the data that is being

sent using that TCP header.

Not only are there flags within the TCP or UDP header--

there are also flags within the IP header.

You can see an example of those flags right here.

Most of the flags being used at the IP header deal

with the fragmentation of data.

There may be times when you want to send traffic

across the network, but because of the architecture

or design of the network, you're,

not able to send packets that are very large.

In those cases, you may need to fragment

the data to be able to get through the smaller size

networks.

We determine the maximum size that you're

able to send using something called a maximum transmission

unit, or an MTU.

This designates the size of the data

that we're able to send through the network

without having to fragment any of that information further.

The reason we don't want to fragment

is that it commonly slows down the overall flow of traffic,

and if you can optimize your network communication

so that you're not fragmenting, you'll

have a much higher throughput of traffic.

This also eliminates any overhead

of having to chop the data into smaller pieces,

send those individual pieces across the network,

and then rebuild those pieces when

they get to the other side.

That's why it's important to know the MTU value that

would be used all the way through the network

from the beginning of the communication all

the way to the very end.

But understanding what the MTU might be

could sometimes be a very complicated process.

There may be many different hops that

are used to be able to communicate from point A

to point B, and each one of those hops

may be using a different MTU.

There is an automated process that your system will

use to attempt to determine what the MTU is when communicating

to that other device, but unfortunately,

if ICMP is filtered in that communication,

there's no way to automate that process, which

means you'll have to manually set the MTU on your side.

Let's take a look at what this fragmentation really means.

We've seen before, where we've taken some TCP, data

we put a TCP header in front of it, an IP header

in front of that, and finally, a DLC

header on the outside to send it across our Ethernet network.

The data that's on the inside from the IP header

all the way through to the data that's being transmitted

is our IP packet, and the maximum size

of an IP packet on an Ethernet network is 1,500 bytes.

If there's no fragmentation that's occurring anywhere

on the network, you'll be able to send all 1,500

bytes through the network without having any of that data

fragmented along the way.

Let's take an example, where we can only

send a very small amount of data through the network.

In this example, 16 bytes of data

is the maximum transmission unit that's

supported on this particular network.

That means we might have 44 bytes of data

that needs to be fragmented, and as we're sending it

through the network, we're going to fragment the first section

of it, or the first 16 bytes.

We'll then send another frame of data that has another 16 bytes,

and the last frame is going to send the remaining

amount of data, up to 16 bytes.

So if we do need to send data across the network that's

44 bytes in length, but the MTU of this network

is only 16 bytes, we're going to end up taking a single frame

and splitting it up into three separate frames.

Fortunately, when you're designing and creating

a network, the MTU is usually set during that creation

process, so once the network is built,

it's very unusual for that MTU to change.

We also know that there are going

to be MTU changes if we have to tunnel any information,

so if you're using a VPN of any type,

you're probably going to need to set some MTU

or ensure that the MTU is going to be properly set

automatically.

There is a flag within the IP part of the header that

will specify that the information you're sending

should not be fragmented as it goes through the network.

And if you send data that's too large with a Don't Fragment bit

set, that data may not be able to make it all

the way through the network.

And very commonly, you'll receive an ICMP message

saying that this data is too large

to send through this network.

If you'd like to test your network between one

device and another to see exactly what the MTU might be,

you can test by using the ping utility.

You can specify in ping to set that Don't Fragment bit,

and then you can force a particular size of data

to be sent through the network.

In the case of Ethernet, the maximum size

would be 1,472 bytes.

Now, normally, that would be 1,500 bytes,

but the ping command is specifying

that 1,500 bytes minus the ICMP header of 8 bytes,

and minus the 20-byte header of the IP

address itself, leaving us with 1,472 as the maximum MTU that

would be used for the ping command on an Ethernet network.

In Windows, you can test this by using the ping command

with the -f, which tells us to ping with the Don't Fragment

bit set, and then with -l, which specifies the length of data

you would like to use in bytes.

And in this case, it's 1,472 bytes.

And if you'd like to try this against Google's DNS server,

you can then use the IP address of 8.8.8.8.

Let's try this ping with the -f to don't fragment.

We'll do -l of 1,472 bytes, and let's

specify the DNS for Google.

And you can see that we are able to send traffic with 1,472-byte

ping frames from our device all the way through

to Google's DNS, and then we do receive a response back from

Google saying that that information was received.

If we tried to do a packet that was larger than 1,472--

let's try, for example, 1,482--

we'll send that information, and it

says this information needs to be fragmented,

but you've set the Don't Fragment bit, which

means it's not going to be able to traverse

this particular network, and you're going

to need to use a lower MTU.

If this was going over VPN, we would simply

keep moving that number lower and lower

until finally it was able to send through the network,

and we would be able to receive replies to our pings.