Use windows socket to download http page

1)Because we need use windows socket to get http page,we need initialise win socket
At the beginning of our application,we should do below:
        int err;
    WORD wVersion;
    WSADATA WSAData;
    wVersion=MAKEWORD(2,0);
    err=WSAStartup(wVersion,&WSAData);
    if(err!=0)
    {
        AfxMessageBox("无法装载Socket库.");
    }
    if(LOBYTE( WSAData.wVersion ) != 2)
    {
        AfxMessageBox("无法找到合适的Socket库.");
        WSACleanup();
    }

After all aplication finished,we should do below:
    WSACleanup();
2)how to download
downLoadHttp.strFileName="c:/1.html";
downLoadHttp.m_strRequest="http://www.baidu.com";
downLoadHttp.Start();

1. // DownLoadHttp.h: interface for the CDownLoadHttp class.
2. //
3. //
5. #if !defined(AFX_DOWNLOADHTTP_H__1E0699F1_CFD6_461B_BBF6_44A8A6A4E269__INCLUDED_)
6. #define AFX_DOWNLOADHTTP_H__1E0699F1_CFD6_461B_BBF6_44A8A6A4E269__INCLUDED_
8. #if _MSC_VER > 1000
9. #pragma once
10. #endif // _MSC_VER > 1000
12. //
13. // 单个对象的下载信息
14. //
15. typedef struct _downloadcellinfo
16. {
17.     int nWillDownloadStartPos;          // 要下载文件的开始位置
18.     int nWillDownloadSize;              // 本次需要下载的大小，-1表示一直下载到文件尾
19.     DWORD nDownloadedSize;              // 该线程已下载的大小
20. } t_DownloadCellInfo;
24. class CDownLoadHttp  
25. {
26. public:
27.     CDownLoadHttp();
28.     virtual ~CDownLoadHttp();
29.     DWORD CDownLoadHttp::GetDownloadElapsedTime();//获取已下载的时间
30.     CString CDownLoadHttp::FormatFileSize ( double fFileSize );//计算速度
31.     UINT DownloadThread();              //下载
32.     void BeginDownLoad(void *pArg);
33.     void Start();
34.     void Suspend();
35.     void Stop2();
37.     
38.     CString strFileName;
39.     CString m_strRequest;
40.     CHttpSocket HttpSocket;
41.     HANDLE m_hThread;                               //线程句柄
42.     t_DownloadCellInfo *m_pDownloadCellInfo;        //下载对象参数
43.     DWORD m_dwDownloadStartTime;                    //开始时间
44.     int nCompletedSize ;
45.     bool bSuspend;
46.     CFile DownloadFile;
49. }; 
51. #endif // !defined(AFX_DOWNLOADHTTP_H__1E0699F1_CFD6_461B_BBF6_44A8A6A4E269__INCLUDED_)

1. // HttpSocket.cpp: implementation of the CHttpSocket class.
2. //
3. //
5. #include "stdafx.h"
6. #include "HttpSocket.h"
8. #ifdef _DEBUG
9. #undef THIS_FILE
10. static char THIS_FILE[]=__FILE__;
11. #define new DEBUG_NEW
12. #endif
14. #define MAXHEADERSIZE 1024
15. //
16. // Construction/Destruction
17. //
18. CHttpSocket::CHttpSocket()
19. {
20.     m_s=NULL;
21.     m_phostent=NULL;
22.     m_port=80;
24.     m_bConnected=FALSE;
26.     for(int i=0;i<256;i++)
27.         m_ipaddr[i]='/0';
28.     memset(m_requestheader,0,MAXHEADERSIZE);
29.     memset(m_ResponseHeader,0,MAXHEADERSIZE);
31.     m_nCurIndex = 0;        //
32.     m_bResponsed = FALSE;
33.     m_nResponseHeaderSize = -1;
34. /*
35.     m_nBufferSize = nBufferSize;
36.     m_pBuffer = new char[nBufferSize];
37.     memset(m_pBuffer,0,nBufferSize);*/
38. }
40. CHttpSocket::~CHttpSocket()
41. {
42.     CloseSocket();
43. }
45. BOOL CHttpSocket::Socket()
46. {
47.     if(m_bConnected)return FALSE;
49.     struct protoent *ppe; 
50.     ppe=getprotobyname("tcp"); 
51.     
52.     ///创建SOCKET对象
53.     m_s=socket(PF_INET,SOCK_STREAM,ppe->p_proto);
54.     if(m_s==INVALID_SOCKET)
55.     {
56.         MessageBox(NULL,"socket()函数执行失败!","错误",MB_OK);
57.         return FALSE;
58.     }
60.     return TRUE;
62. }
64. BOOL CHttpSocket::Connect(char *szHostName,int nPort)
65. {
66.     if(szHostName==NULL)
67.         return FALSE;
69.     ///若已经连接,则先关闭
70.     if(m_bConnected)
71.     {
72.         CloseSocket();
73.     }
75.     ///保存端口号
76.     m_port=nPort;
78.     ///根据主机名获得IP地址
79.     m_phostent=gethostbyname(szHostName);
80.     if(m_phostent==NULL)
81.     {
82.         MessageBox(NULL,"gethostbyname()函数执行失败!","错误",MB_OK);
83.         return FALSE;
84.     }
85.     
86.     ///连接
87.     struct in_addr ip_addr;
88.     memcpy(&ip_addr,m_phostent->h_addr_list[0],4);///h_addr_list[0]里4个字节,每个字节8位
89.     
90.     struct sockaddr_in destaddr;
91.     memset((void *)&destaddr,0,sizeof(destaddr)); 
92.     destaddr.sin_family=AF_INET;
93.     destaddr.sin_port=htons(nPort);
94.     destaddr.sin_addr=ip_addr;
96.     ///保存主机的IP地址字符串
97.     sprintf(m_ipaddr,"%d.%d.%d.%d",
98.         destaddr.sin_addr.S_un.S_un_b.s_b1,
99.         destaddr.sin_addr.S_un.S_un_b.s_b2,
100.         destaddr.sin_addr.S_un.S_un_b.s_b3,
101.         destaddr.sin_addr.S_un.S_un_b.s_b4);
102.     /*inet_addr();把带点的IP地址字符串转化为in_addr格式;
103.       inet_ntoa();作用相反*/
104.     
105.     /*注意理解sturct in_addr 的结构:一个32位的数;一共同体的形式使用
106.     (1)每8位一个即s_b1~s_b4;
107.     (2)每16位一个即s_w1~s_w2;
108.     (3)32位s_addr
109.     struct   in_addr {
110.     union   {
111.               struct{
112.                 unsigned  char   s_b1,
113.                                  s_b2,
114.                                  s_b3,
115.                                  s_b4;
116.                     } S_un_b;
117.               struct{
118.                 unsigned  short  s_w1,
119.                                  s_w2
120.                     }S_un_w;      
121.                unsigned long  S_addr;
122.             } S_un;
123.         };
124.     */
126.     if(connect(m_s,(struct sockaddr*)&destaddr,sizeof(destaddr))!=0)
127.     {
128.         //CloseSocket();
129.         //m_s=NULL;
130.         MessageBox(NULL,"connect()函数执行失败!","错误",MB_OK);
131.         return FALSE;
132.     }
134.     ///设置已经连接的标志
135.     m_bConnected=TRUE;
136.     return TRUE;
137. }
139. ///根据请求的相对URL输出HTTP请求头
140. const char *CHttpSocket::FormatRequestHeader(char *pServer,char *pObject, long &Length,
141.                                       char *pCookie,char *pReferer,long nFrom,
142.                                       long nTo,int nServerType)
143. {
144.     char szPort[10];
145.     char szTemp[20];
146.     sprintf(szPort,"%d",m_port);
147.     memset(m_requestheader,'/0',1024);
149.     ///第1行:方法,请求的路径,版本
150.     strcat(m_requestheader,"GET ");
151.     strcat(m_requestheader,pObject);
152.     strcat(m_requestheader," HTTP/1.1");
153.     strcat(m_requestheader,"/r/n");
155.     ///第2行:主机
156.     strcat(m_requestheader,"Host:");
157.     strcat(m_requestheader,pServer);
158.     strcat(m_requestheader,"/r/n");
160.     ///第3行:
161.     if(pReferer != NULL)
162.     {
163.         strcat(m_requestheader,"Referer:");
164.         strcat(m_requestheader,pReferer);
165.         strcat(m_requestheader,"/r/n");     
166.     }
168.     ///第4行:接收的数据类型
169.     strcat(m_requestheader,"Accept:*/*");
170.     strcat(m_requestheader,"/r/n");
172.     ///第5行:浏览器类型
173.     strcat(m_requestheader,"User-Agent:Mozilla/4.0 (compatible; MSIE 5.00; Windows 98)");
174.     strcat(m_requestheader,"/r/n");
176.     ///第6行:连接设置,保持
177.     strcat(m_requestheader,"Connection:Keep-Alive");
178.     strcat(m_requestheader,"/r/n");
180.     ///第7行:Cookie.
181.     if(pCookie != NULL)
182.     {
183.         strcat(m_requestheader,"Set Cookie:0");
184.         strcat(m_requestheader,pCookie);
185.         strcat(m_requestheader,"/r/n");
186.     }
188.     ///第8行:请求的数据起始字节位置(断点续传的关键)
190.     if(nFrom > 0)
191.     {
192.         strcat(m_requestheader,"Range: bytes=");
193.         _ltoa(nFrom,szTemp,10);
194.         strcat(m_requestheader,szTemp);
195.         strcat(m_requestheader,"-");
196.         if(nTo > nFrom)
197.         {
198.             _ltoa(nTo,szTemp,10);
199.             strcat(m_requestheader,szTemp);
200.         }
201.         strcat(m_requestheader,"/r/n");
202.     }
203.     
204.     ///最后一行:空行
205.     strcat(m_requestheader,"/r/n");
207.     ///返回结果
208.     Length=strlen(m_requestheader);
209.     return m_requestheader;
210. }
212. ///发送请求头
213. BOOL CHttpSocket::SendRequest(const char *pRequestHeader, long Length)
214. {
215.     if(!m_bConnected)return FALSE;
217.     if(pRequestHeader==NULL)
218.         pRequestHeader=m_requestheader;
219.     if(Length==0)
220.         Length=strlen(m_requestheader);
222.     if(send(m_s,pRequestHeader,Length,0)==SOCKET_ERROR)
223.     {
224.         MessageBox(NULL,"send()函数执行失败!","错误",MB_OK);
225.         return FALSE;
226.     }
227.     int nLength;
228.     GetResponseHeader(nLength);
229.     return TRUE;
230. }
232. long CHttpSocket::Receive(char* pBuffer,long nMaxLength)
233. {
234.     if(!m_bConnected)return NULL;
236.     ///接收数据
237.     long nLength;
238.     nLength=recv(m_s,pBuffer,nMaxLength,0);
239.     
240.     if(nLength <= 0)
241.     {
242.         //MessageBox(NULL,"recv()函数执行失败!","错误",MB_OK);
243.         CloseSocket();
244.     }
245.     return nLength;
246. }
248. ///关闭套接字
249. BOOL CHttpSocket::CloseSocket()
250. {
251.     if(m_s != NULL)
252.     {
253.         if(closesocket(m_s)==SOCKET_ERROR)
254.         {
255.             MessageBox(NULL,"closesocket()函数执行失败!","错误",MB_OK);
256.             return FALSE;
257.         }
258.     }
259.     m_s = NULL;
260.     m_bConnected=FALSE;
261.     return TRUE;
262. }
264. int CHttpSocket::GetRequestHeader(char *pHeader, int nMaxLength) const
265. {
266.     int nLength;
267.     if(int(strlen(m_requestheader))>nMaxLength)
268.     {
269.         nLength=nMaxLength;
270.     }
271.     else
272.     {
273.         nLength=strlen(m_requestheader);
274.     }
275.     memcpy(pHeader,m_requestheader,nLength);
276.     return nLength;
277. }
279. //设置接收或者发送的最长时间
280. BOOL CHttpSocket::SetTimeout(int nTime, int nType)
281. {
282.     if(nType == 0)
283.     {
284.         nType = SO_RCVTIMEO;
285.     }
286.     else
287.     {
288.         nType = SO_SNDTIMEO;
289.     }
291.     DWORD dwErr;
292.     dwErr=setsockopt(m_s,SOL_SOCKET,nType,(char*)&nTime,sizeof(nTime)); 
293.     if(dwErr)
294.     {
295.         MessageBox(NULL,"setsockopt()函数执行失败!","错误",MB_OK);
296.         return FALSE;
297.     }
298.     return TRUE;
299. }
301. //获取HTTP请求的返回头
302. const char* CHttpSocket::GetResponseHeader(int &nLength)
303. {
304. //  if(!m_bResponsed)
305.     {
307.         char c = 0;
308.         int nIndex = 0;
309.         m_nResponseHeaderSize=-1;
310.         BOOL bEndResponse = FALSE;
312.         while(!bEndResponse && nIndex < MAXHEADERSIZE)
313.         {
314.             recv(m_s,&c,1,0);
315.             m_ResponseHeader[nIndex++] = c;
316.             if(nIndex >= 4)
317.             {
318.                 if(m_ResponseHeader[0]!='H'&&m_ResponseHeader[1]!='T'
319.                     &&m_ResponseHeader[2]!='T'&&m_ResponseHeader[3]!='P')
320.                 {
321.                     AfxMessageBox("返回信息有误,下载中止");
322.                     CloseSocket();
323.                     break;
324.                 }
325.                 if(m_ResponseHeader[nIndex - 4] == '/r' && m_ResponseHeader[nIndex - 3] == '/n'
326.                     && m_ResponseHeader[nIndex - 2] == '/r' && m_ResponseHeader[nIndex - 1] == '/n')
327.                 bEndResponse = TRUE;
328.             }
329.         }
330.         
331.         m_nResponseHeaderSize = nIndex;
332.         m_ResponseHeader[nIndex]=NULL;
333.         m_bResponsed = TRUE;
334.     }
335.     
336.     nLength = m_nResponseHeaderSize;
337.     return m_ResponseHeader;
338. }
340. //返回HTTP响应头中的一行.
341. int CHttpSocket::GetResponseLine(char *pLine, int nMaxLength)
342. {
343.     if(m_nCurIndex >= m_nResponseHeaderSize)
344.     {
345.         m_nCurIndex = 0;
346.         return -1;
347.     }
349.     int nIndex = 0;
350.     char c = 0;
351.     do 
352.     {
353.         c = m_ResponseHeader[m_nCurIndex++];
354.         pLine[nIndex++] = c;
355.     } while(c != '/n' && m_nCurIndex < m_nResponseHeaderSize && nIndex < nMaxLength);
356.     
357.     return nIndex;
358. }
360. int CHttpSocket::GetField(const char *szSession, char *szValue, int nMaxLength)
361. {
362.     //取得某个域值
363.     if(!m_bResponsed) return -1;
364.     
365.     CString strRespons;
366.     strRespons = m_ResponseHeader;
367.     int nPos = -1;
368.     nPos = strRespons.Find(szSession,0);
369.     if(nPos != -1)
370.     {
371.         nPos += strlen(szSession);
372.         nPos += 2;
373.         int nCr = strRespons.Find("/r/n",nPos);
374.         CString strValue = strRespons.Mid(nPos,nCr - nPos);
375.         strcpy(szValue,strValue);
376.         return (nCr - nPos);
377.     }
378.     else
379.     {
380.         return -1;
381.     }
382. }
384. int CHttpSocket::GetServerState()
385. {
386.     //若没有取得响应头,返回失败
387.     if(!m_bResponsed) return -1;
388.     
389.     char szState[3];
390.     szState[0] = m_ResponseHeader[9];
391.     szState[1] = m_ResponseHeader[10];
392.     szState[2] = m_ResponseHeader[11];
394.     return atoi(szState);
395. }

1. // HttpSocket.h: interface for the CHttpSocket class.
2. //
3. //
5. #if !defined(AFX_HTTPSOCKET_H__F49A8F82_A933_41A8_AF47_68FBCAC4ADA6__INCLUDED_)
6. #define AFX_HTTPSOCKET_H__F49A8F82_A933_41A8_AF47_68FBCAC4ADA6__INCLUDED_
8. #include "winsock2.h"
9. #include <afxinet.h>
10. #include <afxsock.h>
12. #if _MSC_VER > 1000
13. #pragma once
14. #endif // _MSC_VER > 1000
15. class _declspec(dllexport) CHttpSocket  :public CSocket
16. {
17. public:
18.     int             GetServerState();                       //返回服务器状态码 -1表示不成功
19.     int             GetField(const char* szSession,char *szValue,int nMaxLength);   //返回某个域值,-1表示不成功
20.     int             GetResponseLine(char *pLine,int nMaxLength);                //获取返回头的一行
21.     const char*     GetResponseHeader(int &Length);                             //获取完整的返回头
22.     const char *    FormatRequestHeader(char *pServer,char *pObject,long &Length,
23.                         char* pCookie=NULL,char *pReferer=NULL,
24.                         long nFrom=0,long nTo=0,
25.                         int nServerType=0);                                 //格式化请求头
26.     int             GetRequestHeader(char *pHeader,int nMaxLength) const;
27.     BOOL            SendRequest(const char* pRequestHeader = NULL,long Length = 0);
28.     
29.     CHttpSocket();
30.     virtual ~CHttpSocket();
32.     BOOL            SetTimeout(int nTime,int nType=0);
33.     long            Receive(char* pBuffer,long nMaxLength);
34.     BOOL            Connect(char* szHostName,int nPort=80);
35.     BOOL            Socket();
36.     BOOL            CloseSocket();
37.     char m_ResponseHeader[1024];    //回应头
40. protected:  
41.     char m_requestheader[1024];     //请求头
43.     int m_port;                     //端口
44.     char m_ipaddr[256];             //IP地址
45.     BOOL m_bConnected;
46.     SOCKET m_s;
47.     hostent *m_phostent;
49.     int m_nCurIndex;                //GetResponsLine()函数的游标记录
50.     BOOL m_bResponsed;              //是否已经取得了返回头
51.     int m_nResponseHeaderSize;      //回应头的大小
52. /*
53.     int m_nBufferSize;
54.     char *m_pBuffer;*/
56. };
58. #endif // !defined(AFX_HTTPSOCKET_H__F49A8F82_A933_41A8_AF47_68FBCAC4ADA6__INCLUDED_)

1. // DownLoadHttp.cpp: implementation of the CDownLoadHttp class.
2. //
3. //
5. #include "stdafx.h"
6. #include "HttpSocket.h"
7. #include "DownLoadHttp.h"
8. //#include "TestHttpDlg.h"
10. #ifdef _DEBUG
11. #undef THIS_FILE
12. static char THIS_FILE[]=__FILE__;
13. #define new DEBUG_NEW
14. #endif
16. //
17. // Construction/Destruction
18. //
19.  
21. CDownLoadHttp::CDownLoadHttp()
22. {
23.     nCompletedSize=0;
24.         m_hThread = NULL;
25.         bSuspend=false; 
27. }
29. CDownLoadHttp::~CDownLoadHttp()
30. {
32. }
35. //
36. // 获取下载所消耗的时间（毫秒），可用来计算下载速度和推算剩余时间
37. //
38. DWORD CDownLoadHttp::GetDownloadElapsedTime()
39. {
40.     return (GetTickCount() - m_dwDownloadStartTime);
41. }
44. UINT CDownLoadHttp::DownloadThread()
45. { 
46.  
47.     
48.     CString strServer,strObject;
49.     unsigned short nPort;
50.     DWORD dwServiceType;
51.     long nLength;
52. //  char  pCookie[256]='/0';
53. //  char  pReferer[256]='/0';
54.     const char *pRequestHeader = NULL;
55.     
56.     BOOL bIsTran=TRUE;
57.     int nSvrState;
58.     while(bIsTran)
59.     {
60.         
61.         
62.         AfxParseURL(m_strRequest,dwServiceType,strServer,strObject,nPort);
63.         pRequestHeader = HttpSocket.FormatRequestHeader((LPTSTR)(LPCTSTR)strServer
64.             ,(LPTSTR)(LPCTSTR)strObject,nLength,NULL,NULL,nCompletedSize);  
65.         
66.          
67.         HttpSocket.Socket();
68.         HttpSocket.Connect((LPTSTR)(LPCTSTR)strServer,nPort);
69.         HttpSocket.SendRequest();
70.         HttpSocket.SetTimeout(10000,0); 
71.     //  HttpSocket.GetField("Cookie",pCookie,256);
72.         
73.         //服务器状态,(300,400)被重定向
74.         nSvrState = HttpSocket.GetServerState();
75.         if( nSvrState>= 300 && nSvrState< 400 )
76.         {
77.             char sLocal[256];
78.             int path=HttpSocket.GetField("Location",sLocal,256);
79.          
80.             bIsTran=TRUE;
81.             HttpSocket.CloseSocket();       
82.         }
83.         else bIsTran=FALSE;
84.     }
85.     
86.     if(nSvrState<200||nSvrState>=400)
87.     {
88.         AfxMessageBox("服务器信息有错");
89.         return 0;
90.     }
91.     BeginDownLoad(NULL);
93.     
95.     return 0;
96. }
98. void CDownLoadHttp::BeginDownLoad(void *pArg)
99. { 
100.     char szValue[30];
101.     HttpSocket.GetField("Content-Length",szValue,30);
102.     int nFileSize = atoi(szValue);  
103.     
105.     int iThisDown=0;
106.     DownloadFile.Open(strFileName,CFile::modeCreate | CFile::modeReadWrite|CFile::modeNoTruncate|CFile::shareDenyNone);
107.     long lposition=DownloadFile.GetPosition();
108.     long fileLength=DownloadFile.GetLength();
109.     if(nCompletedSize)lposition=DownloadFile.Seek(nCompletedSize,CFile::begin);
110.     char pData[1024];
111.     int nReceSize = 0;
112.     m_dwDownloadStartTime= GetTickCount();
113.     while(iThisDown< nFileSize)
114.     {
115.     
116.     
117.         nReceSize = HttpSocket.Receive(pData,1024);
118.         if(nReceSize == 0)
119.         {
120.             AfxMessageBox("服务器已经关闭连接.");
121.         //  DownloadFile.Close();
122.             break;
123.         }
124.         if(nReceSize == -1)
125.         {
126.             AfxMessageBox("接收数据超时.");
127.     //      DownloadFile.Close();
128.             break;
129.         }
130.     
131.         DownloadFile.Write(pData,nReceSize);
132.         iThisDown+=nReceSize;
133.         nCompletedSize += nReceSize; 
134.         
135.         //Speed
136.         int nElapsedTime = this->GetDownloadElapsedTime ();
137.         if ( nElapsedTime > 5*1000 || ( nElapsedTime > 2*1000 && nCompletedSize > 1024*10 ) )
138.         {
139.             double dSpeed = (double)nCompletedSize / ((double)nElapsedTime / 1000.0);
140.             CString csSpeed = FormatFileSize ( dSpeed );
141.             csSpeed += "/S"; 
142.         }
143.     
144.     }
145.     if(iThisDown==nFileSize)
146.     {
147.         AfxMessageBox("Download Complete");
148.     }
149.         HttpSocket.CloseSocket(); 
150.         ::CloseHandle ( m_hThread );
151.         (m_hThread) = NULL;
152.     
153.         DownloadFile.Close();
154.             
155.     
156.     
157.     
158.     
161. }
163. CString CDownLoadHttp::FormatFileSize ( double fFileSize )
164. {
165.     CString csRet;
166.     if ( fFileSize < 1024.0 )
167.     {
168.         csRet.Format ( "%d b", fFileSize );
169.     }
170.     else if ( fFileSize >= 1024.0 && fFileSize < 1024.0*1024.0 )
171.     {
172.         csRet.Format ( "%.2f K", fFileSize/1024.0 );
173.     }
174.     else if ( fFileSize >= 1024.0*1024.0 && fFileSize < 1024.0*1024.0*1024.0 )
175.     {
176.         csRet.Format ( "%.2f M", fFileSize/(1024.0*1024.0) );
177.     }
178.     else
179.     {
180.         csRet.Format ( "%.2f G", fFileSize/(1024.0*1024.0*1024.0) );
181.     }
182.     return csRet;
183. }
185. DWORD WINAPI  DownloadThread(void *pArg)
186. {
187.      CDownLoadHttp *nDownLoad=(CDownLoadHttp *)pArg;
188.      nDownLoad->DownloadThread();
189.      return 0;
191.     
192. }
194. void CDownLoadHttp::Start()
195. {
197.     DWORD dwThreadId=0;
198.     m_hThread = CreateThread ( NULL, 0, ::DownloadThread, LPVOID(this), 0, &dwThreadId );
199.     if ( !m_hThread )
200.     {
201.         AfxMessageBox("Create download thread failed" );
202.     
203.     }
205. }
207. void CDownLoadHttp::Suspend()
208. {
211.     
212.     if ( m_hThread )
213.     {
214. /*      //  HttpSocket.CancelBlockingCall ();
215.             HttpSocket.CloseSocket(); 
216.         DWORD dwWaitTime=5000;
217.         if ( ::WaitForSingleObject ( m_hThread, dwWaitTime ) == WAIT_TIMEOUT )
218.         {
219.             ::TerminateThread ( m_hThread, 0 );
220.         }
221.         ::CloseHandle ( m_hThread );
222.         (m_hThread) = NULL;
223.         
224.         */      
225.         if(!bSuspend)
226.         {
227.             
228.             SuspendThread(m_hThread);
229.             bSuspend=true;
230.             CString sSuspend;
231.             sSuspend.Format("Suspend %d",this->nCompletedSize);
232.             
233.             AfxMessageBox(sSuspend);
235.         }
236.         else
237.         {
239.     //      AfxMessageBox("Resume");
240.             CString sResume;    
241.             sResume.Format("Resume  %d",this->nCompletedSize);
242.             AfxMessageBox(sResume);
243.             ResumeThread(m_hThread);
244.             bSuspend=false;
245.             
246.         }
247.         
248.     }
249.     else    AfxMessageBox("Please download first.");    
250. }
252. void CDownLoadHttp::Stop2()
253. {
256.     
257.     if ( m_hThread )
258.     {
259.     
260.         //  HttpSocket.CancelBlockingCall ();
261.         SuspendThread(m_hThread);
262.         HttpSocket.CloseSocket(); 
263.         DWORD dwWaitTime=500;
264.         if ( ::WaitForSingleObject ( m_hThread, dwWaitTime ) == WAIT_TIMEOUT )
265.         {
266.             ::TerminateThread ( m_hThread, 0 );
267.         }
268.         ::CloseHandle ( m_hThread );
269.         (m_hThread) = NULL;
270.     
271.         DownloadFile.Close();
272.                 
273.     }
274. }