FTP云盘（Linux阶段）

Linux网络编程的综合项目，是一个简易的类似FTP云盘服务器的功能，实现了客户端向服务端请求查看目录，进入指定目录，发送文件到服务端，得到服务端的文件，退出客户端连接等操作，实现了客户端和服务端的简单交互，记录学习嵌入式成长的过程，方便以后自己查看。

实现功能

ls：查看当前文件

lls：查看服务器文件

cd：服务器进入文件夹或返回上一级

lcd：本地进入文件夹或返回上一级

pwd：打印当前路径

get xxx ：得到服务端文件

put xxx ：发送文件到服务端

quit：退出

服务端

server.c

代码如下（示例）：

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include "config.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;
        //其他指令未定义，返回100表示未找到
        return 0;
}

//分割字符串
char *get_dir(char *cmsg)
{
        char *p;
        p = strtok(cmsg, " ");
        //再次调用时，cmsg应设置为NULL
        p = strtok(NULL, " ");
        return p;
}

//信息处理函数
void msg_handler(struct Msg msg, int fd)
{
        char dataBuf[1024] = {0};
        char *file = NULL;
        int fdfile;//文件描述符

        //msg.data为字符数组
        printf("The command requested by the client is: %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 = get_dir(msg.data);
                        printf("Switched to directory: %s\n",dir);
                        chdir(dir);
                        break;
                case GET://打印文件内容
                        msg.type = DOFILE;
                        file = get_dir(msg.data);

                        if(access(file, F_OK) == -1){
                                strcpy(msg.data, "The requested file does not exist!");
                                write(fd, &msg, sizeof(msg));
                        }else{
                                fdfile = open(file, O_RDWR);//打开文件，获取文件描述符
                                read(fdfile, dataBuf, sizeof(dataBuf));//将文件内容读取到dataBuf
                                close(fdfile);//关闭文件描述符，释放占用的资源
                                //将内容拷贝到msg.data然后写入到套接字描述符中
                                strcpy(msg.data, dataBuf);
                                write(fd, &msg, sizeof(msg));
                        }
                        break;
                case PUT://上传文件内容
                        fdfile = open(get_dir(msg.data), O_RDWR | O_CREAT, 0600);
                        write(fdfile, msg.secondBuf, strlen(msg.secondBuf));
                        close(fdfile);
                        break;
                case QUIT://退出
                        printf("The client has exited.\n");
                        printf("-----------------------------------------\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("Unqualified parameters!\n");
                exit(-1);
        }

        //初始化，清空
        memset(&s_addr, 0, sizeof(struct sockaddr_in));
        memset(&c_addr, 0, sizeof(struct sockaddr_in));

        //1.socket
        s_fd = socket(AF_INET, SOCK_STREAM, 0);//Ipv4 TCP协议
        if(s_fd == -1){
                printf("Ask for socket error!");
                exit(-1);
        }

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

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

        //3.listen
        listen(s_fd, 15);
        //4.accept
        int clen = sizeof(struct sockaddr_in);

        printf("Waiting for client connection ...\n");
        printf("-----------------------------------------\n");
        while(1){

                c_fd = accept(s_fd, (struct sockaddr *)&c_addr, &clen);

                if(c_fd == -1)
                        perror("Failed to establish connection!");

                        printf("Client connection succeed.\n");
                        printf("The IP address of the client is: %s\n",inet_ntoa(c_addr.sin_addr));
                        printf("-----------------------------------\n");

                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("This client has exit.\n");
                                        printf("---------------------------------------\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 <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include "config.h"


int get_cmd_type(char *cmd)//判断模拟指令类型
{
        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, "lcd"))          return LCD;
        if(strstr(cmd, "cd"))           return CD;
        if(strstr(cmd, "get"))          return GET;
        if(strstr(cmd, "put"))          return PUT;

        return -1;
}

char *get_dir(char *cmd)//分割字符串
{
        char *p;
        p = strtok(cmd, " ");
        //再次调用时候，cmsg应设置为NULL
        p = strtok(NULL, " ");
        return p;
}

int cmd_handler(struct Msg msg, int fd)//指令处理函数
{
        char *dir = NULL;
        char buf[32] = {0};
        int ret;
        int filefd;

        ret = get_cmd_type(msg.data);

        switch(ret){
                //输出当前文件列表
                case LS:
                case CD:
                case PWD:
                case GET:
                        msg.type = 0;
                        write(fd, &msg, sizeof(msg));
                        break;
                //上传文件内容
                case PUT:
                        strcpy(buf, msg.data);
                        dir = get_dir(buf);//分割字符串，得到文件名字符串
                        if(access(dir, F_OK) == -1){
                                printf("%s is not exsit.\n",dir);
                        }else{
                                filefd = open(dir, O_RDWR);
                                read(filefd, msg.secondBuf, sizeof(msg.secondBuf));//buf 不是secondBuf
                                close(filefd);

                                write(fd, &msg, sizeof(msg));
                        }
                        break;
                //输出当前文件列表
                case LLS:
                        printf("---------------------------------------\n\n");
                        system("ls");
                        printf("\n---------------------------------------\n");
                        break;
                //切换目录
                case LCD:
                        dir = get_dir(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 disconnected,quit!\n");
                exit(-1);
        }
        else if(msgget.type == DOFILE){ //GET指令，打印文件内容
                char *p = get_dir(msg.data);
                newfilefd = open(p, O_RDWR|O_CREAT, 0600);//0666
                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;

        if(argc != 3){
                printf("param is not good\n");
                exit(-1);
        }
        //初始化 清空 0
        memset(&c_addr, 0, sizeof(struct sockaddr_in));

        //1.socket
        c_fd = socket(AF_INET, SOCK_STREAM, 0);
        if(c_fd == -1){
                printf("Ask for socket error!");
                exit(-1);
        }

        //配置客户端IP地址和端口号
        c_addr.sin_family = AF_INET;
        c_addr.sin_port = htons(atoi(argv[2]));
        inet_aton(argv[1], &c_addr.sin_addr);

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

        //连接成功
        printf("Successfully connected to server.\n");
        printf("-----------------------------------\n");
        int mark = 0;

        //不断输出指令并处理指令
        while(1){
                memset(msg.data, 0, sizeof(msg.data));
                if(mark == 0) printf("> ");

                fgets(msg.data, sizeof(msg.data), stdin);

                msg.data[strlen(msg.data) - 1] = '\0';

                if(strlen(msg.data) == 0){
                        if(mark == 1) printf("> ");
                        continue;
                }
                mark = 1;

                //调用命令处理函数
                int ret = cmd_handler(msg, c_fd);
                if(ret > IFGO){
                        printf("> ");
                        fflush(stdout); //舒心出缓冲区
                        continue;
                }
                if(ret == -1){
                        printf("Sorry, the command you entered does not exist.\n");
                        printf("> ");
                        fflush(stdout);
                        continue;
                }

                //调用服务器信息处理函数
                handler_server_message(c_fd, msg);
        }

        close(c_fd);
        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];

};

运行结果展示

//服务器

gcc server.c -o server

./server 192.168.10.81 8900

//客户端

gcc client.c -o client

./client 192.168.10.81 8900

师承--抖音上官社长（上官可编程）