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

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

Symbian

开发平台：

C/C++

validatr.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"
  37. #include "hlxclib/stdio.h"
  38. #include "hxtypes.h"
  39. #include "hxresult.h"
  40. #include "hxassert.h"
  41. #include "hxcomm.h"
  42. #include "hxplugn.h"
  43. #include "hxfiles.h"
  44. #include "hxmeta.h"
  45. #include "hxcore.h"
  46. #include "hxpends.h"
  47. #include "timeval.h"
  48. #include "pq.h"
  49. #include "hxstring.h"
  50. #include "hxslist.h"
  51. #include "hxrquest.h"
  52. #include "hxbuffer.h"
  53. #include "chxpckts.h"
  54. #include "dbcs.h"
  55. #include "hxmarsh.h"
  56. #include "hxmime.h"
  57. #include "hxstrutl.h"
  58. #include "plghand2.h"
  59. #include "validatr.h"
  60. #include "hxxfile.h"
  61. #include "rmfftype.h"
  63. #include "hxheap.h"
  64. #ifdef _DEBUG
  65. #undef HX_THIS_FILE
  66. static const char HX_THIS_FILE[] = __FILE__;
  67. #endif
  69. #define MAX_URL_STRING 4096
  71. HXValidator::HXValidator(IUnknown* pContext)
  72. : m_lRefCount (0)
  73. , m_pContext (NULL)
  74. , m_bRefresh (TRUE)
  75. {
  76.     if (pContext)
  77.     {
  78. m_pContext = pContext;
  79. m_pContext->AddRef();
  80.     }
  81. }
  83. HXValidator::~HXValidator()
  84. {
  85.     CHXSimpleList::Iterator i;
  87.     // cleanup the protocol list
  88.     i = m_ProtocolList.Begin();
  89.     for (; i != m_ProtocolList.End(); ++i)
  90.     {
  91. CHXString* pProtocol = (CHXString*) (*i);
  92. HX_DELETE(pProtocol);
  93.     }
  94.     m_ProtocolList.RemoveAll();
  96.     HX_RELEASE(m_pContext);
  97. }
  99. STDMETHODIMP
  100. HXValidator::QueryInterface(REFIID riid, void**ppvObj)
  101. {
  102.     QInterfaceList qiList[] =
  103.         {
  104.             { GET_IIDHANDLE(IID_IHXValidator), (IHXValidator*)this },
  105.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXValidator*)this },
  106.         };
  107.     
  108.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  109. }
  111. /////////////////////////////////////////////////////////////////////////
  112. //  Method:
  113. // IUnknown::AddRef
  114. //  Purpose:
  115. // Everyone usually implements this the same... feel free to use
  116. // this implementation.
  117. //
  118. STDMETHODIMP_(ULONG32) 
  119. HXValidator::AddRef()
  120. {
  121.     return InterlockedIncrement(&m_lRefCount);
  122. }
  124. /////////////////////////////////////////////////////////////////////////
  125. //  Method:
  126. // IUnknown::Release
  127. //  Purpose:
  128. // Everyone usually implements this the same... feel free to use
  129. // this implementation.
  130. //
  131. STDMETHODIMP_(ULONG32) 
  132. HXValidator::Release()
  133. {
  134.     if (InterlockedDecrement(&m_lRefCount) > 0)
  135.     {
  136.         return m_lRefCount;
  137.     }
  139.     delete this;
  140.     return 0;
  141. }
  143. /************************************************************************
  144.  * Method:
  145.  *     IHXValidator::ValidateProtocol
  146.  * Purpose:
  147.  *     Find out if the protocol is valid
  148.  *     
  149.  *
  150.  */
  151. STDMETHODIMP_(BOOL)
  152. HXValidator::ValidateProtocol(char* pProtocol)
  153. {
  154.     BOOL bResult = FALSE;
  155.     CHXString* pValue = NULL;
  156.     CHXSimpleList::Iterator i;
  158.     if (!pProtocol)
  159.     {
  160. goto cleanup;
  161.     }
  163.     if (m_bRefresh)
  164.     {
  165. BuildProtocolList();
  166. m_bRefresh = FALSE;
  167.     }
  169.     i = m_ProtocolList.Begin();
  170.     for (; i != m_ProtocolList.End(); ++i)
  171.     {
  172. pValue = (CHXString*) (*i);
  174. if (strcasecmp(pProtocol, (const char*)(*pValue)) == 0)
  175. {
  176.     bResult = TRUE;
  177.     break;
  178. }
  179.     }
  181. cleanup:
  183.     return bResult;
  184. }
  186. /************************************************************************
  187.  * Method:
  188.  *     IHXValidator::ValidateMetaFile
  189.  * Purpose:
  190.  *     Find out if it is a meta file
  191.  *     
  192.  *
  193.  */
  194. STDMETHODIMP
  195. HXValidator::ValidateMetaFile(IHXRequest* pRequest,
  196.        IHXBuffer* pData)
  197. {
  198.     HX_RESULT hr = HXR_OK;    
  199.     BOOL bIsRAM = FALSE;
  200.     BOOL bTrackFound = FALSE;
  201.     BOOL bHeaderToBeSet = FALSE;
  202.     UINT32 ulFileType = 0;
  203.     UINT32 ulSize = 0;
  204.     UINT32 ulMajorVersion = 0;
  205.     int i = 0; 
  206.     int j = 0;
  207.     int iLen = 0;
  208.     int iSize = 0;
  209.     char* pMimeType = NULL;
  210.     char* pFileExt = NULL;
  211.     char* pProtocol = NULL;
  212.     char* pCursor = NULL;
  213.     char* pLine = NULL;
  214.     char* pContent = NULL;
  215.     char* pTemp = NULL;
  216.     char* pURL = NULL;
  217.     const char* pConstTemp = NULL;
  218.     const char* charset = " rnt";
  219.     const char* tokenset = "nr";    
  220.     UINT32 ulProtocol = 0;
  221.     CHXString* pString = NULL;
  222.     IHXBuffer* pValue = NULL;
  223.     IHXValues* pResponseHeaders = NULL;
  224.     
  225.     if (pRequest)
  226.     {
  227. pRequest->AddRef();
  228.     }
  230.     if (pData)
  231.     {
  232.         pData->AddRef();
  233.     }
  234.     else
  235.     {
  236. hr = HXR_FAILED;
  237. goto cleanup;
  238.     }
  240.     if (pRequest)
  241.     {
  242.         pRequest->GetURL(pConstTemp);
  243.         if (HXXFile::IsPlusURL(pConstTemp))
  244.         {
  245.     hr = HXR_FAILED;
  246.     goto cleanup;
  247.         }
  248.     }
  250.     ulSize = pData->GetSize() + 1;
  251.     pContent = new char[ulSize];
  252.     memset(pContent, 0, ulSize);
  253.     memcpy(pContent, (char*)pData->GetBuffer(), pData->GetSize()); /* Flawfinder: ignore */
  255.     // if the first FOURCC is either ".RA " or ".RMF"
  256.     if (pData->GetSize() >= 4)
  257.     {
  258. ulFileType = (UINT32) getlong((UCHAR*) pContent);
  259.     
  260. const char* pContentType = NULL;
  261. switch (ulFileType)
  262. {
  263.     case RM_HEADER_OBJECT:
  264.     case RMS_HEADER_OBJECT:
  265.     case RA_FILE_MAGIC_NUMBER:
  266.     {
  267. pContentType = REALAUDIO_MIME_TYPE;
  268.     }
  269.     break;
  271.     case REDHAT_PACKAGE_MAGIC_NUMBER:
  272.     {
  273. pContentType = REDHAT_PACKAGE_MIME_TYPE;
  274.     }
  275.     break;
  276. }
  278. if (pContentType)
  279. {
  280.     if (pRequest)
  281.     {
  282. pRequest->GetResponseHeaders(pResponseHeaders);
  283. if (!pResponseHeaders)
  284. {
  285.     pResponseHeaders = (IHXValues*) new CHXHeader;
  286.     pResponseHeaders->AddRef();
  287.     bHeaderToBeSet = TRUE;
  288. }
  290. if (HXR_OK !=
  291.     pResponseHeaders->GetPropertyCString("Content-Type",
  292.  pValue) ||
  293.     !pValue)
  294. {
  295.     pValue = (IHXBuffer*) new CHXBuffer;
  296.     pValue->AddRef();
  297.     pValue->Set((UCHAR*)pContentType,
  298. ::strlen(pContentType) + 1);
  299.     pResponseHeaders->SetPropertyCString("Content-Type",
  300.  pValue);
  302.     if (bHeaderToBeSet)
  303.     {
  304. pRequest->SetResponseHeaders(pResponseHeaders);
  305.     }
  306. }
  307.     }
  308.     
  309.     hr = HXR_FAILED;
  310.     goto cleanup;
  311. }
  312.     }
  314.     // retreive the MimeType and FileExt
  315.     if (pRequest)
  316.     {
  317. if (HXR_OK == pRequest->GetResponseHeaders(pResponseHeaders) &&
  318.     pResponseHeaders)
  319. {
  320.     if (HXR_OK == pResponseHeaders->GetPropertyCString("Content-Type", pValue) &&
  321. pValue)
  322.     {
  323. pMimeType = (char*)pValue->GetBuffer();
  324.     }
  325. }
  327. pTemp = (char*)pConstTemp;
  329. if (pTemp)
  330. {
  331.     pURL = new char[strlen(pTemp) + 1];
  332.     strcpy(pURL, pTemp); /* Flawfinder: ignore */
  334.     pTemp = strrchr(pURL, '?');
  336.     if (pTemp)
  337.     {
  338. *pTemp = '';
  339.     }
  341.     pFileExt = strrchr(pURL, '.');
  342. }
  343.     }
  345.     // determine whether it is a RAM file
  346.     if ((pMimeType &&
  347.  ((strcasecmp(pMimeType, "audio/x-pn-realaudio") == 0) ||
  348.   (strcasecmp(pMimeType, "audio/x-pn-realaudio-plugin") == 0))) ||
  349. (pFileExt &&
  350.  ((strcasecmp(pFileExt, ".ram") == 0) ||
  351.   (strcasecmp(pFileExt, ".rpm") == 0) ||
  352.   (strcasecmp(pFileExt, ".rmm") == 0))))
  353.     {
  354. bIsRAM = TRUE;
  356.         iLen = pData->GetSize();
  357. char* ramFile = new char[iLen+1];
  358.     
  359. while( i <= iLen && !bTrackFound)
  360. {
  361. /*
  362.  * XXXJHUG  12/07/00 change to allow unlimitted length ram files.
  363.  *      - we no longer need to check to see if the url
  364.  *        is longer than a fixed value.
  365.     if (j >= MAX_URL_STRING)
  366.     {
  367. // exceeds the max. length of URL
  368. // skip the whole line
  369. while (pContent[i] != 'n' && pContent[i] != 'r' &&
  370.        pContent[i] != 0 && i < iLen)
  371. {
  372.     i++;
  373. }
  375. memset(pUrl, 0, MAX_URL_STRING);
  376. j = 0;
  377. i++;
  379. continue;
  380.     }
  381. */
  382.     ramFile[j] = pContent[i]; 
  383.     
  384.     // Look for line terminators.
  385.     if ( ramFile[j] == 'n' || ramFile[j] == 'r' || ramFile[j] == 0 || i == iLen)
  386.     {
  387. ramFile[j] = 0;
  389. pString = new CHXString(ramFile);
  391. pString->TrimLeft();
  392. pString->TrimRight();
  394. iSize = pString->GetLength();
  395. if (iSize)
  396. {
  397.     memset(ramFile, 0, iLen+1);
  398.     SafeStrCpy(ramFile,  pString->GetBuffer(iSize), iLen+1);
  399.     
  400.     // A URL must have at least 4 chars. for protocol. This will
  401.     // take care of lines with junk or just CR on them.
  402.     
  403.     // detect RAM3.0 syntax
  404.     if (strncasecmp(ramFile, HX_RAM30_START_TAG, HX_RAM30_START_TAGSIZE) == 0)
  405.     {
  406. ulMajorVersion = 3;
  407.     }
  408.     else if (strncasecmp(ramFile, HX_RAM30_END_TAG, HX_RAM30_END_TAGSIZE) == 0)
  409.     {
  410. HX_DELETE(pString);
  411. break;
  412.     }
  413.     // detect RAM2.0 syntax
  414.     else if (strncasecmp(ramFile, HX_RAM20_START_TAG, HX_RAM20_START_TAGSIZE) == 0)
  415.     {
  416. ulMajorVersion = 2;
  417.     }
  418.     else if (strncasecmp(ramFile, HX_RAM20_END_TAG, HX_RAM20_END_TAGSIZE) == 0)
  419.     {
  420. HX_DELETE(pString);
  421. break;
  422.     }
  423.     // handle "--stop--" tag in 6.0
  424.     else if (strncasecmp(ramFile, "--stop--", 8) == 0)
  425.     {
  426. HX_DELETE(pString);
  427. break;
  428.     }
  429.     else 
  430.     {
  431. if (ulMajorVersion == 2 || ulMajorVersion == 3)
  432. {
  433.     if (strncasecmp(ramFile, HX_RAM_ENTRY_TAG, HX_RAM_ENTRY_TAGSIZE) == 0 && 
  434. (iSize >= (HX_RAM_ENTRY_TAGSIZE + 4)))
  435.     {
  436. CHXString* pStringAfterTag = new CHXString(ramFile+2);
  438. pStringAfterTag->TrimLeft();
  439. pStringAfterTag->TrimRight();
  440.     
  441. iSize = pStringAfterTag->GetLength();
  442. if (iSize)
  443. {
  444.     memset(ramFile, 0, iLen);
  445.     SafeStrCpy(ramFile,  pStringAfterTag->GetBuffer(iSize), iLen+1);
  446. }
  447. HX_DELETE(pStringAfterTag);
  448.     }
  449.     else
  450.     {
  451. memset(ramFile, 0, iLen);
  452.     }     
  453. }
  454.     
  455. pCursor = strstr(ramFile, ":");
  456. if (pCursor)
  457. {
  458.     ulProtocol = pCursor - ramFile;
  460.     if (ulProtocol > 0)
  461.     {
  462. pProtocol = new char[ulProtocol+1];
  463. memset(pProtocol, 0, ulProtocol+1);
  464. strncpy(pProtocol, ramFile, ulProtocol); /* Flawfinder: ignore */
  466. if (ValidateProtocol(pProtocol))
  467. {
  468.     bTrackFound = TRUE;
  469. }
  471. HX_VECTOR_DELETE(pProtocol);
  472.     }
  473. }
  474.     }
  475. }
  477. j = 0;
  478. HX_DELETE(pString);
  479.     }
  480.     else
  481.     {
  482. j++; 
  483.     }
  485.     i++;
  486. }
  487. HX_VECTOR_DELETE(ramFile);
  489. if (bTrackFound)
  490. {     
  491.     hr = HXR_OK;
  492.     goto cleanup;
  493. }
  494. else
  495. {
  496.     hr = HXR_INVALID_METAFILE;
  497.     goto cleanup;
  498. }
  499.     }
  500.     // determine if it is a RAM
  501.     else
  502.     {
  503. // Trim off any leading spaces/EOLs/tabs before adding on the pnm protocol...
  504. pLine = strtok(pContent, tokenset);
  506. while (pLine != NULL)
  507. {
  508.     size_t pos = strspn(pLine,charset);
  509.     pLine += pos;
  511.     // handle RAM3.0 syntax
  512.     if (strncasecmp(pLine, HX_RAM30_START_TAG, HX_RAM30_START_TAGSIZE) == 0)
  513.     {
  514. ulMajorVersion = 3;
  515. pLine = strtok(NULL, tokenset);
  516. continue;
  517.     }
  518.     // handle RAM2.0 syntax
  519.     else if (strncasecmp(pLine, HX_RAM20_START_TAG, HX_RAM20_START_TAGSIZE) == 0)
  520.     {
  521. ulMajorVersion = 2;
  522. pLine = strtok(NULL, tokenset);
  523. continue;
  524.     }
  526.     if (ulMajorVersion == 2 && ulMajorVersion == 3)
  527.     {
  528. if (strncasecmp(pLine, HX_RAM_ENTRY_TAG, HX_RAM_ENTRY_TAGSIZE) == 0 &&
  529.     (pCursor = strstr(pLine, ":")))
  530. {
  531.     pLine += 2;     
  532.     // trim off the leading spaces
  533.     while (pLine[0] == ' ')
  534.     {
  535. pLine++;
  536.     }
  537. }
  538. else
  539. {
  540.     pLine = strtok(NULL, tokenset);
  541.     continue;
  542. }     
  543.     }
  544.     else
  545.     {
  546. pString = new CHXString(pLine);
  548. pString->TrimLeft();
  549. pString->TrimRight();
  551. if ((pString->GetLength() == 0)     ||
  552.     (strncasecmp(pLine, "//", 2) == 0)  ||
  553.     (strncasecmp(pLine, "#", 1) == 0))
  554. {
  555.     // comments, skip to next line
  556.     pLine = strtok(NULL, tokenset);
  557.     HX_DELETE(pString);
  558.     continue;
  559. }
  560. HX_DELETE(pString);
  562. pCursor = strstr(pLine, ":");
  563. if (!pCursor)
  564. {
  565.     bIsRAM = FALSE;
  566.     break;
  567. }
  568.     }
  570.     ulProtocol = pCursor - pLine;
  571.     if (ulProtocol > 0)
  572.     {
  573. pProtocol = new char[ulProtocol+1];
  574. memset(pProtocol, 0, ulProtocol+1);
  575. strncpy(pProtocol, pLine, ulProtocol); /* Flawfinder: ignore */
  577. bIsRAM = ValidateProtocol(pProtocol);
  579. HX_VECTOR_DELETE(pProtocol);
  580. break;
  581.     }
  582.     else
  583.     {
  584. bIsRAM = FALSE;
  585. break;
  586.     }
  587. }
  589. if (bIsRAM)
  590. {
  591.     hr = HXR_OK;
  592.     goto cleanup;
  593. }
  594. else
  595. {
  596.     hr = HXR_FAILED;
  597.     goto cleanup;
  598. }
  599.     }
  600.     
  601. cleanup:
  603.     // set the RAMVersion to response header, it will be retrieved by the 
  604.     // RAM file format
  605.     if (pRequest && bIsRAM)
  606.     {
  607. if (!pResponseHeaders)
  608. {
  609.     pResponseHeaders = (IHXValues*) new CHXHeader;
  610.     pResponseHeaders->AddRef();
  611.     bHeaderToBeSet = TRUE;
  612. }
  614. UINT32 ulPersistentVersion = HX_ENCODE_PROD_VERSION(ulMajorVersion, 0, 0, 0);
  615. pResponseHeaders->SetPropertyULONG32("PersistentVersion", ulPersistentVersion);
  617. if (bHeaderToBeSet)
  618. {
  619.     pRequest->SetResponseHeaders(pResponseHeaders); 
  620. }
  621.     }
  623.     HX_VECTOR_DELETE(pURL);
  624.     HX_VECTOR_DELETE(pContent);
  626.     HX_RELEASE(pResponseHeaders);
  627.     HX_RELEASE(pValue);
  628.     HX_RELEASE(pRequest);
  629.     HX_RELEASE(pData);
  631.     return hr;
  632. }
  634. HX_RESULT
  635. HXValidator::BuildProtocolList(void)
  636. {
  637.     HX_RESULT hr = HXR_OK;
  638.     UINT32 j = 0;
  639.     UINT32 ulPlugins = 0;
  640.     IHXValues* pValues = NULL;
  641.     IHXBuffer* pBuffer = NULL;
  642.     IHXCommonClassFactory* pCommonClassFactory = NULL;
  643.     IHXPluginQuery* pPluginQuery = NULL;
  644.     IHXPluginGroupEnumerator* pPluginEnum = NULL;
  645.     CHXString* pProtocol = NULL;
  646.     CHXSimpleList::Iterator i;
  648.     if (HXR_OK != m_pContext->QueryInterface(IID_IHXCommonClassFactory, (void**)&pCommonClassFactory))
  649.     {
  650. hr = HXR_FAILED;
  651. goto cleanup;
  652.     }
  654.     // reset the list
  655.     i = m_ProtocolList.Begin();
  656.     for (; i != m_ProtocolList.End(); ++i)
  657.     {
  658. pProtocol = (CHXString*) (*i);
  659. HX_DELETE(pProtocol);
  660.     }
  661.     m_ProtocolList.RemoveAll();
  663.     // we always add "pnm" and "rtsp"
  664.     pProtocol = new CHXString("pnm");
  665.     m_ProtocolList.AddTail(pProtocol);
  667.     pProtocol = new CHXString("rtsp");
  668.     m_ProtocolList.AddTail(pProtocol);
  670.     // collect protocol info. from the pluginhandler
  671.     if (HXR_OK != pCommonClassFactory->CreateInstance(IID_IHXPluginGroupEnumerator, 
  672. (void**)&pPluginEnum))
  673.     {
  674. goto cleanup;
  675.     }
  677.     if (HXR_OK != pPluginEnum->QueryInterface(IID_IHXPluginQuery, (void**)&pPluginQuery))
  678.     {
  679. goto cleanup;
  680.     }
  682.     if (HXR_OK != pPluginQuery->GetNumPluginsGivenGroup(IID_IHXFileSystemObject, ulPlugins))
  683.     {
  684. goto cleanup;
  685.     }
  687.     for (j = 0; j < ulPlugins; j++)
  688.     {
  689. HX_RELEASE(pBuffer);
  690. HX_RELEASE(pValues);
  692. if (HXR_OK != pPluginQuery->GetPluginInfo(IID_IHXFileSystemObject, j, pValues) ||
  693.     !pValues)
  694. {
  695.     continue;
  696. }
  698. if (HXR_OK != pValues->GetPropertyCString("FileProtocol", pBuffer) ||
  699.     !pBuffer)
  700. {
  701.     continue;
  702. }
  704. pProtocol = new CHXString((const char*) pBuffer->GetBuffer());
  705. int nPos = pProtocol->Find('|');
  706. while (nPos > 0)
  707. {
  708.     CHXString* pTemp = new CHXString(pProtocol->Left(nPos));
  709.     *pProtocol = pProtocol->Mid(nPos + 1);
  710.     m_ProtocolList.AddTail(pTemp);
  711.     nPos = pProtocol->Find('|');
  712. }
  713. m_ProtocolList.AddTail(pProtocol);
  714. if (pProtocol->CompareNoCase("lice") == 0)
  715. {
  716.     CHXString *pAnother = new CHXString("rnba");
  717.     m_ProtocolList.AddTail(pAnother);
  718. }
  719.     }
  721. cleanup:
  723.     HX_RELEASE(pBuffer);
  724.     HX_RELEASE(pValues);
  725.     HX_RELEASE(pPluginQuery);
  726.     HX_RELEASE(pPluginEnum);
  727.     HX_RELEASE(pCommonClassFactory);
  729.     return hr;
  730. }
  732. void
  733. HXValidator::RefreshProtocols(void)
  734. {
  735.     m_bRefresh = TRUE;
  736. }