wininet 异步+多线程

一、http://topic.csdn.net/t/20050915/17/4273306.html

异步方式并不是什么高深莫测的事物，WinInet   API   更是大家耳熟能详。  
   
  如果你仔细看过   MSDN   和   internet   上关于   WinInet   API   的文章，你会发现尽管在很多篇章中提到了异步方式的使用，但是大部分说明都只说可以使用，而没有说如何使用。尽管如此，还是有一些文章可以给我们很多的提示，我会在后面列出。  
   
  由于网络数据传输经常会消耗一定的时间，因此我们总是把这些可能消耗时间的操作放到一个单独的子线程，以免影响主线程正常的进行。可是当子线程发生长时间阻塞的时候，主线程由于某种原因需要退出，我们通常希望子线程能在主线程退出前正常退出。这时主线程就不得不   wait   子线程，这样就导致主线程也被阻塞了。当然，主线程可以不   wait   子线程而自行退出，还可以使用   TerminateThread   强行终止子线程，但是这样的后果通常是不可预料的，内存泄漏或许是最轻的一种危害了。  
   
  使用异步方式是解决这类问题的正确手段，下面我们根据一个实例来分析一下   WinInet   API   异步方式的使用方法和注意事项。  
   
  我们的例子完成这样的功能：给定一个   URL   (如：http://www.sina.com.cn/)，使用   HTTP   协议下载该网页或文件。我们一共创建了三个线程：主线程负责创建下载子线程，并等待子线程返回消息；子线程则使用异步方式的   WinInet   API   完成下载任务，并在各个阶段返回消息给主线程；子线程还会创建一个回调函数线程，其作用我们稍后解释。  
   
  实例代码中涉及到一些线程，消息，事件，错误处理的   API，由于不是我讨论的内容，就不仔细说明了。  
   
  1.   主线程工作流程  
    a.   创建下载子线程  
      m_hMainThread   =   ::CreateThread(NULL,  
        0,  
        AsyncMainThread,  
        this,  
        NULL,  
        &m_dwMainThreadID);  
   
    b.   等待子线程返回消息  
      MSG   msg;  
      while   (1)  
      {  
        ::GetMessage(&msg,   m_hWnd,   0,   0);  
     
        if   (msg.message   ==   WM_ASYNCGETHTTPFILE)  
        {   //子线程发回消息  
          switch(LOWORD(msg.wParam))  
          {  
          case   AGHF_FAIL:  
            {  
            MessageBox(_T("下载行动失败结束！"));  
            return;  
            }  
          case   AGHF_SUCCESS:  
            MessageBox(_T("下载行动成功结束！"));  
            return;  
          case   AGHF_PROCESS:  
            //下载进度通知  
            break;  
          case   AGHF_LENGTH:  
            //获取下载文件尺寸通知  
            break;  
          }  
        }  
     
        DispatchMessage(&msg);  
      }  
     
  2.   下载子线程工作流程  
    a.   使用标记   INTERNET_FLAG_ASYNC   初始化   InternetOpen  
      m_hInternet   =   ::InternetOpen(m_szAgent,  
        INTERNET_OPEN_TYPE_PRECONFIG,  
        NULL,  
        NULL,  
        INTERNET_FLAG_ASYNC);  
      起步并不费劲，也不难理解，MSDN   上说这样设置之后，以后所有的   API   调用都是异步的了。  
      警惕......  
      看起来好像很简单，但是会有无数的陷阱等着我们掉进去。  
   
    b.   设置状态回调函数   InternetSetStatusCallback  
      ::InternetSetStatusCallback(m_hInternet,   AsyncInternetCallback);  
      第一个陷阱就在这里等着你呢，文献[2]中提到使用一个单独的线程来进行这项设置，并解释说如果不这样会有潜在的影响，而在其他文档中却没有这样使用的例子。尽管看起来多余，并且增加了一些复杂度，我们还是先把这种方法写出来再讨论。子线程需要创建一个回调函数线程：  
      //重置回调函数设置成功事件  
      ::ResetEvent(m_hEvent[0]);  
      m_hCallbackThread   =   ::CreateThread(NULL,  
        0,  
        AsyncCallbackThread,  
        this,  
        NULL,  
        &m_dwCallbackThreadID);  
      //等待回调函数设置成功事件  
      ::WaitForSingleObject(m_hEvent[0],   INFINITE);  
      回调函数线程的实现如下：  
      DWORD   WINAPI   CAsyncGetHttpFile::AsyncCallbackThread(LPVOID   lpParameter)  
      {  
        CAsyncGetHttpFile   *   pObj   =   (CAsyncGetHttpFile*)lpParameter;  
       
        ::InternetSetStatusCallback(pObj->m_hInternet,   AsyncInternetCallback);  
       
        //通知子线程回调函数设置成功，子线程可以继续工作  
        ::SetEvent(pObj->m_hEvent[0]);  
         
        //等待用户终止事件或者子线程结束事件  
        //子线程结束前需要设置子线程结束事件，并等待回调线程结束  
        ::WaitForSingleObject(pObj->m_hEvent[2],   INFINITE);  
        return   0;  
      }  
      确实复杂了很多吧，虽然我试验的结果发现两种设置方法都能正确工作，但是确实发现了这两种设置方法产生的一些不同效果，遗憾的是我没有弄清具体的原因。我推荐大家使用后一种方法。  
   
    c.   打断一下子线程的流程，由于回调函数和上一部分的关系如此密切，我们来看看它的实现  
      void   CALLBACK   CAsyncGetHttpFile::AsyncInternetCallback(  
        HINTERNET   hInternet,  
        DWORD   dwContext,  
        DWORD   dwInternetStatus,  
        LPVOID   lpvStatusInformation,  
        DWORD   dwStatusInformationLength)  
      {  
        CAsyncGetHttpFile   *   pObj   =   (CAsyncGetHttpFile*)dwContext;  
        //在我们的应用中，我们只关心下面三个状态  
        switch(dwInternetStatus)  
        {  
        //句柄被创建  
        case   INTERNET_STATUS_HANDLE_CREATED:  
          pObj->m_hFile   =   (HINTERNET)(((LPINTERNET_ASYNC_RESULT)  
            (lpvStatusInformation))->dwResult);  
          break;  
        //句柄被关闭  
        case   INTERNET_STATUS_HANDLE_CLOSING:  
          ::SetEvent(pObj->m_hEvent[1]);  
          break;  
        //一个请求完成，比如一次句柄创建的请求，或者一次读数据的请求  
        case   INTERNET_STATUS_REQUEST_COMPLETE:  
          if   (ERROR_SUCCESS   ==   ((LPINTERNET_ASYNC_RESULT)  
            (lpvStatusInformation))->dwError)  
          {   //设置句柄被创建事件或者读数据成功完成事件  
            ::SetEvent(pObj->m_hEvent[0]);  
          }  
          else  
          {   //如果发生错误，则设置子线程退出事件  
            //这里也是一个陷阱，经常会忽视处理这个错误，  
            ::SetEvent(pObj->m_hEvent[2]);  
          }  
          break;  
        }  
      }  
　　d.   继续子线程的流程，使用   InternetOpenUrl   完成连接并获取下载文件头信息  
      //重置句柄被创建事件  
      ::ResetEvent(m_hEvent[0]);  
      m_hFile   =   ::InternetOpenUrl(m_hInternet,  
        m_szUrl,  
        NULL,  
        NULL,  
        INTERNET_FLAG_DONT_CACHE   |   INTERNET_FLAG_RELOAD,  
        (DWORD)this);  
      if   (NULL   ==   m_hFile)  
      {  
        if   (ERROR_IO_PENDING   ==   ::GetLastError())  
        {  
          if   (WaitExitEvent())  
          {  
            return   FALSE;  
          }  
        }  
        else  
        {  
          return   FALSE;  
        }  
      }  
      等我们把   WaitExitEvent   函数的实现列出在来再解释发生的一切：  
      BOOL   CAsyncGetHttpFile::WaitExitEvent()  
      {  
        DWORD   dwRet   =   ::WaitForMultipleObjects(3,   m_hEvent,   FALSE,   INFINITE);  
        switch   (dwRet)  
        {  
        //句柄被创建事件或者读数据请求成功完成事件  
        case   WAIT_OBJECT_0:  
        //句柄被关闭事件  
        case   WAIT_OBJECT_0+1:  
        //用户要求终止子线程事件或者发生错误事件  
        case   WAIT_OBJECT_0+2:  
          break;  
        }  
        return   WAIT_OBJECT_0   !=   dwRet;  
      }  
      在这里我们终于看到异步方式的巨大优势了，InternetOpenUrl   函数要完成域名解析，服务器连接，发送请求，接收返回头信息等任务，异步方式中   InternetOpenUrl   并不等待成功创建了   m_hFile   才返回，我们看到   m_hFile   是可以在回调函数中赋值的。如果   InternetOpenUrl   的返回值为   NULL   并且   GetLastError   返回   ERROR_IO_PENDING，我们使用   WaitForMultipleObjects   来等待请求的成功完成，这样主线程就有机会在这个等待过程中终止子线程的操作。我真是迫不及待的想把主线程如何强行终止子线程的代码列出来了：  
      //设置要求子线程结束事件  
      ::SetEvent(m_hEvent[2]);  
      //等待子线程安全退出  
      ::WaitForSingleObject(m_hMainThread,   INFINITE);  
      //关闭线程句柄  
      ::CloseHandle(m_hMainThread);  
      哈哈，不需要使用   TerminateThread   终止线程，一切都是安全的，可预料的。  
      我们再考虑一种情况，这种情况好得超乎你的想象，InternetOpenUrl   返回了一个非空的   m_hFile   怎么办？呵呵，这说明   InternetOpenUrl   已经成功创建了一个   m_hFile，并且没有发生任何阻塞，都不用等待任何事件，直接继续下一步吧。  
      最后需要说明得是，InternetOpenUrl   的最后一个参数会被作为回调函数的第二个参数使用。并且哪怕在回调函数中不需要这个参数，这个值你也不能设置为   0，否则   InternetOpenUrl   将不会按照异步的方式工作。  
      到这里，我们已经将   WinInet   API   的异步方式使用的关键部分都展示了，你应该可以使用   WinInet   API   的异步方式写出你自己的应用了。不过还是让我们继续完成这个实例的其他部分。  
   
    e.   使用   HttpQueryInfo   分析头信息  
      DWORD   dwStatusSize   =   sizeof(m_dwStatusCode);  
      if   (FALSE   ==   ::HttpQueryInfo(m_hFile,  
        HTTP_QUERY_STATUS_CODE   |   HTTP_QUERY_FLAG_NUMBER,  
        &m_dwStatusCode,  
        &dwStatusSize,  
        NULL))     //获取返回状态码  
      {  
        return   FALSE;  
      }  
      //判断状态码是不是   200  
      if   (HTTP_STATUS_OK   !=   m_dwStatusCode)  
      {  
        return   FALSE;  
      }  
      DWORD   dwLengthSize   =   sizeof(m_dwContentLength);  
      if   (FALSE   ==   ::HttpQueryInfo(m_hFile,  
        HTTP_QUERY_CONTENT_LENGTH   |   HTTP_QUERY_FLAG_NUMBER,  
        &m_dwContentLength,  
        &dwLengthSize,  
        NULL))     //获取返回的Content-Length  
      {  
        return   FALSE;  
      }  
      ...//通知主线程获取文件大小成功  
      需要说明的是   HttpQueryInfo   并不进行网络操作，因此它不需要进行异步操作的处理。  
   
    f.   使用标记   IRF_ASYNC   读数据   InternetReadFileEx  
      //为了向主线程报告进度，我们设置每次读数据最多   1024   字节  
      for   (DWORD   i=0;   i<m_dwContentLength;   )  
      {  
        INTERNET_BUFFERS   i_buf   =   {0};  
        i_buf.dwStructSize   =   sizeof(INTERNET_BUFFERS);  
        i_buf.lpvBuffer   =   new   TCHAR[1024];  
        i_buf.dwBufferLength   =   1024;  
     
        //重置读数据事件  
        ::ResetEvent(m_hEvent[0]);  
        if   (FALSE   ==   ::InternetReadFileEx(m_hFile,  
          &i_buf,  
          IRF_ASYNC,  
          (DWORD)this))  
        {  
          if   (ERROR_IO_PENDING   ==   ::GetLastError())  
          {  
            if   (WaitExitEvent())  
            {  
              delete[]   i_buf.lpvBuffer;  
              return   FALSE;  
            }  
          }  
          else  
          {  
            delete[]   i_buf.lpvBuffer;  
            return   FALSE;  
          }  
        }  
        else  
        {  
          //在网络传输速度快，步长较小的情况下，  
          //InternetReadFileEx   经常会直接返回成功，  
          //因此要判断是否发生了用户要求终止子线程事件。  
          if   (WAIT_OBJECT_0   ==   ::WaitForSingleObject(m_hEvent[2],   0))  
          {  
            ::ResetEvent(m_hEvent[2]);  
            delete[]   i_buf.lpvBuffer;  
            return   FALSE;  
          }  
        }  
        i   +=   i_buf.dwBufferLength;  
        ...//保存数据  
        ...//通知主线程下载进度  
        delete[]   i_buf.lpvBuffer;  
      }  
      这里   InternetReadFileEx   的异步处理方式同   InternetOpenUrl   的处理方式类似，我没有使用   InternetReadFile   因为它没有异步的工作方式。  
   
    g.   最后清理战场，一切都该结束了  
      //关闭   m_hFile  
      ::InternetCloseHandle(m_hFile);  
      //等待句柄被关闭事件或者要求子线程退出事件  
      while   (!WaitExitEvent())  
      {  
        ::ResetEvent(m_hEvent[0]);  
      }  
      //设置子线程退出事件，通知回调线程退出  
      ::SetEvent(m_hEvent[2]);  
      //等待回调线程安全退出  
      ::WaitForSingleObject(m_hCallbackThread,   INFINITE);  
      ::CloseHandle(m_hCallbackThread);  
      //注销回调函数  
      ::InternetSetStatusCallback(m_hInternet,   NULL);  
      ::InternetCloseHandle(m_hInternet);  
      ...//通知主线程子线程成功或者失败退出  
   
   
  实例中，我们建立一个完整的   HTTP   下载程序，并且可以在主线程中对下载过程进行完全的监控。我们使用了   WinInet   API   中的这些函数：  
    InternetOpen  
    InternetSetStatusCallback  
    InternetOpenUrl  
    HttpQueryInfo  
    InternetReadFileEx  
    InternetCloseHandle  
  其中   InternetOpenUrl   和   InternetReadFileEx   函数是按照异步方式工作的，文献[4]中列出了可以按照异步方式工作的   API：  
    FtpCreateDirectory  
    FtpDeleteFile  
    FtpFindFirstFile  
    FtpGetCurrentDirectory  
    FtpGetFile  
    FtpOpenFile  
    FtpPutFile  
    FtpRemoveDirectory  
    FtpRenameFile  
    FtpSetCurrentDirectory  
    GopherFindFirstFile  
    GopherOpenFile  
    HttpEndRequest  
    HttpOpenRequest  
    HttpSendRequestEx  
    InternetConnect  
    InternetOpenUrl  
    InternetReadFileEx  

 

二、

 http://hi.baidu.com/zhaquanmin/blog/item/c9989a2457dad16935a80f38.html

 

基于WININET下HTTP协议访问之同步异步篇

2009-08-02 10:45

      基于WININET下HTTP协议访问，不采用VC下的封装类CInternetSession，因为它的异步操作理论上可行，MSDN中说明实际代码还在完善。

WININET API下以在HTTP协议下下载一个页面的源代码信息为例，先来看看同步的流程：
1)InternetOpen；
2)InternetOpenUrl；
3)HttpQueryInfo；
4)InternetReadFile；
5)InternetCloseHandle。
       在第2步和第4步，程序会一直等待，直到函数返回。如果要设置超时，可以使用InternetSetOption(不过好像没什么用)。在很多时候，这个函数是不合适的。比如用户主动要中断下载，却只能等待函数返回。还有，如果是大文件下载，无法想像一次读取上兆字节的数据，需使用断点续传，虽然也可以使用同步函数InternetSetFilePointer来定位网络文件读取位置，但很多服务器是不支持的。如果在手机上使用，还要考虑诸如移动网关的限制等等。
同步的好处是函数较少，流程清晰，调试也方便。

再采用异步方法，看看异步的总体流程：
1)InternetOpen，需指定是异步；
2)InternetSetStatusCallback,设置回调；
3)InternetOpenUrl,需指定回调参数；
4)WaitForSingObject或WaitForMultipleObjects，接收信号量；
5)HttpQueryInfo；
6)InternetReadFileEx，需指定回调参数；
7)WaitForSingObject或WaitForMultipleObjects，接收信号量；
8)InternetSetStatusCallback,卸载回调；
9)InternetCloseHandle。

    可以看出，异步比同步要复杂了不少，重点在于回调函数。在回调中，系统会及时返回各种系统定义的HTTP消息，我们根据这些消息来设置某些信号量。在WaitForSingObject或WaitForMultipleObjects里，等待这些信号(当然也可以等待用户的取消动作)。当有正确的信号返回时，继续往下的操作。
    异步方式下，InternetOpenUrl可以在header头里设置要读取的范围。比如读0到1024的数据，在header头里加入Range: bytes=0-1024\r\n。这种方式保证了断点续传。要注意的是，如果服务器支持断点续传，此时使用HttpQueryInfo得到的状态码是206，而不是200。

回调函数写法：
    回调函数怎么写啊？看看微软提供的一个例子吧。这个例子是用POST的方式上传数据，比上述下载数据步骤更为麻烦，把InternetOpenUrl这个函数分成更多的函数来处理。有时间再挖挖这个例子。微软这个例子是在一个sendreqexasync.cpp的文件中，在微软的网站上应该可以得到。

源代码如下：

#include<windows.h>
#include<wininet.h>
#include<iostream.h>

DWORD dwNumKSent;
DWORD dwNumKToSend;
DWORD dwNumBytesComplete = 0;
char lpOutBuf[1024];
HANDLE hConnectedEvent, hRequestCompleteEvent;
HINTERNET hInstance, hConnect, hRequest;
char *lpszUrl, *lpszServer;

BOOL bAllDone = FALSE;

void __stdcall Callback(HINTERNET hInternet,
              DWORD dwContext,
              DWORD dwInternetStatus,
              LPVOID lpStatusInfo,
              DWORD dwStatusInfoLen);

void main(int argc, char *argv[])
{
    if (argc != 4)
    {
        cout << "Usage: sendreqexasync <server> <url> <size in kilobytes>" << endl;
        cout << "   Example: sendreqexasync http://www.foo.com/ /postfolder/upload.exe 256" << endl;
        return;
    }

    lpszServer = argv[1];
    lpszUrl = argv[2];
    dwNumKToSend = atoi(argv[3]);

    FillMemory(lpOutBuf, 1024, 'A');
    hConnectedEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    hRequestCompleteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

    hInstance = InternetOpen("sendreqexasync",
                                       INTERNET_OPEN_TYPE_PRECONFIG,
                                       NULL,
                                       NULL,
                                       INTERNET_FLAG_ASYNC);

    if (hInstance == NULL)
    {
        cout << "InternetOpen failed, error " << GetLastError();
        return;
    }

    if (InternetSetStatusCallback(hInstance,
                                  (INTERNET_STATUS_CALLBACK)&Callback) == INTERNET_INVALID_STATUS_CALLBACK)
    {
        cout << "InternetSetStatusCallback failed, error " << GetLastError();
        return;
    }

    hConnect = InternetConnect(hInstance,
                               lpszServer,
                               INTERNET_DEFAULT_HTTP_PORT,
                               NULL,
                               NULL,
                               INTERNET_SERVICE_HTTP,
                               0,
                               1);
    if (hConnect == NULL)
    {
        if (GetLastError() != ERROR_IO_PENDING)
        {
            cout << "InternetConnect failed, error " << GetLastError();
            return;
        }
        WaitForSingleObject(hConnectedEvent, INFINITE);
    }

    hRequest = HttpOpenRequest(hConnect,
                               "POST",
                               lpszUrl,
                               NULL,
                               NULL,
                               NULL,
                               INTERNET_FLAG_RELOAD | INTERNET_FLAG_NO_CACHE_WRITE,
                               2);
    if (hRequest == NULL)
    {
        if (GetLastError() != ERROR_IO_PENDING)
        {
            cout << "HttpOpenRequest failed, error " << GetLastError();
            return;
        }
        WaitForSingleObject(hRequestCompleteEvent, INFINITE);
    }

    INTERNET_BUFFERS IntBuff;

    FillMemory(&IntBuff, sizeof(IntBuff), 0);
    IntBuff.dwStructSize= sizeof(IntBuff);
    IntBuff.dwBufferTotal = 1024*dwNumKToSend;
    IntBuff.lpcszHeader = "Content-Type: text/text\r\n";
    IntBuff.dwHeadersLength = lstrlen(IntBuff.lpcszHeader);

    if (!HttpSendRequestEx(hRequest,
                           &IntBuff,
                           NULL,
                           0,
                           2))
    {
        if (GetLastError() != ERROR_IO_PENDING)
        {
            cout << "HttpSendRequestEx failed, error " << GetLastError();
            return;
        }
        cout << "HttpSendRequestEx called successfully" << endl;
        cout.flush();

        WaitForSingleObject(hRequestCompleteEvent, INFINITE);
    }

    for (dwNumKSent = 0; dwNumKSent < dwNumKToSend; dwNumKSent++)
    {
        DWORD dwBytesWritten;

        if(!InternetWriteFile(hRequest,
                               lpOutBuf,
                               1024,
                               &dwBytesWritten))
        {
            if (GetLastError() != ERROR_IO_PENDING)
            {
                cout << "InternetWriteFile failed, error " << GetLastError();
                return;
            }
            else
            {
                cout << "InternetWriteFile completing asynchronously" << endl;
                cout.flush();
                WaitForSingleObject(hRequestCompleteEvent, INFINITE);
            }
        }
    }

    cout << "Calling HttpEndRequest" << endl;
    cout.flush();
    if (!HttpEndRequest(hRequest, NULL, HSR_INITIATE, 2))
    {
        if (GetLastError() == ERROR_IO_PENDING)
        {
            cout << "HttpEndRequest called" << endl;
            cout.flush();
            WaitForSingleObject(hRequestCompleteEvent, INFINITE);
        }
        else
        {
            cout << "HttpEndRequest failed, error " << GetLastError() << endl;
            return;
        }
    }

    cout << "------------------- Read the response -------------------" << endl;
    char lpReadBuff[256];

    do
    {
        INTERNET_BUFFERS InetBuff;
        FillMemory(&InetBuff, sizeof(InetBuff), 0);
        InetBuff.dwStructSize = sizeof(InetBuff);
        InetBuff.lpvBuffer = lpReadBuff;
        InetBuff.dwBufferLength = sizeof(lpReadBuff) - 1;
       
        cout << "Calling InternetReadFileEx" << endl;
        cout.flush();

        if (!InternetReadFileEx(hRequest,
                              &InetBuff,
                              0, 2))
        {
            if (GetLastError() == ERROR_IO_PENDING)
            {
                cout << "Waiting for InternetReadFile to complete" << endl;
                cout.flush();
                WaitForSingleObject(hRequestCompleteEvent, INFINITE);
            }
            else
            {
                cout << "InternetReadFileEx failed, error " << GetLastError();
                cout.flush();
                return;
            }
        }

        lpReadBuff[InetBuff.dwBufferLength] = 0;
        cout << lpReadBuff;
        cout.flush();

        if (InetBuff.dwBufferLength == 0)
            bAllDone = TRUE;

    } while (bAllDone == FALSE);

    cout << endl << endl << "------------------- Request Complete ----------------" << endl;

}

/////这是回调函数，重点看下它的写法
void __stdcall Callback(HINTERNET hInternet,
              DWORD dwContext,
              DWORD dwInternetStatus,
              LPVOID lpStatusInfo,
              DWORD dwStatusInfoLen)
{
    cout << "Callback dwInternetStatus: " << dwInternetStatus << " Context: " << dwContext << endl;
    cout.flush();

    switch(dwContext)
    {
    case 1: // Connection handle
        if (dwInternetStatus == INTERNET_STATUS_HANDLE_CREATED)
        {
            INTERNET_ASYNC_RESULT *pRes = (INTERNET_ASYNC_RESULT *)lpStatusInfo;
            hConnect = (HINTERNET)pRes->dwResult;
            cout << "Connect handle created" << endl;
            cout.flush();
            SetEvent(hConnectedEvent);
        }
        break;
    case 2: // Request handle
        switch(dwInternetStatus)
        {
        case INTERNET_STATUS_HANDLE_CREATED:
            {
                INTERNET_ASYNC_RESULT *pRes = (INTERNET_ASYNC_RESULT *)lpStatusInfo;
                hRequest = (HINTERNET)pRes->dwResult;
                cout << "Request handle created" << endl;
                cout.flush();
            }
            break;
        case INTERNET_STATUS_REQUEST_SENT:
            {
                DWORD *lpBytesSent = (DWORD*)lpStatusInfo;
                cout << "Bytes Sent: " << *lpBytesSent << endl;
                dwNumBytesComplete += *lpBytesSent;
            }
            break;
        case INTERNET_STATUS_REQUEST_COMPLETE:
            {
                INTERNET_ASYNC_RESULT *pAsyncRes = (INTERNET_ASYNC_RESULT *)lpStatusInfo;
                cout << "Function call finished" << endl;
                cout << "dwResult: " << pAsyncRes->dwResult << endl;
                cout << "dwError: " << pAsyncRes->dwError << endl;
                cout.flush();
                SetEvent(hRequestCompleteEvent);
            }
            break;
        case INTERNET_STATUS_RECEIVING_RESPONSE:
            cout << "Receiving Response" << endl;
            cout.flush();
            break;
        case INTERNET_STATUS_RESPONSE_RECEIVED:
            {
                DWORD *dwBytesReceived = (DWORD*)lpStatusInfo;
                cout << "Received " << *dwBytesReceived << endl;
                cout.flush();
            }
        }
    }
}

 

 

三、

http://hi.baidu.com/fagex/blog/item/2999f4ce54c3953eb600c8e8.html

WinINet 异步下载类一实例(h)

2008-11-28 13:06

#include <wininet.h>
#include <mmsystem.h>

class AsyncWinINet
{
public:
   typedef void (*notify_fp)(const StringMap&);
  
   class thread_info
   {
   public:
    thread_info(const String& _url,     //请求下载的地址(in)
     const StringMap& _request_headrs,   //请求头request_headrs(in)
     const notify_fp& _pfp,      //下载进度通知回调函数指针
     const StringMap& _pfp_param,
     String& _response_headrs,     //返回头response_headrs(out)  
     const String& _saved_filename,    //下载内容保存文件名(in)
     String& _response_content,     //返回内容(out)
     size_t _read_content_size)     //控制保存在response_content中内容的长度(in)) :
     : request_headrs(_request_headrs), pfp(_pfp),
     pfp_param(_pfp_param),      //pfp函数传回参数
     response_headrs(_response_headrs), saved_filename(_saved_filename),
     response_content(_response_content), read_content_size(_read_content_size)
    {
     this->response_headrs.clear();
     this->response_content.clear();
     this->url = StringUtil::EncodeURIComponent(_url);
     for(int i = 0; i < 3; ++i)
     {
      this->hEvent[i] = CreateEvent(NULL,TRUE,FALSE,NULL);
     }
    }

    HANDLE hThread;
    DWORD dwThreadID;
    HANDLE hCallbackThread;
    DWORD dwCallbackThreadID;
    HANDLE hEvent[3];
    LPVOID hInternet;
    LPVOID hFile;
    DWORD dwStatusCode;
    DWORD dwContentLength;

    String url;         //请求下载的地址(in)
    const StringMap& request_headrs;   //请求头request_headrs(in)
    const notify_fp& pfp;      //下载进度通知回调函数指针
    const StringMap& pfp_param;     //pfp函数传回参数

    String& response_headrs;     //返回头response_headrs(out)  
    const String& saved_filename;    //下载内容保存文件名(in)
    String& response_content;     //返回内容(out)
    size_t read_content_size;     //控制保存在response_content中内容的长度(in)
   };

   /*******************************************************************************
   * 函数：download
   * 功能：下载，返回WinINet_ERR_CODE值
   *   说明：关于notify_fp 类型说明: 函数的参数为StringMap类型，传回的变量名与变量值
   * 2007-12
   *******************************************************************************/
   static DWORD download(const String& url, //请求下载的地址(in)
    const StringMap& request_headrs,   //请求头request_headrs(in)
    const notify_fp& pfp,      //下载进度通知回调函数指针
    const StringMap& pfp_param,     //pfp函数传回参数
    String& response_headrs,     //返回头response_headrs(out)  
    const String& saved_filename,    //下载内容保存文件名(in)
    String& response_content,     //返回内容(out)
    size_t read_content_size = 0);    //控制保存在response_content中内容的长度(in)

protected:
   static BOOL WaitExitEvent(thread_info *p);
   static DWORD WINAPI AsyncThread(LPVOID lpParameter);
   static DWORD WINAPI AsyncCallbackThread(LPVOID lpParameter);
   static VOID CALLBACK AsyncInternetCallback(HINTERNET hInternet,
    DWORD dwContext,
    DWORD dwInternetStatus,
    LPVOID lpvStatusInformation,
    DWORD dwStatusInformationLength);

};