Linux网络编程 局域网文件共享工具开发

最新推荐文章于 2023-04-08 22:00:00 发布
最新推荐文章于 2023-04-08 22:00:00 发布
阅读量711 收藏 6
点赞数 2
分类专栏： 网络编程 文章标签： 网络 socket linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/captainljp/article/details/106731541
版权

在linux下，开发一个局域网文件共享工具，其实并不局限于局域网，只要是有ip地址和端口号（默认是5168），就能进行文件共享。
功能：

  • 客户端向服务端发送文件
    ./Client IP地址 send 文件名 //Client是编译后的文件名 自行更改
  • 客户端从服务器下载文件
    ./Client IP地址 download 文件名 //注意这里的文件名是服务端的
  • 客户端获取服务端的文件目录
    ./Client IP地址 ls

服务端启动方法
./Server //名字可自行更改

代码：
Client端

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>

#define PORT 5168
#define MSGLEN 1024

int Connect(char *addrname)
{
    int sockfd;
    struct sockaddr_in sevrAddr;
    struct hostent *host;
    host = gethostbyname(addrname);

    // 声明并初始化一个socket地址结构
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        perror("socket error");
        exit(-1);
    }
    else
        printf("socket ok\n");
    sevrAddr.sin_family = AF_INET;
    sevrAddr.sin_port = htons(PORT);
    sevrAddr.sin_addr = *((struct in_addr *)host->h_addr);
    bzero(&sevrAddr.sin_zero, 8);

    // 向服务器发起连接，连接成功后client_socket_fd代表了客户端和服务器的一个socket连接
    if (connect(sockfd, (struct sockaddr *)&sevrAddr, sizeof(struct sockaddr)) == -1)
    {
        perror("connect error");
        exit(-1);
    }
    else
        printf("connect ok\n");

    return sockfd;
}
void file_send(char *addrname, char *option, char *filename)
{
    int sockfd;
    FILE *fp;
    char readBuff[MSGLEN];
    char recv_filename[50];
    int len;

    //获取套接字
    sockfd = Connect(addrname);

    //发送send命令到服务端
    if (send(sockfd, option, sizeof(option), 0) < 0)
    {
        perror("send option error");
        exit(-1);
    }
    sleep(1);

    //发送文件名到服务端
    bzero(&recv_filename, sizeof(recv_filename));
    strcpy(recv_filename, filename);
    if (send(sockfd, recv_filename, sizeof(recv_filename), 0) < 0)
    {
        perror("send filename error");
        exit(-1);
    }
    sleep(1);

    fp = fopen(filename, "rb");
    if (fp != NULL)
    {
        printf("sending file");
        bzero(&readBuff, MSGLEN);
        while (1)
        {
            if ((len = fread(readBuff, 1, MSGLEN, fp)) > 0)
            {
                if (send(sockfd, readBuff, len, 0) < 0)
                {
                    perror("send error");
                    exit(-1);
                }
                else
                {
                    printf(".");
                    bzero(&readBuff, MSGLEN);
                }
            }
            else if (len == 0)
            { //等于0表示文件已到末尾
                printf("\nfile send success\n\n\n");
                fclose(fp);
                break;
            }
            else
            {
                perror("read error");
                exit(-1);
            }
        }
    }
    else
    {
        printf("open file failed\n");
    }
    close(sockfd);
}
void file_dowload(char *addrname, char *option, char *filename)
{
    int sockfd;
    int dfp;
    char dowBuff[MSGLEN];
    char recv_filename[50];
    int dow_len;
    char message[50];

    sockfd = Connect(addrname);

    //发送dowload命令到服务端
    if (send(sockfd, option, sizeof(option), 0) < 0)
    {
        perror("dowload option error");
        exit(-1);
    }
    sleep(1);

    //发送想要下载的文件名
    bzero(&recv_filename, sizeof(recv_filename));
    strcpy(recv_filename, filename);
    if (send(sockfd, recv_filename, sizeof(recv_filename), 0) < 0)
    {
        perror("send filename error");
        exit(-1);
    }
    sleep(1);

    if (recv(sockfd, message, sizeof(message), 0) < 0) //收到服务器是否有该文件的信息
    {
        perror("receive message error");
        exit(-1);
    }

    if (strcmp(message, "file no exists") == 0) //服务器没有该文件
    {
        printf("file doesn't exists in the server\n");
        close(sockfd);
        exit(-1);
    }
    else
    {
        //准备接收文件
        dfp = open(filename, O_RDWR | O_CREAT, 777);
        printf("%d\n", dfp);
        int flags = 0;
        bzero(&dowBuff, MSGLEN);
        while ((dow_len = recv(sockfd, dowBuff, MSGLEN, 0)) > 0)
        {
            flags++;
            if (flags == 1)
            {
                printf("dowload file start");
            }
            else
            {
                printf(".");
            }
            if (write(dfp, dowBuff, dow_len))
            {
                bzero(&dowBuff, MSGLEN);
            }
            else
            {
                perror("write error");
                break;
            }
        }
        if (flags == 0)
        {
            perror("dowload file error");
            close(sockfd);
        }
        if (flags > 0)
        {
            printf("\ndowload file success\n");
            close(sockfd);
        }
    }
}
void file_look(char *addrname, char *option)
{
    int sockfd;
    char recv_Buff[MSGLEN];
    int ok;   //通信状态标识
    int sent; //收发字节数

    sockfd = Connect(addrname);//初始化套接字并进行连接

    //发送ls命令到服务端
    if (send(sockfd, option, sizeof(option), 0) < 0)
    {
        perror("send option error");
        exit(-1);
    }
    // sleep(1);

    //接收服务端目录
    recv(sockfd, &ok, sizeof(ok), 0); //接收服务端的状态
    if (ok == -1)
    {
        puts("open path error");
        close(sockfd);
    }
    else
    {
        //   显示服务器目录内容
        printf("the filelist in server:\n");
        bzero(recv_Buff, MSGLEN);
        while (1)
        {
            recv(sockfd, &sent, sizeof(sent), 0);
            if (sent == 0)
            {
                break;
            }
            recv(sockfd, recv_Buff, sent, 0);
            recv_Buff[sent] = 0;
            puts(recv_Buff);
        }
        close(sockfd);
    }
}

void menu(char *addrname, char *option, char *filename)
{
    if (strcmp(option, "send") == 0)
    {
        file_send(addrname, option, filename);
    }
    else if (strcmp(option, "download") == 0)
    {
        file_dowload(addrname, option, filename);
    }
    else if (strcmp(option, "ls") == 0)
    {
        file_look(addrname, option);
    }
    else
    {
        printf("option error\n");
    }
}

int main(int argc, char **argv)
{
    char addrname[32];
    char option[20];
    char filename[50];

    if (argc == 4)
    {
        strcpy(addrname, argv[1]);
        strcpy(option, argv[2]);
        strcpy(filename, argv[3]);
        menu(addrname, option, filename);
    }
    else if (argc == 3)
    {
        strcpy(addrname, argv[1]);
        strcpy(option, argv[2]);
        menu(addrname, option, NULL);
    }
    else
    {
        printf("Usage: ./client [hostname] [option] [filename] or ./client [hostname] [ls]");
        exit(-1);
    }

    return 0;
}

Server端：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <dirent.h>
#include <sys/types.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/stat.h>
#include <fcntl.h>

#define PORT 5168
#define MSGLEN 1024

int main(int argc, char **argv)
{
    int severFd, clientFd; //服务端套接字，客户端套接字
    int fp, flags;         //文件描述符，文件读取标志
    socklen_t addrlen;     //int
    addrlen = sizeof(struct sockaddr);
    struct sockaddr_in severAddr, clientAddr; //socket地址结构
    char recvBuff[MSGLEN];                    //文件接收缓冲区
    char sendBuff[MSGLEN];                    //文件发送缓冲区
    char listBuff[MSGLEN];                    //文件列表发送缓冲区
    char recv_filename[50];                   //文件名接收缓冲区
    char filename[50];                        //文件名
    char option[20];                          //命令接收缓冲区
    char t_message[50] = "file exists";       //文件存在
    char f_message[50] = "file no exists";    //文件不存在
    int recv_len;                             //文件接收长度
    int send_len;                             //文件发送长度
    int list_len;                             //文件列表发送长度

    // 声明并初始化一个服务器端的socket地址结构
    if ((severFd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        perror("sockst error");                         //perror()用来将上一个函数发生错误的原因输出到标准设备 ，错误原因依照全局变量errno 的值来决定要输出的字符串
        exit(-1);
    }
    severAddr.sin_family = AF_INET;                     //地址家族，AF_INET代表TCP/IP
    severAddr.sin_port = htons(PORT);                   //端口，将一个无符号短整型数值转换为网络字节序，即大端模式(big-endian)　参数：16位无符号整数　返回值:TCP / IP网络字节顺序.
    severAddr.sin_addr.s_addr = htonl(INADDR_ANY);      //IP地址，htonl()将一个32位数从主机字节顺序转换成网络字节顺序
    bzero(&severAddr.sin_zero, 8);                      //结构的其余的部分须置 0

    // 绑定sseverFD和socket地址结构
    //参数1：用socket()函数创建的文件描述符
    //参数2：指向一个结构为sockaddr参数的指针
    //参数3：结构的长度
    if (bind(severFd, (struct sockaddr *)&severAddr, sizeof(struct sockaddr)) == -1)
    {
        perror("bind error");
        exit(-1);
    }

    // socket监听
    // 参数1：需要进入监听状态的套接字
    // 参数2：请求队列的最大长度
    // 当请求队列满时，就不再接收新的请求，对于 Linux，客户端会收到 ECONNREFUSED 错误
    if (listen(severFd, 10) == -1)
    {
        perror("listen error");
        exit(-1);
    }

    while (1)
    {
        // 接受连接请求，返回一个新的socket(描述符)，这个新socket用于同连接的客户端通信
        // accept函数会把连接到的客户端信息写到client_addr中 ，accept() 会阻塞程序执行（后面代码不能被执行），直到有新的请求到来
        // 参数1：服务器端套接字
        // 参数2：sockaddr_in 结构体变量
        if ((clientFd = accept(severFd, (struct sockaddr *)&clientAddr, &addrlen)) == -1)
        {
            perror("accept error");
            exit(-1);
        }
        printf("connect ip:%s  port: %d\n", inet_ntoa(clientAddr.sin_addr), ntohs(clientAddr.sin_port));

        //接收客户端命令 
        //bzero() 会将内存块（字符串）的前n个字节清零
        bzero(&option, sizeof(option));
        
        //recv先等待s的发送缓冲区的数据被协议传送完毕，recv函数仅仅是copy数据，真正的接收数据是协议来完成的
        if (recv(clientFd, option, sizeof(option), 0) < 0)
        {
            perror("receive option error");
            break;
        }

        //执行对应操作
        if (strcmp(option, "send") == 0) //客户端想要发文件
        {
            //接收客户端发来的文件名
            bzero(&recv_filename, sizeof(recv_filename));
            if (recv(clientFd, recv_filename, sizeof(recv_filename), 0) < 0)
            {
                perror("receive filename error");
                break;
            }
            strcpy(filename, recv_filename);

            //循环接收数据
            bzero(&recvBuff, MSGLEN);
            fp = open(filename, O_RDWR | O_CREAT, 777); //创建文件
            flags = 0;
            while ((recv_len = recv(clientFd, recvBuff, MSGLEN, 0)) > 0)
            {
                flags++;
                if (flags == 1)
                {
                    printf("receive file start");
                }
                else
                {
                    printf(".");
                }
                if (write(fp, recvBuff, recv_len))
                {
                    bzero(&recvBuff, MSGLEN);
                }
                else
                {
                    perror("write error");
                    break;
                }
            }
            if (flags == 0) //未接收到文件数据
            {
                perror("receive file error");
            }
            if (flags > 0)
            {
                printf("\nreceive file success\n\n");
            }
            close(clientFd);
        }
        else if (strcmp(option, "download") == 0) //客户端想要下载文件
        {
            //接收客户端发来的文件名
            bzero(&recv_filename, sizeof(recv_filename));
            if (recv(clientFd, recv_filename, sizeof(recv_filename), 0) < 0)
            {
                perror("receive filename error");
                break;
            }
            bzero(&filename, sizeof(filename));
            strcpy(filename, recv_filename);
            FILE *sfp;
            sfp = fopen(filename, "rb");
            if (sfp != NULL)
            {
                //send仅仅是把buf中的数据copy到套接字sockfd的发送缓冲区的剩余空间里
                if (send(clientFd, t_message, sizeof(t_message), 0) < 0)
                {
                    perror("send t_message error");
                    exit(1);
                }
                sleep(1);

                printf("sending file");
                bzero(&sendBuff, MSGLEN);
                while (1)
                {
                    if ((send_len = fread(sendBuff, 1, MSGLEN, sfp)) > 0)
                    {
                        if (send(clientFd, sendBuff, send_len, 0) < 0)
                        {
                            perror("send error");
                            exit(-1);
                        }
                        else
                        {
                            printf("...");
                            bzero(&sendBuff, MSGLEN);
                        }
                    }
                    else if (send_len == 0) //等于0表示文件已到末尾
                    {
                        printf("\nfile send success\n\n");
                        break;
                    }
                    else
                    {
                        perror("read error");
                        exit(-1);
                    }
                }
                fclose(sfp);
            }
            else //文件不存在
            {
                printf("no such file\n\n");
                if (send(clientFd, f_message, sizeof(f_message), 0) < 0)    //发送文件不存在的信息
                {
                    perror("send f_message error");
                    exit(-1);
                }
                sleep(1);
            }
            close(clientFd);
            sleep(1);
        }
        else if (strcmp(option, "ls") == 0)
        {
            int ok;   //收发标识
            int sent; //收发字节数
            DIR *dir;
            struct dirent *ptr;
            char data_send[MSGLEN];
            char path[5] = ".";
            if ((dir = opendir(path)) == NULL)
            {
                ok = -1;
                send(clientFd, &ok, sizeof(ok), 0); //打开路径失败则返回ok=-1
                close(clientFd);
            }
            else
            {
                ok = 1;
                send(clientFd, &ok, sizeof(ok), 0); //打开路径成功则返回ok=1

                // 逐行内容读取并发送
                while (1)
                {
                    ptr = readdir(dir);
                    if (ptr == NULL)
                        sent = 0;
                    else
                        sent = strlen(ptr->d_name);
                    send(clientFd, &sent, sizeof(sent), 0);
                    if (sent == 0)
                        break;
                    strcpy(data_send, ptr->d_name);
                    send(clientFd, data_send, sent, 0);
                }
                closedir(dir); //关闭文
                printf("send filelist success\n\n");
                close(clientFd);
            }
        }
    }
    close(severFd);
    return 0;
}

获取文件目录结果
在这里插入图片描述
代码有详细的注释，这里就不多做解释了
有一点就是，这个逻辑是：执行一次命令客户端就结束退出（因为后期跟SpringBoot结合，所以这个逻辑是这样）。如果看懂了代码可以自己修改逻辑，不过我这还有另外一个版本，在客户端给了一个菜单选项，你可以自行决定是否退出或者继续共享文件。放在下载了，感兴趣可以看看。

LL金盆
关注
专栏目录
linux shell 局域网共享文件访问
09-14
把windows/linux共享文件，通过挂载的方式挂载到/mnt目录下
Linux文件共享工具及相关配置
huzm08的专栏
11-15 692
1tftp 服务器配置（宿主机到目标机的下载工具） 简单介绍：        这里说到宿主机于目标机 两个不同的概念 我们有的电脑机宿主机——用来执行编译出开发平台能使用的可执行程序（ELF）格式     我们的开发平台是ARM开发板即目标——来执行应用程序   （符合嵌入式定义：以应用为中心；软硬件可裁剪；对功耗、体积、成本、可靠性有相关要求的计算机操作系统） 一个总结吧：tftp 是运行
Samba: Ubuntu和Win7文件共享
kerlubasola
05-30 133
转自：http://www.linuxidc.com/Linux/2011-09/43848.htm Samba是Ubuntu和Windows进行网络共享的工具，比如分享打印机，互相之间传输资料文件。 安装samba sudo apt-get install samba 查看samba是否安装成功 sudo dpkg -l samba* Desired=...
Linux 文件共享（两种方法）
最新发布
m0_59302403的博客
04-08 4万+
快速掌握Linux文件共享（共享文件夹）的两种方法。 法一通过在/mnt/hgfs下挂载共享文件夹实现，法二通过Samba共享协议实现。
LINUX资源共享软件
03-12
一个用于windows和linux系统传递文件的工具
局域网文件传输工具 NitroShare.zip
03-13
总的来说，NitroShare是C++编程在局域网文件传输领域的一个优秀实践案例，其源代码不仅为我们提供了学习C++网络编程的机会，也启发了我们思考如何构建高效、安全的文件共享系统。通过深入了解和分析，我们可以从中...
局域网文件共享
10-12
局域网文件共享技术是计算机网络中常见的应用场景，它允许在同一网络内的多台计算机之间交换文件，极大地提高了工作效率。在本项目中，用户能够访问部署在服务器上的文件系统，特别强调了对中文路径的支持，这表明...
文件共享工具.zip
06-13
两种逻辑的Linux局域网文件共享工具。 第一种是单次执行，详细操作见博客https://blog.csdn.net/CaptainLJP/article/details/106731541 第二种是可以循环执行的，在客户端提供菜单，可以选择是否退出或者是继续执行...
超级详细的Linux网络编程教程
07-31
Linux网络编程是IT领域中的重要组成部分，特别是在服务器端开发中占据着核心地位。本教程将带你深入理解Linux网络编程的方方面面，从基础概念到实际应用，覆盖了TCP/IP通信、并发进程实现以及网络分类的详细解析。 ...
局域网文件共享软件
01-16
实现功能是：获取局域网内所有电脑的共享文件信息，并能从指定电脑多线程下载文件。并可以实现断点续传等功能。通过本课程设计熟悉了linux编程和网络编程，加深了对TCP/IP的了解。 主要工作：写了一个前台和用户交互...
window下共享linux文件工具
06-28
win下共享linux系统，文件相互传递
linux与Windows之间文件共享软件 WinSCP
04-10
linux与Windows之间文件共享软件___WinSCP_5.1.2.zip ) linux与Windows之间文件共享软件___WinSCP_5.1.2.zip )
Linux三大共享文件的方法
weixin_34378969的博客
05-07 404
1. Samba     Samba 用于Linux 和windows之间的共享，ubuntu里面默认没有安装samba     在安装好samba之后，就用开始配置samba服务:     Samba服务器主要配置文件为/etc/samba/smb.conf，并且可以将NetBIOS名与主机的对应关系写在/etc/samba /lmhosts文件中。     在Windows系统中不...
送给那些开发局域网文件共享软件的你们（中）
weixin_30825199的博客
03-23 329
四　做什么 　　这是个问得最多的问题，实际上问这个问题的人是想问：做什么软件能赚到钱？对这个问题最简单有效的回答是：做有用的局域网文件共享软件。试想一下，如果你做的软件连你自已都不准备用它，你会希望别人会用吗？你在做的时候可能就是持着能捞就捞，捞不到拉倒的心态。这样只是浪费时间，劳而无获。现在很多人抱怨抄的人太多，什么是抄呢？如果你做数据库软件，我也做数据库，这不叫抄。这叫参与行...
linux 内网文件传输工具_使用Warpinator在Linux桌面之间共享文件
weixin_39584405的博客
12-16 1717
Written by Sk September 21, 2020有多种工具可用于跨网络的文件共享和接收。今天，我们将共同来认识一款名为“Warpinator”的网络文件共享应用。Warpinator是一个简单的图形化网络传输工具，由Linux mint团队开发。使用这个工具，我们可以在处于一个局域网下的Linux桌面之间轻松安全地共享文件。Warpinator是一个用Python编写的免费开源应用...
使用Linux搭建FTP服务器实现文件共享
weixin_30609287的博客
10-02 360
使用Linux搭建FTP服务器实现文件共享、、、 ---------------- Linux中的文件共享：FTPVSFTPDVSFTPD虚拟用户 FTP可以用在Linux与Linux 和Windows与Linux之间，跨平台使用 Samba可以用在Linux与Linux 和Windows与Linux之间，跨平台使用-----------------林那克斯FTp：File Transfe...
linux 的CIFS 网络文件系统与Samba 文件共享软件
weixin_43369306的博客
11-27 214
        CIFS 是一个新提出的协议，它使程序可以访问远程Internet计算机上的文件并要求此计算机提供服务。CIFS 使用客户/服务器模式。客户程序请求远在服务器上的服务器程序为它提供服务。服务器获得请求并返回响应。CIFS是公共的或开放的SMB协议版本，并由Microsoft使用。SMB协议在局域网上用于服务器文件访问和打印的协议。像SMB协议一样，CIFS在高层运行，而不像TCP/...
Linux之文件共享
Ever_Linux的博客
06-16 1390
文件共享 NFS NFS的优点： 安装和设置简单，轻量级的文件共享软件。可以实现linux和unix系统之间的文件共享。在win7/win10系统中也可以访问nfs共享。支持基于IP的访问控制。 缺点： 不支持基于用户名的访问控制。即访问nfs共享时，无需输入用户名和密码。如果要解决此问题，可采用ftp、samba、apache、nginx共享。 网络环境拓扑： 客户机client ...
linux下如何实现文件共享
加载中。。。请等待
02-26 274
挂接Windows文件共享 　　Windows网络共享的核心是SMB/CIFS，在linux下要挂接(mount)windows的磁盘共享，就必须安装和使用samba软件包。现在流行的linux发行版绝大多数已经包含了samba软件包，如果安装linux系统时未安装samba请首先安装samba。当然也可以到www.samba.org网站下载......新的版本是3.0.10版。 　　当w...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值