简易网络文件拷贝的C实现

已于 2022-09-02 13:21:55 修改
阅读量202 收藏 1
点赞数
文章标签： 网络 c语言 开发语言
于 2022-07-28 15:13:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37132481/article/details/126035536
版权

效果

服务端

./s

客户端读服务端文件

./c 127.0.0.1 src_file dst_file 0 

客户端写文件到服务端

 ./c 127.0.0.1 src_file dst_file 1

服务端实现server.c

#include <stdio.h>
#include <stdbool.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdint.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include "cs.c"

int init_socket(void)
{
        int opt = 1;
        struct sockaddr_in servaddr = {0};
        unsigned int len = sizeof(opt);
        int sock = socket(AF_INET, SOCK_STREAM, 0);
        bool ok = false;

        servaddr.sin_family = AF_INET;
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
        servaddr.sin_port = htons(SERVICE_PORT);

        if(sock < 0) {
                perror("socket");
        } else if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, len)) {
                perror("setsockopt");
        } else if (bind(sock, (struct sockaddr *)&servaddr,sizeof(servaddr))) {
                perror("bind");
        } else if (listen(sock, 1)) {
                perror("listen");
        } else {
                ok = true;
        }
        if(ok) {
                /* null */
        } else if(sock >= 0) {
                close(sock);
        }
        return ok ? sock : -1;
}

void *server_thread(void *args)
{
        struct trans_op *op = (struct trans_op *)malloc(sizeof(*op));
        int client = *(int *)args;

        if(op) {
                perror("malloc");
        } else {
                op->magic = 0;
        }
        if(!op) {
                /* null */
        } else if(client < 0) {
                /* null */
        } else if (safe_recv(client, op,sizeof(*op), 0) == sizeof(*op)) {
                /* null */
        } else {
                printf("recv op err\n");
        }
        if(op->magic != START_EXIT) {
                printf("op->magic != START_EXIT\n");
        } else {
                switch(op->read_write) {
                        case READ_OP:
                                printf("client read file:%s -> %s\n", op->src_file, op->dst_file);
                                client_read_file(client, op);
                                break;
                        case WRITE_OP:
                                printf("client write file:%s -> %s\n", op->src_file, op->dst_file);
                                client_write_file(client, op);
                                break;
                        default:
                                break;
                }
        }
        if(!op) {
                /* null */
        } else {
                free(op);
        }
        if(client < 0) {
                /* null */
        } else {
                close(client);
        }
        return NULL;
}
int main(int argc, char *argv[])
{
        int client = -1;
        int  socklen = sizeof(struct sockaddr_in);
        struct sockaddr_in clientaddr = {0};
        int sock = init_socket();

        while(sock >= 0) {
                client = accept(sock,(struct sockaddr *)&clientaddr,(socklen_t*)&socklen);
                if(client < 0) {
                        perror("accept");
                } else {
                        printf("detect client:%d\n", client);
                        pthread_t tid = 0;
                        pthread_create(&tid, NULL, server_thread, &client);
                        if(tid) {
                                /* null */
                        } else {
                                pthread_detach(tid);
                        }
                }
        }
        return 0;
}

void client_read_file(int client, struct trans_op *op)
{
        // server read to -> client
        __read(client, op, op->src_file);
}
void client_write_file(int client, struct trans_op *op)
{
        // client send to -> server
        __write(client, op, op->dst_file);
}

客户端实现client.c

#include <stdio.h>
#include <stdbool.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdint.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "cs.c"

int init_socket(int argc, char *argv[])
{
        int sock = socket(AF_INET, SOCK_STREAM, 0);
        int opt = 1; unsigned int len = sizeof(opt);
        struct sockaddr_in servaddr = {0};
        bool ok = false;

        servaddr.sin_family = AF_INET;
        servaddr.sin_addr.s_addr = inet_addr(argv[1]);
        servaddr.sin_port = htons(SERVICE_PORT);

        if(sock < 0) {
                perror("socket");
        } else if(setsockopt(sock , SOL_SOCKET, SO_REUSEADDR, &opt, len)) {
                perror("setsockopt");
        } else if(connect(sock, (struct sockaddr *)&servaddr, sizeof(servaddr))) {
                perror("connect");
        } else {
                ok = true;
        }
        if(ok) {
                /* null */
        } else if(sock >= 0){
                close(sock);
        }
        return ok ? sock : -1;
}

int main(int argc, char *argv[])
{
        int sock = -1;
        struct trans_op *op = (struct trans_op *)malloc(sizeof(*op));

        if(argc != 5) {
                printf("for read ./c 127.0.0.1 srcFile dstFile 0\n");
                printf("for write ./c 127.0.0.1 srcFile dstFile 1\n");
        } else if(!op) {
                perror("malloc");
        } else if((sock = init_socket(argc, argv)) == -1) {
                perror("init_socket");
        } else {
                memcpy(op->src_file, argv[2], strlen(argv[2]));
                memcpy(op->dst_file, argv[3], strlen(argv[3]));
                op->read_write = atoi(argv[4]);
                op->magic = START_EXIT;
        }
        if(sock < 0) {
                /* null */
        } else if(safe_send(sock, op, sizeof(*op), 0) != sizeof(*op)) {
                perror("send");
        } else {
                switch(op->read_write)
                {
                case READ_OP:
                        printf("client read file:%s -> %s\n", op->src_file, op->dst_file);
                        client_read_file(sock, op);
                        break;
                case WRITE_OP:
                        printf("client write file:%s -> %s\n", op->src_file, op->dst_file);
                        client_write_file(sock, op);
                        break;
                default:
                        break;
                }
        }
        if(!op) {
                /* null */
        } else {
                free(op);
        }
        if(sock < 0) {
                /* null */
        } else {
                close(sock);
        }
        return 0;
}

void client_read_file(int client, struct trans_op *op)
{
        // server send to -> client
        __write(client, op, op->dst_file);
}
void client_write_file(int client, struct trans_op *op)
{
        // client send to -> server
        __read(client, op, op->src_file);
}

文件读写实现cs.c

#define READ_WRITE_END 0xBB
#define START_EXIT 0xCC
#define SERVICE_PORT 1234
#define WRITE_OP 1
#define READ_OP 0
struct trans_op
{
        uint8_t magic;
        uint8_t read_write;//0:READ_OP 1:WRITE_OP
        uint32_t size;
        char src_file[256];
        char dst_file[256];
        char buffer[4096 - 8 - 512];
};
void client_read_file(int client, struct trans_op *op);
void client_write_file(int client, struct trans_op *op);


ssize_t safe_recv(int sockfd, void *buf, size_t len, int flags)
{
        ssize_t res = 0;
        size_t expect = 0;

        do {
                res = recv(sockfd, (char *)buf + expect, len - expect, flags);
                if(res == -1) {
                        break;
                } else if(res == 0) {
                        break;
                } else {
                        expect += res;
                }
        } while(expect != len);
        if(res == -1) {
                /* null */
        } else {
                res = expect;
        }
        return res;
}

ssize_t safe_send(int sockfd, const void *buf, size_t len, int flags)
{
        ssize_t res = 0;
        size_t expect = 0;

        do {
                res = send(sockfd, (char *)buf + expect, len - expect, flags);
                if(res == -1) {
                        break;
                } else if(res == 0) {
                        break;
                } else {
                        expect += res;
                }
        } while(expect != len);
        if(res == -1) {
                /* null */
        } else {
                res = expect;
        }
        return res;
}

ssize_t safe_write(int fd, const void *buf, size_t count)
{
        ssize_t res = 0;
        size_t expect = 0;

        do {
                res = write(fd, (char *)buf + expect, count - expect);
                if(res == -1) {
                        break;
                } else if(res == 0) {
                        break;
                } else {
                        expect += res;
                }
        } while(expect != count);
        if(res == -1) {
                /* null */
        } else {
                res = expect;
        }
        return res;

}
ssize_t safe_read(int fd, void *buf, size_t count)
{
        ssize_t res = 0;
        size_t expect = 0;

        do {
                res = read(fd, (char *)buf + expect, count - expect);
                if(res == -1) {
                        break;
                } else if(res == 0) {
                        break;
                } else {
                        expect += res;
                }
        } while(expect != count);
        if(res == -1) {
                /* null */
        } else {
                res = expect;
        }
        return res;

}

void __write (int client, struct trans_op *op, char *filename)
{
        int fd = open(filename, O_CREAT | O_WRONLY, 0777);
        ssize_t total = 0;

        printf("write %s\n", filename);
        if(fd < 0) {
                perror("open");
        }
        else {
                while(1) {
                        memset(op, 0, sizeof(*op));
                        if(safe_recv(client, op, sizeof(*op), 0) != sizeof(*op)) {
                                break;
                        } else if(op->magic == READ_WRITE_END) {
                                printf("magic is bb exit.\n");
                                break;
                        } else if(safe_write(fd, op->buffer, op->size) != op->size) {
                                perror("safe_write");
                                break;
                        } else {
                                total += op->size;
                        }
                }
                printf("toatl = %ld\n", total);
                close(fd);
        }

        /* check return code */
        if(op->magic != READ_WRITE_END || op->size != total) {
                printf("end fail\n");
        } else {
                printf("end success\n");
        }
        /* replay */
        op->magic = START_EXIT;
        op->size = total;
        safe_send(client, op, sizeof(*op), 0);
}
void __read(int client, struct trans_op *op, char *filename)
{
        int fd = open(filename, O_RDONLY, 0777);
        ssize_t total = 0;

        printf("read %s\n", filename);
        if(fd < 0) {
                perror("open");
        }
        else {
                while(1) {
                        memset(op, 0, sizeof(*op));
                        if((op->size = safe_read(fd, op->buffer, sizeof(op->buffer))) < 0) {
                                perror("read error");
                                break;
                        } else if(op->size == 0) {
                                /* read end */
                                break;
                        } else if(safe_send(client, op, sizeof(*op),0) != sizeof(*op)) {
                                perror("send error");
                                break;
                        } else {
                                total += op->size;
                        }
                }
                /* relply */
                op->magic = READ_WRITE_END;
                op->size = total;
                if(safe_send(client, op, sizeof(*op), 0) == sizeof(*op)) {
                        /* null */
                } else {
                        perror("safe_send");
                }
                printf("toatl = %ld\n", total);
                close(fd);
        }
        /* check return code */
        safe_recv(client, op, sizeof(*op), 0);
        if(op->magic != START_EXIT || op->size != total) {
                printf("end fail, op->magic,op->size=%d,%d\n", op->magic, op->size);
        } else {
                printf("end success\n");
        }
}

<完> 

蓝牙先生
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
网络之间之间拷贝文件
10-28
局域网络之间可以之间进行拷贝文件，可以多路同时拷贝，也可以单路拷贝
windows server 2003 下，简易网络硬盘的搭建
12-07
"windows server 2003 下，简易网络硬盘的搭建" Windows Server 2003 是一款功能强大的服务器操作系统，本文将指导您如何在 Windows Server 2003 下搭建简易网络硬盘，并使用 Apache SQL 数据库简易管理界面。 ...
拷贝网络文件
ORACLE专栏
09-28 1078
   net use z: //ipaddress/directory password /USER:usernameConst OverwriteExisting = TrueSet objFSO = CreateObject("Scripting.FileSystemObject")objFSO.CopyFile "z:/vbs/*.vbs" , "f:/Archive/" , Overwri
linux 网络拷贝,（网络）文件拷贝（Windows/Linux）
weixin_39644713的博客
05-06 446
【Windows】1、本地拷贝推荐：FastCopy2、网络拷贝推荐：RichCopy【Linux】1、rsync 命令#删除海量文件目录mkdirempty_dirrsync-a--deleteempty_dir/yourdirectory/#本地拷贝rsync-a/some/path/to/src//other/path/to/dest/#网络拷贝rsync-a-ess...
网络拷贝数据
weixin_30784501的博客
07-25 147
USE master--映射盘符Zexec master..xp_cmdshell 'net use z: \\192.168.0.117\c$ "密码" /user:192.168.0.117\administrator'--映射后拷贝EXEC xp_cmdshell 'copy e:\0724.bak z:\',NO_OUTPUT--映射后删除exec master..xp_cmdshell ...
用网络实现电脑和电脑之间文件的拷贝
ZHANG8023ZHEN的博客
03-19 370
用网络实现电脑和电脑之间文件的拷贝 打开需要拷贝的文件所在位置的终端 在终端输入 ifconfig 找到eno1名下的inet地址，记住此地址，例如172.26.178.50 在终端输入python –m http.server [意思是把此电脑设置为服务器] 打开另一台电脑的游览器，输入eno1名下的inet地址，再加上：8000。例如172.26.178.50：8000 得到所在文件夹下面...
ULTRAMAP 拷贝数据简易教程.doc
05-05
**ULTRAMAP 数据拷贝教程** ULTRAMAP 是一款专业的数据管理工具，尤其适用于航空飞行数据的拷贝和管理。本教程将详细介绍如何使用 ULTRAMAP 进行数据拷贝，确保数据安全有效地从原始源转移到备份介质。 **步骤一：...
VB6.0简易答题器
05-16
摘要:VB源码,数据库应用,答题器　VisualBasic6.0简易答题系统，VB简易答题器是帮朋友做的一个设计，一个简单的VB+TXT程序，朋友有个设计展，不得不说...　小王软件OICQ：447201162，使用时请把生成的EXE文件拷贝到与HT
LRC歌词文件转换器 V3.1
05-05
如果您不能正常使用本软件，请将Comdlg32.ocx文件拷贝到Windows所在文件夹的“System32”文件夹中。如您的Windows安装在C:\Windows，则将Comdlg32.ocx拷贝到C:\Windows\System32。 【使用方法】 1. 选择输入文件...
M16C Family Easy Programmer.rar
10-21
《M16C家族简易编程器详解》 M16C家族是一系列微控制器，由日本瑞萨电子（Renesas Electronics）开发，主要用于嵌入式系统设计。这些微控制器以其高效能、低功耗和丰富的外设接口而受到广泛的欢迎。"M16C Family ...
网络拷贝文件方法一(服务器)
07-20
网络拷贝文件方法一(服务器),非常好用，可直接下载使用。
VC局域网文件传输程序答辩文档及源代码
01-14
局域网内输入对方IP选择文件，对方同意了就可实现文件传输。课程设计，学习的好东东。Visual Studio 2008 CN环境下编译的。
通过网络完全复制你的电脑
Bekars涡轮增压的Blog ^_^
12-14 1925
通过网络完全复制你的电脑  提要尽管克隆动物（“多莉羊“）甚至人类胚胎的研究依然是一个充满争议和风险的领域，而掌握一些关于“克隆”电脑的知识不但没有害（正确的操作为前提），反而会使你仔细书写配置脚本的能力得到提升。根据摩尔定律以及计算机生产的快速进程，我们在使用电脑时很可能会遇到需要“克隆”我们的电脑的情况——不管是台式机被笔记本取代还是换一
网络文件传输之零拷贝
weixin_42189550的博客
07-20 671
文件传输之零拷贝
windows安全中心用户名和密码_【技巧 】iOS&Windows互传文件？透过「文件」轻松解决~...
weixin_39866419的博客
10-21 2700
苹果家的隔空投送能做到手机、电脑间的无缝衔接；在iOS13的「文件」中加入了局域网的文件共享功能，电脑不需要安装任何软件，实现 iPhone 与 Windows 电脑间文件的共享、传输。注意：本文介绍的是基于局域网（同一路由器）下的文件传输，所以一定要把手机、电脑连接在同一网络下。Windows电脑端设置第一步：设置网路共享打开“控制面板---网络和Internet---网络和共享中心---高级共...
VC下文件(夹)拷贝的方式
caomiao2006的专栏
11-23 2133
    1、直接通过CRT标注函数fopen/fclose打开/关闭文件，fread/fwrite读写文件；    2、WIN32 API的CopyFile函数或CopyFileEX(回调函数返回进度)函数直接进行拷贝；    3、WIN32 API的SHFileOperation函数拷贝文件或文件夹；    4、WIN32 API的CreateFile、ReadFile和WriteF
vc函数拷贝一个网络共享文件夹文件 vc_实验室局域网建立共享文件夹和磁盘映射...
weixin_39568926的博客
12-08 362
0 前言我们在实验室经常会相互传递资料或者共享一些资料，可能我们会用U盘拷贝资料到另一台电脑或者我通过QQ等方式传输资料，索然无味。这篇文章让你一分钟学会在实验室同局域网下建立共享文件夹，局域网下实验室所有人员都可以进行访问，具有读/写权限。1 如何获取电脑的IP先把如何查看电脑的IP方向写在前面，后面会用到，大家拿笔记一下自己的IP。查找电脑的IP方法很多，大家也可以自行百度。我使用的是无线网，...
TCP/IP编程实现远程文件传输
08-30 1163
在TCP/IP网络结构中，为了保证网络安全，网络人员往往需要在路由器上添加防火墙，禁止非法用户用FTP等安全危 害较大的TCP/IP协议访问主机。而有时系统维护人员需要用ftp将一些文件从中心机房主机传到前端网点主机上，比如应用程序的替换升级。如果每次传输 文件时都要打开防火墙，未免显得有些繁琐，要是在自己的应用程序中增加一个专门的文件传输模块，那将是十分愉快的事情。　　UNIX网络程序设计一般都
java文件拷贝具体实现
最新发布
04-09
好的，Java文件拷贝可以通过使用Java的IO流来实现，可以使用FileInputStream和FileOutputStream来读写文件，也可以使用BufferedInputStream和BufferedOutputStream来提高速度。以下是一个示例代码： ``` import ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值