Learning about UDP in Linux

1. Introduction to UDP and Linux Basics

Socket: IP address + port number

IP address: 4 bytes Port number: 2 bytes, that is, the range is 0~65535
Port numbers are divided into: well-known port numbers, some fixed port numbers, and well-known port numbers.
0--1023: http, ssh, ftp, telnet and other protocol port numbers are fixed and cannot be assigned by the operating system

Some fixed port numbers

ssh server, using port 22
ftp server, using port 21
Telnet server, using port 23
http server, using port 80
HTTPS server uses port 443. The port number dynamically assigned by the operating system is the port number of the client server. The operating system can assign port numbers in this range.

Check the port number

less /etc/services
 //You can view all port numbers under Linux

Understanding of IP addresses:
An IP address is used to identify a host.

Understanding of port numbers:
The port number is used to tell the operating system which process to operate on, that is, the port number is used to identify a process. A port number can only be occupied by one process, but a process can have multiple port numbers, that is, the process and port number are a one-to-many relationship. When we write a program using port numbers, we must avoid these well-known port numbers.

【question】

(1) Can a process bind to multiple port numbers?
Yes, because a process can open multiple file descriptors, and each file descriptor corresponds to a port number, so a process can bind multiple port numbers

(2) Can a port number be bound by multiple processes?
No. If a process first binds a port number and then forks a child process, multiple processes can be bound to one port number. However, it is not possible for different processes to bind to the same port number.
In the TIME_WAIT state, the server cannot be restarted immediately, which also means that different processes cannot bind to the same port number at the same time.

(3) Can multiple processes listen to the same port number?
Can. Before listening, you need to create a socket->bind ip::port number->listen. We can use the setsockopt function before bind to set socket options, including the REUSEADDR option, which indicates that multiple processes can reuse the address and port number specified in the bind function. Therefore, the socket can accurately identify a process on a host, thereby completing communication between computers (a process on host A communicates with another process on host B)

Network byte order conversion:
When data is transmitted in the network, it has its own transmission rules. There are two transmission sequences for data on the host:
Big endian: high byte order is placed at low address Little endian: low byte order is placed at low address Transmission: data at low address is transmitted first and then data at high address Therefore, when data is transmitted on the host to the network, data errors may occur (for example, when the host is little endian, conversion is required)

Conversion function:

uint32_t htonl(uint32_t hostlong);
uint16_thtons(uint16 hostshort);
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);
h: indicates host name
n: indicates network
l: indicates 4-byte long
s: indicates a 2-byte short

Address conversion function:

Convert string to in_addr
in_addr_t inet_addr(const char* strptr)
in_addr is converted to string char* inet_ntoa(struct in_addr inaddr)

It is non-reentrant, that is, it cannot be called multiple times, because the function itself allocates a space in the static area to store the IP address string.

UDP protocol:
UDP protocol end format

• 16 is the UDP length, which indicates the maximum length of the entire datagram (UDP header + UDP data) (64KB)
• Checksum: If the checksum is wrong, it will be discarded directly (the check is to check both the header and the data part)
• The checksum is first calculated by a special algorithm at the data sender, and then recalculated after being transmitted to the receiver. If a datagram is tampered with by a third party during transmission or is damaged due to line noise or other reasons, the checksum calculation values ​​of the sender and receiver will not match, so the UDP protocol can check whether there is an error.
• Source port number: It is selected when the other party replies. If it is not needed, all 0 can be used
• Destination port number: must be used when delivering messages at the destination
• Length: The length of the UDP user datagram, the minimum value is 8 (only the header)

Characteristics of UDP:

• No connection: Directly transmit data after receiving the IP and port number of the other end, without establishing a connection
• Unreliable: There is no confirmation mechanism, no retransmission mechanism; because there is no network failure, the segment cannot be sent to the other party, and the UDP protocol layer will not return any error information to the application layer
• Datagram-oriented: cannot flexibly control the number and amount of reading and writing data
• Fewer control options, less delay during data transmission, and high data transmission efficiency
• Datagram Oriented
• No matter how long the application layer gives to UDP, UDP sends it as is, without splitting or merging

Example: Use UDP to transmit 100 bytes of data <br /> If the sender calls sendto once, it sends 100 bytes. Then the receiving end must also call the corresponding recvfrom once to receive 100 bytes; it cannot call recvfrom 10 times in a loop, sending 10 bytes each time.
UDP buffer
UDP has no send buffer. After calling sendto, the data is directly handed over to the kernel, which passes the data to the network layer protocol for subsequent transmission. Because UDP is not connection-oriented, there is no retransmission mechanism, and there is no need to send a buffer to save the data that has been sent in preparation for retransmission in case of a failed transmission.
UDP has a receive buffer. However, this receive buffer cannot guarantee that the order of received UDP packets is consistent with the order of sent UDP packets; if the buffer is full, the arriving UDP data will be discarded.
UDP Socket can read and write, full-duplex

Notes on using UDP:
The UDP protocol header has a maximum length of 16 bits, which means that the maximum length of data that can be transmitted by UDP is 64K (including the UDP header). But 64K is a very small number in today's Internet environment. If the data we need to transmit exceeds 64K, we need to manually split it into packets at the application layer, send it multiple times, and assemble it at the receiving end.
The calculation method of the checksum in the UDP header is somewhat special. When calculating the checksum, a 12-byte pseudo header is added before the UDP user datagram. The pseudo header is neither transmitted downward nor delivered upstream, but is only used to calculate the checksum. Unlike the IP datagram checksum, which only checks the IP datagram header, the UDP checksum checks both the header and the data part.

Pseudo header:

UDP-based application layer protocols:

• NFS: Network File System
• TFTP: Trivial File Transfer Protocol
• DHCP: Dynamic Host Configuration Protocol
• DNS: Domain Name Resolution Protocol

Using UDP to achieve reliable transmission?

• Refer to TCP's reliability mechanism and implement similar logic at the application layer
• Reference serial number to ensure data order
• Introduce confirmation responses to ensure that the other end has received the data
• Introduce timeout retransmission. If there is no response after a period of time, resend the data.

2. Use of each function

1. Use of socket functions

1.1 Function prototype

int socket(int domain, int type, int protocol);
domain: domain AF_INET:IPV4
    AF_INET6: IPV6
type: type SOCK_STREAM
    SOCK_DGARM
protocol: protocol

1.2 What does the function do?
Creates an unbound socket in the communication domain and returns a file descriptor that can be used in subsequent function calls that operate on the socket.

2. Use of bind function

2.1 Function prototype
int bind(int socket, const struct sockaddr* address, socklen_t address_len);
2.2. Function This function uses the previously created socket to bind the IP address and port number, which means that the socket can identify a certain host in a network and the process in the host.

3. Use of recvfrom function

3.1 Function prototype

ssize_t recvfrom(int socket, void* restrict buffer, size_t length, 
                 int flags, struct sockaddr* restrict address, 
                socklen_t* restrict address_len);
​
socket: the socket whose message is to be received buffer: the buffer used to receive messages length: the length of the received message flags: type address: a null pointer or a sockaddr structure for storing sent information addless_len: specifies the length of the sockaddr structure pointed to by the address parameter

3.2 Functions
Used to receive messages sent from the socket. The sockaddr structure of the socket also knows

4. Use of sendto function

4.1 Function prototype
ssize_t recvfrom(int socket, const void* message, size_t length,
int flags, const struct sockaddr* dest_addr,
socklen_t* dest_len);
4.2 Function <br /> This function is used by the socket to receive messages from dest_addr.

3. Expand your knowledge

1. netstat

Netstat is a non-critical tool used to monitor TCP/IP networks. Syntax: netstat [options]
Function: View network status

Options:
-a, display all connected Sockets
-c, continuously list network status
-n, use the IP address directly without going through the domain name server, that is, display it as a number
-l, display the socket of the monitored server, and only list the socket in the listening state
-p, displays the identification code and name (PID/Program name) of the program that is using the socket
-t, display the connection status of TCP transmission protocol
-u, display the connection status of the UDP transport protocol
-v, display the execution process of the command
-V, display version information
-x, display the connection status of the UNIX transport protocol
-s, display network work information statistics
-h, online help

2. pidof

Viewing the server process ID is very convenient

Syntax: pisdof [process name]

Function: View process id by process name

This is the end of this article about learning UDP in Linux. For more relevant Linux content, please search for previous articles on 123WORDPRESS.COM or continue to browse the related articles below. I hope everyone will support 123WORDPRESS.COM in the future!