httpget及httppost

1. #pragma once
2. /*
3. * HttpClient同步类
4. * 暂时只实现[方案二]
5. * 使用[方案一]:
6. * #include "SyncHttpClient.h"
7. * int main()
8. * {
9. *   CSyncHttpClient syncClient;
10. *   BYTE pData[1024];
11. *   uint16  uSize = 1024;
12. *   syncClient.SetHost(TEXT("192.168.1.1"));
13. *   syncClient.SetPort(8000);                   
14. *   syncClient.SetProgram(TEXT("/program"));    //.............or use default
15. *   if(syncClient.Request(pData, uSize))
16. *   {
17. *     BYTE *bRcvBuf = NULL;
18. *     uint16 uBufSize = 4069;
19. *     uint16 uPerTime = 512;
20. *     
21. *      if(syscClient.QueryContentLength(&uBufSize))
22. *      {
23. *        try{
24. *          bRcvBuf = new BYTE[nBufSize];
25. *        }
26. *        catch(...)
27. *        {
28. *          return;
29. *        }
30. *        if(syncClient.GetResponse(bRcvBuf, uBufSize, uPerTime))
31. *        {
32. *          //deal the data
33. *          delete []bRcvBuf;   
34. *        }
35. *      }
36. *   }
37. * }
38. * [方案二]：
39. * #include "SyncHTTPClient.h"
40. * class CClientTest:IDataSubscriber
41. * {
42. * public:
43. *   //收到数据包
44. *   virtual void OnPacketReceived(void *pData, UINT16 uSize){//dealit};
45. *   //数据进度
46. *   virtual void OnRecvDataPercent(IN BYTE nPercent){//update progress};
47. *   //数据接收出错
48. *   virtual void OnRcvError(IN INT16 nError){//report for error};
49. * };
50. * 
51. * int DoRequest(void *pData, short uLen)
52. * {
53. *   CClientTest test;
54. *   CNetDataAdapter ada(test);  //ada回主动找CConnectionManager要host等的配置
55. *   ada.Request(pData, uLen);
56. *   return 0;
57. * }
58. *
59. */
60. #include <wininet.h>
61. #include "DataInterface.h"
62. #define  _DEFAULT_HOST TEXT("192.168.1.10")
63. #define  _DEFAULT_PORT 80
64. #define  _DEFAULT_PROG TEXT("/test")
65. #define  _DEFAULT_MAX_RCV_BUF_SIZE 8192 * 20
66. #define  _DEFAULT_RECV_BUF_UNIT 4096
67. #define  _DEFAULT_REFERER_LENGTH 30
68. class CAsyncHttpClient :IDataCommunicater
69. {
70.     friend class CConnectManager;
71. public:
72.     enum
73.     {
74.         STATUS_LAZY = 0,        //空闲
75.         STATUS_BUSING,          //忙
76.         STATUS_FINISH           //结束
77.     };
78.     enum
79.     {
80.         ERR_MEMORY_EXPRESS = -100,          //内存过大，超过m_dwMaxSize限制
81.         ERR_MEMORY_HEAP_FAILED,             //HeapCreate失败
82.         ERR_INET_OPEN_FAILED,               //InternetOpen失败
83.         ERR_INET_CONNECT_FAILED,            //InternetConnect失败
84.         ERR_INET_REQUEST_FAILED,            //HttpOpenRequest失败
85.         ERR_INET_RESPONSE,                  //返回不为200
86.         ERR_INET_CONTENT_LENGTH,            //无法得到长度
87.         ERR_INET_READ,                      //读数据出错
88.         ERR_INET_FINISH = 0,                //没有错误
89.         ERR_INET_START                      //开始
90.         
91.     };
92. public:
93.     CAsyncHttpClient(void);
94.     ~CAsyncHttpClient(void);
95.     //post对象配置
96. public:
97.     //设置主机
98.     void SetPostHost(const TCHAR* szHost = _DEFAULT_HOST);
99.     //设置主机端口
100.     void SetHostPort(unsigned short uPort = _DEFAULT_PORT);
101.     //设置程序
102.     void SetPostProgram(const TCHAR* szProgram = _DEFAULT_PROG);
103.     //设置Session,通常一个程序只需要一个Session,即InternetOpen返回的句柄
104.     void SetSession(HINTERNET hSession = 0);
105.     //IDataCommunicater接口
106. public:
107.     //注册订阅者
108.     virtual bool RegisterSubscriber(HWND aSubscriber);
109.     //取消订阅者
110.     virtual bool RemoveSubscirber(HWND aSubscriber);
111.     //是否繁忙
112.     virtual bool IsBusy() const;
113.     //发送流
114.     virtual bool Request(void* aData, DWORD uSize);
115.     //get请法
116.     virtual bool HttpGet(TCHAR* szFile);
117.     //取消发送
118.     virtual void Cancel();
119.     //销毁资源
120.     virtual void Close();
121. private:
122.     void OnWork();
123.     //状态回调函数
124. private:
125.     static void CALLBACK StatusCallback(HINTERNET hInternet,
126.         DWORD_PTR dwContext,
127.         DWORD dwInternetStatus,
128.         LPVOID lpvStatusInformation,
129.         DWORD dwStatusInformationLength);
130.     //数据读取例程
131.     static DWORD CALLBACK ThreadEntry(LPVOID pThis);
132.     //辅助函数
133. private:
134.     //判断内存是否足够，不足按指定的粒度分配
135.     bool EnsureEnoughSpace(DWORD dwRequired = 0);
136.     //释放内存资源
137.     void ReleaseResource();
138.     //完成请求
139.     void SetCompleteRequest();
140.     //等待完成请求
141.     bool WaitCompleteRequest(unsigned long ntime=INFINITE);
142.     //状态机转换
143.     bool SetState(short uState);
144.     short GetState();
145.     //设置进度条
146.     void SetProgress(int nStep);
147.     //创建读数据线程
148.     void BeginAsyncRead();
149.     //主机信息与缓存
150. private:
151.     //主机 ip/name
152.     TCHAR* m_pszHost;
153.     //端口
154.     unsigned short m_uPort;
155.     //程序
156.     TCHAR* m_pszProg;
157.     
158.     //缓冲区
159.     const char* m_pData;
160.     DWORD       m_dwContentSize;
161.     //最大容量，超过此容量，会自动分配
162.     DWORD       m_dwMaxSize;
163.     //单元容量，当内存不足时，按此容量增加分配
164.     DWORD       m_dwUnitSize;        
165.     //当前容量
166.     DWORD       m_dwCurSize;
167.     
168.     //服务状态
169. private:
170.     //服务正所处的状态
171.     //InternetOpen
172.     //InternetConnect
173.     //HttpOpenRequest
174.     //HttpAddRequestHeaders
175.     //HttpSendRequest
176.     //HttpQueryInfo 查询是否成功
177.     //              读数据长度
178.     //InternetReadFile 读数据
179.     //                 重新分配缓存
180.     //                 处理完毕
181.     short  m_uSeviceState;
182.     HINTERNET      _hSession;
183.     HINTERNET      _hConn;
184.     HINTERNET      _hRequest;
185.     
186.     bool           _bCloseSession;  //如果不是公用的(SetSession)，则要关闭
187.     //订阅客户
188. private:
189.     //订阅数据的客户，目前只支持一个订阅者
190.     HWND  m_pCS;
191.     //堆内存管理
192. private:
193.     //heap堆句柄
194.     HANDLE  _hHeap;
195.     //同步事件,请求已完成
196.     HANDLE       _hCompleteRequestEvent;
197.     //提取数据线程句柄
198.     HANDLE      _hThread;
199.     DWORD       _dwThreadID;
200.     int         m_nPercents;
201. };

1. #include "StdAfx.h"
2. #include "AsyncHttpClient.h"
4. #define SAFE_DELARRAY(arr) if(arr){delete[] arr;arr = NULL;}
6. CAsyncHttpClient::CAsyncHttpClient(void)
7. :m_pszHost(NULL)
8. ,m_uPort(_DEFAULT_PORT)
9. ,m_pszProg(NULL)
10. ,m_pData(NULL)
11. ,m_dwContentSize(0)
12. ,m_dwMaxSize(_DEFAULT_MAX_RCV_BUF_SIZE)
13. ,m_dwUnitSize(_DEFAULT_RECV_BUF_UNIT)
14. ,m_dwCurSize(0)
15. ,m_uSeviceState(STATUS_LAZY)
16. ,_hSession(0)
17. ,_hConn(0)
18. ,_hRequest(0)
19. ,_bCloseSession(true)
20. ,m_pCS(NULL)
21. ,_hHeap(0)
22. ,_hCompleteRequestEvent(INVALID_HANDLE_VALUE)
23. ,_hThread(INVALID_HANDLE_VALUE)
24. ,_dwThreadID(0)
25. ,m_nPercents(0)
26. {
28. }
31. CAsyncHttpClient::~CAsyncHttpClient(void)
32. {
33.     Close();
34.     //释放内存
35.     ReleaseResource();
36. }
39. //------------------------------------------------------------------------
40. //设置
41. //------------------------------------------------------------------------
42. //设置主机
43. void CAsyncHttpClient::SetPostHost(const TCHAR* szHost/* = _DEFAULT_HOST*/) throw()
44. {
45.     if(m_uSeviceState != STATUS_LAZY)
46.     {
47.         return;
48.     }
50.     unsigned short uSize = _tcslen(szHost);
51.     if(uSize == 0){
52.         return;
53.     }
54.     
55.     SAFE_DELARRAY(m_pszHost);
56.     m_pszHost = new TCHAR[uSize+1];
57.     if(m_pszHost == NULL)
58.     {
59.         return;
60.     }
62.     CopyMemory(m_pszHost, szHost, sizeof(TCHAR) * uSize);
63.     m_pszHost[uSize] = '/0';
64.     return;
65. }
67. //设置主机端口
68. void CAsyncHttpClient::SetHostPort(unsigned short uPort/* = _DEFAULT_PORT*/) throw ()
69. {
70.     if(m_uSeviceState != STATUS_LAZY)
71.     {
72.         return;
73.     }
75.     m_uPort = uPort;
76.     return;
77. }
79. //设置程序
80. void CAsyncHttpClient::SetPostProgram(const TCHAR* szProgram/* = _DEFAULT_PROG*/)
81. {
82.     if(m_uSeviceState != STATUS_LAZY)
83.     {
84.         return;
85.     }
87.     unsigned short uSize = _tcslen(szProgram);
88.     if(uSize == 0){
89.         return;
90.     }
91.     
92.     SAFE_DELARRAY(m_pszProg);
93.     m_pszProg = new TCHAR[uSize+1];
94.     if(m_pszProg == NULL)
95.     {
96.         return;
97.     }
99.     CopyMemory(m_pszProg, szProgram, sizeof(TCHAR) * uSize);
100.     m_pszProg[uSize] = '/0';
101.     return;
102. }
104. //设置Session,通常一个程序只需要一个Session,即InternetOpen返回的句柄
105. void CAsyncHttpClient::SetSession(HINTERNET hSession/* = 0*/) 
106. {
107.     if(hSession == 0) return;
109.     if(m_uSeviceState != STATUS_LAZY)
110.     {
111.         return;
112.     }
113.     
114.     _hSession = hSession;
115.     _bCloseSession = false;
117.     return;
118. }
120. //------------------------------------------------------------------------
121. //IDataCommunicater接口
122. //------------------------------------------------------------------------
123. //注册订阅者
124. bool CAsyncHttpClient::RegisterSubscriber(HWND aSubscriber)
125. {
126.     if(!aSubscriber) return false;
128.     m_pCS = aSubscriber;
130.     return true;
131. }
133. //取消订阅者
134. bool CAsyncHttpClient::RemoveSubscirber(HWND aSubscriber)
135. {
136.     if(aSubscriber != m_pCS) return false;
138.     m_pCS = NULL;
140.     return true;
141. }
143. //是否繁忙
144. bool CAsyncHttpClient::IsBusy() const
145. {
146.     return m_uSeviceState != STATUS_LAZY && STATUS_FINISH != m_uSeviceState;
147. }
149. //发送流
150. bool CAsyncHttpClient::Request(void* aData, DWORD uSize)
151. {
152.     if(IsBusy()) return false;
154.     if(m_pszHost == NULL)
155.         SetPostHost();
157.     if(m_uPort == 0)
158.         SetHostPort();
160.     if(m_pszProg == NULL)
161.         SetPostProgram();
164.     if(_hCompleteRequestEvent == INVALID_HANDLE_VALUE)
165.     {
166.         _hCompleteRequestEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
167.     }
169.     const TCHAR* pszAccepts[] = {L"*/*", NULL};
170.     TCHAR szReferer[_DEFAULT_REFERER_LENGTH] = {0};
171.     
172. #ifdef _UNICODE
173.     wsprintf(szReferer, L"%s:%d", m_pszHost, m_uPort);
174. #else
175.     sprintf(szReferer, "%s:%d", m_pszHost, m_uPort);
176. #endif
178.     m_uSeviceState = STATUS_BUSING;
180.     if(m_pCS)
181.     {
182.         PostMessage(m_pCS, WM_STATUS, ERR_INET_START, 0);
183.     }
185.     if(_hSession == NULL)
186.     {
187.         //打开
188.         _hSession = ::InternetOpen(TEXT("Agent")
189.                                                         ,INTERNET_OPEN_TYPE_PRECONFIG
190.                                                             ,NULL   //从注册表里读代理信息
191.                                                             ,NULL
192.                                                             ,INTERNET_FLAG_ASYNC);  //异步连接
193.         if(NULL == _hSession || _hSession == INVALID_HANDLE_VALUE)
194.         {
195.             if(m_pCS)
196.             {
197.                 PostMessage(m_pCS, WM_STATUS, ERR_INET_OPEN_FAILED, 0);
198.             }
200.             //取消
201.             Cancel();
203.             return false;
204.         }
206.         _bCloseSession = true;
207.     }
209.     //设置回调函数
210.     INTERNET_STATUS_CALLBACK pc=::InternetSetStatusCallback(_hSession, (INTERNET_STATUS_CALLBACK)this->StatusCallback);
211.     if(pc == INTERNET_INVALID_STATUS_CALLBACK)
212.     {
213.         if(m_pCS)
214.         {
215.             PostMessage(m_pCS, WM_STATUS, ERR_INET_OPEN_FAILED, 0);
216.         }
218.         //取消
219.         Cancel();
221.         return false;
222.     }
224.     if(NULL == _hConn)
225.     {
226.         //链接
227.         _hConn = ::InternetConnect(_hSession
228.                                                         ,m_pszHost
229.                                                         ,m_uPort   //ip and port
230.                                                         ,L""
231.                                                         ,L""    //username and pwd
232.                                                         ,INTERNET_SERVICE_HTTP
233.                                                         ,0
234.                                                         ,reinterpret_cast<unsigned long>(this));  //传到回调函数的自定义参数
235.         if(NULL == _hConn || INVALID_HANDLE_VALUE == _hConn)
236.         {
237.             if(m_pCS)
238.             {
239.                 PostMessage(m_pCS, WM_STATUS, ERR_INET_CONNECT_FAILED, 0);
240.             }
242.             //取消
243.             Cancel();
245.             return false;
246.         }
248.     }
249.                 
250.     //请求网页
251.     _hRequest = ::HttpOpenRequest(_hConn
252.                                                             ,L"POST"
253.                                                             ,m_pszProg
254.                                                             ,NULL          //使用http/1.0
255.                                                             ,szReferer
256.                                                             ,pszAccepts    //accept */*
257.                                                             ,INTERNET_FLAG_DONT_CACHE | INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_NO_CACHE_WRITE
258.                                                             ,reinterpret_cast<unsigned long>(this));//传到回调函数的自定义参数
259.     if(NULL == _hRequest || _hRequest==INVALID_HANDLE_VALUE)
260.     {
262.         if(m_pCS)
263.         {
264.             PostMessage(m_pCS, WM_STATUS, ERR_INET_REQUEST_FAILED, 0);
265.         }
267.         //取消
268.         Cancel();
270.         return false;
271.     }
273.     更改请求头
274.     //if(FALSE == ::HttpAddRequestHeaders( _hRequest, L"Accept: */*/r/n", _tcslen(L"Accept: */*/r/n"), HTTP_ADDREQ_FLAG_REPLACE))
275.     //{
276.     //  sError.Format(L"HttpAddRequestHeaders不能打开 NO = %d", GetLastError());
277.     //  ThrowError(sError);
278.     //  goto ERROR_RELEASE;
279.     //}
281.     //开始发请求
282.     static INTERNET_BUFFERS InternetBufferIn = {0};
283.     InternetBufferIn.dwStructSize = sizeof(INTERNET_BUFFERS);
284.     InternetBufferIn.Next = NULL;
285.     InternetBufferIn.lpcszHeader = NULL;
286.     InternetBufferIn.dwHeadersLength = 0;
287.     InternetBufferIn.lpvBuffer = aData;        //post的数据
288.     InternetBufferIn.dwBufferLength = uSize;   //数据长度
290.     //发出请求
291.     if(FALSE == ::HttpSendRequestEx(_hRequest
292.                                     ,&InternetBufferIn
293.                                     ,NULL
294.                                     ,0
295.                                     ,reinterpret_cast<unsigned long>(this))
296.         &&::GetLastError()!=ERROR_IO_PENDING)
297.     {
298.         if(m_pCS)
299.         {
300.             PostMessage(m_pCS, WM_STATUS, ERR_INET_REQUEST_FAILED, 0);
301.         }
303.         //取消
304.         Cancel();
306.         return false;
307.     }
309.     SetProgress(10);
311.     //等待10s,否则返回失败
312.     if(WaitCompleteRequest(10 * 1000) == false)
313.     {
314.         if(m_pCS)
315.         {
316.             PostMessage(m_pCS, WM_STATUS, ERR_INET_REQUEST_FAILED, 0);
317.         }
319.         //取消
320.         Cancel();
322.         return false;
323.     }
325.     SetProgress(20);
327.     //请求结束
328.     if(!::HttpEndRequest(_hRequest, NULL, 0, reinterpret_cast<unsigned long>(this))
329.         &&::GetLastError()!=ERROR_IO_PENDING)
330.     {
331.         if(m_pCS)
332.         {
333.             PostMessage(m_pCS, WM_STATUS, ERR_INET_REQUEST_FAILED, 0);
334.         }
336.         //取消
337.         Cancel();
339.         return false;
340.     }
342.   //创建读数据线程
343.     _hThread = CreateThread(NULL
344.                         , 0
345.                         ,(LPTHREAD_START_ROUTINE)ThreadEntry
346.                         ,LPVOID(this)
347.                         , 0
348.                         ,&_dwThreadID);
349.     if(_hThread == 0 || _hThread == INVALID_HANDLE_VALUE)
350.     {
351.         if(m_pCS)
352.         {
353.             PostMessage(m_pCS, WM_STATUS, ERR_INET_REQUEST_FAILED, 0);
354.         }
356.         //取消
357.         Cancel();
359.         return false;
360.     }
361.     SetProgress(10);
362.     return true;
363. }
365. bool CAsyncHttpClient::HttpGet(TCHAR* szFile)
366. {
367.     if(IsBusy()) return false;
370.     if(_hCompleteRequestEvent == INVALID_HANDLE_VALUE)
371.     {
372.         _hCompleteRequestEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
373.     }
375.     const TCHAR* pszAccepts[] = {L"*/*", NULL};
377.     if(m_pCS)
378.     {
379.         PostMessage(m_pCS, WM_STATUS, ERR_INET_START, 0);
380.     }
382.     if(_hSession == NULL)
383.     {
384.         //打开
385.         _hSession = ::InternetOpen(TEXT("TGUIDE")
386.             ,INTERNET_OPEN_TYPE_PRECONFIG
387.             ,NULL   //从注册表里读代理信息
388.             ,NULL
389.             ,INTERNET_FLAG_ASYNC);  //异步连接
390.         if(NULL == _hSession || _hSession == INVALID_HANDLE_VALUE)
391.         {
392.             if(m_pCS)
393.             {
394.                 PostMessage(m_pCS, WM_STATUS, ERR_INET_OPEN_FAILED, 0);
395.             }
397.             //取消
398.             Cancel();
400.             return false;
401.         }
403.         _bCloseSession = true;
404.     }
406.     //设置回调函数
407.     INTERNET_STATUS_CALLBACK pc=::InternetSetStatusCallback(_hSession, (INTERNET_STATUS_CALLBACK)this->StatusCallback);
408.     if(pc == INTERNET_INVALID_STATUS_CALLBACK)
409.     {
410.         if(m_pCS)
411.         {
412.             PostMessage(m_pCS, WM_STATUS, ERR_INET_OPEN_FAILED, 0);
413.         }
415.         //取消
416.         Cancel();
418.         return false;
419.     }
421.     if(NULL == (_hRequest = InternetOpenUrl(_hSession
422.                                   , szFile                         //地址
423.                                                             , NULL                           //头
424.                                                             , 0                              //头的长度
425.                                                             , INTERNET_FLAG_RELOAD           //标志
426.                                                             , reinterpret_cast<unsigned long>(this))) &&::GetLastError()!=ERROR_IO_PENDING)
427.     {
428.         if(m_pCS)
429.         {
430.             PostMessage(m_pCS, WM_STATUS, ERR_INET_REQUEST_FAILED, 0);
431.         }
433.         //取消
434.         Cancel();
436.         return false;
437.     }
439.     SetProgress(10);
441.     //等待10s,否则返回失败
442.     if(WaitCompleteRequest(10 * 1000) == false)
443.     {
444.         if(m_pCS)
445.         {
446.             PostMessage(m_pCS, WM_STATUS, ERR_INET_REQUEST_FAILED, 0);
447.         }
449.         //取消
450.         Cancel();
452.         return false;
453.     }
455.     SetProgress(20);
457.     //创建读数据线程
458.     _hThread = CreateThread(NULL
459.         , 0
460.         ,(LPTHREAD_START_ROUTINE)ThreadEntry
461.         ,LPVOID(this)
462.         , 0
463.         ,&_dwThreadID);
464.     if(_hThread == 0 || _hThread == INVALID_HANDLE_VALUE)
465.     {
466.         if(m_pCS)
467.         {
468.             PostMessage(m_pCS, WM_STATUS, ERR_INET_REQUEST_FAILED, 0);
469.         }
471.         //取消
472.         Cancel();
474.         return false;
475.     }
476.     SetProgress(10);
478.     SetCompleteRequest();
480.     return true;
481. }
483. //取消发送
484. void CAsyncHttpClient::Cancel()
485. {
486.     if(_hRequest){
487.         ::InternetCloseHandle(_hRequest);
488.         _hRequest = 0;
489.     }
491.     if(_hConn)
492.     {
493.         ::InternetCloseHandle(_hConn);
494.         _hConn = 0;
495.     }
497.     //如果任务未完成，就取消，则要重置缓冲区，清除接收缓冲区
498.     //if(1/*STATUS_FINISH != m_uSeviceState*/)
499.     //{
500.     //  m_dwContentSize = 0;
501.     //  if(m_pData)
502.     //  {
503.     //      ATLASSERT(_hHeap);
504.     //      BOOL bRet = ::HeapFree(_hHeap, HEAP_NO_SERIALIZE, (LPVOID)m_pData);
505.     //      ATLASSERT(bRet);
506.     //      bRet = HeapDestroy(_hHeap);
507.     //      ATLASSERT(bRet);
508.     //  }
509.     //  m_dwCurSize = 0;
510.     //}
512.     if(m_pData)
513.     {
514.         //ASSERT(_hHeap);
515.         //BOOL bRet = ::HeapFree(_hHeap, HEAP_NO_SERIALIZE, (LPVOID)m_pData);
516.         //ASSERT(bRet);
517.         //bRet = HeapDestroy(_hHeap);
518.         //ASSERT(bRet);
519.         SAFE_DELARRAY(m_pData);
520.         m_dwCurSize = 0;
521.         m_dwContentSize = 0;
522.     }
524.     m_dwContentSize = 0;
525.     m_uSeviceState = STATUS_LAZY;
526. }
528. //销毁资源
529. void CAsyncHttpClient::Close()
530. {
531.     Cancel();
535.     if(_bCloseSession && _hSession)
536.     {
537.         ::InternetCloseHandle(_hSession);
538.         _hSession = 0;
539.     }
541.     ReleaseResource();
542. }
545. //------------------------------------------------------------------------
546. //实现IWorkThread接口
547. //------------------------------------------------------------------------
548. void CAsyncHttpClient::OnWork()
549. {
550.     //while(true)
551.     //{
552.         //等待发送请求事件,等待10秒
553.         if(!WaitCompleteRequest(10*1000))
554.         {
555.             if(m_pCS)
556.             {
557.                 PostMessage(m_pCS, WM_STATUS, ERR_INET_REQUEST_FAILED, 0);
558.             }
560.             //取消
561.             Cancel();
563.             goto DO_RELEASE;;
564.         }
566.         //获取数据长度
567.         DWORD dwTotalSize = 0;
568.         DWORD dwStatusSize = sizeof(dwTotalSize);
569.         if(FALSE == ::HttpQueryInfo(_hRequest, HTTP_QUERY_CONTENT_LENGTH| HTTP_QUERY_FLAG_NUMBER, &dwTotalSize, &dwStatusSize, 0))
570.         {
571.             //if(m_pCS)
572.             //  m_pCS->OnRcvError(ERR_INET_CONTENT_LENGTH);
573.         }
575.         //读数据
576.         DWORD dwPerRead = m_dwUnitSize;
577.         DWORD dwReaded = 0;
578.         m_dwContentSize = 0;
580.         if(!InternetQueryDataAvailable(_hRequest
581.                                    ,&dwPerRead
582.                                    ,0
583.                                    ,0))
584.         {
585.             //等数据2秒，否则失败
586.             if(!WaitCompleteRequest(10*1000))
587.             {
588.                 if(m_pCS)
589.                 {
590.                     PostMessage(m_pCS, WM_STATUS, ERR_INET_REQUEST_FAILED, 0);
591.                 }
593.                 //取消
594.                 Cancel();
596.                 goto DO_RELEASE;;
597.             }
598.         }
600.         if(EnsureEnoughSpace(dwPerRead) == false) goto DO_RELEASE;;
601.         
602.         BYTE bPercent = 0;
603.         while(::InternetReadFile(_hRequest
604.                                  ,(LPVOID)(m_pData + m_dwContentSize)
605.                                  ,dwPerRead
606.                                  ,&dwReaded))
607.         {
608.             if(dwReaded == 0) break;
609.             m_dwContentSize += dwReaded;
610.             if(m_dwContentSize + dwPerRead > m_dwMaxSize)
611.             {
612.                 m_dwContentSize = m_dwMaxSize;
613.                 break;
614.             }
616.             if(!InternetQueryDataAvailable(_hRequest
617.                                    ,&dwPerRead
618.                                    ,0
619.                                    ,0))
620.             {
621.                 //等数据2秒，否则失败
622.                 if(!WaitCompleteRequest(10*1000))
623.                 {
624.                     if(m_pCS)
625.                     {
626.                         PostMessage(m_pCS, WM_STATUS, ERR_INET_REQUEST_FAILED, 0);
627.                     }
629.                     //取消
630.                     Cancel();
632.                     goto DO_RELEASE;
633.                 }
634.             }
636.             if(EnsureEnoughSpace(dwPerRead) == false) break;
637.         }
639.         m_uSeviceState = STATUS_FINISH;
641.         //读取完成
642.         if(m_pCS)
643.         {
644.             PostMessage(m_pCS, WM_RESPONSE, (WPARAM)m_pData, (LPARAM)m_dwContentSize);
645.         }
647. DO_RELEASE:
648.         ;
649.         //delete this;
650. }
652. //------------------------------------------------------------------------
653. //状态回调函数
654. //------------------------------------------------------------------------
655. void CAsyncHttpClient::StatusCallback(HINTERNET hInternet,
656.         DWORD_PTR dwContext,
657.         DWORD dwInternetStatus,
658.         LPVOID lpvStatusInformation,
659.         DWORD dwStatusInformationLength)
660. {
661.     CAsyncHttpClient* pC = (CAsyncHttpClient*)dwContext;
663.     switch (dwInternetStatus)
664.     {   
665.         case INTERNET_STATUS_HANDLE_CREATED:   //60
666.             {
667.                 INTERNET_ASYNC_RESULT* res = (INTERNET_ASYNC_RESULT*)lpvStatusInformation;
668.                 pC->_hRequest = (HINTERNET)(res->dwResult);
669.             }
670.             break;
671.         case INTERNET_STATUS_RESOLVING_NAME:   //10
672.             {
673.                 //AfxMessageBox(L"正在解析URL");
674.             }
675.             break;
676.         case INTERNET_STATUS_NAME_RESOLVED:    //11
677.             {
678.                 //AfxMessageBox(L"URL已解析完毕");
679.             }
680.             break;
681.         case INTERNET_STATUS_CONNECTING_TO_SERVER:   //20
682.             {
683.                 //AfxMessageBox(L"正在连接URL");
684.             }
685.             break;
686.         case INTERNET_STATUS_CONNECTED_TO_SERVER:    //21
687.             {
688.                 //AfxMessageBox(L"已连接URL");
689.             }
690.             break;
691.         case INTERNET_STATUS_SENDING_REQUEST:       //30
692.             {
693.                 //AfxMessageBox(L"正在发送请求");
694.             }
695.             break;
696.         case INTERNET_STATUS_REQUEST_SENT:         //32
697.             {
698.                 //unsigned long *pnsent=(unsigned long*)lpvStatusInformation;
699.                 //CString sz;
700.                 //sz.Format(L"已发送%d字节", *pnsent);
701.                 //AfxMessageBox(sz);
702.                 
703.             }
704.             break;
705.         case INTERNET_STATUS_RECEIVING_RESPONSE:  //40
706.             {
707.                 if(pC)
708.                     pC->SetState(STATUS_BUSING);
710.                 //AfxMessageBox(L"正在等待响应");
711.             }
712.             break;
713.         case INTERNET_STATUS_RESPONSE_RECEIVED:  //41
714.             {
715.                 //AfxMessageBox(L"服务器已经响应");
716.             }
717.             break;
718.         case INTERNET_STATUS_REQUEST_COMPLETE:   //100
719.             {
720.                 if(pC)
721.                 {
722.                     pC->SetCompleteRequest();       //请求完成
723.                 }
724.             }
725.             break;
727.         case INTERNET_STATUS_CLOSING_CONNECTION:  //50
728.             {
729.                 //AfxMessageBox(L"正在关闭连接");
730.             }
731.             break;
732.         case INTERNET_STATUS_CONNECTION_CLOSED:  //51
733.             {
734.                 //AfxMessageBox(L"连接已关闭");
735.             }
736.             break;
737.         case INTERNET_STATUS_HANDLE_CLOSING:   //70
738.             break;
739.         case INTERNET_STATUS_INTERMEDIATE_RESPONSE:  //120
740.             break;
741.         case INTERNET_STATUS_REDIRECT:   //110
742.             break;
743.         case INTERNET_STATUS_STATE_CHANGE:  //200
744.             break;
745.         default:
746.             break;
747.     };
749.     return;
750. }
753. //数据读取例程
754. DWORD CAsyncHttpClient::ThreadEntry(LPVOID pThis)
755. {
756.     ((CAsyncHttpClient*) pThis)->OnWork();
758.     return 0;
759. }
761. //------------------------------------------------------------------------
762. //辅助
763. //------------------------------------------------------------------------
764. //判断内存是否足够，不足按指定的粒度分配
765. bool CAsyncHttpClient::EnsureEnoughSpace(DWORD dwRequired /*= 0*/)
766. {
767.     DWORD dwTotalSize = 0;
769.     //计算内存是否足够
770.     if(m_dwCurSize - m_dwContentSize >= dwRequired)
771.     {
772.         return true;
773.     }
774.     else  
775.     {
776.         //是否超过总大小
777.         if((m_dwContentSize + dwRequired) > m_dwMaxSize)
778.         {
779.             if(m_pCS)
780.             {
781.                 PostMessage(m_pCS, WM_STATUS, ERR_MEMORY_EXPRESS, 0);
782.             }
783.             return false;
784.         }
786.         //按粒度计算需要的内存大小
787.         dwTotalSize = m_dwContentSize + dwRequired;
788.         if(((m_dwContentSize % m_dwUnitSize) + dwRequired) != 0)
789.         {
790.             dwTotalSize += m_dwUnitSize;
791.         }
793.         if(dwTotalSize > m_dwMaxSize) dwTotalSize = m_dwMaxSize;
794.     }
796.     //否则要再增加内存
797.     //if(_hHeap == NULL)
798.     //{
799.     //  //获取系统内存页大小
800.     //  SYSTEM_INFO  Sysinfo;
801.     //  GetSystemInfo(&Sysinfo);
802.     //  //make a stack which can chang big
803.     //  //alloct memory
804.     //  _hHeap = HeapCreate(HEAP_NO_SERIALIZE, Sysinfo.dwPageSize, 0);
805.     //  if(0 == _hHeap)
806.     //  {
807.     //      if(m_pCS)
808.     //      {
809.     //          PostMessage(m_pCS, WM_STATUS, ERR_MEMORY_HEAP_FAILED, 0);
810.     //      }
811.     //      return false;
812.     //  }
813.     //}
815.     LPVOID pData = NULL;
817.     try
818.     {
819.         if(m_pData == NULL) //第一次分配
820.         {
821.             //pData = ::HeapAlloc(_hHeap
822.             //                        ,HEAP_ZERO_MEMORY
823.             //                        ,dwTotalSize);
824.             pData = new char[dwTotalSize];
825.             if(pData == NULL)
826.             {
827.                 if(m_pCS)
828.                 {
829.                     PostMessage(m_pCS, WM_STATUS, ERR_MEMORY_HEAP_FAILED, 0);
830.                 }
831.                 return false;
832.             }    
834.             m_dwCurSize = dwTotalSize;
835.         }else{ //重新分配
836.             //pData = HeapReAlloc(_hHeap, HEAP_ZERO_MEMORY, (LPVOID)m_pData, dwTotalSize);
837.             pData = new char[dwTotalSize];
838.             if(pData == NULL)
839.           {
840.                 if(m_pCS)
841.                 {
842.                     PostMessage(m_pCS, WM_STATUS, ERR_MEMORY_HEAP_FAILED, 0);
843.                 }
844.                 return false;
845.             }
847.             memmove(pData, m_pData, m_dwContentSize);
848.             delete[] m_pData;
850.             m_dwCurSize = dwTotalSize;
851.         }
852.     }
853.     catch(...)
854.     {
855.         return false;
856.     }
858.     m_pData = (char*)pData;
860.     return true;
861. }
863. //释放内存资源
864. void CAsyncHttpClient::ReleaseResource()
865. {
866.     SAFE_DELARRAY(m_pszHost);
867.     SAFE_DELARRAY(m_pszProg);
868.     //SAFE_DELARRAY(m_pData);
869.     if(m_pData)
870.     {
871.         //ASSERT(_hHeap);
872.         //BOOL bRet = ::HeapFree(_hHeap, HEAP_NO_SERIALIZE, (LPVOID)m_pData);
873.         //ASSERT(bRet);
874.         //bRet = HeapDestroy(_hHeap);
875.         //ASSERT(bRet);
876.         SAFE_DELARRAY(m_pData);
877.         m_pData = NULL;
878.         m_dwCurSize = 0;
879.         m_dwContentSize = 0;
880.     }
882.     if(_hCompleteRequestEvent != INVALID_HANDLE_VALUE)
883.     {
884.         ::CloseHandle(_hCompleteRequestEvent);
885.         _hCompleteRequestEvent = INVALID_HANDLE_VALUE;
886.     }
887. }
889. //完成请求
890. void CAsyncHttpClient::SetCompleteRequest()
891. {
892.     if(_hCompleteRequestEvent !=0 && _hCompleteRequestEvent != INVALID_HANDLE_VALUE)
893.         ::SetEvent(_hCompleteRequestEvent); 
894. }
896. //等待完成请求
897. bool CAsyncHttpClient::WaitCompleteRequest(unsigned long ntime/*=INFINITE*/)
898. {
899.     if(!_hCompleteRequestEvent || _hCompleteRequestEvent==INVALID_HANDLE_VALUE)
900.         false;
901.     return ::WaitForSingleObject(_hCompleteRequestEvent, ntime)==WAIT_OBJECT_0? true:false;
902. }
904. //状态机转换
905. bool CAsyncHttpClient::SetState(short uState)
906. {
907.     //if(STATUS_LAZY == m_uSeviceState)
908.     //{
909.     //  if(uState == STATUS_OPENNED)
910.     //  {
911.     //      m_uSeviceState = uState;
912.     //  }else{
913.     //      return false;
914.     //  }
915.     //}
916.     //else if(STATUS_OPENNED == m_uSeviceState)
917.     //{
918.     //  //if(uState == STATUS_OPENNED || uState == )
919.     //}
921.     m_uSeviceState = uState;
922.     return true;
923. }
925. short CAsyncHttpClient::GetState()
926. {
927.     return m_uSeviceState;
928. }
930. void CAsyncHttpClient::SetProgress(int nStep)
931. {
932.     m_nPercents += nStep;
933.     if(m_nPercents > 100)
934.         m_nPercents = 100;
935. }