1. Tổng quan về giao thức UDP

UDP (User Datagram Protocol) là giao thức thuộc tầng giao vận (Transport Layer), hoạt động theo cơ chế không hướng kết nối (connectionless). Khác với TCP, UDP không yêu cầu thiết lập liên kết trước khi truyền tải, không có cơ chế xác nhận gói tin (ACK) và không đảm bảo dữ liệu sẽ đến đích theo đúng thứ tự. Chính vì vậy, nó thường được gọi là giao thức "không tin cậy", nhưng lại mang đến hiệu năng cực cao về mặt tốc độ.

Đặc điểm kỹ thuật:

• Không trạng thái: Không duy trì trạng thái kết nối, giúp tiết kiệm tài nguyên hệ thống.
• Hướng gói tin: Dữ liệu được gửi đi dưới dạng các Datagram riêng lẻ. Ranh giới giữa các gói tin được giữ nguyên (khác với dòng bit liên tục của TCP).
• Tốc độ tối ưu: Không tốn chi phí cho việc bắt tay (handshake), kiểm soát luồng hay gửi lại gói tin lỗi.
• Khả năng truyền tin đa hướng: Hỗ trợ tốt các chế độ Broadcast (quảng bá) và Multicast (đa điểm).

Các trường hợp ứng dụng:

• Truy vấn DNS, đồng bộ thời gian NTP.
• Truyền tải dữ liệu thời gian thực: Livestream, VoIP, Game online, IPTV.
• Các thiết bị IoT hoặc dịch vụ trong mạng nội bộ cần phát hiện thiết bị tự động.

2. Quy trình lập trình Socket UDP

Phía gửi (Client):

1. Khởi tạo Socket bằng hàm socket().
2. Cấu hình địa chỉ đích (IP và Port) vào cấu trúc sockaddr_in.
3. Thực hiện gửi dữ liệu bằng hàm sendto().
4. Đóng Socket khi hoàn tất.

Phía nhận (Server):

1. Khởi tạo Socket bằng hàm socket().
2. Liên kết Socket với một địa chỉ và cổng cụ thể trên máy thông qua hàm bind().
3. Chờ và nhận dữ liệu bằng hàm recvfrom() (hàm này thường sẽ chặn luồng thực thi cho đến khi có dữ liệu).
4. Đóng Socket.

3. Chi tiết các hàm API hệ thống

Khởi tạo Socket

#include <sys/socket.h>
int socket(int domain, int type, int protocol);

• domain: Thường dùng AF_INET cho IPv4.
• type: Sử dụng SOCK_DGRAM cho giao thức UDP.
• protocol: Mặc định là 0.

Gửi dữ liệu (sendto)

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
               const struct sockaddr *dest_addr, socklen_t addrlen);

Nhận dữ liệu (recvfrom)

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                 struct sockaddr *src_addr, socklen_t *addrlen);

Cấu trúc địa chỉ sockaddr_in

struct sockaddr_in {
    sa_family_t    sin_family; // AF_INET
    in_port_t      sin_port;   // Cổng (định dạng Network Byte Order)
    struct in_addr sin_addr;   // Địa chỉ IP
};

4. Mã nguồn minh họa lập trình UDP trong C

Chương trình gửi dữ liệu (Sender)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

int main() {
    int sockfd_client = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd_client < 0) {
        perror("Lỗi tạo socket");
        return 1;
    }

    struct sockaddr_in target_info;
    memset(&target_info, 0, sizeof(target_info));
    target_info.sin_family = AF_INET;
    target_info.sin_port = htons(9000); // Cổng đích
    target_info.sin_addr.s_addr = inet_addr("127.0.0.1");

    char input_msg[256];
    while (1) {
        printf("Nhập nội dung: ");
        fgets(input_msg, sizeof(input_msg), stdin);
        
        ssize_t bytes_sent = sendto(sockfd_client, input_msg, strlen(input_msg), 0,
                                   (struct sockaddr *)&target_info, sizeof(target_info));
        if (bytes_sent > 0) {
            printf("Đã gửi %zd byte.\n", bytes_sent);
        }
    }

    close(sockfd_client);
    return 0;
}

Chương trình nhận dữ liệu (Receiver)

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

int main() {
    int sockfd_server = socket(AF_INET, SOCK_DGRAM, 0);
    
    struct sockaddr_in host_addr;
    host_addr.sin_family = AF_INET;
    host_addr.sin_port = htons(9000);
    host_addr.sin_addr.s_addr = INADDR_ANY; // Nhận từ mọi giao diện mạng

    if (bind(sockfd_server, (struct sockaddr *)&host_addr, sizeof(host_addr)) < 0) {
        perror("Lỗi bind");
        return 1;
    }

    char buffer[1024];
    struct sockaddr_in client_info;
    socklen_t info_len = sizeof(client_info);

    printf("Đang chờ dữ liệu trên cổng 9000...\n");
    while (1) {
        memset(buffer, 0, sizeof(buffer));
        ssize_t n = recvfrom(sockfd_server, buffer, sizeof(buffer) - 1, 0,
                             (struct sockaddr *)&client_info, &info_len);
        if (n > 0) {
            printf("Từ [%s:%d]: %s", inet_ntoa(client_info.sin_addr), 
                   ntohs(client_info.sin_port), buffer);
        }
    }

    close(sockfd_server);
    return 0;
}

5. Kỹ thuật nâng cao: Thiết lập thuộc tính Socket

Để tối ưu hóa hoặc kích hoạt các tính năng đặc biệt, lập trình viên sử dụng hàm setsockopt().

• SO_REUSEADDR: Cho phép tái sử dụng địa chỉ và cổng ngay lập tức sau khi đóng chương trình, tránh lỗi "Address already in use".
• SO_BROADCAST: Cho phép gửi các gói tin quảng bá đến toàn bộ mạng cục bộ.
• SO_RCVTIMEO: Thiết lập thời gian chờ (timeout) cho hàm nhận dữ liệu để tránh bị treo vô hạn.

Ví dụ thiết lập Timeout khi nhận dữ liệu:

struct timeval timeout;
timeout.tv_sec = 3;  // 3 giây
timeout.tv_usec = 0;
setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));

6. So sánh UDP và TCP

7. Xử lý các vấn đề thường gặp

1. Mất dữ liệu: Do UDP không có cơ chế điều khiển luồng, nếu tốc độ gửi nhanh hơn tốc độ xử lý của bên nhận, hàng đợi sẽ bị tràn và gói tin bị hủy. Giải pháp là tăng kích thước buffer nhận bằng SO_RCVBUF hoặc triển khai cơ chế xác nhận ở tầng ứng dụng.
2. Tường lửa ngăn chặn: Nhiều máy chủ đám mây (như AWS, Alibaba Cloud) mặc định chặn các cổng UDP. Cần cấu hình "Security Group" để mở các cổng cần thiết.
3. Phân mảnh gói tin: Nếu kích thước dữ liệu vượt quá MTU (thường là 1500 byte), gói tin sẽ bị chia nhỏ. Nếu mất một mảnh, toàn bộ gói tin sẽ không thể phục hồi. Khuyến nghị nên giữ kích thước dữ liệu UDP dưới 512 hoặc 1472 byte.