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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 词法分析 > 查看源码
XMLHTTPRequest.cpp
资源名称：xerces-c-src_2_3_0.zip　[点击查看]
上传用户：zhuqijet
上传日期：2013-06-25
资源大小：10074k
文件大小：30k
源码类别：

词法分析

开发平台：

Visual 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.1.1.1  2002/02/01 22:21:42  peiyongz
  60.  * sane_include
  61.  *
  62.  * Revision 1.3  2000/06/03 00:29:03  andyh
  63.  * COM Wrapper changes from Curt Arnold
  64.  *
  65.  * Revision 1.2  2000/03/30 02:00:09  abagchi
  66.  * Initial checkin of working code with Copyright Notice
  67.  *
  68.  */
  70. #include "stdafx.h"
  72. #include "xml4com.h"
  73. #include "XMLHttpRequest.h"
  74. #include "XMLDOMDocument.h"
  76. // I need to make sure the file is registered with long filenames
  77. HRESULT WINAPI CXMLHttpRequest::UpdateRegistry(BOOL bRegister)
  78. {
  79. USES_CONVERSION;
  81. TCHAR file[MAX_PATH];
  82. if (::GetModuleFileName(_Module.m_hInst, file, MAX_PATH)) {
  83. WIN32_FIND_DATA d;
  84. memset(&d,0,sizeof(WIN32_FIND_DATA));
  85. HANDLE h = FindFirstFile(file,&d);
  86. if (h != INVALID_HANDLE_VALUE) {
  87. TCHAR  *name = _tcsrchr(file,_T('\'));
  88. TCHAR newFile[MAX_PATH] = _T("");
  89. _tcsncpy(newFile,file,name-file);
  90. _tcscat(newFile,_T("\"));
  91. _tcscat(newFile,d.cFileName);
  92. FindClose(h);
  94. _ATL_REGMAP_ENTRY regmap[2] = {{NULL,NULL},{NULL,NULL}};
  95. regmap[0].szKey  = OLESTR("XMLMODULE");
  96. regmap[0].szData = T2OLE(newFile);
  97. return _Module.UpdateRegistryFromResource((UINT) IDR_XMLHTTPREQUEST, bRegister,regmap);
  98. }
  99. }
  100. return E_FAIL;
  101. }
  103. CXMLHttpRequest::CXMLHttpRequest()
  104. :m_pOnReadyStateChange (NULL)
  105. ,m_bAbort (false)
  106. ,m_hThread (NULL)
  107. ,m_lReadyState (0)
  108. ,m_bAsync (false)
  109. ,m_Method (_T(""))
  110. ,m_HostName (_T(""))
  111. ,m_Port (INTERNET_DEFAULT_HTTP_PORT)
  112. ,m_URLPath (_T(""))
  113. ,m_User (_T(""))
  114. ,m_Password (_T(""))
  115. ,m_dwStatus (0)
  116. ,m_StatusText (_T(""))
  117. ,m_ResponseHeaders (_T(""))
  118. ,m_HwndParent (NULL)
  119. ,m_pBody (NULL)
  120. ,m_lBodyLength (0)
  121. ,m_pResponseBody (NULL)
  122. ,m_lResponseBodyLength (0)
  123. ,m_Error (_T(""))
  124. ,m_bSuccess (true)
  125. {
  126. }
  128. HRESULT CXMLHttpRequest::FinalConstruct()
  129. {
  130. // create monitor window
  131. RECT rc;
  132.     memset(&rc,0,sizeof(RECT));
  133. if (NULL == Create(NULL, rc, _T("XML HTTP Request Monitor Window"), 0))
  134. return E_FAIL;
  136. return S_OK;
  137. }
  139. void CXMLHttpRequest::FinalRelease()
  140. {
  141. if (NULL != m_hThread) {
  142. m_bAbort = true;
  143. ::WaitForSingleObject(m_hThread, INFINITE);
  144. ::CloseHandle(m_hThread);
  145. m_hThread = NULL;
  146. }
  148. if (m_pOnReadyStateChange != NULL) {
  149. m_pOnReadyStateChange->Release();
  150. m_pOnReadyStateChange = NULL;
  151. }
  153. DestroyWindow();
  155. delete [] m_pBody;
  156. m_pBody = NULL;
  157. m_lBodyLength = 0;
  159. delete [] m_pResponseBody;
  160. m_pResponseBody = NULL;
  161. m_lResponseBodyLength = 0;
  162. }
  164. LRESULT CXMLHttpRequest::OnReadyStateChange(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
  165. {
  166. ATLTRACE(_T("CXMLHttpRequest::OnReadyStateChangen"));
  168. bHandled = TRUE;
  170. m_lReadyState = wParam;
  171. if (NULL != m_pOnReadyStateChange) {
  172. CComVariant varResult;
  173. DISPPARAMS disp = { NULL, NULL, 0, 0 };
  174. m_pOnReadyStateChange->Invoke(DISPID_VALUE, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
  175. }
  177. return 1L;
  178. }
  181. STDMETHODIMP CXMLHttpRequest::InterfaceSupportsErrorInfo(REFIID riid)
  182. {
  183. if (IsEqualGUID(IID_IXMLHttpRequest,riid))
  184. return S_OK;
  185. return S_FALSE;
  186. }
  188. STDMETHODIMP CXMLHttpRequest::open(BSTR bstrMethod, BSTR bstrUrl,VARIANT varAsync,VARIANT bstrUser,VARIANT bstrPassword)
  189. {
  190. ATLTRACE(_T("CXMLHttpRequest::openn"));
  192. // do not open if there is a send active  
  193. if (NULL != m_hThread) {
  194. DWORD exitCode = 0;
  195. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  196. if (!rc || STILL_ACTIVE == exitCode) 
  197. return E_FAIL;
  199. ::CloseHandle(m_hThread);
  200. m_hThread = NULL;
  201. }
  203. if (V_VT(&varAsync) != VT_BOOL)
  204. return E_INVALIDARG;
  206. _bstr_t method = bstrMethod;
  207. if (0 == method.length())
  208. return E_INVALIDARG;
  210. _bstr_t url = bstrUrl;
  211. if (0 == url.length())
  212. return E_INVALIDARG;
  214. TCHAR hostName[INTERNET_MAX_PATH_LENGTH] = _T("");
  215. TCHAR strPathName[INTERNET_MAX_PATH_LENGTH] = _T("");
  216. URL_COMPONENTS urlComponents;
  217. memset(&urlComponents, 0, sizeof(URL_COMPONENTS)); 
  218. urlComponents.dwStructSize = sizeof(URL_COMPONENTS);
  219. urlComponents.lpszHostName = hostName;
  220. urlComponents.dwHostNameLength = INTERNET_MAX_PATH_LENGTH;
  221. urlComponents.lpszUrlPath   = strPathName;
  222. urlComponents.dwUrlPathLength = INTERNET_MAX_PATH_LENGTH;
  224. if (!InternetCrackUrl(url, url.length(), 0, &urlComponents)) 
  225. return E_INVALIDARG;
  227. m_Method = method;
  228. m_HostName = hostName;
  229. if (urlComponents.nPort != 0)
  230. m_Port = urlComponents.nPort; 
  232. m_URLPath = strPathName;
  233. m_bAsync = (VARIANT_TRUE == V_BOOL(&varAsync)) ? true : false; 
  234. if (VT_BSTR == V_VT(&bstrUser))
  235. m_User = V_BSTR(&bstrUser);
  236. else
  237. m_User = _T("");
  239. if (VT_BSTR == V_VT(&bstrPassword) && m_User.length() > 0)
  240. m_Password = V_BSTR(&bstrPassword);
  241. else
  242. m_Password = _T(""); 
  244. return S_OK;
  245. }
  247. STDMETHODIMP CXMLHttpRequest::setRequestHeader(BSTR bstrHeader,  BSTR bstrValue)
  248. {
  249. ATLTRACE(_T("CXMLHttpRequest::setRequestHeadern"));
  251. if (NULL == bstrHeader || NULL == bstrValue)
  252. return E_INVALIDARG;
  254. // check if there is a send active  
  255. if (NULL != m_hThread) {
  256. DWORD exitCode = 0;
  257. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  258. if (!rc || STILL_ACTIVE == exitCode) 
  259. return E_PENDING;
  261. ::CloseHandle(m_hThread);
  262. m_hThread = NULL;
  263. }
  265. m_RequestHeaderMap.Remove(bstrHeader);
  266. m_RequestHeaderMap.Add(bstrHeader,bstrValue);
  267. return S_OK;
  268. }
  270. STDMETHODIMP CXMLHttpRequest::getResponseHeader(BSTR bstrHeader, BSTR * pbstrValue)
  271. {
  272. ATLTRACE(_T("CXMLHttpRequest::getResponseHeadern"));
  274. if (NULL == pbstrValue)
  275. return E_POINTER;
  277. *pbstrValue = NULL;
  279. if (NULL == bstrHeader)
  280. return E_INVALIDARG;
  282. // check if there is a send active  
  283. if (NULL != m_hThread) {
  284. DWORD exitCode = 0;
  285. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  286. if (!rc || STILL_ACTIVE == exitCode) 
  287. return E_PENDING;
  289. ::CloseHandle(m_hThread);
  290. m_hThread = NULL;
  291. }
  293. if (0 == m_ResponseHeaders.length())
  294. return S_FALSE;
  296. _bstr_t value;
  297. _bstr_t header(bstrHeader);
  298. header += _T(": ");
  299. _tcslwr(header);
  300. TCHAR *pHeaders = new TCHAR[m_ResponseHeaders.length() + sizeof(TCHAR)];
  301. _tcscpy(pHeaders,m_ResponseHeaders);
  302. _tcslwr(pHeaders);
  303. TCHAR *pStart = _tcsstr(pHeaders,header);
  304. if (pStart) {
  305. pStart += header.length();
  306. TCHAR *pEnd = _tcsstr(pStart,_T("rn"));
  307. if (pEnd) {
  308. TCHAR *pHeader = new TCHAR[pEnd-pStart + sizeof(TCHAR)];
  309. _tcsncpy(pHeader,static_cast<LPCTSTR> (m_ResponseHeaders) + (pStart-pHeaders),pEnd-pStart);
  310. value = pHeader;
  311. delete [] pHeader;
  312. }
  313. }
  314. delete[] pHeaders;
  316. if (0 == value.length())
  317. return S_FALSE;
  319. *pbstrValue = value.copy();
  321. return S_OK;
  322. }
  324. STDMETHODIMP CXMLHttpRequest::getAllResponseHeaders(BSTR * pbstrHeaders)
  325. {
  326. ATLTRACE(_T("CXMLHttpRequest::getAllResponseHeadersn"));
  328. if (NULL == pbstrHeaders)
  329. return E_POINTER;
  331. *pbstrHeaders = NULL;
  333. if (NULL == pbstrHeaders)
  334. return E_INVALIDARG;
  336. // check if there is a send active  
  337. if (NULL != m_hThread) {
  338. DWORD exitCode = 0;
  339. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  340. if (!rc || STILL_ACTIVE == exitCode) 
  341. return E_PENDING;
  343. ::CloseHandle(m_hThread);
  344. m_hThread = NULL;
  345. }
  347. *pbstrHeaders = m_ResponseHeaders.copy();
  348. return S_OK;
  349. }
  351. STDMETHODIMP CXMLHttpRequest::send(VARIANT varBody)
  352. {
  353. ATLTRACE(_T("CXMLHttpRequest::sendn"));
  355. if (V_VT(&varBody) != VT_BSTR && 
  356. V_VT(&varBody) != VT_DISPATCH &&
  357. V_VT(&varBody) != (VT_ARRAY | VT_VARIANT) &&
  358. V_VT(&varBody) != (VT_ARRAY | VT_UI1) &&
  359. V_VT(&varBody) != VT_UNKNOWN)
  360. return E_INVALIDARG;
  362. // do not start another thread if there is another active  
  363. if (NULL != m_hThread) {
  364. DWORD exitCode = 0;
  365. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  366. if (!rc || STILL_ACTIVE == exitCode) 
  367. return E_PENDING;
  369. ::CloseHandle(m_hThread);
  370. m_hThread = NULL;
  371. }
  373. HRESULT hr = S_OK;
  374. m_bSuccess = true;
  375. m_bAbort = false;
  376. delete [] m_pBody;
  377. m_pBody = NULL;
  378. m_lBodyLength = 0;
  379. delete [] m_pResponseBody;
  380. m_pResponseBody = NULL;
  381. m_lResponseBodyLength = 0;
  382. m_dwStatus  = 0;
  383. m_StatusText = _T("");
  384. m_ResponseHeaders = _T("");
  386. if (V_VT(&varBody) == VT_BSTR) {
  387. _bstr_t body = V_BSTR(&varBody);
  388. m_lBodyLength = body.length() + 1;
  389. m_pBody = new BYTE[m_lBodyLength];
  390. memset(m_pBody,0,m_lBodyLength);
  391. memcpy(m_pBody,static_cast<char*> (body),body.length());
  392. }
  393. else
  394. if (V_VT(&varBody) == VT_UNKNOWN) {
  395. CComQIPtr<IStream,&IID_IStream> pS(V_UNKNOWN(&varBody));
  396. if (!pS)
  397. return E_INVALIDARG;
  399. CComBSTR b;
  400. hr = b.ReadFromStream(pS);
  401. if (S_OK != hr)
  402. return hr;
  404. _bstr_t body = b;
  405. m_lBodyLength = body.length() + 1;
  406. m_pBody = new BYTE[m_lBodyLength];
  407. memset(m_pBody,0,m_lBodyLength);
  408. memcpy(m_pBody,static_cast<char*> (body),body.length());
  409. }
  410. else
  411. if (V_VT(&varBody) == VT_DISPATCH) {
  412. CComQIPtr<IXMLDOMDocument,&IID_IXMLDOMDocument> pDoc(V_DISPATCH(&varBody));
  413. if (!pDoc)
  414. return E_INVALIDARG;
  416. BSTR b = NULL;
  417. hr = pDoc->get_xml(&b);
  418. if (S_OK != hr)
  419. return hr;
  421. _bstr_t body = b;
  422. ::SysFreeString(b);
  424. m_lBodyLength = body.length() + 1;
  425. m_pBody = new BYTE[m_lBodyLength];
  426. memset(m_pBody,0,m_lBodyLength);
  427. memcpy(m_pBody,static_cast<char*> (body),body.length());
  428. }
  429. else
  430. if (V_VT(&varBody) == (VT_ARRAY | VT_VARIANT)) {
  431. SAFEARRAY *pArray = reinterpret_cast<SAFEARRAY *> (varBody.byref);
  432. if (NULL == pArray)
  433. return E_INVALIDARG;
  435. long lLBoundVar = 0;
  436. long lUBoundVar = 0;
  438. UINT dims = ::SafeArrayGetDim(pArray);
  439. if (dims == 0)
  440. return E_INVALIDARG;
  442. hr = ::SafeArrayGetLBound(pArray, dims, &lLBoundVar);
  443. if (S_OK != hr)
  444. return hr;
  446. hr = ::SafeArrayGetUBound(pArray, dims, &lUBoundVar);
  447. if (S_OK != hr)
  448. return hr;
  450. if (lUBoundVar >= lLBoundVar) {
  451. VARIANT *pIndex = NULL; 
  452. hr = ::SafeArrayAccessData(pArray, reinterpret_cast<void **> (&pIndex));
  453. if (S_OK != hr)
  454. return hr;
  456. m_lBodyLength = lUBoundVar-lLBoundVar+1;
  457. m_pBody = new BYTE[m_lBodyLength];
  458. for (long i = 0; i <= lUBoundVar-lLBoundVar; ++i) {
  459. VARIANT var = pIndex[i];
  460. if (V_VT(&var) != VT_UI1) {
  461. hr = E_INVALIDARG;
  462. break;
  463. }
  464. m_pBody[i] = V_UI1(&var); 
  465. }
  467. ::SafeArrayUnaccessData(pArray);
  468. if (S_OK != hr) {
  469. delete [] m_pBody;
  470. m_pBody = NULL;
  471. m_lBodyLength = 0;
  472. return hr;
  473. }
  474. }
  475. }
  476. else
  477. if (V_VT(&varBody) == (VT_ARRAY | VT_UI1)) {
  478. SAFEARRAY *pArray = reinterpret_cast<SAFEARRAY *> (varBody.byref);
  479. if (NULL == pArray)
  480. return E_INVALIDARG;
  482. long lLBoundVar = 0;
  483. long lUBoundVar = 0;
  485. UINT dims = ::SafeArrayGetDim(pArray);
  486. if (dims == 0)
  487. return E_INVALIDARG;
  489. hr = ::SafeArrayGetLBound(pArray, dims, &lLBoundVar);
  490. if (S_OK != hr)
  491. return hr;
  493. hr = ::SafeArrayGetUBound(pArray, dims, &lUBoundVar);
  494. if (S_OK != hr)
  495. return hr;
  497. if (lUBoundVar >= lLBoundVar) {
  498. BYTE *pIndex = NULL; 
  499. hr = ::SafeArrayAccessData(pArray, reinterpret_cast<void **> (&pIndex));
  500. if (S_OK != hr)
  501. return hr;
  503. m_lBodyLength = lUBoundVar-lLBoundVar+1;
  504. m_pBody = new BYTE[m_lBodyLength];
  505. for (long i = 0; i <= lUBoundVar-lLBoundVar; ++i)
  506. m_pBody[i] = pIndex[i]; 
  508. ::SafeArrayUnaccessData(pArray);
  509. }
  510. }
  512. m_HwndParent = GetParentWindow();
  514. UINT nthreadID = 0;
  515. m_hThread = reinterpret_cast<HANDLE> (_beginthreadex(NULL,
  516.  0,
  517.      CXMLHttpRequest::SendThread,
  518.  (void *) this, 
  519.  0,
  520.  &nthreadID));
  521. if (NULL == m_hThread) 
  522. return E_FAIL;
  524. if (m_bAsync) 
  525. return S_OK;
  527. bool bWait = true;
  528. while (bWait) {
  529. DWORD dwEvt = MsgWaitForMultipleObjects(1,&m_hThread,FALSE,INFINITE,QS_ALLINPUT);
  530. switch(dwEvt) {
  531. case WAIT_OBJECT_0:
  532. bWait = false;
  533. break;
  534. case WAIT_OBJECT_0 + 1:
  535. {
  536. MSG msg;
  537. while(::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) { 
  538. if (WM_CLOSE == msg.message || WM_QUIT == msg.message) {
  539.  bWait = false;
  540.  m_bAbort = true;
  541.  break;
  542. }
  543. else {
  544. PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
  545. TranslateMessage(&msg);  
  546. DispatchMessage(&msg);
  547. }
  548. }
  549. break;
  550. }
  551. default:
  552. m_bAbort = true;
  553. bWait = false;
  554. break;
  555. }
  556. }
  558. return S_OK;
  559. }
  561. UINT APIENTRY CXMLHttpRequest::SendThread(void *pParm)
  562. {
  563. ATLTRACE(_T("CXMLHttpRequest::SendThreadn"));
  565. CXMLHttpRequest *pCtx = reinterpret_cast<CXMLHttpRequest *> (pParm);
  566. if (NULL == pCtx)
  567. return 0;
  569. HINTERNET hOpen    = NULL;
  570. HINTERNET hConnect = NULL; 
  571. HINTERNET hRequest = NULL; 
  573. hOpen = InternetOpen(_T("XMLHTTP/1.0"),INTERNET_OPEN_TYPE_PRECONFIG,
  574. NULL,NULL,0);
  575. if (NULL == hOpen) {
  576. DWORD res = GetLastError();
  577. pCtx->m_Error = CXMLHttpRequest::GetErrorMsg(res);
  578. pCtx->m_bSuccess = false;
  579. }
  581. if (!pCtx->m_bAbort && pCtx->m_bSuccess) {
  582. if (INTERNET_INVALID_STATUS_CALLBACK == InternetSetStatusCallback(hOpen,
  583. CXMLHttpRequest::InternetStatusCallback)) {
  584. pCtx->m_Error = _T("Invalid Internet Status Callback function.");
  585. pCtx->m_bSuccess = false;
  586. }
  587. }
  589. bool bPromptForAuthentication = true;
  590. if (!pCtx->m_bAbort && pCtx->m_bSuccess) {
  591. LPTSTR lpszUserName = NULL;
  592. LPTSTR lpszPassword = NULL;
  593. if (pCtx->m_User.length() > 0) {
  594. bPromptForAuthentication = false;
  595. lpszUserName = pCtx->m_User; 
  596. if (pCtx->m_Password.length() > 0) 
  597. lpszPassword = pCtx->m_Password;
  598. }    
  599. hConnect = InternetConnect(hOpen,pCtx->m_HostName,pCtx->m_Port,lpszUserName,lpszPassword,
  600. INTERNET_SERVICE_HTTP,0,reinterpret_cast<DWORD> (pCtx));
  601. if (NULL == hConnect) {
  602. DWORD res = GetLastError();
  603. pCtx->m_Error = CXMLHttpRequest::GetErrorMsg(res);
  604. pCtx->m_bSuccess = false;
  605. }
  606. }
  608. if (!pCtx->m_bAbort && pCtx->m_bSuccess) {
  609. DWORD dwFlags = (443 == pCtx->m_Port) ? INTERNET_FLAG_SECURE : 0;
  610. dwFlags |= INTERNET_FLAG_NO_CACHE_WRITE;
  611. hRequest = HttpOpenRequest(hConnect,pCtx->m_Method,
  612. pCtx->m_URLPath,NULL,NULL,NULL,
  613. dwFlags,reinterpret_cast<DWORD> (pCtx));
  614. if (NULL == hRequest) {
  615. DWORD res = GetLastError();
  616. pCtx->m_bSuccess = false;
  617. pCtx->m_Error = CXMLHttpRequest::GetErrorMsg(res);
  618. }
  619. }
  621. BOOL rc = TRUE;
  623. if (!pCtx->m_bAbort && pCtx->m_bSuccess && pCtx->m_RequestHeaderMap.GetSize() > 0) {
  624. _bstr_t requestHeaders;
  625. for (int i = 0 ; i < pCtx->m_RequestHeaderMap.GetSize(); ++i) {
  626. requestHeaders += pCtx->m_RequestHeaderMap.GetKeyAt(i);
  627. requestHeaders += _T(": ");
  628. requestHeaders += pCtx->m_RequestHeaderMap.GetValueAt(i);
  629. requestHeaders += _T("rn");
  630. }
  631. rc = HttpAddRequestHeaders(hRequest,requestHeaders,-1,HTTP_ADDREQ_FLAG_ADD | HTTP_ADDREQ_FLAG_REPLACE);
  632. if (!rc) {
  633. DWORD res = GetLastError();
  634. pCtx->m_bSuccess = false;
  635. pCtx->m_Error = CXMLHttpRequest::GetErrorMsg(res);
  636. }
  637. }
  639. DWORD dwLen = 0;
  640. DWORD dwError = ERROR_SUCCESS; 
  641. do {
  642. if (!pCtx->m_bAbort && pCtx->m_bSuccess) {
  643. rc = HttpSendRequest(hRequest,NULL,0,pCtx->m_pBody,pCtx->m_lBodyLength);
  644. if (!rc) {
  645. DWORD res = GetLastError();
  646. pCtx->m_bSuccess = false;
  647. pCtx->m_Error = CXMLHttpRequest::GetErrorMsg(res);
  648. break;
  649. }
  650. }
  651. if (!pCtx->m_bAbort && pCtx->m_bSuccess) {
  652. dwLen = sizeof(DWORD);
  653. rc = HttpQueryInfo(hRequest,
  654.    HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER,
  655.    &pCtx->m_dwStatus,&dwLen,NULL);
  656. if (!rc) {
  657. DWORD res = GetLastError();
  658. pCtx->m_bSuccess = false;
  659. pCtx->m_Error = CXMLHttpRequest::GetErrorMsg(res);
  660. break;
  661. }
  662. }
  663. if (!pCtx->m_bAbort && pCtx->m_bSuccess &&
  664. bPromptForAuthentication &&
  665. (HTTP_STATUS_PROXY_AUTH_REQ == pCtx->m_dwStatus ||
  666.  HTTP_STATUS_DENIED     == pCtx->m_dwStatus)) 
  667.     dwError = InternetErrorDlg(pCtx->m_HwndParent,
  668.    hRequest,
  669.    ERROR_INTERNET_INCORRECT_PASSWORD,
  670.    FLAGS_ERROR_UI_FILTER_FOR_ERRORS    |
  671.    FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS |
  672.    FLAGS_ERROR_UI_FLAGS_GENERATE_DATA,
  673.    NULL);
  674. else
  675. break;
  677. } while (ERROR_INTERNET_FORCE_RETRY == dwError &&
  678.  !pCtx->m_bAbort && pCtx->m_bSuccess); 
  680. if (!pCtx->m_bAbort && pCtx->m_bSuccess) {
  681. dwLen = 1024;
  682. TCHAR *pBuff = new TCHAR[dwLen];
  683. rc = HttpQueryInfo(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF,pBuff,&dwLen,NULL);
  684. if (!rc) {
  685. DWORD res = GetLastError();
  686. if (ERROR_INSUFFICIENT_BUFFER == res) {
  687. delete [] pBuff;
  688. pBuff = new TCHAR[dwLen];
  689. rc = HttpQueryInfo(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF,pBuff,&dwLen,NULL);
  690. if (!rc) {
  691. res = GetLastError();
  692. pCtx->m_bSuccess = false;
  693. pCtx->m_Error = CXMLHttpRequest::GetErrorMsg(res);
  694. }
  695. }
  696. else {
  697. pCtx->m_bSuccess = false;
  698. pCtx->m_Error = CXMLHttpRequest::GetErrorMsg(res);
  699. }
  700. }
  701. if (rc)
  702.  pCtx->m_ResponseHeaders = pBuff;
  704. delete [] pBuff;
  705. }
  707. if (!pCtx->m_bAbort && pCtx->m_bSuccess) {
  708. dwLen = 1024;
  709. TCHAR *pBuff = new TCHAR[dwLen];
  710. rc = HttpQueryInfo(hRequest,HTTP_QUERY_STATUS_TEXT,pBuff,&dwLen,NULL);
  711. if (!rc) {
  712. DWORD res = GetLastError();
  713. if (ERROR_INSUFFICIENT_BUFFER == res) {
  714. delete [] pBuff;
  715. pBuff = new TCHAR[dwLen];
  716. rc = HttpQueryInfo(hRequest,HTTP_QUERY_STATUS_TEXT,pBuff,&dwLen,NULL);
  717. if (!rc) 
  718. _tcscpy(pBuff,_T("Unknown"));
  719. }
  720. else 
  721. _tcscpy(pBuff,_T("Unknown"));
  722. }
  723. pCtx->m_StatusText = pBuff; 
  724. delete [] pBuff;
  726. if (HTTP_STATUS_OK != pCtx->m_dwStatus) {
  727. TCHAR errBuff[MAX_PATH] = _T("");
  728. wsprintf(errBuff,_T("HTTP Status Code: %d, Reason: "),pCtx->m_dwStatus);
  729. pCtx->m_Error = errBuff;
  730. pCtx->m_Error += pCtx->m_StatusText;
  731. pCtx->m_bSuccess = false;
  732. }
  733. }
  735. if (!pCtx->m_bAbort && pCtx->m_bSuccess) {
  736. PBYTE buffer[255];
  737. DWORD dwRead = 0;
  738. delete [] pCtx->m_pResponseBody;
  739. pCtx->m_pResponseBody = NULL;
  740. pCtx->m_lResponseBodyLength = 0;
  741. while (rc = InternetReadFile(hRequest,buffer,255,&dwRead)) {
  742. if (!rc || pCtx->m_bAbort || 0 == dwRead) 
  743. break;
  745. PBYTE tmp = new BYTE[pCtx->m_lResponseBodyLength + dwRead];
  746. if (pCtx->m_pResponseBody) {
  747. memcpy(tmp,pCtx->m_pResponseBody,pCtx->m_lResponseBodyLength);
  748. delete [] pCtx->m_pResponseBody;
  749. }
  751. memcpy(tmp+pCtx->m_lResponseBodyLength,buffer,dwRead);
  752. pCtx->m_pResponseBody = tmp;
  753. pCtx->m_lResponseBodyLength += dwRead;
  754. }
  755. if (!rc) {
  756. DWORD res = GetLastError();
  757. pCtx->m_Error = _T("Error reading response: ") + CXMLHttpRequest::GetErrorMsg(res);
  758. pCtx->m_bSuccess = false;
  759. }
  760. }
  762. if (hRequest != NULL)
  763. InternetCloseHandle(hRequest);
  765. if (hConnect != NULL) 
  766. InternetCloseHandle(hConnect);
  768. if (hOpen)
  769. InternetCloseHandle(hOpen);
  771. if (!pCtx->m_bAbort && pCtx->m_bAsync)
  772. ::PostMessage(pCtx->m_hWnd,MSG_READY_STATE_CHANGE,4,0); 
  773.   
  774. return 0;
  775. }
  777. HWND CXMLHttpRequest::GetParentWindow()
  778. {
  779. HWND hWnd = GetDesktopWindow();
  781. CComPtr<IServiceProvider> pSP;
  782. HRESULT hr = GetSite(IID_IServiceProvider, reinterpret_cast<LPVOID *> (&pSP));
  783.     if (S_OK != hr)
  784. return hWnd;
  786. CComPtr<IWebBrowser2> pWB;
  787.     hr = pSP->QueryService(SID_SWebBrowserApp,IID_IWebBrowser2,
  788.                                  reinterpret_cast<LPVOID *> (&pWB));
  789. if (S_OK != hr)
  790. return hWnd;
  792. long lWnd = 0;
  793. hr = pWB->get_HWND(&lWnd);
  794. if (S_OK != hr)
  795. return hWnd;
  797. return reinterpret_cast<HWND> (lWnd);
  798. }
  800. void CALLBACK  CXMLHttpRequest::InternetStatusCallback(HINTERNET hInternet,
  801. DWORD dwContext,
  802. DWORD dwInternetStatus,
  803. LPVOID lpvStatusInformation,
  804. DWORD dwStatusInformationLength)
  805. {
  806. ATLTRACE(_T("CXMLHttpRequest::InternetStatusCallback - dwInternetStatus %dn"),dwInternetStatus);
  807. }
  809. STDMETHODIMP CXMLHttpRequest::abort()
  810. {
  811. ATLTRACE(_T("CXMLHttpRequest::abortn"));
  812. m_bAbort = true;
  813. return S_OK;
  814. }
  816. STDMETHODIMP CXMLHttpRequest::get_status(long * plStatus)
  817. {
  818. ATLTRACE(_T("CXMLHttpRequest::get_statusn"));
  820. if (NULL == plStatus)
  821. return E_POINTER;
  823. *plStatus = 0;
  825. // check if there is a send active  
  826. if (NULL != m_hThread) {
  827. DWORD exitCode = 0;
  828. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  829. if (!rc || STILL_ACTIVE == exitCode) 
  830. return E_PENDING;
  832. ::CloseHandle(m_hThread);
  833. m_hThread = NULL;
  834. }
  836. *plStatus = m_dwStatus;
  837. return S_OK;
  838. }
  840. STDMETHODIMP CXMLHttpRequest::get_statusText( BSTR * pbstrStatus)
  841. {
  842. ATLTRACE(_T("CXMLHttpRequest::get_statusTextn"));
  844. if (NULL == pbstrStatus)
  845. return E_POINTER;
  847. *pbstrStatus = NULL;
  849. // check if there is a send active  
  850. if (NULL != m_hThread) {
  851. DWORD exitCode = 0;
  852. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  853. if (!rc || STILL_ACTIVE == exitCode) 
  854. return E_PENDING;
  856. ::CloseHandle(m_hThread);
  857. m_hThread = NULL;
  858. }
  860. *pbstrStatus = m_StatusText.copy();
  861. return S_OK;
  862. }
  864. STDMETHODIMP CXMLHttpRequest::get_responseXML(IDispatch **ppBody)
  865. {
  866. ATLTRACE(_T("CXMLHttpRequest::get_responseXMLn"));
  868. if (NULL == ppBody)
  869. return E_POINTER;
  871. *ppBody = NULL;
  873. // check if there is a send active 
  874. if (NULL != m_hThread) {
  875. DWORD exitCode = 0;
  876. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  877. if (!rc || STILL_ACTIVE == exitCode) 
  878. return E_PENDING;
  880. ::CloseHandle(m_hThread);
  881. m_hThread = NULL;
  882. }
  884. BSTR text = NULL;
  885. HRESULT hr = get_responseText(&text);
  886. if (S_OK != hr || NULL == text)
  887. return hr;
  889. CXMLDOMDocumentObj *pObj = NULL;
  890. hr = CXMLDOMDocumentObj::CreateInstance(&pObj);
  891. if (S_OK == hr) {
  892. pObj->AddRef();
  893. VARIANT_BOOL isSuccessful = VARIANT_FALSE;
  894. hr = pObj->loadXML(text, &isSuccessful);
  895. if (S_OK == hr && VARIANT_TRUE == isSuccessful) {
  896. *ppBody = pObj;
  897. (*ppBody)->AddRef();
  898. }
  899. pObj->Release();
  900. }
  902. ::SysFreeString(text);
  904. return hr;
  905. }
  907. STDMETHODIMP CXMLHttpRequest::get_responseText(BSTR *pVal)
  908. {
  909. ATLTRACE(_T("CXMLHttpRequest::get_responseTextn"));
  911. if (NULL == pVal)
  912. return E_POINTER;
  914. *pVal = NULL;
  916. // check if there is a send active 
  917. if (NULL != m_hThread) {
  918. DWORD exitCode = 0;
  919. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  920. if (!rc || STILL_ACTIVE == exitCode) 
  921. return E_PENDING;
  923. ::CloseHandle(m_hThread);
  924. m_hThread = NULL;
  925. }
  927. if (NULL == m_pResponseBody)
  928. return S_OK;
  930. TCHAR *psz = new TCHAR[m_lResponseBodyLength+1];
  931. ZeroMemory(psz,m_lResponseBodyLength+1);
  932. CopyMemory(psz,m_pResponseBody,m_lResponseBodyLength);
  933.   
  934. *pVal =  SysAllocStringByteLen(psz,m_lResponseBodyLength); 
  935. delete [] psz;
  936.  
  937. return S_OK;
  938. }
  940. STDMETHODIMP CXMLHttpRequest::get_responseBody(VARIANT *pVal)
  941. {
  942. ATLTRACE(_T("CXMLHttpRequest::get_responseBodyn"));
  944. if (NULL == pVal)
  945. return E_POINTER;
  947. ::VariantInit(pVal);
  948. V_VT(pVal) = VT_NULL;
  950. // check if there is a send active 
  951. if (NULL != m_hThread) {
  952. DWORD exitCode = 0;
  953. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  954. if (!rc || STILL_ACTIVE == exitCode) 
  955. return E_PENDING;
  957. ::CloseHandle(m_hThread);
  958. m_hThread = NULL;
  959. }
  961. if (NULL == m_pResponseBody)
  962. return S_OK;
  964. return CXMLHttpRequest::InitializeVarFromByte(*pVal, m_pResponseBody,m_lResponseBodyLength);
  965. }
  967. STDMETHODIMP CXMLHttpRequest::get_responseStream(VARIANT *pVal)
  968. {
  969. ATLTRACE(_T("CXMLHttpRequest::get_responseStreamn"));
  971. if (NULL == pVal)
  972. return E_POINTER;
  974. ::VariantInit(pVal);
  975. V_VT(pVal) = VT_NULL;
  977. // check if there is a send active 
  978. if (NULL != m_hThread) {
  979. DWORD exitCode = 0;
  980. BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
  981. if (!rc || STILL_ACTIVE == exitCode) 
  982. return E_PENDING;
  984. ::CloseHandle(m_hThread);
  985. m_hThread = NULL;
  986. }
  988. if (NULL == m_pResponseBody)
  989. return S_OK;
  991. //Create an IStream from global memory
  992. CComPtr<IStream> pStm;
  993.     HRESULT hr = CreateStreamOnHGlobal(NULL, TRUE, &pStm);
  994.     if (S_OK != hr) 
  995. return hr;
  997. hr = pStm->Write(m_pResponseBody, m_lResponseBodyLength, NULL);
  998. if (S_OK != hr) 
  999. return hr;
  1001. LARGE_INTEGER dlibMove;
  1002. memset(&dlibMove,0,sizeof(LARGE_INTEGER));
  1003. hr = pStm->Seek(dlibMove,STREAM_SEEK_SET,NULL);    
  1004. if (S_OK != hr) 
  1005. return hr;
  1007. V_VT(pVal) = VT_UNKNOWN;
  1008. V_UNKNOWN(pVal) = pStm.Detach(); 
  1010. return S_OK;
  1011. }
  1013. STDMETHODIMP CXMLHttpRequest::get_readyState(long *pVal)
  1014. {
  1015. ATLTRACE(_T("CXMLHttpRequest::get_readyStaten"));
  1017. if (NULL == pVal)
  1018. return E_POINTER;
  1020. *pVal = m_lReadyState;
  1022. return S_OK;
  1023. }
  1025. STDMETHODIMP CXMLHttpRequest::put_onreadystatechange(IDispatch * pReadyStateSink)
  1026. {
  1027. ATLTRACE(_T("CXMLHttpRequest::put_onreadystatechangen"));
  1029. if (m_pOnReadyStateChange != NULL) {
  1030. m_pOnReadyStateChange->Release();
  1031. m_pOnReadyStateChange = NULL;
  1032. }
  1033. m_pOnReadyStateChange = pReadyStateSink;
  1034. if (m_pOnReadyStateChange != NULL) 
  1035. m_pOnReadyStateChange->AddRef();
  1037. return S_OK;
  1038. }
  1040. _bstr_t CXMLHttpRequest::GetErrorMsg(DWORD rc)
  1041. {
  1042. _bstr_t msg(_T(""));
  1043. TCHAR *lpBuffer = NULL;
  1045. if (ERROR_INTERNET_EXTENDED_ERROR == rc) {
  1046. DWORD dwError  = 0;
  1047. DWORD dwLength = 0; 
  1048. InternetGetLastResponseInfo (&dwError, NULL, &dwLength);
  1049.         if (dwLength > 0) {
  1050. lpBuffer = (TCHAR *) LocalAlloc(LPTR,dwLength);
  1051. if (!lpBuffer) {
  1052. msg = _T("Unable to allocate memory to display Internet extended error: ");
  1053.                 rc = GetLastError();
  1054.            }
  1055. else {
  1056.                 if (!InternetGetLastResponseInfo(&dwError,lpBuffer,&dwLength)) {
  1057.     msg = _T("Unable to get Internet extended error: ");
  1058.                     rc = GetLastError();
  1059. LocalFree(lpBuffer);
  1060.                 }
  1061. else {
  1062. int len = lstrlen(lpBuffer);
  1063. for (int i=0; i < len; ++i) {
  1064. if (_istcntrl(lpBuffer[i])) 
  1065. lpBuffer[i] = _T(' ');
  1066. }
  1067. msg = lpBuffer;
  1068. LocalFree(lpBuffer);
  1069. return msg;
  1070.   }
  1071. }
  1072. }
  1073.     }
  1075. lpBuffer = NULL;
  1076. HMODULE hModule = NULL; // default to system source
  1077.     
  1078. if (rc >= INTERNET_ERROR_BASE) 
  1079.  hModule = LoadLibraryEx(_T("wininet.dll"),NULL,LOAD_LIBRARY_AS_DATAFILE);
  1080.     
  1081. ::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
  1082. FORMAT_MESSAGE_IGNORE_INSERTS |
  1083. FORMAT_MESSAGE_FROM_SYSTEM |
  1084. ((hModule != NULL) ? FORMAT_MESSAGE_FROM_HMODULE : 0),
  1085. hModule, 
  1086. rc,
  1087. MAKELANGID(LANG_NEUTRAL, SUBLANG_SYS_DEFAULT),
  1088. (LPTSTR)&lpBuffer, 0, NULL);
  1090. if (lpBuffer) {
  1091. int len = lstrlen(lpBuffer);
  1092. for (int i=0; i < len; ++i) {
  1093. if (_istcntrl(lpBuffer[i])) 
  1094. lpBuffer[i] = _T(' ');
  1095. }
  1096. }
  1098. msg += lpBuffer;
  1099. LocalFree(lpBuffer);
  1101. if (hModule != NULL)
  1102.     FreeLibrary(hModule);
  1104. return msg;
  1105. }
  1107. HRESULT CXMLHttpRequest::InitializeVarFromByte(VARIANT &varOut, const PBYTE pByte, long lSize)
  1108. {
  1109. ::VariantInit(&varOut);
  1110. V_VT(&varOut) = VT_NULL;
  1112. HRESULT hr = S_OK;
  1113. SAFEARRAYBOUND rgsabound[1];
  1114. rgsabound[0].cElements = lSize;
  1115. rgsabound[0].lLbound   = 0;
  1117. SAFEARRAY *psa = ::SafeArrayCreate( VT_VARIANT, 1, rgsabound);
  1118. if (psa == NULL)
  1119. return E_FAIL;
  1121. if (pByte != NULL) {
  1122. long ix[1];
  1123. for (ULONG i = 0; i < rgsabound[0].cElements; ++i) {
  1124. ix[0] = i;
  1125. VARIANT var;
  1126. ::VariantInit(&var);
  1127. V_VT(&var)   = VT_UI1;
  1128. V_UI1(&var)  = pByte[i];
  1130. hr = ::SafeArrayPutElement(psa, ix, &var);
  1131. if (S_OK != hr) {
  1132. ::SafeArrayDestroy(psa);
  1133. break;
  1134. }
  1135. }
  1136. }
  1138. if (S_OK == hr) {
  1139. V_VT(&varOut)  = VT_ARRAY | VT_VARIANT;
  1140. V_ARRAY(&varOut) = psa;
  1141. }
  1143. return hr;
  1144. }