基于C socket编程的FTP文件传输软件（类似无界面版本的百度云盘）

简述

FTP服务器（File Transfer Protocol Server）是在互联网上提供文件存储和访问服务的计算机，它们依照FTP协议提供服务。 FTP是File Transfer Protocol(文件传输协议)。顾名思义，就是专门用来传输文件的协议。简单地说，支持FTP协议的服务器就是FTP服务器。

FTP是用来在两台计算机之间传输文件，是Internet中应用非常广泛的服务之一。它可根据实际需要设置各用户的使用权限，同时还具有跨平台的特性，即在UNIX、Linux和Windows等操作系统中都可实现FTP客户端和服务器，相互之间可跨平台进行文件的传输。因此，FTP服务是网络中经常采用的资源共享方式之一。

FTP（File Transfer Protocol）即文件传输协议，是一种基于TCP的协议，采用客户/服务器模式。通过FTP协议，用户可以在FTP服务器中进行文件的上传或下载等操作。

以上来自百度百科。

该项目是基于socket编程实现的，实现了服务器端和客户端的指令或者解析功能，技术栈：系统软件编程 (Linux）、C socket，网络基础。
运行服务器：./server ip port
运行客户端：./client ip port

---

功能规划设想

简单上图：

具体实现如下图：

我们在老版本的基础上做了些变动，socket编程现实服务器端和客户端交互通过socket建立通道这个是一定要做的，变动的是在连接好之后的read和write可以将我们的指令要求读和写来达到相应的操作，所以重点是read write。

运行效果

演示功能依次如下：
1、ls，展示服务器有哪些文件
2、pwd，打印显示当前服务器文件路径
3、cd /home/SXH 进入服务器的某个文件夹
4、get file 获取服务器的文件（包括参数错误）
5、put file 上传本地文件到服务器（包括参数错误）
6、lls 查看客户端本地文件
7、lcd /mnt/hgfs 进入客户端本地文件夹
8、客户端退出打印退出信息

。。。忘了演示，也可以支持多端操作哦！

代码

服务器端server.c

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<string.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<stdlib.h>
#include"config.h"
#include<fcntl.h>
#include<sys/stat.h>

int get_cmd_type(char *cmd){//发送的数据是字符串，我们需要返回易操作的整型，这里需要定义解析处理函数
     if(!strcmp("ls",cmd))          return LS;
     if(!strcmp("quit",cmd))        return QUIT;
     if(!strcmp("pwd",cmd))         return PWD;
     if(strstr(cmd,"cd")!=NULL)     return CD;
     if(strstr(cmd,"get")!=NULL)    return GET;
     if(strstr(cmd,"put")!=NULL)    return PUT;
     
     return 100;
}

char *getDesDir(char *cmsg){
      char *p;
      p = strtok(cmsg," ");//strtok分割字符串函数，以空格为分割点
      p = strtok(NULL," ");
      return p;
}

void msg_handler(struct Msg msg, int fd){

    char dataBuf[1024]={0};
    char *file = NULL;
    int fdfile;

    printf("cmd : %s\n",msg.data);
    int ret = get_cmd_type(msg.data);//将发送来的指令解析为我们定义的宏

    switch(ret){
        case LS:
        case PWD: 
               msg.type = 0;
               FILE *r = popen(msg.data,"r");
               fread(msg.data,sizeof(msg.data),1,r);
               write(fd,&msg,sizeof(msg));         
               break;
        case CD:
              msg.type = 1;
              char *dir = getDesDir(msg.data);//调用getDesDir分割字符串
              printf("dir:%s\n",dir);
              chdir(dir);//注意要用chdir，不要用 system，它会再开启一个shell来执行
              break;

        case GET:
              file = getDesDir(msg.data);
              if(access(file,F_OK) == -1){
                             strcpy(msg.data,"NO this File!");
                             write(fd,&msg,sizeof(msg));
              }else{
                        msg.type = DOFILE;
                        
                        fdfile = open(file,O_RDWR);
                        read(fdfile,dataBuf,sizeof(dataBuf));
                        close(fdfile);

                        strcpy(msg.data,dataBuf);
                        write(fd,&msg,sizeof(msg));
                   }
                   break;
     
         case PUT:
                 fdfile = open(getDesDir(msg.data),O_RDWR|O_CREAT,0666);
                 write(fdfile,msg.secondBuf,strlen(msg.secondBuf));
                 close(fdfile);
                 break;
         case QUIT:
                 printf("client quit!\n");
                 exit(-1);
    }
}

int main(int argc ,char **argv){

int s_fd;
int c_fd;
int n_read;

char readBuf[128];

struct sockaddr_in  s_addr;
struct sockaddr_in  c_addr;
struct Msg msg;
//判断参数
if(argc != 3){
      printf("Parameter error\n");
      exit(-1);
}
memset(&s_addr,0,sizeof(struct sockaddr_in));
memset(&c_addr,0,sizeof(struct sockaddr_in));//初值全部重写为0
//1.socket

s_fd = socket(AF_INET,SOCK_STREAM,0);//创建套接字，返回int套接字描述符
if(s_fd == -1){
  perror("socket");
  exit(-1);
}

//2.bind
s_addr.sin_family = AF_INET;
s_addr.sin_port = htons(atoi(argv[2]));
inet_aton(argv[1],&s_addr.sin_addr);
//为套接字绑定端口和IP地址
bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));

//3.listen
 
listen(s_fd,10);//监听函数
 
//4.accept
int len = sizeof(struct sockaddr_in);//接受连接
while(1){
		c_fd = accept(s_fd,(struct sockaddr*)&c_addr,&len);
		if(c_fd == -1){  
			perror("accept");
		}
		
		printf("get connect: %s\n",inet_ntoa(c_addr.sin_addr));

		if(fork() == 0){
			while(1){
				memset(msg.data,0,sizeof(msg.data));
				n_read = read(c_fd,&msg,sizeof(msg));//读指令数据，会在这里阻塞等待客户端的数据
				if(n_read == 0){
					printf("customer out\n");
					break;
				}else if(n_read > 0){
					msg_handler(msg,c_fd);
				}
			}   

		}  
	}
	close(c_fd);
	close(s_fd);
	return 0;
}

客户端client.c

#include<stdio.h>
#include<sys/types.h>
#include <sys/socket.h>
#include<string.h>
#include<stdlib.h>
#include <arpa/inet.h>
#include<netinet/in.h>
#include<fcntl.h>
#include"config.h"


char *getdir(char *cmd){
      char *p;
      p = strtok(cmd," ");
      p = strtok(NULL," ");
      return p;
}

int get_cmd_type(char *cmd){
     if(strstr(cmd,"lcd"))          return LCD;

     if(!strcmp("lls",cmd))         return LLS;
     if(!strcmp("ls",cmd))          return LS;
     if(!strcmp("quit",cmd))        return QUIT;
     if(!strcmp("pwd",cmd))         return LS;
     if(strstr(cmd,"cd")!=NULL)    return CD;
     if(strstr(cmd,"get")!=NULL)    return GET;
     if(strstr(cmd,"put")!=NULL)    return PUT;
     
     return -1;
}

int  cmd_handler(struct Msg msg , int fd){

    char *dir = NULL;
    char buf[32];
    int ret;
    int filefd;
  
    ret = get_cmd_type(msg.data);

    switch(ret){
        case LS:
        case PWD:
        case CD: 
              msg.type = 0;
              write(fd,&msg,sizeof(msg));
              break;

        case GET:
              msg.type = 2;
              write(fd,&msg,sizeof(msg));
              break;
     
         case PUT:
                 strcpy(buf ,msg.data);
                 dir = getdir(buf);

                 if(access(dir,F_OK) == -1){
                          printf("%s not exsit\n",dir);
                 }else{
                          filefd = open(dir,O_RDWR);
                          read(filefd,msg.secondBuf,sizeof(msg.secondBuf));
                          close(filefd);
    
                          write(fd ,&msg ,sizeof(msg));
                      }
                      break;
         case LLS:
                 system("ls");
                 break;
         case LCD:
                 dir = getdir(msg.data);
                 chdir(dir);
                 break;
         case QUIT:
                 strcpy(msg.data,"quit");
                 write(fd,&msg,sizeof(msg));
                 close(fd);
                 exit(-1);
    }
    return ret;
}

void handler_server_message(int c_fd , struct Msg msg){
        int  n_read;
        struct Msg msgget;
        int newfilefd;
  
        n_read = read(c_fd , &msgget,sizeof(msgget));
       
        if(n_read == 0){
                printf("server is out ,quit\n");
                exit(-1);
        }
       
        else if(msgget.type == DOFILE){
                       char *p = getdir(msg.data);
                       newfilefd = open(p,O_RDWR|O_CREAT,0600);
                       write(newfilefd,msgget.data,strlen(msgget.data));
                       putchar('>');
                       fflush(stdout);

        }else{

                 printf("==========================\n");
                 printf("\n%s\n",msgget.data);
                 printf("==========================\n");
 
                 putchar('>');
                 fflush(stdout);
             }

}

int main(int argc ,char **argv){

int c_fd;
struct sockaddr_in  c_addr;
struct Msg msg;

memset(&c_addr,0,sizeof(struct sockaddr_in));
if(argc != 3){
    printf("Parameter error\n");
    exit(-1);
}
//1.socket

c_fd = socket(AF_INET,SOCK_STREAM,0);
if(c_fd == -1){
  perror("socket");
  exit(-1);
}

//2.bind
c_addr.sin_family = AF_INET;
c_addr.sin_port = htons(atoi(argv[2]));
inet_aton(argv[1],&c_addr.sin_addr);
  
bind(c_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr_in));


 
//3.connect
 
if(connect(c_fd,(struct sockaddr*)&c_addr,sizeof(struct sockaddr)) == -1){
   perror("connect");
   exit(-1);
}

printf("connected\n");

int mark = 0;

while(1){
     
            memset(msg.data,0,sizeof(msg.data));
            if(mark == 0)   printf(">");
            gets(msg.data);
            
            if(strlen(msg.data)==0){
                    if(mark == 1){
                            printf(">");
                    }
                    continue;
            
            }
            
            mark = 1;

           int  ret = cmd_handler(msg,c_fd);
       
           if(ret > IFGO){
                   putchar('>');
                   fflush(stdout);
                   continue;
           }
           if(ret == -1){
                   printf("command not \n");
                   printf(">");
                   fflush(stdout);
                   continue;
           }
           handler_server_message(c_fd , msg);
      
}
return 0;
}

（分文件编程）头文件config.h

#define LS    0
#define GET   1
#define PWD   2

#define IFGO  3

#define LCD   4
#define LLS   5
#define CD    6
#define PUT   7

#define QUIT   8
#define DOFILE 9


struct Msg
{
     int type;
     char data[1024];
     char secondBuf[128];
};

注解

开发思路：
在server中，我们先建立起socket通道，而后我们等待连接，也就是accept，注意是要不断循环监听通过的连接，在循环里面，我们创建子进程，循环不断地read来自已完成连接客户端发过来的指令数据，接到数据判断是否为0
否则将指令数据传入msg，进行msg_handler函数数据处理操作，在msg_handler首先解析指令，通过get_cmd_type函数解析，返回整型ret数据，然后根据ret进行分支处理，例如get指令，首先用getDesDir分割字符串，接下来判断这个要get的文件是否存在，否则error，存在打开文件读，然后write，以供客户端接收并read。

在客户端client中，差别不是很大，流程都是一致的，首先建立通道，连接好之后puts指令，同样的调用cmd_handler函数进行解析、分割等等操作，返回ret，根据ret的值做出判断，直至调用handler_server_message函数在handler_server_message函数里只有read操作如若我们读到的是get发来的数据，就要创建文件并write，其他的指令都要read，然后刷新即可。

关于listen和accept：
listen不断的监听数据，假设listen最大连接是10，那么在这10个里面有已经完成3次握手的，也有未完成的，如果有已经完成，会接着往下执行accept会接受这个连接，和相应的客户端完成部分操作。accept的功能就是用于从已完成连接队列队头返回下一个已完成连接，如果已完成连接队列为空，那么进程就会被投入睡眠。

循环的子进程：
一个子进程负责一条连接通道，在socket编程中，当新的客户端接入的时候
创建子进程，其他时候不要创建，不然创建多个子进程，很难管控，代码会跑废掉。

关于部分字符串api：
请参考C语言中常见字符串API详解

关于socket流程和api介绍：
请参考socket编程详解（一）——服务器端
请参考socket编程详解（二）——客户端