Linux文件服务站（C语言）

最新推荐文章于 2022-06-24 11:21:50 发布
最新推荐文章于 2022-06-24 11:21:50 发布
阅读量586 收藏 3
点赞数
分类专栏： C语言学习 Linux 网络编程笔记
生活会辜负努力的人，但不会辜负一直努力的人——Leo的个人博客。
本文链接：https://blog.csdn.net/zouchengzhi1021/article/details/113668089
版权

服务端代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
#define LS      0
#define PWD     1
#define GET     2
#define CD      3
 
#define IFGO    4
 
#define LLS     5
#define LCD     6
#define PUT     7
#define QUIT    8
#define DOFILE  9
 
struct msg
{
    int type;
    char cmd[1024];        //存放命令和文件数据
    char secondBuf[1024];   //存放文件内容
};
 
int get_cmd_type(char* cmd)//把字符串转成整型数
{
        //int strcmp(const char *s1, const char *s2);//字符串比较
        if(strcmp("ls",cmd) == 0)         return LS;
        if(strcmp("quit",cmd) == 0)       return QUIT;
        if(strcmp("pwd",cmd) == 0)        return PWD;
        //char *strstr(const char *haystack, const char *needle);//搜索一个字符串在另一个字符串中的第一次出现
        if(strstr(cmd,"cd") != NULL)      return CD;
        if(strstr(cmd,"get") != NULL)     return GET;
        if(strstr(cmd,"put") != NULL)     return PUT;
 
        return 250;
}
 
char* get_dir(char* cmd)//分割字符串
{
        char* fp;
        //char *strtok(char *s, char *delim)//分解字符串 str 为一组字符串，delim 为分隔符,返回值：分隔符匹配到的第一个子串
        fp=strtok(cmd,"|");
        fp=strtok(NULL,"|");
        return fp;
}
 
void msgs_Handler(struct msg msgs,int cfd)
{
        int ret;
        char* filename=NULL;
        int fdfile;
        FILE* fp=NULL;
        char* dir=NULL;
 
        char dataBuf[1024]={"\0"};
 
        ret=get_cmd_type(msgs.cmd);//把字符串转成整型数
 
        printf("cmd:%s\n",msgs.cmd);//打印客户端输出的指令      
        printf("ret:%d\n",ret);
 
        switch(ret)
        {
                case PWD:
                case LS:
                        //FILE *popen(const char *command, const char *type);
                        fp=popen(msgs.cmd,"r");
                        fread(msgs.cmd,sizeof(msgs.cmd),1,fp);
                        write(cfd,&msgs,sizeof(msgs));
                        break;
 
                case CD:
                        dir=get_dir(msgs.cmd);//通过该函数获取文件名字
                        printf("dir:%s\n",dir);
                        //int chdir(const char *path)//改变当前工作目录
                        chdir(dir);//dir目录，ch,change,改变
                        break;
 
                case GET:
                        filename=get_dir(msgs.cmd);//获取要操作的文件名(即指令后面的文件名字)
                        //int access(const char* pathname, int mode);//F_OK 值为0，判断文件是否存在
                        if(access(filename,F_OK) == -1)//判断该文件是否存在
                        {
                                strcpy(msgs.cmd,"No this file!");
                                write(cfd,&msgs,sizeof(msgs));
                        }
                        else
                        {
                        //      msgs.type = DOFILE;
                                fdfile=open(filename,O_RDWR);//存在文件就打开文件
                                read(fdfile,dataBuf,sizeof(dataBuf));//读取信息
                                close(fdfile);//关闭文件
 
                                strcpy(msgs.cmd,dataBuf);//将读取的内容复制到cmd数组
                                write(cfd,&msgs,sizeof(msgs));//将读取的内容发送到客户端                        
                                //close(fdfile);//关闭文件
                        }
                                break;
                case PUT:
                        filename=get_dir(msgs.cmd);//获取文件名称
                        fdfile=open(filename,O_RDWR|O_CREAT,0666);//有就打开文件，没有就创建文件
                        write(fdfile,msgs.secondBuf,strlen(msgs.secondBuf));//写内容到目标文件
                        close(fdfile);
                        break;
 
                case QUIT:
                        printf("client quit!\n");
                        exit(-1);
                        break;
        }
 
}
 
int main(int argc,char** argv)
{
 
        if(argc != 3)//判断传入参数是否有三个
        {
                printf("program error!\n");
                exit(-1);
        }
 
        int sfd;
        int cfd;
        int nread;
        struct msg msgs;
 
        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));
 
        //1.socket//创建套接字
        //int socket(int domain, int type, int protocol);
 
        sfd=socket(AF_INET,SOCK_STREAM,0);
        if(sfd == -1)//判断是否创建成功
        {
                perror("socket");
                exit(-1);
        }
 
        //2.bind//绑定IP号及端口
        //int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
 
        s_addr.sin_family=AF_INET;//协议族
        s_addr.sin_port=htons(atoi(argv[2]));//返回网络字节序的值
        inet_aton(argv[1],&s_addr.sin_addr);//把字符串形式的IP转换为网络能识别的格式
 
        int nbind=bind(sfd,(struct sockaddr*)&s_addr,sizeof(struct sockaddr_in));
        if(nbind == -1)
        {
                perror("bind");
                exit(-1);
        }
        //3.lieten 监听
        // int listen(int sockfd, int backlog);
 
        int nlisten=listen(sfd,10);
        if(nlisten == -1)
        {
                perror("listen");
                exit(-1);
        }
        //4.accept 连接
        //int accept(int sockfd,struct sockaddr *addr,socklen_t *addrlen);
        int len=sizeof(struct sockaddr_in);
                while(1){
                        cfd=accept(sfd,(struct sockaddr*)&c_addr,&len);
                        if(cfd == -1)
                        {
                                perror("accept");
                                exit(-1);
                        }
                        printf("connect success:%s\n",inet_ntoa(s_addr.sin_addr));//打印连接的地址
                        if(fork() == 0){//一个子进程负责一条连接通道
                                while(1){
                                        //5.recv 接受数据
                                        // ssize_t recv(int sockfd, void *buf, size_t len, int flags);//与read功能类似
                                        //ssize_t read(int fd, void *buf, size_t count);
                                        memset(&msgs.cmd,'\0',sizeof(msgs.cmd));
                                        nread=read(cfd,&msgs,sizeof(msgs));
                                        if(nread == 0){//没有读到数据
                                                printf("client out!\n");
                                                exit(-1);
                                        }
                                        else if(nread > 0)//读到可用数据
                                        {
                                                msgs_Handler(msgs,cfd);//处理接受的数据指令
                                        }
                                }
                        }
                }
                return 0;
}

客户端代码 ：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/msg.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <pthread.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <arpa/inet.h>
 
#define LS      0
#define PWD     1
#define GET     2
#define CD      3
 
#define IFGO    4
 
#define LLS     5
#define LCD     6
#define PUT     7
#define QUIT    8
#define DOFILE  9
 
struct msg
{
    int type;
    char cmd[1024];        //存放命令和文件数据
    char secondBuf[1024];   //存放文件内容
};
 
int get_cmd_type(char* cmd)//把字符串转换成整形数
{
        //char *strstr(const char *haystack, const char *needle);//搜索一个字符串在另一个字符串中的第一次出现
        if(strcmp(cmd,"ls")  == 0)        return LS;
        if(strcmp(cmd,"lls")  == 0)       return LLS;
        if(strcmp(cmd,"pwd")  == 0)       return PWD;
        if(strcmp(cmd,"quit") == 0)      return QUIT;
        //char *strstr(const char *haystack, const char *needle);//搜索一个字符串在另一个字符串中的第一次出现
        if(strstr(cmd,"get") != NULL)    return GET;
        if(strstr(cmd,"put") != NULL)     return PUT;
        if(strstr(cmd,"cd")  != NULL)      return CD;
        if(strstr(cmd,"lcd") != NULL)     return LCD;
        return -1;
}
 
char* getdir(char* cmd)
{
        char* fp;
        //char *strtok(char *s, char *delim)//分解字符串 str 为一组字符串，delim 为分隔符,返回值：分隔符匹配到的第一个子串
        fp=strtok(cmd,"|");
        fp=strtok(NULL,"|");
        return fp;
}
 
int cmd_Handler(struct msg msgs,int cfd)
{
        int ret;
        int fdfile;
        char* dir=NULL;
        //char buf[32];
 
        ret=get_cmd_type(msgs.cmd);//将字符串转换成整形数
        printf("ret:%d\n",ret);
        switch(ret)
        {
                case PWD:
                case LS:
                case CD:
                        write(cfd,&msgs,sizeof(msgs));
                        break;
 
                case GET:
                        write(cfd,&msgs,sizeof(msgs));
                        break;
 
                case PUT:
                        //strcpy(buf,msgs.cmd);
                        dir=getdir(msgs.cmd);
                        if(access(dir,F_OK) == -1)
                        {
                                printf("%s not exist\n",dir);
                        }
                        else
                        {
                                fdfile=open(dir,O_RDWR);
                                read(fdfile,msgs.secondBuf,sizeof(msgs.secondBuf));
 
                                write(cfd,&msgs,sizeof(msgs));
                                close(fdfile);
                        }
                        break;
 
                case LCD:
                        //printf("LCDsucess!\n");//调试信息
                        dir=getdir(msgs.cmd);
                        if(access(dir,F_OK) == -1)
                        {
                                printf("No this file!\n");
                        }
                        else
                        {
                                chdir(dir);
                        }
                        break;
 
                case LLS:
                        //printf("999999\n");
                         system("ls");
                         break;
 
                case QUIT:
                        //strcpy(msgs.cmd,"quit");
                        write(cfd,&msgs,sizeof(msgs));
                        close(cfd);
                        exit(-1);
                        break;
 
    }
                return ret;
 }
 
void handler_server_message(int cfd,struct msg msgs)
{
        int nread;
        int fd;
        struct msg msgget;
 
        nread=read(cfd,&msgget,sizeof(msgget));//读取服务端传来的数据
 
        if(nread == 0)
        {
                perror("server out!\n");;
                exit(-1);
        }
 
        else if(msgget.type == DOFILE)
        {
                char* p=getdir(msgs.cmd);
                fd= open(p,O_RDWR|O_CREAT,0600);
                write(fd,msgget.cmd,strlen(msgget.cmd));
                close(fd);
                putchar('>');
                fflush(stdout);
        }
        else
        {
                printf("------------------------\n");
                printf("\n%s\n",msgget.cmd);
                printf("------------------------\n");
 
                fflush(stdout);
                putchar('>');
        }
}
int main(int argc,char** argv)
{
 
        int cfd;
        int ret;
        struct msg msgs;
 
        struct sockaddr_in c_addr;
        memset(&c_addr,'\0',sizeof(c_addr));
 
        if(argc != 3)//判断传入参数是否有三个
        {
                printf("program error!\n");
                exit(-1);
        }
 
        //1.socket//创建套接字
        //int socket(int domain, int type, int protocol);
        cfd=socket(AF_INET,SOCK_STREAM,0);
        if(cfd == -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);//把字符串形式的IP转换为网络能识别的格式
 
        //2.connect 连接//客户连接主机
        //int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
        int nconnect=connect(cfd,(struct sockaddr*)&c_addr,sizeof(struct sockaddr_in));
        if(nconnect == -1)
        {
                perror("connect");
                exit(-1);
        }
 
        printf("connect......\n");
 
        for(;;){
                memset(msgs.cmd,0,sizeof(msgs.cmd));//初始化数组
 
                scanf("%s",msgs.cmd);//获取用于输入
 
                ret=cmd_Handler(msgs,cfd);//对输入信息进行处理,返回对应指令的值
 
                if(ret > IFGO)//过滤错误信息
                {
                        putchar('>');
                        fflush(stdout);
                        continue;
                }
 
                if(ret == -1)
                {
                        printf("command not\n");
                        printf(">");
                        fflush(stdout);
                        continue;
                }
 
                handler_server_message(cfd,msgs);//操作服务器传递过来的数据
        }
        return 0;
}

在这里插入图片描述

LEO-max
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言文件访问（Linux）
LYH2277的博客
04-23 517
在C语言中，操作系统会为每个文件分配一个结构体，记录该文件的信息，该结构体可以表示为： struct File { 缓冲区的位置（用来存放文件内容） 缓冲区中当前字符的位置 文件的读写状态 是否达到文件的结尾 ...... } 所以创建一个文件指针也可以说是创建一个该结构体的指针（以下都表述为文件指针）： File *fp; 可以用fopen函数来打开一个文件，其定义如下： ...
C语言制作web服务器(静态)
qq_43669302的博客
05-06 592
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <pthread.h> #include <sys/socket.h> #include <arpa/inet.h> #include <fcntl.h> #include &lt...
C++调用外部程序
善战者无赫赫之功 的专栏
10-20 1459
转载自：http://blog.csdn.net/eof_2011/article/details/7285604#关于三个SDK函数:WinExec， ShellExecute，CreateProcess的其他注意事项：【1】定义头文件必须定义以下两个头文件：#include <shlobj.h> //可替换为 windows.h #include <shellapi.h>//如果定义了头文
Linux-----进程
qq_42428154的博客
04-20 131
一、什么是进程 程序是指编译好的二进制文件，进程是运行着的程序。 区别在于：（1）程序占用磁盘，不占用系统资源，（2）进程占用内存，占用系统资源，（3）一个程序对应多个进程，一个进程对应一个程序，（4）程序没有生命周期，进程有生命周期 多道程序设计：出现多个进程一起执行的现象，这是因为每个进程都运行很短的时间，不断地重复这个过程，导致我们看起来多个进程是同时运行的。 MMU的作用：（1）负责虚拟地址和物理地址的映射，（2）对内存访问级别进行修改 PCB：进程控制模块 注意：下图中，两个用户空间总即使存在相
Linux环境下的C语言和shell编程
weixin_38849487的博客
06-24 1901
Linux编程
C语言编程: CreateProcess标准输出重定向到文件
07-23 818
说明:CreateProcess创建进程执行不支持简单的 > 符号重定向，system之类的函数执行外部进程可以使用 > 符号直接重定向到文件，但是system这类函数执行命令时，都会弹出控制台窗口，而CreateProcess创建执行进程可以设置属性隐藏这个控制台窗口，后台执行。 示例代码： int my_CreateProcess() { SECURITY_ATTRIBUTES sa; sa.nLength = sizeof(sa); sa.lpSecuri..
LinuxC_C语言_Linux/Unix编程_Dot._
10-02
在"压缩包子文件的文件名称列表"中，我们看到一个名为"LinuxC.pdf"的文件，这很可能就是上述教程的PDF版本，包含了关于Linux环境下的C语言编程的详细讲解，包括基本的C语法、Linux系统调用、文件操作、进程管理、...
Linux c语言编程一站式学习
12-25
除了这些技术层面的知识，理解Linux文件系统结构、系统调用机制以及进程间通信（IPC）原理也非常重要。熟悉`man`手册页，它是获取Linux命令和函数详细信息的宝贵资源。 在实践中，编写C程序时应遵循良好的编程习惯...
C代码版本的HTTP POST上传文件/JSON
01-16
6. **错误处理**：在C语言实现中，必须充分考虑错误处理，例如网络连接失败、文件读取错误或服务器响应错误等。良好的错误处理机制能够确保程序的健壮性。 7. **内存管理**：由于C语言没有自动垃圾回收机制，程序员...
linux c一站式编程
11-23
《Linux C一站式编程》是一本面向初学者的指南，旨在帮助读者全面掌握在Linux环境下进行C语言编程的基础知识和高级技巧。这本书以HTML格式呈现，方便电子阅读和查阅。 Linux是一个开源的操作系统，它提供了丰富的...
Linux下C语言编程
04-18
在Linux下进行C语言编程，首先需要理解C语言的基本语法和特性，包括变量、数据类型、控制流语句、函数、指针等。C语言允许程序员直接访问内存，因此对内存管理有较高的自由度，但也需要谨防内存泄漏和野指针问题。 ...
C Primer Plus 第十三章 课后答案
asdgyy的博客
10-06 5765
目录   复习题 1.下面的程序有什么问题 2.下面的程序完成什么任务？（假设在命令行环境中运行） 3.假设程序中有下列语句： 另外，假设成功打开了两个文件。补全下面函数调用中缺少的参数： a.ch = getc(); b.fprintf( ,"%c\n", ); c.putc( , ); d.fclose(); /* 关闭terky文件 */ 4.编写一个程序，不接受任何命...
c语言系统编程八：Linux进程间通信之消息队列
qq_33808440的博客
06-21 2628
消息队列是消息的链表，存放在内存中，由内核维护； System V提供的IPC通信机制需要一个key值，通过key值就可以在系统内获得一个唯一的消息队列标识符。key值可以人工指定，也可以通过ftok函数获得 功能 参数 返回值 功能 参数 返回值 删除消息队列 3.4 消息队列的信息格式的定义 消息队列的信息格式是需要人工定义的，格式放在一个结构体中； 信息结构体中的第一个long型的成员的作用是，只有对这类信息感兴趣的进程才能拿到这类信息 功能 向消息队
字符串函数与内存函数的总结
weixin_48937110的博客
09-19 116
库函数的模拟实现 1.模拟实现strlen #include<stdio.h> #include<stdlib.h> #include<assert.h> size_t my_strlen( const char *str) { assert(str != NULL); if (*str == '\0')//递归结束标志 return 0; return (my_strlen(str+ 1)) + 1;//采用递归实现对字符串长度的计量 } int main() {
1|进程管理 linux l例子
weixin_43846020的博客
12-19 556
案例1：使用pipe()实现父子进程间通信，要求父进程作为写端，子进程作为读端。 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/types.h> #include <sys/wait.h> int main() { int fd[2];//定义文件描述符数组 int ret=pipe
学习C语言——学习笔记（1）
wzwpy99的博客
01-12 1217
1.预处理指令 预处理指令解释为由预处理器读入源码，然后根据预处理指令对其进行修改，最后将修改过后的源代码递交给编译器 以下5行都是预处理指令： #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_COLS 20 #define MAX_INPUT 1000 预处理指令的作用仿佛是将stdio.h的内容逐字写到源文件的位置，以上第二、三条指令的功能都类似，不同点在于二、三条替换
Linux 进程间通信编程
qq_46186025的博客
03-05 1250
Linux 进程间通信编程（单机）一、进程间通信概述二、管道通信（默认无名管道）1.创建无名管道函数pipe（）2.使用无名管道读取的代码练习三、命名管道1.创建有名管道函数mkfifo（）四、信号通信五、共享内存六、消息队列七、信号量 一、进程间通信概述 1、目的： 1）数据传输： 一个进程需要将它的数据发送给另一个进程 2）资源共享 多个进程之间共享同样的资源 3）通知事件 一个进程需要向另一个或一组进程发送消息，通知他们发生了某种事件 4）进程控制 有些进程希望完全控制另一个进程的执行，此时控制进程希
发生段错误后程序不崩溃
耿小渣的进阶之路
01-13 1142
一个段错误的例子： #include <stdio.h> #include <stdlib.h> #include <string.h> int main() { char *tmp = NULL; strcpy(tmp, "hello"); return 0; } 执行结果 加上段错误处理函数： #include <stdi...
Linux C编程全方位指南
"部分III.Linux系统编程"将C语言与Linux操作系统相结合，涵盖了文件与I/O操作、文件系统管理、进程控制、Shell脚本编写、正则表达式、信号处理、终端和守护进程、多线程以及TCP/IP网络编程的基础。通过这些章节，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

LEO-max

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值