• linux下的采用epoll网络模型的文件传输

    首先  在linux中 我们最常采用的是epoll，这种网络模型是异步的，而且相比于poll和select网络模型，在连接的客户端较多时，epoll的处理效率要更高。

    这里先采用epoll来写一个服务器用于与客户端之交互。

    既然用到epoll，我们可以先简单了解一下epoll

    核心部分就是三个API

    Epoll通常有三大部分

    Epoll_create创建红黑树

    Struct epoll_event定义要监控的文件结构体

    Epoll_ctl把要监控的文件描述添加到一颗红黑树，epoll_wait等待发生的消息列表返回，链表中所有的消息都是已经发生的

    我们遍历列表处理事件即可

    这里先例举一个简单的单线程epoll框架

    上图的服务器模型可以实现简单的与客户端之间的对话

    我们之后会在这个框架的基础上改进

    首先我创建了一个函数recvdata 用来接受数据

    这里我介绍一下我的传输逻辑：

    （1）先传输一个文件信息包（不含文件内容）

    typedef struct fileinfo
    {
            int filesize;
            char filepath[MAXSIZE];
    }fileinfo;

    来告知服务器：我的文件想存放在哪里，我的文件大小是多少。

    （2）然后服务器校验文件信息，如果满足条件就发送回复“OK“。

    （3）客户端收到“OK”后发送文件内容

    （4）服务器接受文件内容 直到接受完整在再进行写入文件（这样尽量不会影响接受效率）

    （5）最后，在客户端退出时，会发送推出标识“OT”，服务器一旦受到推出标识就会与相应客户端断开连接。

    改进后的

    服务器代码如下：

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. #include
    10. #define MAXSIZE 1024
    11. //定义文件包
    12. typedef struct fileinfo
    13. {
    14.         int filesize;
    15.         char filepath[MAXSIZE];
    16. }fileinfo;
    17.  
    18. void recvdata(int fd,int offest,fileinfo*fileif)
    19. {
    20.                                 //打开文件
    21.  
    22.                                                         char szbuf[10240];
    23.                                                         char mark[3];
    24.                                                         fileinfo*info=(fileinfo*)fileif;
    25.                                                         printf("filesize is %d\n",info->filesize);
    26.                                                         printf("filepath is %s\n",info->filepath);
    27.                                         if(info->filesize>0)
    28.                                         {
    29.  
    30.                                                       
    31.  
    32.                                                         //FILE*fp=fopen(pfile->filepath,"a");
    33.                                                         FILE*fp=fopen(info->filepath,"a");
    34.                                                         if(NULL==fp)
    35.                                                         {
    36.                                                         printf("fopen failed...\n");
    37.                                                         return;
    38.                                                         }
    39. 				strcpy(mark,"OK");mark[2]='\0';send(fd,mark,3,0);
    40.                                                         int nerl=0;
    41.                                                         size_t nwr=0;
    42.                                                 bzero(szbuf,10240);
    43.                                                 while((nerl=recv(fd,szbuf,sizeof(szbuf),0))>0)
    44.                                                 {
    45.                                                         printf("recv data is %s\n",szbuf);
    46.                                                         printf("nerl is %d\n",nerl);
    47.  
    48.                                                         offest+=nerl;
    49.  
    50.                                                         if(offest>=info->filesize)
    51.                                                         {
    52.                                                         //收文件
    53.                                                         fwrite(szbuf,1,offest,fp);
    54.                                                         printf("offest is %d\n",offest);
    55.                                                         printf("file size is: %d\n",info->filesize);
    56.                                                         fclose(fp);
    57.  
    58.                                                         offest=0;
    59.                                                         printf("recvdata success...\n");
    60. 				break;
    61.                                                         }
    62.                                                 }
    63.                                         }
    64.  
    65.  
    66.  
    67. }
    68. int main()
    69. {
    70. //创建套接子socket()
    71.         int sockfd=socket(AF_INET,SOCK_STREAM,0);
    72.         if(sockfd==-1)
    73.         {
    74.         perror("socket failed...");
    75.         exit(0);
    76.         }
    77. //绑定bind()
    78.         struct sockaddr_in addr;
    79.         addr.sin_family=AF_INET;
    80.         addr.sin_addr.s_addr=0;
    81.         addr.sin_port=htons(8899);
    82.         if(-1==bind(sockfd,(struct sockaddr*)&addr,sizeof(addr)))
    83.         {
    84.         perror("bind failed...");
    85.         exit(0);
    86.         }
    87. //监听listen()
    88.         if(-1==listen(sockfd,128))
    89.         {
    90.         perror("listen failed...");
    91.         exit(0);
    92.         }
    93. //定义struct
    94.         int epfd=epoll_create(1024);
    95.         struct epoll_event ep;
    96.         struct epoll_event sockary[1024];
    97.         ep.data.fd=sockfd;
    98.         ep.events=EPOLLIN;
    99.         epoll_ctl(epfd,EPOLL_CTL_ADD,sockfd,&ep);
    100.  
    101. //将socket放入集合
    102.         int nerl=0;
    103.         char szbuf[10240];
    104.         int nreadnum=0;
    105.         int clientfd;
    106.  
    107. //连接accept()或者接受文件recv()
    108.  
    109.         while(1)
    110.         {
    111.                 //监控的红黑数文件描述，已经发生的消息的连表，最大管理数量，-1
    112.                 nreadnum=epoll_wait(epfd,sockary,1024,-1);
    113.                 int i=0;
    114.                 int offest=0;
    115. 	  printf("nreadnum is %d\n",nreadnum);
    116.  
    117.  
    118.                 while(i
    119.                 {
    120.                         if(sockary[i].events&EPOLLIN)
    121.                         {
    122.                                 if(sockary[i].data.fd==sockfd)
    123.                                 {
    124.                                         clientfd=accept(sockfd,0,0);
    125.                                         printf("accept success");
    126.                                         struct epoll_event ep;
    127.                                         ep.data.fd=clientfd;
    128.                                         ep.events=EPOLLIN;
    129.                                         epoll_ctl(epfd,EPOLL_CTL_ADD,clientfd,&ep);
    130.                                 }
    131.                                 else
    132.                                 {
    133.  
    134.                                         bzero(szbuf,10240);
    135.                                         if((nerl=recv(sockary[i].data.fd,szbuf,10240,0))>0)
    136.                                         {
    137.                                                 if(strcmp(szbuf,"OT")==0){close(sockary[i].data.fd);continue;}
    138.                                                 recvdata(sockary[i].data.fd,offest,(fileinfo*)szbuf);
    139.                                         }sleep(1);
    140.  
    141.                                         sockary[i].events=EPOLLIN;
    142.  
    143.  
    144.                                 }
    145.  
    146.                                 
    147.                                 //bzero(szbuf,sizeof(szbuf));
    148.                         }
    149.                         i++;
    150.  
    151.                 }
    152.                 sleep(5);
    153.  
    154.  
    155.         }
    156.        sleep(1);
    157.         close(sockfd);
    158.         for(int i=1;i<1024;i++){if(sockary[i].data.fd!=-1)close(sockary[i].data.fd);}
    159.         //close(clientfd);
    160.  
    161.  
    162. return 0;
    163. }

    到了客户端 我想要实现多个文件传输，这里有一个功能是将一个文件夹下的所有文件都传输出去。

    这里借鉴了

    (57条消息) Linux环境下C语言Socket编程——客户端向服务端单次发送一个或多个文件的功能_linux网络编程-C代码类资源-CSDN文库

    先简单介绍一下客户端传输的步骤：

    （1）先确定传一个还是多个文件，按0传一个，按1传多个。

    （2）传一个：输入当前想要上传的文件名，程序会校验输入的文件是否存在，不存在重新输入，存在则输入接收端存放的路径，程序也会校验，如果路径下的那个文件不存在，程序会在路径创建文件。

            传多个：程序会遍历当前文件夹的所有文件，循环上传，只不过你需要依次输入存放路径。

    （3）我们的上传文件函数中会先发送文件信息，待收到“OK”后再发送文件内容。

    在退出时，发送“OT”。

    客户端代码如下：

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #define MAXSIZE 1024
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #define SERVER_PORT 6666
    13. #define BUFFER_SIZE 1024
    14. #define CLIENT_PATH "../test/send/"
    15. #define SERVER_PATH "../test/recv/"
    16. typedef struct fileinfo
    17. {
    18.         int filesize;
    19.         char filepath[MAXSIZE];
    20. }fileinfo;
    21.  
    22. int pack_send_File(char*path,int clientfd, FILE* fp)
    23. {
    24. //定义发送缓冲字符串和一些变量
    25.         size_t nerl;
    26.         char sendbuff[1024];
    27.         char mark[3];
    28.         bzero(sendbuff,1024);
    29.  
    30.         int bigfilesize=0;
    31. //获取文件大小
    32.         fseek(fp,0,SEEK_END);
    33.         bigfilesize=ftell(fp);
    34.         printf("bigsize is %d\n",bigfilesize);
    35.         fseek(fp,0,SEEK_SET);
    36. //定义包内容
    37.         fileinfo *info=(fileinfo*)malloc(sizeof(fileinfo));
    38.         info->filesize=bigfilesize;
    39.         strcpy(info->filepath,path);
    40.         printf("info->filepath is %s\n",info->filepath);
    41. //发送包内容 等待回复
    42.         if(send(clientfd,(char*)info,1028,0)<=0){printf("first send failed...\n");}
    43.         recv(clientfd,mark,3,0);
    44.         printf("recv mark is %s\n",mark);
    45. //校验回复  看让不让发
    46. if(strcmp(mark,"OK")==0)
    47.         {
    48.                 printf("w and s is begin...\n");
    49. //发送内容
    50.                 while((nerl=fread(sendbuff,1,1024,fp))>0)
    51.                 {
    52.  
    53.  
    54.                         printf("sendbuff is %s\n",sendbuff);
    55.                         if(send(clientfd,sendbuff,nerl,0)<0)
    56.                         {
    57.                                 printf("file send failed...\n");
    58.                                 break;
    59.                         }
    60.  
    61.                 bzero(sendbuff,1024);
    62.  
    63.                 }sleep(1);
    64.         }
    65. //不让发
    66.                 else{printf("the conform recv error...\n");}
    67.         free(info);
    68. }
    69. int  submit_Files(int clientSocket)
    70. {
    71.  
    72.  FILE* fp;
    73.   char filename[100] = {0}, pre_filename[100] = {0};
    74.   struct dirent* ptr;
    75.   DIR* path = NULL;
    76.   char send_buf[BUFFER_SIZE] = {0};
    77.   path = opendir((char*)CLIENT_PATH);
    78.   while((ptr=readdir(path)) != NULL) {
    79.     if(strcmp(ptr->d_name,".")==0||strcmp(ptr->d_name,"..")==0) {
    80.       continue;
    81.     }
    82.     if(ptr->d_type==DT_REG) {
    83.       printf("%s\n",ptr->d_name);
    84.       strcpy(pre_filename,CLIENT_PATH);
    85.       strcat(pre_filename,ptr->d_name);
    86.       fp = fopen(pre_filename, "rb");
    87.     while(1)
    88.     {
    89.          bzero(pre_filename,sizeof(pre_filename));
    90.         bzero(filename,sizeof(filename));
    91.          strcpy(pre_filename,SERVER_PATH);
    92.          printf("请输入你要写入的文件名: ");
    93.          scanf("%[^\n]%*c",filename);
    94.          strcat(pre_filename,filename);
    95.          FILE*fp1 = fopen(pre_filename, "w");
    96.          if(fp1 == NULL) {
    97.            printf("您提供的文件不存在并且 创建文件失败，请重新输入！\n");
    98.            fclose(fp1);
    99.            continue;
    100.         }
    101.     fclose(fp1);
    102.     break;
    103.     }
    104.  
    105.   printf("已找到或创建好了您的文件:路径是%s\n",pre_filename);
    106.  
    107.       pack_send_File(pre_filename,clientSocket, fp);
    108.       printf("文件%s上传成功！\n",ptr->d_name);
    109.     }
    110.   }
    111.  
    112.  
    113.  
    114.  
    115. }
    116.  
    117. int submit_File(int clientSocket)
    118. {
    119.  
    120.  FILE *fp;
    121.   char send_buf[BUFFER_SIZE] = {0};
    122.   char filename[100] = {0};
    123.   char* pre_filename = (char*)malloc(sizeof(char)*100);
    124.   while(1){
    125.     strcpy(pre_filename,CLIENT_PATH);
    126.     printf("请输入你要提交的文件名: ");
    127.     scanf("%[^\n]%*c",filename);
    128.     strcat(pre_filename,filename);
    129.  fp = fopen(pre_filename, "rb");
    130.     if(fp == NULL) {
    131.       printf("您提供的文件不存在，请重新输入！\n");
    132.       continue;
    133.     }
    134.     break;
    135.   }
    136.   printf("已找到您的文件:路径是%s\n",pre_filename);
    137.   while(1){
    138.     bzero(pre_filename,sizeof(pre_filename));
    139.     bzero(filename,sizeof(filename));
    140.     strcpy(pre_filename,SERVER_PATH);
    141.     printf("请输入你要写入的文件路径: ");
    142.     scanf("%[^\n]%*c",filename);
    143.     strcat(pre_filename,filename);
    144.     FILE*fp1 = fopen(pre_filename, "w");
    145.     if(fp1 == NULL) {
    146.       printf("您提供的文件不存在，请重新输入！\n");
    147.       fclose(fp1);
    148.       continue;
    149.     }
    150.     fclose(fp1);
    151.     break;
    152.   }
    153.  
    154.   printf("已找到您的文件:路径是%s\n",pre_filename);
    155.   pack_send_File(pre_filename,clientSocket, fp);
    156.   printf("文件上传成功！\n");
    157.   close(clientSocket);
    158.  
    159.  
    160. }
    161. int main()
    162. {
    163.         //socket()
    164.         int clientfd=socket(AF_INET,SOCK_STREAM,0);
    165.         //connect()
    166.         struct sockaddr_in addr;
    167.         addr.sin_family=AF_INET;
    168.         addr.sin_addr.s_addr=inet_addr("127.0.0.1");
    169.         addr.sin_port=htons(8899);
    170.         if(-1==connect(clientfd,(struct sockaddr*)&addr,sizeof(addr)))
    171.         {
    172.                 perror("connect failed");
    173.                 exit(0);
    174.         }
    175.  
    176.  
    177.  
    178.  
    179. int choice=-1;
    180. printf("请选择上传单个文件还是多个文件，单个文件输入0,多个文件输入1：");
    181. while(1)
    182. {
    183.     scanf("%d",&choice);
    184.     getchar();
    185.     if(choice == 0 || choice == 1)
    186.       break;
    187.     else
    188.       printf("请正确输入0或1");
    189. }
    190. if(choice == 0)
    191. {
    192.     submit_File(clientfd);
    193. }
    194. else
    195. {
    196.     //int filenum = get_File_Num((char*)CLIENT_PATH);
    197.     submit_Files(clientfd);
    198. }
    199.         send(clientfd,"OT",3,0);
    200.  
    201.        close(clientfd);
    202.  
    203.         return 0;
    204. }
    205.

  • 相关阅读:
    开机强制进入安全模式的三种方法
    React源码分析1-jsx转换及React.createElement
    2.10 负载均衡原理- url hash 与 least_conn
    安全防御---防火墙实验1
    Visual Studio Code从GIT拉取vue项目并运行
    生信步骤|转录组mRNA数据的有参组装
    Nginx错误日志说明
    Linux libreoffice安装 word转pdf 中文乱码（缺少字体解决）
    功率放大器在超声导波中的应用有哪些
    gradle尚硅谷笔记
  • 原文地址：https://blog.csdn.net/van9527/article/details/127768542