基于socket的ftp实现

服务器端的实现：
#include <sys/types.h>
#include <sys/socket.h>
#include<netinet/in.h>//sockaddr_in等结构的定义
#include<netdb.h>//addrinfo等结构的定义
#include <stdio.h>
#include <unistd.h>
#include <dirent.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>

#define TRUE 1
#define LISTEN_PORT 3499
#define dataLen 1024

char currentDirPath[200];
char currentDirName[30];
char help[]="get 

    get a file from server\n\
put      upload afile to server\n\
pwd      display      the current directory of server\n\
dir      displaythe files in the current directory of server\n\
cd      change thedirectory of server\n\
?      display thewhole command which equals 'help'\n\
quit      return\n";

char *getDirName(char *dirPathName);
void cmd_pwd(int sock);
void cmd_dir(int sock);
void cmd_cd(int sock,char *dirName);
void cmd_cdback(int sock);
void cmd_help(int sock);
void cmd_get(int sock,char*fileName);
void cmd_put(int sock,char *fileName);
 
int main(int argc,char *argv[])
{
    int sock,sockmsg, length,lengthmsg;
    char client_cmd[10] ,cmd_arg[20];
    struct sockaddr_inserver;
    struct sockaddr_inservermsg;
    int datasock,msgsock;       
    pid_t child;
 
  // intdatasock;    //data socket
    int rval;
    sock=socket(AF_INET,SOCK_STREAM,0);//创建流式套接字
    sockmsg=socket(AF_INET,SOCK_STREAM,0);
    if(sock<0||sockmsg<0)
    {
      perror("opening stream socket");
      exit(1);
    }
 
    server.sin_family=AF_INET;//AF_INET针对internet,另一种形式AF_UNIX只能够用于单一的Unix系统进程通信（主机通信协议）
    server.sin_addr.s_addr=INADDR_ANY;//表示可以和任何主机通信
    server.sin_port=htons(LISTEN_PORT);//htons将短整形数据转换位网络字节顺序

 
    servermsg.sin_family=AF_INET;
    servermsg.sin_addr.s_addr=INADDR_ANY;
    servermsg.sin_port=htons(LISTEN_PORT+1);

    if (bind(sock,(struct sockaddr*)&server,sizeofserver)<0||bind(sockmsg,(struct sockaddr*)&servermsg,sizeofservermsg)<0)//将本地端口与socket返回的文件描述符绑定在一起
    {
      perror("binding stream socket");
      exit(1);
    }
   
    length=sizeof server;
    lengthmsg=sizeofservermsg;
    if (getsockname(sock,(structsockaddr*)&server,&length)<0||getsockname(sockmsg,(structsockaddr*)&servermsg,&lengthmsg)<0)//用于得套接口的名字
    {
      perror("getting socket name");
      exit(1);
    }
 
    printf("Socket port #%d  %d\n",ntohs(server.sin_port),ntohs(servermsg.sin_port));

    memset(currentDirPath,0,sizeof(currentDirPath));//将currentDirpath置零
    getcwd(currentDirPath,sizeof(currentDirPath));//得到当前路径，保存在currentDirPath中
 
    listen(sock,2);//监听，允许最大监听数位2，将绑定的套接字变成监听套接字
    listen(sockmsg,2);
    do  
    {
        datasock = accept(sock,(structsockaddr*)0,(int*)0);//接受请求
        msgsock =accept(sockmsg,(struct sockaddr*)0,(int*)0);
        if (datasock ==-1||msgsock==-1)
            perror("accept");
        else
        {
            if((child=fork())==-1)//创建子进程
            {
                  printf("Fork Error!\n");
            }
            //The child process
            if(child==0)
            {
                  printf("connection accepted! new clientcomming\n");
loop:
                  memset(client_cmd,0,sizeof(client_cmd));
                  rval=0;
                  rval=read(msgsock,client_cmd,sizeof(client_cmd));//从msgsock中读取数据到client_cmd
 
                  if(rval<0)
                  {
                        perror("reading command failed\n");
                  }
                  else if(rval==0)
                  {
                        printf("connection closed.\n");
                        close(datasock);//关闭套接字
                        close(msgsock);
                  }
                  else
                  {
                        if(strcmp(client_cmd,"pwd")==0)
                        {
                              printf("cmmand pwd\n");
                              cmd_pwd(datasock);
                              printf("done\n\n");
                              goto loop;
                        }
                        else if(strcmp(client_cmd,"dir")==0)
                        {
                              printf("command dir\n");
                              cmd_dir(datasock);
                              printf("done\n\n");
                              goto loop;
                        }
                        else if(strcmp(client_cmd,"cd")==0)
                        {
                              printf("command cd\n");
                              //read the argument
                              memset(cmd_arg,0,sizeof(cmd_arg));
                              read(msgsock,cmd_arg,sizeof(cmd_arg));
                              cmd_cd(datasock,cmd_arg);
                              printf("done\n\n");
                              goto loop;
                        }
                        else if(strcmp(client_cmd,"cd..")==0)
                        {
                              printf("command cd..\n");
                              cmd_cdback(datasock);
                              printf("done\n\n");
                              goto loop;
                        }
                        else if(strcmp(client_cmd,"get")==0)
                        {
                              printf("command get\n");
 
                              memset(cmd_arg,0,sizeof(cmd_arg));
                              read(msgsock,cmd_arg,sizeof(cmd_arg));
                              cmd_get(datasock,cmd_arg);
                              printf("done\n\n");
                              goto loop;
                        }
                        else if(strcmp(client_cmd,"put")==0)
                        {
                              printf("command put\n");
 
                              memset(cmd_arg,0,sizeof(cmd_arg));
                              read(msgsock,cmd_arg,sizeof(cmd_arg));
                              cmd_put(datasock,cmd_arg);
                              printf("done\n\n");
                              goto loop;
                        }
                        else if(strcmp(client_cmd,"?")==0)
                        {
                              printf("command ?\n");

                              cmd_help(datasock);
                              printf("done\n\n");
                              goto loop;
                        }
                        else if(strcmp(client_cmd,"quit")==0)
                        {
                              printf("quit\n");
                              goto endchild;
                        }
                        else  
                        {
                              printf("bad request!\n");
                              goto loop;
                        }
                  }
endchild:
                  printf("connection closed.\n");
                  close(datasock);
                  close(msgsock);
                  exit(0);
            }
             
        }
    }while(TRUE);
 
    exit(0);
}

//pwd command
void cmd_pwd(int sock)
{
      intlen;
      memset(currentDirPath,0,sizeof(currentDirPath));
      getcwd(currentDirPath,sizeof(currentDirPath));
      char*savePointer=getDirName(currentDirPath);
      strcpy(currentDirName,savePointer);
      len=strlen(currentDirName)+1;
      write(sock,currentDirName,len);
}

//dir command
void cmd_dir(int sock)
{
      DIR *pdir;//目录结构
      charfileName[30];
      charfileInfo[50];
      int i,fcounts=0, len;
      structdirent *pent;//目录的结构体属性
      intfd;
      struct statfileSta;//文件属性
      charfilePath[200];
     
      pdir=opendir(currentDirPath);//打开目录
      pent=readdir(pdir);//读取目录
     
      while(pent!=NULL)
      {
            fcounts++;//计算文件个数
            pent=readdir(pdir);
      }

      write(sock,&fcounts,sizeof(int));//将文件个数写入sock
      closedir(pdir);//关闭目录

      if(fcounts<=0)
      {
            return;
      }
      else
      {
            pdir=opendir(currentDirPath);
            for(i=0;i<fcounts;i++)
            {
                  pent=readdir(pdir);
                  memset(fileName,0,30);
                  memset(fileInfo,0,sizeof(fileInfo));
                  strcpy(fileName,pent->d_name);
                 
                  //check the file is a directory or a file
                  memset(filePath,0,sizeof(filePath));
                  strcpy(filePath,currentDirPath);
                  strcat(filePath,"/");//链接两个字符串
                  strcat(filePath,fileName);
                  fd=open(filePath,O_RDONLY, S_IREAD);
                 
                  fstat(fd,&fileSta);//用来读取打开的文件的属性，stat用来读取没有打开的文件的属性
                  if(S_ISDIR(fileSta.st_mode))//判断文件是否为目录
                  {
                        strcat(fileInfo,"dir\t");
                        strcat(fileInfo,fileName);
                  }
                  else
                  {     
                        strcat(fileInfo,"file\t");
                        strcat(fileInfo,fileName);
                  }
                  write(sock,fileInfo,sizeof(fileInfo));
            }
            closedir(pdir);
      }
     
     
}

//command cd
void cmd_cd(int sock,char *dirName)
{
      DIR*pdir;
      structdirent *pent;
      charfilename[30];
      inti,fcounts=0;
      intflag=0;

      pdir=opendir(currentDirPath);
      pent=readdir(pdir);
     
      while(pent!=NULL)
      {
            fcounts++;
            pent=readdir(pdir);
      }

      closedir(pdir);

      if(fcounts<=0)
      {
            return;
      }
      else
      {
            pdir=opendir(currentDirPath);
            for(i=0;i<fcounts;i++)
            {
                  pent=readdir(pdir);
                  if(strcmp(pent->d_name,dirName)==0)
                  {
                        strcat(currentDirPath,"/");
                        strcat(currentDirPath,dirName);
                        flag=1;
                        break;
                  }
            }
           
            if(flag==1)
            {
                  write(sock,currentDirPath,sizeof(currentDirPath));
            }
            closedir(pdir);
      }
     
     
}

//command cd..
void cmd_cdback(int sock)
{
      intlen;
      int i,record;

      len=strlen(currentDirPath);
     
      for(i=len-1;i>=0;i--)
      {
            if(currentDirPath[i]=='/')
            {
                  currentDirPath[i]='\0';
                  break;
            }
            currentDirPath[i]='\0';
      }
}
//command ?
void cmd_help(int sock)
{
      intlen=strlen(help)+1;
      write(sock,help,len);
}

//command get
void cmd_get(int sock,char*fileName)
{
      intfd;
      struct statfileSta;
      longfileSize;
      charfilePath[200], buf[dataLen];
     
      memset(filePath,0,sizeof(filePath));
      strcpy(filePath,currentDirPath);
      strcat(filePath,"/");
      strcat(filePath,fileName);

      fd=open(filePath,O_RDONLY, S_IREAD);
      if(fd!=-1)
      {
            fstat(fd,&fileSta);
            fileSize=(long) fileSta.st_size;//？
            write(sock,&fileSize,sizeof(long));
            memset(buf,0,dataLen);
            while(fileSize>dataLen)
            {
                  read(fd,buf,dataLen);
                  write(sock,buf,dataLen);
                  fileSize=fileSize-dataLen;
            }
           
            read(fd,buf,fileSize);
            write(sock,buf,fileSize);
            close(fd);
            printf("transfer completed\n");
      }
      else
      {
            printf("open file %s failed\n",filePath);
      }     
}

//command put
void cmd_put(int sock,char *fileName)
{     
      intfd;
      longfileSize;
     
      charfilePath[200], buf[dataLen];
      strcpy(filePath,currentDirPath);
      strcat(filePath,"/");
      strcat(filePath,fileName);
     

      fd=open(filePath,O_RDWR|O_CREAT,S_IREAD|S_IWRITE);
      if(fd!=-1)
      {     
            memset(buf,0,dataLen);
            read(sock,&fileSize,sizeof(long));

            while(fileSize>dataLen)
            {
                  read(sock,buf,dataLen);
                  write(fd,buf,dataLen);
                  fileSize=fileSize-dataLen;
            }
           
            read(sock,buf,fileSize);
            write(fd,buf,fileSize);
            close(fd);
            printf("transfer completed\n");
      }
      else
      {
            printf("open file %s failed\n",filePath);
      }
     
}

//get the last string after the last char '/'
char *getDirName(char *dirPathName)
{
      int i, pos,len;
      char*dirName;

      if(dirPathName==NULL)
      {
            printf("directory absoultly path isnull!\n");
            return NULL;
      }     
     
      len=strlen(dirPathName);
      for(i=len-1;i>=0;i--)
      {
            if(dirPathName[i]=='/')
            {
                  pos=i;
                  break;
            }
      }
     
      dirName=(char *)malloc(len-pos+1);
      for(i=pos+1;i<len;i++)
      {
            dirName[i-pos-1]=dirPathName[i];     
      }
     
      returndirName;
}
客户端实现：
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>

#define TRUE 1
#define dataLen 1024
char user_cmd[10],cmd_arg[20];
char buf[dataLen];

void cmd_pwd(int sock,int sockmsg);
void cmd_dir(int sock,int sockmsg);
void cmd_cd(int sock,int sockmsg,char *dirName);
void cmd_cdback(int sock,int sockmsg);
void cmd_help(int sock,int sockmsg);
void cmd_get(int sock,int sockmsg,char *fileName);
void cmd_put(int sock,int sockmsg,char *fileName);
void cmd_quit(int sock,int sockmsg);
 
int main(int argc,char *argv[])
{
  int cmd_len,arg_len;
  int sock, sockmsg;
  struct sockaddr_in server, servermsg;
  struct hostent *hp;
   
  sock=socket(AF_INET,SOCK_STREAM,0);
  sockmsg=socket(AF_INET,SOCK_STREAM,0);
       
  if(sock<0||sockmsg<0)
  {
      perror("opening stream socket");
      exit(1);
  }
 
  hp = gethostbyname(argv[1]);
  if (hp==0)
  {
      fprintf(stderr,"%s:unknown host\n",argv[1]);
      exit(2);
  }
 
  server.sin_family=AF_INET;
  server.sin_port=htons(atoi(argv[2]));
  memcpy((char*)&server.sin_addr,(char*)hp->h_addr,hp->h_length);
 
  servermsg.sin_family=AF_INET;
  servermsg.sin_port=htons(atoi(argv[2])+1);
  memcpy((char*)&servermsg.sin_addr,(char*)hp->h_addr,hp->h_length);
 
  if (connect(sock,(struct sockaddr*)&server,sizeofserver)<0||connect(sockmsg,(struct sockaddr*)&servermsg,sizeofservermsg)<0)
  {
        perror("connecting stream socket");
      exit(1);
  }
 
 
  //Get command from command line and do just theaction
  while(TRUE)
  {
      memset(user_cmd,0,10);
      memset(cmd_arg,0,20);

      //First getthe input character by user
      printf("command: ");
      scanf("%s",user_cmd);
      cmd_len=strlen(user_cmd);
      //Then getthe command character and the argument
      if(strcmp(user_cmd,"quit")==0)            //command"quit"
      {
            cmd_quit(sock,sockmsg);
            close(sockmsg);
            close(sock);
            printf("connection closed\n\n");
            exit(0);
      }       
      elseif(strcmp(user_cmd,"?")==0)        //command"?"
      {
            cmd_help(sock,sockmsg);
      }
      elseif(strcmp(user_cmd,"pwd")==0)      //command"pwd"
      {
            cmd_pwd(sock,sockmsg);
      }
      elseif(strcmp(user_cmd,"dir")==0)        //command"dir"
      {
            cmd_dir(sock,sockmsg);
      }
      elseif(strcmp(user_cmd,"cd")==0)      //commad "cd"
      {
            //inputcommand argument
            scanf("%s",cmd_arg);
            cmd_cd(sock,sockmsg,cmd_arg);
      }
      elseif(strcmp(user_cmd,"cd..")==0)
      {
            cmd_cdback(sock,sockmsg);
      }
      elseif(strcmp(user_cmd,"get")==0)      //command "get"
      {
            //inputcommand argument
            scanf("%s",cmd_arg);
            cmd_get(sock,sockmsg,cmd_arg);
      }
      elseif(strcmp(user_cmd,"put")==0)      //command "put"
      {     
            //inputcommand argument
            scanf("%s",cmd_arg);
            cmd_put(sock,sockmsg,cmd_arg);
      }
      else
      {
            printf("badcommand!\n");
      }
  } 
 
}

//command pwd
void cmd_pwd(int sock,int sockmsg)
{
      //intnumRead;
      chardirName[30];
      write(sockmsg,user_cmd,sizeof(user_cmd));
      read(sock,dirName,30);
      printf("%s\n",dirName);
}

//command dir
void cmd_dir(int sock, int sockmsg)
{
      int i,fileNum=0;
      charfileInfo[50];
     
      write(sockmsg,user_cmd,sizeof(user_cmd));
      read(sock,&fileNum,sizeof(int));

      printf("--------------------------------------------------------\n");
      printf("filenumber : %d\n",fileNum);
      if(fileNum>0)
      {
            for(i=0;i<fileNum;i++)
            {
                  memset(fileInfo,0,sizeof(fileInfo));
                  read(sock,fileInfo,sizeof(fileInfo));
                  printf("%s\n",fileInfo);
            }
            printf("--------------------------------------------------------\n");
      }
      elseif(fileNum==0)
      {
            printf("directory of server point is empty.\n");
            return;
      }
      else
      {
            printf("error in command 'dir'\n");
            return;
      }
}

//command cd
void cmd_cd(int sock,int sockmsg,char *dirName)
{
      charcurrentDirPath[200];
      write(sockmsg,user_cmd,sizeof(user_cmd));
      write(sockmsg,cmd_arg,sizeof(cmd_arg));
      read(sock,currentDirPath,sizeof(currentDirPath));
     
      printf("nowin directory : %s\n",currentDirPath);
}

//command cd..
void cmd_cdback(int sock,int sockmsg)
{
      write(sockmsg,user_cmd,sizeof(user_cmd));     
}
//command quit
void cmd_quit(int sock,int sockmsg)
{
      write(sockmsg,user_cmd,sizeof(user_cmd));
}

//command help
void cmd_help(int sock, int sockmsg)
{
      charhelp[300];
      write(sockmsg,user_cmd,sizeof(user_cmd));
      read(sock,help,300);
     
      printf("%s\n",help);     
}

//command get
void cmd_get(int sock,int sockmsg,char *fileName)
{
      intfd;
      longfileSize;
      charlocalFilePath[200];

      write(sockmsg,user_cmd,sizeof(user_cmd));
      write(sockmsg,cmd_arg,sizeof(cmd_arg));
      printf("%s\n%s\n",user_cmd,cmd_arg);
     
      memset(localFilePath,0,sizeof(localFilePath));
      getcwd(localFilePath,sizeof(localFilePath));
      strcat(localFilePath,"/");
      strcat(localFilePath,fileName);

      fd=open(localFilePath,O_RDWR|O_CREAT, S_IREAD|S_IWRITE);
      if(fd!=-1)
      {     
            memset(buf,0,dataLen);
            read(sock,&fileSize,sizeof(long));
            while(fileSize>dataLen)
            {
                  read(sock,buf,dataLen);
                  write(fd,buf,dataLen);
                  fileSize=fileSize-dataLen;
            }
           
            read(sock,buf,fileSize);
            write(fd,buf,fileSize);
            close(fd);
            printf("download completed\n");
      }
      else
      {
            printf("openfile %s failed\n",localFilePath);
      }
}

//command put
void cmd_put(int sock,int sockmsg,char* fileName)
{     
      write(sockmsg,user_cmd,sizeof(user_cmd));
      write(sockmsg,cmd_arg,sizeof(cmd_arg));
     
      intfd;
      longfileSize;
      intnumRead;
      charfilePath[200];
      struct statfileSta;

      memset(filePath,0,sizeof(filePath));
      getcwd(filePath,sizeof(filePath));
     
      strcat(filePath,"/");
      strcat(filePath,fileName);
     
      fd=open(filePath,O_RDONLY, S_IREAD);

      if(fd!=-1)
      {
            fstat(fd,&fileSta);
            fileSize=(long) fileSta.st_size;

            write(sock,&fileSize,sizeof(long));
            memset(buf,0,dataLen);
            while(fileSize>dataLen)
            {
                  read(fd,buf,dataLen);
                  write(sock,buf,dataLen);
                  fileSize=fileSize-dataLen;
            }
           
            read(fd,buf,fileSize);
            write(sock,buf,fileSize);
            close(fd);
            printf("upload completed\n");
      }
      else
      {
            printf("openfile %s failed\n",filePath);
      }     
}