开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
HttpClt.cpp
资源名称：clking_src.rar　[点击查看]
上传用户：zhanglf88
上传日期：2013-11-19
资源大小：6036k
文件大小：26k
源码类别：

金融证券系统

开发平台：

Visual C++

HttpClt.cpp：源码内容
  2. #include "stdafx.h"
  3. #include "HttpClt.h"
  4. #include "Resource.h"
  5. #include "Base64.h"
  6. #include "Strings.h"
  7. #include "ProxySocket.h"
  9. #include <TCHAR.h>
  11. /////////////////////////////////////////////////////////////////////////////
  12. // CTearException object
  14. IMPLEMENT_DYNCREATE(CTearException, CException)
  16. CTearException::CTearException(int nCode)
  17. {
  18. m_nErrorCode = nCode;
  19. }
  21. BOOL CTearException::GetErrorMessage(LPTSTR lpszError, UINT nMaxError, PUINT pnHelpContext)
  22. {
  23. CString string;
  24. switch (m_nErrorCode)
  25. {
  26. case ERR_TEAR_CANCEL:
  27. break;
  28. case ERR_TEAR_URLFORMAT:
  29. string = szErrUrlFormat;
  30. break;
  31. case ERR_TEAR_REDIRECT:
  32. string = szErrRedirect;
  33. break;
  34. case ERR_TEAR_INTERRUPTED:
  35. string = szErrInterrupted;
  36. break;
  37. case ERR_TEAR_DATATRANSFER:
  38. string = szErrDataTransfer;
  39. break;
  40. }
  42. strncpy(lpszError, string.GetBuffer(string.GetLength()+1), nMaxError);
  43. string.ReleaseBuffer();
  45. return TRUE;
  46. }
  48. void ThrowTearException(int nCode)
  49. {
  50. CTearException* pEx = new CTearException(nCode);
  51. throw pEx;
  52. }
  54. /////////////////////////////////////////////////////////////////////////////
  55. // CHttpClient object
  57. const TCHAR *szHeaderFormat = "%s: %srn";
  58. const TCHAR *szUserAgentKey = _T("User-Agent");
  59. const TCHAR *szUserAgentValue = _T("Internet Explorer");
  60. const TCHAR *szCookieKey = _T("Cookie");
  61. const TCHAR *szRange = _T("Range");
  62. const TCHAR *szCheckSumKey = _T("BLCheckSum");
  63. const TCHAR *szCheckSumKeySuffix = _T("BLCheckSum: ");
  65. const TCHAR *szRegCodeKey = _T("RegCode");
  66. const TCHAR *szUserNameKey = _T("User");
  67. const TCHAR *szPasswdKey = _T("Passwd");
  68. const TCHAR *szDiskSerialKey= _T("SerialCheck");
  69. const TCHAR *szVersionKey = _T("Version");
  71. const TCHAR szHttpURLFormat[] = "http://%s:%d%s";
  73. #ifdef CLKLAN_ENGLISH_US
  74. const TCHAR *szWebpathWGet = _T("/enu/download/ninebulls/wget");
  75. const TCHAR *szWebpathLogin = _T("/enu/download/ninebulls/login");
  76. const TCHAR *szWebpathLogout = _T("/enu/download/ninebulls/logout");
  77. const TCHAR *szWebpathPackageInfo = _T("/enu/download/ninebulls/package3.xml");
  78. const TCHAR *szWebpathServerInfo = _T("/enu/download/ninebulls/server3.xml");
  79. #elif defined CLKVER_OEM
  80. const TCHAR *szWebpathWGet = _T("/download/stockana/wget");
  81. const TCHAR *szWebpathLogin = _T("/download/stockana/login");
  82. const TCHAR *szWebpathLogout = _T("/download/stockana/logout");
  83. const TCHAR *szWebpathPackageInfo = _T("/download/stockana/package3.xml");
  84. const TCHAR *szWebpathServerInfo = _T("/download/stockana/server3.xml");
  85. #else
  86. const TCHAR *szWebpathWGet = _T("/download/clking/wget");
  87. const TCHAR *szWebpathLogin = _T("/download/clking/login");
  88. const TCHAR *szWebpathLogout = _T("/download/clking/logout");
  89. const TCHAR *szWebpathPackageInfo = _T("/download/clking/package3.xml");
  90. const TCHAR *szWebpathServerInfo = _T("/download/clking/server3.xml");
  91. #endif
  93. const TCHAR *szWGetResultKey = _T("retvalue=");
  94. const TCHAR *szResultOKFmt = _T("%sO%s");
  95. const TCHAR *szResultFailed = _T("-ERR");
  97. //////////////////////////////////////////////////////////////////////
  98. // Construction/Destruction
  99. //////////////////////////////////////////////////////////////////////
  101. CHttpClient::CHttpClient()
  102. {
  103. m_nAccessType = INTERNET_OPEN_TYPE_DIRECT;
  104. m_bIsLogin = FALSE;
  105. }
  107. CHttpClient::~CHttpClient()
  108. {
  110. }
  112. BOOL CHttpClient::SetServer(LPCTSTR lpszServer, INTERNET_PORT nPort)
  113. {
  114. if (m_bIsLogin)
  115. {
  116. if (0 != m_strServer.CompareNoCase(lpszServer) || m_nPort != nPort)
  117. m_bIsLogin = FALSE;
  118. }
  120. if (NULL != lpszServer)
  121. m_strServer = lpszServer;
  122. else
  123. m_strServer.Empty();
  124. m_nPort = nPort;
  126. return m_strServer.GetLength()>0;
  127. }
  129. BOOL CHttpClient::SetAccessType(int nAccessType, int nProxyType, LPCTSTR lpszProxyAddress, UINT nProxyPort,
  130. LPCSTR lpszProxyUser, LPCTSTR lpszProxyPasswd)
  131. {
  132. switch(nAccessType)
  133. {
  134. case INTERNET_OPEN_TYPE_PRECONFIG:
  135. m_nAccessType = nAccessType;
  136. break;
  137. case INTERNET_OPEN_TYPE_DIRECT:
  138. m_nAccessType = nAccessType;
  139. break;
  140. case INTERNET_OPEN_TYPE_PROXY:
  141. m_nAccessType = nAccessType;
  142. m_nProxyType = nProxyType;
  143. if (NULL == lpszProxyAddress || strlen(lpszProxyAddress)==0)
  144. {
  145. m_nAccessType = INTERNET_OPEN_TYPE_PRECONFIG;
  146. ASSERT(FALSE);
  147. return FALSE;
  148. }
  149. m_strProxyAddress = lpszProxyAddress;
  150. m_nProxyPort = nProxyPort;
  151. m_strProxyUser = lpszProxyUser;
  152. m_strProxyPasswd = lpszProxyPasswd;
  153. break;
  154. default:
  155. return FALSE;
  156. }
  158. return TRUE;
  159. }
  161. DWORD CHttpClient::WGet(LPCTSTR lpszURL, CString &strResult, PROGRESS_CALLBACK fnCallback, void *cookie)
  162. {
  163. return RequestGet(lpszURL, NULL, &strResult, fnCallback, cookie);
  164. }
  166. DWORD CHttpClient::WGet(LPCTSTR lpszURL, CFile *pFile, PROGRESS_CALLBACK fnCallback, void *cookie)
  167. {
  168. ASSERT(pFile);
  170. return RequestGet(lpszURL, NULL, pFile, fnCallback, cookie);
  171. }
  173. long getHardDriveComputerID();
  175. static CString GetDiskSerial()
  176. {
  177. CString strSerial;
  178. DWORD id = (DWORD)getHardDriveComputerID ();
  180. strSerial.Format("%u", id);
  181. return strSerial;
  182. }
  184. DWORD CHttpClient::WGet(LPCTSTR lpszRegCode, LPCTSTR lpszUserName,
  185. LPCTSTR lpszPasswd, LPCTSTR lpszVersion,
  186. CString &strResult, int nWantLen)
  187. {
  188. CMapStringToString map;
  189. map.SetAt(szRegCodeKey, lpszRegCode);
  190. map.SetAt(szUserNameKey, m_strUserName);
  191. map.SetAt(szPasswdKey, m_strPasswd);
  192. map.SetAt(szVersionKey, lpszVersion);
  194. CString strDiskSerial = GetDiskSerial();
  195. map.SetAt(szDiskSerialKey, strDiskSerial);
  197. CString strURL;
  198. strURL.Format(szHttpURLFormat, m_strServer, m_nPort, szWebpathWGet);
  200. CString strResultLocal, strValue;
  201. DWORD dwRet = RequestPost(strURL, &map, &strResultLocal, NULL, NULL);
  202. if (HTTP_STATUS_OK == dwRet)
  203. {
  204. int nIndex = strResultLocal.Find(szWGetResultKey);
  205. if (-1 != nIndex)
  206. strValue = strResultLocal.Mid(nIndex+strlen(szWGetResultKey), nWantLen);
  207. }
  208. if (strValue.GetLength() == nWantLen)
  209. {
  210. strResult = strValue;
  211. return dwRet;
  212. }
  214. return dwRet;
  215. }
  217. BOOL CHttpClient::Login(LPCTSTR lpszRegCode,
  218. LPCTSTR lpszUserName, LPCTSTR lpszPasswd,
  219. LPCTSTR lpszVersion)
  220. {
  221. if (m_bIsLogin && lpszRegCode && 0 == m_strRegCode.CompareNoCase(lpszRegCode)
  222. && lpszUserName && 0 == m_strUserName.CompareNoCase(lpszUserName))
  223. return TRUE;
  225. m_bIsLogin = FALSE;
  226. m_strRegCode.Empty();
  227. m_strUserName.Empty();
  228. m_strPasswd.Empty();
  229. if (NULL != lpszRegCode)
  230. m_strRegCode = lpszRegCode;
  231. if (NULL != lpszUserName)
  232. m_strUserName = lpszUserName;
  233. if (NULL != lpszPasswd)
  234. m_strPasswd = lpszPasswd;
  236. CMapStringToString map;
  237. map.SetAt(szRegCodeKey, lpszRegCode);
  238. map.SetAt(szVersionKey, lpszVersion);
  239. map.SetAt(szUserNameKey, m_strUserName);
  240. map.SetAt(szPasswdKey, m_strPasswd);
  242. CString strDiskSerial = GetDiskSerial();
  243. map.SetAt(szDiskSerialKey, strDiskSerial);
  245. CString strURL;
  246. strURL.Format(szHttpURLFormat, m_strServer, m_nPort, szWebpathLogin);
  248. CString strResult;
  249. if (HTTP_STATUS_OK == RequestPost(strURL, &map, &strResult, NULL, NULL))
  250. {
  251. CString strResultOK;
  252. strResultOK.Format(szResultOKFmt, "+", "K");
  253. if (-1 != strResult.Find(strResultOK))
  254. {
  255. m_bIsLogin = TRUE;
  256. return TRUE;
  257. }
  258. }
  260. return FALSE;
  261. }
  263. BOOL CHttpClient::Logout()
  264. {
  265. if (!m_bIsLogin)
  266. return FALSE;
  268. m_strRegCode.Empty();
  269. m_strUserName.Empty();
  270. m_strPasswd.Empty();
  272. CString strURL;
  273. strURL.Format(szHttpURLFormat, m_strServer, m_nPort, szWebpathLogout);
  275. CString strResult;
  276. if (HTTP_STATUS_OK == RequestPost(strURL, NULL, &strResult, NULL, NULL))
  277. {
  278. CString strResultOK;
  279. strResultOK.Format(szResultOKFmt, "+", "K");
  280. int nIndex = strResult.Find(strResultOK);
  281. }
  283. m_bIsLogin = FALSE;
  285. return TRUE;
  286. }
  289. BOOL CHttpClient::LoadServerInfo(CString &strResult, PROGRESS_CALLBACK fnCallback, void *cookie)
  290. {
  291. if (!m_bIsLogin)
  292. return FALSE;
  294. CString strURL;
  295. strURL.Format(szHttpURLFormat, m_strServer, m_nPort, szWebpathServerInfo);
  297. return (HTTP_STATUS_OK == RequestGet(strURL, NULL, &strResult, fnCallback, cookie));
  298. }
  300. BOOL CHttpClient::LoadPackageInfo(CString &strResult, PROGRESS_CALLBACK fnCallback, void *cookie)
  301. {
  302. if (!m_bIsLogin)
  303. return FALSE;
  305. CString strURL;
  306. strURL.Format(szHttpURLFormat, m_strServer, m_nPort, szWebpathPackageInfo);
  308. return (HTTP_STATUS_OK == RequestGet(strURL, NULL, &strResult, fnCallback, cookie));
  309. }
  311. BOOL CHttpClient::LoadPackage(LPCTSTR lpszURL, CFile *pFile, PROGRESS_CALLBACK fnCallback, void *cookie)
  312. {
  313. if (!m_bIsLogin)
  314. return FALSE;
  316. return (HTTP_STATUS_OK == RequestGet(lpszURL, NULL, pFile, fnCallback, cookie));
  317. }
  319. BOOL CHttpClient::GetLastErrorMessage(LPTSTR lpszError, UINT nMaxError)
  320. {
  321. if (!m_strLastErrorMessage.IsEmpty())
  322. {
  323. strncpy(lpszError, m_strLastErrorMessage.GetBuffer(m_strLastErrorMessage.GetLength()+1), nMaxError);
  324. m_strLastErrorMessage.ReleaseBuffer();
  325. return strlen(lpszError)>0;
  326. }
  327. if (nMaxError > 0)
  328. lpszError[0] = '';
  330. return FALSE;
  331. }
  333. //////////////////////////////////////////////////////////////
  334. // static methods
  336. const TCHAR  *szUnEscape = _T("^_.-");
  338. BOOL CHttpClient::EscapeString(LPCTSTR lpszValue, CString &strOut)
  339. {
  340. int i = 0;
  341. TCHAR tszTemp[ 4 ];
  343. if (NULL == lpszValue)
  344. return FALSE;
  346. strOut.Empty();
  347. ZeroMemory(tszTemp, sizeof(tszTemp));
  349. for(i=0; i<lstrlen(lpszValue); i++)
  350. {
  351. TCHAR tch = lpszValue[ i ];
  352. if (!_istalnum(tch) && (NULL==_tcschr(szUnEscape, tch)))
  353. {
  354. _stprintf(tszTemp, "%%%02X", (TBYTE)tch);
  355. strOut += tszTemp;
  356. }
  357. else
  358. strOut += tch;
  359. }
  361. return TRUE;
  362. }
  364. BOOL CHttpClient::_MakeHttpData(CMapStringToString &__map, CString &__strOut, LPCTSTR __lpszSep)
  365. {
  366. CString strKey, strValue, strTemp;
  367. POSITION pos;
  369. ASSERT(0 == lstrcmp(__lpszSep, "rn") || 0 == lstrcmp(__lpszSep, "&"));
  371. __strOut = _T("");
  372. pos = __map.GetStartPosition();
  373. while(pos)
  374. {
  375. __map.GetNextAssoc(pos, strKey, strValue);
  376. EscapeString(strValue, strTemp);
  377. __strOut += strKey;
  378. __strOut += _T("=");
  379. __strOut += strTemp;
  380. __strOut += __lpszSep;
  381. }
  383. return TRUE;
  384. }
  386. BOOL CHttpClient::MakeHttpHeader(CMapStringToString &__map, CString &__strOut)
  387. {
  388. CString strKey, strValue, strTemp;
  389. POSITION pos;
  391. pos = __map.GetStartPosition();
  392. while(pos)
  393. {
  394. /* Add other Header */
  395. __map.GetNextAssoc(pos, strKey, strValue);
  397. if (0 != strKey.Compare(szUserAgentKey))
  398. {
  399. strTemp.Format(szHeaderFormat, strKey, strValue);
  400. __strOut += strTemp;
  401. }
  402. }
  404. return TRUE;
  405. }
  407. BOOL CHttpClient::MakePostData(CMapStringToString &__map, CString &__strOut)
  408. {
  409. return _MakeHttpData(__map, __strOut, "rn");
  410. }
  412. BOOL CHttpClient::MakeGetData(CMapStringToString &__map, CString &__strOut)
  413. {
  414. return _MakeHttpData(__map, __strOut, "&");
  415. }
  417. BOOL CHttpClient::PostDataEncoding(CString &strPostData)
  418. {
  419. int len = strPostData.GetLength();
  420. CString strDesData;
  421. CDLocalView des;
  422. des.Create((BYTE *)strPostData.GetBuffer(len), (BYTE *)strDesData.GetBuffer(len+1), len);
  423. (strDesData.GetBuffer(len+1))[len] = '';
  425. size_t srcLen = len;
  426. const char *srcBuf = strDesData.GetBuffer(srcLen);
  427. size_t destSize = 4*(srcLen+2)/3;
  428. destSize += strlen("rn")*destSize/72 + 2;
  429. destSize += 64; /*64;  a little extra room */
  431. /* Allocate destination buffer */
  432. char * destBuf = strPostData.GetBuffer(destSize);
  433. if (0 == destBuf)
  434. {
  435. strDesData.ReleaseBuffer();
  436. strPostData.ReleaseBuffer();
  437. return FALSE;
  438. }
  440. /* Encode source to destination */
  441. size_t destLen = 0;
  442. int result = encode_base64(srcBuf, srcLen, destBuf, destSize, &destLen);
  443. if (destLen < destSize)
  444. destBuf[destLen] = '';
  446. strDesData.ReleaseBuffer();
  447. strPostData.ReleaseBuffer();
  449. return (0 == result && destLen < destSize);
  450. }
  452. BOOL CHttpClient::PostDataDecoding(CString &strPostData)
  453. {
  454. CString strDesData;
  455. int len = strPostData.GetLength();
  457. size_t srcLen = len;
  458. const char *srcBuf = strPostData.GetBuffer(srcLen);
  459. size_t destSize = 4*(srcLen+2)/3;
  460. destSize += strlen("rn")*destSize/72 + 2;
  461. destSize += 64; /*64;  a little extra room */
  463. /* Allocate destination buffer */
  464. char * destBuf = strDesData.GetBuffer(destSize);
  465. if (0 == destBuf)
  466. {
  467. strPostData.ReleaseBuffer();
  468. strDesData.ReleaseBuffer();
  469. return FALSE;
  470. }
  472. /* Encode source to destination */
  473. size_t destLen = 0;
  474. int result = decode_base64(srcBuf, srcLen, destBuf, destSize, &destLen);
  475. if (destLen < destSize)
  476. destBuf[destLen] = '';
  477. strPostData.ReleaseBuffer();
  478. strDesData.ReleaseBuffer();
  479. if (0 != result || destLen >= destSize)
  480. return FALSE;
  482. CDLocalView des;
  483. len = destLen;
  484. des.Destroy((BYTE *)strDesData.GetBuffer(destLen), (BYTE *)strPostData.GetBuffer(len+1), len);
  485. (strPostData.GetBuffer(len+1))[len] = '';
  487. strPostData.ReleaseBuffer();
  488. strDesData.ReleaseBuffer();
  490. return TRUE;
  491. }
  493. //////////////////////////////////////////////////////////////
  494. // common methods
  496. DWORD CHttpClient::RequestGet(LPCTSTR lpszURL, CMapStringToString* pmapParam,
  497. CFile * pFileSave, PROGRESS_CALLBACK fnCallback, void *cookie)
  498. {
  499. if (NULL == lpszURL || strlen(lpszURL) == 0)
  500. return HTTP_STATUS_BAD_REQUEST;
  502. if (NULL != pFileSave && CFile::hFileNull == pFileSave->m_hFile)
  503. {
  504. ASSERT(FALSE);
  505. return HTTP_STATUS_BAD_REQUEST;
  506. }
  508. CString strURL = lpszURL;
  510. if (NULL != pmapParam)
  511. {
  512. CString strParam;
  513. MakeGetData(*pmapParam, strParam);
  514. if (!strParam.IsEmpty())
  515. strURL += "?" + strParam;
  516. }
  518. return Request(strURL, CString(""), pFileSave, NULL, fnCallback, cookie);
  519. }
  521. DWORD CHttpClient::RequestGet(LPCTSTR lpszURL, CMapStringToString* pmapParam,
  522. CString *pstrResult, PROGRESS_CALLBACK fnCallback, void *cookie)
  523. {
  524. if (NULL == lpszURL || strlen(lpszURL) == 0)
  525. return HTTP_STATUS_BAD_REQUEST;
  527. CString strURL = lpszURL;
  528. if (NULL != pmapParam)
  529. {
  530. CString strParam;
  531. MakeGetData(*pmapParam, strParam);
  532. if (!strParam.IsEmpty())
  533. strURL += "?" + strParam;
  534. }
  536. return Request(strURL, CString(""), NULL, pstrResult, fnCallback, cookie);
  537. }
  539. DWORD CHttpClient::RequestPost(LPCTSTR lpszURL, CMapStringToString* pmapParam,
  540. CFile * pFileSave, PROGRESS_CALLBACK fnCallback, void *cookie)
  541. {
  542. if (NULL != pFileSave && CFile::hFileNull == pFileSave->m_hFile)
  543. {
  544. ASSERT(FALSE);
  545. return HTTP_STATUS_BAD_REQUEST;
  546. }
  548. CString strPostData;
  549. if (NULL != pmapParam)
  550. MakePostData(*pmapParam, strPostData);
  552. // PostDataEncoding(strPostData);
  554. return Request(lpszURL, strPostData, pFileSave, NULL, fnCallback, cookie);
  555. }
  557. DWORD CHttpClient::RequestPost(LPCTSTR lpszURL, CMapStringToString* pmapParam,
  558. CString *pstrResult, PROGRESS_CALLBACK fnCallback, void *cookie)
  559. {
  560. CString strPostData;
  561. if (NULL != pmapParam)
  562. MakePostData(*pmapParam, strPostData);
  564. // PostDataEncoding(strPostData);
  566. return Request(lpszURL, strPostData, NULL, pstrResult, fnCallback, cookie);
  567. }
  569. void CHttpClient::DoOpenURL(LPCTSTR lpszURL, DWORD dwHttpRequestFlags,
  570. CString &strHeader, CString &strPostData,
  571. CInternetSession *pSession,
  572. CHttpConnection **ppServer, CHttpFile **ppFile,
  573. PROGRESS_CALLBACK fnCallback, void * cookie)
  574. {
  575. CString strServerName;
  576. CString strObject;
  577. INTERNET_PORT nPort;
  578. DWORD dwServiceType;
  580. int nVerb = (strPostData.GetLength()>0 ? CHttpConnection::HTTP_VERB_POST : CHttpConnection::HTTP_VERB_GET);
  582. if (!AfxParseURL(lpszURL, dwServiceType, strServerName, strObject, nPort) ||
  583. dwServiceType != INTERNET_SERVICE_HTTP)
  584. {
  585. ThrowTearException(ERR_TEAR_URLFORMAT);
  586. }
  588. if (fnCallback)
  589. fnCallback(PROG_HTTPCONNECTTING, 0, NULL, cookie);
  591. CHttpConnection *pServer = pSession->GetHttpConnection(strServerName, dwHttpRequestFlags, nPort, m_strProxyUser, m_strProxyPasswd);
  592. CHttpFile * pFile = pServer->OpenRequest(nVerb, strObject, NULL, 1, NULL, NULL, dwHttpRequestFlags);
  593. pFile->AddRequestHeaders(strHeader, HTTP_ADDREQ_FLAG_COALESCE);
  594. if (strPostData.GetLength() > 0) // post
  595. {
  596. try
  597. {
  598. pFile->SendRequestEx(DWORD(strPostData.GetLength()));
  599. pFile->WriteString(strPostData);
  600. pFile->EndRequest();
  601. }
  602. catch(CInternetException *pp) // HTTP_STATUS_BAD_METHOD
  603. {
  604. pp->Delete();
  606. // close up the redirected site
  607. pFile->Close();
  608. delete pFile;
  609. pFile = NULL;
  610. pServer->Close();
  611. delete pServer;
  612. pServer = NULL;
  614. pServer = pSession->GetHttpConnection(strServerName, dwHttpRequestFlags, nPort, m_strProxyUser, m_strProxyPasswd);
  615. pFile = pServer->OpenRequest(nVerb, strObject, NULL, 1, NULL, NULL, dwHttpRequestFlags);
  616. pFile->AddRequestHeaders(strHeader, HTTP_ADDREQ_FLAG_COALESCE);
  617. pFile->SendRequestEx(DWORD(strPostData.GetLength()));
  618. pFile->WriteString(strPostData);
  619. pFile->EndRequest();
  620. }
  621. }
  622. else
  623. {
  624. pFile->SendRequest();
  625. }
  627. if (fnCallback)
  628. fnCallback(PROG_REQUESTSENT, 0, NULL, cookie);
  630. // Bad Post method
  631. DWORD dwRet = 0;
  632. pFile->QueryInfoStatusCode(dwRet);
  634. // if access was denied, prompt the user for the password
  635. if (dwRet == HTTP_STATUS_DENIED
  636. || dwRet == HTTP_STATUS_PROXY_AUTH_REQ)
  637. {
  638. DWORD dwPrompt;
  639. dwPrompt = pFile->ErrorDlg(NULL, ERROR_INTERNET_INCORRECT_PASSWORD,
  640. FLAGS_ERROR_UI_FILTER_FOR_ERRORS | FLAGS_ERROR_UI_FLAGS_GENERATE_DATA
  641. | FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS, NULL);
  643. // if the user cancelled the dialog, bail out
  644. if (dwPrompt != ERROR_INTERNET_FORCE_RETRY)
  645. ThrowTearException(ERR_TEAR_CANCEL);
  646. if (strPostData.GetLength() > 0) // post
  647. {
  648. try{
  649. pFile->SendRequestEx(DWORD(strPostData.GetLength()));
  650. pFile->WriteString(strPostData);
  651. pFile->EndRequest();
  652. }
  653. catch(CInternetException *pp) // HTTP_STATUS_BAD_METHOD
  654. {
  655. pp->Delete();
  657. pFile->SendRequestEx(DWORD(strPostData.GetLength()));
  658. pFile->WriteString(strPostData);
  659. pFile->EndRequest();
  660. }
  661. }
  662. else
  663. {
  664. pFile->SendRequest();
  665. }
  666. pFile->QueryInfoStatusCode(dwRet);
  667. }
  669. if (dwRet == HTTP_STATUS_BAD_METHOD)
  670. {
  671. // close up the redirected site
  672. pFile->Close();
  673. delete pFile;
  674. pFile = NULL;
  675. pServer->Close();
  676. delete pServer;
  677. pServer = NULL;
  679. pServer = pSession->GetHttpConnection(strServerName, dwHttpRequestFlags, nPort, m_strProxyUser, m_strProxyPasswd);
  680. pFile = pServer->OpenRequest(CHttpConnection::HTTP_VERB_GET, strObject, NULL, 1, NULL, NULL, dwHttpRequestFlags);
  681. pFile->AddRequestHeaders(strHeader, HTTP_ADDREQ_FLAG_COALESCE);
  682. if (strPostData.GetLength() > 0) // post
  683. {
  684. pFile->SendRequestEx(DWORD(strPostData.GetLength()));
  685. pFile->WriteString(strPostData);
  686. pFile->EndRequest();
  687. }
  688. else
  689. {
  690. pFile->SendRequest();
  691. }
  692. }
  694. *ppServer = pServer;
  695. *ppFile = pFile;
  696. }
  698. CString CHttpClient::GetNewLocation(CHttpFile * pFile)
  699. {
  700. CString strNewLocation;
  701. pFile->QueryInfo(HTTP_QUERY_RAW_HEADERS_CRLF, strNewLocation);
  703. int nPlace = strNewLocation.Find(_T("Location: "));
  704. if (nPlace == -1)
  705. {
  706. ThrowTearException(ERR_TEAR_REDIRECT);
  707. }
  709. strNewLocation = strNewLocation.Mid(nPlace + 10);
  710. nPlace = strNewLocation.Find('n');
  711. if (nPlace > 0)
  712. strNewLocation = strNewLocation.Left(nPlace);
  713. return strNewLocation;
  714. }
  716. void CHttpClient::DoSecurityRequest(CHttpFile * pFile, CString &strPostData)
  717. {
  718. DWORD dwPrompt;
  719. dwPrompt = pFile->ErrorDlg(NULL, ERROR_INTERNET_INCORRECT_PASSWORD,
  720. FLAGS_ERROR_UI_FILTER_FOR_ERRORS | FLAGS_ERROR_UI_FLAGS_GENERATE_DATA
  721. | FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS, NULL);
  723. // if the user cancelled the dialog, bail out
  724. if (dwPrompt != ERROR_INTERNET_FORCE_RETRY)
  725. ThrowTearException(ERR_TEAR_CANCEL);
  726. if (strPostData.GetLength() > 0) // post
  727. {
  728. try{
  729. pFile->SendRequestEx(DWORD(strPostData.GetLength()));
  730. pFile->WriteString(strPostData);
  731. pFile->EndRequest();
  732. }
  733. catch(CInternetException *pp)
  734. {
  735. pp->Delete();
  736. // HTTP_STATUS_BAD_METHOD
  737. pFile->SendRequest();
  738. }
  739. }
  740. else
  741. {
  742. pFile->SendRequest();
  743. }
  744. }
  746. CString FormatProxyString(int nProxyType, LPCTSTR lpszProxyAddress, UINT nProxyPort)
  747. {
  748. if (NULL == lpszProxyAddress || strlen(lpszProxyAddress) <= 0)
  749. return "";
  750. CString strProxy;
  751. CString strProxyType;
  752. if (CProxySocket::TypeSocks4 == nProxyType || CProxySocket::TypeSocks5 == nProxyType)
  753. strProxyType = "socks=";
  754. else if (CProxySocket::TypeHTTP == nProxyType)
  755. strProxyType = "http=";
  756. strProxy.Format("%s%s:%d", strProxyType, lpszProxyAddress, nProxyPort);
  757. return strProxy;
  758. }
  760. DWORD CHttpClient::Request(LPCTSTR lpszURL, CString &strPostData,
  761.  CFile *pFileSave, CString *pstrResult,
  762.  PROGRESS_CALLBACK fnCallback, void *cookie)
  763. {
  764. DWORD dwRet = HTTP_STATUS_BAD_REQUEST;
  766. if (NULL == lpszURL || strlen(lpszURL) == 0)
  767. return dwRet;
  769. int nContentLength = 0;
  770. int nContentLengthLocal = 0;
  771. int nContentLengthFinished = 0;
  772. int nContentLengthTotal = 0;
  774. // prepare header
  775. CString strHeader;
  776. CMapStringToString mapHeader;
  777. if (pFileSave && pFileSave->GetPosition() > 0)
  778. {
  779. nContentLengthFinished = (int)pFileSave->GetPosition();
  780. CString strRange;
  781. strRange.Format("bytes=%u-", nContentLengthFinished);
  782. mapHeader.SetAt(szRange, strRange);
  784. }
  785. if (pstrResult && pstrResult->GetLength() > 0)
  786. {
  787. nContentLengthFinished = pstrResult->GetLength();
  788. CString strRange;
  789. strRange.Format("bytes=%u-", nContentLengthFinished);
  790. mapHeader.SetAt(szRange, strRange);
  791. }
  792. if (m_strCookie.GetLength() > 0)
  793. mapHeader.SetAt(szCookieKey, m_strCookie);
  794. MakeHttpHeader(mapHeader, strHeader);
  796. // default type and flags
  797. DWORD dwHttpRequestFlags = INTERNET_FLAG_TRANSFER_BINARY | INTERNET_FLAG_RELOAD
  798. | INTERNET_FLAG_DONT_CACHE
  799. | INTERNET_FLAG_EXISTING_CONNECT; // | INTERNET_FLAG_KEEP_CONNECTION;
  801. CString strProxy;
  802. if (!m_strProxyAddress.IsEmpty())
  803. strProxy = FormatProxyString(m_nProxyType, m_strProxyAddress, m_nProxyPort);
  804. CInternetSession session( szUserAgentValue, 1, m_nAccessType,
  805. strProxy, NULL, INTERNET_FLAG_DONT_CACHE);
  806. // 以下SetOption似乎不起作用
  807. if (!strProxy.IsEmpty() && !m_strProxyAddress.IsEmpty())
  808. {
  809. session.SetOption(INTERNET_OPTION_PROXY_USERNAME, (LPVOID)(LPCTSTR)m_strProxyUser, m_strProxyUser.GetLength());
  810. session.SetOption(INTERNET_OPTION_PROXY_PASSWORD, (LPVOID)(LPCTSTR)m_strProxyPasswd, m_strProxyPasswd.GetLength());
  811. }
  812. session.SetOption(INTERNET_OPTION_RECEIVE_TIMEOUT, 300000);
  813. session.SetOption(INTERNET_OPTION_SEND_TIMEOUT, 30000);
  814. session.SetOption(INTERNET_OPTION_CONNECT_TIMEOUT, 30000);
  816. CHttpConnection* pServer = NULL;
  817. CHttpFile* pFile = NULL;
  818. try
  819. {
  820. // check to see if this is a reasonable URL
  821. DoOpenURL(lpszURL, dwHttpRequestFlags, strHeader, strPostData, &session, &pServer, &pFile, fnCallback, cookie);
  822. if (NULL == pServer || NULL == pFile)
  823. ThrowTearException(ERR_TEAR_INTERRUPTED);
  825. pFile->QueryInfoStatusCode(dwRet);
  827. if (dwRet == HTTP_STATUS_MOVED ||
  828. dwRet == HTTP_STATUS_REDIRECT ||
  829. dwRet == HTTP_STATUS_REDIRECT_METHOD)
  830. {
  831. CString strNewLocation = GetNewLocation(pFile);
  833. // close up the redirected site
  834. pFile->Close();
  835. delete pFile;
  836. pFile = NULL;
  837. pServer->Close();
  838. delete pServer;
  839. pServer = NULL;
  841. // progress callback
  842. if (fnCallback)
  843. fnCallback(PROG_REDIRECTING, 0, NULL, cookie);
  845. // open new url
  846. DoOpenURL(strNewLocation, dwHttpRequestFlags,
  847. strHeader, strPostData,
  848. &session, &pServer, &pFile, fnCallback, cookie);
  850. pFile->QueryInfoStatusCode(dwRet);
  851. }
  853. if (dwRet == HTTP_STATUS_PARTIAL_CONTENT)
  854. dwRet = HTTP_STATUS_OK;
  855. if (dwRet != HTTP_STATUS_OK)
  856. ThrowTearException(ERR_TEAR_INTERRUPTED);
  858. CString strInfo;
  859. pFile->QueryInfo(HTTP_QUERY_SET_COOKIE, strInfo);
  860. pFile->QueryInfo(HTTP_QUERY_COOKIE, strInfo);
  861. if (strInfo.GetLength())
  862. m_strCookie = strInfo;
  863. pFile->QueryInfo(HTTP_QUERY_CONTENT_LENGTH, strInfo);
  864. nContentLength = atol(strInfo);
  865. nContentLengthTotal = nContentLength + nContentLengthFinished;
  866. if (pstrResult && nContentLengthTotal > 0)
  867. pstrResult->GetBuffer(nContentLengthTotal+5);
  869. DWORD dwCheckSum = 0;
  870. BOOL bHasCheckSum = FALSE;
  871. CString strCheckSum;
  872. pFile->QueryInfo(HTTP_QUERY_RAW_HEADERS_CRLF, strCheckSum);
  873. int nPlace = strCheckSum.Find(szCheckSumKeySuffix);
  874. if (-1 != nPlace)
  875. {
  876. strCheckSum = strCheckSum.Mid(nPlace+strlen(szCheckSumKeySuffix));
  877. nPlace = strCheckSum.Find('n');
  878. if (nPlace > 0)
  879. {
  880. dwCheckSum = atol(strCheckSum.Left(nPlace));
  881. bHasCheckSum = TRUE;
  882. }
  883. }
  885. if (fnCallback)
  886. fnCallback(PROG_TRANSFERRING, 0, NULL, cookie);
  888. DWORD dwCheckSumLocal = 0;
  889. TCHAR sz[1028];
  890. int nRead = pFile->Read(sz+4, 1023);
  891. while (nRead > 0)
  892. {
  893. sz[4+nRead] = '';
  894. if (NULL != pFileSave)
  895. pFileSave->Write(sz+4, nRead);
  896. if (NULL != pstrResult)
  897. *pstrResult += (TCHAR *)(sz+4);
  898. nContentLengthLocal += nRead;
  900. if (fnCallback && nContentLengthTotal > 0)
  901. fnCallback(PROG_PROGRESS, DWORD(STKLIB_MAXF_PROGRESS*(nContentLengthFinished+nContentLengthLocal)/nContentLengthTotal), NULL, cookie);
  903. if (bHasCheckSum)
  904. {
  905. *((DWORD *)sz) = dwCheckSumLocal;
  906. dwCheckSumLocal = CRC32(sz, nRead);
  907. }
  909. nRead = pFile->Read(sz+4, 1023);
  910. }
  912. if (pstrResult && nContentLengthTotal > 0)
  913. pstrResult->ReleaseBuffer();
  915. if ((nContentLength > 0 && nContentLengthLocal != nContentLength)
  916. || (bHasCheckSum && dwCheckSum != dwCheckSumLocal))
  917. ThrowTearException(ERR_TEAR_DATATRANSFER);
  919. if (fnCallback)
  920. fnCallback(PROG_PROGRESS, STKLIB_MAX_PROGRESS, NULL, cookie);
  921. }
  922. catch (CInternetException* pEx)
  923. {
  924. // catch errors from WinINet
  925. if (HTTP_STATUS_OK == dwRet)
  926. dwRet = HTTP_STATUS_PARTIAL;
  927. TCHAR szErr[1024];
  928. pEx->GetErrorMessage(szErr, 1024);
  929. m_strLastErrorMessage = szErr;
  930. pEx->Delete();
  931. }
  932. catch (CTearException* pEx)
  933. {
  934. TCHAR szErr[1024];
  935. pEx->GetErrorMessage(szErr, 1024);
  936. m_strLastErrorMessage = szErr;
  937. pEx->Delete();
  938. }
  939. catch(CException * pEx)
  940. {
  941. TCHAR szErr[1024];
  942. pEx->GetErrorMessage(szErr, 1024);
  943. m_strLastErrorMessage = szErr;
  944. pEx->Delete();
  945. }
  947. if (pFile != NULL)
  948. {
  949. pFile->Close();
  950. delete pFile;
  951. }
  952. if (pServer != NULL)
  953. {
  954. pServer->Close();
  955. delete pServer;
  956. }
  957. session.Close();
  959. if (nContentLength > 0 && nContentLengthLocal != nContentLength)
  960. return Request(lpszURL, strPostData, pFileSave, pstrResult, fnCallback, cookie);
  962. return dwRet;
  963. }