Giới thiệu về giao thức TCP

TCP (Transmission Control Protocol) là một giao thức thuộc tầng giao vận, hoạt động dựa trên cơ chế hướng kết nối và đảm bảo độ tin cậy cao trong việc truyền tải dữ liệu dưới dạng dòng byte. Tiêu chuẩn này được định nghĩa trong tài liệu RFC 793 của IETF.

Quy trình giao tiếp TCP thường trải qua ba giai đoạn chính: thiết lập kết nối, truyền tải dữ liệu và ngắt kết nối. Khác với các giao thức không liên kết, TCP yêu cầu hai bên phải thiết lập kênh liên lạc thành công trước khi trao đổi thông tin, tương tự như việc thực hiện một cuộc gọi điện thoại.

Đặc điểm nổi bật

1. Cơ chế hướng kết nối

Trước khi truyền dữ liệu, cả client và server đều phải thiết lập một kết nối logic. Hệ thống sẽ cấp phát tài nguyên内核 (kernel) để quản trạng thái kết nối này. Dữ liệu chỉ được trao đổi qua kênh đã thiết lập. Khi hoàn thành nhiệm vụ, kết nối phải được đóng để giải phóng tài nguyên. Mô hình này mang tính chất điểm-điểm (one-to-one), không hỗ trợ broadcast (nếu cần broadcast, nên sử dụng UDP).

2. Độ tin cậy cao

• Xác nhận gửi (Acknowledgment): Mỗi gói tin gửi đi đều cần nhận được phản hồi ACK từ bên nhận để xác định thành công.
• Truyền lại khi超时 (Timeout Retransmission): Bên gửi khởi tạo bộ đếm thời gian. Nếu không nhận được ACK trong khoảng thời gian quy định, gói tin sẽ được gửi lại. Số thứ tự (sequence number) giúp đảm bảo dữ liệu được sắp xếp đúng trình tự tại bên nhận.
• Kiểm tra lỗi (Error Check): Sử dụng hàm checksum để xác thực tính toàn vẹn của dữ liệu ở cả hai chiều gửi và nhận.
• Kiểm soát luồng và tắc nghẽn: Điều chỉnh tốc độ gửi dữ liệu phù hợp với khả năng xử lý của bên nhận, tránh tình trạng quá tải.

Xây dựng ứng dụng TCP Client

Trong mô hình Client-Server, Client là bên yêu cầu dịch vụ. Quy trình khởi tạo kết nối từ phía Client đơn giản hơn so với Server. Client chỉ cần biết địa chỉ IP và cổng của Server để thiết lập liên lạc.

Mã nguồn tham khảo

import socket

def connect_to_server():
    # Khởi tạo socket TCP
    client_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    
    # Nhập thông tin đích
    target_host = input("Nhập địa chỉ IP máy chủ: ")
    target_port = int(input("Nhập cổng kết nối: "))
    
    try:
        # Thiết lập kết nối
        client_sock.connect((target_host, target_port))
        
        # Nhập và gửi dữ liệu
        message = input("Nhập nội dung cần gửi: ")
        client_sock.send(message.encode('utf-8'))
        
        # Nhận phản hồi
        response = client_sock.recv(1024)
        print(f"Dữ liệu nhận được: {response.decode('utf-8')}")
    except Exception as e:
        print(f"Có lỗi xảy ra: {e}")
    finally:
        # Đóng kết nối
        client_sock.close()

if __name__ == "__main__":
    connect_to_server()

Xây dựng ứng dụng TCP Server

Server đóng vai trò cung cấp dịch vụ và cần thực hiện nhiều bước chuẩn bị hơn để sẵn sàng nhận kết nối từ nhiều Client khác nhau.

Quy trình hoạt động

1. Tạo socket.
2. Bind (gán) địa chỉ IP và Port cụ thể.
3. Listen (chuyển sang chế độ nghe) để chấp nhận kết nối thụ động.
4. Accept (chấp nhận) khi có Client yêu cầu kết nối, tạo ra một socket mới riêng cho Client đó.
5. Thực hiện recv/send dữ liệu.

Mã nguồn tham khảo

import socket

def start_server():
    # Tạo socket server
    server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    
    # Cấu hình địa chỉ lắng nghe
    server_address = ('0.0.0.0', 9900)
    
    # Gán socket vào địa chỉ
    server_sock.bind(server_address)
    
    # Chuyển sang chế độ chờ kết nối
    server_sock.listen(5)
    print("Server đang lắng nghe tại cổng 9900...")
    
    # Chấp nhận kết nối từ client
    client_conn, client_info = server_sock.accept()
    print(f"Kết nối mới từ: {client_info}")
    
    try:
        # Nhận dữ liệu
        data = client_conn.recv(1024)
        print(f"Nội dung nhận được: {data.decode('utf-8')}")
        
        # Gửi phản hồi
        client_conn.send("Xác nhận đã nhận tin nhắn".encode('utf-8'))
    finally:
        # Đóng kết nối với client cụ thể
        client_conn.close()
        server_sock.close()

if __name__ == "__main__":
    start_server()

Các lưu ý kỹ thuật quan trọng

• Server bắt buộc phải thực hiện bind để cố định địa chỉ nhận diện, trong khi Client thường để hệ thống tự cấp phát port ngẫu nhiên.
• Hàm listen chuyển đổi socket từ chế độ chủ động sang thụ động, đây là bước bắt buộc đối với Server.
• Client sử dụng connect để khởi tạo kết nối. Nếu không thành công, quá trình truyền tải không thể diễn ra.
• Khi Server gọi accept, một socket mới được sinh ra để phục vụ riêng Client đó, socket gốc vẫn tiếp tục lắng nghe các kết nối khác.
• Việc đóng socket lắng nghe (listen) sẽ ngăn không cho Client mới kết nối, nhưng các kết nối hiện tại vẫn hoạt động bình thường.
• Đóng socket kết nối (accept trả về) đồng nghĩa với việc chấm dứt phục vụ Client đó.
• Khi Client đóng kết nối, Server gọi recv sẽ trả về độ dài dữ liệu bằng 0, đây là dấu hiệu nhận biết Client đã ngắt kết nối.

Trường hợp thực tế: Chương trình tải file

Dưới đây là ví dụ về việc xây dựng một hệ thống đơn giản cho phép Client yêu cầu tải file từ Server thông qua kết nối TCP.

Phía Server

import socket
import sys
import os

def handle_file_request(filename):
    try:
        with open(filename, "rb") as f:
            return f.read()
    except FileNotFoundError:
        print(f"Không tìm thấy file: {filename}")
        return None

def run_file_server():
    if len(sys.argv) != 2:
        print("Sử dụng: python server.py <port>")
        return
    
    port = int(sys.argv[1])
    server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_sock.bind(('', port))
    server_sock.listen(10)
    print(f"File Server chạy tại port {port}")
    
    while True:
        client_sock, addr = server_sock.accept()
        try:
            req_data = client_sock.recv(1024)
            file_name = req_data.decode("utf-8").strip()
            print(f"Yêu cầu tải file: {file_name}")
            
            content = handle_file_request(file_name)
            if content:
                client_sock.send(content)
        finally:
            client_sock.close()

if __name__ == "__main__":
    run_file_server()

Phía Client

import socket

def download_file():
    client_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    
    host = input("IP Server: ")
    port = int(input("Port Server: "))
    
    client_sock.connect((host, port))
    
    file_name = input("Tên file cần tải: ")
    client_sock.send(file_name.encode("utf-8"))
    
    data = client_sock.recv(4096)
    
    if data:
        save_name = f"downloaded_{file_name}"
        with open(save_name, "wb") as f:
            f.write(data)
        print(f"Đã lưu file vào {save_name}")
    else:
        print("Không nhận được dữ liệu hoặc file không tồn tại")
        
    client_sock.close()

if __name__ == "__main__":
    download_file()

Cơ chế bắt tay 3 bước (Three-way Handshake)

Để thiết lập kết nối TCP, quá trình bắt tay diễn ra như sau:

1. SYN: Client gửi gói tin SYN (synchronize) đến Server để yêu cầu kết nối.
2. SYN-ACK: Server nhận yêu cầu, gửi lại gói tin SYN-ACK để xác nhận và đồng bộ hóa.
3. ACK: Client gửi gói tin ACK cuối cùng để xác nhận hoàn tất thiết lập kết nối.

Sau bước này, kênh truyền thông chính thức được mở và sẵn sàng trao đổi dữ liệu.

Cơ chế ngắt kết nối 4 bước (Four-way Wave)

Khi hoàn thành truyền tải, kết nối được đóng qua 4 bước:

1. Một bên (thường là Client) gửi gói tin FIN (finish) báo muốn đóng kết nối.
2. Bên kia gửi ACK xác nhận đã nhận yêu cầu đóng.
3. Bên kia sau khi hoàn thành xử lý dữ liệu tồn đọng sẽ gửi gói tin FIN của riêng nó.
4. Bên khởi tạo gửi ACK cuối cùng để đóng hoàn toàn kết nối.

Kết nối dài (Long Connection) và Kết nối ngắn (Short Connection)

Mỗi kết nối TCP đều tiêu tốn tài nguyên và thời gian để thiết lập cũng như ngắt bỏ.

Kết nối ngắn

Quy trình: Thiết lập kết nối → Truyền dữ liệu → Đóng kết nối. Mỗi lần giao dịch đều phải thực hiện lại toàn bộ quy trình bắt tay và ngắt kết nối. Phù hợp với các dịch vụ web HTTP truyền thống nơi số lượng client lớn nhưng tần suất tương tác thấp.

Kết nối dài

Quy trình: Thiết lập kết nối → Truyền dữ liệu nhiều lần → Đóng kết nối. Kết nối được giữ mở sau khi hoàn thành giao dịch đầu tiên. Phù hợp cho các ứng dụng cần tương tác liên tục như database connection, chat server, giúp giảm độ trễ và tải cho server.

Ưu nhược điểm

• Kết nối dài: Tiết kiệm thời gian bắt tay, giảm overhead. Tuy nhiên, nếu quản lý không tốt, server có thể bị quá tải do duy trì quá nhiều kết nối idle. Cần cơ chế timeout để đóng các kết nối không hoạt động.
• Kết nối ngắn: Quản lý đơn giản, tài nguyên được giải phóng ngay sau mỗi giao dịch. Tuy nhiên, tốn băng thông và thời gian cho việc thiết lập kết nối lặp lại nếu tần suất giao dịch cao.

Công cụ phân tích mạng Wireshark

Wireshark là công cụ phân tích giao thức mạng phổ biến, cho phép bắt gói tin (packet capture) để quan sát chi tiết quá trình bắt tay, truyền dữ liệu và ngắt kết nối TCP. Việc sử dụng Wireshark giúp kỹ sư mạng hiểu rõ luồng dữ liệu thực tế và phục vụ công tác gỡ lỗi (debug).

Tổng quan về bộ giao thức TCP/IP

Mạng máy tính hoạt động dựa trên các quy chuẩn chung gọi là giao thức (protocol). Để các thiết bị khác nhau có thể giao tiếp, chúng phải tuân thủ cùng một bộ quy tắc. Bộ giao thức phổ biến nhất hiện nay là TCP/IP.

Cấu trúc phân tầng

Bộ giao thức TCP/IP thường được mô hình hóa qua 4 tầng chính:

• Tầng ứng dụng (Application Layer): Chứa các giao thức phục vụ người dùng cuối như HTTP, FTP, SMTP.
• Tầng giao vận (Transport Layer): Chịu trách nhiệm truyền tải dữ liệu end-to-end, bao gồm TCP và UDP.
• Tầng mạng (Internet Layer): Định tuyến và đánh địa chỉ logic, giao thức chính là IP.
• Tầng truy cập mạng (Network Access Layer): Giao tiếp vật lý với mạng, tương đương tầng Liên kết dữ liệu và Vật lý trong mô hình OSI.

Sự kết hợp giữa TCP ở tầng giao vận và IP ở tầng mạng tạo nên nền tảng vững chắc cho Internet toàn cầu.