断点续传的原理

淡淡的烟草味﹌ 2024-04-01 14:50 59阅读 0赞

转载：https://blog.csdn.net/cwhatiscs/article/details/89708709  
断点续传是大型文件数据传输的核心。本文将以多线程技术和Socket技术为依托，介绍大型文件断点续传的实现方法。

基本实现思想

多线程断点续传实现的基本思想就是在发送端（也称客户端）将要传输的文件分割为大小相当的多块，用多个线程，将这些块同时向目标服务器端发送；在服务器端的服务程序监听数据传输请求，每当接到新的请求，则创建一个新的线程，与客户端的发送线程对应，接收数据，记录数据传输进程

图1是点对点文件断点续传第N块传输过程示意图。在传输发起端（客户端），将大型文件事先分割为大小相当的N块，同时创建N个传输线程，连接目标端服务器。当服务器端接收到每一个连接请求后，告知客户端可以传输文件。当客户端接收到可以传输文件的消息时，首先向服务器发送数据传输信息块（包括第几块、在块中的起始位置）请求，当服务器端接收到该请求后，向客户端发送数据传输信息，客户端然后传输数据传输信息块指定的数据给服务器端，服务器端更新数据传输信息块。

(一)断点续传的原理  
其实断点续传的原理很简单，就是在Http的请求上和一般的下载有所不同而已。  
打个比方，浏览器请求服务器上的一个文时，所发出的请求如下：  
假设服务器域名为wwww.sjtu.edu.cn，文件名为down.zip。  
GET /down.zip HTTP/1.1  
Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/vnd.ms-  
excel, application/msword, application/vnd.ms-powerpoint, */*  
Accept-Language: zh-cn  
Accept-Encoding: gzip, deflate  
User-Agent: Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)  
Connection: Keep-Alive

服务器收到请求后，按要求寻找请求的文件，提取文件的信息，然后返回给浏览器，返回信息如下：

200  
Content-Length=106786028  
Accept-Ranges=bytes  
Date=Mon, 30 Apr 2001 12:56:11 GMT  
ETag=W/“02ca57e173c11:95b”  
Content-Type=application/octet-stream  
Server=Microsoft-IIS/5.0  
Last-Modified=Mon, 30 Apr 2001 12:56:11 GMT

所谓断点续传，也就是要从文件已经下载的地方开始继续下载。所以在客户端浏览器传给  
Web服务器的时候要多加一条信息–从哪里开始。  
下面是用自己编的一个"浏览器"来传递请求信息给Web服务器，要求从2000070字节开始。  
GET /down.zip HTTP/1.0  
User-Agent: NetFox  
RANGE: bytes=2000070-  
Accept: text/html, image/gif, image/jpeg, \*; q=.2, */*; q=.2

仔细看一下就会发现多了一行RANGE: bytes=2000070-  
这一行的意思就是告诉服务器down.zip这个文件从2000070字节开始传，前面的字节不用传了。  
服务器收到这个请求以后，返回的信息如下：  
206  
Content-Length=106786028  
Content-Range=bytes 2000070-106786027/106786028  
Date=Mon, 30 Apr 2001 12:55:20 GMT  
ETag=W/“02ca57e173c11:95b”  
Content-Type=application/octet-stream  
Server=Microsoft-IIS/5.0  
Last-Modified=Mon, 30 Apr 2001 12:55:20 GMT

和前面服务器返回的信息比较一下，就会发现增加了一行：  
Content-Range=bytes 2000070-106786027/106786028  
返回的代码也改为206了，而不再是200了。

知道了以上原理，就可以进行断点续传的编程了。

(二)Java实现断点续传的关键几点

(1)用什么方法实现提交RANGE: bytes=2000070-。  
当然用最原始的Socket是肯定能完成的，不过那样太费事了，其实Java的net包中提供了这种功能。代码如下：  
URL url = new URL(“http://www.sjtu.edu.cn/down.zip”);  
HttpURLConnection httpConnection = (HttpURLConnection)url.openConnection

();  
//设置User-Agent  
httpConnection.setRequestProperty(“User-Agent”,“NetFox”);  
//设置断点续传的开始位置  
httpConnection.setRequestProperty(“RANGE”,“bytes=2000070”);  
//获得输入流  
InputStream input = httpConnection.getInputStream();

从输入流中取出的字节流就是down.zip文件从2000070开始的字节流。  
大家看，其实断点续传用Java实现起来还是很简单的吧。  
接下来要做的事就是怎么保存获得的流到文件中去了。

保存文件采用的方法。  
我采用的是IO包中的RandAccessFile类。  
操作相当简单，假设从2000070处开始保存文件，代码如下：  
RandomAccess oSavedFile = new RandomAccessFile(“down.zip”,“rw”);  
long nPos = 2000070;  
//定位文件指针到nPos位置  
oSavedFile.seek(nPos);  
byte\[\] b = new byte\[1024\];  
int nRead;  
//从输入流中读入字节流，然后写到文件中  
while((nRead=input.read(b,0,1024)) > 0)  
\{  
oSavedFile.write(b,0,nRead);  
\}

怎么样，也很简单吧。  
接下来要做的就是整合成一个完整的程序了。包括一系列的线程控制等等。

(三)断点续传内核的实现  
主要用了6个类，包括一个测试类。  
SiteFileFetch.java负责整个文件的抓取，控制内部线程(FileSplitterFetch类)。  
FileSplitterFetch.java负责部分文件的抓取。  
FileAccess.java负责文件的存储。  
SiteInfoBean.java要抓取的文件的信息，如文件保存的目录，名字，抓取文件的URL等。  
Utility.java工具类，放一些简单的方法。  
TestMethod.java测试类。

下面是源程序：  
/\*  
\*\*SiteFileFetch.java  
*/  
package NetFox;  
import java.io.*;  
import java.net.\*;

public class SiteFileFetch extends Thread \{

SiteInfoBean siteInfoBean = null; //文件信息Bean  
long\[\] nStartPos; //开始位置  
long\[\] nEndPos; //结束位置  
FileSplitterFetch\[\] fileSplitterFetch; //子线程对象  
long nFileLength; //文件长度  
boolean bFirst = true; //是否第一次取文件  
boolean bStop = false; //停止标志  
File tmpFile; //文件下载的临时信息  
DataOutputStream output; //输出到文件的输出流

public SiteFileFetch(SiteInfoBean bean) throws IOException  
\{  
siteInfoBean = bean;  
//tmpFile = File.createTempFile (“zhong”,“1111”,new File(bean.getSFilePath()));  
tmpFile = new File(bean.getSFilePath()+File.separator + bean.getSFileName()+“.info”);  
if(tmpFile.exists ())  
\{  
bFirst = false;  
read\_nPos();  
\}  
else  
\{  
nStartPos = new long\[bean.getNSplitter()\];  
nEndPos = new long\[bean.getNSplitter()\];  
\}

public void run()  
\{  
//获得文件长度  
//分割文件  
//实例FileSplitterFetch  
//启动FileSplitterFetch线程  
//等待子线程返回  
try\{  
if(bFirst)  
\{  
nFileLength = getFileSize();  
if(nFileLength == -1)  
\{  
System.err.println(“File Length is not known!”);  
\}  
else if(nFileLength == -2)  
\{  
System.err.println(“File is not access!”);  
\}  
else  
\{  
for(int i=0;i new FileSplitterFetch( siteInfoBean.getSSiteURL(),  
siteInfoBean.getSFilePath() + File.separator + siteInfoBean.getSFileName(),  
nStartPos\[i\],nEndPos\[i\],i);  
Utility.log( " Thread " + i + " , nStartPos =" + nStartPos\[i\]+", nEndPos = " + nEndPos\[i\]);  
fileSplitterFetch\[i\].start();  
\}  
// fileSplitterFetch\[nPos.length-1\] = new FileSplitterFetch(siteInfoBean.getSSiteURL(),  
siteInfoBean.getSFilePath() + File.separator + siteInfoBean.getSFileName() , nPos\[nPos.length-1\], nFileLength, nPos.length-1);  
// Utility.log("Thread " + (nPos.length-1 ) + " , nStartPos = " + nPos\[nPos.length-1\] + ",  
nEndPos = " + nFileLength);  
// fileSplitterFetch\[nPos.length-1\].start();

//等待子线程结束  
//int count = 0;  
//是否结束while循环  
boolean breakWhile = false;

while(!bStop)  
\{  
write\_nPos();  
Utility.sleep(500);  
breakWhile = true;

for(int i=0;i4)  
// siteStop();  
\}

System.err.println(“文件下载结束！”);  
\}  
catch(Exception e)\{e.printStackTrace ();\}  
\}

//获得文件长度  
public long getFileSize()  
\{  
int nFileLength = -1;  
try\{  
URL url = new URL(siteInfoBean.getSSiteURL());  
HttpURLConnection httpConnection = (HttpURLConnection)url.openConnection ();  
httpConnection.setRequestProperty(“User-Agent”,“NetFox”);

int responseCode=httpConnection.getResponseCode();  
if(responseCode>=400)  
\{  
processErrorCode(responseCode);  
return -2; //-2 represent access is error  
\}

String sHeader;

for(int i=1;;i++)  
\{  
//DataInputStream in = new DataInputStream(httpConnection.getInputStream ());  
//Utility.log(in.readLine());  
sHeader=httpConnection.getHeaderFieldKey(i);  
if(sHeader!=null)  
\{  
if(sHeader.equals(“Content-Length”))  
\{  
nFileLength = Integer.parseInt(httpConnection.getHeaderField(sHeader));  
break;  
\}  
\}  
else  
break;  
\}  
\}  
catch(IOException e)\{e.printStackTrace ();\}  
catch(Exception e)\{e.printStackTrace ();\}

Utility.log(nFileLength);

return nFileLength;  
\}

//保存下载信息（文件指针位置）  
private void write\_nPos()  
\{  
try\{  
output = new DataOutputStream(new FileOutputStream(tmpFile));  
output.writeInt(nStartPos.length);  
for(int i=0;iDataInputStream(new FileInputStream(tmpFile));  
int nCount = input.readInt();  
nStartPos = new long\[nCount\];  
nEndPos = new long\[nCount\];  
for(int i=0;i 0 & & nStartPos < nEndPos && !bStop)  
\{  
nStartPos += fileAccessI.write(b,0,nRead);  
//if(nThreadID == 1)  
// Utility.log("nStartPos = " + nStartPos + ", nEndPos = " + nEndPos);  
\}

Utility.log(“Thread " + nThreadID + " is over!”);  
bDownOver = true;  
//nPos = fileAccessI.write (b,0,nRead);  
\}  
catch(Exception e)\{e.printStackTrace ();\}  
\}  
\}

//打印回应的头信息  
public void logResponseHead(HttpURLConnection con)  
\{  
for(int i=1;;i++)  
\{  
String header=con.getHeaderFieldKey(i);  
if(header!=null)  
//responseHeaders.put(header,httpConnection.getHeaderField(header));  
Utility.log(header+" : "+con.getHeaderField(header));  
else  
break;  
\}  
\}

public void splitterStop()  
\{  
bStop = true;  
\}

/\*  
\*\*FileAccess.java  
*/  
package NetFox;  
import java.io.*;

public class FileAccessI implements Serializable\{

RandomAccessFile oSavedFile;  
long nPos;

public FileAccessI() throws IOException  
\{  
this(“”,0);  
\}

public FileAccessI(String sName,long nPos) throws IOException  
\{  
oSavedFile = new RandomAccessFile(sName,“rw”);  
this.nPos = nPos;  
oSavedFile.seek(nPos);  
\}

public synchronized int write(byte\[\] b,int nStart,int nLen)  
\{  
int n = -1;  
try\{  
oSavedFile.write(b,nStart,nLen);  
n = nLen;  
\}  
catch(IOException e)  
\{  
e.printStackTrace ();  
\}

return n;  
\}

/\*  
\*\*SiteInfoBean.java  
\*/  
package NetFox;

public class SiteInfoBean \{

private String sSiteURL; //Site’s URL  
private String sFilePath; //Saved File’s Path  
private String sFileName; //Saved File’s Name  
private int nSplitter; //Count of Splited Downloading File

public SiteInfoBean()  
\{  
//default value of nSplitter is 5  
this(“”,“”,“”,5);  
\}

public SiteInfoBean(String sURL,String sPath,String sName,int nSpiltter)  
\{  
sSiteURL= sURL;  
sFilePath = sPath;  
sFileName = sName;  
this.nSplitter = nSpiltter;

public String getSSiteURL()  
\{  
return sSiteURL;  
\}

public void setSSiteURL(String value)  
\{  
sSiteURL = value;  
\}

public String getSFilePath()  
\{  
return sFilePath;  
\}

public void setSFilePath(String value)  
\{  
sFilePath = value;  
\}

public String getSFileName()  
\{  
return sFileName;  
\}

public void setSFileName(String value)  
\{  
sFileName = value;  
\}

public int getNSplitter()  
\{  
return nSplitter;  
\}

public void setNSplitter(int nCount)  
\{  
nSplitter = nCount;  
\}  
\}

/\*  
\*\*Utility.java  
\*/  
package NetFox;

public class Utility \{

public Utility()  
\{

public static void sleep(int nSecond)  
\{  
try\{  
Thread.sleep(nSecond);  
\}  
catch(Exception e)  
\{  
e.printStackTrace ();  
\}  
\}

public static void log(String sMsg)  
\{  
System.err.println(sMsg);  
\}

public static void log(int sMsg)  
\{  
System.err.println(sMsg);  
\}  
\}

/\*  
\*\*TestMethod.java  
\*/  
package NetFox;

public class TestMethod \{

public TestMethod()  
\{ ///xx/weblogic60b2\_win.exe  
try\{  
SiteInfoBean bean = new SiteInfoBean(“http://localhost/xx/weblogic60b2\_win.exe”," L: emp",“weblogic60b2\_win.exe”,5);  
//SiteInfoBean bean = new SiteInfoBean(“http://localhost:8080/down.zip”," L: emp",“weblogic60b2\_win.exe”,5);  
SiteFileFetch fileFetch = new SiteFileFetch(bean);  
fileFetch.start();  
\}  
catch(Exception e)\{e.printStackTrace ();\}

public static void main(String\[\] args)  
\{  
new TestMethod();  
\}  
\}

一，最重要的一点，断点续传需要服务器的支持，这个是必要条件。  
传统的FTP SERVER是不支持断点续传的，因为它不支持REST指令，传统的FTP指令（我是指服务器端指令）并不包括REST指令。  
第二，客户端要知道使用REST等一系列指令来作断点续传。  
看看断点续传的详细过程（FTP SERVER）：  
首先客户端使用REST指令来告诉FTP SERVER它需要从文件的某个点开始传，接着用STOR或者RETR命令开始传文件，大概的命令的流程如下：  
TYPE I  
200 Type set to I.  
PASV  
227 Entering Passive Mode (204,48,18,69,98,250)  
REST 187392  
350 Restarting at 187392. Send STORE or RETRIEVE to initiate transfer.  
RETR /pub/audio/pci/maestro-3/win2k/1056.zip  
150 Opening BINARY mode data connection for /pub/audio/pci/maestro-3/win2k/1056.zip (936098 bytes).  
首先使用TYPE命令告诉FTP SERVER使用BINARY模式传送文件；  
然后使用PASV命令告诉FTP SERVER使用被动打开模式来传送文件；  
接着使用REST 187392指令告诉FTP SERVER要从文件的187392字节开始传送；  
最后使用RETR指令来传送文件。  
从上面可以看出，这个FTP SERVER支持REST指令，有的FTP SERVER（特别的老的）是不支持这个指令的，这时即使FTP CLIENT支持断点续传也一点用都没有！  
支持断点的FTP SERVER：Serv-U FTP，还有一系列的新出现的FTP SERVER；  
不支持断点的：IIS4以前版本所带的都不行，IIS5 有，不家可以测试一下，登录进FTP SERVER，然后输入REST 1000命令，看服务器是否认识，认识就是支持断点。  
上面说的是FTP SERVER的断点，HTTP的断点续传是这样的：  
在以前版本的HTTP SERVER也是不支持断点的，HTTP/1.1开始就支持了，具体如下：  
在HTTP请求的头部信息里面，通常是这样的：  
GET http://xxx.xxx.xxx.xxx/index.html HTTP/1.1  
Host:www.163.net  
Accept:*/*  
上面是HTTP请求头的主要内容，是浏览器等客户端发给HTTP SERVER的信息。  
在这个请求头里面，第一行叫做Request Line，GET叫做请求方法（通常得到一个HTML页面都是用GET，CGI等请求是用POST），http://bbs.netbuddy.org/index.html是URL，HTTP/1.1为版本号。  
Host:bbs.netbuddy.org是HTTP服务器名字，这也是HTTP/1.1的新东东，以前做虚拟主机可是要一个主机名对应多个IP，现在好了呵呵，这个离题太远，不说了）  
要做断点续传，浏览器等客户端需要在请求头里面发送  
Range: bytes=1140736-  
这样的请求，就是告诉HTTP SERVER，这个文件要从1140736字节开始传送。  
最 后一点，大家看了上面的描述可能会有一个问题，那么多点传送怎么做呢？那就是多起几个线程，连接到服务器，用断点指令来传送文件，在传送的过程中，会检查 前面的（比如说第一个蚂蚁）得到的文件的部分是否超过了后面的（比如说第二个蚂蚁）的起点，相等就停前面的蚂蚁，最后再合并几个部分，就得到一个完整的文 件了

--------------------

C版本实现方式:

3 具体实现

在实现过程中我使用了MFC的多线程和Windows的Socket，分客户端和服务器端实现。因为数据传输往往是对等的，所以需要将客户端和服务器端集成在一起，在客户端和服务器端分别实现后，这是件非常简单的工作，只需将它们集成在一起即可。下面将分别介绍客户端和服务器端的实现。

3.1 关键数据结构

文件信息数据结构 用于在服务器端和客户端之间传递文件第N块的属性信息，详细定义如下：

structfileinfo

int fileno; //文件号

int type; //消息类别

long len; //文件（块）长度，在客户端向服务器端发送数据时，是文件长度；

//在服务器端向客户端发送已传部分的信息时，是应该续传部分的长度；

long seek; //开始位置，标识要传输数据在原文件中的起始位置

char name\[MAX\_PATH\_LEN\];//文件名

\};

发送进度记录结构 用户记录文件传输进程，详细定义如下：

structSentInfo

long totle; //已经成功发送数据的长度；

int block; //块标识；

long filelen; //文件总长度；

int threadno; //负责传输第N块数据的线程标识；

CString name; //文件名称

\};

客户端类 客户端文件发送实例封装，用户记录客户端文件发送过程中的属性信息、已发送大小、发送线程句柄、发送线程状态、发送统计信息等，具体定义是：

classCClient:publicCObject

protected:

//Attributes

public:

CClient(CString ip);

~CClient();

SentInfo doinfo;

long m\_index; //块索引

BOOL sendOk\[BLOCK\]; //块发送结束状态

CString SendFileName;

CString DestIp; //目标IP地址

THREADSTATUS SendStatus;

int GetBlockIndex(); //获取当前要传输文件块的序号，例如0,1,2…

CCriticalSection m\_gCS;

//Sending File Block Thread Handles

HANDLE m\_thread\[BLOCK\]; //Block Sending Thread Handles Array

HANDLE m\_ExitThread; //WaitToExitThread Handle

HANDLE m\_ProcessTrackThread;

HANDLE m\_hEventKill; //User canceled Event

long m\_IdxInListCtrl; //Index in ListView

long m\_lBeginTimeTick;

long m\_lBytesSent;

// Operations

public:

\};

3.2 客户端

发送线程 用于发送由lpparam参数指定的Client对象标识的文件块数据。具体实现是：

//发送线程主函数

//并行进行的线程，针对每个要发送的文件有BLOCK个该线程

DWORDWINAPISendThread(LPVOIDlpparam)

CClient\* pClient=(CClient\*)lpparam;

int block\_index = pClient->GetBlockIndex();

//发送文件的第m\_index块

//发送线程

sockaddr\_in local;

SOCKET m\_socket;

int rc=0;

local.sin\_family=AF\_INET;

local.sin\_port=htons(pMainFrm->m\_FilePort);

local.sin\_addr.S\_un.S\_addr=inet\_addr(pClient->DestIp);

m\_socket=socket(AF\_INET,SOCK\_STREAM,0);

int ret;

char m\_buf\[MAX\_BUFSIZE\];

fileinfo file\_info;

//Connect to Server

ret = connect(m\_socket,(LPSOCKADDR)&local,sizeof(local));

while((ret == SOCKET\_ERROR)&&(WaitForSingleObject(pClient->m\_hEventKill, 0)

==WAIT\_TIMEOUT))

closesocket (m\_socket);

file\_info.len = pClient->doinfo.filelen ;

if (file\_info.len <= 0) //已经完成传输

return 1;

file\_info.seek=0;

file\_info.type=1; //从服务器上获取文件的第index块已接收的大小

file\_info.fileno = block\_index;

strcpy(file\_info.name,pClient->doinfo.name);

//发送第index块已发送大小请求

sendn(m\_socket,(char\*)&file\_info,PROTOCOL\_HEADSIZE);

long nRead = readn(m\_socket,m\_buf,PROTOCOL\_HEADSIZE);

if(nRead <= 0)

closesocket (m\_socket);

return -1;

fileinfo \* pfile\_info = (fileinfo\*)m\_buf;

if (pfile\_info->len == 0)

closesocket (m\_socket);

//block\_index块是续传，且发送完毕

pClient->good\[block\_index\] = TRUE;

return 1;

CFile SourceFile;

SourceFile.Open(pClient->SendFileName,

CFile::modeRead|CFile::typeBinary| CFile::shareDenyNone);

//Seek right position of sending file

long apos=SourceFile.Seek(pfile\_info->seek,CFile::begin);

int len1;

len1=pfile\_info->len;

//取得已经发送的长度

if (block\_index < BLOCK - 1)

pClient->doinfo.totle += pClient->doinfo.filelen / BLOCK - pfile\_info->len;

else

pClient->doinfo.totle += pClient->doinfo.filelen –

pClient->doinfo.filelen/BLOCK\* (BLOCK - 1) - pfile\_info->len;

int nBegin = GetTickCount();

int SendTotal = 0;

while((len1 > 0) && (WaitForSingleObject(pClient->m\_hEventKill, 0) == WAIT\_TIMEOUT))

nRead = SourceFile.Read(m\_buf, (len1 < pMainFrm->m\_CurrentBlockSize) ?

len1:pMainFrm->m\_CurrentBlockSize);

int send\_count=sendn(m\_socket,m\_buf,nRead);

float nLimit;

if(send\_count<=0)

closesocket (m\_socket);

SourceFile.Close();

return 1;

len1 = len1 - send\_count;

//进度信息

pClient->doinfo.totle += send\_count;

SendTotal += send\_count;

SourceFile.Close();

shutdown(m\_socket,2);

closesocket (m\_socket);

if(len1 <= 0)pClient->good\[block\_index\] = TRUE;

return 1;

创建发送线程 对应要发送的文件，创建BLOCK个线程，负责发送各自的数据块。

for(inti=0;i

//创建线程，状态为停止状态

pClient->m\_thread\[i\] = ::CreateThread(NULL,0,SendThread,(LPVOID)pClient,

CREATE\_SUSPENDED,&dwthread);

::SetThreadPriority(pClient->m\_thread\[i\],THREAD\_PRIORITY\_HIGHEST);

3.3 服务器端

监听函数 负责监听文件传输请求，在接受请求后，创建数据块接收线程，具体实现如下：

//监听函数

DWORDWINAPIlistenthread(LPVOIDlpparam)

SOCKET pSocket=(SOCKET)lpparam;

//最多监听MAX\_LISTENCOUNT个客户端连接

int rc=listen(pSocket,MAX\_LISTENCOUNT);

if (rc<0)

//Error

return 0;

//Listening all the incoming connections

while(1)

SOCKET aSocket;

//Listening and Block

aSocket=accept(pSocket,NULL,NULL);

DWORD dwthread;

// Create Server Data Receiving Thread “Serverthread”

// And Transfers data

::CreateThread(NULL,0, Serverthread,(LPVOID)aSocket,0,&dwthread);

return 0;

接收文件数据 负责接收由参数seek和len以及block\_index标识的数据块，实现如下：

//接收文件数据

voidRecvFile(SOCKETso,CStringPeerName,CString DestFileName,long seek,

longlen,intblock\_index,CFileInfoRecving\*pfileinfo)

CFile DestFile;

long fileseek = seek;

long filelen = len;

CMainFrame\* pWnd = (CMainFrame\*) AfxGetMainWnd();

if (!DestFile.Open(pWnd->m\_DestPath + “\\IP” + PeerName + “-” + DestFileName,

CFile::modeWrite|CFile::typeBinary| CFile::shareDenyNone))

DWORD error = GetLastError();

return;

\};

long apos = DestFile.Seek(fileseek,CFile::begin);

char m\_buf\[MAX\_BUFSIZE\];

CString m\_temp;

m\_temp.Format(“%s\\Temp\\IP%s-%s.%d”,pWnd->m\_appPath,PeerName,

DestFileName,block\_index);

CFile BlockFile;

BlockFile.Open(m\_temp, CFile::modeWrite | CFile::typeBinary);

while((filelen>0) && (WaitForSingleObject(pWnd->m\_hEventKill, 0) == WAIT\_TIMEOUT))

int nRead = readn(so, m\_buf, (filelen > MAX\_BUFSIZE) ? MAX\_BUFSIZE : filelen);

//Exited

if (nRead == 0)

CString msg;

msg.Format(“\[SOCKET %d\] Receiving file %s break(Recv 0).”,so,DestFileName);

pWnd->SendMessage(WM\_NEWMSG,(LPARAM)msg.GetBuffer(0),3);

msg.ReleaseBuffer();

break;

if(nRead<0)

CString msg;

msg.Format(“\[SOCKET %d\] Receiving file %s break.”,so,DestFileName);

pWnd->SendMessage(WM\_NEWMSG,(LPARAM)msg.GetBuffer(0),3);

msg.ReleaseBuffer();

break;

DestFile.Write(m\_buf,nRead);

filelen -= nRead;

fileseek += nRead;

BlockFile.Seek(0,CFile::begin);

BlockFile.Write(&fileseek,sizeof(long));

BlockFile.Write(&filelen,sizeof(long));

pfileinfo->m\_seek = fileseek;

pfileinfo->m\_len = filelen;

closesocket (so);

//Current Block Received OK

BlockFile.Close();

DestFile.Close();

if (filelen <= 0)

pfileinfo->canDel = true;

初始化文件数据块信息 负责初始化文件传输时数据块的大小、开始位置等信息。具体实现是：

//初始化文件数据块信息

CFileInfoRecving\*GetRecvedFileBlock(CStringPeerName,CStringFileName,long& filelen,

long&fileseek,intblock\_index)

CString m\_temp;

CMainFrame\* pWnd = (CMainFrame\*) AfxGetMainWnd();

m\_temp.Format(“%s\\temp\\IP%s-%s.%d”,pWnd->m\_appPath,PeerName,FileName,block\_index);

FILE\* fp=NULL;

CFile Blockfile;

CFile RecvFile;

long seek = fileseek;

long flen = filelen;

CString DestFile = pWnd->m\_DestPath + “\\IP” + PeerName + “-” + FileName;

bool DestFileNoExist = false;

if((fp=fopen(DestFile,“r”))==NULL)

RecvFile.Open(DestFile,

CFile::modeCreate|CFile::modeWrite|CFile::typeBinary| CFile::shareDenyNone);

RecvFile.Close();

DestFileNoExist = true;

if (fp) fclose(fp);

CFileInfoRecving\* pfileinfo = NULL;

//如果目标文件不存在或者长度记录文件不存在，重新传

if( ((fp=fopen(m\_temp,“r”))==NULL) || (DestFileNoExist))

//第一次接收

fileseek = block\_index\*(flen/BLOCK);

filelen = flen/BLOCK;

if (block\_index == (BLOCK - 1))

filelen = flen - fileseek;

//Add To Recving File List

pfileinfo = new CFileInfoRecving();

pfileinfo->m\_sFileName = FileName;

pfileinfo->m\_sPeerName = PeerName;

pfileinfo->m\_nBlockIndex = block\_index;

pfileinfo->m\_sFileSize.Format(“%d”,flen);

seek = fileseek;

flen = filelen;

pfileinfo->m\_seek = seek;

pfileinfo->m\_len = flen;

pWnd->m\_RecvingFileList.AddTail(pfileinfo);

Blockfile.Open(m\_temp,

CFile::modeCreate|CFile::modeWrite| CFile::typeBinary | CFile::shareDenyNone);

Blockfile.Write(&seek,sizeof(long));

Blockfile.Write(&flen,sizeof(long));

Blockfile.Close();

else

POSITION pos = pWnd->m\_RecvingFileList.GetHeadPosition();

while (pos)

pfileinfo = pWnd->m\_RecvingFileList.GetAt(pos);

if (pfileinfo)

if ((pfileinfo->m\_sFileName == FileName) &&

(pfileinfo->m\_sPeerName == PeerName) &&

(pfileinfo->m\_nBlockIndex == block\_index))

break;

pWnd->m\_RecvingFileList.GetNext(pos);

Blockfile.Open(m\_temp,CFile::modeRead | CFile::typeBinary | CFile::shareDenyNone);

Blockfile.Read(&fileseek,sizeof(long));

Blockfile.Read(&filelen,sizeof(long));

if ((pfileinfo == NULL) || (!pos))

pfileinfo = new CFileInfoRecving();

pfileinfo->m\_sFileName = FileName;

pfileinfo->m\_sPeerName = PeerName;

pfileinfo->m\_nBlockIndex = block\_index;

pfileinfo->m\_sFileSize.Format(“%d”,flen);

//Add To Recving File List

//pWnd->m\_RecvingFileListCS.Lock();

pWnd->m\_RecvingFileList.AddTail(pfileinfo);

//pWnd->m\_RecvingFileListCS.Unlock();

Blockfile.Close();

pfileinfo->m\_seek = fileseek;

pfileinfo->m\_len = filelen;

if (fp) fclose(fp);

return pfileinfo;

数据接收线程 负责从客户端接收数据信息：

//数据接收线程

DWORDWINAPIServerthread(LPVOIDlpparam)

fileinfo\* pFileInfo;

char\* m\_buf = new char\[PROTOCOL\_HEADSIZE\];

SOCKET pthis=(SOCKET)lpparam;

int nRead = readn(pthis,m\_buf,PROTOCOL\_HEADSIZE);

if( nRead < 0 )

closesocket (pthis);

return -1;

pFileInfo = (fileinfo\*)m\_buf;

CString MsgStr;

int addrlen;

CString FileID;

sockaddr\_in\* pSocket;

CFileInfoRecving\* pfileinfo;

switch(pFileInfo->type)

case 1:

//获取文件块的已接收大小

pfileinfo =

GetRecvedFileBlock(FileID,pFileInfo->name,pFileInfo->len,pFileInfo->seek,pFileInfo->fileno);

nRead = sendn(pthis,(char\*)pFileInfo,PROTOCOL\_HEADSIZE);

if(nRead < 0)

closesocket (pthis);

return -1;

//开始接收文件

RecvFile(pthis,FileID,pFileInfo->name,pFileInfo->seek,

pFileInfo->len,pFileInfo->fileno,pfileinfo);

closesocket(pthis);

break;

default:

break;

delete \[\] m\_buf;

return 0;

DEMO下载地址：https://dwz.cn/fgXtRtnu

断点续传的原理

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关断点续传的原理

相关文件断点续传

相关断点续传

相关断点续传

相关断点续传和下载原理分析

相关 nio 断点续传

相关断点续传和下载原理分析

相关 HTTP：断点续传原理图文分析

相关浅谈HTTP断点续传原理

相关 php 文件下载断点续传原理