UDP sockets offer a connectionless, unreliable datagram service. This means that each data packet (datagram) is sent independently, without any prior connection setup. There are no guarantees of delivery, order, or error-free transmission. This makes UDP faster and lower overhead than TCP, suitable for applications that prioritize speed over absolute reliability.

A UDP server typically waits for incoming datagrams from clients and responds to them.

1. Create the Socket (socket()):
2. The server creates a UDP socket using socket(AF_INET, SOCK_DGRAM, 0).
3. Error Check: Verify sockfd is not -1.
4. Define Server Address (sockaddr_in):
5. A struct sockaddr_in is initialized with the server's IP address (e.g., INADDR_ANY) and the specific port number it will listen on for UDP datagrams.
6. server_addr.sin_family = AF_INET;
7. server_addr.sin_port = htons(PORT_NUMBER);
8. server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
9. Bind the Socket (bind()):
10. The bind() system call associates the UDP socket with the server_addr. This is essential for a UDP server because it tells the operating system which address and port the server will receive datagrams on. Without binding, the server wouldn't have a known address for clients to send to.
11. Error Check: Ensure bind() returns 0.
12. Receive Data (recvfrom()):
13. This is typically placed inside an infinite loop.
14. recvfrom() blocks the server until a datagram arrives on the bound socket.
15. When a datagram is received, recvfrom() places the incoming data into a buffer, and critically, it also fills in the src_addr structure with the IP address and port number of the sender. This information is vital for the server to know where to send a reply.
16. Return Value: Number of bytes received, or -1 on error.
17. Example: bytes_received = recvfrom(server_sockfd, buffer, sizeof(buffer), 0, (struct sockaddr *)&client_addr, &addr_len);
18. Process Data and Send Response (sendto()):
19. After receiving and processing the datagram, the server uses sendto() to send a response back. Since UDP is connectionless, the destination address must be specified for each sendto() call. This destination address is typically the client_addr obtained from the preceding recvfrom() call.
20. Example: sendto(server_sockfd, response, strlen(response), 0, (struct sockaddr *)&client_addr, addr_len);
21. Close the Socket (close()):
22. When the server application is no longer needed, the UDP socket is closed to release resources.
23. Example: close(server_sockfd);

A UDP client sends datagrams to a specific server and can optionally receive replies.

1. Create the Client Socket (socket()):
2. The client creates a UDP socket using socket(AF_INET, SOCK_DGRAM, 0).
3. Error Check: Verify sockfd is not -1.
4. Define Server Address (sockaddr_in):
5. A struct sockaddr_in variable is initialized with the IP address and port number of the target UDP server to which datagrams will be sent.
6. server_addr.sin_family = AF_INET;
7. server_addr.sin_port = htons(SERVER_PORT);
8. inet_pton(AF_INET, "SERVER_IP_ADDRESS", &server_addr.sin_addr);
9. Send Data (sendto()):
10. The client uses sendto() to send a datagram to the specified server_addr. No connect() call is made for a typical UDP client. The operating system assigns an ephemeral (temporary) local port to the client's socket automatically when sendto() is first called.
11. Example: sendto(client_sockfd, message, strlen(message), 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
12. Receive Response (Optional - recvfrom()):
13. If the client expects a reply from the server, it uses recvfrom() to receive the incoming datagram. This call can block until a response arrives.
14. Example: bytes_received = recvfrom(client_sockfd, buffer, sizeof(buffer), 0,
    (struct sockaddr *)&server_addr_response, &addr_len_response);
15. Important: The src_addr argument for recvfrom should typically be a separate sockaddr_in structure (e.g., server_addr_response) to capture the actual sender of the response, as the server might reply from a different port or even a different IP if there's a load balancer.
16. Close the Socket (close()):
17. After completing communication (sending its datagrams and optionally receiving replies), the client close()s its socket.
18. Example: close(client_sockfd);

● Datagram Size: UDP datagrams have a maximum theoretical size, but the practical maximum without fragmentation is limited by the Path MTU (Maximum Transmission Unit), which is typically 1500 bytes for Ethernet. Sending larger datagrams may lead to fragmentation and increased packet loss.

● No Flow Control/Congestion Control: UDP applications are responsible for managing their own data rates. Sending data too fast can overwhelm the receiver or congest the network, leading to packet loss.