crdcache.cpp
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:6k
源码类别:

Symbian

开发平台:

C/C++

  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 ***** */ 
  35. #include "hxcom.h"
  36. #include "hxtypes.h"
  37. #include "hxstring.h"
  38. #include "hxmap.h"
  39. #include "hxbuffer.h"
  40. #include "chxpckts.h"
  41. #include "crdcache.h"
  42. #define DEFAULTCREDENTIALENTRY "defaultCredentialEntry"
  43. CHXCredentialsCache::CHXCredentialsCache()
  44. {
  45.     m_lRefCount = 0;
  46. }
  47. CHXCredentialsCache::~CHXCredentialsCache()
  48. {
  49.     Close();
  50. }
  51. STDMETHODIMP
  52. CHXCredentialsCache::QueryInterface(REFIID riid, void**ppvObj)
  53. {
  54. QInterfaceList qiList[] =
  55. {
  56. { GET_IIDHANDLE(IID_IUnknown), this },
  57. { GET_IIDHANDLE(IID_IHXCredentialsCache), (IHXCredentialsCache*) this },
  58. };
  59.     return QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  60. }
  61. /////////////////////////////////////////////////////////////////////////
  62. //  Method:
  63. // IUnknown::AddRef
  64. //  Purpose:
  65. // Everyone usually implements this the same... feel free to use
  66. // this implementation.
  67. //
  68. STDMETHODIMP_(ULONG32) CHXCredentialsCache::AddRef()
  69. {
  70.     return InterlockedIncrement(&m_lRefCount);
  71. }
  72. /////////////////////////////////////////////////////////////////////////
  73. //  Method:
  74. // IUnknown::Release
  75. //  Purpose:
  76. // Everyone usually implements this the same... feel free to use
  77. // this implementation.
  78. //
  79. STDMETHODIMP_(ULONG32) CHXCredentialsCache::Release()
  80. {
  81.     if (InterlockedDecrement(&m_lRefCount) > 0)
  82.     {
  83.         return m_lRefCount;
  84.     }
  85.     delete this;
  86.     return 0;
  87. }
  88. STDMETHODIMP_(BOOL)
  89. CHXCredentialsCache::IsEmpty(IHXBuffer* pBuffer)
  90. {
  91.     const char* pKey = NULL;
  92.     CredentialEntry* pCredentialEntry = NULL;
  93.     if (!pBuffer)
  94.     {
  95. pKey = DEFAULTCREDENTIALENTRY;
  96.     }
  97.     else
  98.     {
  99. pKey = (const char*)pBuffer->GetBuffer();
  100.     }
  101.     if (m_credentialMap.Lookup(pKey, (void*&)pCredentialEntry) &&
  102. pCredentialEntry)
  103.     {
  104. return FALSE;
  105.     }
  106.     else
  107.     {
  108. return TRUE;
  109.     }
  110. }
  111. STDMETHODIMP 
  112. CHXCredentialsCache::Empty(IHXBuffer* pBuffer)
  113. {   
  114.     HX_RESULT hr = HXR_OK;
  115.     const char* pKey = NULL;
  116.     CredentialEntry* pCredentialEntry = NULL;
  117.     if (!pBuffer)
  118.     {
  119. pKey = DEFAULTCREDENTIALENTRY;
  120.     }
  121.     else
  122.     {
  123. pKey = (const char*)pBuffer->GetBuffer();
  124.     }
  125.     if (m_credentialMap.Lookup(pKey, (void*&)pCredentialEntry) &&
  126. pCredentialEntry)
  127.     {
  128. HX_DELETE(pCredentialEntry);
  129.     
  130.         m_credentialMap.RemoveKey(pKey);
  131.     }
  132.     return hr;
  133. }
  134. STDMETHODIMP
  135. CHXCredentialsCache::FillCredentials(REF(IHXValues*) pValues)
  136. {
  137.     HX_RESULT hr = HXR_FAILED;
  138.     IHXBuffer* pRealm = NULL;
  139.     CredentialEntry* pCredentialEntry = NULL;
  140.     if (!pValues)
  141.     {
  142. goto cleanup;
  143.     }
  144.     
  145.     if (HXR_OK != pValues->GetPropertyCString("Realm", pRealm))
  146.     {
  147. pRealm = new CHXBuffer();
  148. pRealm->AddRef();
  149. pRealm->Set((const unsigned char*)DEFAULTCREDENTIALENTRY, strlen(DEFAULTCREDENTIALENTRY)+1);
  150.     }
  151.         
  152.     if (m_credentialMap.Lookup((const char*)pRealm->GetBuffer(), (void*&)pCredentialEntry) &&
  153. pCredentialEntry)
  154.     {
  155. pValues->SetPropertyCString("Username", pCredentialEntry->m_pUserName);
  156. pValues->SetPropertyCString("Password", pCredentialEntry->m_pPassword);
  157. hr = HXR_OK;
  158.     }
  159. cleanup:
  160.     HX_RELEASE(pRealm);
  161.     return hr;
  162. }
  163. STDMETHODIMP
  164. CHXCredentialsCache::SetCredentials(IHXValues* pValues)
  165. {
  166.     HX_RESULT hr = HXR_OK;
  167.     IHXBuffer* pRealm = NULL;
  168.     IHXBuffer* pUserName = NULL;
  169.     IHXBuffer* pPassword = NULL;
  170.     CredentialEntry* pCredentialEntry = NULL;
  171.     if (!pValues)
  172.     {
  173. goto cleanup;
  174.     }
  175.     
  176.     if (HXR_OK != pValues->GetPropertyCString("Realm", pRealm))
  177.     {
  178. pRealm = new CHXBuffer();
  179. pRealm->AddRef();
  180. pRealm->Set((const unsigned char*)DEFAULTCREDENTIALENTRY, strlen(DEFAULTCREDENTIALENTRY)+1);
  181.     }
  182.     
  183.     Empty(pRealm);
  184.     if (HXR_OK == pValues->GetPropertyCString("Username", pUserName) && pUserName &&
  185. HXR_OK == pValues->GetPropertyCString("Password", pPassword) && pPassword)
  186.     {
  187. pCredentialEntry = new CredentialEntry((char*)pUserName->GetBuffer(),
  188.        (char*)pPassword->GetBuffer());
  189. m_credentialMap.SetAt((const char*)pRealm->GetBuffer(), (void*)pCredentialEntry);
  190.     }
  191. cleanup:
  192.     HX_RELEASE(pRealm);
  193.     HX_RELEASE(pUserName);
  194.     HX_RELEASE(pPassword);
  195.     return hr;
  196. }
  197. void
  198. CHXCredentialsCache::Close()
  199. {
  200.     CHXString key;
  201.     POSITION p;
  202.     CredentialEntry* pCredentialEntry = NULL;
  203.     
  204.     p = m_credentialMap.GetStartPosition();
  205.     while (p)
  206.     {
  207. m_credentialMap.GetNextAssoc(p, key, (void*&)pCredentialEntry);
  208. HX_DELETE(pCredentialEntry);
  209.     }
  210.     m_credentialMap.RemoveAll();
  211. }