• select&epoll讲解（例：实现FTP文件上传下载）

    一.为什么会出现select

    （1）在默认的阻塞模式下的套接字里，recv会阻塞在那里，直到套接字连接上有数据可读，把数据读到buffer里后recv函数才会返回，不然就会一直阻塞在那里。在单线程的程序里出现这种情况会导致主线程（单线程程序里只有一个默认的主线程）被阻塞,这样整个程序被锁死在这里，如果永 远没数据发送过来，那么程序就会被永远锁死。这个问题可以用多线程解决，但是在有多个套接字连接的情况下，这不是一个好的选择，扩展性很差。

    （2）在非阻塞模式的套接字里，recv的调用不管套接字连接上有没有数据可以接收都会马上返回。但在没有数据的情况下，recv确实是马上返回了，但是也返回了一个错误：WSAEWOULDBLOCK，即请求的操作没有成功完成。

      若重复调用recv并检查返回值，直到成功为止，但是这样做效率很成问题，开销太大。

     select就是为了解决上述两个问题，能够实现在一个线程内完成并发操作，即I/O多路复用：多个描述符的I/O操作都能在一个线程内并发交替地完成，随着研究的进展，poll/epoll方法（select的改善）也相继出现，其功能和select类似，可以同时监视多个描述符的读写就绪状况，即在一个线程内同时处理多个socket的I/O请求。

    二.select原理和示例

    • select原理

            在一段指定时间内，监听用户感兴趣的文件描述符上的可读、可写和异常事件，帮助调用者寻找当前就绪的设备。

            原理图如下所示，select首先进行系统调用，当数据准备好时返回socket接口，然后使用recv接受socket发送过来的数据，并进行处理。   

    •  select示例

            select伪代码如下：依次顺序遍历fd，等待数据准备好。

    •  select缺点

            （1）每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大；
            （2）同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大；
            （3）select支持的文件描述符数量太小了，默认是1024；

    三.epoll原理和示例

    • 为什么使用epoll？

            每次调用Select都需要将进程加入到所有监视Socket的等待队列，每次唤醒都需要从每个队列中移除。这里涉及了两次遍历，而且每次都要将整个FDS列表传递给内核，有一定的开销。所以为了减少遍历次数，并保存就绪的socket(fd)，研究出现了epoll方法，它是select和poll的增强版本。

    • epoll示例

            epoll伪代码如下，将所有socket加入到等待队列中，当有数据到达时，可以直接找到对应的socket，无需遍历；

    • select和epoll区别

            使用快递来进行类比，select：需要对快递编号依次遍历，看看有没有快递员到达，也就是当快递到达时没法直接知道快递编号，需要依次遍历进行获取；epoll：当有快递到达时，可以直接得知快递编号。

    三.分别使用select和epoll实现一个FTP文件上传下载

    • select     

            server.c

    1. //server.c
    2. #include  
    3. #include  
    4. #include  
    5. #include  
    6. #include  
    7. #include  
    8. #include  
    9. #include 
    10. #include 
    11.  
    12. int main() 
    13. { 
    14.     int server_sockfd, client_sockfd; 
    15.     int server_len, client_len; 
    16.     struct sockaddr_in server_address; 
    17.     struct sockaddr_in client_address; 
    18.     int ret; 
    19.     fd_set testfds,readfds; 
    20.  
    21.     //1.建立服务器端socket，用于描述IP地址和端口，通过socket向网络发请求或应答网络请求
    22.     server_sockfd = socket(AF_INET, SOCK_STREAM, 0);//建立服务器端socket
    23.  
    24.     //2.绑定侦听的IP地址和端口
    25.     server_address.sin_family = AF_INET;  
    26.     server_address.sin_addr.s_addr = htonl(INADDR_ANY);  //INADDR_ANY=0,表示侦听全部IP地址
    27.     server_address.sin_port = htons(8888);  //端口
    28.     server_len = sizeof(server_address); 
    29.     bind(server_sockfd, (struct sockaddr *)&server_address, server_len);  //将套接字套接字绑定到地址server上。
    30.  
    31.     //3.侦听
    32.     listen(server_sockfd, 7); //监听队列最多容纳7个 
    33.  
    34.     FD_ZERO(&readfds); 
    35.     FD_SET(server_sockfd, &readfds);//可读集合初始化为[server_sockfd,]
    36.  
    37.     while(1) 
    38.     {
    39.         char ch; 
    40.         int nread; 
    41.         printf("server waiting......\n"); 
    42.  
    43.         /*无限期阻塞，并测试文件描述符变动 */
    44.         testfds = readfds; //将需要监视的描述符集copy到select查询队列中，select会对其修改，所以一定要分开使用变量 
    45.         ret = select(FD_SETSIZE, &testfds, (fd_set *)0,(fd_set *)0, (struct timeval *) 0); //数据准备就绪，则文件描述符会发生变化
    46.         /* select：寻找当前准备就绪的设备，当可读、可写、异常任一文件描述符准备就绪，则select返回，每次结束后，select重新赋值
    47.          * 当select()返回后，该数组中就绪的文件描述符便会被内核修改标志位（变成ready），使得进程可以获得这些文件描述符从而进行后续的读写操作
    48.          * readfds：监视的socket，testfds：监视的socket中数据就绪的socket
    49.          * select(int maxfdp, fd_set *readset, fd_set *writeset, fd_set *exceptset,struct timeval *timeout);
    50.          * maxfdp（FD_SETSIZE）:被监听文件描述符总数；readfds、writefds、exceptset：分别指向可读、可写和异常事件
    51.          * timeout: 等于NULL(0)表示无限等待
    52.          */
    53.         //testfds :初始化的可读集合里面哪一个准备就绪了，返回的testfds就等于几，FD_SETSIZE等于初始化可读集合总数+1
    54.         //testfds初始是监听的集合，返回值是准备好的集合
    55.         if(ret < 1)  //ret:0表示超时，-1表示失败
    56.         { 
    57.             perror("select error"); 
    58.             exit(1); 
    59.         } 
    60.  
    61.         /*扫描所有的文件描述符*/
    62.         for(int fd = 0; fd < FD_SETSIZE; fd++) /*循环遍历*/
    63.         {
    64.             if(FD_ISSET(fd,&testfds)) //有数据准备就绪，fd为进来的请求，定位置位
    65.             {
    66.                 // printf("fd:%d\n",fd);
    67.                 if(fd == server_sockfd)  /*判断是否为服务器套接字(3)，是则表示为客户请求连接。*/
    68.                 { 
    69.                     client_len = sizeof(client_address); 
    70.                     client_sockfd = accept(server_sockfd,(struct sockaddr *)&client_address, &client_len);  //接收客户端socket
    71.                     FD_SET(client_sockfd, &readfds);//将客户端socket加入到集合中(可读集合扩充了)
    72.                     printf("adding client on fd %d......\n", client_sockfd); 
    73.                 } 
    74.                 else  /*客户端socket中有数据请求时*/
    75.                 { 
    76.                     char cmd[256];
    77.                     ret = recv(fd, cmd, sizeof(cmd), 0); //接受数据(命令)
    78.                     // printf("cmd:%s",cmd);
    79.  
    80.                     if(ret < 1 || strncmp(cmd, "exit", 4) ==0)/*客户数据请求完毕，关闭套接字，从集合中清除相应描述符 */
    81.                     {
    82.                         close(fd); 
    83.                         FD_CLR(fd, &readfds); //去掉关闭的fd
    84.                         printf("client on fd %d closed......\n", fd); 
    85.                     }
    86.                     else /*对数据进行处理*/
    87.                     {                        
    88.                         /*处理客户数据请求*/
    89.                         if(strncmp(cmd, "put", 3) ==0) //上传文件
    90.                         {
    91.                             char filename[256] = "";
    92.                             char filepath[256] = "./data/";  //上传的文件存放在服务器的位置
    93.                             for(int i=4;cmd[i]!='\0';i++)
    94.                             {
    95.                                 filename[i-4]=cmd[i];
    96.                             }
    97.                             strcat(filepath,filename);
    98.  
    99.                             // printf("recv cmd on fd %d: %s\n", fd,cmd);
    100.                             char a[2] = "ok";
    101.                             ret = send(fd, a,sizeof(a), 0); //通知客户端收到，防止粘包
    102.  
    103.                             char buffer[1024];
    104.                             FILE * fp = fopen(filepath,"w"); //保存客户端发送的文件内容
    105.                             bzero(buffer,1024);
    106.                             int length = 0;
    107.                             if((length = recv(fd,buffer,1024,0))>0)       //接收并写到文件
    108.                             {
    109.                                 if(length < 0)
    110.                                 {
    111.                                     printf("Recieve Data Failed!\n");
    112.                                     break;
    113.                                 }
    114.                                 int write_length = fwrite(buffer,sizeof(char),length,fp);
    115.                                 if (write_length
    116.                                 {
    117.                                     printf("File: Write Failed\n");
    118.                                     break;
    119.                                 }
    120.                             }
    121.                             printf("Successfully received file %s(filelength = %i) on fd %d...\n", filename,length,fd);
    122.                             fclose(fp);
    123.                         }
    124.                         else if(strncmp(cmd, "get" , 3) == 0)//下载文件
    125.                         {
    126.                             char filename[256] = "";
    127.                             char filepath[256] = "./data/";  //下载的文件在服务器的位置
    128.                             for(int i=4;cmd[i]!='\0';i++)
    129.                             {
    130.                                 filename[i-4]=cmd[i];
    131.                             }
    132.                             strcat(filepath,filename);
    133.                             if((access(filepath,F_OK))!=-1) //文件存在
    134.                             {
    135.                                 char a[2] = "ok";
    136.                                 ret = send(fd, a,sizeof(a), 0); //通知客户端文件存在
    137.  
    138.                                 char buffer[1024];
    139.                                 FILE * fp = fopen(filepath,"r");
    140.                                 bzero(buffer, 1024);
    141.                                 int file_length = 0;
    142.                                 while( (file_length = fread(buffer,sizeof(char),1024,fp))>0)
    143.                                 {
    144.                                     if(send(fd,buffer,file_length,0)<0) //向客户端发送文件内容
    145.                                     {
    146.                                         printf("Send File:\t%s Failed\n", filepath);
    147.                                         break;
    148.                                     }
    149.                                     bzero(buffer, 1024);
    150.                                     printf("put all file(file_length = %d) to fd %d...\n",file_length,fd);
    151.                                 }                                                                
    152.                                 fclose(fp);
    153.                             }
    154.                             else
    155.                             {
    156.                                 char a[2] = "on";
    157.                                 ret = send(fd, a,sizeof(a), 0); //通知客户端文件不存在
    158.                                 printf("get file is not valid\n");
    159.                             }                
    160.                         }                        
    161.                     }       
    162.                 } 
    163.             }
    164.         }
    165.     } 
    166.  
    167.     return 0;
    168. }

             client.c

    1. //client.c
    2. #include  
    3. #include  
    4. #include  
    5. #include  
    6. #include  
    7. #include  
    8. #include 
    9. #include 
    10. #include 
    11.  
    12.  
    13. int main() 
    14. { 
    15.     int client_sockfd,len,ret;  
    16.     struct sockaddr_in address;//服务器端网络地址结构体 
    17.     char cmd[256]; 
    18.  
    19.     //1.建立客户端socket
    20.     client_sockfd = socket(AF_INET, SOCK_STREAM, 0); 
    21.     //2.连接服务端
    22.     address.sin_family = AF_INET; 
    23.     address.sin_addr.s_addr = inet_addr("127.0.0.1");
    24.     address.sin_port = htons(8888); 
    25.     len = sizeof(address); 
    26.     ret = connect(client_sockfd, (struct sockaddr *)&address, len); 
    27.     if(ret == -1) 
    28.     { 
    29.          perror("connect error"); 
    30.          exit(1); 
    31.     } 
    32.  
    33.     printf("------Welcome!!-----\n");
    34.     printf("                    (helps:information you need)\n");
    35.     
    36.     while(1)
    37.     {
    38.         printf(">>>");
    39.         bzero(cmd,256);
    40.         if(fgets(cmd,256,stdin) == NULL)
    41.         {
    42.             printf("input Error!\n");
    43.             return -1;
    44.         }
    45.  
    46.         cmd[strlen(cmd)-1]='\0';    //fgets函数读取的最后一个字符为换行符，此处将其替换为'\0'
    47.         
    48.         if(strncmp(cmd, "put", 3) ==0 ) //上传文件(空格是为了标准化格式)
    49.         {
    50.             if(cmd[3]=='\0'||cmd[4]=='\0') //直接回车
    51.             {
    52.                 printf("No filename follows after put cmd!\n");
    53.                 continue;
    54.             }
    55.  
    56.             char filename[256] = "";
    57.             char filepath[256] = "./data/";  //上传文件在本地的位置
    58.             for(int i=4;cmd[i]!='\0';i++)
    59.             {
    60.                 filename[i-4]=cmd[i];
    61.             }
    62.             strcat(filepath,filename);
    63.             if((access(filepath,F_OK))!=-1) //文件存在
    64.             {        
    65.                 ret = send(client_sockfd, cmd,sizeof(cmd), 0); //发送命令
    66.  
    67.                 char a[2];
    68.                 ret = recv(client_sockfd, a, sizeof(a), 0); //防止粘包
    69.                 if(strncmp(a, "ok" , 2) == 0) //收到服务器的回应
    70.                 {
    71.                     char buffer[1024];
    72.                     FILE * fp = fopen(filepath,"r");
    73.                     bzero(buffer, 1024);
    74.                     int file_length = 0;
    75.                     while( (file_length = fread(buffer,sizeof(char),1024,fp))>0)
    76.                     {
    77.                         //上传文件内容
    78.                         if(send(client_sockfd,buffer,file_length,0)<0)
    79.                         {
    80.                             printf("Send File:\t%s Failed\n", filepath);
    81.                             break;
    82.                         }
    83.                         bzero(buffer, 1024);
    84.                         printf("put all file(file_length = %d)...\n",file_length);
    85.                     }                                                                 //这段代码是循环读取文件的一段数据，在循环调用send，发送到客户端，这里强调一点的TCP每次接受最多是1024字节，多了就会分片，因此每次发送时尽量不要超过1024字节。
    86.                     fclose(fp);
    87.                 }
    88.             }
    89.             else{
    90.                 printf("File is not valid\n");
    91.                 continue;
    92.             }            
    93.         }
    94.         else if(strncmp(cmd, "get" , 3) == 0) //下载文件
    95.         {
    96.             if(cmd[3]=='\0'||cmd[4]=='\0') //直接回车的情况
    97.             {
    98.                 printf("No filename follows after get cmd!\n");
    99.                 continue;
    100.             }
    101.  
    102.             char filename[256] = "";
    103.             char filepath[256] = "./data/";  //下载的文件在服务器的位置
    104.             for(int i=4;cmd[i]!='\0';i++)
    105.             {
    106.                 filename[i-4]=cmd[i];
    107.             }
    108.             strcat(filepath,filename);
    109.  
    110.             ret = send(client_sockfd,cmd,sizeof(cmd), 0); //发送命令
    111.  
    112.             char a[2];
    113.             ret = recv(client_sockfd, a, sizeof(a), 0); //防止粘包
    114.             if(strncmp(a, "ok" , 2) == 0) //收到服务器的回应，文件存在
    115.             {
    116.                 char buffer[1024];
    117.                 FILE * fp = fopen(filepath,"w"); //保存服务器发送的文件内容
    118.                 bzero(buffer,1024);
    119.                 int length = 0;
    120.                 if((length = recv(client_sockfd,buffer,1024,0))>0)     //接收并写到文件
    121.                 {
    122.                     if(length < 0)
    123.                     {
    124.                         printf("Recieve Data Failed!\n");
    125.                         break;
    126.                     }
    127.                     int write_length = fwrite(buffer,sizeof(char),length,fp);
    128.                     if (write_length
    129.                     {
    130.                         printf("File: Write Failed\n");
    131.                         break;
    132.                     }
    133.                 }
    134.                 printf("Successfully received file %s(filelength = %i) ...\n", filename,length);
    135.                 fclose(fp);
    136.             }
    137.             else
    138.             {
    139.                 printf("get file is not valid\n");
    140.             }     
    141.         }
    142.         else if(strncmp(cmd,"helps",5) == 0) //帮助信息
    143.         {
    144.             printf("put filename         #upload\n");
    145.             printf("get filename         #download\n");
    146.             printf("exit                 #exit\n");
    147.             printf("others               #return NULL\n");
    148.         }
    149.         else if(strncmp(cmd,"exit",4) == 0) //退出
    150.         {
    151. 		    ret = send(client_sockfd, cmd,sizeof(cmd), 0); //发送命令
    152.             close(client_sockfd);
    153.             exit(1);
    154.         }
    155.         else
    156.         {
    157.             printf("NULL\n");
    158.         }
    159.     }
    160.    
    161.     return 0;
    162. }

              操作说明：

    #原始文件#
    --server
      --/data
        --5.txt 6.txt  服务器中的文件
    --client
      --/data
        --1.txt 2.txt  客户端中的文件

    1.打开服务器
    cd server
    gcc server.c -o server
    ./server

    2.打开客户端1
    cd client
    gcc client.c -o client
    ./client

    #向服务器上传文件1.txt,成功后会出现/server/data/1.txt
    put 1.txt

    #从服务器中下载文件5.txt,成功后会出现/client/data/5.txt
    get 5.txt

    3.打开客户端2
    cd client
    gcc client.c -o client
    ./client

    #向服务器上传文件2.txt,成功后会出现/server/data/2.txt
    put 2.txt

    #从服务器中下载文件6.txt,成功后会出现/client/data/6.txt
    get 6.txt

    • epoll

            server.c

    1. //server.c
    2. #include  
    3. #include  
    4. #include  
    5. #include  
    6. #include  
    7. #include  
    8. #include  
    9. #include 
    10. #include 
    11. #include 
    12.  
    13. int main() 
    14. { 
    15.     int server_sockfd, client_sockfd; 
    16.     int server_len, client_len; 
    17.     struct sockaddr_in server_address; 
    18.     struct sockaddr_in client_address; 
    19.     int ret;  
    20.  
    21.     //1.建立服务器端socket，用于描述IP地址和端口，通过socket向网络发请求或应答网络请求
    22.     server_sockfd = socket(AF_INET, SOCK_STREAM, 0);//建立服务器端socket
    23.  
    24.     //2.绑定侦听的IP地址和端口
    25.     server_address.sin_family = AF_INET;  
    26.     server_address.sin_addr.s_addr = htonl(INADDR_ANY);  //INADDR_ANY=0,表示侦听全部IP地址
    27.     server_address.sin_port = htons(8787);  //端口
    28.     server_len = sizeof(server_address); 
    29.     bind(server_sockfd, (struct sockaddr *)&server_address, server_len);  //将套接字套接字绑定到地址server上。
    30.  
    31.     //3.侦听
    32.     listen(server_sockfd, 7); //监听队列最多容纳7个 
    33.  
    34.     int epollfd = epoll_create(10); //创建文件描述符(10表示epollfd上能关注的最大fd数)
    35.  
    36.     struct epoll_event tmp,epevents[5];  //创建epoll对象
    37.     tmp.events = EPOLLIN; //表示对应的文件描述符可以读（包括对端SOCKET正常关闭）；
    38.     tmp.data.fd = server_sockfd;
    39.     epoll_ctl(epollfd,EPOLL_CTL_ADD,server_sockfd,&tmp);//将需要监视的socket加入到epollfd中(关注了server_sockfd)，等待队列
    40.     /*(epoll_create()返回值,动作，需要监听的socket，需要监听的内容(可读))*/
    41.  
    42.     while(1) 
    43.     {
    44.         char ch; 
    45.         int nread; 
    46.         printf("server waiting......\n"); 
    47.  
    48.         //获取准备好的描述符事件   
    49.         int num = epoll_wait(epollfd,epevents,5,-1); //等待epevents对象，可读时通知，读到后就改为写时通知,epollfd为需要监视的socket集合
    50.  
    51.         /*select扫描所有的fd，然后准备就绪的fd放在等待队列进行数据处理
    52.          *epoll 不用，其等待队列已经存放于events中（即epevents[i].data.fd），只需要判断它的fd是不是可读
    53.          *select每次都需要添加可读等待队列（fd），然后阻塞，遍历所有的fd-size。
    54.          *但是epoll不用，其等待队列（fd）已经存放于events中，一直阻塞，只需要遍历epevents事件判断其fd是否可读
    55.          */
    56.  
    57.         /*扫描所有的文件描述符*/
    58.         for(int i = 0; i < num; i++) /*num为等待到的连接数(1)*/
    59.         {
    60.             if(!(epevents[i].events & EPOLLIN)) //如果不是读事件，直接跳过 [&：两个都运行，有一个为假就不成立]
    61.             {
    62.                 continue;
    63.             }
    64.             if(epevents[i].data.fd == server_sockfd) /*判断是否为服务器套接字(3)，是则表示为客户请求连接。*/
    65.             {
    66.                 client_len = sizeof(client_address); 
    67.                 client_sockfd = accept(server_sockfd,(struct sockaddr *)&client_address, &client_len);  //接收客户端socket
    68.                 tmp.events = EPOLLIN;
    69.                 tmp.data.fd = client_sockfd;
    70.                 ret = epoll_ctl(epollfd,EPOLL_CTL_ADD,client_sockfd, &tmp); //将客户端socket加入到epollfd中
    71.                 printf("adding client on fd %d......\n", client_sockfd); 
    72.             }
    73.             else /*客户端socket中有数据请求时*/
    74.             {
    75.                 char cmd[256];
    76.                 ret = recv(epevents[i].data.fd, cmd, sizeof(cmd), 0); //接受数据(命令)
    77.  
    78.                 if(ret < 1 || strncmp(cmd, "exit", 4) ==0)/*客户数据请求完毕，关闭套接字，从集合中清除相应描述符 */
    79.                 {
    80.                     close(epevents[i].data.fd);
    81.                     epoll_ctl(epollfd,EPOLL_CTL_DEL,epevents[i].data.fd,NULL);//删除已经注册的fd
    82.                     printf("client on fd %d closed......\n", epevents[i].data.fd); 
    83.                 }
    84.                 else /*对数据进行处理*/
    85.                 {                        
    86.                     /*处理客户数据请求*/
    87.                     if(strncmp(cmd, "put", 3) ==0) //上传文件
    88.                     {
    89.                         char filename[256] = "";
    90.                         char filepath[256] = "./data/";  //上传的文件存放在服务器的位置
    91.                         for(int i=4;cmd[i]!='\0';i++)
    92.                         {
    93.                             filename[i-4]=cmd[i];
    94.                         }
    95.                         strcat(filepath,filename);
    96.  
    97.                         // printf("recv cmd on fd %d: %s\n", fd,cmd);
    98.                         char a[2] = "ok";
    99.                         ret = send(epevents[i].data.fd, a,sizeof(a), 0); //通知客户端收到，防止粘包
    100.  
    101.                         char buffer[1024];
    102.                         FILE * fp = fopen(filepath,"w"); //保存客户端发送的文件内容
    103.                         bzero(buffer,1024);
    104.                         int length = 0;
    105.                         if((length = recv(epevents[i].data.fd,buffer,1024,0))>0)       //接收并写到文件
    106.                         {
    107.                             if(length < 0)
    108.                             {
    109.                                 printf("Recieve Data Failed!\n");
    110.                                 break;
    111.                             }
    112.                             int write_length = fwrite(buffer,sizeof(char),length,fp);
    113.                             if (write_length
    114.                             {
    115.                                 printf("File: Write Failed\n");
    116.                                 break;
    117.                             }
    118.                         }
    119.                         printf("Successfully received file %s(filelength = %i) on fd %d...\n", filename,length,epevents[i].data.fd);
    120.                         fclose(fp);
    121.                     }
    122.                     else if(strncmp(cmd, "get" , 3) == 0)//下载文件
    123.                     {
    124.                         char filename[256] = "";
    125.                         char filepath[256] = "./data/";  //下载的文件在服务器的位置
    126.                         for(int i=4;cmd[i]!='\0';i++)
    127.                         {
    128.                             filename[i-4]=cmd[i];
    129.                         }
    130.                         strcat(filepath,filename);
    131.                         if((access(filepath,F_OK))!=-1) //文件存在
    132.                         {
    133.                             char a[2] = "ok";
    134.                             ret = send(epevents[i].data.fd, a,sizeof(a), 0); //通知客户端文件存在
    135.  
    136.                             char buffer[1024];
    137.                             FILE * fp = fopen(filepath,"r");
    138.                             bzero(buffer, 1024);
    139.                             int file_length = 0;
    140.                             while( (file_length = fread(buffer,sizeof(char),1024,fp))>0)
    141.                             {
    142.                                 if(send(epevents[i].data.fd,buffer,file_length,0)<0) //向客户端发送文件内容
    143.                                 {
    144.                                     printf("Send File:\t%s Failed\n", filepath);
    145.                                     break;
    146.                                 }
    147.                                 bzero(buffer, 1024);
    148.                                 printf("put all file(file_length = %d) to fd %d...\n",file_length,epevents[i].data.fd);
    149.                             }                                                                
    150.                             fclose(fp);
    151.                         }
    152.                         else
    153.                         {
    154.                             char a[2] = "on";
    155.                             ret = send(epevents[i].data.fd, a,sizeof(a), 0); //通知客户端文件不存在
    156.                             printf("get file is not valid\n");
    157.                         }                
    158.                     }                        
    159.                 }       
    160.             }
    161.         }
    162.     } 
    163.     
    164.     close(epollfd);
    165.  
    166.     return 0;
    167. }

            client.c

    1. //client.c
    2. #include  
    3. #include  
    4. #include  
    5. #include  
    6. #include  
    7. #include  
    8. #include 
    9. #include 
    10. #include 
    11.  
    12.  
    13. int main() 
    14. { 
    15.     int client_sockfd,len,ret;  
    16.     struct sockaddr_in address;//服务器端网络地址结构体 
    17.     char cmd[256]; 
    18.  
    19.     //1.建立客户端socket
    20.     client_sockfd = socket(AF_INET, SOCK_STREAM, 0); 
    21.     //2.连接服务端
    22.     address.sin_family = AF_INET; 
    23.     address.sin_addr.s_addr = inet_addr("127.0.0.1");
    24.     address.sin_port = htons(8787); 
    25.     len = sizeof(address); 
    26.     ret = connect(client_sockfd, (struct sockaddr *)&address, len); 
    27.     if(ret == -1) 
    28.     { 
    29.          perror("connect error"); 
    30.          exit(1); 
    31.     } 
    32.  
    33.     printf("------Welcome!!-----\n");
    34.     printf("                    (helps:information you need)\n");
    35.     
    36.     while(1)
    37.     {
    38.         printf(">>>");
    39.         bzero(cmd,256);
    40.         if(fgets(cmd,256,stdin) == NULL)
    41.         {
    42.             printf("input Error!\n");
    43.             return -1;
    44.         }
    45.  
    46.         cmd[strlen(cmd)-1]='\0';    //fgets函数读取的最后一个字符为换行符，此处将其替换为'\0'
    47.         
    48.         if(strncmp(cmd, "put", 3) ==0 ) //上传文件(空格是为了标准化格式)
    49.         {
    50.             if(cmd[3]=='\0'||cmd[4]=='\0') //直接回车
    51.             {
    52.                 printf("No filename follows after put cmd!\n");
    53.                 continue;
    54.             }
    55.  
    56.             char filename[256] = "";
    57.             char filepath[256] = "./data/";  //上传文件在本地的位置
    58.             for(int i=4;cmd[i]!='\0';i++)
    59.             {
    60.                 filename[i-4]=cmd[i];
    61.             }
    62.             strcat(filepath,filename);
    63.             if((access(filepath,F_OK))!=-1) //文件存在
    64.             {     
    65.                 ret = send(client_sockfd, cmd,sizeof(cmd), 0); //发送命令
    66.  
    67.                 char a[2];
    68.                 ret = recv(client_sockfd, a, sizeof(a), 0); //防止粘包
    69.                 if(strncmp(a, "ok" , 2) == 0) //收到服务器的回应
    70.                 {
    71.                     char buffer[1024];
    72.                     FILE * fp = fopen(filepath,"r");
    73.                     bzero(buffer, 1024);
    74.                     int file_length = 0;
    75.                     while( (file_length = fread(buffer,sizeof(char),1024,fp))>0)
    76.                     {
    77.                         //上传文件内容
    78.                         if(send(client_sockfd,buffer,file_length,0)<0)
    79.                         {
    80.                             printf("Send File:\t%s Failed\n", filepath);
    81.                             break;
    82.                         }
    83.                         bzero(buffer, 1024);
    84.                         printf("put all file(file_length = %d)...\n",file_length);
    85.                     }                                                                 //这段代码是循环读取文件的一段数据，在循环调用send，发送到客户端，这里强调一点的TCP每次接受最多是1024字节，多了就会分片，因此每次发送时尽量不要超过1024字节。
    86.                     fclose(fp);
    87.                 }
    88.             }
    89.             else{
    90.                 printf("File is not valid\n");
    91.                 continue;
    92.             }            
    93.         }
    94.         else if(strncmp(cmd, "get" , 3) == 0) //下载文件
    95.         {
    96.             if(cmd[3]=='\0'||cmd[4]=='\0') //直接回车的情况
    97.             {
    98.                 printf("No filename follows after get cmd!\n");
    99.                 continue;
    100.             }
    101.  
    102.             char filename[256] = "";
    103.             char filepath[256] = "./data/";  //下载的文件在服务器的位置
    104.             for(int i=4;cmd[i]!='\0';i++)
    105.             {
    106.                 filename[i-4]=cmd[i];
    107.             }
    108.             strcat(filepath,filename);
    109.  
    110.             ret = send(client_sockfd,cmd,sizeof(cmd), 0); //发送命令
    111.  
    112.             char a[2];
    113.             ret = recv(client_sockfd, a, sizeof(a), 0); //防止粘包
    114.             if(strncmp(a, "ok" , 2) == 0) //收到服务器的回应，文件存在
    115.             {
    116.                 char buffer[1024];
    117.                 FILE * fp = fopen(filepath,"w"); //保存服务器发送的文件内容
    118.                 bzero(buffer,1024);
    119.                 int length = 0;
    120.                 if((length = recv(client_sockfd,buffer,1024,0))>0)     //接收并写到文件
    121.                 {
    122.                     if(length < 0)
    123.                     {
    124.                         printf("Recieve Data Failed!\n");
    125.                         break;
    126.                     }
    127.                     int write_length = fwrite(buffer,sizeof(char),length,fp);
    128.                     if (write_length
    129.                     {
    130.                         printf("File: Write Failed\n");
    131.                         break;
    132.                     }
    133.                 }
    134.                 printf("Successfully received file %s(filelength = %i) ...\n", filename,length);
    135.                 fclose(fp);
    136.             }
    137.             else
    138.             {
    139.                 printf("get file is not valid\n");
    140.             }     
    141.         }
    142.         else if(strncmp(cmd,"helps",5) == 0) //帮助信息
    143.         {
    144.             printf("put filename         #upload\n");
    145.             printf("get filename         #download\n");
    146.             printf("exit                 #exit\n");
    147.             printf("others               #return NULL\n");
    148.         }
    149.         else if(strncmp(cmd,"exit",4) == 0) //退出
    150.         {
    151. 		    ret = send(client_sockfd, cmd,sizeof(cmd), 0); //发送命令
    152.             close(client_sockfd);
    153.             exit(1);
    154.         }
    155.         else
    156.         {
    157.             printf("NULL\n");
    158.         }
    159.     }
    160.    
    161.     return 0;
    162. }

            操作说明：

    #原始文件#
    --server
      --/data
        --5.txt 6.txt  服务器中的文件
    --client
      --/data
        --1.txt 2.txt  客户端中的文件

    1.打开服务器
    cd server
    gcc server.c -o server
    ./server

    2.打开客户端1
    cd client
    gcc client.c -o client
    ./client

    #向服务器上传文件1.txt,成功后会出现/server/data/1.txt
    put 1.txt

    #从服务器中下载文件5.txt,成功后会出现/client/data/5.txt
    get 5.txt

    3.打开客户端2
    cd client
    gcc client.c -o client
    ./client

    #向服务器上传文件2.txt,成功后会出现/server/data/2.txt
    put 2.txt

    #从服务器中下载文件6.txt,成功后会出现/client/data/6.txt
    get 6.txt

    参考博客：

    https://www.cnblogs.com/skyfsm/p/7079458.html
    https://www.cnblogs.com/-zyj/p/5719923.html

  • 相关阅读:
    Vue2封装评论组件详细讲解
    SpringBoot--HttpServletRequest中的方法--使用/详解
    见缝插针游戏针不会更着上面旋转的小球运动
    CUDA学习笔记5——CUDA程序错误检测
    [carla] GNSS传感器与Carla坐标系 转换方法
    jmeter如何压测和存储
    200、使用默认 Exchange 实现 P2P 消息 之 消息生产者（发送消息） 和 消息消费者（消费消息）
    软考高级信息系统项目管理师系列之二：信息化和信息系统习题
    LeetCode简单题之数组能形成多少数对
    深入理解c指针（五）
  • 原文地址：https://blog.csdn.net/m0_37865160/article/details/126700709