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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
dtrvtcon.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：14k
源码类别：

Symbian

开发平台：

C/C++

dtrvtcon.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #include "hxcom.h"
  38. #include "ihxpckts.h"
  39. #include "hxdtcvt.h"
  40. #include "plghand2.h"
  42. #include "dtrvtcon.h"
  43. #include "hxmarsh.h"
  45. #include "hxstrutl.h"
  47. #include "rtsputil.h"
  48. #include "hxbuffer.h"
  50. #define HX_CONVERT_MIME_TYPE "application/vnd.rn.dataconvert."
  52. DataRevertController::DataRevertController(IUnknown* pContext)
  53. : m_pPlugin2Handler(0)
  54. , m_pContext(0)
  55. , m_pControlResp(0)
  56. , m_lRefCount(0)
  57. , m_pDataRevert(0)
  58. , m_pStreamHeaders(0)
  59. , m_pRevertedStreamHeaders(0)
  60. , m_pFileHeaders(0)
  61. , m_pResponseHeaders(0)
  62. , m_pCurrentStreamHeader(0)
  63. , m_pDataResp(0)
  64. , m_pPacketList(0)
  65. , m_pControlBufferList(0)
  66. , m_bInited(FALSE)
  67. {
  68.     m_pContext = pContext;
  69.     m_pContext->AddRef();
  70.     m_pContext->QueryInterface(IID_IHXPlugin2Handler,
  71.     (void**)&m_pPlugin2Handler);
  72. }
  74. DataRevertController::~DataRevertController()
  75. {
  76.     HX_RELEASE(m_pContext);
  77.     HX_RELEASE(m_pPlugin2Handler);
  78.     HX_RELEASE(m_pDataRevert);
  79.     HX_RELEASE(m_pCurrentStreamHeader);
  80.     CleanStreamHeaders();
  81.     CleanControlBuffers();
  82.     HX_RELEASE(m_pFileHeaders);
  83.     HX_RELEASE(m_pResponseHeaders);
  84.     delete m_pPacketList;
  85. }
  87. void
  88. DataRevertController::CleanControlBuffers()
  89. {
  90.     IHXBuffer* pBuffer;
  91.     if (m_pControlBufferList)
  92.     {
  93. while (!m_pControlBufferList->IsEmpty())
  94. {
  95.     pBuffer = (IHXBuffer*)m_pControlBufferList->RemoveHead();
  96.     pBuffer->Release();
  97. }
  98. delete m_pControlBufferList;
  99.     }
  100. }
  102. void
  103. DataRevertController::CleanStreamHeaders()
  104. {
  105.     IHXValues* pHeader;
  106.     if (m_pStreamHeaders)
  107.     {
  108. while (!m_pStreamHeaders->IsEmpty())
  109. {
  110.     pHeader = (IHXValues*)m_pStreamHeaders->RemoveHead();
  111.     pHeader->Release();
  112. }
  113. delete m_pStreamHeaders;
  114.     }
  115.     if (m_pRevertedStreamHeaders)
  116.     {
  117. while (!m_pRevertedStreamHeaders->IsEmpty())
  118. {
  119.     pHeader = (IHXValues*)m_pRevertedStreamHeaders->RemoveHead();
  120.     pHeader->Release();
  121. }
  122. delete m_pRevertedStreamHeaders;
  123.     }
  124. }
  126. void
  127. DataRevertController::SetControlResponse(DataRevertControllerResponse* pResp)
  128. {
  129.     m_pControlResp = pResp;
  130. }
  132. void
  133. DataRevertController::RevertHeaders(IHXValues* pFileHeader,
  134.     CHXSimpleList* pStreamHeaders,
  135.     IHXValues* pResponseHeaders)
  136. {
  137.     IHXBuffer* pMimeType = 0;
  138.     IHXValues* pHeader;
  139.     CHXSimpleList::Iterator i;
  140.     char* pConversionType = NULL;
  141.     IUnknown* pUnkReverter = NULL;
  142.     HX_RELEASE(m_pDataRevert);
  143.     
  144.     i = pStreamHeaders->Begin();
  145.     if (i != pStreamHeaders->End())
  146.     {
  147. pHeader = (IHXValues*)(*i);
  148. pHeader->GetPropertyCString("MimeType", pMimeType);
  149. if (!pMimeType)
  150. {
  151.     HX_ASSERT(0);
  152.     goto exit;
  153. }
  154. if (strncasecmp((const char*)pMimeType->GetBuffer(),
  155.     HX_CONVERT_MIME_TYPE, (int)strlen(HX_CONVERT_MIME_TYPE)))
  156. {
  157.     goto exit;
  158. }
  160. pConversionType = (char*)pMimeType->GetBuffer() +
  161.     strlen(HX_CONVERT_MIME_TYPE);
  162. if (m_pPlugin2Handler &&
  163.     HXR_OK == m_pPlugin2Handler->FindPluginUsingStrings(
  164. PLUGIN_CLASS, PLUGIN_REVERTER_TYPE,
  165. PLUGIN_REVERTER_MIME, pConversionType,
  166. NULL, NULL, pUnkReverter))
  167. {
  168.     pUnkReverter->QueryInterface(IID_IHXDataRevert,
  169.     (void**)&m_pDataRevert);
  170.     pUnkReverter->Release();
  171. }
  172. if (!m_pDataRevert)
  173. {
  174.     goto exit;
  175. }
  176. IHXPlugin* pPlugin;
  177. m_pDataRevert->QueryInterface(IID_IHXPlugin, (void**)&pPlugin);
  178. pPlugin->InitPlugin(m_pContext);
  179. pPlugin->Release();
  180. HX_RELEASE(pMimeType);
  182. m_pStreamHeaders = new CHXSimpleList;
  183. m_pRevertedStreamHeaders = new CHXSimpleList;
  184. IHXBuffer* pConvertHeader = 0;
  185. for (i = pStreamHeaders->Begin(); i != pStreamHeaders->End(); ++i)
  186. {
  187.     pHeader = (IHXValues*)(*i);
  188.     /*
  189.      * If this stream header was converted and flattened then
  190.      * the one we want to give to the plugin is the result
  191.      * of re-inflating that.  If not, then just give the plugin
  192.      * the one we already got.
  193.      */
  194.     if (HXR_OK == pHeader->GetPropertyBuffer("DataConvertStreamHeader",
  195.     pConvertHeader))
  196.     {
  197. pHeader = InflateConvertHeader(pConvertHeader);
  198. pConvertHeader->Release();
  199.     }
  200.     else
  201.     {
  202. IHXBuffer* pPreConvertMimeType;
  203. if (HXR_OK == pHeader->GetPropertyCString("PreConvertMimeType",
  204. pPreConvertMimeType))
  205. {
  206.     pHeader->SetPropertyCString("MimeType",
  207. pPreConvertMimeType);
  208.     pPreConvertMimeType->Release();
  209. }
  210. pHeader->AddRef();
  211.     }
  212.     m_pStreamHeaders->AddTail((void*)pHeader);
  213. }
  214. m_pResponseHeaders = pResponseHeaders;
  215. m_pResponseHeaders->AddRef();
  217. /*
  218.  * If playing through an old proxy which does not support
  219.  * initiate-session then the DataConvertBuffer will come in here.
  220.  * This is not an ideal situation because only one can come in
  221.  * at this point, but it's better then nothing. 
  222.  */
  223. IHXBuffer* pConvertBuffer = 0;
  224. if (HXR_OK == pFileHeader->GetPropertyBuffer("DataConvertBuffer",
  225.     pConvertBuffer))
  226. {
  227.     const char* pContent = (const char*)pConvertBuffer->GetBuffer();
  228.     IHXBuffer* pNewBuffer = new CHXBuffer();
  229.     int contentLen = pConvertBuffer->GetSize();
  230.     pNewBuffer->SetSize(contentLen);
  231.     int offset = BinFrom64(pContent, contentLen,
  232.     (unsigned char*)pNewBuffer->GetBuffer());
  233.     pNewBuffer->SetSize(offset);
  234.     pNewBuffer->AddRef();
  235.     ControlBufferReady(pNewBuffer);
  236.     pNewBuffer->Release();
  237.     pConvertBuffer->Release();
  238. }
  239. /*
  240.  * Again for file header, if the header was converted and
  241.  * flattened then give to plugin the inflated version of that.
  242.  * If not, then give the straight old header that we already
  243.  * have.
  244.  */
  245. if (HXR_OK == pFileHeader->GetPropertyBuffer("DataConvertFileHeader",
  246.     pConvertHeader))
  247. {
  248.     m_pFileHeaders = InflateConvertHeader(pConvertHeader);
  249.     pConvertHeader->Release();
  250. }
  251. else
  252. {
  253.     m_pFileHeaders = pFileHeader;
  254.     m_pFileHeaders->AddRef();
  255. }
  257. m_pDataRevert->DataRevertInit(this);
  258. return;
  259.     }
  262. exit:;
  263.     HX_RELEASE(pMimeType);
  264.     m_pControlResp->RevertHeadersDone(pFileHeader, 
  265.       pStreamHeaders,
  266.       pResponseHeaders,
  267.       FALSE);
  268. }
  270. void
  271. DataRevertController::ControlBufferReady(IHXBuffer* pBuffer)
  272. {
  273.     if (!m_bInited)
  274.     {
  275. if (!m_pControlBufferList)
  276. {
  277.     m_pControlBufferList = new CHXSimpleList;
  278. }
  279. m_pControlBufferList->AddTail((void*)pBuffer);
  280. pBuffer->AddRef();
  281.     }
  282.     else
  283.     {
  284. m_pDataRevert->ControlBufferReady(pBuffer);
  285.     }
  286. }
  288. /*
  289.  *  IUnknown methods
  290.  */
  291. STDMETHODIMP
  292. DataRevertController::QueryInterface(REFIID riid, void** ppvObj)
  293. {
  294.     QInterfaceList qiList[] =
  295.         {
  296.             { GET_IIDHANDLE(IID_IHXDataRevertResponse), (IHXDataRevertResponse*)this },
  297.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXDataRevertResponse*)this },
  298.         };
  299.     
  300.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  301. }
  303. STDMETHODIMP_(ULONG32)
  304. DataRevertController::AddRef()
  305. {
  306.     return InterlockedIncrement(&m_lRefCount);
  307. }
  309. STDMETHODIMP_(ULONG32)
  310. DataRevertController::Release()
  311. {
  312.     if (InterlockedDecrement(&m_lRefCount) > 0)
  313.     {
  314. return m_lRefCount;
  315.     }
  316.     delete this;
  317.     return 0;
  318. }
  320. /************************************************************************
  321.  *  IHXDataRevertResponse
  322.  */
  323. STDMETHODIMP
  324. DataRevertController::DataRevertInitDone(HX_RESULT status)
  325. {
  326.     m_bInited = TRUE;
  327.     if (m_pControlBufferList)
  328.     {
  329. IHXBuffer* pBuffer;
  330. while (!m_pControlBufferList->IsEmpty())
  331. {
  332.     pBuffer = (IHXBuffer*)m_pControlBufferList->RemoveHead();
  333.     m_pDataRevert->ControlBufferReady(pBuffer);
  334.     pBuffer->Release();
  335. }
  336.     }
  337.     m_pDataRevert->RevertFileHeader(m_pFileHeaders);
  338.     return HXR_OK;
  339. }
  341. STDMETHODIMP
  342. DataRevertController::RevertedFileHeaderReady(HX_RESULT status,
  343. IHXValues* pHeader)
  344. {
  345.     if (pHeader)
  346.     {
  347. HX_RELEASE(m_pFileHeaders);
  348. m_pFileHeaders = pHeader;
  349. pHeader->AddRef();
  350.     }
  352.     pHeader = (IHXValues*)m_pStreamHeaders->RemoveHead(); 
  353.     if (!pHeader)
  354.     {
  355. m_pControlResp->RevertHeadersDone(m_pFileHeaders,
  356.   m_pRevertedStreamHeaders, 
  357.   m_pResponseHeaders,
  358.   TRUE);
  359. return HXR_OK;
  360.     }
  361.     
  362.     HX_RELEASE(m_pCurrentStreamHeader);
  363.     m_pCurrentStreamHeader = pHeader;
  364.     m_pDataRevert->RevertStreamHeader(pHeader);
  366.     return HXR_OK;
  367. }
  369. STDMETHODIMP
  370. DataRevertController::RevertedStreamHeaderReady(HX_RESULT status,
  371. IHXValues* pHeader)
  372. {
  373.     if (!pHeader)
  374.     {
  375. pHeader = m_pCurrentStreamHeader;
  376.     }
  377.     else
  378.     {
  379. pHeader->AddRef();
  380.     }
  381.     m_pRevertedStreamHeaders->AddTail((void*)pHeader);
  382.     if (!m_pStreamHeaders->IsEmpty())
  383.     {
  384. HX_RELEASE(m_pCurrentStreamHeader);
  385. m_pCurrentStreamHeader = (IHXValues*)m_pStreamHeaders->RemoveHead();
  386. m_pDataRevert->RevertStreamHeader(m_pCurrentStreamHeader);
  387.     }
  388.     else
  389.     {
  390. m_pControlResp->RevertHeadersDone(m_pFileHeaders,
  391.   m_pRevertedStreamHeaders, 
  392.   m_pResponseHeaders,
  393.   TRUE);
  394.     }
  396.     return HXR_OK;
  397. }
  399. STDMETHODIMP
  400. DataRevertController::RevertedDataReady(HX_RESULT status, IHXPacket* pPacket)
  401. {
  402.     IHXPacket* pThisPacket;
  403.     pThisPacket = (IHXPacket*)m_pPacketList->RemoveTail();
  404.     if (pPacket)
  405.     {
  406. HX_RELEASE(pThisPacket);
  407. pThisPacket = pPacket;
  408. pThisPacket->AddRef();
  409.     }
  410.     m_pDataResp->FilterPacket(pThisPacket);
  411.     pThisPacket->Release();
  412.     return HXR_OK;
  413. }
  415. STDMETHODIMP
  416. DataRevertController::SendControlBuffer(IHXBuffer* pBuffer)
  417. {
  418.     m_pControlResp->SendControlBuffer(pBuffer);
  419.     return HXR_OK;
  420. }
  422. void
  423. DataRevertController::FilterPacket(IHXPacket* pPacket)
  424. {
  425.     if (m_pDataRevert)
  426.     {
  427. pPacket->AddRef();
  428. if (!m_pPacketList)
  429. {
  430.     m_pPacketList = new CHXSimpleList;
  431. }
  432. m_pPacketList->AddHead((void*)pPacket);
  433. m_pDataRevert->RevertData(pPacket);
  434.     }
  435.     else
  436.     {
  437. m_pDataResp->FilterPacket(pPacket);
  438.     }
  439. }
  441. void
  442. DataRevertController::SetFilterResponse(RawPacketFilter* pFilt)
  443. {
  444.     m_pDataResp = pFilt;
  445. }
  447. IHXValues*
  448. DataRevertController::InflateConvertHeader(IHXBuffer* pInflate)
  449. {
  450.     IHXValues* pNewHeader = NULL;
  451.     IHXCommonClassFactory* pCCF;
  452.     
  453.     m_pContext->QueryInterface(IID_IHXCommonClassFactory,
  454.     (void**)&pCCF);
  455.     
  456.     pCCF->CreateInstance(CLSID_IHXValues, (void**)&pNewHeader);
  457.     ULONG32 ul;
  458.     IHXBuffer* pBuffer;
  459.     const char* p;
  460.     IHXBuffer* pTemp;
  461.     ULONG32 ulTemp;
  463.     pCCF->CreateInstance(CLSID_IHXBuffer, (void**)&pTemp);
  464.     UINT32 limit = pInflate->GetSize();
  465.     UINT32 i = 0;
  466.     p = (const char*)pInflate->GetBuffer();
  467.     while (i < pInflate->GetSize() - 5)
  468.     {
  469. if (p[i] == 'u')
  470. {
  471.     i++;
  472.     ulTemp = getlong((UINT8*) &(p[i]));
  473.     i += 4;
  474.     if (i + ulTemp > limit)
  475.     {
  476. goto error;
  477.     }
  478.     pTemp->SetSize(ulTemp + 1);
  479.     memcpy((char *)pTemp->GetBuffer(), &(p[i]), ulTemp); /* Flawfinder: ignore */
  480.     ((char*)pTemp->GetBuffer())[ulTemp] = 0;
  481.     i += ulTemp;
  482.     if (i + 4 > limit)
  483.     {
  484. goto error;
  485.     }
  486.     ul = getlong((UINT8*) &(p[i]));
  487.     i += 4;
  488.     pNewHeader->SetPropertyULONG32((char*)pTemp->GetBuffer(), ul);
  489. }
  490. else if (p[i] == 's' || p[i] == 'b')
  491. {
  492.     int at = i;
  493.     i++;
  494.     ulTemp = getlong((UINT8*) &(p[i]));
  495.     i += 4;
  496.     if (i + ulTemp > limit)
  497.     {
  498. goto error;
  499.     }
  500.     pTemp->SetSize(ulTemp + 1);
  501.     memcpy((char*)pTemp->GetBuffer(), &(p[i]), ulTemp); /* Flawfinder: ignore */
  502.     ((char*)pTemp->GetBuffer())[ulTemp] = 0;
  503.     i += ulTemp;
  504.     if (i + 4 > limit)
  505.     {
  506. goto error;
  507.     }
  508.     ulTemp = getlong((UINT8*) &(p[i]));
  509.     i += 4;
  510.     if (i + ulTemp > limit)
  511.     {
  512. goto error;
  513.     }
  514.     pCCF->CreateInstance(CLSID_IHXBuffer, (void**)&pBuffer);
  515.     pBuffer->SetSize(ulTemp);
  516.     memcpy((char*)pBuffer->GetBuffer(), &(p[i]), ulTemp); /* Flawfinder: ignore */
  518.     if (p[at] == 's')
  519.     {
  520. pNewHeader->SetPropertyCString((const char*)pTemp->GetBuffer(),
  521. pBuffer);
  522.     }
  523.     else
  524.     {
  525. pNewHeader->SetPropertyBuffer((const char*)pTemp->GetBuffer(),
  526. pBuffer);
  527.     }
  528.     pBuffer->Release();
  529.     i+= ulTemp;
  530. }
  531. else
  532. {
  533.     goto error;
  534. }
  535.     }
  536.     if (i != pInflate->GetSize())
  537.     {
  538. goto error;
  539.     }
  540.     
  541.     goto exit;
  542.     
  543. error:;
  545.     
  546. exit:;
  548.     HX_RELEASE(pTemp);
  549.     HX_RELEASE(pCCF);
  550.     
  551.     return pNewHeader;
  552. }
  554. void
  555. DataRevertController::Done(void)
  556. {
  557.     HX_RELEASE(m_pDataRevert);
  558. }