vmware linux问题 写一个程序

vmware linux问题 写一个程序
1、服务器端进程建立 DeviceRecode.txt文件，等待客户端的请求，接收数据，并写入客户端传来的信息。

2、客户端进程运行时，提示“请输入学号和姓名：，等待用户输入学号和姓名，输入的信息发送给服务器，提示“请输入设备号：”等待用户输入设备号，输入的设备号发送给服务器；然后提示“请输入设备名称：”，等待用户输入设备名称，输入的设备名称发送给服务器，然后提示“请输入参数：”，等待用户输入参数，输入的参数发送给服务器。服务器接收信息后写入DeviceRecode.txt文件，同时发送接收到的信息给客户端，客户端显示接收的信息。

3、系统采用进程互斥的方式添加信息，防止接收的信息发生错位的现象。

该回答引用ChatGPT

还请尝试下面代码
服务器端代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <pthread.h>

#define MAX_BUF_SIZE 1024

char device_file[] = "DeviceRecord.txt";
pthread_mutex_t mutex;

void *handle_client(void *client_fd_ptr) {
    int client_fd = *((int*)client_fd_ptr);
    char buffer[MAX_BUF_SIZE];
    int n;

    memset(buffer, 0, MAX_BUF_SIZE);
    n = read(client_fd, buffer, MAX_BUF_SIZE-1);
    if (n < 0) {
        perror("Error reading from socket");
        close(client_fd);
        return NULL;
    }

    printf("Received data from client: %s\n", buffer);
    pthread_mutex_lock(&mutex);

    FILE *fp;
    fp = fopen(device_file, "a");
    if (fp != NULL) {
        fprintf(fp, "%s\n", buffer);
        fclose(fp);
    } else {
        printf("Failed to open file %s\n", device_file);
    }

    pthread_mutex_unlock(&mutex);
    n = write(client_fd, buffer, strlen(buffer));
    if (n < 0) {
        perror("Error writing to socket");
        close(client_fd);
        return NULL;
    }

    close(client_fd);
    return NULL;
}

int main(int argc, char *argv[]) {
    int sockfd, newsockfd, portno;
    socklen_t clilen;
    struct sockaddr_in serv_addr, cli_addr;
    pthread_t thread_id;

    if (argc < 2) {
        printf("Usage: %s port\n", argv[0]);
        exit(1);
    }

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("Error opening socket");
        exit(1);
    }

    memset((char*)&serv_addr, 0, sizeof(serv_addr));
    portno = atoi(argv[1]);
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = INADDR_ANY;
    serv_addr.sin_port = htons(portno);

    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
        perror("Error on binding");
        exit(1);
    }

    listen(sockfd, 5);
    printf("Server started, waiting for clients...\n");

    while (1) {
        clilen = sizeof(cli_addr);
        newsockfd = accept(sockfd, (struct sockaddr*)&cli_addr, &clilen);

        if (newsockfd < 0) {
            perror("Error on accept");
            continue;
        }

        pthread_create(&thread_id, NULL, handle_client, (void*)&newsockfd);
    }

    close(sockfd);
    return 0;
}

客户端代码

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

#define PORT 8888
#define BUF_SIZE 1024

int main() {
    int client_socket;
    struct sockaddr_in server_addr;
    char buf[BUF_SIZE];
    char stu_num[50], name[50], device_num[50], device_name[50], param[50];

    // 创建套接字对象
    if ((client_socket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // 设置服务器地址信息
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    memset(server_addr.sin_zero, 0, sizeof(server_addr.sin_zero));

    // 连接服务器
    if (connect(client_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("connect");
        exit(EXIT_FAILURE);
    }

    // 循环输入学号、姓名、设备号、设备名称、参数
    while (1) {
        printf("请输入学号：");
        scanf("%s", stu_num);
        printf("请输入姓名：");
        scanf("%s", name);
        printf("请输入设备号：");
        scanf("%s", device_num);
        printf("请输入设备名称：");
        scanf("%s", device_name);
        printf("请输入参数：");
        scanf("%s", param);

        // 将输入的信息打包成字符串
        snprintf(buf, BUF_SIZE, "%s %s %s %s %s", stu_num, name, device_num, device_name, param);

        // 发送数据到服务器
        if (send(client_socket, buf, strlen(buf), 0) == -1) {
            perror("send");
            exit(EXIT_FAILURE);
        }

        // 接收服务器返回的数据并打印
        if (recv(client_socket, buf, BUF_SIZE, 0) == -1) {
            perror("recv");
            exit(EXIT_FAILURE);
        }
        printf("接收到的信息：%s\n", buf);
    }

    // 关闭套接字
    close(client_socket);

    return 0;
}

server端：

import socket
import threading

# 服务器地址和端口
SERVER_ADDRESS = ('0.0.0.0', 8888)

# 设备记录文件路径
DEVICE_RECORD_FILE = 'DeviceRecode.txt'

# 定义全局锁
lock = threading.Lock()


# 处理客户端请求的线程函数
def handle_client(client_socket):
    # 接收客户端的学号和姓名
    student_id = client_socket.recv(1024).decode()
    client_socket.send(f"学号和姓名：{student_id}".encode())

    # 接收客户端的设备号
    device_id = client_socket.recv(1024).decode()
    client_socket.send(f"设备号：{device_id}".encode())

    # 接收客户端的设备名称
    device_name = client_socket.recv(1024).decode()
    client_socket.send(f"设备名称：{device_name}".encode())

    # 接收客户端的参数
    parameter = client_socket.recv(1024).decode()
    client_socket.send(f"参数：{parameter}".encode())

    # 构造设备记录字符串
    device_record = f"{student_id},{device_id},{device_name},{parameter}"

    # 加锁，避免多个线程同时写入文件导致错位
    with lock:
        with open(DEVICE_RECORD_FILE, 'a') as f:
            f.write(device_record + '\n')

    # 发送回客户端
    client_socket.send(f"已接收：{device_record}".encode())

    # 关闭客户端连接
    client_socket.close()


# 服务器主函数
def main():
    # 创建服务器套接字
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 绑定服务器地址和端口
    server_socket.bind(SERVER_ADDRESS)

    # 监听客户端连接
    server_socket.listen(5)

    print(f"服务器已启动，地址：{SERVER_ADDRESS[0]}，端口：{SERVER_ADDRESS[1]}")

    while True:
        # 等待客户端连接
        client_socket, client_address = server_socket.accept()

        # 开启一个线程处理客户端请求
        t = threading.Thread(target=handle_client, args=(client_socket,))
        t.start()


if __name__ == '__main__':
    main()

client端：

import socket

# 创建一个客户端socket对象
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 服务器IP地址和端口号
server_address = ('192.168.1.100', 8000)

# 连接服务器
client_socket.connect(server_address)

# 等待用户输入学号和姓名
stu_num = input("请输入学号：")
stu_name = input("请输入姓名：")

# 发送学号和姓名给服务器
client_socket.sendall(bytes(stu_num + ',' + stu_name, encoding='utf-8'))

# 接收服务器返回的数据并打印
recv_data = client_socket.recv(1024).decode('utf-8')
print("收到服务器返回的数据：", recv_data)

# 等待用户输入设备号、设备名称和参数
dev_num = input("请输入设备号：")
dev_name = input("请输入设备名称：")
dev_param = input("请输入参数：")

# 发送设备信息给服务器
client_socket.sendall(bytes(dev_num + ',' + dev_name + ',' + dev_param, encoding='utf-8'))

# 接收服务器返回的数据并打印
recv_data = client_socket.recv(1024).decode('utf-8')
print("收到服务器返回的数据：", recv_data)

# 关闭客户端socket
client_socket.close()

以下是一个基于socket和进程互斥的方式实现上述需求的示例程序。这个程序使用Python编写，可以在Linux系统上运行，并假定客户端和服务器端在同一台机器上运行。

import socket
import threading

mutex = threading.Lock()
filename = "DeviceRecord.txt"

def handle_client(client_socket):
    # receive student info
    student_info = client_socket.recv(1024).decode()
    student_id, student_name = student_info.split(",")

    # receive device info
    device_id = client_socket.recv(1024).decode()
    device_name = client_socket.recv(1024).decode()
    parameter = client_socket.recv(1024).decode()

    # write to file
    with mutex:
        with open(filename, "a") as f:
            f.write(f"{student_id},{student_name},{device_id},{device_name},{parameter}\n")

    # send response back to client
    response = f"Received: {student_id}, {student_name}, {device_id}, {device_name}, {parameter}"
    client_socket.send(response.encode())

    # close socket
    client_socket.close()

def main():
    # create socket
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(("127.0.0.1", 8888))
    server_socket.listen(5)

    while True:
        # accept connection
        client_socket, address = server_socket.accept()

        # handle client request in a new thread
        t = threading.Thread(target=handle_client, args=(client_socket,))
        t.start()

if __name__ == "__main__":
    main()

client.py

import socket

def main():
    # create socket
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # connect to server
    server_address = ("127.0.0.1", 8888)
    client_socket.connect(server_address)

    # receive student info
    student_id = input("请输入学号：")
    student_name = input("请输入姓名：")
    student_info = f"{student_id},{student_name}"
    client_socket.send(student_info.encode())

    # receive device info
    device_id = input("请输入设备号：")
    device_name = input("请输入设备名称：")
    parameter = input("请输入参数：")
    client_socket.send(device_id.encode())
    client_socket.send(device_name.encode())
    client_socket.send(parameter.encode())

    # receive response from server
    response = client_socket.recv(1024).decode()
    print(response)

    # close socket
    client_socket.close()

if __name__ == "__main__":
    main()

在运行这个程序之前，你需要在Linux上安装Python环境，并且将以上代码保存到两个不同的文件中，例如server.py和client.py。在终端中进入这些文件所在的目录，分别运行python server.py和python client.py即可。注意，需要先运行服务器程序再运行客户端程序。

如果对您有帮助，请给与采纳，谢谢。

不知道你解决了没有？如果没有，我们可以聊聊。

这个问题的核心在于互斥，不要被同时修改。
其他的功能还好说。

不知道你希望什么语言来处理？

以下是一个简单的基于Python的解决方案，它使用了socket编程库和线程锁（thread lock）来实现进程互斥：

服务器端程序：

import socket
import threading

# 创建线程锁
lock = threading.Lock()

# 创建服务器套接字
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 监听端口号
port = 12345
server_socket.bind(('localhost', port))

# 等待客户端连接
server_socket.listen(1)
print("等待客户端连接...")

# 创建记录设备信息的文件
with open('DeviceRecord.txt', 'w') as f:
    f.write('学号\t姓名\t设备号\t设备名称\t参数\n')

# 处理客户端请求的函数
def handle_request(conn):
    # 获取客户端的学号和姓名
    conn.sendall(b"请输入学号和姓名（用空格分隔）：")
    student_info = conn.recv(1024).decode().strip().split()
    student_id, student_name = student_info[0], student_info[1]

    # 获取客户端的设备信息
    conn.sendall(b"请输入设备号：")
    device_id = conn.recv(1024).decode().strip()

    conn.sendall(b"请输入设备名称：")
    device_name = conn.recv(1024).decode().strip()

    conn.sendall(b"请输入参数：")
    parameter = conn.recv(1024).decode().strip()

    # 将设备信息写入文件
    with lock:
        with open('DeviceRecord.txt', 'a') as f:
            f.write(f'{student_id}\t{student_name}\t{device_id}\t{device_name}\t{parameter}\n')

    # 发送响应给客户端
    response = f'成功添加设备信息：{student_id} {student_name} {device_id} {device_name} {parameter}\n'
    conn.sendall(response.encode())

    # 关闭连接
    conn.close()

# 不断等待客户端连接并处理请求
while True:
    conn, addr = server_socket.accept()
    print(f"客户端 {addr} 已连接")
    t = threading.Thread(target=handle_request, args=(conn,))
    t.start()

客户端程序：

import socket

# 创建客户端套接字
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 连接服务器
server_address = ('localhost', 12345)
client_socket.connect(server_address)

# 获取用户输入
student_info = input("请输入学号和姓名（用空格分隔）：")
device_id = input("请输入设备号：")
device_name = input("请输入设备名称：")
parameter = input("请输入参数：")

# 发送信息给服务器
client_socket.sendall(f"{student_info}\n{device_id}\n{device_name}\n{parameter}\n".encode())

# 接收服务器响应并显示
response = client_socket.recv(1024).decode()
print(response)

# 关闭连接
client_socket.close()

参考gpt
以下是一个简单的示例程序，使用C语言在Linux上实现服务器端和客户端的进程通信。该程序会创建一个名为DeviceRecord.txt的文件，在服务器端接收客户端传来的数据，并将其写入该文件中。同时，客户端会提示用户输入学号、姓名、设备号、设备名称和参数，将这些数据发送给服务器端，并等待服务器端的响应。

服务器端程序：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <semaphore.h>

#define PORT 8080
#define MAXLINE 1024

sem_t mutex;

int main()
{
    int sockfd, connfd, len;
    struct sockaddr_in servaddr, cli;

    // 创建套接字
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        printf("socket creation failed...\n");
        exit(0);
    }
    else
        printf("Socket successfully created..\n");

    // 初始化服务器地址结构体
    bzero(&servaddr, sizeof(servaddr));

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

    // 绑定套接字
    if ((bind(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr))) != 0) {
        printf("socket bind failed...\n");
        exit(0);
    }
    else
        printf("Socket successfully bound..\n");

    // 监听套接字
    if ((listen(sockfd, 5)) != 0) {
        printf("Listen failed...\n");
        exit(0);
    }
    else
        printf("Server listening..\n");

    len = sizeof(cli);

    while (1) {
        // 接受客户端请求
        connfd = accept(sockfd, (struct sockaddr*)&cli, &len);
        if (connfd < 0) {
            printf("server acccept failed...\n");
            exit(0);
        }
        else
            printf("server acccept the client...\n");

        // 创建子进程
        if (fork() == 0) {
            close(sockfd);
            char buffer[MAXLINE];

            // 读取客户端传来的数据
            read(connfd, buffer, sizeof(buffer));
            sem_wait(&mutex); // 进入临界区
            printf("Data received from client: %s\n", buffer);

            // 将数据写入文件
            FILE* fp = fopen("DeviceRecord.txt", "a");
            fprintf(fp, "%s\n", buffer);
            fclose(fp);

            // 发送数据给客户端
            write(connfd, buffer, sizeof(buffer));
            sem_post(&mutex); // 离开临界区

            // 关闭连接
            close(connfd);
            exit(0);
        }
        else {
            close(connfd);
        }
    }

    close(sockfd);
    return 0;
}

客户端程序：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <semaphore.h>

#define PORT 8080
#define MAXLINE 1024

sem

运行结果会根据具体的输入和输出而不同。但是，我们可以简单地描述程序的预期行为和输出。

当服务器端进程运行时，它会创建一个名为DeviceRecode.txt的文件，并等待客户端连接。一旦客户端连接成功并发送数据，服务器进程将接收并写入该文件，并将接收到的数据发送回客户端。

当客户端进程运行时，它会提示用户输入学号和姓名。用户输入学号和姓名后，客户端将这些信息发送到服务器。然后，客户端提示用户输入设备号、设备名称和参数，并将这些信息发送到服务器。客户端接收并显示从服务器返回的信息。

如果多个客户端同时尝试连接服务器，则服务器会按照进程互斥的方式添加信息，以防止信息错位。

• 建议你看下这篇博客👉 ：VMware虚拟机下安装Linux，不能联网问题解决

服务器端代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <pthread.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void handle_client(int client_socket) {
    char buffer[1024];
    int n;
    while ((n = recv(client_socket, buffer, sizeof(buffer), 0)) > 0) {
        pthread_mutex_lock(&mutex);
        FILE *fp = fopen("DeviceRecode.txt", "a");
        fwrite(buffer, 1, n, fp);
        fclose(fp);
        send(client_socket, buffer, n, 0);
        pthread_mutex_unlock(&mutex);
    }
    close(client_socket);
}

void start_server() {
    int server_socket, client_socket;
    struct sockaddr_in server_address, client_address;
    socklen_t client_address_len;

    server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket < 0) {
        perror("创建套接字失败");
        exit(1);
    }

    memset(&server_address, 0, sizeof(server_address));
    server_address.sin_family = AF_INET;
    server_address.sin_addr.s_addr = htonl(INADDR_ANY);
    server_address.sin_port = htons(8000);

    if (bind(server_socket, (struct sockaddr *)&server_address, sizeof(server_address)) < 0) {
        perror("绑定套接字失败");
        exit(1);
    }

    if (listen(server_socket, 5) < 0) {
        perror("监听套接字失败");
        exit(1);
    }

    printf("服务器已启动，等待客户端连接...\n");
    while (1) {
        client_address_len = sizeof(client_address);
        client_socket = accept(server_socket, (struct sockaddr *)&client_address, &client_address_len);
        if (client_socket < 0) {
            perror("接受客户端连接失败");
            exit(1);
        }
        printf("客户端已连接\n");
        pthread_t client_thread;
        pthread_create(&client_thread, NULL, (void *)&handle_client, (void *)client_socket);
    }
    close(server_socket);
}

int main() {
    start_server();
    return 0;
}

客户端代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>

void send_data(int client_socket, const char *data) {
    send(client_socket, data, strlen(data), 0);
    char buffer[1024];
    int n = recv(client_socket, buffer, sizeof(buffer), 0);
    buffer[n] = '\0';
    printf("接收到的信息：%s\n", buffer);
}

void start_client() {
    int client_socket;
    struct sockaddr_in server_address;

    client_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (client_socket < 0) {
        perror("创建套接字失败");
        exit(1);
    }

    memset(&server_address, 0, sizeof(server_address));
    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(8000);
    if (inet_pton(AF_INET, "127.0.0.1", &server_address.sin_addr) <= 0) {
        perror("无效的 IP 地址");
        exit(1);
   if (connect(client_socket, (struct sockaddr *)&server_address, sizeof(server_address)) < 0) {
        perror("连接服务器失败");
        exit(1);
    }

    char data[1024];
    printf("请输入学号和姓名：");
    fgets(data, sizeof(data), stdin);
    send_data(client_socket, data);

    printf("请输入设备号：");
    fgets(data, sizeof(data), stdin);
    send_data(client_socket, data);

    printf("请输入设备名称：");
    fgets(data, sizeof(data), stdin);
    send_data(client_socket, data);

    printf("请输入参数：");
    fgets(data, sizeof(data), stdin);
    send_data(client_socket, data);

    close(client_socket);
}

int main() {
    start_client();
    return 0;
}

在客户端程序中，我们首先创建一个套接字并连接到服务器。然后，从标准输入中读取用户输入的信息，并发送给服务器。每次发送完毕后，我们还会接收服务器返回的数据，并将其打印到控制台上。

在 send_data 函数中，我们先将数据发送到服务器，然后接收服务器返回的数据。注意到我们使用了 recv 函数来接收数据，这个函数在没有数据可读时会阻塞程序，直到有数据可读。在接收到数据后，我们将其打印到控制台上。

为了实现进程互斥，我们使用了一个互斥锁来保护文件的写操作。在 handle_client 函数中，我们首先使用 pthread_mutex_lock 函数获得互斥锁，然后打开文件并写入数据，最后释放互斥锁。这样，我们就可以保证每个进程在写文件时不会相互干扰。

服务器端代码

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

#define BUF_SIZE 1024

int main() {
    int server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket == -1) {
        perror("socket() failed");
        exit(1);
    }

    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(12345);

    if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        perror("bind() failed");
        exit(1);
    }

    if (listen(server_socket, 5) == -1) {
        perror("listen() failed");
        exit(1);
    }

    int client_socket;
    struct sockaddr_in client_addr;
    socklen_t client_addr_size = sizeof(client_addr);
    char buf[BUF_SIZE];

    int fd = open("DeviceRecode.txt", O_CREAT | O_WRONLY | O_APPEND, 0644);
    if (fd == -1) {
        perror("open() failed");
        exit(1);
    }

    while (1) {
        client_socket = accept(server_socket, (struct sockaddr*)&client_addr, &client_addr_size);
        if (client_socket == -1) {
            perror("accept() failed");
            continue;
        }

        int n = read(client_socket, buf, BUF_SIZE);
        if (n == -1) {
            perror("read() failed");
            continue;
        } else if (n == 0) {
            close(client_socket);
            continue;
        }

        buf[n] = '\0';
        printf("Received data from client: %s\n", buf);

        if (flock(fd, LOCK_EX) == -1) {
            perror("flock() failed");
            close(client_socket);
            continue;
        }

        if (write(fd, buf, n) == -1) {
            perror("write() failed");
            flock(fd, LOCK_UN);
            close(client_socket);
            continue;
        }

        if (flock(fd, LOCK_UN) == -1) {
            perror("flock() failed");
            close(client_socket);
            continue;
        }

        if (send(client_socket, buf, n, 0) == -1) {
            perror("send() failed");
        }

        close(client_socket);
    }

    close(server_socket);
    close(fd);
    return 0;
}

客户端代码

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

#define BUF_SIZE 1024

int main() {
    int client_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (client_socket == -1) {
        perror("socket() failed");
        exit(1);
    }

    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    server_addr.sin_port = htons(12345);

    if (connect(client_socket, (

下面是基于Python实现的一个简单的服务器端和客户端程序，实现了题目中描述的功能：
服务器端代码：

import socket

def process_request(conn, addr):
    # 建立 DeviceRecode.txt 文件
    with open("DeviceRecode.txt", "w") as f:
        f.write("学号\t姓名\t设备号\t设备名称\t参数\n")

    while True:
        # 接收客户端请求
        data = conn.recv(1024)
        if not data:
            break

        # 解析客户端请求
        student_id, student_name, device_id, device_name, param = data.decode().strip().split()

        # 向 DeviceRecode.txt 文件写入记录
        with open("DeviceRecode.txt", "a") as f:
            f.write(f"{student_id}\t{student_name}\t{device_id}\t{device_name}\t{param}\n")

        # 发送响应给客户端
        response = f"已成功添加记录：{student_id}\t{student_name}\t{device_id}\t{device_name}\t{param}\n"
        conn.send(response.encode())

    conn.close()

if __name__ == '__main__':
    # 创建 socket
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 绑定端口
    server_address = ('localhost', 8000)
    server_socket.bind(server_address)

    # 监听连接
    server_socket.listen(5)

    while True:
        # 接收客户端连接
        conn, addr = server_socket.accept()

        # 处理客户端请求
        process_request(conn, addr)

客户端代码：

import socket

if __name__ == '__main__':
    # 创建 socket
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 连接服务器
    server_address = ('localhost', 8000)
    client_socket.connect(server_address)

    # 输入学号和姓名
    student_id = input("请输入学号：")
    student_name = input("请输入姓名：")

    # 发送学号和姓名
    message = f"{student_id} {student_name} "
    client_socket.send(message.encode())

    # 输入设备号、设备名称和参数
    device_id = input("请输入设备号：")
    device_name = input("请输入设备名称：")
    param = input("请输入参数：")

    # 发送设备信息
    message = f"{device_id} {device_name} {param}"
    client_socket.send(message.encode())

    # 接收服务器响应
    response = client_socket.recv(1024).decode()

    # 显示服务器响应
    print(response)

    # 关闭 socket 连接
    client_socket.close()

https://www.baidu.com/link?url=DghetjBCNoHXuSko_7DWA-XNOGEUiNhxqGJFi-uNpt2ggkL7rjpijkwk2hCe6cTyjsBfhaKxtL-fVXMiDLdpMJiTlscs18u0EmCxp6zJerG&wd=&eqid=a575b1cb001d90450000000263f2d5f8

以下答案基于ChatGPT与GISer Liu编写：

以下是一个简单的Python程序实现了你提出的功能，注意需要在服务器端建立名为DeviceRecord.txt的文件并在程序中指定路径，程序中使用了socket库实现客户端和服务器端之间的通信，同时使用了threading库实现进程互斥。

服务器端代码：

python

import socket
import threading

# 服务器IP和端口
SERVER_ADDRESS = ('0.0.0.0', 8888)

# DeviceRecord.txt文件路径
RECORD_PATH = '/path/to/DeviceRecord.txt'

# 互斥锁
mutex = threading.Lock()

def handle_client(conn, addr):
    # 接收学号和姓名
    student_id = conn.recv(1024).decode()
    name = conn.recv(1024).decode()

    # 接收设备号、设备名称和参数
    device_id = conn.recv(1024).decode()
    device_name = conn.recv(1024).decode()
    parameter = conn.recv(1024).decode()

    # 写入DeviceRecord.txt文件
    with mutex:
        with open(RECORD_PATH, 'a') as f:
            f.write(f'{student_id},{name},{device_id},{device_name},{parameter}\n')

    # 发送接收到的信息
    conn.send(f'Received: {student_id}, {name}, {device_id}, {device_name}, {parameter}'.encode())

    # 关闭连接
    conn.close()

def start_server():
    # 创建socket
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(SERVER_ADDRESS)
    server_socket.listen(5)

    while True:
        # 接收连接
        conn, addr = server_socket.accept()

        # 开启新线程处理连接
        t = threading.Thread(target=handle_client, args=(conn, addr))
        t.start()

if __name__ == '__main__':
    start_server()

客户端代码：

python

import socket

# 服务器IP和端口
SERVER_ADDRESS = ('127.0.0.1', 8888)

def send_message(message):
    # 创建socket
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client_socket.connect(SERVER_ADDRESS)

    # 发送消息
    client_socket.send(message.encode())

    # 接收服务器响应
    response = client_socket.recv(1024).decode()
    print(response)

    # 关闭连接
    client_socket.close()

if __name__ == '__main__':
    # 输入学号和姓名
    student_id = input('请输入学号：')
    name = input('请输入姓名：')

    # 发送学号和姓名
    send_message(f'{student_id}\n{name}\n')

    # 输入设备号、设备名称和参数
    device_id = input('请输入设备号：')
    device_name = input('请输入设备名称：')
    parameter = input('请输入参数：')

    # 发送设备信息
    send_message(f'{device_id}\n{device_name}\n{parameter}\n')

注意替换服务器IP和端口，以及DeviceRecord.txt文件的路径。运行客户端程序后，按照提示输入相应的信息即可完成数据传输。

该回答引用ChatGPT
使用VMware Linux中的Socket编程来实现上述功能。首先，您需要在服务器端编写一个Socket服务器，用于接收客户端发送的信息，并将信息写入DeviceRecode.txt文件，同时将接收到的信息发送给客户端；然后，您需要在客户端编写一个Socket客户端，用于接收服务器发送的信息，并将用户输入的信息发送给服务器；最后，您需要使用进程互斥的方式来添加信息，以防止接收的信息发生错位的现象。