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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
XMLHTTPRequest.cpp
资源名称：xerces-c-src1_6_0.tar.gz　[点击查看]
上传用户：huihehuasu
上传日期：2007-01-10
资源大小：6948k
文件大小：29k
源码类别：

xml/soap/webservice

开发平台：

C/C++

XMLHTTPRequest.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  * 
  4.  * Copyright (c) 1999-2000 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  * 
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  * 
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer. 
  13.  * 
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  * 
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:  
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  * 
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written 
  29.  *    permission, please contact apache@apache.org.
  30.  * 
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  * 
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  * 
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  57. /*
  58.  * $Log: XMLHTTPRequest.cpp,v $
  59.  * Revision 1.3  2000/06/03 00:29:03  andyh
  60.  * COM Wrapper changes from Curt Arnold
  61.  *
  62.  * Revision 1.2  2000/03/30 02:00:09  abagchi
  63.  * Initial checkin of working code with Copyright Notice
  64.  *
  65.  */
  67. #include "stdafx.h"
  69. #include "xml4com.h"
  70. #include "XMLHttpRequest.h"
  71. #include "XMLDOMDocument.h"
  73. // I need to make sure the file is registered with long filenames
  74. HRESULT WINAPI CXMLHttpRequest::UpdateRegistry(BOOL bRegister)
  75. {
  76. USES_CONVERSION;
  78. TCHAR file[MAX_PATH];
  79. if (::GetModuleFileName(_Module.m_hInst, file, MAX_PATH)) {
  80. WIN32_FIND_DATA d;
  81. memset(&d,0,sizeof(WIN32_FIND_DATA));
  82. HANDLE h = FindFirstFile(file,&d);
  83. if (h != INVALID_HANDLE_VALUE) {
  84. TCHAR  *name = _tcsrchr(file,_T('\'));
  85. TCHAR newFile[MAX_PATH] = _T("");
  86. _tcsncpy(newFile,file,name-file);
  87. _tcscat(newFile,_T("\"));
  88. _tcscat(newFile,d.cFileName);
  89. FindClose(h);
  91. _ATL_REGMAP_ENTRY regmap[2] = {{NULL,NULL},{NULL,NULL}};
  92. regmap[0].szKey  = OLESTR("XMLMODULE");
  93. regmap[0].szData = T2OLE(newFile);
  94. return _Module.UpdateRegistryFromResource((UINT) IDR_XMLHTTPREQUEST, bRegister,regmap);
  95. }
  96. }
  97. return E_FAIL;
  98. }
  100. CXMLHttpRequest::CXMLHttpRequest()
  101. :m_pOnReadyStateChange (NULL)
  102. ,m_bAbort (false)
  103. ,m_hThread (NULL)
  104. ,m_lReadyState (0)
  105. ,m_bAsync (false)
  106. ,m_Method (_T(""))
  107. ,m_HostName (_T(""))
  108. ,m_Port (INTERNET_DEFAULT_HTTP_PORT)
  109. ,m_URLPath (_T(""))
  110. ,m_User (_T(""))
  111. ,m_Password (_T(""))
  112. ,m_dwStatus (0)
  113. ,m_StatusText (_T(""))
  114. ,m_ResponseHeaders (_T(""))
  115. ,m_HwndParent (NULL)
  116. ,m_pBody (NULL)
  117. ,m_lBodyLength (0)
  118. ,m_pResponseBody (NULL)
  119. ,m_lResponseBodyLength (0)
  120. ,m_Error (_T(""))
  121. ,m_bSuccess (true)
  122. {
  123. }
  125. HRESULT CXMLHttpRequest::FinalConstruct()
  126. {
  127. // create monitor window
  128. RECT rc;
  129.     memset(&rc,0,sizeof(RECT));
  130. if (NULL == Create(NULL, rc, _T("XML HTTP Request Monitor Window"), 0))
  131. return E_FAIL;
  133. return S_OK;
  134. }
  136. void CXMLHttpRequest::FinalRelease()
  137. {
  138. if (NULL != m_hThread) {
  139. m_bAbort = true;
  140. ::WaitForSingleObject(m_hThread, INFINITE);
  141. ::CloseHandle(m_hThread);
  142. m_hThread = NULL;
  143. }
  145. if (m_pOnReadyStateChange != NULL) {
  146. m_pOnReadyStateChange->Release();
  147. m_pOnReadyStateChange = NULL;
  148. }
  150. DestroyWindow();
  152. delete [] m_pBody;
  153. m_pBody = NULL;
  154. m_lBodyLength = 0;
  156. delete [] m_pResponseBody;
  157. m_pResponseBody = NULL;
  158. m_lResponseBodyLength = 0;
  159. }
  161. LRESULT CXMLHttpRequest::OnReadyStateChange(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
  162. {
  163. ATLTRACE(_T("CXMLHttpRequest::OnReadyStateChangen"));
  165. bHandled = TRUE;
  167. m_lReadyState = wParam;
  168. if (NULL != m_pOnReadyStateChange) {
  169. CComVariant varResult;
  170. DISPPARAMS disp = { NULL, NULL, 0, 0 };
  171. m_pOnReadyStateChange->Invoke(DISPID_VALUE, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
  172. }
  174. return 1L;
  175. }
  178. STDMETHODIMP CXMLHttpRequest::InterfaceSupportsErrorInfo(REFIID riid)
  179. {
  180. if (IsEqualGUID(IID_IXMLHttpRequest,riid))
  181. return S_OK;
  182. return S_FALSE;
  183. }
  185. STDMETHODIMP CXMLHttpRequest::open(BSTR bstrMethod, BSTR bstrUrl,VARIANT varAsync,VARIANT bstrUser,VARIANT bstrPassword)
  186. {
  187. ATLTRACE(_T("CXMLHttpRequest::openn"));
  189. // do not open if there is a send active  
  190. if (NULL != m_hThread) {
  191. DWORD exitCode = 0;
  192. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  193. if (!rc || STILL_ACTIVE == exitCode) 
  194. return E_FAIL;
  196. ::CloseHandle(m_hThread);
  197. m_hThread = NULL;
  198. }
  200. if (V_VT(&varAsync) != VT_BOOL)
  201. return E_INVALIDARG;
  203. _bstr_t method = bstrMethod;
  204. if (0 == method.length())
  205. return E_INVALIDARG;
  207. _bstr_t url = bstrUrl;
  208. if (0 == url.length())
  209. return E_INVALIDARG;
  211. TCHAR hostName[INTERNET_MAX_PATH_LENGTH] = _T("");
  212. TCHAR strPathName[INTERNET_MAX_PATH_LENGTH] = _T("");
  213. URL_COMPONENTS urlComponents;
  214. memset(&urlComponents, 0, sizeof(URL_COMPONENTS)); 
  215. urlComponents.dwStructSize = sizeof(URL_COMPONENTS);
  216. urlComponents.lpszHostName = hostName;
  217. urlComponents.dwHostNameLength = INTERNET_MAX_PATH_LENGTH;
  218. urlComponents.lpszUrlPath   = strPathName;
  219. urlComponents.dwUrlPathLength = INTERNET_MAX_PATH_LENGTH;
  221. if (!InternetCrackUrl(url, url.length(), 0, &urlComponents)) 
  222. return E_INVALIDARG;
  224. m_Method = method;
  225. m_HostName = hostName;
  226. if (urlComponents.nPort != 0)
  227. m_Port = urlComponents.nPort; 
  229. m_URLPath = strPathName;
  230. m_bAsync = (VARIANT_TRUE == V_BOOL(&varAsync)) ? true : false; 
  231. if (VT_BSTR == V_VT(&bstrUser))
  232. m_User = V_BSTR(&bstrUser);
  233. else
  234. m_User = _T("");
  236. if (VT_BSTR == V_VT(&bstrPassword) && m_User.length() > 0)
  237. m_Password = V_BSTR(&bstrPassword);
  238. else
  239. m_Password = _T(""); 
  241. return S_OK;
  242. }
  244. STDMETHODIMP CXMLHttpRequest::setRequestHeader(BSTR bstrHeader,  BSTR bstrValue)
  245. {
  246. ATLTRACE(_T("CXMLHttpRequest::setRequestHeadern"));
  248. if (NULL == bstrHeader || NULL == bstrValue)
  249. return E_INVALIDARG;
  251. // check if there is a send active  
  252. if (NULL != m_hThread) {
  253. DWORD exitCode = 0;
  254. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  255. if (!rc || STILL_ACTIVE == exitCode) 
  256. return E_PENDING;
  258. ::CloseHandle(m_hThread);
  259. m_hThread = NULL;
  260. }
  262. m_RequestHeaderMap.Remove(bstrHeader);
  263. m_RequestHeaderMap.Add(bstrHeader,bstrValue);
  264. return S_OK;
  265. }
  267. STDMETHODIMP CXMLHttpRequest::getResponseHeader(BSTR bstrHeader, BSTR * pbstrValue)
  268. {
  269. ATLTRACE(_T("CXMLHttpRequest::getResponseHeadern"));
  271. if (NULL == pbstrValue)
  272. return E_POINTER;
  274. *pbstrValue = NULL;
  276. if (NULL == bstrHeader)
  277. return E_INVALIDARG;
  279. // check if there is a send active  
  280. if (NULL != m_hThread) {
  281. DWORD exitCode = 0;
  282. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  283. if (!rc || STILL_ACTIVE == exitCode) 
  284. return E_PENDING;
  286. ::CloseHandle(m_hThread);
  287. m_hThread = NULL;
  288. }
  290. if (0 == m_ResponseHeaders.length())
  291. return S_FALSE;
  293. _bstr_t value;
  294. _bstr_t header(bstrHeader);
  295. header += _T(": ");
  296. _tcslwr(header);
  297. TCHAR *pHeaders = new TCHAR[m_ResponseHeaders.length() + sizeof(TCHAR)];
  298. _tcscpy(pHeaders,m_ResponseHeaders);
  299. _tcslwr(pHeaders);
  300. TCHAR *pStart = _tcsstr(pHeaders,header);
  301. if (pStart) {
  302. pStart += header.length();
  303. TCHAR *pEnd = _tcsstr(pStart,_T("rn"));
  304. if (pEnd) {
  305. TCHAR *pHeader = new TCHAR[pEnd-pStart + sizeof(TCHAR)];
  306. _tcsncpy(pHeader,static_cast<LPCTSTR> (m_ResponseHeaders) + (pStart-pHeaders),pEnd-pStart);
  307. value = pHeader;
  308. delete [] pHeader;
  309. }
  310. }
  311. delete[] pHeaders;
  313. if (0 == value.length())
  314. return S_FALSE;
  316. *pbstrValue = value.copy();
  318. return S_OK;
  319. }
  321. STDMETHODIMP CXMLHttpRequest::getAllResponseHeaders(BSTR * pbstrHeaders)
  322. {
  323. ATLTRACE(_T("CXMLHttpRequest::getAllResponseHeadersn"));
  325. if (NULL == pbstrHeaders)
  326. return E_POINTER;
  328. *pbstrHeaders = NULL;
  330. if (NULL == pbstrHeaders)
  331. return E_INVALIDARG;
  333. // check if there is a send active  
  334. if (NULL != m_hThread) {
  335. DWORD exitCode = 0;
  336. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  337. if (!rc || STILL_ACTIVE == exitCode) 
  338. return E_PENDING;
  340. ::CloseHandle(m_hThread);
  341. m_hThread = NULL;
  342. }
  344. *pbstrHeaders = m_ResponseHeaders.copy();
  345. return S_OK;
  346. }
  348. STDMETHODIMP CXMLHttpRequest::send(VARIANT varBody)
  349. {
  350. ATLTRACE(_T("CXMLHttpRequest::sendn"));
  352. if (V_VT(&varBody) != VT_BSTR && 
  353. V_VT(&varBody) != VT_DISPATCH &&
  354. V_VT(&varBody) != (VT_ARRAY | VT_VARIANT) &&
  355. V_VT(&varBody) != (VT_ARRAY | VT_UI1) &&
  356. V_VT(&varBody) != VT_UNKNOWN)
  357. return E_INVALIDARG;
  359. // do not start another thread if there is another active  
  360. if (NULL != m_hThread) {
  361. DWORD exitCode = 0;
  362. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  363. if (!rc || STILL_ACTIVE == exitCode) 
  364. return E_PENDING;
  366. ::CloseHandle(m_hThread);
  367. m_hThread = NULL;
  368. }
  370. HRESULT hr = S_OK;
  371. m_bSuccess = true;
  372. m_bAbort = false;
  373. delete [] m_pBody;
  374. m_pBody = NULL;
  375. m_lBodyLength = 0;
  376. delete [] m_pResponseBody;
  377. m_pResponseBody = NULL;
  378. m_lResponseBodyLength = 0;
  379. m_dwStatus  = 0;
  380. m_StatusText = _T("");
  381. m_ResponseHeaders = _T("");
  383. if (V_VT(&varBody) == VT_BSTR) {
  384. _bstr_t body = V_BSTR(&varBody);
  385. m_lBodyLength = body.length() + 1;
  386. m_pBody = new BYTE[m_lBodyLength];
  387. memset(m_pBody,0,m_lBodyLength);
  388. memcpy(m_pBody,static_cast<char*> (body),body.length());
  389. }
  390. else
  391. if (V_VT(&varBody) == VT_UNKNOWN) {
  392. CComQIPtr<IStream,&IID_IStream> pS(V_UNKNOWN(&varBody));
  393. if (!pS)
  394. return E_INVALIDARG;
  396. CComBSTR b;
  397. hr = b.ReadFromStream(pS);
  398. if (S_OK != hr)
  399. return hr;
  401. _bstr_t body = b;
  402. m_lBodyLength = body.length() + 1;
  403. m_pBody = new BYTE[m_lBodyLength];
  404. memset(m_pBody,0,m_lBodyLength);
  405. memcpy(m_pBody,static_cast<char*> (body),body.length());
  406. }
  407. else
  408. if (V_VT(&varBody) == VT_DISPATCH) {
  409. CComQIPtr<IXMLDOMDocument,&IID_IXMLDOMDocument> pDoc(V_DISPATCH(&varBody));
  410. if (!pDoc)
  411. return E_INVALIDARG;
  413. BSTR b = NULL;
  414. hr = pDoc->get_xml(&b);
  415. if (S_OK != hr)
  416. return hr;
  418. _bstr_t body = b;
  419. ::SysFreeString(b);
  421. m_lBodyLength = body.length() + 1;
  422. m_pBody = new BYTE[m_lBodyLength];
  423. memset(m_pBody,0,m_lBodyLength);
  424. memcpy(m_pBody,static_cast<char*> (body),body.length());
  425. }
  426. else
  427. if (V_VT(&varBody) == (VT_ARRAY | VT_VARIANT)) {
  428. SAFEARRAY *pArray = reinterpret_cast<SAFEARRAY *> (varBody.byref);
  429. if (NULL == pArray)
  430. return E_INVALIDARG;
  432. long lLBoundVar = 0;
  433. long lUBoundVar = 0;
  435. UINT dims = ::SafeArrayGetDim(pArray);
  436. if (dims == 0)
  437. return E_INVALIDARG;
  439. hr = ::SafeArrayGetLBound(pArray, dims, &lLBoundVar);
  440. if (S_OK != hr)
  441. return hr;
  443. hr = ::SafeArrayGetUBound(pArray, dims, &lUBoundVar);
  444. if (S_OK != hr)
  445. return hr;
  447. if (lUBoundVar >= lLBoundVar) {
  448. VARIANT *pIndex = NULL; 
  449. hr = ::SafeArrayAccessData(pArray, reinterpret_cast<void **> (&pIndex));
  450. if (S_OK != hr)
  451. return hr;
  453. m_lBodyLength = lUBoundVar-lLBoundVar+1;
  454. m_pBody = new BYTE[m_lBodyLength];
  455. for (long i = 0; i <= lUBoundVar-lLBoundVar; ++i) {
  456. VARIANT var = pIndex[i];
  457. if (V_VT(&var) != VT_UI1) {
  458. hr = E_INVALIDARG;
  459. break;
  460. }
  461. m_pBody[i] = V_UI1(&var); 
  462. }
  464. ::SafeArrayUnaccessData(pArray);
  465. if (S_OK != hr) {
  466. delete [] m_pBody;
  467. m_pBody = NULL;
  468. m_lBodyLength = 0;
  469. return hr;
  470. }
  471. }
  472. }
  473. else
  474. if (V_VT(&varBody) == (VT_ARRAY | VT_UI1)) {
  475. SAFEARRAY *pArray = reinterpret_cast<SAFEARRAY *> (varBody.byref);
  476. if (NULL == pArray)
  477. return E_INVALIDARG;
  479. long lLBoundVar = 0;
  480. long lUBoundVar = 0;
  482. UINT dims = ::SafeArrayGetDim(pArray);
  483. if (dims == 0)
  484. return E_INVALIDARG;
  486. hr = ::SafeArrayGetLBound(pArray, dims, &lLBoundVar);
  487. if (S_OK != hr)
  488. return hr;
  490. hr = ::SafeArrayGetUBound(pArray, dims, &lUBoundVar);
  491. if (S_OK != hr)
  492. return hr;
  494. if (lUBoundVar >= lLBoundVar) {
  495. BYTE *pIndex = NULL; 
  496. hr = ::SafeArrayAccessData(pArray, reinterpret_cast<void **> (&pIndex));
  497. if (S_OK != hr)
  498. return hr;
  500. m_lBodyLength = lUBoundVar-lLBoundVar+1;
  501. m_pBody = new BYTE[m_lBodyLength];
  502. for (long i = 0; i <= lUBoundVar-lLBoundVar; ++i)
  503. m_pBody[i] = pIndex[i]; 
  505. ::SafeArrayUnaccessData(pArray);
  506. }
  507. }
  509. m_HwndParent = GetParentWindow();
  511. UINT nthreadID = 0;
  512. m_hThread = reinterpret_cast<HANDLE> (_beginthreadex(NULL,
  513.  0,
  514.      CXMLHttpRequest::SendThread,
  515.  (void *) this, 
  516.  0,
  517.  &nthreadID));
  518. if (NULL == m_hThread) 
  519. return E_FAIL;
  521. if (m_bAsync) 
  522. return S_OK;
  524. bool bWait = true;
  525. while (bWait) {
  526. DWORD dwEvt = MsgWaitForMultipleObjects(1,&m_hThread,FALSE,INFINITE,QS_ALLINPUT);
  527. switch(dwEvt) {
  528. case WAIT_OBJECT_0:
  529. bWait = false;
  530. break;
  531. case WAIT_OBJECT_0 + 1:
  532. {
  533. MSG msg;
  534. while(::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) { 
  535. if (WM_CLOSE == msg.message || WM_QUIT == msg.message) {
  536.  bWait = false;
  537.  m_bAbort = true;
  538.  break;
  539. }
  540. else {
  541. PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
  542. TranslateMessage(&msg);  
  543. DispatchMessage(&msg);
  544. }
  545. }
  546. break;
  547. }
  548. default:
  549. m_bAbort = true;
  550. bWait = false;
  551. break;
  552. }
  553. }
  555. return S_OK;
  556. }
  558. UINT APIENTRY CXMLHttpRequest::SendThread(void *pParm)
  559. {
  560. ATLTRACE(_T("CXMLHttpRequest::SendThreadn"));
  562. CXMLHttpRequest *pCtx = reinterpret_cast<CXMLHttpRequest *> (pParm);
  563. if (NULL == pCtx)
  564. return 0;
  566. HINTERNET hOpen    = NULL;
  567. HINTERNET hConnect = NULL; 
  568. HINTERNET hRequest = NULL; 
  570. hOpen = InternetOpen(_T("XMLHTTP/1.0"),INTERNET_OPEN_TYPE_PRECONFIG,
  571. NULL,NULL,0);
  572. if (NULL == hOpen) {
  573. DWORD res = GetLastError();
  574. pCtx->m_Error = CXMLHttpRequest::GetErrorMsg(res);
  575. pCtx->m_bSuccess = false;
  576. }
  578. if (!pCtx->m_bAbort && pCtx->m_bSuccess) {
  579. if (INTERNET_INVALID_STATUS_CALLBACK == InternetSetStatusCallback(hOpen,
  580. CXMLHttpRequest::InternetStatusCallback)) {
  581. pCtx->m_Error = _T("Invalid Internet Status Callback function.");
  582. pCtx->m_bSuccess = false;
  583. }
  584. }
  586. bool bPromptForAuthentication = true;
  587. if (!pCtx->m_bAbort && pCtx->m_bSuccess) {
  588. LPTSTR lpszUserName = NULL;
  589. LPTSTR lpszPassword = NULL;
  590. if (pCtx->m_User.length() > 0) {
  591. bPromptForAuthentication = false;
  592. lpszUserName = pCtx->m_User; 
  593. if (pCtx->m_Password.length() > 0) 
  594. lpszPassword = pCtx->m_Password;
  595. }    
  596. hConnect = InternetConnect(hOpen,pCtx->m_HostName,pCtx->m_Port,lpszUserName,lpszPassword,
  597. INTERNET_SERVICE_HTTP,0,reinterpret_cast<DWORD> (pCtx));
  598. if (NULL == hConnect) {
  599. DWORD res = GetLastError();
  600. pCtx->m_Error = CXMLHttpRequest::GetErrorMsg(res);
  601. pCtx->m_bSuccess = false;
  602. }
  603. }
  605. if (!pCtx->m_bAbort && pCtx->m_bSuccess) {
  606. DWORD dwFlags = (443 == pCtx->m_Port) ? INTERNET_FLAG_SECURE : 0;
  607. dwFlags |= INTERNET_FLAG_NO_CACHE_WRITE;
  608. hRequest = HttpOpenRequest(hConnect,pCtx->m_Method,
  609. pCtx->m_URLPath,NULL,NULL,NULL,
  610. dwFlags,reinterpret_cast<DWORD> (pCtx));
  611. if (NULL == hRequest) {
  612. DWORD res = GetLastError();
  613. pCtx->m_bSuccess = false;
  614. pCtx->m_Error = CXMLHttpRequest::GetErrorMsg(res);
  615. }
  616. }
  618. BOOL rc = TRUE;
  620. if (!pCtx->m_bAbort && pCtx->m_bSuccess && pCtx->m_RequestHeaderMap.GetSize() > 0) {
  621. _bstr_t requestHeaders;
  622. for (int i = 0 ; i < pCtx->m_RequestHeaderMap.GetSize(); ++i) {
  623. requestHeaders += pCtx->m_RequestHeaderMap.GetKeyAt(i);
  624. requestHeaders += _T(": ");
  625. requestHeaders += pCtx->m_RequestHeaderMap.GetValueAt(i);
  626. requestHeaders += _T("rn");
  627. }
  628. rc = HttpAddRequestHeaders(hRequest,requestHeaders,-1,HTTP_ADDREQ_FLAG_ADD | HTTP_ADDREQ_FLAG_REPLACE);
  629. if (!rc) {
  630. DWORD res = GetLastError();
  631. pCtx->m_bSuccess = false;
  632. pCtx->m_Error = CXMLHttpRequest::GetErrorMsg(res);
  633. }
  634. }
  636. DWORD dwLen = 0;
  637. DWORD dwError = ERROR_SUCCESS; 
  638. do {
  639. if (!pCtx->m_bAbort && pCtx->m_bSuccess) {
  640. rc = HttpSendRequest(hRequest,NULL,0,pCtx->m_pBody,pCtx->m_lBodyLength);
  641. if (!rc) {
  642. DWORD res = GetLastError();
  643. pCtx->m_bSuccess = false;
  644. pCtx->m_Error = CXMLHttpRequest::GetErrorMsg(res);
  645. break;
  646. }
  647. }
  648. if (!pCtx->m_bAbort && pCtx->m_bSuccess) {
  649. dwLen = sizeof(DWORD);
  650. rc = HttpQueryInfo(hRequest,
  651.    HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER,
  652.    &pCtx->m_dwStatus,&dwLen,NULL);
  653. if (!rc) {
  654. DWORD res = GetLastError();
  655. pCtx->m_bSuccess = false;
  656. pCtx->m_Error = CXMLHttpRequest::GetErrorMsg(res);
  657. break;
  658. }
  659. }
  660. if (!pCtx->m_bAbort && pCtx->m_bSuccess &&
  661. bPromptForAuthentication &&
  662. (HTTP_STATUS_PROXY_AUTH_REQ == pCtx->m_dwStatus ||
  663.  HTTP_STATUS_DENIED     == pCtx->m_dwStatus)) 
  664.     dwError = InternetErrorDlg(pCtx->m_HwndParent,
  665.    hRequest,
  666.    ERROR_INTERNET_INCORRECT_PASSWORD,
  667.    FLAGS_ERROR_UI_FILTER_FOR_ERRORS    |
  668.    FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS |
  669.    FLAGS_ERROR_UI_FLAGS_GENERATE_DATA,
  670.    NULL);
  671. else
  672. break;
  674. } while (ERROR_INTERNET_FORCE_RETRY == dwError &&
  675.  !pCtx->m_bAbort && pCtx->m_bSuccess); 
  677. if (!pCtx->m_bAbort && pCtx->m_bSuccess) {
  678. dwLen = 1024;
  679. TCHAR *pBuff = new TCHAR[dwLen];
  680. rc = HttpQueryInfo(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF,pBuff,&dwLen,NULL);
  681. if (!rc) {
  682. DWORD res = GetLastError();
  683. if (ERROR_INSUFFICIENT_BUFFER == res) {
  684. delete [] pBuff;
  685. pBuff = new TCHAR[dwLen];
  686. rc = HttpQueryInfo(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF,pBuff,&dwLen,NULL);
  687. if (!rc) {
  688. res = GetLastError();
  689. pCtx->m_bSuccess = false;
  690. pCtx->m_Error = CXMLHttpRequest::GetErrorMsg(res);
  691. }
  692. }
  693. else {
  694. pCtx->m_bSuccess = false;
  695. pCtx->m_Error = CXMLHttpRequest::GetErrorMsg(res);
  696. }
  697. }
  698. if (rc)
  699.  pCtx->m_ResponseHeaders = pBuff;
  701. delete [] pBuff;
  702. }
  704. if (!pCtx->m_bAbort && pCtx->m_bSuccess) {
  705. dwLen = 1024;
  706. TCHAR *pBuff = new TCHAR[dwLen];
  707. rc = HttpQueryInfo(hRequest,HTTP_QUERY_STATUS_TEXT,pBuff,&dwLen,NULL);
  708. if (!rc) {
  709. DWORD res = GetLastError();
  710. if (ERROR_INSUFFICIENT_BUFFER == res) {
  711. delete [] pBuff;
  712. pBuff = new TCHAR[dwLen];
  713. rc = HttpQueryInfo(hRequest,HTTP_QUERY_STATUS_TEXT,pBuff,&dwLen,NULL);
  714. if (!rc) 
  715. _tcscpy(pBuff,_T("Unknown"));
  716. }
  717. else 
  718. _tcscpy(pBuff,_T("Unknown"));
  719. }
  720. pCtx->m_StatusText = pBuff; 
  721. delete [] pBuff;
  723. if (HTTP_STATUS_OK != pCtx->m_dwStatus) {
  724. TCHAR errBuff[MAX_PATH] = _T("");
  725. wsprintf(errBuff,_T("HTTP Status Code: %d, Reason: "),pCtx->m_dwStatus);
  726. pCtx->m_Error = errBuff;
  727. pCtx->m_Error += pCtx->m_StatusText;
  728. pCtx->m_bSuccess = false;
  729. }
  730. }
  732. if (!pCtx->m_bAbort && pCtx->m_bSuccess) {
  733. PBYTE buffer[255];
  734. DWORD dwRead = 0;
  735. delete [] pCtx->m_pResponseBody;
  736. pCtx->m_pResponseBody = NULL;
  737. pCtx->m_lResponseBodyLength = 0;
  738. while (rc = InternetReadFile(hRequest,buffer,255,&dwRead)) {
  739. if (!rc || pCtx->m_bAbort || 0 == dwRead) 
  740. break;
  742. PBYTE tmp = new BYTE[pCtx->m_lResponseBodyLength + dwRead];
  743. if (pCtx->m_pResponseBody) {
  744. memcpy(tmp,pCtx->m_pResponseBody,pCtx->m_lResponseBodyLength);
  745. delete [] pCtx->m_pResponseBody;
  746. }
  748. memcpy(tmp+pCtx->m_lResponseBodyLength,buffer,dwRead);
  749. pCtx->m_pResponseBody = tmp;
  750. pCtx->m_lResponseBodyLength += dwRead;
  751. }
  752. if (!rc) {
  753. DWORD res = GetLastError();
  754. pCtx->m_Error = _T("Error reading response: ") + CXMLHttpRequest::GetErrorMsg(res);
  755. pCtx->m_bSuccess = false;
  756. }
  757. }
  759. if (hRequest != NULL)
  760. InternetCloseHandle(hRequest);
  762. if (hConnect != NULL) 
  763. InternetCloseHandle(hConnect);
  765. if (hOpen)
  766. InternetCloseHandle(hOpen);
  768. if (!pCtx->m_bAbort && pCtx->m_bAsync)
  769. ::PostMessage(pCtx->m_hWnd,MSG_READY_STATE_CHANGE,4,0); 
  770.   
  771. return 0;
  772. }
  774. HWND CXMLHttpRequest::GetParentWindow()
  775. {
  776. HWND hWnd = GetDesktopWindow();
  778. CComPtr<IServiceProvider> pSP;
  779. HRESULT hr = GetSite(IID_IServiceProvider, reinterpret_cast<LPVOID *> (&pSP));
  780.     if (S_OK != hr)
  781. return hWnd;
  783. CComPtr<IWebBrowser2> pWB;
  784.     hr = pSP->QueryService(SID_SWebBrowserApp,IID_IWebBrowser2,
  785.                                  reinterpret_cast<LPVOID *> (&pWB));
  786. if (S_OK != hr)
  787. return hWnd;
  789. long lWnd = 0;
  790. hr = pWB->get_HWND(&lWnd);
  791. if (S_OK != hr)
  792. return hWnd;
  794. return reinterpret_cast<HWND> (lWnd);
  795. }
  797. void CALLBACK  CXMLHttpRequest::InternetStatusCallback(HINTERNET hInternet,
  798. DWORD dwContext,
  799. DWORD dwInternetStatus,
  800. LPVOID lpvStatusInformation,
  801. DWORD dwStatusInformationLength)
  802. {
  803. ATLTRACE(_T("CXMLHttpRequest::InternetStatusCallback - dwInternetStatus %dn"),dwInternetStatus);
  804. }
  806. STDMETHODIMP CXMLHttpRequest::abort()
  807. {
  808. ATLTRACE(_T("CXMLHttpRequest::abortn"));
  809. m_bAbort = true;
  810. return S_OK;
  811. }
  813. STDMETHODIMP CXMLHttpRequest::get_status(long * plStatus)
  814. {
  815. ATLTRACE(_T("CXMLHttpRequest::get_statusn"));
  817. if (NULL == plStatus)
  818. return E_POINTER;
  820. *plStatus = 0;
  822. // check if there is a send active  
  823. if (NULL != m_hThread) {
  824. DWORD exitCode = 0;
  825. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  826. if (!rc || STILL_ACTIVE == exitCode) 
  827. return E_PENDING;
  829. ::CloseHandle(m_hThread);
  830. m_hThread = NULL;
  831. }
  833. *plStatus = m_dwStatus;
  834. return S_OK;
  835. }
  837. STDMETHODIMP CXMLHttpRequest::get_statusText( BSTR * pbstrStatus)
  838. {
  839. ATLTRACE(_T("CXMLHttpRequest::get_statusTextn"));
  841. if (NULL == pbstrStatus)
  842. return E_POINTER;
  844. *pbstrStatus = NULL;
  846. // check if there is a send active  
  847. if (NULL != m_hThread) {
  848. DWORD exitCode = 0;
  849. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  850. if (!rc || STILL_ACTIVE == exitCode) 
  851. return E_PENDING;
  853. ::CloseHandle(m_hThread);
  854. m_hThread = NULL;
  855. }
  857. *pbstrStatus = m_StatusText.copy();
  858. return S_OK;
  859. }
  861. STDMETHODIMP CXMLHttpRequest::get_responseXML(IDispatch **ppBody)
  862. {
  863. ATLTRACE(_T("CXMLHttpRequest::get_responseXMLn"));
  865. if (NULL == ppBody)
  866. return E_POINTER;
  868. *ppBody = NULL;
  870. // check if there is a send active 
  871. if (NULL != m_hThread) {
  872. DWORD exitCode = 0;
  873. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  874. if (!rc || STILL_ACTIVE == exitCode) 
  875. return E_PENDING;
  877. ::CloseHandle(m_hThread);
  878. m_hThread = NULL;
  879. }
  881. BSTR text = NULL;
  882. HRESULT hr = get_responseText(&text);
  883. if (S_OK != hr || NULL == text)
  884. return hr;
  886. CXMLDOMDocumentObj *pObj = NULL;
  887. hr = CXMLDOMDocumentObj::CreateInstance(&pObj);
  888. if (S_OK == hr) {
  889. pObj->AddRef();
  890. VARIANT_BOOL isSuccessful = VARIANT_FALSE;
  891. hr = pObj->loadXML(text, &isSuccessful);
  892. if (S_OK == hr && VARIANT_TRUE == isSuccessful) {
  893. *ppBody = pObj;
  894. (*ppBody)->AddRef();
  895. }
  896. pObj->Release();
  897. }
  899. ::SysFreeString(text);
  901. return hr;
  902. }
  904. STDMETHODIMP CXMLHttpRequest::get_responseText(BSTR *pVal)
  905. {
  906. ATLTRACE(_T("CXMLHttpRequest::get_responseTextn"));
  908. if (NULL == pVal)
  909. return E_POINTER;
  911. *pVal = NULL;
  913. // check if there is a send active 
  914. if (NULL != m_hThread) {
  915. DWORD exitCode = 0;
  916. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  917. if (!rc || STILL_ACTIVE == exitCode) 
  918. return E_PENDING;
  920. ::CloseHandle(m_hThread);
  921. m_hThread = NULL;
  922. }
  924. if (NULL == m_pResponseBody)
  925. return S_OK;
  927. TCHAR *psz = new TCHAR[m_lResponseBodyLength+1];
  928. ZeroMemory(psz,m_lResponseBodyLength+1);
  929. CopyMemory(psz,m_pResponseBody,m_lResponseBodyLength);
  930.   
  931. *pVal =  SysAllocStringByteLen(psz,m_lResponseBodyLength); 
  932. delete [] psz;
  933.  
  934. return S_OK;
  935. }
  937. STDMETHODIMP CXMLHttpRequest::get_responseBody(VARIANT *pVal)
  938. {
  939. ATLTRACE(_T("CXMLHttpRequest::get_responseBodyn"));
  941. if (NULL == pVal)
  942. return E_POINTER;
  944. ::VariantInit(pVal);
  945. V_VT(pVal) = VT_NULL;
  947. // check if there is a send active 
  948. if (NULL != m_hThread) {
  949. DWORD exitCode = 0;
  950. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  951. if (!rc || STILL_ACTIVE == exitCode) 
  952. return E_PENDING;
  954. ::CloseHandle(m_hThread);
  955. m_hThread = NULL;
  956. }
  958. if (NULL == m_pResponseBody)
  959. return S_OK;
  961. return CXMLHttpRequest::InitializeVarFromByte(*pVal, m_pResponseBody,m_lResponseBodyLength);
  962. }
  964. STDMETHODIMP CXMLHttpRequest::get_responseStream(VARIANT *pVal)
  965. {
  966. ATLTRACE(_T("CXMLHttpRequest::get_responseStreamn"));
  968. if (NULL == pVal)
  969. return E_POINTER;
  971. ::VariantInit(pVal);
  972. V_VT(pVal) = VT_NULL;
  974. // check if there is a send active 
  975. if (NULL != m_hThread) {
  976. DWORD exitCode = 0;
  977. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  978. if (!rc || STILL_ACTIVE == exitCode) 
  979. return E_PENDING;
  981. ::CloseHandle(m_hThread);
  982. m_hThread = NULL;
  983. }
  985. if (NULL == m_pResponseBody)
  986. return S_OK;
  988. //Create an IStream from global memory
  989. CComPtr<IStream> pStm;
  990.     HRESULT hr = CreateStreamOnHGlobal(NULL, TRUE, &pStm);
  991.     if (S_OK != hr) 
  992. return hr;
  994. hr = pStm->Write(m_pResponseBody, m_lResponseBodyLength, NULL);
  995. if (S_OK != hr) 
  996. return hr;
  998. LARGE_INTEGER dlibMove;
  999. memset(&dlibMove,0,sizeof(LARGE_INTEGER));
  1000. hr = pStm->Seek(dlibMove,STREAM_SEEK_SET,NULL);    
  1001. if (S_OK != hr) 
  1002. return hr;
  1004. V_VT(pVal) = VT_UNKNOWN;
  1005. V_UNKNOWN(pVal) = pStm.Detach(); 
  1007. return S_OK;
  1008. }
  1010. STDMETHODIMP CXMLHttpRequest::get_readyState(long *pVal)
  1011. {
  1012. ATLTRACE(_T("CXMLHttpRequest::get_readyStaten"));
  1014. if (NULL == pVal)
  1015. return E_POINTER;
  1017. *pVal = m_lReadyState;
  1019. return S_OK;
  1020. }
  1022. STDMETHODIMP CXMLHttpRequest::put_onreadystatechange(IDispatch * pReadyStateSink)
  1023. {
  1024. ATLTRACE(_T("CXMLHttpRequest::put_onreadystatechangen"));
  1026. if (m_pOnReadyStateChange != NULL) {
  1027. m_pOnReadyStateChange->Release();
  1028. m_pOnReadyStateChange = NULL;
  1029. }
  1030. m_pOnReadyStateChange = pReadyStateSink;
  1031. if (m_pOnReadyStateChange != NULL) 
  1032. m_pOnReadyStateChange->AddRef();
  1034. return S_OK;
  1035. }
  1037. _bstr_t CXMLHttpRequest::GetErrorMsg(DWORD rc)
  1038. {
  1039. _bstr_t msg(_T(""));
  1040. TCHAR *lpBuffer = NULL;
  1042. if (ERROR_INTERNET_EXTENDED_ERROR == rc) {
  1043. DWORD dwError  = 0;
  1044. DWORD dwLength = 0; 
  1045. InternetGetLastResponseInfo (&dwError, NULL, &dwLength);
  1046.         if (dwLength > 0) {
  1047. lpBuffer = (TCHAR *) LocalAlloc(LPTR,dwLength);
  1048. if (!lpBuffer) {
  1049. msg = _T("Unable to allocate memory to display Internet extended error: ");
  1050.                 rc = GetLastError();
  1051.            }
  1052. else {
  1053.                 if (!InternetGetLastResponseInfo(&dwError,lpBuffer,&dwLength)) {
  1054.     msg = _T("Unable to get Internet extended error: ");
  1055.                     rc = GetLastError();
  1056. LocalFree(lpBuffer);
  1057.                 }
  1058. else {
  1059. int len = lstrlen(lpBuffer);
  1060. for (int i=0; i < len; ++i) {
  1061. if (_istcntrl(lpBuffer[i])) 
  1062. lpBuffer[i] = _T(' ');
  1063. }
  1064. msg = lpBuffer;
  1065. LocalFree(lpBuffer);
  1066. return msg;
  1067.   }
  1068. }
  1069. }
  1070.     }
  1072. lpBuffer = NULL;
  1073. HMODULE hModule = NULL; // default to system source
  1074.     
  1075. if (rc >= INTERNET_ERROR_BASE) 
  1076.  hModule = LoadLibraryEx(_T("wininet.dll"),NULL,LOAD_LIBRARY_AS_DATAFILE);
  1077.     
  1078. ::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
  1079. FORMAT_MESSAGE_IGNORE_INSERTS |
  1080. FORMAT_MESSAGE_FROM_SYSTEM |
  1081. ((hModule != NULL) ? FORMAT_MESSAGE_FROM_HMODULE : 0),
  1082. hModule, 
  1083. rc,
  1084. MAKELANGID(LANG_NEUTRAL, SUBLANG_SYS_DEFAULT),
  1085. (LPTSTR)&lpBuffer, 0, NULL);
  1087. if (lpBuffer) {
  1088. int len = lstrlen(lpBuffer);
  1089. for (int i=0; i < len; ++i) {
  1090. if (_istcntrl(lpBuffer[i])) 
  1091. lpBuffer[i] = _T(' ');
  1092. }
  1093. }
  1095. msg += lpBuffer;
  1096. LocalFree(lpBuffer);
  1098. if (hModule != NULL)
  1099.     FreeLibrary(hModule);
  1101. return msg;
  1102. }
  1104. HRESULT CXMLHttpRequest::InitializeVarFromByte(VARIANT &varOut, const PBYTE pByte, long lSize)
  1105. {
  1106. ::VariantInit(&varOut);
  1107. V_VT(&varOut) = VT_NULL;
  1109. HRESULT hr = S_OK;
  1110. SAFEARRAYBOUND rgsabound[1];
  1111. rgsabound[0].cElements = lSize;
  1112. rgsabound[0].lLbound   = 0;
  1114. SAFEARRAY *psa = ::SafeArrayCreate( VT_VARIANT, 1, rgsabound);
  1115. if (psa == NULL)
  1116. return E_FAIL;
  1118. if (pByte != NULL) {
  1119. long ix[1];
  1120. for (ULONG i = 0; i < rgsabound[0].cElements; ++i) {
  1121. ix[0] = i;
  1122. VARIANT var;
  1123. ::VariantInit(&var);
  1124. V_VT(&var)   = VT_UI1;
  1125. V_UI1(&var)  = pByte[i];
  1127. hr = ::SafeArrayPutElement(psa, ix, &var);
  1128. if (S_OK != hr) {
  1129. ::SafeArrayDestroy(psa);
  1130. break;
  1131. }
  1132. }
  1133. }
  1135. if (S_OK == hr) {
  1136. V_VT(&varOut)  = VT_ARRAY | VT_VARIANT;
  1137. V_ARRAY(&varOut) = psa;
  1138. }
  1140. return hr;
  1141. }