实现linux下的基于C语言的一个严谨的TCP客户端与服务端的通信，支持推送指定长度数据（如1MB或10MB），支持慢发送usleep函数的调用并显示单位毫秒

好的，我可以为您解答这个问题。首先，您需要使用套接字（socket）编程来实现TCP客户端与服务端之间的通信。在C语言中，可以使用socket、bind、listen、accept、connect、send和recv等函数来实现TCP通信。

在客户端中，您可以使用以下步骤来实现：

1. 创建一个套接字：使用socket函数创建一个套接字。

2. 连接服务器：使用connect函数连接服务器。

3. 发送数据：使用send函数发送数据。

4. 接收数据：使用recv函数接收数据。

在服务端中，您可以使用以下步骤来实现：

1. 创建一个套接字：使用socket函数创建一个套接字。

2. 绑定套接字到IP地址和端口号：使用bind函数将套接字绑定到IP地址和端口号。

3. 监听连接请求：使用listen函数监听连接请求。

4. 接收连接请求：使用accept函数接收连接请求。

5. 接收数据：使用recv函数接收数据。

6. 发送数据：使用send函数发送数据。

要支持推送指定长度数据，您可以在发送数据之前先使用malloc函数动态分配内存，然后将数据存储在动态分配的内存中。要支持慢发送并显示单位毫秒的延迟，您可以使用usleep函数设置延迟，并使用clock函数获取当前时间来计算延迟的时间。

下面是一个基本的TCP客户端和服务端实现示例的代码：

客户端代码：

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

#define SERVER_IP "127.0.0.1"
#define SERVER_PORT 8888
#define BUFFER_SIZE 1024*1024 // 1MB

int main()
{
    int sockfd;
    struct sockaddr_in server_addr;
    char *buffer;
    int buffer_len = BUFFER_SIZE;
    int delay = 1000; // 1ms delay

    // create socket
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("socket error");
        exit(EXIT_FAILURE);
    }

    // set server address
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
    server_addr.sin_port = htons(SERVER_PORT);

    // connect to server
    if (connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        perror("connect error");
        exit(EXIT_FAILURE);
    }

    // send data
    buffer = malloc(buffer_len);
    memset(buffer, 'A', buffer_len);
    clock_t start = clock();
    int total_len = 0;
    while (total_len < buffer_len) {
        int len = send(sockfd, buffer+total_len, buffer_len-total_len, 0);
        if (len < 0) {
            perror("send error");
            exit(EXIT_FAILURE);
        }
        total_len += len;
        usleep(delay);
    }
    clock_t end = clock();
    double time = (double)(end - start) / CLOCKS_PER_SEC * 1000;
    printf("send %d bytes in %.2lf ms\n", buffer_len, time);

    // close socket
    close(sockfd);
    free(buffer);

    return 0;
}

服务端代码：

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

#define SERVER_IP "0.0.0.0"
#define SERVER_PORT 8888
#define BUFFER_SIZE 1024*1024 // 1MB

int main()
{
    int listenfd, connfd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len;
    char buffer[BUFFER_SIZE];

    // create socket
    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (listenfd < 0) {
        perror("socket error");
        exit(EXIT_FAILURE);
    }

    // set server address
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
    server_addr.sin_port = htons(SERVER_PORT);

    // bind socket to address
    if (bind(listenfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind error");
        exit(EXIT_FAILURE);
    }

    // listen for connections
    if (listen(listenfd, 5) < 0) {
        perror("listen error");
        exit(EXIT_FAILURE);
    }

    // accept connection
    client_len = sizeof(client_addr);
    connfd = accept(listenfd, (struct sockaddr*)&client_addr, &client_len);
    if (connfd < 0) {
        perror("accept error");
        exit(EXIT_FAILURE);
    }

    // receive data
    int total_len = 0;
    while (total_len < BUFFER_SIZE) {
        int len = recv(connfd, buffer+total_len, BUFFER_SIZE-total_len, 0);
        if (len < 0) {
            perror("recv error");
            exit(EXIT_FAILURE);
        } else if (len == 0) {
            printf("client closed connection\n");
            break;
        }
        total_len += len;
    }
    printf("received %d bytes\n", total_len);

    // close connection and socket
    close(connfd);
    close(listenfd);

    return 0;
}