精华内容
下载资源
问答
  • 使用Java完成Socket文件传输
    2022-04-19 11:09:29

    TCP协议的Socket文件传输

    分别使用三个类(TCPFileUpload_Server服务器端、TCPFileUpload_Client客户端、StreamUtils工具类)完成图片的传输。

    同样先运行服务器端文件,再运行客户端文件

    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /**
     * 服务器端
     */
    public class TCPFileUpload_Server {
        public static void main(String[] args) throws Exception {
            //思路
            //在本机 的8888端口监听, 等待连接
            ServerSocket serverSocket = new ServerSocket(8888);
            System.out.println("服务器端,监听8888端口,等待连接");
            //当没有客户端连接8888端口时,程序会 阻塞, 等待连接
            //如果有客户端连接,则会返回Socket对象,程序继续
            Socket socket = serverSocket.accept();
    
            //通过socket.getInputStream() 读取客户端写入到数据通道的数据, 并转换成字节数组
            BufferedInputStream bufferedInputStream = new BufferedInputStream(socket.getInputStream());
            byte[] bytes = StreamUtils.streamToByteArray(bufferedInputStream);
            //写入指定路径
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("src\\G.jpg"));
            bufferedOutputStream.write(bytes);
            //关闭IO流
            bufferedOutputStream.close();
    
            //向客户端回复收到图片
            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            bufferedWriter.write("收到图片!");
            bufferedWriter.flush();
            socket.shutdownOutput();
    
    
            //关闭所有流
            bufferedWriter.close();
            bufferedInputStream.close();
            socket.close();
            serverSocket.close();
    
        }
    }
    
    import java.io.*;
    import java.net.InetAddress;
    import java.net.Socket;
    
    /**
     * 客户端
     */
    public class TCPFileUpload_Client {
        public static void main(String[] args) throws Exception {
            //连接服务端 (ip , 端口)
            //解读:连接本机的 8888端口, 如果连接成功,返回Socket对象
            Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
            System.out.println("客户端 连接端口:" + socket.getPort());
    
            //创建读取磁盘文件IO流
            BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("src/P.jpg"));
            //获取字节数组
            byte[] bytes = StreamUtils.streamToByteArray(bufferedInputStream);
            //通过Socket获取到输出流,将bytes发送到服务端
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(socket.getOutputStream());
            bufferedOutputStream.write(bytes);
            //关闭流对象,socket,刷新,添加终止符
            bufferedInputStream.close();
            bufferedOutputStream.flush();
            socket.shutdownOutput();
    
            //接受回复消息
            //此处可调用Utils的方法
    //        String s = "";
    //        while ((s = bufferedReader.readLine()) != null)
    //            System.out.println(s);
            System.out.println(StreamUtils.streamToString(socket.getInputStream()));
    
            //关闭所有流
            bufferedOutputStream.close(); //socket的包装流不要过早关闭
            socket.close();
    
        }
    
    }
    
    import java.io.BufferedReader;
    import java.io.ByteArrayOutputStream;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    
    /**
     * 此类用于演示关于流的读写方法
     */
    public class StreamUtils {
        /**
         * 功能:将输入流转换成byte[]
         *
         * @param is 输入流
         * @return byte数组
         * @throws Exception IO流异常
         */
        public static byte[] streamToByteArray(InputStream is) throws Exception {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
            byte[] b = new byte[1024];
            int len;
            while ((len = is.read(b)) != -1) {
                bos.write(b, 0, len);
            }
            byte[] array = bos.toByteArray();
            bos.close();
            return array;
        }
    
        /**
         * 功能:将InputStream转换成String
         *
         * @param is 输入流
         * @return 字符串
         * @throws Exception IO流异常
         */
        public static String streamToString(InputStream is) throws Exception {
            BufferedReader reader = new BufferedReader(new InputStreamReader(is));
            StringBuilder builder = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) { //当读取到 null时,就表示结束
                builder.append(line + "\r\n");
            }
            return builder.toString();
    
        }
    
    }
    

    更多相关内容
  • android Socket文件传输

    2021-09-02 17:28:59
    android Socket文件传输,对于几十M的文件都可以很好的传输
  • Android Socket 文件传输

    2016-11-18 10:43:12
    发送端用Socket发送指定路径的文件给接收端,接收端将文件存储到指定路径。
  • C#Socket文件传输,将文件名和文件保存到一个byte[]中传输,再通过解析获取文件名和文件保存到本地文件夹中
  • Socket文件传输

    热门讨论 2013-09-25 18:26:51
    本软件使用MFC采用面向对象的方法实现了基于Socket文件传输。功能完整。
  • 主要介绍了Java使用Socket通信传输文件的方法,结合实例形式分析了java socket编程实现文件传输操作的相关技巧,需要的朋友可以参考下
  • 计算机网络课程设计基于socket文件传输实验,vs2013c++
  • 基于socket UDP协议实现文件传输(windows vc++源代码) UDP1GB的文件仅需15秒 该代码包含 根据文件内容长度生成MD5码,以供校验文件完整性 本代码包含windows vc++编写dll的代码
  • C#SOCKET文件传输.zip

    2020-05-16 14:23:54
    C# 实现的SOCKET文件传输,支持高并发,断点续等,是学习SOCKET通信的经典案例,走过路过不要错过!!!!!!
  • 主要介绍了C语言实现Linux下的socket文件传输的方法,较为详细的分析了C语言文件Socket文件传输客户端与服务器端相关实现技巧,需要的朋友可以参考下
  • 本篇文章主要介绍了python:socket传输文件示例,具有一定的参考价值,有兴趣的可以了解一下,
  • SOCKET 文件传输

    2019-05-25 02:32:22
    NULL 博文链接:https://wlh269.iteye.com/blog/473371
  • 基于java nio socket文件传输例程
  • socket文件传输

    2017-10-18 21:35:19
    在完成客户端与服务端通信的基础上,开发断点续的模拟功能,实现在接收文件时,可以用暂停,并且在重新开始时将文件写入指定位置
  • Socket文件传输源码 asp.net版Socket文件传输源码 asp.net版Socket文件传输源码 asp.net版Socket文件传输源码 asp.net版Socket文件传输源码 asp.net版
  • java socket 文件传输

    2021-02-12 12:48:43
    闲着无聊,写了一个基于java的socket文件传输。是这样设计的:1、Server提供文件传输的server服务器端,接收client发送过来的文件。提供多线程并发处理,能同时处理多个client的文件传输请求。2、Client根据提供的...

    闲着无聊,写了一个基于java的socket文件传输。

    是这样设计的:

    1、Server

    提供文件传输的server服务器端,接收client发送过来的文件。

    提供多线程并发处理,能同时处理多个client的文件传输请求。

    2、Client

    根据提供的参数指定的server以及本地文件的路径,进行文件传输

    client的代码

    import java.io.BufferedInputStream;

    import java.io.BufferedOutputStream;

    import java.io.File;

    import java.io.FileInputStream;

    import java.io.IOException;

    import java.net.InetAddress;

    import java.net.InetSocketAddress;

    import java.net.Socket;

    import java.net.SocketAddress;

    import org.apache.commons.io.IOUtils;

    import org.apache.commons.lang.StringUtils;

    import org.apache.log4j.Logger;

    public class FileClient {

    private static final Logger LOGGER = Logger.getLogger(FileClient.class);

    private Socket socket;

    public void sendFile(File file, String host, int port) throws IOException {

    if (!file.exists() || !file.isFile()) {

    throw new IllegalArgumentException("file : " + file

    + " is not a valid file!");

    }

    connect(host, port);

    sendFile(file);

    close();

    }

    private void sendFile(File file) throws IOException {

    BufferedOutputStream fileOutput = new BufferedOutputStream(

    socket.getOutputStream());

    BufferedInputStream input = new BufferedInputStream(

    new FileInputStream(file));

    IOUtils.copy(input, fileOutput);

    fileOutput.flush();

    IOUtils.closeQuietly(input);

    IOUtils.closeQuietly(fileOutput);

    }

    private void close() throws IOException {

    if (isConnected()) {

    socket.close();

    }

    }

    private boolean isConnected() {

    return null != socket && socket.isConnected() && !socket.isClosed();

    }

    private void connect(String host, int port) throws IOException {

    if (isConnected()) {

    return;

    }

    socket = new Socket();

    socket.setKeepAlive(true);

    socket.setReuseAddress(true);

    InetAddress addr = InetAddress.getByName(host);

    SocketAddress endpoint = new InetSocketAddress(addr, port);

    socket.connect(endpoint);

    }

    /**

    * @param args

    */

    public static void main(String[] args) {

    String filePath = System.getProperty("file");

    if (StringUtils.isEmpty(filePath)) {

    LOGGER.error("Error: JVM argumengs -Dfile is null !");

    return;

    }

    String host = System.getProperty("host");

    if (StringUtils.isEmpty(host)) {

    LOGGER.error("Error: JVM argumengs -Dhost is null !");

    return;

    }

    String portString = System.getProperty("port");

    if (StringUtils.isEmpty(portString)) {

    LOGGER.error("Error: JVM argumengs -Dport is null !");

    return;

    }

    int port = Integer.valueOf(portString).intValue();

    File file = new File(filePath);

    FileClient client = new FileClient();

    try {

    LOGGER.info("start to transfer file : " + file);

    long before = System.currentTimeMillis();

    client.sendFile(file, host, port);

    LOGGER.info("transfer file : " + file

    + " successfully! It consumes "

    + (System.currentTimeMillis() - before) + " ms.");

    } catch (IOException e) {

    LOGGER.error("Error:" + e.getMessage(), e);

    }

    }

    }

    server的代码:

    import java.io.File;

    import java.net.Socket;

    import java.util.concurrent.BlockingQueue;

    import java.util.concurrent.ExecutorService;

    import java.util.concurrent.Executors;

    import java.util.concurrent.LinkedBlockingQueue;

    public class Bootstrap {

    /**

    * @param args

    */

    public static void main(String[] args) throws Exception{

    int cpuTimes = 4;

    int port = 7777;

    BlockingQueue queue = new LinkedBlockingQueue();

    ExecutorService exec = Executors.newCachedThreadPool();

    exec.execute(new FileEchoServer("server-1", port, queue));

    File path = new File("E:/temp");

    for (int i = 0, count = Runtime.getRuntime().availableProcessors()

    * cpuTimes; i < count; i++) {

    exec.execute(new FileConsumer("socket-" + i, queue,path));

    }

    exec.shutdown();

    }

    }

    import java.io.IOException;

    import java.net.ServerSocket;

    import java.net.Socket;

    import java.util.concurrent.BlockingQueue;

    import org.apache.log4j.Logger;

    /**

    * @author kanpiaoxue

    *

    */

    public class FileEchoServer implements Runnable {

    protected static final Logger LOGGER = Logger.getLogger(FileEchoServer.class);

    protected final ServerSocket serverSocket;

    protected final BlockingQueue queue;

    protected final String name;

    public FileEchoServer(String name, int port, BlockingQueue queue)

    throws IOException {

    serverSocket = new ServerSocket(port);

    serverSocket.setReuseAddress(true);

    LOGGER.info(serverSocket);

    this.queue = queue;

    this.name = name;

    }

    @Override

    public void run() {

    setName(name);

    while (true) {

    try {

    queue.put(serverSocket.accept());

    } catch (Exception e) {

    LOGGER.error("Error:" + e.getMessage(), e);

    }

    }

    }

    private void setName(String name) {

    Thread.currentThread().setName(name);

    LOGGER.info(name + " start to work.");

    }

    }

    import java.net.Socket;

    import java.util.concurrent.BlockingQueue;

    import org.apache.log4j.Logger;

    /**

    * @author kanpiaoxue

    *

    */

    public abstract class AbstractSocketConsumer implements Runnable {

    protected static final Logger LOGGER = Logger

    .getLogger(AbstractSocketConsumer.class);

    protected final String name;

    protected final BlockingQueue queue;

    public AbstractSocketConsumer(String name, BlockingQueue queue) {

    super();

    this.name = name;

    this.queue = queue;

    }

    private void setName(String name) {

    Thread.currentThread().setName(name);

    LOGGER.info(name + " start to work.");

    }

    @Override

    public void run() {

    setName(name);

    while (true) {

    try {

    consume(queue.take());

    } catch (Exception e) {

    LOGGER.error("Error:" + e.getMessage(), e);

    }

    }

    }

    protected abstract void consume(Socket socket) throws Exception;

    }

    import java.io.BufferedInputStream;

    import java.io.BufferedOutputStream;

    import java.io.File;

    import java.io.FileOutputStream;

    import java.io.PrintWriter;

    import java.net.Socket;

    import java.util.concurrent.BlockingQueue;

    import java.util.concurrent.atomic.AtomicLong;

    import org.apache.commons.io.IOUtils;

    import com.wanmei.net.slef.file.AbstractSocketConsumer;

    public class FileConsumer extends AbstractSocketConsumer {

    private File filePath;

    private static final AtomicLong FILE_COUNT = new AtomicLong();

    public FileConsumer(String name, BlockingQueue queue, File path) {

    super(name, queue);

    this.filePath = path;

    }

    @Override

    protected void consume(Socket socket) throws Exception {

    LOGGER.info("start to receive file from "

    + socket.getInetAddress().getHostName() + ":"

    + socket.getPort());

    long before = System.currentTimeMillis();

    File file = new File(filePath, "file-" + FILE_COUNT.getAndIncrement());

    if (file.exists()) {

    file.delete();

    }

    BufferedOutputStream fileOutput = new BufferedOutputStream(

    new FileOutputStream(file));

    BufferedInputStream input = new BufferedInputStream(

    socket.getInputStream());

    IOUtils.copy(input, fileOutput);

    fileOutput.flush();

    PrintWriter response = new PrintWriter(socket.getOutputStream());

    String responseString = echo(socket);

    response.println(responseString);

    response.flush();

    if (null != socket) {

    IOUtils.closeQuietly(input);

    IOUtils.closeQuietly(fileOutput);

    IOUtils.closeQuietly(response);

    socket.close();

    }

    LOGGER.info("transfer file : " + file + " successfully! It consumes "

    + (System.currentTimeMillis() - before) + " ms.");

    }

    private String echo(Socket socket) {

    return "Transfer file " + socket.getLocalAddress().getHostName() + ":"

    + socket.getLocalPort() + " OK!";

    }

    }

    这个进行过测试,代码是可以运行的。这里的代码有其他的的依赖的jar包,就是apache下面的commons下面的一些常用包:

    org.apache.commons.io.IOUtils

    org.apache.commons.lang.StringUtils

    org.apache.log4j.Logger

    后记:这里只是简单的写了一个socket的文件传输。其实这里的代码的实际应用意义不是很大。

    一般我们进行文件传输的时候,还需要进行一些必要的工作,比如:文件大小的校验,或者文件的MD5的校验,用来保证文件传输之前和传输之后的完整性,正确性。

    这里给出一个提示:

    client:可以在发送文件的client里面写2个socket,第一个socket用来告诉服务器“我要给你传输一个文件,这个文件的名字是:file-test.txt,它的MD5是:XXXXXXXXXX,文件的大小是xxxxxbytes”。当这个socket从服务器得到允许“yes”的消息,以及服务器创建的临时ServerSocket的host、port之后,开始用第二个socket进行文件传输。

    server:在server中,当一个socket接到client发送的“我要给你传输一个文件,这个文件的名字是:file-test.txt,它的MD5是:XXXXXXXXXX,文件的大小是xxxxxbytes”的消息之后,判断是否需要client进行文件发送(例如根据文件的大小,判断当前的服务器有足够的磁盘空间存放客户端发送来的文件。如果文件大小够存放client传输过来的文件,那么进行下一步。如果不够存放client传输过来的文件,那么告知client,当前的服务器磁盘空间已满,不能进行文件传输。)。如果需要,则把该文件的名称,该文件的MD5记录到本地的内存中,然后建立一个临时的ServerSocket对象(指定任意端口),再通过上面的socket回复给client的第一个socket,告诉他可以(yes),并告知client的第一个socket这个临时的ServerSocket的对象的host,port。好允许client利用第二个socket进行文件传输,将文件流写给这里的ServerSocket。

    当Server端判断出文件接收完毕,马上对该接收到的文件生成MD5校验码,将该校验码与之前client第一个socket传送来的MD5校验码进行校对。发现一致,继续等待下一个文件的传输任务的到来;如果不一致,可以告诉client,该文件需要进行重传。

    这里需要注意的一个地方是:当server端启动多个线程进行文件接收的时候,最好不要用文件大小来判断磁盘空间是否可以存放client传输过来的文件。为什么?因为server接收文件是并行的。当其中一个线程接收到文件的磁盘检查的时候,该服务器的磁盘空间确实够存放文件,就会告诉client进行文件传输。这个时候很有可能,server的另一个线程也接到文件大小的检验的任务,开始检查磁盘空间是否够存放client传输的文件。发现空间是够用的,也告诉了当前的client可以进行文件传输。这个时候,会产生问题的:当server的磁盘空间就剩下1G的时候,一个client传输的文件是600M,另一个client传输的文件是700M,就会造成2个client的文件都无法完成传输而报错。因为它们占用服务器空间的大小,超过了服务器现在的空间大小。

    那么该如何处理服务器磁盘空间大小检查的问题呢?没有更好的办法,服务器只能采用单线程的服务器文件传输。另一个方法,服务器程序内含一个文件大小检查的线程,定时(间隔10秒)检查服务器的空间是否达到预警阀值(这个阀值最好设置的大一点,比如1T的大小,可以存放半天的数据传输)。当到达预警阀值,可以发送预警信息(电子邮件、手机短信)给管理员,要求他进行磁盘空间的扩展。

    另一个文件传输的方法:采用一个socket进行文件传输,而不是像上面那样采用2个socket,一个用来发送文件的具体信息,一个用来传输文件。如果需要采用一个socket,就需要自己写一个协议。其实这样的协议是存在的,如 http 协议。我们也可以自己写一个传输文件的协议,该协议分为2个部分。第一部分,header,用来存放文件的必要信息,比如:文件大小,文件名称,文件的MD5等等;第二部分,body,用来存放文件的流内容。这样,client可以在按照协议发送给服务器一个封装好的内容,server呢按照协议进行解析出header、body,然后存放文件。这样做就会复杂一点,要想简化,可以采用http协议来传输文件。http具有“协议、header、body”的完整结构,可以满足文件传输的需要。

    上面给出的思路,大致能实现文件的安全传输,里面包含了文件传输,文件完整性/准确性校验,文件传输发生错误之后的重传机制。这个思路,和FTP的文件传输相似。可以进行参考。

    展开全文
  • 发送端可以不停的发送新文件,接收端可以不停的接收新文件。 例如:发送端输入:e:\visio.rar,接收端会默认保存为 e:\new_visio.rar,支持多并发,具体实现如下; 接收端: 方法一: #-*- coding: UTF-8 -*- ...
  • 基于c语言实现socket文件传输

    千次阅读 2021-06-05 16:03:59
    c语言实现基于socket文件传输,从server传输到client。

    一.概述

      本文基于socket实现server到client的文件传输,测试流程为client向server发起文件下载请求,同时将文件名发送给server;server收到client的请求之后根据文件名到本地目录中查找相应文件,若是找到匹配的文件则使用fread将文件中的内容读出到buffer缓存中,使用scoket send函数发送给client,client收到数据之后将buffer中的内容使用fwrite函数写到文件中。整个过程使用到的基本操作就是:socket网络传输+文件操作。

    二.实现源码

    2.1 server.c源码实现:

    #include<netinet/in.h>   
    #include<sys/types.h>   
    #include<sys/socket.h>   
    #include<stdio.h>   
    #include<stdlib.h>   
    #include<string.h>   
    #include<arpa/inet.h>
    #include<unistd.h>
    
    #define PORT 17980						//定义服务器端口号
    #define SERVER "192.168.44.129"			//定义服务器的IP地址
    
    #define LENGTH_OF_LISTEN_QUEUE     20  
    #define BUFFER_SIZE                4096  
    #define FILE_NAME_MAX_SIZE         512  
      
    int main(int argc, char **argv)  
    {  
    	FILE *fp = NULL;
        // set socket's address information   
        // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口  
        struct sockaddr_in   server_addr;  
        bzero(&server_addr, sizeof(server_addr));  
        server_addr.sin_family = AF_INET;  
        server_addr.sin_addr.s_addr = inet_addr(SERVER);  
        server_addr.sin_port = htons(PORT);  
      
        // create a stream socket   
        // 创建用于internet的流协议(TCP)socket,用server_socket代表服务器向客户端提供服务的接口  
        int server_socket = socket(PF_INET, SOCK_STREAM, 0);  
        if (server_socket < 0)  
        {  
            printf("Create Socket Failed!\n");  
            exit(1);  
        }  
    	printf("Create Socket Success!\n");  
      
    	//注意:由TCP套接字状态TIME_WAIT引起在结束本次会话后close立刻开启下次会话会Bind失败。
    	//该状态在套接字关闭后约保留 2 到 4 分钟。在 TIME_WAIT 状态退出之后,套接字被删除,该地址才能被重新绑定而不出问题。
    	//因此下面两句话的加入可以解决这个问题
    	int on = 1;
    	setsockopt( server_socket, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) );
    
        // 把socket和socket地址结构绑定   
        if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))  
        {  
            printf("Binded success!\n");  
            exit(1);  
        }  
    	printf("Create Socket Success!\n");  
    	
        // server_socket用于监听   
        if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))  
        {  
            printf("Server Listen Failed!\n");  
            exit(1);  
        }  
    	printf("server listen...\n");  
    	
    	// 定义客户端的socket地址结构client_addr,当收到来自客户端的请求后,调用accept  
    	// 接受此请求,同时将client端的地址和端口等信息写入client_addr中  
    	struct sockaddr_in client_addr;  
    	socklen_t          length = sizeof(client_addr);  
    
    	// 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中  
    	// 如果没有连接请求,则一直等待直到有连接请求为止,这是accept函数的特性,可以  
    	// 用select()来实现超时检测   
    	// accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信  
    	// 这里的new_server_socket代表了这个通信通道  
    	int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);  
    	if (new_server_socket < 0)  
    	{  
    		printf("Server Accept Failed!\n");  
    		exit(1);  
    	}  
    	printf("listen连接客户端成功,new_server_socket = %d\n",new_server_socket);  
    	printf("客户端ip =  %s\n",inet_ntoa(client_addr.sin_addr));
    	printf("客户端端口号port = %d\n",ntohs(client_addr.sin_port));
    		
        // 服务器端一直运行用以持续为客户端提供服务   
    	char buffer[BUFFER_SIZE];  
        while(1)  
        {  
            bzero(buffer, sizeof(buffer));  
    		printf("等待客户端发送过来的文件名:\n");
            length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);  
    		if(length > 0)
    		{
    			printf("接收client消息成功:'%s',共%d个字节的数据\n", buffer, length);
    		}
            else
            {  
                printf("客户端断开了连接,退出!!!\n");  
                break;  
            }  
            char file_name[FILE_NAME_MAX_SIZE + 1];  
            bzero(file_name, sizeof(file_name));  
            strncpy(file_name, buffer,strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));  
      
            fp = fopen(file_name, "r");  
            if (fp == NULL)  
            {  
                printf("File:\t%s Not Found!\n", file_name);  
            }  
            else  
            {  
    			printf("File:\t%s open success!\n", file_name);  
                bzero(buffer, BUFFER_SIZE);  
                int file_block_length = 0;  
    			//循环将文件file_name(fp)中的内容读取到buffer中
                while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)  
                {  
                    printf("读取到的文件长度file_block_length = %d\n", file_block_length);  
      
                    // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端  
                    if (send(new_server_socket, buffer, file_block_length, 0) < 0)  
                    {  
                        printf("Send File:\t%s Failed!\n", file_name);  
                        break;  
                    }  
    				//清空buffer缓存区
                    bzero(buffer, sizeof(buffer));  
                }  
                fclose(fp);  			//关闭文件描述符fp
                printf("File:\t%s Transfer Finished!\n", file_name);  
            }  
        }  
    	close(new_server_socket);  		//关闭accept文件描述符
        close(server_socket);  			//关闭socket文件描述符
        return 0;  
    }  
    

    2.2 client.c源码实现:

    //  
    // file_client.c  socket传输文件的client端示例程序   
    //
    #include<netinet/in.h>                         // for sockaddr_in  
    #include<sys/types.h>                          // for socket  
    #include<sys/socket.h>                         // for socket  
    #include<stdio.h>                              // for printf  
    #include<stdlib.h>                             // for exit  
    #include<string.h>                             // for bzero  
    #include<arpa/inet.h>  
    #include<unistd.h>
     
    #define SERV_PORT 	17980                   //服务器端口
    #define SERV_ADDR 	"192.168.44.129"         //服务器ip
    char recv_buf[4096];        //定义接收缓存区
    char send_buf[4096];        //定义发送缓存区
    
    int main(int argc, char **argv)  
    {  
    	int ret = -1;
    	int sockfd = -1;  //定义网络文件描述符
    	FILE *fp = NULL;  //定义文件操作指针
    	
    	struct sockaddr_in servaddr={0};  //服务器sockaddr_in定义成ipv4类型的服务器ip结构体(ipv6是sockaddr_inv6)
    
    	//1.首先使用socket函数创建网络文件描述符(类似于文件IO中的open函数)
        //函数原型:int socket(int domain, int type, int protocol);   
    	sockfd = socket(AF_INET, SOCK_STREAM, 0);   //ipv4,TCP,系统自动选择protocol
    	if(sockfd < 0)
    	{
    		printf("创建socket文件描述符失败\n");
    		_exit(-1);
    	}
    	printf("sockfd=%d\n",sockfd);
    	//2.使用connect函数连接服务器
    	//函数原型:int connect(int socket, const struct sockaddr *address,socklen_t address_len);
    	servaddr.sin_family = AF_INET;             			//定义servaddr的domain地址族为ipv4
    	servaddr.sin_port = htons(SERV_PORT);      			//定义servaddr的portnum为SERV_PORT(8010),host to net short
    	servaddr.sin_addr.s_addr = inet_addr(SERV_ADDR);  	//定义servaddr的address为SERV_ADDR(192.168.1.23)  person----->u32
    
        ret = connect(sockfd, (const struct sockaddr *)&servaddr,sizeof(servaddr));
    	if(ret < 0)
    	{
    		printf("客户端connect服务器失败\n");
    		_exit(-1);
    	}
    	printf("客户端connect服务器成功\n");
    	
    	//下面客户端和服务器互相收发
    	while(1)
    	{
    		//3.使用send函数发生数据
    		printf("请输入要发送给服务器的内容: \n");
    		scanf("%s", send_buf);  
    		if(!strncmp(send_buf,"+++",3))break;	//输入+++客户端断开连接
    		fp = fopen(send_buf, "w");  
    		if (fp == NULL)  
    		{  
    			printf("File:\t%s Can Not Open To Write!\n", send_buf);  
    			_exit(-1);  
    		}  
    		printf("File:\t%s Open Success,Waitting To Write...\n", send_buf); 
    		
    		ret = send(sockfd, send_buf, strlen(send_buf), 0);
    		printf("send buffer:%s,sned len:%d\n",send_buf,ret);
    		
    		//4.使用recv函数接收来自服务端的消息
    		ret = recv(sockfd, recv_buf, sizeof(recv_buf), 0);   
    		if(ret < 1)
    		{
    			printf("服务器断开了连接\n");
    			break;
    		}
    		printf("收到服务器发送的数据:recv buffer:\n%s\nrecv len:%d\n",recv_buf,ret);
    		printf("将接收到的数据写入文件中:\n");
    		//调用fwrite函数将recv_buf缓存中的数据写入文件中
    		int write_length = fwrite(recv_buf, sizeof(char), ret, fp);  
            if (write_length < ret)  
            {  
                printf("文件写入失败!\n");  
                break;  
            }  
    		printf("Recieve File:\t %s From Server[%s] 接收成功!\n", send_buf, SERV_ADDR);  
    		memset(send_buf,0,sizeof(send_buf));   //清空接收缓存区
    		memset(recv_buf,0,sizeof(recv_buf));   //清空接收缓存区
    		fclose(fp);  
    	}
    	printf("关闭连接并退出\n");
    	close(sockfd);     //关闭socket文件描述符
    	return 0;
    }  
    

    三.编译及测试

    编译:

    gcc send_file_server.c -o server
    gcc send_file_client.c -o client
    

    测试:
    1.在sever机器上与server同路径下创建test.txt文件并随意写入内容;
    2.服务端启动server服务端程序如下:
    ./server
    在这里插入图片描述
    3.客户端启动client服务端程序如下:
    ./client
    在这里插入图片描述
    4.客户端发送需要下载的文件(如test.txt):
    在这里插入图片描述
    5.server服务端的响应动作如下:
    在这里插入图片描述

    展开全文
  • 使用socket实现文件传输同时使用了多线程,首先服务端选择文件,开始监听启动客户端,选择连接就实现了文件的传输。 注意: 不同机器连接要修改源代码的的ip地址。 开发环境为Visual Studio 2010
  • 本文所述示例程序是基于Linux平台的socket网络编程,实现文件传输功能。该示例是基于TCP流协议实现的socket网络文件传输程序。采用C语言编写。最终能够实现传输任何格式文件的文件传输程序。 具体实现代码如下: ...
  • 近需要进行网络传输大文件,于是对基于socket文件传输作了一个初步的了解。在一位网友提供的程序基础上,俺进行了一些加工,采用了缓冲输入/输出流来包装输出流,再采用数据输入/输出输出流进行包装,加快传输的...
  • linux下的c++实现socket文件传输功能

    热门讨论 2012-07-13 10:49:35
    在linux下的c/c++实现的socket文件传输
  • aio方式socket文件传输,客户端的server IP,server port,文件路径设为传递参数,服务端的port设为传递参数
  • 主要为大家详细介绍了基于python3实现socket文件传输和校验,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 好,在发送消息的基础上增加文件传输。后期会增加视频,音频的传输,增加表情包。那一起来看看图文消息的效果图,带领大家一起来实现通讯的简易聊天功能。 需要解决的难点: 如何判断socket接收的
  • socket文件传输代码

    2016-07-19 13:30:09
    gui界面,客户端向服务器端传送文件
  • C# Socket实现大文件的分包上传。基本原理:添加客户端缓存,计算上传文件的字节,计算包的数量 ,计算最后一个包的字节。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 246,224
精华内容 98,489
关键字:

socket文件传输

友情链接: 数据恢复精灵.rar