socket(TCP)----ftp服务器

实现功能：ls—查看服务端文件

                   lls—查看本地文件

                   lcd---进入客户端文件

                   cd--进入服务端文件

                   get--下载文件

                    put--上传文件

服务端代码：

server.c

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

int get_cmd_type(char *cmd)
{
        //int strcmp(const char *s1, const char *s2);
        //当s1<s2时，返回为负数；
        //当s1=s2时，返回值= 0；
        //当s1>s2时，返回正数。
        //char *strstr(const char *haystack, const char *needle);
        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," ");
        p = strtok(NULL," ");

        return p;
}

void msg_handle(struct MSG msg,int fd)
{
        char dataBuf[128] = {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 * popen ( const char * command , const char * type );
                        FILE *r = popen(msg.data,"r");
                        //size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
                        /*ptr -- 这是指向带有最小尺寸 size*nmemb 字节的内存块的指针。
                        size -- 这是要读取的每个元素的大小，以字节为单位。
                        nmemb -- 这是元素的个数，每个元素的大小为 size 字节。
                        stream -- 这是指向 FILE 对象的指针，该 FILE 对象指定了一个输入流
                        */
                        fread(msg.data,sizeof(msg.data),1,r);
                        write(fd,&msg,sizeof(msg));
                        break;
                case CD:
                        msg.type =  1;
                        char *dir = getDesDir(msg.data);
                        printf("dir: %s\n",dir);
                        chdir(dir);
                        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;

        struct MSG msg;
        struct sockaddr_in s_addr;
        struct sockaddr_in c_addr;


        memset(&s_addr,0,sizeof(struct sockaddr_in));
        memset(&c_addr,0,sizeof(struct sockaddr_in));

        if(argc!=3){
                printf("param is not good\n");
                exit(-1);
        }

        //1.socket         //int socket(int domain, int type, int protocol);

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

        s_addr.sin_family = AF_INET;//协议
        s_addr.sin_port = htons(atoi(argv[2]));//字节序转换  端口号

        //int inet_aton(const char *cp, struct in_addr *inp);
        inet_aton(argv[1],&s_addr.sin_addr);//字符串ip地址转换成网络序列ip地址

        //2.bind

        //int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)；

        bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));

        //3.listen

        //int listen(int sockfd, int backlog);
        listen(s_fd,10);

        //4.accept
        //int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); 
        int clen = sizeof(struct sockaddr_in);

        while(1){
                c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&clen);
                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));
                                //ssize_t read(int fd, void *buf, size_t count);
                                n_read = read(c_fd,&msg,sizeof(msg));
                                if(n_read==0){
                                        printf("client out \n");
                                        break;
                                }else if(n_read>0){
                                        msg_handle(msg,c_fd);
                                }
                        }
                }
        }

        //5.read

        //6.write

        close(c_fd);
        close(s_fd);

        return 0;
}

客户端代码:

client.c

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


char *getdir(char *cmd)
{
        char *p;

        p = strtok(cmd," ");//char * strtok （char * str，const * sep）sep的参数是个字符串，定义了用作分隔符的字
符集合
//str指定一个字符串，它包含了一个或多个sep中分隔符分割的标记
//strtok函数会找到str中的分隔符标记，并将其换成\0，返回该字符串的首地址(strtok会改变被操作的字符串)
//strtok函数的第一个参数不为NULL，函数将找到str中第一个被分割的字符串，同时strtok还会记住该分割符的位置
//strtok函数的第一个参数为NULL，函数将在之前strtok记住的分隔符的位置开始，查找下一个标记
//如果字符串中不存在更多的分隔符标记，则返回NULL
        p = strtok(NULL," ");

        return p;
}

int get_cmd_type(char *cmd)
{
        if(strstr(cmd, "lcd"))  return LCD;
        if(!strcmp("quit",cmd)) return QUIT;
        if(!strcmp("ls",cmd))   return LS;
        if(!strcmp("lls",cmd))  return LLS;
        if(!strcmp("pwd",cmd))  return PWD;

        if(strstr(cmd,"cd"))    return CD;
        if(strstr(cmd,"get"))   return GET;
        if(strstr(cmd,"put"))   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 CD:
                case PWD:
                        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){//nt access(const char *pathname, int mode);
//此函数是用来获得调用进程对pathname所指向的文件(regular)或者是目录(directory)的访问权限。
//pathname: 文件或者是目录路径
//mode:访问模式。R_OK   检验调用进程是否有读访问权限
//W_OK   检验调用进程是否有写访问权限
//X_OK   检验调用进程是否有执行访问权限
//F_OK   检验规定的文件是否存在
                                printf("%s not exit\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);//int chdir(const char *path)

                                //函数说明：将当前的工作目录改变成以参数path所指的目录。

                                //返回值：执行成功则返回0，失败返回-1，errno为错误代码。
                        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("param is not good \n");
                exit(-1);
        }
        //1.socket
        c_fd = socket(AF_INET,SOCK_STREAM,0);
        if(c_fd==-1){
                perror("socket");
                exit(-1);
        }


        c_addr.sin_family = AF_INET;
        c_addr.sin_port = htons(atoi(argv[2]));
        inet_aton(argv[1],&c_addr.sin_addr);

        //2.connect       
        //int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
        if(connect(c_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr))==-1){
                perror("connect");
                exit(-1);
        }
        printf("connect .....\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);//fflush(stdout)：清空输出缓冲区，并把缓冲区内容输出。
                        continue;
                }



/*头文件：#include<stdio.h>
 
定义函数：int fflush(FILE * stream);
函数说明：fflush()会强迫将缓冲区内的数据写回参数stream指定的文件中，如果参数stream为NULL，fflush()会将所有打开的文件数据更新。
返回值：成功返回0，失败返回EOF，错误代码存于errno中。
fflush()也可用于标准输入（stdin）和标准输出（stdout），用来清空标准输入输出缓冲区。
stdin是standard input的缩写，即标准输入，一般是指键盘；标准输入缓冲区即是用来暂存从键盘输入的内容的缓冲区。stdout是standard output 的缩写，即标准输出，一般是指显示器；标准输出缓冲区即是用来暂存将要显示的内容的缓冲区。
 
 
清空标准输出缓冲区，
刷新输出缓冲区，即将缓冲区的东西输出到屏幕上 
如果圆括号里是已写打开的文件的指针，则将输出缓冲区的内容写入该指针指向的文件，否则清除输出缓冲区。
这里的stdout是系统定义的标准输出文件指针，默认情况下指屏幕，那就是把缓冲区的内容写到屏幕上。
*/


                if(ret == -1){
                        printf("command not\n");
                        printf(">");
                        fflush(stdout);
                        continue;
                }

                handler_server_message(c_fd,msg);
        }

        //3.write

        //4.read

        //5.close
        return 0;
}

定义宏文件：

config.h

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

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

#define QUIT 8
#define IFGO 3
#define DOFILE 9

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