面试篇——Tcp/Ip编程

一晚想明白一生的事

于 2024-09-15 17:00:00 发布

阅读量550

点赞数 17

分类专栏：面试小技巧文章标签：面试 tcp/ip 职场和发展 c++ 网络协议网络

本文链接：https://blog.csdn.net/qq_42331320/article/details/142262613

版权

面试小技巧专栏收录该内容

3 篇文章 0 订阅

订阅专栏

TCP/IP 编程是基于 TCP 和 UDP 协议进行网络通信的编程技术。在 Linux 和 Windows 中，使用套接字（Socket）来进行 TCP/IP 编程。以下是 TCP/IP 编程的基本概念和步骤，涵盖了客户端和服务器端的实现。------祝大家中秋快乐！

一、Socket 基础概念

1.Socket（套接字）

套接字是一个抽象的通信端点。通过套接字，程序可以向网络发送数据或接收数据。

2.TCP（Transmission Control Protocol）

面向连接的协议，提供可靠的字节流传输。

3.UDP（User Datagram Protocol）

无连接的协议，适用于需要快速传输且不在乎丢包的场景。

二、套接字编程的基本步骤

TCP 和 UDP 编程的步骤稍有不同，以下是基于 TCP 的编程流程：

1.TCP服务器端

创建套接字：使用 socket() 函数创建一个套接字。
绑定 IP 和端口：使用 bind() 函数将套接字绑定到指定的 IP 地址和端口号。
监听连接：使用 listen() 函数让服务器开始监听连接请求。
接受连接：使用 accept() 函数接收客户端连接请求，并创建一个新的套接字用于通信。
发送和接收数据：使用 send() 和 recv() 函数进行数据的发送和接收。
关闭套接字：使用 close() 或 shutdown() 函数关闭套接字。

2.TCP客户端

创建套接字：使用 socket() 函数创建一个套接字。
连接到服务器：使用 connect() 函数连接到服务器的 IP 地址和端口。
发送和接收数据：使用 send() 和 recv() 函数进行数据的发送和接收。
关闭套接字：使用 close() 或 shutdown() 函数关闭套接字。

三、TCP 服务器与客户端编程示例

1.TCP 服务器（C++）

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <arpa/inet.h>

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);
    char buffer[BUFFER_SIZE] = {0};
    const char* hello = "Hello from server";

    // 创建 socket 文件描述符
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("Socket failed");
        exit(EXIT_FAILURE);
    }

    // 绑定 socket 到端口
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
        perror("setsockopt");
        exit(EXIT_FAILURE);
    }

    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    // 绑定 socket 到给定的 IP 和端口
    if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
        perror("Bind failed");
        exit(EXIT_FAILURE);
    }

    // 监听连接
    if (listen(server_fd, 3) < 0) {
        perror("Listen failed");
        exit(EXIT_FAILURE);
    }

    // 接受客户端连接
    if ((new_socket = accept(server_fd, (struct sockaddr*)&address, (socklen_t*)&addrlen)) < 0) {
        perror("Accept failed");
        exit(EXIT_FAILURE);
    }

    // 接收来自客户端的消息
    read(new_socket, buffer, BUFFER_SIZE);
    std::cout << "Message from client: " << buffer << std::endl;

    // 发送消息给客户端
    send(new_socket, hello, strlen(hello), 0);
    std::cout << "Hello message sent" << std::endl;

    close(new_socket);
    close(server_fd);

    return 0;
}

2.TCP 客户端（C++）

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <arpa/inet.h>

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;
    char buffer[BUFFER_SIZE] = {0};
    const char* hello = "Hello from client";

    // 创建 socket
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        std::cerr << "Socket creation error" << std::endl;
        return -1;
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);

    // 将服务器地址转换为二进制形式
    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        std::cerr << "Invalid address/Address not supported" << std::endl;
        return -1;
    }

    // 连接服务器
    if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
        std::cerr << "Connection failed" << std::endl;
        return -1;
    }

    // 发送消息给服务器
    send(sock, hello, strlen(hello), 0);
    std::cout << "Hello message sent" << std::endl;

    // 接收来自服务器的消息
    read(sock, buffer, BUFFER_SIZE);
    std::cout << "Message from server: " << buffer << std::endl;

    close(sock);

    return 0;
}

四、UDP 服务器与客户端编程示例

UDP 是无连接的，所以服务器和客户端的操作比 TCP 简单，没有建立连接的过程。以下是 UDP 编程示例。

1.UDP 服务器（C++）

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <arpa/inet.h>

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    int sockfd;
    char buffer[BUFFER_SIZE];
    struct sockaddr_in servaddr, cliaddr;

    // 创建 socket
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("Socket creation failed");
        exit(EXIT_FAILURE);
    }

    memset(&servaddr, 0, sizeof(servaddr));
    memset(&cliaddr, 0, sizeof(cliaddr));

    // 填充服务器信息
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = INADDR_ANY;
    servaddr.sin_port = htons(PORT);

    // 绑定 socket 到 IP 和端口
    if (bind(sockfd, (const struct sockaddr*)&servaddr, sizeof(servaddr)) < 0) {
        perror("Bind failed");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    int len = sizeof(cliaddr);
    int n;

    // 接收客户端消息
    n = recvfrom(sockfd, (char*)buffer, BUFFER_SIZE, 0, (struct sockaddr*)&cliaddr, (socklen_t*)&len);
    buffer[n] = '\0';
    std::cout << "Message from client: " << buffer << std::endl;

    // 发送消息给客户端
    const char* hello = "Hello from server";
    sendto(sockfd, (const char*)hello, strlen(hello), 0, (const struct sockaddr*)&cliaddr, len);
    std::cout << "Hello message sent" << std::endl;

    close(sockfd);

    return 0;
}

2.UDP 客户端（C++）

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <arpa/inet.h>

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    int sockfd;
    char buffer[BUFFER_SIZE];
    struct sockaddr_in servaddr;

    // 创建 socket
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("Socket creation failed");
        exit(EXIT_FAILURE);
    }

    memset(&servaddr, 0, sizeof(servaddr));

    // 填充服务器信息
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(PORT);
    servaddr.sin_addr.s_addr = INADDR_ANY;

    // 发送消息给服务器
    const char* hello = "Hello from client";
    sendto(sockfd, (const char*)hello, strlen(hello), 0, (const struct sockaddr*)&servaddr, sizeof(servaddr));
    std::cout << "Hello message sent" << std::endl;

    int len = sizeof(servaddr);
    int n;

    // 接收服务器消息
    n = recvfrom(sockfd, (char*)buffer, BUFFER_SIZE, 0, (struct sockaddr*)&servaddr, (socklen_t*)&len);
    buffer[n] = '\0';
    std::cout << "Message from server: " << buffer << std::endl;

    close(sockfd);

    return 0;
}

五、常用的套接字函数

socket()：创建一个新的套接字。
bind()：将套接字绑定到 IP 地址和端口。
listen()：在套接字上监听传入连接（仅限 TCP）。
accept()：接受传入的连接请求（仅限 TCP）。
connect()：客户端连接到服务器。
send()：向连接的套接字发送数据。
recv()：从连接的套接字接收数据。
sendto()：发送数据到指定地址（仅限 UDP）。
recvfrom()：从指定地址接收数据（仅限 UDP）。
close()：关闭套接字。

六、TCP/IP 编程中的常见问题

在使用 C++ 进行 TCP/IP 编程时，开发者经常会遇到一些常见问题。了解并解决这些问题可以帮助确保网络应用的稳定性和高效性。

1.端口占用问题

问题描述：当服务器程序异常退出后，再次启动时可能会遇到“端口已被占用”的错误。即使程序已经关闭，端口可能仍然处于 TIME_WAIT 状态，无法立即重用。
解决方案：使用 setsockopt() 配置 SO_REUSEADDR 选项，允许在处于 TIME_WAIT 状态的端口上立即重用套接字。

int opt = 1;
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

2.TCP粘包/拆包问题

问题描述：TCP 是面向流的协议，发送方发送的数据可能会被一次或多次发送，接收方也可能一次性接收多个数据包（粘包），或者一个包被分成多次接收（拆包）。
解决方案：使用应用层协议解决粘包和拆包问题。可以在每个消息前增加定长的头部来标明数据的长度，或者使用分隔符区分消息。

例如，可以在每条消息前增加 4 字节表示消息的长度，接收方通过读取这 4 字节确定完整消息的大小。

// 定义消息头的结构
struct MessageHeader {
    uint32_t length;  // 消息长度
};

3.阻塞与非阻塞 I/O

问题描述：默认情况下，TCP 套接字是阻塞的，这意味着 recv() 或 send() 函数会阻塞当前线程，直到完成操作。如果对高并发场景没有进行非阻塞处理，服务器性能会受到影响。
解决方案：可以将套接字设置为非阻塞模式，并使用 select() 或 epoll() 等 I/O 多路复用机制来处理多个连接。

int flags = fcntl(sockfd, F_GETFL, 0);
fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);

非阻塞套接字允许程序在没有数据可读时立即返回，以便处理其他任务或连接。

4.资源泄露

在客户端和服务器端连接关闭时，确保正确调用 close() 关闭套接字。
使用智能指针（如 C++11 的 std::unique_ptr 和 std::shared_ptr）管理动态分配的内存，以避免手动管理内存带来的问题。

5.数据包丢失和重传

问题描述：由于网络抖动或不稳定，TCP 连接上的数据包可能会丢失。TCP 会自动进行重传，但这可能导致性能下降，特别是在高延迟网络中。
解决方案：虽然 TCP 内部已经处理了丢包和重传，但在高延迟或丢包率较高的网络环境下，可以通过优化窗口大小、调整超时机制等措施来改善性能。例如，调整 SO_RCVBUF 和 SO_SNDBUF 的大小来优化数据传输性能。

6.数据的有序性与重复性

问题描述：TCP 保证数据的有序性，但有时候由于网络抖动，接收方可能会收到重复的数据。尽管 TCP 能够自动处理这些情况，但仍有可能由于应用程序逻辑的问题出现重复处理。
解决方案：在应用层协议中引入数据序列号，确保数据按序列号处理。收到重复的数据包时，可以根据序列号丢弃重复的部分。

7.长时间空闲的连接超时

问题描述：TCP 连接在长时间没有数据传输的情况下可能会被防火墙或路由器关闭（例如 NAT 超时）。这对于长期保持连接的应用（如 WebSocket、长连接）是个常见问题。
解决方案：通过设置心跳机制（heartbeat），定期发送少量数据保持连接的活跃状态，或者启用 TCP 的 SO_KEEPALIVE 选项。

int opt = 1;
setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(opt));

8.IPv4 与 IPv6 的兼容性

问题描述：随着 IPv6 的普及，应用程序需要兼容 IPv4 和 IPv6 地址。然而，IPv4 和 IPv6 套接字在创建和绑定上有所不同。
解决方案：使用支持 IPv4 和 IPv6 的通用机制，或者在创建套接字时明确指定使用 IPv6 的协议族 AF_INET6。还可以设置 IPV6_V6ONLY 选项来控制套接字是否只能接收 IPv6 连接。

9.宽带控制

问题描述：在某些情况下，发送大量数据时可能会占用过多的带宽，影响其他程序的网络连接。
解决方案：通过控制数据发送的速率来限制带宽占用。例如，在发送数据时引入延迟或分批发送来控制带宽。

10.防止拒绝服务攻击（DoS）

问题描述：服务器面临 DoS 攻击时，可能会被大量无效连接请求耗尽资源，导致正常请求无法处理。
解决方案：
1. 使用防火墙限制每个 IP 地址的连接数。
2. 在应用程序层面限制每个客户端的并发连接数量。
3. 在高并发情况下使用 epoll 或 select 等多路复用机制高效处理连接。

11.Nagle 算法

问题描述：Nagle 算法是一种通过合并小数据包来减少网络上的包数量的算法。虽然它可以减少拥塞，但在某些低延迟要求的场景中可能会导致响应延迟。
解决方案：如果需要即时发送小数据包，可以禁用 Nagle 算法：

int flag = 1;
setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(int));

12.大数据传输中的问题

问题描述：当需要传输大数据时，网络带宽或内存可能成为瓶颈，导致数据传输缓慢甚至失败。
解决方案：
1. 进行分段传输，每次发送固定大小的数据块。
2. 对数据进行压缩，减少数据量。
3. 增加发送和接收缓冲区大小，优化传输效率。

int buf_size = 65536; // 64 KB
setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &buf_size, sizeof(buf_size));
setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &buf_size, sizeof(buf_size));