基于TCP的FTP文件传输系统设计与实现（超详细）

基于TCP的FTP文件传输系统设计与实现

1. FTP协议概述与TCP基础

1.1 FTP协议简介

文件传输协议（FTP）是用于在网络上进行文件传输的一套标准协议，使用TCP/IP协议进行数据传输。FTP采用客户端-服务器（C/S）架构模型，通过建立两个连接来工作：控制连接和数据连接。

FTP协议的主要特点：

• 使用两个独立连接：控制连接（端口21）和数据连接（端口20）
• 支持多种文件类型（ASCII、二进制等）
• 提供用户身份验证机制
• 支持主动模式和被动模式

1.2 TCP协议基础

传输控制协议（TCP）是面向连接的、可靠的、基于字节流的传输层通信协议。TCP提供全双工通信，通过三次握手建立连接，四次挥手断开连接。

TCP的关键特性：

• 可靠数据传输：通过序列号、确认应答、重传机制保证
• 流量控制：通过滑动窗口机制实现
• 拥塞控制：通过慢启动、拥塞避免等算法实现
• 面向连接：建立连接后才能传输数据

// TCP套接字创建的基本流程// 服务器端：socket() -> bind() -> listen() -> accept()// 客户端：socket() -> connect()

2. TCP Socket编程基础

2.1 Socket编程核心概念

Socket（套接字）是网络编程的抽象概念，是应用层与TCP/IP协议族通信的中间软件抽象层。在TCP/IP协议中，Socket组合了IP地址和端口号，用于标识网络中的唯一进程。

Socket类型：

• 流式Socket（SOCK_STREAM）：面向连接的TCP协议
• 数据报Socket（SOCK_DGRAM）：无连接的UDP协议
• 原始Socket（SOCK_RAW）：原始协议访问

2.2 TCP Socket API详解

// 主要Socket API函数#include<sys/types.h>#include<sys/socket.h>// 创建Socketintsocket(intdomain,inttype,intprotocol);// 绑定地址intbind(intsockfd,conststructsockaddr*addr,socklen_taddrlen);// 监听连接intlisten(intsockfd,intbacklog);// 接受连接intaccept(intsockfd,structsockaddr*addr,socklen_t*addrlen);// 建立连接intconnect(intsockfd,conststructsockaddr*addr,socklen_taddrlen);// 发送数据ssize_tsend(intsockfd,constvoid*buf,size_tlen,intflags);// 接收数据ssize_trecv(intsockfd,void*buf,size_tlen,intflags);// 关闭连接intclose(intfd);

3. 系统设计与架构

3.1 系统整体架构设计

我们的FTP系统采用经典的客户端-服务器架构，设计上包含以下核心模块：

1. 服务器端模块：

   • 连接管理模块
   • 文件接收处理模块
   • 协议解析模块
   • 日志记录模块

2. 客户端模块：

   • 连接建立模块
   • 文件发送模块
   • 进度显示模块
   • 错误处理模块

3.2 通信协议设计

我们设计一个简化的FTP协议，包含以下命令格式：

命令格式：COMMAND [参数]\n 响应格式：CODE 消息内容\n 支持的命令： 1. PUT filename size - 上传文件 2. GET filename - 下载文件 3. LIST - 列出文件 4. QUIT - 退出

4. 服务器端实现

4.1 服务器端主框架

#include<stdio.h>#include<stdlib.h>#include<string.h>#include<unistd.h>#include<arpa/inet.h>#include<sys/socket.h>#include<sys/types.h>#include<sys/stat.h>#include<fcntl.h>#include<errno.h>#include<time.h>#include<dirent.h>#include<pthread.h>#definePORT8888#defineBUFFER_SIZE1024#defineMAX_CLIENTS10#defineMAX_FILENAME256// 服务器配置结构体typedefstruct{intport;intmax_clients;charroot_dir[256];intverbose;}ServerConfig;// 客户端连接信息结构体typedefstruct{intclient_socket;structsockaddr_inclient_addr;pthread_tthread_id;time_tconnect_time;}ClientInfo;// 全局配置ServerConfig server_config={.port=PORT,.max_clients=MAX_CLIENTS,.root_dir="./server_files",.verbose=1};// 日志函数voidlog_message(intlevel,constchar*format,...){if(!server_config.verbose&&level==1)return;time_tnow=time(NULL);chartime_str[20];strftime(time_str,sizeof(time_str),"%Y-%m-%d %H:%M:%S",localtime(&now));va_list args;va_start(args,format);printf("[%s] ",time_str);vprintf(format,args);printf("\n");va_end(args);}// 创建服务器Socketintcreate_server_socket(intport){intserver_fd;structsockaddr_inserver_addr;// 创建Socketif((server_fd=socket(AF_INET,SOCK_STREAM,0))==-1){perror("Socket creation failed");return-1;}// 设置SO_REUSEADDR选项，避免地址占用intopt=1;if(setsockopt(server_fd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt))<0){perror("Setsockopt failed");close(server_fd);return-1;}// 配置服务器地址memset(&server_addr,0,sizeof(server_addr));server_addr.sin_family=AF_INET;server_addr.sin_addr.s_addr=INADDR_ANY;server_addr.sin_port=htons(port);// 绑定地址if(bind(server_fd,(structsockaddr*)&server_addr,sizeof(server_addr))<0){perror("Bind failed");close(server_fd);return-1;}// 开始监听if(listen(server_fd,server_config.max_clients)<0){perror("Listen failed");close(server_fd);return-1;}returnserver_fd;}

4.2 文件接收处理模块

// 文件接收状态枚举typedefenum{FILE_RECV_IDLE,FILE_RECV_HEADER,FILE_RECV_DATA,FILE_RECV_COMPLETE,FILE_RECV_ERROR}FileRecvState;// 文件传输上下文typedefstruct{charfilename[MAX_FILENAME];longfile_size;longreceived_bytes;intfile_fd;FileRecvState state;time_tstart_time;}FileTransferContext;// 初始化文件传输上下文voidinit_file_transfer_context(FileTransferContext*ctx){memset(ctx,0,sizeof(FileTransferContext));ctx->state=FILE_RECV_IDLE;ctx->file_fd=-1;}// 解析文件传输头信息intparse_file_header(constchar*header,FileTransferContext*ctx){// 格式：PUT filename filesizecharcommand[10];charfilename[MAX_FILENAME];longfilesize;if(sscanf(header,"%s %s %ld",command,filename,&filesize)!=3){return-1;}if(strcmp(command,"PUT")!=0){return-1;}// 安全检查：防止路径遍历攻击if(strstr(filename,"..")!=NULL||strchr(filename,'/')!=NULL){return-1;}strncpy(ctx->filename,filename,MAX_FILENAME-1);ctx->file_size=filesize;ctx->received_bytes=0;return0;}// 处理文件接收intreceive_file_data(intclient_fd,FileTransferContext*ctx){charbuffer[BUFFER_SIZE];ssize_tbytes_read;ssize_tbytes_written;ssize_ttotal_written=0;while(ctx->received_bytes<ctx->file_size){// 计算剩余字节数longremaining=ctx->file_size-ctx->received_bytes;ssize_tto_read=(remaining<BUFFER_SIZE)?remaining:BUFFER_SIZE;// 从Socket读取数据bytes_read=recv(client_fd,buffer,to_read,0);if(bytes_read<=0){if(bytes_read==0){log_message(1,"Client disconnected during file transfer");}else{perror("Error reading file data");}return-1;}// 写入文件bytes_written=write(ctx->file_fd,buffer,bytes_read);if(bytes_written!=bytes_read){log_message(0,"Error writing to file: wrote %ld of %ld bytes",bytes_written,bytes_read);return-1;}ctx->received_bytes+=bytes_written;total_written+=bytes_written;// 每接收1MB显示一次进度if(ctx->file_size>0&&(ctx->received_bytes%(1024*1024))<BUFFER_SIZE){intpercent=(int)((ctx->received_bytes*100)/ctx->file_size);log_message(1,"Receiving file: %s [%d%%] %ld/%ld bytes",ctx->filename,percent,ctx->received_bytes,ctx->file_size);}}log_message(0,"File received successfully: %s (%ld bytes)",ctx->filename,total_written);return0;}// 处理客户端上传文件请求inthandle_file_upload(intclient_fd,constchar*request){FileTransferContext ctx;init_file_transfer_context(&ctx);// 解析请求头if(parse_file_header(request,&ctx)!=0){send(client_fd,"ERROR Invalid file header format\n",33,0);return-1;}// 检查文件大小限制（例如100MB）if(ctx.file_size>100*1024*1024){charerror_msg[100];snprintf(error_msg,sizeof(error_msg),"ERROR File too large: %ld bytes (max 100MB)\n",ctx.file_size);send(client_fd,error_msg,strlen(error_msg),0);return-1;}// 准备文件路径charfilepath[MAX_FILENAME+100];snprintf(filepath,sizeof(filepath),"%s/%s",server_config.root_dir,ctx.filename);// 打开文件（如果存在则清空）intflags=O_WRONLY|O_CREAT;if(access(filepath,F_OK)==0){log_message(1,"File exists, truncating: %s",filepath);flags|=O_TRUNC;}else{log_message(1,"Creating new file: %s",filepath);}ctx.file_fd=open(filepath,flags,0644);if(ctx.file_fd<0){perror("Failed to open file");send(client_fd,"ERROR Cannot create file\n",25,0);return-1;}// 发送准备接收的响应send(client_fd,"READY Start sending file data\n",30,0);// 开始接收文件数据ctx.start_time=time(NULL);intresult=receive_file_data(client_fd,&ctx);// 计算传输统计time_tend_time=time(NULL);doubleelapsed=difftime(end_time,ctx.start_time);doublespeed=(elapsed>0)?(ctx.received_bytes/elapsed):0;// 关闭文件close(ctx.file_fd);if(result==0){// 发送成功响应charsuccess_msg[200];snprintf(success_msg,sizeof(success_msg),"SUCCESS File uploaded: %s (%ld bytes, %.1f seconds, %.2f KB/s)\n",ctx.filename,ctx.received_bytes,elapsed,speed/1024);send(client_fd,success_msg,strlen(success_msg),0);return0;}else{// 删除不完整的文件unlink(filepath);send(client_fd,"ERROR File transfer failed\n",27,0);return-1;}}

4.3 多线程客户端处理

// 客户端处理线程函数void*handle_client_thread(void*arg){ClientInfo*client_info=(ClientInfo*)arg;intclient_fd=client_info->client_socket;charclient_ip[INET_ADDRSTRLEN];// 获取客户端IP地址inet_ntop(AF_INET,&(client_info->client_addr.sin_addr),client_ip,INET_ADDRSTRLEN);log_message(0,"New client connected: %s:%d",client_ip,ntohs(client_info->client_addr.sin_port));charbuffer[BUFFER_SIZE];charresponse[BUFFER_SIZE];// 发送欢迎消息constchar*welcome_msg="Welcome to Simple FTP Server\n""Commands: PUT <filename> <size>, GET <filename>, LIST, QUIT\n";send(client_fd,welcome_msg,strlen(welcome_msg),0);// 处理客户端请求while(1){memset(buffer,0,BUFFER_SIZE);// 接收客户端命令ssize_tbytes_received=recv(client_fd,buffer,BUFFER_SIZE-1,0);if(bytes_received<=0){if(bytes_received==0){log_message(1,"Client disconnected: %s:%d",client_ip,ntohs(client_info->client_addr.sin_port));}else{perror("Error receiving from client");}break;}// 移除换行符buffer[strcspn(buffer,"\n")]=0;log_message(1,"Received command from %s: %s",client_ip,buffer);// 解析命令if(strncmp(buffer,"PUT ",4)==0){// 处理文件上传handle_file_upload(client_fd,buffer);}elseif(strncmp(buffer,"GET ",4)==0){// 处理文件下载handle_file_download(client_fd,buffer+4);}elseif(strcmp(buffer,"LIST")==0){// 处理文件列表请求handle_list_files(client_fd);}elseif(strcmp(buffer,"QUIT")==0){send(client_fd,"Goodbye!\n",9,0);break;}else{// 未知命令snprintf(response,sizeof(response),"ERROR Unknown command: %s\n",buffer);send(client_fd,response,strlen(response),0);}}// 清理资源close(client_fd);free(client_info);log_message(1,"Client thread exiting: %s",client_ip);pthread_exit(NULL);}// 文件下载处理函数inthandle_file_download(intclient_fd,constchar*filename){charfilepath[MAX_FILENAME+100];structstatfile_stat;// 安全检查if(strstr(filename,"..")!=NULL||strchr(filename,'/')!=NULL){send(client_fd,"ERROR Invalid filename\n",23,0);return-1;}snprintf(filepath,sizeof(filepath),"%s/%s",server_config.root_dir,filename);// 检查文件是否存在if(stat(filepath,&file_stat)<0){send(client_fd,"ERROR File not found\n",21,0);return-1;}// 检查是否为常规文件if(!S_ISREG(file_stat.st_mode)){send(client_fd,"ERROR Not a regular file\n",25,0);return-1;}// 发送文件信息charheader[100];snprintf(header,sizeof(header),"FILE %s %ld\n",filename,file_stat.st_size);send(client_fd,header,strlen(header),0);// 打开文件intfile_fd=open(filepath,O_RDONLY);if(file_fd<0){perror("Failed to open file for reading");send(client_fd,"ERROR Cannot open file\n",23,0);return-1;}// 发送文件内容charbuffer[BUFFER_SIZE];ssize_tbytes_read;longtotal_sent=0;while((bytes_read=read(file_fd,buffer,BUFFER_SIZE))>0){ssize_tbytes_sent=send(client_fd,buffer,bytes_read,0);if(bytes_sent<0){perror("Error sending file data");break;}total_sent+=bytes_sent;// 显示进度intpercent=(file_stat.st_size>0)?(int)((total_sent*100)/file_stat.st_size):0;if(percent%10==0){log_message(1,"Sending file: %s [%d%%]",filename,percent);}}close(file_fd);log_message(0,"File sent: %s (%ld bytes)",filename,total_sent);return0;}// 文件列表处理函数inthandle_list_files(intclient_fd){DIR*dir;structdirent*entry;structstatfile_stat;charresponse[BUFFER_SIZE*4];charline[256];time_tcurrent_time=time(NULL);snprintf(response,sizeof(response),"Files in server directory:\n");snprintf(response+strlen(response),sizeof(response)-strlen(response),"%-40s %10s %20s\n","Filename","Size","Modified");snprintf(response+strlen(response),sizeof(response)-strlen(response),"%-40s %10s %20s\n","--------","----","--------");dir=opendir(server_config.root_dir);if(dir==NULL){perror("Failed to open directory");send(client_fd,"ERROR Cannot list directory\n",27,0);return-1;}while((entry=readdir(dir))!=NULL){// 跳过隐藏文件和目录if(entry->d_name[0]=='.')continue;charfilepath[512];snprintf(filepath,sizeof(filepath),"%s/%s",server_config.root_dir,entry->d_name);if(stat(filepath,&file_stat)==0&&S_ISREG(file_stat.st_mode)){// 格式化文件大小charsize_str[20];if(file_stat.st_size<1024){snprintf(size_str,sizeof(size_str),"%ldB",file_stat.st_size);}elseif(file_stat.st_size<1024*1024){snprintf(size_str,sizeof(size_str),"%.1fKB",file_stat.st_size/1024.0);}else{snprintf(size_str,sizeof(size_str),"%.1fMB",file_stat.st_size/(1024.0*1024.0));}// 格式化修改时间chartime_str[20];structtm*timeinfo=localtime(&file_stat.st_mtime);strftime(time_str,sizeof(time_str),"%Y-%m-%d %H:%M:%S",timeinfo);snprintf(line,sizeof(line),"%-40s %10s %20s\n",entry->d_name,size_str,time_str);// 检查缓冲区是否足够if(strlen(response)+strlen(line)<sizeof(response)-100){strcat(response,line);}else{strcat(response,"... (truncated)\n");break;}}}closedir(dir);// 发送文件列表send(client_fd,response,strlen(response),0);return0;}

4.4 服务器主函数

// 服务器主函数intmain(intargc,char*argv[]){intserver_fd;structsockaddr_inclient_addr;socklen_tclient_len=sizeof(client_addr);// 解析命令行参数for(inti=1;i<argc;i++){if(strcmp(argv[i],"-p")==0&&i+1<argc){server_config.port=atoi(argv[++i]);}elseif(strcmp(argv[i],"-d")==0&&i+1<argc){strncpy(server_config.root_dir,argv[++i],sizeof(server_config.root_dir)-1);}elseif(strcmp(argv[i],"-v")==0){server_config.verbose=1;}elseif(strcmp(argv[i],"-q")==0){server_config.verbose=0;}}// 创建服务器目录（如果不存在）structstatst={0};if(stat(server_config.root_dir,&st)==-1){mkdir(server_config.root_dir,0755);log_message(0,"Created server directory: %s",server_config.root_dir);}// 创建服务器Socketserver_fd=create_server_socket(server_config.port);if(server_fd<0){log_message(0,"Failed to create server socket");return1;}log_message(0,"FTP Server started on port %d",server_config.port);log_message(0,"Server directory: %s",server_config.root_dir);log_message(0,"Maximum clients: %d",server_config.max_clients);log_message(0,"Waiting for connections...\n");// 主循环，接受客户端连接while(1){// 分配客户端信息结构ClientInfo*client_info=malloc(sizeof(ClientInfo));if(!client_info){perror("Failed to allocate client info");continue;}// 接受客户端连接client_info->client_socket=accept(server_fd,(structsockaddr*)&client_addr,&client_len);if(client_info->client_socket<0){perror("Accept failed");free(client_info);continue;}// 保存客户端信息memcpy(&client_info->client_addr,&client_addr,sizeof(client_addr));client_info->connect_time=time(NULL);// 创建线程处理客户端pthread_tthread_id;if(pthread_create(&thread_id,NULL,handle_client_thread,client_info)!=0){perror("Failed to create thread");close(client_info->client_socket);free(client_info);continue;}client_info->thread_id=thread_id;// 分离线程，让系统自动回收资源pthread_detach(thread_id);log_message(1,"Created thread for new client");}// 关闭服务器Socket（通常不会执行到这里）close(server_fd);return0;}

5. 客户端实现

5.1 客户端主框架

#include<stdio.h>#include<stdlib.h>#include<string.h>#include<unistd.h>#include<arpa/inet.h>#include<sys/socket.h>#include<sys/types.h>#include<sys/stat.h>#include<fcntl.h>#include<errno.h>#include<time.h>#include<ctype.h>#defineBUFFER_SIZE1024#defineMAX_FILENAME256// 客户端配置结构体typedefstruct{charserver_ip[16];intserver_port;intverbose;intbinary_mode;}ClientConfig;// 全局配置ClientConfig client_config={.server_ip="127.0.0.1",.server_port=8888,.verbose=1,.binary_mode=1};// 客户端状态枚举typedefenum{CLIENT_DISCONNECTED,CLIENT_CONNECTING,CLIENT_CONNECTED,CLIENT_TRANSFERRING,CLIENT_ERROR}ClientState;// 客户端上下文typedefstruct{intsockfd;ClientState state;structsockaddr_inserver_addr;charcurrent_dir[256];}ClientContext;// 初始化客户端上下文voidinit_client_context(ClientContext*ctx){memset(ctx,0,sizeof(ClientContext));ctx->sockfd=-1;ctx->state=CLIENT_DISCONNECTED;getcwd(ctx->current_dir,sizeof(ctx->current_dir));}// 连接到服务器intconnect_to_server(ClientContext*ctx,constchar*ip,intport){// 创建Socketctx->sockfd=socket(AF_INET,SOCK_STREAM,0);if(ctx->sockfd<0){perror("Socket creation failed");return-1;}// 配置服务器地址memset(&ctx->server_addr,0,sizeof(ctx->server_addr));ctx->server_addr.sin_family=AF_INET;ctx->server_addr.sin_port=htons(port);if(inet_pton(AF_INET,ip,&ctx->server_addr.sin_addr)<=0){perror("Invalid address");close(ctx->sockfd);ctx->sockfd=-1;return-1;}// 连接服务器printf("Connecting to %s:%d...\n",ip,port);if(connect(ctx->sockfd,(structsockaddr*)&ctx->server_addr,sizeof(ctx->server_addr))<0){perror("Connection failed");close(ctx->sockfd);ctx->sockfd=-1;return-1;}ctx->state=CLIENT_CONNECTED;printf("Connected to server successfully!\n");// 接收服务器欢迎消息charbuffer[BUFFER_SIZE];ssize_tbytes_received=recv(ctx->sockfd,buffer,BUFFER_SIZE-1,0);if(bytes_received>0){buffer[bytes_received]='\0';printf("%s",buffer);}return0;}// 发送命令并接收响应intsend_command(ClientContext*ctx,constchar*command,char*response,size_tresp_size){if(ctx->state!=CLIENT_CONNECTED){printf("Not connected to server\n");return-1;}// 发送命令（确保以换行符结尾）charcmd_with_newline[BUFFER_SIZE];snprintf(cmd_with_newline,sizeof(cmd_with_newline),"%s\n",command);if(send(ctx->sockfd,cmd_with_newline,strlen(cmd_with_newline),0)<0){perror("Failed to send command");return-1;}if(client_config.verbose){printf("Sent: %s",cmd_with_newline);}// 接收响应if(response&&resp_size>0){memset(response,0,resp_size);ssize_tbytes_received=recv(ctx->sockfd,response,resp_size-1,0);if(bytes_received>0){response[bytes_received]='\0';if(client_config.verbose){printf("Received: %s",response);}returnbytes_received;}elseif(bytes_received==0){printf("Server disconnected\n");ctx->state=CLIENT_DISCONNECTED;return-1;}else{perror("Failed to receive response");return-1;}}return0;}

5.2 文件上传功能

// 计算文件大小longget_file_size(constchar*filename){structstatfile_stat;if(stat(filename,&file_stat)==0&&S_ISREG(file_stat.st_mode)){returnfile_stat.st_size;}return-1;}// 上传文件到服务器intupload_file(ClientContext*ctx,constchar*filename){// 检查文件是否存在longfile_size=get_file_size(filename);if(file_size<0){printf("File not found or not a regular file: %s\n",filename);return-1;}printf("Uploading file: %s (size: %ld bytes)\n",filename,file_size);// 发送PUT命令charcommand[BUFFER_SIZE];charresponse[BUFFER_SIZE];snprintf(command,sizeof(command),"PUT %s %ld",filename,file_size);if(send_command(ctx,command,response,sizeof(response))<0){return-1;}// 检查服务器响应if(strncmp(response,"READY",5)!=0){printf("Server not ready: %s",response);return-1;}// 打开本地文件intfile_fd=open(filename,O_RDONLY);if(file_fd<0){perror("Failed to open file");return-1;}// 读取并发送文件内容charbuffer[BUFFER_SIZE];ssize_tbytes_read;longtotal_sent=0;time_tstart_time=time(NULL);ctx->state=CLIENT_TRANSFERRING;while((bytes_read=read(file_fd,buffer,BUFFER_SIZE))>0){ssize_tbytes_sent=send(ctx->sockfd,buffer,bytes_read,0);if(bytes_sent<0){perror("Error sending file data");close(file_fd);ctx->state=CLIENT_CONNECTED;return-1;}total_sent+=bytes_sent;// 显示进度if(file_size>0){intpercent=(int)((total_sent*100)/file_size);if(percent%5==0){printf("\rProgress: [");intbars=percent/2;for(inti=0;i<50;i++){if(i<bars)printf("=");elseprintf(" ");}printf("] %d%% %ld/%ld bytes",percent,total_sent,file_size);fflush(stdout);}}}close(file_fd);// 显示传输完成printf("\n");// 接收服务器确认memset(response,0,sizeof(response));ssize_tbytes_received=recv(ctx->sockfd,response,sizeof(response)-1,0);if(bytes_received>0){response[bytes_received]='\0';printf("%s",response);}// 计算传输统计time_tend_time=time(NULL);doubleelapsed=difftime(end_time,start_time);doublespeed=(elapsed>0)?(total_sent/elapsed):0;printf("Upload complete: %.1f seconds, %.2f KB/s\n",elapsed,speed/1024);ctx->state=CLIENT_CONNECTED;return0;}// 下载文件从服务器intdownload_file(ClientContext*ctx,constchar*filename){charcommand[BUFFER_SIZE];charresponse[BUFFER_SIZE];// 发送GET命令snprintf(command,sizeof(command),"GET %s",filename);if(send_command(ctx,command,response,sizeof(response))<0){return-1;}// 检查响应if(strncmp(response,"FILE",4)!=0){printf("Server error: %s",response);return-1;}// 解析文件信息charresponse_filename[MAX_FILENAME];longfile_size;if(sscanf(response,"FILE %s %ld",response_filename,&file_size)!=2){printf("Invalid server response format\n");return-1;}printf("Downloading file: %s (size: %ld bytes)\n",response_filename,file_size);// 创建本地文件（如果存在则清空）intfile_fd=open(response_filename,O_WRONLY|O_CREAT|O_TRUNC,0644);if(file_fd<0){perror("Failed to create local file");return-1;}// 接收文件数据charbuffer[BUFFER_SIZE];ssize_tbytes_received;longtotal_received=0;time_tstart_time=time(NULL);ctx->state=CLIENT_TRANSFERRING;while(total_received<file_size){longremaining=file_size-total_received;ssize_tto_receive=(remaining<BUFFER_SIZE)?remaining:BUFFER_SIZE;bytes_received=recv(ctx->sockfd,buffer,to_receive,0);if(bytes_received<=0){if(bytes_received==0){printf("\nServer disconnected during transfer\n");}else{perror("Error receiving file data");}close(file_fd);unlink(response_filename);// 删除不完整的文件ctx->state=CLIENT_CONNECTED;return-1;}// 写入本地文件ssize_tbytes_written=write(file_fd,buffer,bytes_received);if(bytes_written!=bytes_received){printf("\nError writing to local file\n");close(file_fd);unlink(response_filename);ctx->state=CLIENT_CONNECTED;return-1;}total_received+=bytes_received;// 显示进度if(file_size>0){intpercent=(int)((total_received*100)/file_size);if(percent%5==0){printf("\rProgress: [");intbars=percent/2;for(inti=0;i<50;i++){if(i<bars)printf("=");elseprintf(" ");}printf("] %d%% %ld/%ld bytes",percent,total_received,file_size);fflush(stdout);}}}close(file_fd);// 显示传输完成printf("\n");// 计算传输统计time_tend_time=time(NULL);doubleelapsed=difftime(end_time,start_time);doublespeed=(elapsed>0)?(total_received/elapsed):0;printf("Download complete: %s (%.1f seconds, %.2f KB/s)\n",response_filename,elapsed,speed/1024);ctx->state=CLIENT_CONNECTED;return0;}// 列出服务器文件intlist_server_files(ClientContext*ctx){charresponse[BUFFER_SIZE*4];if(send_command(ctx,"LIST",response,sizeof(response))<0){return-1;}printf("%s",response);return0;}

5.3 客户端交互界面

// 显示帮助信息voidshow_help(){printf("\nAvailable commands:\n");printf(" connect <ip> <port> - Connect to FTP server\n");printf(" put <filename> - Upload file to server\n");printf(" get <filename> - Download file from server\n");printf(" list - List files on server\n");printf(" pwd - Show current directory\n");printf(" cd <directory> - Change local directory\n");printf(" ls - List local files\n");printf(" mode binary/ascii - Set transfer mode\n");printf(" verbose on/off - Toggle verbose mode\n");printf(" help - Show this help\n");printf(" quit - Exit client\n");printf("\n");}// 列出本地文件voidlist_local_files(){DIR*dir;structdirent*entry;structstatfile_stat;printf("Local files in current directory:\n");printf("%-40s %10s %20s\n","Filename","Size","Modified");printf("%-40s %10s %20s\n","--------","----","--------");dir=opendir(".");if(dir==NULL){perror("Failed to open directory");return;}while((entry=readdir(dir))!=NULL){// 跳过隐藏文件if(entry->d_name[0]=='.')continue;if(stat(entry->d_name,&file_stat)==0){// 格式化文件大小charsize_str[20];if(S_ISDIR(file_stat.st_mode)){strcpy(size_str,"<DIR>");}elseif(file_stat.st_size<1024){snprintf(size_str,sizeof(size_str),"%ldB",file_stat.st_size);}elseif(file_stat.st_size<1024*1024){snprintf(size_str,sizeof(size_str),"%.1fKB",file_stat.st_size/1024.0);}else{snprintf(size_str,sizeof(size_str),"%.1fMB",file_stat.st_size/(1024.0*1024.0));}// 格式化修改时间chartime_str[20];structtm*timeinfo=localtime(&file_stat.st_mtime);strftime(time_str,sizeof(time_str),"%Y-%m-%d %H:%M:%S",timeinfo);printf("%-40s %10s %20s\n",entry->d_name,size_str,time_str);}}closedir(dir);}// 改变本地目录intchange_local_directory(constchar*path){if(chdir(path)==0){charcwd[256];getcwd(cwd,sizeof(cwd));printf("Current directory: %s\n",cwd);return0;}else{perror("Failed to change directory");return-1;}}// 客户端主循环voidclient_main_loop(ClientContext*ctx){charinput[BUFFER_SIZE];charcommand[50];chararg1[100];chararg2[100];show_help();while(1){printf("\nftp> ");fflush(stdout);// 读取用户输入if(fgets(input,sizeof(input),stdin)==NULL){break;}// 移除换行符input[strcspn(input,"\n")]=0;// 解析命令intargc=sscanf(input,"%s %s %s",command,arg1,arg2);if(argc==0){continue;}// 转换为小写以便比较for(inti=0;command[i];i++){command[i]=tolower(command[i]);}// 处理命令if(strcmp(command,"connect")==0){if(argc>=3){intport=atoi(arg2);connect_to_server(ctx,arg1,port);}else{printf("Usage: connect <ip> <port>\n");}}elseif(strcmp(command,"put")==0){if(argc>=2){upload_file(ctx,arg1);}else{printf("Usage: put <filename>\n");}}elseif(strcmp(command,"get")==0){if(argc>=2){download_file(ctx,arg1);}else{printf("Usage: get <filename>\n");}}elseif(strcmp(command,"list")==0){list_server_files(ctx);}elseif(strcmp(command,"ls")==0){list_local_files();}elseif(strcmp(command,"pwd")==0){charcwd[256];getcwd(cwd,sizeof(cwd));printf("Current directory: %s\n",cwd);}elseif(strcmp(command,"cd")==0){if(argc>=2){change_local_directory(arg1);}else{printf("Usage: cd <directory>\n");}}elseif(strcmp(command,"mode")==0){if(argc>=2){if(strcasecmp(arg1,"binary")==0){client_config.binary_mode=1;printf("Transfer mode set to BINARY\n");}elseif(strcasecmp(arg1,"ascii")==0){client_config.binary_mode=0;printf("Transfer mode set to ASCII\n");}else{printf("Invalid mode. Use 'binary' or 'ascii'\n");}}else{printf("Current mode: %s\n",client_config.binary_mode?"BINARY":"ASCII");}}elseif(strcmp(command,"verbose")==0){if(argc>=2){if(strcasecmp(arg1,"on")==0){client_config.verbose=1;printf("Verbose mode ON\n");}elseif(strcasecmp(arg1,"off")==0){client_config.verbose=0;printf("Verbose mode OFF\n");}else{printf("Usage: verbose on|off\n");}}else{printf("Verbose mode is %s\n",client_config.verbose?"ON":"OFF");}}elseif(strcmp(command,"help")==0){show_help();}elseif(strcmp(command,"quit")==0||strcmp(command,"exit")==0){if(ctx->state==CLIENT_CONNECTED){send_command(ctx,"QUIT",NULL,0);close(ctx->sockfd);}printf("Goodbye!\n");break;}else{printf("Unknown command: %s\n",command);printf("Type 'help' for available commands\n");}}}

5.4 客户端主函数

// 客户端主函数intmain(intargc,char*argv[]){ClientContext ctx;// 初始化客户端init_client_context(&ctx);// 解析命令行参数for(inti=1;i<argc;i++){if(strcmp(argv[i],"-h")==0&&i+1<argc){strncpy(client_config.server_ip,argv[++i],sizeof(client_config.server_ip)-1);}elseif(strcmp(argv[i],"-p")==0&&i+1<argc){client_config.server_port=atoi(argv[++i]);}elseif(strcmp(argv[i],"-v")==0){client_config.verbose=1;}elseif(strcmp(argv[i],"-q")==0){client_config.verbose=0;}elseif(strcmp(argv[i],"-connect")==0&&i+2<argc){strncpy(client_config.server_ip,argv[++i],sizeof(client_config.server_ip)-1);client_config.server_port=atoi(argv[++i]);}}printf("Simple FTP Client\n");printf("================\n");// 如果有指定连接参数，则自动连接if(argc>1){for(inti=1;i<argc;i++){if(strcmp(argv[i],"-connect")==0&&i+2<argc){if(connect_to_server(&ctx,client_config.server_ip,client_config.server_port)==0){break;}}}}// 启动客户端交互client_main_loop(&ctx);// 清理资源if(ctx.sockfd>=0){close(ctx.sockfd);}return0;}

6. 编译与测试

6.1 编译脚本

# Makefile for Simple FTP System CC = gcc CFLAGS = -Wall -Wextra -O2 -pthread SERVER_SRC = ftp_server.c CLIENT_SRC = ftp_client.c SERVER_BIN = ftp_server CLIENT_BIN = ftp_client all: $(SERVER_BIN) $(CLIENT_BIN) $(SERVER_BIN): $(SERVER_SRC) $(CC) $(CFLAGS) -o $(SERVER_BIN) $(SERVER_SRC) $(CLIENT_BIN): $(CLIENT_SRC) $(CC) $(CFLAGS) -o $(CLIENT_BIN) $(CLIENT_SRC) clean: rm -f $(SERVER_BIN) $(CLIENT_BIN) *.o run_server: $(SERVER_BIN) ./$(SERVER_BIN) -v run_client: $(CLIENT_BIN) ./$(CLIENT_BIN) test: all @echo "Starting server in background..." @./$(SERVER_BIN) -q & @sleep 2 @echo "Testing client connection..." @./$(CLIENT_BIN) -connect 127.0.0.1 8888 -q @pkill ftp_server .PHONY: all clean run_server run_client test

6.2 测试脚本

#!/bin/bash# test_ftp.sh - FTP系统测试脚本echo"=== FTP系统测试脚本 ==="echo"1. 编译项目..."makecleanmakeecho-e"\n2. 启动服务器..."./ftp_server -p8888-d ./test_server_files -v&SERVER_PID=$!sleep2# 等待服务器启动echo-e"\n3. 测试客户端基本功能..."echo"3.1 连接服务器"./ftp_client -connect127.0.0.18888-q<<EOF ls put test_file.txt list get test_file.txt quit EOFecho-e"\n3.2 测试大文件传输..."# 创建测试大文件ddif=/dev/urandomof=large_file.binbs=1Mcount=102>/dev/null ./ftp_client -connect127.0.0.18888-q<<EOF put large_file.bin list get large_file.bin quit EOFecho-e"\n3.3 测试错误处理..."./ftp_client -connect127.0.0.18888-q<<EOF get non_existent_file.txt put /etc/passwd # 应该被拒绝 quit EOFecho-e"\n4. 清理测试文件..."rm-f test_file.txt large_file.bin downloaded_*.binrm-rf ./test_server_filesecho-e"\n5. 停止服务器..."kill$SERVER_PIDwait$SERVER_PID2>/dev/nullecho-e"\n=== 测试完成 ==="

6.3 性能测试

// performance_test.c - 性能测试程序#include<stdio.h>#include<stdlib.h>#include<time.h>#include<sys/time.h>#include<unistd.h>#defineTEST_FILE_SIZE(10*1024*1024)// 10MB// 生成测试文件voidgenerate_test_file(constchar*filename,size_tsize){FILE*file=fopen(filename,"wb");if(!file){perror("Failed to create test file");exit(1);}unsignedchar*buffer=malloc(1024*1024);// 1MB缓冲区if(!buffer){perror("Memory allocation failed");fclose(file);exit(1);}// 用伪随机数据填充缓冲区srand(time(NULL));for(size_ti=0;i<1024*1024;i++){buffer[i]=rand()%256;}// 写入文件size_tremaining=size;while(remaining>0){size_tto_write=(remaining>1024*1024)?1024*1024:remaining;fwrite(buffer,1,to_write,file);remaining-=to_write;}free(buffer);fclose(file);printf("Generated test file: %s (%ld bytes)\n",filename,size);}// 运行性能测试voidrun_performance_test(){structtimevalstart,end;doubleupload_time,download_time;constchar*test_file="performance_test.bin";// 生成测试文件generate_test_file(test_file,TEST_FILE_SIZE);printf("\n=== 性能测试开始 ===\n");// 上传测试printf("\n1. 上传测试...\n");gettimeofday(&start,NULL);// 这里应该调用实际上传函数system("./ftp_client -connect 127.0.0.1 8888 -q << 'EOF'\n""put performance_test.bin\n""quit\n""EOF");gettimeofday(&end,NULL);upload_time=(end.tv_sec-start.tv_sec)+(end.tv_usec-start.tv_usec)/1000000.0;// 下载测试printf("\n2. 下载测试...\n");gettimeofday(&start,NULL);// 这里应该调用实际下载函数system("./ftp_client -connect 127.0.0.1 8888 -q << 'EOF'\n""get performance_test.bin\n""quit\n""EOF");gettimeofday(&end,NULL);download_time=(end.tv_sec-start.tv_sec)+(end.tv_usec-start.tv_usec)/1000000.0;// 输出结果printf("\n=== 性能测试结果 ===\n");printf("文件大小: %.2f MB\n",TEST_FILE_SIZE/(1024.0*1024.0));printf("上传时间: %.2f 秒\n",upload_time);printf("上传速度: %.2f MB/s\n",(TEST_FILE_SIZE/(1024.0*1024.0))/upload_time);printf("下载时间: %.2f 秒\n",download_time);printf("下载速度: %.2f MB/s\n",(TEST_FILE_SIZE/(1024.0*1024.0))/download_time);// 清理remove(test_file);remove("downloaded_performance_test.bin");}intmain(){run_performance_test();return0;}

7. 高级功能扩展

7.1 断点续传功能

// 断点续传实现typedefstruct{charfilename[MAX_FILENAME];longfile_size;longtransferred_bytes;intis_resume;chartemp_filename[MAX_FILENAME+10];}ResumeContext;// 检查文件传输状态intcheck_file_transfer_status(constchar*filename,ResumeContext*ctx){chartemp_file[256];snprintf(temp_file,sizeof(temp_file),"%s.part",filename);structstatst;if(stat(temp_file,&st)==0){// 存在部分传输的文件ctx->is_resume=1;ctx->transferred_bytes=st.st_size;strcpy(ctx->temp_filename,temp_file);// 获取原始文件大小（需要从服务器获取）// 这里简化为从文件名中提取return1;}return0;}// 支持断点续传的文件上传intupload_file_with_resume(ClientContext*ctx,constchar*filename){ResumeContext resume_ctx;memset(&resume_ctx,0,sizeof(resume_ctx));strcpy(resume_ctx.filename,filename);// 检查是否有未完成的传输if(check_file_transfer_status(filename,&resume_ctx)){printf("发现未完成的传输，已传输 %ld 字节\n",resume_ctx.transferred_bytes);printf("是否继续? (y/n): ");charresponse[10];fgets(response,sizeof(response),stdin);if(response[0]!='y'&&response[0]!='Y'){// 重新开始unlink(resume_ctx.temp_filename);resume_ctx.is_resume=0;resume_ctx.transferred_bytes=0;}}// 获取文件总大小longfile_size=get_file_size(filename);if(file_size<=0){printf("无法获取文件大小\n");return-1;}// 发送断点续传命令charcommand[BUFFER_SIZE];if(resume_ctx.is_resume){snprintf(command,sizeof(command),"RESUME %s %ld %ld",filename,file_size,resume_ctx.transferred_bytes);}else{snprintf(command,sizeof(command),"PUT %s %ld",filename,file_size);}// 继续传输...return0;}

7.2 加密传输功能

// 简单异或加密（仅示例，实际应使用更安全的算法）voidsimple_encrypt(char*data,size_tlen,constchar*key){size_tkey_len=strlen(key);for(size_ti=0;i<len;i++){data[i]^=key[i%key_len];}}// 加密发送ssize_tsend_encrypted(intsockfd,constvoid*buf,size_tlen,intflags,constchar*key){char*encrypted_buf=malloc(len);if(!encrypted_buf)return-1;memcpy(encrypted_buf,buf,len);simple_encrypt(encrypted_buf,len,key);ssize_tresult=send(sockfd,encrypted_buf,len,flags);free(encrypted_buf);returnresult;}// 解密接收ssize_trecv_decrypted(intsockfd,void*buf,size_tlen,intflags,constchar*key){ssize_tresult=recv(sockfd,buf,len,flags);if(result>0){simple_encrypt(buf,result,key);// 异或加密/解密是相同的操作}returnresult;}

7.3 多线程并行传输

// 并行传输上下文typedefstruct{intthread_id;intsockfd;charfilename[MAX_FILENAME];longstart_offset;longend_offset;longtransferred;pthread_mutex_t*mutex;}ParallelTransferContext;// 并行传输线程函数void*parallel_transfer_thread(void*arg){ParallelTransferContext*ctx=(ParallelTransferContext*)arg;intfile_fd=open(ctx->filename,O_RDONLY);if(file_fd<0){perror("Failed to open file");returnNULL;}// 定位到指定偏移lseek(file_fd,ctx->start_offset,SEEK_SET);charbuffer[BUFFER_SIZE];longremaining=ctx->end_offset-ctx->start_offset;longcurrent_pos=ctx->start_offset;while(remaining>0){size_tto_read=(remaining<BUFFER_SIZE)?remaining:BUFFER_SIZE;ssize_tbytes_read=read(file_fd,buffer,to_read);if(bytes_read<=0)break;// 发送数据ssize_tbytes_sent=send(ctx->sockfd,buffer,bytes_read,0);if(bytes_sent<=0)break;// 更新统计pthread_mutex_lock(ctx->mutex);ctx->transferred+=bytes_sent;pthread_mutex_unlock(ctx->mutex);remaining-=bytes_sent;current_pos+=bytes_sent;}close(file_fd);returnNULL;}// 启动并行传输intstart_parallel_transfer(constchar*filename,intnum_threads){// 创建多个连接// 分割文件// 启动多个线程// 合并结果return0;}

8. 错误处理与优化

8.1 完善的错误处理机制

// 错误码定义typedefenum{FTP_SUCCESS=0,FTP_ERROR_SOCKET,FTP_ERROR_CONNECT,FTP_ERROR_BIND,FTP_ERROR_LISTEN,FTP_ERROR_ACCEPT,FTP_ERROR_SEND,FTP_ERROR_RECV,FTP_ERROR_FILE_OPEN,FTP_ERROR_FILE_READ,FTP_ERROR_FILE_WRITE,FTP_ERROR_MEMORY,FTP_ERROR_TIMEOUT,FTP_ERROR_PROTOCOL,FTP_ERROR_AUTH,FTP_ERROR_PERMISSION}FTPErrorCode;// 错误处理函数constchar*ftp_strerror(FTPErrorCode error){staticconstchar*error_strings[]={"Success","Socket creation failed","Connection failed","Bind failed","Listen failed","Accept connection failed","Send data failed","Receive data failed","Cannot open file","Cannot read file","Cannot write file","Memory allocation failed","Operation timeout","Protocol error","Authentication failed","Permission denied"};if(error<0||error>FTP_ERROR_PERMISSION){return"Unknown error";}returnerror_strings[error];}// 带错误处理的Socket操作intsafe_send(intsockfd,constvoid*buf,size_tlen,intflags){size_ttotal_sent=0;constchar*ptr=(constchar*)buf;while(total_sent<len){ssize_tsent=send(sockfd,ptr+total_sent,len-total_sent,flags);if(sent<0){if(errno==EINTR)continue;// 被信号中断，重试if(errno==EAGAIN||errno==EWOULDBLOCK){// 非阻塞模式下，等待可写fd_set write_fds;structtimevaltimeout={5,0};// 5秒超时FD_ZERO(&write_fds);FD_SET(sockfd,&write_fds);if(select(sockfd+1,NULL,&write_fds,NULL,&timeout)<=0){returnFTP_ERROR_TIMEOUT;}continue;}returnFTP_ERROR_SEND;}total_sent+=sent;}returnFTP_SUCCESS;}

8.2 连接池管理

// 连接池结构typedefstructConnectionPool{int*connections;intpool_size;intused_count;pthread_mutex_tlock;pthread_cond_tavailable;}ConnectionPool;// 初始化连接池ConnectionPool*init_connection_pool(constchar*host,intport,intsize){ConnectionPool*pool=malloc(sizeof(ConnectionPool));if(!pool)returnNULL;pool->connections=malloc(sizeof(int)*size);if(!pool->connections){free(pool);returnNULL;}// 创建连接for(inti=0;i<size;i++){pool->connections[i]=create_connection(host,port);if(pool->connections[i]<0){// 连接失败，清理已创建的连接for(intj=0;j<i;j++){close(pool->connections[j]);}free(pool->connections);free(pool);returnNULL;}}pool->pool_size=size;pool->used_count=0;pthread_mutex_init(&pool->lock,NULL);pthread_cond_init(&pool->available,NULL);returnpool;}// 从连接池获取连接intget_connection(ConnectionPool*pool){pthread_mutex_lock(&pool->lock);while(pool->used_count>=pool->pool_size){pthread_cond_wait(&pool->available,&pool->lock);}for(inti=0;i<pool->pool_size;i++){if(pool->connections[i]>=0){intconn=pool->connections[i];pool->connections[i]=-1;// 标记为使用中pool->used_count++;pthread_mutex_unlock(&pool->lock);returnconn;}}pthread_mutex_unlock(&pool->lock);return-1;}// 归还连接到连接池voidrelease_connection(ConnectionPool*pool,intconn){pthread_mutex_lock(&pool->lock);for(inti=0;i<pool->pool_size;i++){if(pool->connections[i]==-1){pool->connections[i]=conn;pool->used_count--;pthread_cond_signal(&pool->available);break;}}pthread_mutex_unlock(&pool->lock);}

9. 安全考虑

9.1 防止目录遍历攻击

// 安全的路径检查intis_safe_path(constchar*path){// 检查路径遍历if(strstr(path,"..")!=NULL){return0;}// 检查绝对路径if(path[0]=='/'){return0;}// 检查危险字符constchar*dangerous_chars="|;&$><`\\\"'";for(inti=0;path[i];i++){if(strchr(dangerous_chars,path[i])!=NULL){return0;}}return1;}// 安全的文件打开intsafe_open(constchar*base_dir,constchar*filename,intflags){charsafe_path[512];// 验证文件名if(!is_safe_path(filename)){errno=EPERM;return-1;}// 构造完整路径if(snprintf(safe_path,sizeof(safe_path),"%s/%s",base_dir,filename)>=sizeof(safe_path)){errno=ENAMETOOLONG;return-1;}// 规范化路径charresolved_path[512];if(realpath(safe_path,resolved_path)==NULL){return-1;}// 确保路径在基础目录内size_tbase_len=strlen(base_dir);if(strncmp(resolved_path,base_dir,base_len)!=0){errno=EPERM;return-1;}returnopen(resolved_path,flags,0644);}

9.2 连接限制与超时控制

// 连接限制管理器typedefstruct{intmax_connections_per_ip;intconnection_timeout;// 秒pthread_mutex_tlock;}ConnectionManager;// 检查连接频率intcheck_connection_rate(structsockaddr_in*client_addr){staticstruct{structsockaddr_inaddr;time_tlast_connect;intcount;}connection_log[1000];staticintlog_count=0;staticpthread_mutex_tlog_mutex=PTHREAD_MUTEX_INITIALIZER;time_tnow=time(NULL);pthread_mutex_lock(&log_mutex);// 查找现有记录for(inti=0;i<log_count;i++){if(connection_log[i].addr.sin_addr.s_addr==client_addr->sin_addr.s_addr){// 检查连接频率if(now-connection_log[i].last_connect<1){// 1秒内connection_log[i].count++;if(connection_log[i].count>5){// 每秒最多5次连接pthread_mutex_unlock(&log_mutex);return0;// 拒绝连接}}else{connection_log[i].count=1;}connection_log[i].last_connect=now;pthread_mutex_unlock(&log_mutex);return1;// 允许连接}}// 添加新记录if(log_count<1000){connection_log[log_count].addr=*client_addr;connection_log[log_count].last_connect=now;connection_log[log_count].count=1;log_count++;}pthread_mutex_unlock(&log_mutex);return1;}// 设置Socket超时intset_socket_timeout(intsockfd,inttimeout_seconds){structtimevaltimeout;timeout.tv_sec=timeout_seconds;timeout.tv_usec=0;if(setsockopt(sockfd,SOL_SOCKET,SO_RCVTIMEO,&timeout,sizeof(timeout))<0){return-1;}if(setsockopt(sockfd,SOL_SOCKET,SO_SNDTIMEO,&timeout,sizeof(timeout))<0){return-1;}return0;}

10. 性能优化

10.1 缓冲区优化

// 动态缓冲区管理typedefstruct{char*data;size_tsize;size_tcapacity;size_tread_pos;size_twrite_pos;}DynamicBuffer;// 初始化动态缓冲区DynamicBuffer*buffer_create(size_tinitial_capacity){DynamicBuffer*buf=malloc(sizeof(DynamicBuffer));if(!buf)returnNULL;buf->data=malloc(initial_capacity);if(!buf->data){free(buf);returnNULL;}buf->size=0;buf->capacity=initial_capacity;buf->read_pos=0;buf->write_pos=0;returnbuf;}// 扩展缓冲区intbuffer_expand(DynamicBuffer*buf,size_tmin_capacity){size_tnew_capacity=buf->capacity*2;if(new_capacity<min_capacity){new_capacity=min_capacity;}char*new_data=realloc(buf->data,new_capacity);if(!new_data)return-1;buf->data=new_data;buf->capacity=new_capacity;return0;}// 写入缓冲区ssize_tbuffer_write(DynamicBuffer*buf,constvoid*data,size_tlen){if(buf->write_pos+len>buf->capacity){if(buffer_expand(buf,buf->write_pos+len)<0){return-1;}}memcpy(buf->data+buf->write_pos,data,len);buf->write_pos+=len;buf->size+=len;returnlen;}// 从Socket读取到缓冲区ssize_tbuffer_read_from_socket(DynamicBuffer*buf,intsockfd){chartemp[4096];ssize_tbytes_read;// 确保有足够空间if(buf->capacity-buf->write_pos<4096){if(buffer_expand(buf,buf->capacity+4096)<0){return-1;}}bytes_read=recv(sockfd,temp,sizeof(temp),0);if(bytes_read>0){buffer_write(buf,temp,bytes_read);}returnbytes_read;}

10.2 零拷贝技术优化

// 使用sendfile系统调用（Linux特有）#ifdef__linux__intsend_file_zerocopy(intsockfd,intfile_fd,off_toffset,size_tcount){off_tfile_offset=offset;size_tremaining=count;while(remaining>0){ssize_tsent=sendfile(sockfd,file_fd,&file_offset,remaining);if(sent<=0){if(errno==EINTR)continue;if(errno==EAGAIN){// 等待Socket可写fd_set write_fds;structtimevaltimeout={1,0};FD_ZERO(&write_fds);FD_SET(sockfd,&write_fds);if(select(sockfd+1,NULL,&write_fds,NULL,&timeout)<=0){return-1;}continue;}return-1;}remaining-=sent;}return0;}#endif// 使用splice系统调用（Linux特有）#ifdef__linux__inttransfer_file_pipe(intsockfd,intfile_fd,size_tcount){intpipefd[2];if(pipe(pipefd)<0){return-1;}size_tremaining=count;while(remaining>0){// 从文件读取到管道ssize_tspliced=splice(file_fd,NULL,pipefd[1],NULL,(remaining>65536)?65536:remaining,SPLICE_F_MOVE);if(spliced<=0)break;// 从管道写入到Socketssize_tsent=splice(pipefd[0],NULL,sockfd,NULL,spliced,SPLICE_F_MOVE);if(sent!=spliced)break;remaining-=sent;}close(pipefd[0]);close(pipefd[1]);return(remaining==0)?0:-1;}#endif

11. 测试与验证

11.1 单元测试

// test_ftp.c - 单元测试#include<assert.h>#include<stdio.h>#include<string.h>// 测试路径安全检查voidtest_path_security(){printf("测试路径安全检查...\n");assert(is_safe_path("test.txt")==1);assert(is_safe_path("../test.txt")==0);assert(is_safe_path("/etc/passwd")==0);assert(is_safe_path("test|bad.txt")==0);assert(is_safe_path("normal_file.dat")==1);printf("路径安全检查测试通过！\n");}// 测试协议解析voidtest_protocol_parsing(){printf("测试协议解析...\n");charheader[]="PUT test.txt 1024";FileTransferContext ctx;assert(parse_file_header(header,&ctx)==0);assert(strcmp(ctx.filename,"test.txt")==0);assert(ctx.file_size==1024);printf("协议解析测试通过！\n");}// 测试缓冲区管理voidtest_buffer_management(){printf("测试缓冲区管理...\n");DynamicBuffer*buf=buffer_create(100);assert(buf!=NULL);assert(buf->capacity>=100);constchar*test_data="Hello, World!";ssize_twritten=buffer_write(buf,test_data,strlen(test_data));assert(written==strlen(test_data));assert(buf->size==strlen(test_data));buffer_free(buf);printf("缓冲区管理测试通过！\n");}intmain(){printf("开始FTP系统单元测试\n");printf("==================\n");test_path_security();test_protocol_parsing();test_buffer_management();printf("\n所有单元测试通过！\n");return0;}

11.2 集成测试

#!/usr/bin/env python3# integration_test.py - 集成测试脚本importsubprocessimporttimeimportosimportsignalimportsysdefstart_server(port=8888):"""启动FTP服务器"""server_cmd=["./ftp_server","-p",str(port),"-d","./test_dir","-q"]server_proc=subprocess.Popen(server_cmd,stdout=subprocess.PIPE,stderr=subprocess.PIPE)time.sleep(2)# 等待服务器启动returnserver_procdefrun_client_command(command):"""运行客户端命令"""client_cmd=["./ftp_client","-connect","127.0.0.1","8888","-q"]proc=subprocess.Popen(client_cmd,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)stdout,stderr=proc.communicate(input=command)returnproc.returncode,stdout,stderrdefcreate_test_file(filename,size_kb):"""创建测试文件"""withopen(filename,'wb')asf:f.write(os.urandom(size_kb*1024))defmain():print("FTP系统集成测试")print("==============")# 创建测试目录os.makedirs("./test_dir",exist_ok=True)# 启动服务器print("1. 启动服务器...")server=start_server()try:# 测试1: 基本连接print("\n2. 测试基本连接...")retcode,output,error=run_client_command("list\nquit\n")assertretcode==0print("基本连接测试通过")# 测试2: 文件上传print("\n3. 测试文件上传...")create_test_file("upload_test.bin",1024)# 1MB文件retcode,output,error=run_client_command("put upload_test.bin\nquit\n")assertretcode==0print("文件上传测试通过")# 测试3: 文件下载print("\n4. 测试文件下载...")retcode,output,error=run_client_command("get upload_test.bin\nquit\n")assertretcode==0assertos.path.exists("downloaded_upload_test.bin")print("文件下载测试通过")# 测试4: 大文件传输print("\n5. 测试大文件传输...")create_test_file("large_file.bin",10240)# 10MB文件retcode,output,error=run_client_command("put large_file.bin\nget large_file.bin\nquit\n")assertretcode==0print("大文件传输测试通过")# 测试5: 错误处理print("\n6. 测试错误处理...")retcode,output,error=run_client_command("get non_existent_file.txt\nquit\n")assert"ERROR"inoutputor"error"inoutput.lower()print("错误处理测试通过")print("\n所有集成测试通过！")finally:# 清理print("\n7. 清理测试文件...")server.send_signal(signal.SIGTERM)server.wait()files_to_remove=["upload_test.bin","downloaded_upload_test.bin","large_file.bin","downloaded_large_file.bin"]forfilenameinfiles_to_remove:ifos.path.exists(filename):os.remove(filename)ifos.path.exists("./test_dir"):forfilenameinos.listdir("./test_dir"):os.remove(os.path.join("./test_dir",filename))os.rmdir("./test_dir")print("测试完成！")if__name__=="__main__":main()