WinInet单线程断点续传下载

最近比较空闲，尝试了一下网络方面的编程，于是兴起写一个多线程断点续传下载的简单demo。于是首先在网络上搜索各种实现思路，最终决定先从一个简单的单线程断点续传下载开始。

实现思路：

每次都以如果不存在则创建的方式打开要下载的文件，然后获取其大小size，然后给URL发送请求头，带上头信息range，并以size作为要获取的数据起始位置，终止位置不写（表明要获取后面所有的数据）。然后便是不断的向文件末尾追写数据。直至某一次启动下载的时候发现返回的状态码为416，表明范围超出了，则表示文件已经下载完成了。

关键知识点：

1、需要对HTTP协议有初步的理解，主要是对请求头与返回头的格式要求进行理解。

2、要明白Http请求头中range关键字的用法。

3、学会使用Goole Chrome的审查元素功能和微软的wfetch小工具进行Http请求头和返回头信息的查看。

4、最后，当然就是编程方面的知识了，包括wininet库的使用和基本的线程和文件的操作等。

 

剩下的便是按照这个思路，去慢慢的学习相关知识，然后编程实现这个Demo了。我这里粘上自己的代码，本人英语实在很差，但是还是尝试着使用英语去注释了，看不太懂的，可以来问我。

/*
    Filename:
            main.cpp

    Function：
            单线程断点续传功能实验。
            以文件本身的大小（没有则新创建）作为本次要下载时请求数据的起始位置，每次都将读取下来的数据追加到文件末尾。

    Knowledge：
            需要具备HTTP相关知识。
            HTTP 请求头中verb（行为）可以用HEADER去获取大小，但是我们这里不需要去获取大小，所以不需要。
            HTTP Header中存在range关键字用于指定所请求的数据范围。格式为"Range: bytes=StartPos-EndPos\r\n"如果"EndPos"不写，则默认为接收后面所有数据。
                如果StartPos超出了范围，则会返回”416 Requested Range Not Satisfiable“。当存在Range时返回的状态码始终为206。
                另外当EndPos==StartPos时，会返回1字节数据。当EndPos>StartPos时，返回所有数据。

    History：
        time:            2012/11/26
        remarks:        test finish
        auth:            monotone
*/

#include <Windows.h>   
#include <wininet.h>   
#include <stdio.h>   
#include <string>   
#include <iostream>   
#include <tchar.h>

using namespace std;   

#pragma comment(lib, "wininet.lib")   

const char* STR_TEST_URL = 
    "http://dl_dir.qq.com/qqfile/qq/QQ2013/QQ2013Beta1.exe"        // 以腾讯的QQ下载作为实验，这里是我临时加上的，之前我测试过下载更大的文件，没问题。
const DWORD DWORD_MAX_CCH_OF_TEST_URL = 256;
const DWORD DWORD_MAX_CCH_OF_HOST_NAME = 128;
const DWORD DWORD_MAX_CCH_OF_URL_PATH = 256;

BOOL GetWininetLastErrorMsgA(OUT string& rStrErrorMsg)
{
    BOOL lbResult = FALSE;
    char* lscErrorMsg = NULL;
    if(0 != FormatMessageA(
        FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ALLOCATE_BUFFER,             // dwFlags
        GetModuleHandle( TEXT("wininet.dll") ),  // lpSource
        GetLastError(),                          // dwMessageId
        0,                                       // dwLanguageId
        (LPTSTR)&lscErrorMsg,                    // lpBuffer
        0,                                        // nSize
        NULL))
    {
        rStrErrorMsg = lscErrorMsg;
        lbResult = TRUE;
    }

    if(NULL != lscErrorMsg)
        LocalFree(lscErrorMsg);

    return lbResult;
}


int main()   
{   
    HINTERNET hInetOpen = NULL;
    HINTERNET hInetConnect = NULL;
    HINTERNET hInetRequest = NULL;
    HANDLE lhFile = NULL;
    do
    {
        // struct to contains the constituent parts of a URL
        URL_COMPONENTS ldCrackedURL;   
        ZeroMemory(&ldCrackedURL, sizeof(URL_COMPONENTS));   
        ldCrackedURL.dwStructSize = sizeof(URL_COMPONENTS);                    // 必须设置

        // buffer to store host name
        TCHAR szHostName[DWORD_MAX_CCH_OF_HOST_NAME] = {0};
        ldCrackedURL.lpszHostName = szHostName;   
        ldCrackedURL.dwHostNameLength = DWORD_MAX_CCH_OF_HOST_NAME;            // 字符数

        // buffer to store url path
        char szUrlPath[DWORD_MAX_CCH_OF_URL_PATH] = {0}; 
        ldCrackedURL.lpszUrlPath = szUrlPath;   
        ldCrackedURL.dwUrlPathLength  = DWORD_MAX_CCH_OF_URL_PATH;            // 字符数

        // 该函数用来将给定的Ulr分割成对应的部分。如果URL_COMPONENTS内部成员指针指向提供的缓冲，则其对应的长度也必须提供缓冲区大小。函数成功返回后，会将实际拷贝的内容大小存放在指针对象的大小中，不包括最后结束符。
        // 如果提供的URL_COMPONENTS内部各指针指向NULL，而dwStructSize成员不为0，则调用函数后，指针成员会存储对应内容的第一个字符的地址，对应长度则为该内容实际的长度。
        // 注意不要在使用"file://"类的URL时包含空格。
        if(FALSE == InternetCrackUrlA(STR_TEST_URL, (DWORD)strlen(STR_TEST_URL), 0, &ldCrackedURL))
        {
            // GetLastError();
            break;
        }

        // Get file name，注意，只适用于ulr末尾包含了文件名的url。
        string loStrFileName(ldCrackedURL.lpszUrlPath);
        string::size_type liFileNamePos = loStrFileName.rfind("/");
        if(string::npos != liFileNamePos)
        {
            loStrFileName = loStrFileName.substr(liFileNamePos + 1, string::npos);
        }

        // open internet
        hInetOpen = InternetOpenA("Breakpoint Continue Dounload Sample", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
        if(NULL == hInetOpen)
        {
            // GetLastError();
            break;
        }

        // connect server 
        hInetConnect = InternetConnectA(hInetOpen, ldCrackedURL.lpszHostName, ldCrackedURL.nPort, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
        if(NULL == hInetConnect)
        {
            // GetLastError();
            break;
        }

        
        /* test 1:    
                    Read the destination file size as the size of data which download last(if file not exist, set the size to zero).
                    And set the value argument of HTTP Header "Range: bytes=value-\r\n" to "size - 1"(the size position).
                    Then open(or create) the file and append data from the end until no data to read, it means file download over.
        */
        
        // Get the file size
        lhFile = CreateFileA(loStrFileName.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        if(lhFile ==  INVALID_HANDLE_VALUE)
        {
            break;
        }
        LARGE_INTEGER ldFileSize;
        if(FALSE == GetFileSizeEx(lhFile, &ldFileSize))
        {
            break;
        }

        // make the start position
        LONGLONG lllStartPos = 0;
        if(0 == ldFileSize.QuadPart)
        {
            cout << "new file to download. " << endl;
        }
        else
        {
            // Set the file pointer position
            if(INVALID_SET_FILE_POINTER == SetFilePointer(lhFile, 0, NULL, FILE_END))
            {
                cout << "Move file pointer failed. " << endl;

                break;
            }

            lllStartPos = ldFileSize.QuadPart;
            cout << "continue to download from position:" << lllStartPos << endl;
        }

        // convert the range start position to character
        char lscRangeStartPosition[30] = {0};
        if(0 != _i64toa_s((__int64)(lllStartPos), lscRangeStartPosition, sizeof(lscRangeStartPosition), 10))
        {
            break;
        }

        // additional header: set the file data range .
        string loAdditionalHeader = "Range: bytes=";
        loAdditionalHeader += lscRangeStartPosition;            // start position of remaining
        loAdditionalHeader += "-\r\n";        

        // open request with "GET" verb to get the remaining file data
        const char* lplpszAcceptTypes[] = {"*/*", NULL};
        hInetRequest = HttpOpenRequestA(hInetConnect, "GET", ldCrackedURL.lpszUrlPath, "HTTP/1.1", NULL, lplpszAcceptTypes, 0, 0);
        if(NULL == hInetConnect)
        {
            // GetLastError();
            break;
        }

        // send request with additional header
        if(FALSE == HttpSendRequestA(hInetRequest, loAdditionalHeader.c_str(), loAdditionalHeader.size(), NULL, 0))
        {
            // GetLastError();
            break;
        }

        // query the status code from the reponse of servers
        DWORD ldwStatusCode;
        DWORD ldwCbOfStatusCode = sizeof(ldwStatusCode);
        if(FALSE == HttpQueryInfo(hInetRequest, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &ldwStatusCode, &ldwCbOfStatusCode, 0))
        {
            break;
        }
        

        //HTTP_QUERY_CONTENT_RANGE 
        //// get file size


        // check the status code
        if(416 == ldwStatusCode)                // 416 Requested Range Not Satisfiable
        {
            cout << "the file does not need to download." << endl;
            break;
        }
        else if(200 != ldwStatusCode && 206 != ldwStatusCode)    // 206 Partial Content
        {
            // statuscode means error occurred.
            break;
        }

        // loop to read the data from HTTP and store to file
        BYTE lpbBufferToReceiveData[2048];    // 存放读取数据的Buffer
        DWORD ldwCbBuffer = 2048;
        DWORD ldwCrtCbReaded;                // 本次实际读取的字节数
        DWORD ldwCbWritten = 0;                // 本次实际写入到文件的字节数
        bool lbIsOk = false;

        LONGLONG lllCbAllRead = 0;
        do  
        {   
            // read data
            if (FALSE == InternetReadFile(hInetRequest, lpbBufferToReceiveData, ldwCbBuffer,  &ldwCrtCbReaded))   
            {    
                cout << "read data failed." << endl;
                break;
            }

            
            if(ldwCrtCbReaded == 0)            // all data haved been read.
            {
                cout << "Congratulation! file download finish successfully." << endl;
                break;   
            }            

            // write to file
            if(FALSE == WriteFile(lhFile, lpbBufferToReceiveData, ldwCrtCbReaded, &ldwCbWritten, NULL) || ldwCbWritten != ldwCrtCbReaded) 
            { 
                cout << "A exception happens when write data to file" << endl;
                break; 
            }

            // clear data in buffer
            ZeroMemory(lpbBufferToReceiveData, ldwCrtCbReaded);

            lllCbAllRead += ldwCrtCbReaded;

            cout << "crt readed data size:——————————" << lllCbAllRead / 1048576 << "MB" << endl;

        } while (true);


    }while(false);
    string loStrErrorMsg;
    if(FALSE != GetWininetLastErrorMsgA(loStrErrorMsg))
    {
        cout << loStrErrorMsg.c_str() << endl;
    }

    if(NULL != lhFile)
    {
        CloseHandle(lhFile);
    }

    if(NULL != hInetRequest)
    {
        InternetCloseHandle(hInetRequest);
    }
    if(NULL != hInetConnect)
    {
        InternetCloseHandle(hInetConnect);
    }
    if(NULL != hInetOpen)
    {
        InternetCloseHandle(hInetOpen);
    }

    getchar();
    return 0;
}

 

不足之处：

1、没有检测服务器端到底支不支持断点续传。

2、没有检测当前网络状态。

3、对于整个流程的出错检测不是很清晰。