SLIP and PPP protocol. SLIP (Serial Line Internet Protocol) protocol
We previously looked at joining the network via a local Ethernet interface. Let's consider using a telephone line in a network. There is corresponding software.
The computer is connected to the telephone line via a modem or other similar device.
As standard programs Controlling transmission over telephone lines uses two protocols: SLIP and PPP.
SLIP protocol
SLIP (Serial Line IP) – serial data transmission protocol. The SLIP protocol allows a computer to use IP to communicate on the network through telephone lines and modems, as well as directly through the RS-232 interface.
Software that implements the SLIP protocol receives IP packets from the process that sends them from the network layer program, adds its own service information and transmits it to the serial data device (modem, COM port, etc., byte-oriented) . At the other end of the serial line, a similar program receives symbols passing from the serial data transmission device, frees it from service information, restoring IP packets, and transfers them to the corresponding network layer program.
The following are used as service symbols to distinguish transmitted datagrams:
The SLIP END character is the corresponding byte with decimal code 192, which marks the end of the datagram. When the receiving SLIP receives a byte with this code, it determines that this is the end of the datagram and passes it on to the IP layer.
The SLIP ESC character is the corresponding byte with decimal code 219. This character is intended to be excluded from the sequence of SLIP control characters. If the transmitting SLIP recognizes a byte in the output information with a value equivalent to SLIP END, then it converts this character into a two-byte byte sequence. These are 2 byte sequences, it converts them back to single byte values.
The SLIP protocol is very simple. It does not organize checks for the correctness of transmission, does not know how to manage connection parameters, etc., which greatly limits its applicability.
PPP protocol
Taking into account the shortcomings of SLIP, the PPP protocol was developed - the point-to-point protocol. This protocol was developed by the IETF (Internet Engineering Task Force) as part of the TCP/IP stack for transmitting frames of information over serial global channels. PPP has become the de facto standard for wide-area communications to connect remote clients to servers and to form connections between routers in corporate network. The PPP protocol was developed to transfer data to a wide range of network protocols. The PPP protocol is a more reliable protocol than SLIP, but also more labor-intensive to implement.
When developing the PPP protocol, the HDLC frame format was taken as a basis and expanded own fields. The PPP protocol fields are nested within the data field of the HDLC frame. Later, standards were developed that used PPP frame nesting within frame relay and other wide area network protocols.
The PPP protocol is a 3-layer protocol, including:
Data link layer protocol– the data forwarding layer uses a simple modification of the HDLC version of the protocol (High-level Data Link Control). HDLC is an international standard for reliable data transmission over a synchronous, serial communication line, i.e. The PPP protocol can guarantee reliable delivery of messages over various types of serial lines.
Link Control Protocol– communication control protocol. Produces control information for a serial line. It is used to establish a connection, configure connection parameters, check the quality of the connection, and close the connection.
Network Control Protocol– network management protocol – produces configuration and control information for network layer protocols.
The main difference between PPP and other link-layer protocols is that it achieves coordinated operation of various devices through a negotiation procedure during which various parameters are transmitted, such as line quality, authentication protocol and encapsulated network layer protocols.
The negotiation procedure occurs during connection establishment. The PPP protocol is based on four principles: negotiable acceptance of connection parameters, multi-protocol support, protocol extensibility, independence from global services.
Negotiated acceptance of connection parameters. In a corporate network, end systems often differ in the size of buffers for temporary storage of packets, restrictions on packet size, and the list of supported network layer protocols. The physical line connecting the end devices can range from a low-speed analog line to a high-speed digital line with varying levels of quality of service. To cope with all possible situations, the PPP protocol has a set of default settings that take into account all standard configurations. When establishing a connection, two communicating devices first try to use these settings to find mutual understanding. Each end node describes its capabilities and requirements. Then, based on this information, connection parameters are adopted that suit both parties, which include data encapsulation formats, packet sizes, line quality and authentication procedure. The protocol according to which connection parameters are received is called Link Control Protocol (LCP). A protocol that allows end nodes to agree on which network protocols will be transmitted over established connection, called Network Control Protocol (NCP). Within one PPP connection, data streams of various network protocols can be transmitted. One of the important parameters of the PPP connection is the authentication mode. For authentication purposes, PPP offers by default the PAP (Password Authentication Protocol), which transmits the password over the communication line in clear text, or the CHAP (Challenge Handshake Authentication Protocol), which does not transmit the password over the communication line and therefore provides greater network security. Users are also allowed to add new authentication algorithms. The discipline for choosing header and data compression algorithms is similar.
DNS protocol
7.6.1 Description of the DNS protocol
In the early years, the Internet had a small number of nodes. Before 1980, the ARPANET network included several hundred computers. The correspondence between their names and IP addresses was stored in a text file called hosts.txt, but it was stored on a computer at the Stanford Research Institute's Network Inform Center (SRI-NIC).
Other computers connected to the ARPANET copied this file from the SRI-NIC computer as needed. Updates occurred once or twice a week. As the number of cars grew, problems began to arise:
The hosts.txt file has become too large;
The update must be carried out several times a day;
All network traffic related to name resolution passed through the SRI-NIC, and maintaining the hosts.txt file became a bottleneck for the entire network;
The hosts.txt file used a linear namespace.
These and other problems forced ARPANET management to look for a mechanism to replace the hosts.txt file. As a result, it was created domain system names - DNS.
DNS is a method of assigning names by transferring network groups responsibility for their subset of names.
Each level of this system is called a domain. Domains in names are separated from each other by dots.
Example: admin.isp.nsc.ru. or cyber.neic.nsk.ru.
The first name in the name is the name of the working machine - a real computer with an IP address.
Then the name contains the name of the group (for example: neic – the name of the institute, or the name of a group that supports many machine names).
The group is part of a larger association (for example: nsc - Siberian branch, nsk - Novosibirsk).
The association is part of a national network (for example: ru, su - Russia, de - Germany, pl - Poland, etc.).
For the USA, the name of the country is omitted, where the largest associations are networks of educational (.edu), commercial (.com), government (.gov), military (.mil), other (.org) and network (.net) resources.
There should not be identical names within the same domain. If the group itself is engaged in the distribution and recognition of its names, it must be allocated to a separate DNS zone and have DNS servers (primary and secondary), which maintain an information base on the names of computers for this entire group.
DNS is a hierarchical distributed database management system based on a client-server architecture. The purpose of the DNS database is to resolve computer names into IP addresses. DNS clients are called qualifiers, and the servers are called name servers.
Information about these servers should be stored on DNS servers in the zone for more than high level, which includes the domain of this zone.
Name servers are divided into primary and backup.
Main server names receives data for the zone from local files. Zone modification—adding (removing) domains or nodes—is performed at the main server level.
Backup servers names receive zone data from the main server. Transferring zone information is called zone transfer.
The server is defined as primary and backup at the zone level. Therefore, each server can be either primary or backup.
When a local computer requests an address, it passes the request to the local name server, the DNS server responsible for the country. It passes on below and so on until some local DNS server determines that the name is in its database. The IP address of the destination machine is sent back.
This IP address is delivered to the local computer that attempted to send the message. The received IP address is placed in the IP header of the message being sent, and it is sent.
The DNS server has two files containing the name base:
direct zone file;
reverse zone file.
The forward zone file named.hosts is used to convert machine names to IP addresses.
The line in that file contains the machine name and its IP address:
admin.isp.nsc.ru IN A 194.226.178.182
The reverse zone file named.rev (*.rev) resolves an IP address to a machine name. The reverse zone file line contains the machine's IP address and its name:
194.226.178.182 IN PTR admin.isp.nsc.ru
7.7 RIP routing protocol
Routing information protocol. RIP (routing information protocol) belongs to a well-known class of routing protocols based on the Bellman-Ford algorithm. This protocol is based on so-called vector distance algorithms.
Routing is a means of determining the optimal path between two nodes on the Internet. Without routing, traffic would be limited to a simple physical network.
There are three most common routing configurations:
minimal routing– used when the network is completely isolated from other TCP/IP networks. The minimum routing table is created manually by the administrator during the network configuration process;
static configuration– used when the network has a limited number of gateways to other TCP/IP networks. The static routing table is created manually by the system administrator using the route command. The static routing table is used if there is no change in the network structure;
dynamic routing– used when there is more than one route to some other machine on the network.
Table dynamic routing is constructed from exchanged information of routing protocols. Routing protocols ensure that information is sent across the network that reflects changes in network traffic. The routing protocol detects changes in network routing situations much faster and more accurately than the system administrator. They determine which route is better based on the so-called “cost” of transmission (number of nodes along the route, total delays, etc.).
Information about routes between hosts, regardless of how it was determined - manually by the administrator or by the routing protocol, is stored in the route table.
The algorithm that implements the RIP protocol is based on the exchange between routers only of information about the distances between them in the corresponding metric.
It is believed that the networks themselves are point objects, that is, the distance between any two nodes of the same network is equal to zero, therefore the distance between the routers of two different networks equal to the distance between these networks.
Each router has a table listing all the other networks in that domain. The table also shows the names of those neighbors through which the path to other networks passes, and the corresponding metrics - the distance to these networks from the network of this router.
Each router sends its distance table to all routes - its immediate neighbors. Neighboring routers adjust their tables, provided that the path from the neighbor is shorter:
length equals = (path length reported by neighbor A) + (path length to neighbor A).
Let's consider the principle of forming route tables. Let the network shown in Figure 7.7 be given.
Fig.7.7. Network structure example
Let's fill in the route tables for each network. Obviously, the distance between neighbors and the metric must be known in advance. Unknown parameters are set arbitrarily. Examples of the initial states of the route tables of each router are shown in Fig. 7.8:
Router A.
Router B.
Router C.
Fig.7.8. Route tables
Exchanges are carried out according to the state, and after a certain number we get the result.
So after the first iteration of exchanges, router A will receive data from router B and adjust the metric to network D. Router C will receive data from router D and adjust the metric to network T.
The lack of restrictions on the initial state of distance vectors, except that all distances must be non-negative, means that if the network topology changes, the process will still continue to converge, but to a new distance vector. The process converges in finite time if there are no changes in the network topology. If changes happen constantly, then the process will constantly converge.
The Bellman-Ford algorithm provides for the diagnosis of a line break. If a neighbor does not respond to a neighbor for a long time, the line is assigned a metric equal to infinity – ∞.
The RIP protocol has the following disadvantages:
use of fixed metrics;
difficulties in use in large networks, since as the network expands, the number of topology changes increases, which requires more frequent transmission of routing information;
routing tables do not take into account the resulting channel load.
The RIP protocol implies choosing one single route, even if an alternative exists. RIP sends all traffic along this single route, putting a heavy load on it.
Currently, a new generation routing protocol, OSPF (open shortest path first), has been introduced.
In addition to the main function - routing, it quickly distributes the schedule between equivalent routes.
Routing tables can be constructed using the Bellman-Ford algorithm. And the mechanism for collecting and using routing information differs from RIP.
Each router has all the information that its neighbors have. Therefore, it can perform all the calculations required for the routing table.
If a change occurs, information is sent using flood routing.
7.8 NFS – network file system
NFS – allows directories and files to be distributed over a network.
NFS was originally developed by SON Microsystem. Currently used in all UNIX-like operating systems and other non-UNIX-like operating systems.
Through NFS, users and programs gain access to files located on remote computers.
NFS has the following advantages:
allows you to reduce the required amount of memory on the local computer, that is, the network can save a single copy of directories accessible to everyone.
NFS simplifies the centralized support of jobs, since files can still be transferred across the network.
NFS allows users to use a family of UNIX commands to manage deleted files. For example, to copy a file from one PC to another, you do not need to use FTP, but you can use the cp (copy) command.
There are two sides to NFS - one side is the client and the other is the server.
An NFS client is a system that uses remote directories as if they were part of their own local file system.
An NFS server is a system that makes directories available for use.
Attaching a remote directory to the local file system (a client function) is called mounting the directory.
Providing a directory for remote access (server functions) is called exporting the directory.
Often the OS loads both the server - functions, and the client - functions in one machine.
The processes (daemons) required to run NFS are loaded when the computer boots in the boot file.
7.8.1 Mounting the file system
The corresponding file system (FS) must be embedded in the existing hierarchical directory tree. Only after this, the kernel can execute on this file system file operations, such as creating, opening, reading, or writing to a file.
Mounting a file system is done with the mount system call. The following are passed as arguments:
type of mounted file system;
name of the directory to which FS is connected;
flags (for example, read-only access to FS);
additional data (the type depends on the implementation of the specific FS).
Once mounted, the file system can be addressed by its mount point name.
#mount –r oberon: / / USR / local.
#mount –t NFS oberon: / / USR / local
7.8.2 Blocking access to a file
NFS allows (in accordance with the UNIX architecture) multiple processes simultaneous read and write access to a file.
At the same time, there are means of blocking access. Locking eliminates the possibility of one process modifying data between two successive calls to read that data by another process, which could lead to inconsistent file operations and data corruption.
To lock a specified range of bytes of a file or to write to a file, use the fcntl() system call and the library function lockf() to lock the entire file for writing and reading.
struct flock lock;
// fill in the lock structure to block the entire file for writing
lock.l_type = F_RDLCK
// lock the file for writing
fcntl(fd, SETLKW, &lock);
// write data to file
write(fd, record, sizeof(record));
// remove the blocking
lock l_type = F_UNLCK;
Internet users working through Internet service providers represent a very significant segment of the network. Data is received and transmitted using a modem connected through a computer serial port to a regular telephone line. To work with the network via a modem, one of two existing protocols for working over serial communication lines is used: PPP or SLIP. In order to write network applications, you need to have a good understanding of the key points and differences between them. You must also have an understanding of the SLIP derivative protocol, which is called SLIP with compression (which provides data compression). This article discusses issues related to the first protocol - SLIP and its modification CSLIP (described in RFC 1055 and RFC 1144).
To establish a connection using the SLIP protocol, a modem is usually used, operating over a telephone line and connected to an asynchronous serial port. Two computers that have established such a connection exchange data with pauses of variable length. Unfortunately, there is always interference (noise) on the telephone line, so devices connected to the telephone network distinguish data from possible interference using various communication parameters.
SLIP connection
In the early years of the Internet, SLIP was the most popular protocol for novice users to access the Internet from their home or work computers. To use SLIP, you must have the appropriate software that can establish a connection using this protocol between your computer and an Internet host. Software of this kind (often called TCP-manager) performs the functions of managing a network device, that is, it is the driver of a network device, such as a modem. You load and unload the SLIP control program as needed.
A SLIP connection is the most cost-effective and easiest way to connect your computer to the Internet. SLIP can be used if your local network does not have direct access to the Internet, or you want to connect a separate computer. For SLIP to work, your ISP must also provide SLIP on its host computer (Internet host).
It is known that each layer of the TCP/IP protocol stack encapsulates (inserts) data in the format in which it is required for transmission to surrounding layers. As data travels through the TCP/IP protocol stack, it is sequentially surrounded by additional information (encapsulated) for the next layer along the path. In order to send an IP datagram through the network layer, the upper connection layer must appropriately encapsulate the data, format it into a frame, as required by the TCP/IP network layer standard. For example, the connection level for Ethernet networks encapsulates data in an Ethernet frame. For the token-ring network, accordingly, these will be frames of the token-ring standard.
The serial communications standards, SLIP and CSLIP, simply define a different method of encapsulation. SLIP and CSLIP prepare data for transmission over a serial link (usually an RS-232 interface) to the Internet. The PPP protocol also encapsulates data for the same purpose. However, PPP uses a more complex encapsulation method and interface to the Internet than SLIP. However, the transmission channel for all of them is still serial and point-to-point. Logically, SLIP and PPP are located between the computer's serial port and its TCP/IP software stack.
What is SLIP?
The TCP/IP family of protocols can operate over a wide range of different network technologies. Most network technologies require a well-defined data frame structure. The Institute of Electrical and Electronic Engineering (IEEE), founded in 1963 and with more than 300,000 members, described the recruitment various standards, making it easier for software and equipment manufacturers to develop and apply compatible standards for data transmission, including in local computer networks. Like most standards-creating organizations, IEEE numbers its output documents. The IEEE 802 group of standards is dedicated to local computer networks. For example, the IEEE 802.1 standard is devoted to network management methods, IEEE 802.3 and IEEE 802.5 describe physical levels for Ethernet and token-ring networks, IEEE 802.2 contains a connection layer specification for networks such as Ethernet, token ring and a number of other technologies.
The conversion (encapsulation) of data for transmission over serial links is described in a document called RFC 1055, "A Nonstandard for Transmission of IP Datagrams Over Serial Lines: SLIP", Rornkey, 1988. RFC 1055 is not an official Internet standard. It describes the de facto standard. This means that while the Internet community does not consider RFC 1055 a standard, anyone who wants their software to be compatible with existing transmission methods should use the document's recommendations in their work.
SLIP is a protocol for encapsulating IP packets into frames suitable for transmission over a serial communication link. SLIP does not provide the ability to address data, designate frame types, correct or detect data corruption, or compress packets. The absence of these features makes the protocol extremely easy to implement and therefore popular. Despite its popularity, firms and software manufacturers rarely use SLIP as a standard protocol, as it is not an official Internet standard. As a rule, PPP is used as such a standard. The PPP protocol is truly an Internet standard that has the same point-to-point serial data transfer properties as SLIP.
SLIP Data Encapsulation
Each protocol has the property of encapsulating data. SLIP is no exception here. It uses special characters to delimit a data frame on a serial link. SLIP defines the following two characters to serve this purpose: End and Esc. The End character is a character with ASCII code 192 (OxCO), and the Esc character is a character with ASCII code 219 (OxDB). A computer running SLIP sends an End character at the end of each data packet. The Esc character is used to indicate data that has the same number as the Esc and End characters within a data packet. There is no special hidden meaning in the fact that the specified codes were chosen for Esc and End. They were just chosen, that's all. Therefore, it is almost certain that both Esc and End characters will appear in the user's data stream. When this happens, SLIP uses Esc to tell the receiver that the next End character is not actually the end of the frame. For example, when a data packet contains a byte with the number OxCO (End character code), SLIP substitutes the two-byte Esc sequence Esc OxDC. If the byte has the code for the Esc character itself, SLIP inserts the two-byte Esc sequence Esc OxDD.
The SLIP implementation on the receiving side does the opposite to properly parse the incoming data packet. If the Esc character is encountered in the sequence, SLIP immediately looks at the character following Esc and, depending on its number, interprets the received sequence one way or another. For example, if the character following Esc has the code OxDC, SLIP replaces the two characters with one with the code OxCO. If the Esc OxDD combination is accepted, it is replaced by a byte with the OxDB code. When SLIP sees that the incoming byte has the End code and there is no byte with the Esc code before it, this means that the end of the frame has been reached. Next, SLIP transmits all previously received data to the higher-lying network layer as an IP packet.
Most SLIP implementations also send the End byte ahead of the data frame. Strictly speaking, the SLIP protocol does not require this. However, by doing so, SLIP allows the receiving end to effectively discard any garbage received before a valid frame is transmitted that is treated as a frame. An implementation of SLIP operating in this manner allows a zero-length data frame to be discarded when the receiving end receives two consecutive End characters.
As we noted above, inserting an End character before the start of the frame allows the receiving side to get rid of any noise on the communication line. However, with such measures all SLIP’s ability to identify and, moreover, correct data errors is exhausted. SLIP delegates the task of identifying and correcting data packets and messages entirely to the higher-lying protocols, that is, to the network and transport layers of TCP/IP. The IP protocol requires the presence and verification of a checksum in the packet header, so SLIP may well ignore possible data corruption - the IP protocol will do this work for it, which will check the packet and discard it if damaged. The TCP protocol will check the checksum of its header and data segment in the same way and, if damaged, will deal with the packet appropriately. So, we see that since the underlying protocols already check the state and integrity of the data, there is no need to introduce additional data control at the SLIP protocol level.
In the previous paragraph, we reiterated the fact that IP and TCP detect and correct errors that may occur when data is transferred to them from lower layers, for example, from the SLIP protocol, which itself does not detect errors. Since UDP does not use checksums, no one can guarantee that a UDP packet will reach the recipient via SLIP intact unless SLIP also detects errors. Imagine sending UDP packets over a noisy telephone line using SLIP. None of these protocols will pay attention to possible failure and data corruption. A computer that receives a damaged packet will in good conscience consider it normal, and such behavior can lead to unpredictable consequences. Therefore, you cannot send UDP datagrams over SLIP unless you use UDP with a checksum.
Disadvantages of SLIP
In addition to the lack of error detection and correction, the SLIP protocol lacks some other functions that are quite important for professional network programmers. For example, SLIP is not able to address packets, designate packets various types, and also compress data within the package. RFC 1055 explicitly states that the creators of SLIP designed it when the presence of such functionality was not essential.
Each time a SLIP connection is established, the computer turns into a full-fledged Internet host with its own IP address. In this way, it becomes possible to serve other Internet users as well. Because your ISP may use dynamic address assignment (from a range they have), your computer will receive a new IP address each time you connect. Consequently, other computers on the network will be forced to look for you every time under an unknown address.
To add insult to injury, there is no method to directly specify your new IP address when establishing a SLIP connection. Each time you are forced to manually enter the changed address into the computer, since one computer cannot automatically transfer the IP address to another using SLIP. There is only one way out of this situation: get from your service provider one computer IP address that belongs only to you. Typically, having such an address will cost you more than having a dynamically assigned one.
There are many computers in the world that can run several different network protocols at the same time. For example, DEC computers can combine TCP/IP and DECnet. Of course, when working with two protocols at once, you will want them to live together on the same wire connecting you to outside world. This task is easy as long as you use Ethernet as your networking medium. Ethernet frames have corresponding fields that indicate the type of packet being transmitted, but as soon as you try to switch to SLIP, you will find that the SLIP frame does not have such a field, and, therefore, it can only transmit data for one IP protocol.
Ethernet networks transmit information at speeds of up to 10 million bits per second. A SLIP connection can work on a high-speed modem, but even then only provide a speed of 19,200 bits per second. In other words, Ethernet is more than five hundred times faster than SLIP. To increase the performance of a SLIP connection, you can compress the data sent over the modem, which reduces the required network traffic and allows you to transfer more information in less time. Suppose you need to transfer a file of 100 KB in size (100x1024 bytes) over a modem at a speed of 1200 baud. This will take about 14 minutes:
100 x 1024 = 102400 bytes
102400 bytes / 120 bytes per second = 853 seconds 853 seconds / 60 seconds per minute = 14 minutes
If the transmitted data is pre-compressed in a ratio of 1:4, the volume will be reduced to 25 KB. The time required for transmission will be reduced to four minutes. New modems use built-in data compression technology. Some software protocols also use data compression during operation. Information in TCP and IP packet headers that changes rarely can be effectively eliminated using simple data compression algorithms, where only the changing portions of the headers are transmitted. RFC 1055, which describes the SLIP protocol, does not describe any compression algorithm. In the next section, you'll see an implementation of the CSLIP protocol, which has the ability to compress TCP/IP headers to improve performance.
Compressed SLIP Protocol (CSLIP)
A header-compressed SLIP algorithm that improves network performance is discussed in RFC 1144, Compressing TCP/IP Headers for Low-Speed Serial Links (Jacobson, 1990).
The CSLIP protocol compresses only packet headers. The package data itself remains unchanged. More precisely, CSLIP exclusively compresses the TCP and IP headers for TCP data segments. CSLIP does not affect either the UDP packet headers or the IP headers for them. There are quite a few different implementations of the CSLIP protocol developed, so you probably won't need to invent a new one.
Prerequisites for the emergence of CSLIP
To understand why packet header compression is so effective, let's look at some common networking tasks;
Interactive login to a remote computer (Telnet);
Interactive file transfer (FTP);
Email using Simple Mail Transfer Protocol (SMTP);
Read and transmit news using Network News Transfer Protocol (NNTP).
Like any other communication line, a serial line carries user data packets with headers. To increase line throughput, it would be a good idea to compress packet headers. Methods for transmitting packets over a network fall into two broad categories: interactive and non-interactive. We will show later that the efficiency of a communication channel depends on the type of packet transmission.
There are no excellent examples interactive transmission There are two protocols used for packets: FTP and NNTP. Of course, the initial stage of operation of both processes includes them manual setting and passing parameters. However, all that happens afterwards is the transfer of information from one network host to another, without requiring your intervention. When you start ftp from your computer, you specify the name of the file to transfer, and then sit back and wait for the stream of bytes that make up that file to flow from the other host to your own. Similarly, you select a newsgroup in the NNTP application and wait for all the news from the server to be transferred to your computer. These are examples of non-interactive packet transmission.
A typical example of interactive information transfer is Telnet. Each press on the user's keyboard typically results in a packet containing the code for the entered character being sent to a remote network host. Despite the fact that many Telnet implementations are able to transmit the entire entered string of characters at once, this feature is usually not used, because the user wants to get an immediate response from the remote computer to the entered character. In addition, the remote computer sends an acknowledgment packet with a copy of the entered character back to the user. In general, Telnet creates a bidirectional data stream consisting of small packets.
Typically IP headers are 20 bytes long, and the TCP header is also 20 bytes long. This means that a Telnet session produces data packets of 40 bytes of headers for each one-byte character transmitted. To understand how CSLIP works, you need to understand two different but closely related concepts: line efficiency and system interactive response. Link efficiency is a ratio equal to the length of the TCP/IP packet header divided by the length of the header plus the length of the user data in that packet. We will now calculate the line efficiency for a Telnet session.
Let's assume that the Telnet program transmits one packet per keystroke, which in turn consists of one byte-long character. A data packet that contains a byte-long character and has TCP/IP headers (another 40 bytes) will be 41 bytes long. The receiver of the packet must send back a delivery confirmation, and this will be a 41-byte packet. Now let's calculate the efficiency of the line. It will be less than three percent (the TCP/IP transmission process is duplex, since data packets travel independently of each other in both directions, so the efficiency of the line is calculated independently for both directions. However, in our case the result is the same for both another direction).
To increase the efficiency of the line, you must either increase the amount of data in the packet or reduce the size of the headers. The CSLIP algorithm focuses on reducing the size of packet headers. In addition, CSLIP complies with the system's interactive response requirements. The interactivity of a system's response is simply its ability to convince the user that everything works. For example, when a user presses a key, he understandably wants to see the typed character appear on his monitor. If the network operation results in noticeable delays in packet transmission, the user will perceive the network's interactivity as unsatisfactory.
RFC 1144 discusses how the transmission of network data packet headers can affect the user's perception of the situation. Assuming that each character entered results in two 41-byte packets, a baud rate of at least 4000 bits per second is required to ensure an echo delay of no more than 200 milliseconds. In other words, a slow serial line makes the user think that the program is slow, even if the program is actually quite efficient.
Non-interactive packet transmission can also affect the system's interactive response. For example, to achieve greater than 90 percent efficiency in transmitting non-interactive packets when TCP/IP headers are 40 bytes long, the maximum packet length (MTU) must be kept between 500 and 1000 bytes. Let's further assume that your SLIP connection has an MTU of 1024 bytes with a modem speed of 9600 baud. In this case, one packet in one direction will be transmitted in approximately a second. Any interactive session will then wait for the non-interactive packet to complete transmission.
Hardware Impact
In addition to the human factors we discussed, several hardware features also influence protocol design. Modem manufacturers use various methods to increase the efficiency of these devices. When programming applications, you don't need to know exactly what's going on inside the modem, but there are a few things you need to pay attention to.
Communication theory specifies the actual bandwidth between two devices. The effective bandwidth, depending on the technology used, allows for the actual bandwidth to be increased (and exceeded) when compressing the transmitted data. Compressing data allows you to transfer more of it in the same amount of time. In some cases, the transmission speed achieved in this case exceeds the theoretical speed limit of the communication channel.
In a full-duplex protocol, typical of a modem, data flows in both directions simultaneously. However, the same bandwidth is rarely used in both directions, since one of the parties involved in the connection is likely transmitting more data than the other. It is for this that a large bandwidth is allocated at the expense of the opposite side. Bandwidth allocation is transparent to the user and controlled by the modem itself.
To determine which side of a connection requires the most bandwidth, modem manufacturers assume that one of the sides is always human, and that side requires the most bandwidth. The modem, however, must figure this out on its own. The starting point is 300 bits per second. Most people cannot type faster than this speed. Unfortunately, the situation changes as soon as we start transmitting TCP/IP packets with headers of forty bytes for each character entered. The speed increases at a ratio of 40:1 and causes the modem to frequently change lanes in opposite directions. An IP packet of 41 bytes consists of 328 bits, which is beyond the limits prescribed for the modem to recognize a person. When purchasing a modem, you should pay attention to such details as supported data compression types and other data transfer capabilities. Buying a good modem in these respects will allow you to significantly increase the performance of your network connection.
Design Goals
Modern modem architecture can reduce the need for keystroke transmission rates to 300 bits per second or even less. If we consider a ten-bit sequence per character (eight data bits plus start and stop bits), 300 bits per second results in a bandwidth of 30 bytes of data per second. Typical typing speed on the keyboard is 5 characters per second. This leaves 25 bytes (30 - 5) for header transmission, provided the selected maximum bandwidth of 300 bits per second is maintained. In other words, for one transmitted character it is also possible to transmit a five-byte header. In addition, such a transmission maintains good interactivity of the system, since the pause between pressing and receiving an echo will not exceed 200 milliseconds at a speed of 4096 bits per second.
Implementation of SLIP
RFC 1144 discusses techniques for reducing the required length of transmitted headers from 40 bytes per packet to as little as three to five. Jacobson shows that over the course of a TCP connection, about half of the header information remains the same. The CSLIP protocol requires that after hosts establish a TCP connection, they store copies of the last received and transmitted packets, and in the future, storing the number of the current connection, simply transmits changes in the headers, allowing the real header to be assembled based on the existing unchanged part and accepted change.
As soon as a new CSLIP packet appears, the network software uses the identifier to determine which connection it belongs to and restores it to normal. As you can see, real packet headers are not transmitted over CSLIP, which reduces the packet size by 20 bytes.
Further, CSLIP does not transmit the Total Length IP header field, receiving it instead from the network layer of the connection and reducing the length by at least two more bytes. Only the header checksum field remains in the IP packet header, but there is no need to transmit a checksum of the missing data. Instead of transmitting the header checksum, CSLIP calculates it in place, unlike SLIP, which is still forced to transmit the checksum over the communication link. We remove the header checksum and get two more bytes of savings.
This leaves another 16 bytes in the packet header that can change throughout the TCP/IP session. Of course, they do not change constantly, but only sometimes. RFC 1144 notes that, say, FTP protocol changes only the packet identifiers (ID), sequence number and checksum in the direction from the transmitter to the receiver. The packet ID, acknowledgment packet, checksum, and possibly the transmission window are what typically change from receiver to transmitter. The CSLIP transmitter always keeps a copy of the last packet sent. Thus, he knows exactly what changes occurred in the next packet to be transmitted. If the transmitter sends only the changed bytes, the average packet header size becomes approximately ten bytes. By knowing how the fields in the header change, you can further reduce its size.
The packet identifier changes, as a rule, by one with each new packet transmitted. What does it mean? That the difference between two identifiers can be encoded as a small positive integer less than 256 (one byte). As a rule, this number is equal to one. Further, for the transmitter, the sequence number of the current packet will be the number obtained by adding this number from the previous packet with the length of the previous packet. The maximum length of an IP packet is 64000 bytes, which means that the change in sequence number between two packets will never exceed two bytes. At this stage, by sending only their changes instead of real fields, CSLIP saves us an additional three to four bytes.
So, we were able to reduce the size of the TCP/IP header from 40 bytes to five, which was our goal. Implementation details are generally not important unless you want to write your own CSLIP implementation...
The SLIP (Serial Line IP) protocol became the first de facto industrial standard that allowed devices connected by a serial low-speed communication interface to operate over TCP/IP protocols. This Internet protocol allows the use of ordinary telephone lines as communication lines. The protocol was created in the early 80s and, according to RFC-1055, was first included as a means of accessing an IP network in the 3COM package - UNET. In 1984, SLIP was built into the 4.2 Berkley Unix operating system by Rick Adams. SLIP was later supported in other versions of Unix and implemented in PC software. Due to its functional simplicity, SLIP was and is used mainly on switched communication lines, which are not typical for critical and high-speed network connections. However, a switched channel differs from a non-switched one only in lower quality and the need to perform the subscriber calling procedure, so SLIP is quite applicable on dedicated channels. The SLIP protocol performs a single function - it allows the stream of bits that arrive over a dedicated (or switched) channel to recognize the beginning and end of an IP packet. SLIP does not support other network layer protocols. Software that implements the SLIP protocol receives characters coming from a serial data device (modem, serial port, etc.); considers and interprets them as components of an IP packet; puts the received data into a full-fledged normal IP packet and transmits this packet further to the appropriate program that processes IP packets, for example, the TCP module. On the way back, SLIP receives from the program (network layer) sending IP packets, IP packet, extracts its contents, reformats it accordingly, then divides it into characters and sends it through a serial device over a serial line to the network - a neighboring Internet node. SLIP protocol frame structure. The SLIP protocol is designed to transmit IP packets over asynchronous communication lines. Since asynchronous transmission is byte-oriented, before transport by SLIP, the packet is divided into octets (bytes), which are transmitted one after another. As is known, in an Ethernet network, an IP packet can be up to 1500 bytes long, which necessitates its segmentation - breaking it into shorter packets. SLIP does this quite primitively. It does not parse the data stream or highlight any information in that stream. To recognize the boundary of IP packets, the SLIP protocol provides for the use of a special character END, the value of which in hexadecimal representation is (C0) A. To separate SLIP frames, a service separator byte is inserted between them - the character ESC (DB) A. The use of a special character can create a conflict: if the byte of the transmitted data is identical to the END character, then it will be erroneously identified as a sign of the end of the packet. To prevent such a byte found inside an IP packet from being perceived as a delimiter, a byte staffing mechanism is provided. Thus, the actual service information in the SLIP protocol is quite small: one separator byte is added per IP packet (they are not duplicated between packets), and sometimes several additional bytes appear, inserted using the byte insertion procedure.
The standard does not define a fixed size for a SLIP frame, so any SLIP interface has a special field in which the user must specify this length. However, in specific implementations the maximum size of a SLIP frame is often limited to a very small value (from 256 to 1006 bytes). This limitation dates back to the first implementation of SLIP in the corresponding Berkley Unix driver, and is necessary to maintain compatibility between different SLIP implementations (most modern implementations support this length and allow the administrator to set its size, and default to 1500 bytes). In each of the SLIP frames, the IP header of 20 bytes is reproduced in full (Fig. 5.11). Because of this, the redundancy that occurs when transmitting long packets over the SLIP protocol is quite large.
The redundancy generated by the asynchronous transmission method itself on the PC-modem interface is also significant (minimum 20% for additional start and table bits for each byte). But nothing can be done about this, since all personal computers have only asynchronous ports. To establish communication using the SLIP protocol, computers must have information about each other's IP addresses. The SLIP protocol does not have mechanisms that provide the ability to exchange address information, since the frame structure does not provide for an address field and its special processing. Therefore, computers communicating via the SLIP protocol must be assigned IP addresses in advance. Each time a SLIP connection is established, the computer turns into a full-fledged Internet host with its own IP address. If the provider uses dynamic assignment of IP addresses, then with each new connection the computer will receive a new IP address. Consequently, other computers on the network will be forced to look for it under an unknown address. Another disadvantage of the SLIP protocol is its lack of indication of the type of protocol whose packet is encapsulated in the SLIP frame. Therefore, traffic of only one network protocol can be transmitted through a serial line using the SLIP protocol. SLIP does not differentiate between packets based on protocol type, such as IP or DECnet. When working over the SLIP protocol, it is assumed that only the IP protocol is used, as defined by its name Serial Line IP. When working with real telephone lines, which are noisy and therefore distort information during transmission, error detection and correction procedures are necessary. The SLIP protocol does not provide for such procedures. These functions are provided by the underlying protocols: the IP protocol tests the integrity of the packet using the IP header, and one of the two transport protocols (UDP or TCP) checks the integrity of all data using checksums. Standard SLIP does not provide data compression, but there are variants with compression, for example C SLIP. Most modern modems that support V.42bis and MNP5 standards perform this operation in hardware. The low bandwidth of serial communication lines makes it possible to reduce the transmission time of packets, reducing the amount of service information contained in them. This problem is solved using the Compressed SLIP (CSLIP) protocol, which supports compression of IP packet headers. The CSLIP protocol was created at Lawrence Berkeley Labs (LBL) by Van Jacobson as a means to improve the serial transmission efficiency and service level of applications using TCP/IP over slow lines. The CSLIP protocol, compared to the SLIP protocol, uses six times less redundant information (in the form of headers). At low data transfer rates, this difference is noticeable only when working with IP packets carrying small amounts of information; such packets are formed, for example, when working telnet or rlogin. At higher speeds, CSLIP gives less gain and almost no gain for packets with large amounts of data, such as ftp packets. The appearance of CSLIP explains the fact that when using programs such as telnet, rlogin and others, in order to send one byte of data, 40 bytes of service information must be sent. Header compression replaces the 20 octets of the IP header and 20 octets of the TCP header (40 bytes total) with 3-7 octets. CSLIP uses information from the previous packet to compress, decompress and verify that the packet (and header) has been correctly forwarded, i.e. transmission has a chain structure. The first packet in the chain is uncompressed. If any packet is lost, then the chain is broken, the same packet cannot be requested at the very end of the transmission, it must be resent immediately, i.e. stop the transfer process and start a new chain. Thus, this technology, when packets are lost or corrupted, results in greater time losses than conventional SLIP. This occurs due to delays in stopping and transmitting a new uncompressed packet. Since the SLIP protocol does not provide error detection and correction procedures, it is undesirable to use the UDP and SLIP datagram protocol together. This is because the UDP protocol does not necessarily use checksums. Further development The SLIP protocol is the PPP protocol (RFC 1331), which eliminates some of the shortcomings of the SLIP protocol. It must be remembered that SLIP and PPP are link layer protocols.
This protocol is one of the oldest Internet protocols used to connect remote machines over leased or dial-up telephone lines via a COM port [and modem]. The main purpose of this protocol is to split packets into smaller units before transportation and stitch them together after transmission. It does not encapsulate packets and is the simplest, because does not analyze the data stream and does not allow manipulation of addresses. Therefore, for SLIP communication, computers must have the correct IP addresses, adjusted in advance. According to the standard, this protocol is IP-centric, i.e. can only work with IP packets. However, its simplicity makes it possible to implement it for other basic transport protocols. According to its internal ideology, the SLIP protocol is a client-server-oriented protocol, because the client is a machine that temporarily connects to the network and initiates the connection, and the server is permanently located in it and responds to client requests. This protocol is quite insecure, both for security reasons and for data transmission error correction - in the original, it does not have it at all.
End of work -
This topic belongs to the section:
Course of lectures on the discipline infocommunication systems and networks
Course of lectures on the discipline.. infocommunication systems and networks.. topic: basic concepts of infocommunication networks; class of infocommunication networks as open information systems..
If you need additional material on this topic, or you did not find what you were looking for, we recommend using the search in our database of works:
What will we do with the received material:
If this material was useful to you, you can save it to your page on social networks:
| Tweet |
All topics in this section:
The emergence of the concept of openness
The development of computer systems and tools, their expanded implementation in all areas of science, technology, services and everyday life have led to the need to combine specific computing devices
Open system concept
Currently, there are many definitions of the concept "open system". Thus, the Association of French Users of UNIX and Open Systems (AFUU) gives the following definition: “From
Construction principles
The main requirements for information infrastructure are to ensure the necessary functionality, speed, throughput and security. At the same time, we proceed from the fact
Topic 2
MODELS AND STRUCTURES OF INFORMATION NETWORKS 2.1 Topology The method of connecting computers in a network is called topology. When choosing a specific t
Ring topology
In this case, all workstations and the server are connected to each other via a ring through which data and the recipient's address are sent. Workstations receive relevant data by analyzing the address of the village
Bus topology
Such a network is similar to a central line to which a server and individual workstations are connected. Bus topology has become widespread, which, first of all, can be explained by small
Mixed topologies
Today, mixed topologies are increasingly common; for example, clusters of machines located at a remote distance from each other can be connected using a cable. +----------------+ cable +-
Coaxial transmission media
Coaxial cable is the most common medium used to transmit radio frequency signals. Structurally, it consists of a single-core or stranded conductor surrounded
Transmission media based on twisted pair conductors
Ideally, a transmission line consists of at least two conductors separated by a dielectric material and having a uniform gap along its entire length. To two conductors
Cable systems for high-speed data transmission
As demand for faster and more complex networks grows, so does the market for cable products. High frequency performance cables represent approximately 20% of the market and their share will continue to grow.
Impedance Uniformity
It's useful to reiterate that upcoming applications will most likely run in full-duplex mode. The phenomenon of impedance heterogeneity in a transmission line is similar to the resistance to water flow from
Benefits of fiber
Fiber optic communications have a number of advantages over electronic systems that use metal-based transmission media. In fiber optic systems before
Basic elements of optical fiber
Core. The core is the light-transmitting part of the fiber, made of either glass or plastic. The larger the core diameter, the more light can be transmitted along the fiber.
Access Method and Frames for Token Ring Networks
Token Ring adapters support the Token Ring access method and provide transfer rates of 4 Mbps or 16 Mbps. The main provisions of this method are listed below: Art.
Access method and frames for ARCNet networks
When connecting devices in ARCNet, a bus or star topology is used. ARCNet adapters support the Token Bus access method and provide performance of 2.5 Mbit/s. This method
UDP (User Datagram Protocol)
The UDP protocol is one of the main transport protocols. It works directly with IP packets and multiplexes them between various programs and processes. Main
IP protocol
The Internet Protocol (IP) is the basic internetworking protocol through which information is exchanged on the global network. In a regular local network, the IP protocol is whenever possible
TCP (Transmission Control Protocol)
This protocol is also a transport protocol and is designed to deliver packets called segments. It is used when guaranteed delivery of a package is necessary. Here, from
RIP (Routing Information Protocol)
This protocol is intended solely for routing table management. Its specification defines how and when the routing table will be updated. Race information required for this
RARP (Reverse Address Resolution Protocol)
In a standard configuration of servers and local machines, usually the IP addresses of computers are stored on local media and read into memory when the systems boot. In case it is necessary
BOOTP (BOOT strap Protocol)
We have already noted earlier that not all network components (computers, routers, hubs, etc.) have their own local storage devices, however, somehow they must be loaded
ICMP (Internet Control Massage Protocol)
Although the underlying internetworking protocol on the Internet is IP, it does not control error conditions in the network environment. This problem is solved by a specially developed network control protocol
PPP (Point To Point connection) protocol
PPP is also a protocol for connecting over serial ports. Like SLIP, it “cuts” packets into smaller pieces and sends and receives them sequentially
DNS (Domain Name Server) protocol and service
Once upon a time, quite a long time ago, there were relatively few machines on the Internet, but even this small number was difficult to identify and was named by users using numeric IP addresses. Poeto
Application services
Email protocols and services (POP, UUCP, SMTP) If DNS and DHCP were system purpose services and are used for routing and packet delivery systems (i.e. a regular user
Telnet remote access protocol and service
Similar to FTP, Telnet, too, was once just an OC UNIX command, however, due to its popularity and convenience, it spread as separate application to all existing network operating systems
HTTP protocol and WWW service
Of all the Internet user services, WWW technology (World Wide Web) or the "World Wide Web" of distributed information systems is the most developing and progressive.
Basic Reference Model for Open Systems Interconnection
BEMVOS is a conceptual framework that defines the characteristics and capabilities of open systems. It ensures operation in one network of systems produced various manufacturers. Designed by I
Transfer of data between MBO levels
For example, let's say an application makes a request to an application layer, such as a file service. Based on this request, the application level software generates a standard message
Connections
A connection is an association of function blocks established for data transfer. According to the seven levels of the open systems interconnection domain, there are 7 types of connections,
Subscriber system
This is a system that is a provider or consumer of information. The speaker system is implemented in the form of one or more devices:
Relay system
It is a system designed for data transfer or protocol conversion. The need to combine several networks with different protocols has posed the task of creating such relay systems
Circuit switching node
A circuit switching node is a relay system that establishes a call-based connection of sequences of channels between partners during a session. Its main part performs the functions of physical
Network interconnection
Thus, relay systems implement internetwork, channel and physical processes. The task is to perform functions, including transformations, necessary to connect parts of the network
Administrative systems
Administrative systems are systems that provide management of a network or part of it. It is assigned the following functions: collecting information and recording the operation of network components (temporary
Topic 5.
MONO-CHANNEL SUBNETWORKS AND MONO-CHANNEL. COMMUNICATION SUBNETWORKS. MULTICHANNEL SUBNETWORKS. CYCLIC SUBNETWORKS. NODE SUBNETWORKS. A mono channel is a channel that simultaneously (with precision
Mono-channel network
A monochannel network is a local network whose core is a monochannel. In accordance with the basic reference model of open systems interaction, a monochannel plays the role of a physical
Topic 6.
METHODS OF ROUTING INFORMATION FLOW 6.1 Routers Quite often in computer literature the following generalized definition of m is given
Network services. Model of distributed information processing. Information security. Basic functional profiles. Full functional profiles
Network service is a type of service provided by a network. Service is the process of servicing objects. The service is provided to users, programs, systems, levels, functionality
EDI Network Service
EDI Network Service is a network service for electronic data interchange. EDI technology, also referred to as ELS Email Service, is a standard and platform-independent
FTAM Network Service
FTAM Network Service is a network service that provides file management and access. FTAM is located at the application layer, defined by the International Standards Organization (ISO)
JTM Network Service
JTM network service is a network service for transferring jobs and managing their execution. JTM works in accordance with ISO standards and operates with so-called virtual jobs
Network NMS Service
NMS Network Service is a network service that performs network management processes. NMS was developed by the International Standards Organization (ISO) and is located at the application level. Provide
ODA Network Service
ODA Network Service is a network service that provides document processing and transmission. ODA is located at the application level and defines the exchange of documents (letters, official records
Distributed information processing model
Distributed data processing is a technique for executing application programs by a group of systems. The essence of DDP is that the user gets the opportunity to work with network
Distributed Computing Technologies
The software for organizing distributed computing is called middleware. A new direction for organizing distributed computing in networks
Distributed Data Processing Environment
(Distributed Computing Environment (DCE*)) is a distributed data processing technology proposed by the Open Software Foundation. She is not opposed to others
Information security
Data security is the concept of protecting programs and data from accidental or intentional change, destruction, disclosure, as well as unauthorized use.
Basic functional profiles
A functional profile is a hierarchy of interconnected protocols designed for a specific range of data processing and transmission tasks. ISO and ITU documents define a wide range of
Collapse functional profile
A collapsed functional profile is a pseudo-complete functional profile in which one or more levels are missing. A collapsed profile is a profile in which there are no functions.
Open network architecture
Open network architecture- a complete functional profile developed by British Telecom.& British Telecom uses ONA (Open Network Architec) at all seven levels
Topic 8.
Information switching methods. Implementation protocols 8.1 Switching. Channel switching When, removing telephone handset, subscriber or computer dialing
Equipment used
Routers A router can be simplistically viewed as a device that provides: · physical connection channels are defined to yourself
Reaction time
Typically, a response time is used as a time characteristic of network performance. The term "reaction time" can be used in a very broad sense, so
Criteria that differ in the unit of measurement of transmitted information
The unit of measurement of transmitted information is usually packets (or frames, later these terms will be used interchangeably) or bits. Accordingly, the throughput measured
Criteria that differ by taking into account proprietary information
Any protocol has a header that carries service information and a data field that carries information that is considered user information for a given protocol. For example, in the protoco frame
Criteria that differ in the number and location of measurement points
Bandwidth can be measured between any two nodes or points on the network, for example, between client computer 1 and server 3 in the example shown in Figure 1.2. At the same time, the resulting
Factors that determine network efficiency
The most commonly used means of communication are twisted pair, coaxial cable, and fiber optic lines. Each computer must have a network card installed. When choosing a tee
Ethernet cable
The Ethernet cable is also a 50 ohm coaxial cable. It is also called thick Ethernet or yellow cable. It uses 15 pin standard
Performance of three typical transmission media
Indicators Data transmission medium Two-core cable - twisted pair Coaxial cable
Frame errors due to collisions
The following are typical collision errors for Ethernet protocol frames: - Local Collision. Is the result of simultaneous transmission of two or more nodes
Collision diagnostics
The average collision rate in a normally operating network should be less than 5%. Large spikes (more than 20%) may be an indicator of cable problems. If the collision intensity is more than 10%, then
Ethernet frame errors due to length and incorrect checksum
- Shortframes. These are frames that are less than the maximum length, that is, less than 64 bytes. Sometimes this type of frames is differentiated into two classes - just short frames, which
Ethernet Frame Errors in RMON Standard
The RMON standard defines the following types of Ethernet frame errors: etherStatsCRCAlignErrors - the total number of received packets that had a length (excluding preamble) between 64
Typical errors when operating protocols
In addition to obvious errors in network operation, manifested in the appearance of frames with incorrect field values, there are error situations resulting from inconsistent settings of flow parameters
Ethernet frame format mismatch
Ethernet is one of the oldest local network technologies, with a long history of development to which various companies and organizations have contributed. As a result, there are several
Packet loss
Regular losses of packets or frames can have very serious consequences for local networks, since lower-level protocols (link protocols) are designed for high-quality cable channels St.
Non-existent address and duplicate addresses
Sending a packet to a non-existent address naturally cannot lead to normal interaction between nodes on the network. Non-existent addresses can appear on the network only if they store
Exceeded timeout values and inconsistent timeout values
Time outs are very important parameters many protocols, since unforeseen exceeding them usually leads to serious consequences. For example, exceeding a timeout may cause logic to break.
Network operating systems
System software that controls processes in computer networks, integrated common architecture, certain communication protocols and mechanisms for interaction of computing
Requirements for network operating systems
The following system requirements are distinguished: unified system architecture. ensuring the required high level of transparency. high-level and high-reliability files
Centrally managed networks
In such networks, the network operating system, also called the server OS, provides basic functions such as file system support, task scheduling, and memory management. Sethe
Decentralized or peer-to-peer networks
Online with de centralized management computers are combined, each of which can be both a server and a client. In such a network, any computer runs a regular disk OS, and for
Network applications
An important requirement for most modern application program packages (APP) is their ability to work in local networks, that is, to perform the functions of network application programs (APP).
Specialized software
In the Internet era, a huge number of specialized software tools that perform specific tasks are required. Examples include: · browsers ( Internet Explorer, Op
Terminal equipment
Terminal equipment is the main part of the subscriber system, performing application processes and, possibly, part of the functions of the interaction area. The main task terminally
Interest in these two protocols is due to the fact that they are used on both dial-up and dedicated telephone lines. Using these channels, most individual users, as well as small local networks, connect to the network. Such communication lines can provide data transfer rates of up to 115,200 bits per second.
SLIP protocol(Serial Line Internet Protocol). TCP/IP technology allows you to organize internetworking using various physical and channel data exchange protocols (IEEE 802.3 - ethernet, IEEE 802.5 - token ring, X.25, etc.). At the same time, without exchanging data over telephone lines using regular modems Internet popularity would be significantly lower. Most Internet users use their home phone as a window into the world of computer networks, connecting their computer via modem to the modem pool of an IP service company or to their work computer. The simplest way to provide full IP service is to connect through the serial port of a personal computer using the SLIP protocol. According to RFC-1055, SLIP was first included as a means of accessing an IP network in 3COM's UNET package. In 1984, Rick Adams implemented SLIP for BSD 4.2, and thus SLIP became the property of the entire IP community. Typically, this protocol is used on both dedicated and switched communication lines with speeds from 1200 to 19200 bits per second. If modems allow more, then the speed can be “increased”, because modern personal computers allow data to be transferred to the port at a speed of 115,200 bits per second. At the same time, when determining the data exchange rate, it should be taken into account that when transmitting data over a physical line, the data undergoes transformations: compression and error protection on the line. This conversion causes the line speed to be determined to be lower than the port speed. It should be noted that among the shareware IP software stacks (FreeWare), Trumpet Winsock, for example, support for SLIP communications is necessarily included. Such OS, like FreeBSD, Linux, NetBSD, which you can freely copy and install on your personal computer, or HP-UX, which comes with Hewlett Packard workstations, have in their arsenal software tools like sliplogin (FreeBSD) or slp (HP-UX ), ensuring the computer operates as a SLIP server for remote users connecting to the IP network by telephone. The SLIP protocol does not define the concept of "SLIP server", but real life makes adjustments to the standards. In the context of our presentation, a “SLIP client” is a computer that initiates a physical connection, and a “SLIP server” is a machine that is permanently connected to an IP network. In the chapter on IP networking and connectivity remote computers, we will talk in detail about the various methods of connecting via the SLIP protocol; therefore, without dwelling on the details of such a connection, we will move on to a discussion of the SLIP protocol itself. Unlike Ethernet, SLIP does not “wrap” the IP packet in its own wrapper, but “cuts” it into “pieces”. At the same time, it does it quite primitively. A SLIP packet begins with ESC (octal 333 or decimal 219) and ends with END (octal 300 or decimal 192). If these characters are found inside the packet, they are replaced with the two-byte sequences ESC-END (333,334) and ESC-ESC (333,335). The standard does not define the size of a SLIP packet; therefore, any SLIP interface has a special field in which the user must specify this length. At the same time, the standard states that the BSD SLIP driver supports packets with a length of 1006 bytes, and therefore “modern” implementations of SLIP programs must support this packet length. The SLIP module does not analyze the data stream and does not highlight any information in this stream. It simply "cuts" it into "pieces", each of which begins with the ESC character and ends with the END character. From the above description it is clear that SLIP does not allow you to perform any actions related to addresses, because The packet structure does not provide for the address field and its special processing. Computers communicating via SLIP must know their IP addresses in advance. SLIP does not allow packets to be distinguished by protocol type, such as IP or DECnet. In fact, when working over SLIP, it is assumed that only IP will be used (Serial Line IP after all), but the simplicity of the package should be tempting for other protocols. SLIP does not have information to correct link errors. Error correction is assigned to transport layer protocols - TCP, UDP. Standard SLIP does not provide data compression, but there are protocol variants with such compression. Regarding compression, the following should be noted: most modern modems that support V.42bis and MNP5 standards implement hardware compression. At the same time, the practice of working on our usual telephone channels shows that it is better to abandon this compression and work only with automatic error correction, for example MNP4 or V.42. Generally speaking, everyone should choose the mode that is most stable under the specific operating conditions of the telephone network (including the time of year and the frequency of accidents on heating mains).
Point-to-point connections - PPP (Point to Point Protocol). PPP is a younger protocol than SLIP. At the same time, its purpose is the same - control of data transmission over dedicated or dial-up communication lines. According to RFC-1661, PPP provides a standard method for communication between two hosts on a network. It is assumed that bidirectional simultaneous data transmission is provided. As in SLIP, the data is "cut" into fragments called packets. Packets are transmitted from node to node in an orderly manner. Unlike SLIP, PPP allows packets to be transmitted simultaneously over a communication line. various protocols. At the same time, PPP involves a process of auto-configuration of both interacting parties. Strictly speaking, PPP consists of three parts: an encapsulation mechanism, a link control protocol, and a family of network control protocols. When discussing how to transport data over an internetwork, encapsulation is often used, such as IP encapsulation in X.25. We have already met with TCP encapsulation in IP. Encapsulation provides multiplexing of different network protocols (internet protocols, such as IP) through a single data channel. PPP encapsulation is designed quite efficiently, for example, only 8 additional bytes (8 octets, according to PPP terminology) are required to transmit an HDLC frame. With other methods of dividing information into frames, the number of additional bytes should be reduced to 4 or even 2. To ensure fast processing information, the PPP packet boundary must be a multiple of 32 bits. When extremely important, a "ballast" is added to the end of the packet for alignment on the 32-bit boundary. Generally speaking, the concept of encapsulation in terms of PPP is not only the addition of service information to the transported information, but, if this is extremely important, also breaking this information into smaller fragments. A datagram in PPP is understood as an information unit of the network layer, in relation to IP - an IP packet. A frame is understood as an information unit of the data link layer (according to the OSI model). A frame consists of a header and a tail, between which the data is contained. The datagram must be encapsulated in one or more frames. A packet is an information unit of exchange between network and link level modules. Typically, each packet is assigned one frame, except when link layer requires even greater fragmentation of data or, on the contrary, combines packets for more efficient transmission.
SLIP and PPP protocols - concept and types. Classification and features of the category "SLIP and PPP Protocols" 2017, 2018.
In terms of protocols, the Internet uses several types of protocols that have emerged over time and development. computer technology. These include TCP/IT Protocol (1974) o TCP (Transmission Control Protocol) The file is divided into packets of no more than 1.5 KB in size Packets are transmitted... .
Internet addressing For each computer on the Internet, two unique addresses are established: a digital IP address and a domain address. Both of these addresses can be used equally. A digital address is convenient for processing on a computer, and a domain address is convenient for... .
Local network is a network that connects PCs located in a limited area and operating on the same software principles. The advent of LAN made it possible to significantly increase the efficiency of using VT due to more rational use of hardware,...