通过网络编程实现一个C/S模式的员工管理系统，服务器端用多进程或多线程模型支持多个客户端同时连接、操作。具体要求如下： （1）员工信息包括三个字段：姓名，年龄，手机号，用结构体表示； （2）服务器功能： 添加新员工——接受客户端发送来的新员工结构体数据，追加到数据文件emp.db中； 获取员工列表——把emp.db中的每个员工结构体数据读出发回客户端； （3）客户端功能： 添加新员工——从终端读取新员工信息并构造为结构体变量，发到服务器请求添加新员工； 显示员工列表——向服务器请求员工列表，接收后显示到终端。 （4）客户端和服务器之间的协议应事先设计，如服务器返回给客户端的各类报告信息、错误信息都应事先统一设计好编号

和格式。

协议设计：
客户端发送数据格式：
添加新员工请求：
编号：0x01
数据：员工结构体

获取员工列表请求：
编号：0x02
数据：无

服务器返回数据格式：
添加新员工成功：
编号：0x11
数据：添加成功

添加新员工失败：
编号：0x12
数据：添加失败原因

获取员工列表成功：
编号：0x21
数据：员工结构体数组

获取员工列表失败：
编号：0x22
数据：获取失败原因

服务器端流程：
1.建立服务器端套接字
2.绑定套接字，并监听客户端连接
3.当有客户端连接时，创建新的子进程处理连接请求
4.子进程接受客户端请求
5.根据客户端请求编号执行相应操作
6.服务器返回数据给客户端

客户端流程：
1.建立客户端套接字
2.连接服务器端
3.从终端读取用户输入，构造请求数据
4.发送请求给服务器端
5.等待服务器返回数据
6.根据服务器返回数据编号执行相应操作

代码实现：

服务器端

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

#define PORT 9000 
#define MAX_BUFFER 1024 

typedef struct _Employee { 
    char name[32]; 
    int age; 
    char phone[16]; 
} Employee; 

int addEmployee(Employee employee); 
Employee* getEmployees(int* count); 

int main(int argc, char const *argv[]) 
{ 
    int server_fd, client_fd; 
    pid_t child_pid; 
    struct sockaddr_in server_addr, client_addr; 
    socklen_t sin_len = sizeof(client_addr); 

    char buffer[MAX_BUFFER]; 
    int count = 0; 

    server_fd = socket(AF_INET, SOCK_STREAM, 0); 
    if (server_fd < 0) { 
        perror("socket error"); 
        exit(1); 
    } 

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

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

    if (listen(server_fd, 10) == -1) { 
        perror("listen error"); 
        close(server_fd); 
        exit(1); 
    } 

    printf("Server started.\n"); 

    while (1) { 
        client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &sin_len); 
        if (client_fd == -1) { 
            perror("accept error"); 
            continue; 
        } 

        inet_ntop(AF_INET, &client_addr.sin_addr, buffer, MAX_BUFFER); 
        printf("Client connected: %s\n", buffer); 

        if ((child_pid = fork()) == -1) { 
            perror("fork error"); 
            close(client_fd); 
            continue; 
        } else if (child_pid == 0) { 
            close(server_fd); 

            while (1) { 
                memset(buffer, 0, MAX_BUFFER); 
                int bytes_read = read(client_fd, buffer, MAX_BUFFER); 
                if (bytes_read < 0) { 
                    perror("read error"); 
                    close(client_fd); 
                    exit(1); 
                } else if (bytes_read == 0) { 
                    printf("Connection closed.\n"); 
                    close(client_fd); 
                    exit(0); 
                } 

                int request_code = buffer[0]; 
                if (request_code == 0x01) { 
                    Employee employee; 
                    memcpy(&employee, buffer + 1, sizeof(Employee)); 
                    if (addEmployee(employee) < 0) { 
                        strcpy(buffer, "Add employee failed."); 
                        write(client_fd, buffer, strlen(buffer)); 
                    } else { 
                        strcpy(buffer, "Add employee success."); 
                        write(client_fd, buffer, strlen(buffer)); 
                    } 
                } else if (request_code == 0x02) { 
                    Employee* employees = getEmployees(&count); 
                    if (employees == NULL || count <= 0) { 
                        strcpy(buffer, "Get employees failed."); 
                        write(client_fd, buffer, strlen(buffer)); 
                    } else { 
                        memcpy(buffer, &count, sizeof(count)); 
                        memcpy(buffer + sizeof(count), employees, sizeof(Employee) * count); 
                        write(client_fd, buffer, sizeof(count) + sizeof(Employee) * count); 
                        free(employees); 
                    } 
                } 
            } 

            close(client_fd); 
            exit(0); 
        } 

        close(client_fd); 
    } 

    return 0; 
} 

int addEmployee(Employee employee) 
{ 
    FILE* fp; 
    fp = fopen("emp.db", "ab"); 
    if (fp == NULL) { 
        perror("open file error"); 
        return -1; 
    } 

    fwrite(&employee, sizeof(Employee), 1, fp); 
    fclose(fp); 

    return 0; 
} 

Employee* getEmployees(int* count) 
{ 
    FILE* fp; 
    Employee* employees = NULL; 
    int size = 0; 

    fp = fopen("emp.db", "rb"); 
    if (fp == NULL) { 
        perror("open file error"); 
        return NULL; 
    } 

    fseek(fp, 0, SEEK_END); 
    size = ftell(fp); 
    rewind(fp); 

    if (size % sizeof(Employee) != 0) { 
        perror("file error"); 
        fclose(fp); 
        return NULL; 
    } 

    *count = size / sizeof(Employee); 
    employees = (Employee*)malloc(sizeof(Employee) * (*count)); 
    fread(employees, sizeof(Employee), (*count), fp); 

    fclose(fp); 
    return employees; 
} 

客户端

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

#define SERVER_IP "localhost" 
#define PORT 9000 
#define MAX_BUFFER 1024 

typedef struct _Employee { 
    char name[32]; 
    int age; 
    char phone[16]; 
} Employee; 

void addEmployee(int sockfd); 
void getEmployees(int sockfd); 

int main(int argc, char const *argv[]) 
{ 
    int sockfd; 
    struct sockaddr_in server_addr; 

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

    server_addr.sin_family = AF_INET; 
    server_addr.sin_port = htons(PORT); 
    inet_pton(AF_INET, SERVER_IP, &server_addr.sin_addr); 

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

    char option[16]; 
    while (1) { 
        printf("Enter option: "); 
        scanf("%s", option); 
        if (strcasecmp(option, "add") == 0) { 
            addEmployee(sockfd); 
        } else if (strcasecmp(option, "get") == 0) { 
            getEmployees(sockfd); 
        } else if (strcasecmp(option, "exit") == 0) { 
            break; 
        } else { 
            printf("Invalid option.\n"); 
        } 
    } 

    close(sockfd); 

    return 0; 
} 

void addEmployee(int sockfd) 
{ 
    Employee employee; 
    printf("Enter name: "); 
    scanf("%s", employee.name); 
    printf("Enter age: "); 
    scanf("%d", &employee.age); 
    printf("Enter phone: "); 
    scanf("%s", employee.phone); 

    char buffer[MAX_BUFFER]; 
    memset(buffer, 0, MAX_BUFFER); 
    memcpy(buffer, &employee, sizeof(Employee)); 
    buffer[0] = 0x01; 

    write(sockfd, buffer, sizeof(Employee) + 1); 

    memset(buffer, 0, MAX_BUFFER); 
    int bytes_read = read(sockfd, buffer, MAX_BUFFER); 
    if (bytes_read < 0) { 
        perror("read error"); 
    } else { 
        printf("%s\n", buffer); 
    } 
} 

void getEmployees(int sockfd) 
{ 
    char buffer[MAX_BUFFER]; 
    memset(buffer, 0, MAX_BUFFER); 
    buffer[0] = 0x02; 

    write(sockfd, buffer, 1); 

    memset(buffer, 0, MAX_BUFFER); 
    int bytes_read = read(sockfd, buffer, MAX_BUFFER); 
    if (bytes_read < 0) { 
        perror("read error"); 
    } else { 
        int count = 0; 
        memcpy(&count, buffer, sizeof(count)); 

        if (count <= 0) { 
            printf("No employee.\n"); 
        } else { 
            Employee* employees = (Employee*)(buffer + sizeof(count)); 
            for (int i = 0; i < count; i++) { 
                printf("name: %s, age: %d, phone: %s\n", 
                    employees[i].name, employees[i].age, employees[i].phone); 
            } 
        } 
    } 
}