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

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

Symbian

开发平台：

C/C++

cookies.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.  *                 Phil Dibowitz
  34.  *  
  35.  * ***** END LICENSE BLOCK ***** */ 
  37. #include "hxcom.h"
  38. #include "hxtypes.h"
  39. #include "hlxclib/string.h"
  40. // #include "hlxclib/stdio.h"
  41. #include "safestring.h"
  43. #ifdef _MACINTOSH
  44. #ifdef _CARBON
  45. #ifdef _MAC_MACHO
  46. #include <sys/stat.h>
  47. #else
  48. #include <stat.h>
  49. #endif
  50. #else /* _CARBON */
  51. #include <stat.mac.h>
  52. #endif /* _CARBON */
  53. #else /* _MACINTOSH */
  54. #include "hlxclib/sys/types.h"
  55. #include "hlxclib/sys/stat.h"
  56. #endif /* _MACINTOSH */
  58. #include "hlxclib/time.h"
  60. #if defined(_AIX)
  61. #include <ctype.h>
  62. #endif
  64. #ifdef _WINDOWS
  65. #include "hlxclib/windows.h"
  66. #include <wininet.h>
  67. #include "hlxclib/io.h"
  68. #endif /* _WINDOWS */
  70. #if defined(_CARBON) || defined(_MAC_MACHO)
  71. #include "hxver.h" // for HXVER_SDK_PRODUCT
  72. #endif
  74. #ifdef _CARBON
  75. #include "cfwrappers.h"
  76. #endif
  78. #include "hxresult.h"
  79. #include "hxslist.h"
  80. #include "chxpckts.h"
  81. #include "hxstrutl.h"
  82. #include "dbcs.h"
  83. #include "dllpath.h"
  84. #include "hxprefs.h"
  85. #include "hxthread.h"
  86. #include "ihxcookies.h"
  87. #include "cookhlpr.h"
  88. #include "ihxcookies2.h"
  89. #include "hxdate.h"
  90. #include "cookies.h"
  91. #include "md5.h"
  92. #include "filespecutils.h"
  94. #ifdef _UNIX
  95. #include <sys/types.h>
  96. #include <sys/stat.h>
  97. #endif
  99. #if defined (_UNIX) && !defined(_SUN) && !defined(_HPUX) && !defined(_IRIX) && !defined(_OSF1)
  100. #include <sys/file.h>
  101. #endif /* UNIX */
  103. #define RM_COOKIE_CAPTION "# Helix Cookie Filen# http://www.netscape.com/newsref/std/cookie_spec.htmln# This is a generated file!  Do not edit.nn"
  105. #ifdef _UNIX
  106. #  define RM_COOKIE_FILE_NAME "Cookies_6_0"
  107. #else
  108. #  define RM_COOKIE_FILE_NAME "cookies.txt"
  109. #endif
  111. /* We should really define it in a common header file */
  112. #if defined (_WINDOWS ) || defined (WIN32) || defined(_SYMBIAN)
  113. #define OS_SEPARATOR_CHAR '\'
  114. #define OS_SEPARATOR_STRING "\"
  115. #elif defined (_UNIX) || defined (_OPENWAVE)
  116. #define OS_SEPARATOR_CHAR '/'
  117. #define OS_SEPARATOR_STRING "/"
  118. #elif defined (_MACINTOSH)
  119. #define OS_SEPARATOR_CHAR ':'
  120. #define OS_SEPARATOR_STRING ":"
  121. #endif /* defined (_WINDOWS ) || defined (WIN32) */
  123. HXCookies::HXCookies(IUnknown* pContext, BOOL bMemoryOnly)
  124. : m_lRefCount(0)
  125. , m_bSaveCookies(FALSE)
  126. , m_bMemoryOnly(bMemoryOnly)
  127. , m_pNSCookiesPath(NULL)
  128. , m_pNSCookies(NULL)
  129. , m_pRMCookiesPath(NULL)
  130. , m_pRMCookies(NULL)
  131. , m_pCookiesHelper(NULL)
  132. , m_pPreferences(NULL)
  133. , m_bInitialized(FALSE)
  134. , m_lastModification(0)
  135. , m_pContext(NULL)
  136. #ifdef _WINDOWS
  137. , m_hLib(NULL)
  138. , m_pLock(NULL)
  139. , _pInternetSetCookie(NULL)
  140. , _pInternetGetCookie(NULL)
  141. #elif _UNIX
  142. , m_fileID(0)
  143. #endif /* _WINDOWS */
  144. {    
  145.     if (pContext)
  146.     {
  147. m_pContext = pContext;
  148. m_pContext->AddRef();
  149.     }
  150. }
  152. HXCookies::~HXCookies()
  153. {
  154.     Close();
  155. }
  157. STDMETHODIMP
  158. HXCookies::QueryInterface(REFIID riid, void**ppvObj)
  159. {
  160.     QInterfaceList qiList[] =
  161.     {
  162. { GET_IIDHANDLE(IID_IUnknown), this },
  163. { GET_IIDHANDLE(IID_IHXCookies), (IHXCookies*) this },
  164. { GET_IIDHANDLE(IID_IHXCookies2), (IHXCookies2*) this }
  165.     };
  167.     if (QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj) == HXR_OK)
  168.     {
  169.         return HXR_OK;
  170.     }
  171.     else if (IsEqualIID(riid, IID_IHXCookiesHelper) && m_pCookiesHelper)
  172.     {
  173. return m_pCookiesHelper->QueryInterface(riid, ppvObj);
  174.     }
  176.     *ppvObj = NULL;
  177.     return HXR_NOINTERFACE;
  178. }
  180. /////////////////////////////////////////////////////////////////////////
  181. //  Method:
  182. // IUnknown::AddRef
  183. //  Purpose:
  184. // Everyone usually implements this the same... feel free to use
  185. // this implementation.
  186. //
  187. STDMETHODIMP_(ULONG32) 
  188. HXCookies::AddRef()
  189. {
  190.     return InterlockedIncrement(&m_lRefCount);
  191. }
  193. /////////////////////////////////////////////////////////////////////////
  194. //  Method:
  195. // IUnknown::Release
  196. //  Purpose:
  197. // Everyone usually implements this the same... feel free to use
  198. // this implementation.
  199. //
  200. STDMETHODIMP_(ULONG32) 
  201. HXCookies::Release()
  202. {
  203.     if (InterlockedDecrement(&m_lRefCount) > 0)
  204.     {
  205.         return m_lRefCount;
  206.     }
  208.     delete this;
  209.     return 0;
  210. }
  212. HX_RESULT    
  213. HXCookies::Initialize(void)
  214. {
  215.     HX_RESULT hr = HXR_OK;
  216.     
  217.     if (!m_pContext || !IsCookieEnabled())
  218.     {
  219. hr = HXR_FAILED;
  220. goto cleanup;
  221.     }
  223.     m_pContext->QueryInterface(IID_IHXCookiesHelper, (void**) &m_pCookiesHelper);
  224.     if (!m_pCookiesHelper)
  225.     {
  226.         HXCookiesHelper* pHelper = new HXCookiesHelper();
  227.         if (pHelper)
  228. {
  229.             pHelper->QueryInterface(IID_IHXCookiesHelper, (void**) &m_pCookiesHelper);
  230. }
  231.     }
  233.     if (!m_bMemoryOnly)
  234.     {
  235. #ifdef _WINDOWS
  236.         if (m_hLib = LoadLibrary(OS_STRING("wininet.dll")))
  237. {
  238.             _pInternetSetCookie = (INTERNETSETCOOKIE)GetProcAddress(m_hLib, OS_STRING("InternetSetCookieA"));
  239.     _pInternetGetCookie = (INTERNETGETCOOKIE)GetProcAddress(m_hLib, OS_STRING("InternetGetCookieA"));
  240. }
  241. #endif /* _WINDOWS */
  243.         PrepareCookiesPath();
  245.         if (m_pNSCookiesPath)
  246. {
  247.     OpenCookies(m_pNSCookiesPath, FALSE, m_pNSCookies);
  248. }
  250.         if (m_pRMCookiesPath)
  251. {
  252.     OpenCookies(m_pRMCookiesPath, TRUE, m_pRMCookies);
  253.         }
  254.     }
  256.     m_bInitialized = TRUE;
  258. cleanup:
  260.     return hr;
  261. }
  263. void
  264. HXCookies::Close(void)
  265. {
  266.     if (m_bSaveCookies && !m_bMemoryOnly)
  267.     {
  268. SaveCookies();
  269.     }
  271.     ResetCookies(m_pNSCookies);
  272.     ResetCookies(m_pRMCookies);
  274.     HX_DELETE(m_pNSCookies);
  275.     HX_DELETE(m_pRMCookies);
  277.     HX_VECTOR_DELETE(m_pNSCookiesPath);
  278.     HX_VECTOR_DELETE(m_pRMCookiesPath);
  280.     HX_RELEASE(m_pPreferences);
  281.     HX_RELEASE(m_pCookiesHelper);
  282.     HX_RELEASE(m_pContext);
  284.     m_bInitialized = FALSE;
  286. #ifdef _WINDOWS
  287.     if (m_hLib)
  288.     {
  289. FreeLibrary(m_hLib);
  290. m_hLib = NULL;
  291.     }
  293.     HX_DELETE(m_pLock);
  294. #endif /* _WINDOWS */
  295. }
  297. STDMETHODIMP 
  298. HXCookies::SetCookies(const char* pHost, const char* pPath, IHXBuffer* pCookies)
  299. {
  300.     HX_RESULT     hr = HXR_OK;
  301.     int     host_length = 0;
  302.     int     path_length = 0;
  303.     int     domain_length = 0;
  304.     char*     pURL = NULL;
  305.     char*     path_from_header = NULL;
  306.     char*     domain_from_header = NULL;
  307.     char*     name_from_header = NULL;
  308.     char*     cookie_from_header = NULL;
  309.     char*     dot = NULL;
  310.     char*     slash = NULL;
  311.     BOOL     bIsDomain = FALSE;
  312.     time_t     expires=0;
  313.     IHXBuffer*     pBuffer = NULL;
  314.     IHXValues*     pValues = NULL;    
  315.     CookieStruct*   pNewCookie = NULL;
  316.     
  317.     if (!IsCookieEnabled())
  318.     {
  319. goto cleanup;
  320.     }
  322.     if (!m_bInitialized)
  323.     {
  324. hr = Initialize();
  326. if (HXR_OK != hr)
  327. {
  328.     goto cleanup;
  329. }
  330.     }
  332.     if (!m_pCookiesHelper || !pCookies || !pHost)
  333.     {
  334. hr = HXR_FAILED;
  335. goto cleanup;
  336.     }
  338.     if (HXR_OK != m_pCookiesHelper->Pack(pCookies, pValues))
  339.     {
  340. hr = HXR_FAILED;
  341. goto cleanup;
  342.     }
  344.     if (HXR_OK == pValues->GetPropertyBuffer("path", pBuffer) && pBuffer)
  345.     {
  346. ::StrAllocCopy(path_from_header, (char*)pBuffer->GetBuffer());
  347.     }
  348.     HX_RELEASE(pBuffer);
  350.     if (HXR_OK == pValues->GetPropertyBuffer("domain", pBuffer) && pBuffer)
  351.     {
  352.         // verify that this host has the authority to set for
  353.         // this domain.   We do this by making sure that the
  354.         // host is in the domain
  355.         // We also require that a domain have at least two
  356.         // periods to prevent domains of the form ".com"
  357.         // and ".edu"
  358. //
  359. // also make sure that there is more stuff after
  360. // the second dot to prevent ".com."
  361. ::StrAllocCopy(domain_from_header, (char*)pBuffer->GetBuffer());
  363.         dot = strchr(domain_from_header, '.');
  364.     
  365. if(dot)
  366. {
  367.             dot = strchr(dot+1, '.');
  368. }
  370. if(!dot || *(dot+1) == '') 
  371. {
  372.     // did not pass two dot test. FAIL
  373.     hr = HXR_FAILED;
  374.     goto cleanup;
  375. }
  377. domain_length = strlen(domain_from_header);
  378. host_length = strlen(pHost);
  380. // check to see if the host is in the domain
  381. if(domain_length > host_length || 
  382.    strcasecmp(domain_from_header, &pHost[host_length-domain_length]))
  383. {
  384.     hr = HXR_FAILED;
  385.     goto cleanup;
  386. }
  388. bIsDomain = TRUE;
  389.     }
  390.     HX_RELEASE(pBuffer);
  392.     if (HXR_OK == pValues->GetPropertyBuffer("name", pBuffer) && pBuffer)
  393.     {
  394. ::StrAllocCopy(name_from_header, (char*)pBuffer->GetBuffer());
  395.     }
  396.     HX_RELEASE(pBuffer);
  398.     if (HXR_OK == pValues->GetPropertyBuffer("value", pBuffer) && pBuffer)
  399.     {
  400. ::StrAllocCopy(cookie_from_header, (char*)pBuffer->GetBuffer());
  401.     }
  402.     HX_RELEASE(pBuffer);
  404.     if (HXR_OK == pValues->GetPropertyBuffer("expires", pBuffer) && pBuffer)
  405.     {
  406. expires = ::ParseDate((char*)pBuffer->GetBuffer());
  407.     }
  408.     HX_RELEASE(pBuffer);
  410.     if(!path_from_header && pPath)
  411.     {
  412.         // strip down everything after the last slash
  413.         // to get the path.
  414. CHXString strPath = pPath;
  415. INT32 nIndex = strPath.ReverseFind('/');
  417. if (nIndex != -1)
  418. {
  419.     strPath = strPath.Left(nIndex + 1);
  420. }
  422. ::StrAllocCopy(path_from_header, (char*) (const char*) strPath);
  423.     }
  425.     if(!domain_from_header && pHost)
  426.     {
  427. ::StrAllocCopy(domain_from_header, (char*)pHost); 
  428.     }
  429.     
  430.     m_bSaveCookies = TRUE;
  432.     // We have decided we are going to insert a cookie into the list
  433.     // Get the cookie lock so that we can munge on the list
  435.     pNewCookie = CheckForPrevCookie(path_from_header, 
  436.     domain_from_header, 
  437.     name_from_header);
  439.     if(pNewCookie) 
  440.     {
  441. HX_DELETE(pNewCookie->pCookieValue);
  442. HX_DELETE(pNewCookie->pCookieName);
  443. HX_DELETE(pNewCookie->pPath);
  444.         HX_DELETE(pNewCookie->pHost);
  445.         
  446. pNewCookie->pCookieValue = new CHXString(cookie_from_header);
  447. pNewCookie->pCookieName = new CHXString(name_from_header);
  448.         pNewCookie->pPath = new CHXString(path_from_header);
  449.         pNewCookie->pHost = new CHXString(domain_from_header);
  450.         pNewCookie->expires = expires;
  451.         pNewCookie->bIsDomain = bIsDomain;
  452. pNewCookie->bMemoryOnly = TRUE;
  453.     }
  454.     else 
  455.     {
  456. pNewCookie = new CookieStruct;
  458.         // copy
  459. pNewCookie->pCookieValue = new CHXString(cookie_from_header);
  460. pNewCookie->pCookieName = new CHXString(name_from_header);
  461.         pNewCookie->pPath = new CHXString(path_from_header);
  462.         pNewCookie->pHost = new CHXString(domain_from_header);
  463.         pNewCookie->expires = expires;
  464.         pNewCookie->bIsDomain = bIsDomain;
  465. pNewCookie->bMemoryOnly = TRUE;
  467. if (!m_pRMCookies)
  468. {
  469.     m_pRMCookies = new CHXSimpleList();
  470. }
  472. hr = AddCookie(pNewCookie, m_pRMCookies);
  473.     }
  475. #ifdef _WINDOWS
  476.     if (!m_bMemoryOnly)
  477.     {
  478.         if (!_pInternetSetCookie)
  479. {
  480.     goto cleanup;
  481. }
  483. host_length = strlen(pHost);
  485. if (pPath)
  486. {
  487.     path_length = strlen(pPath);
  488. }
  490. pURL = new char[host_length + path_length + 8];
  491. sprintf(pURL, "http://%s%s", pHost, pPath); /* Flawfinder: ignore */
  493. _pInternetSetCookie(pURL, NULL, (const char*)pCookies->GetBuffer());
  494.     }
  495. #endif /* _WINDOWS */
  497. cleanup:
  499.     HX_RELEASE(pBuffer);
  500.     HX_RELEASE(pValues);
  502.     HX_VECTOR_DELETE(pURL);
  503.     HX_VECTOR_DELETE(path_from_header);
  504.     HX_VECTOR_DELETE(domain_from_header);
  505.     HX_VECTOR_DELETE(name_from_header);
  506.     HX_VECTOR_DELETE(cookie_from_header);
  507.     
  508.     return hr;
  509. }
  511. STDMETHODIMP 
  512. HXCookies::GetCookies(const char* pHost, const char* pPath, REF(IHXBuffer*) pCookies)
  513. {
  514.     IHXBuffer* pPlayerCookies = NULL;
  515.     HX_RESULT res = GetCookiesInternal(pHost, pPath, pCookies, pPlayerCookies);
  516.     HX_RELEASE(pPlayerCookies);
  517.     return res;
  518. }
  520. STDMETHODIMP HXCookies::GetCookies(const char*     pHost,
  521.       const char*     pPath,
  522.       REF(IHXBuffer*)   pCookies,
  523.       REF(IHXBuffer*)   pPlayerCookies)
  524. {
  525.     return GetCookiesInternal(pHost, pPath, pCookies, pPlayerCookies);
  526. }
  529. #if defined(_CARBON) || defined(_MAC_MACH)
  530. #define REPORT_COOKIES 1
  531. #endif
  533. HX_RESULT HXCookies::GetCookiesInternal(const char* pHost,
  534.  const char*     pPath,
  535.  REF(IHXBuffer*)   pCookies,
  536.  REF(IHXBuffer*)   pPlayerCookies)
  537. {
  538.     HX_RESULT     hr = HXR_OK;
  539.     char*     cp = NULL;
  540.     char*     pComma = NULL;
  541.     char*     pEqualSign = NULL;
  542.     char*     pData = NULL;
  543.     char*     pURL = NULL;
  544.     int     l = 0;
  545.     int     host_length = 0;
  546.     int     path_length = 0;
  547.     BOOL     bAdded = FALSE;
  548. UINT32     dwSize = 0;    
  549.     time_t     cur_time = time(NULL);
  550.     CookieStruct*   pTempCookie = NULL;
  551.     CookieStruct*   pNewCookie = NULL;
  552.     CHXSimpleList*  pCookiesFound1 = NULL;
  553.     CHXSimpleList*  pCookiesFound2 = NULL;
  554.     CHXSimpleList*  pCookiesList = NULL;
  555.     IHXValues*     pValues = NULL;
  556.     CHXSimpleList::Iterator  i;
  557.     CHXString       cHostCopy;
  558.     INT32           lColon;
  559.     BOOL     bIsPlayerCookieList = FALSE;
  560.     CHXString     strPlayerCookies;
  561. #ifdef REPORT_COOKIES
  562.     CHXString strCookieReport;
  563. #endif
  564.     
  565.     pCookies = NULL;
  566.     pPlayerCookies = NULL;
  568.     if (!IsCookieEnabled())
  569.     {
  570. goto cleanup;
  571.     }
  573.     if (!m_bInitialized)
  574.     {
  575. hr = Initialize();
  577. if (HXR_OK != hr)
  578. {
  579.     goto cleanup;
  580. }
  581.     }
  582.     else
  583.     {
  584. SyncRMCookies(FALSE);
  585.     }
  587.     if (!pHost || !m_pCookiesHelper)
  588.     {
  589. hr = HXR_FAILED;
  590. goto cleanup;
  591.     }
  593.     // return string to build    
  594.     if (!(pValues = new CHXHeader()))
  595.     {
  596. hr = HXR_OUTOFMEMORY;
  597. goto cleanup;
  598.     }
  600.     pValues->AddRef();
  602.     cHostCopy = pHost;
  603.     lColon    = cHostCopy.Find(':');
  604.     if (lColon >= 0)
  605.     {
  606. cHostCopy = cHostCopy.Left(lColon);
  607.     }
  608.     cHostCopy.MakeLower();
  610.     // search for all cookies(Netscape only for now)
  611.     for (l = 0; l < 2; l++)
  612.     {
  613. switch (l)
  614. {
  615. case 0:
  616.     pCookiesList = m_pRMCookies;
  617.     bIsPlayerCookieList = TRUE;
  618.     break;
  619. case 1:
  620.     pCookiesList = m_pNSCookies;
  621.     bIsPlayerCookieList = FALSE;
  622.     break;
  623. default:
  624.     break;
  625. }
  627. if (!pCookiesList)
  628. {
  629.     continue;
  630. }
  632. for (i = pCookiesList->Begin(); i != pCookiesList->End(); ++i)
  633. {
  634.     pTempCookie = (CookieStruct*) (*i);
  635.     
  636.     if (!pTempCookie->pHost)
  637.     {
  638. continue;
  639.     }
  640.     
  641.     // check the host or domain first
  642.     if(pTempCookie->bIsDomain)
  643.     {
  644. if (!DoesDomainMatch(*pTempCookie->pHost, cHostCopy))
  645. {
  646.     continue;
  647. }
  648.     }
  649.     else if(strcasecmp((const char*)*(pTempCookie->pHost), pHost))
  650.     {
  651. // hostname matchup failed.
  652. continue;
  653.     }
  655.     // shorter strings always come last so there can be no
  656.     // ambiquity             
  657.     if(pTempCookie->pPath && 
  658.        !strncmp(pPath, (const char*)*(pTempCookie->pPath), pTempCookie->pPath->GetLength()))
  659.     {
  660. // check for expired cookies
  661. if(pTempCookie->expires && (pTempCookie->expires < cur_time))
  662. {
  663.     m_bSaveCookies = TRUE;
  664.     continue;
  665. }
  667. if (!pCookiesFound1)
  668. {
  669.     pCookiesFound1 = new CHXSimpleList();
  670.     pCookiesFound1->AddTail(pTempCookie);
  671. }
  672. else if (!WasCookieAdded(pCookiesFound1, pTempCookie))
  673. {
  674.     pCookiesFound1->AddTail(pTempCookie);
  675. }
  676. if(bIsPlayerCookieList)
  677. {
  678.     if(!strPlayerCookies.IsEmpty())
  679.     {
  680.         strPlayerCookies += "|";
  681.     }
  682.     strPlayerCookies += *pTempCookie->pCookieName;
  683. #ifdef REPORT_COOKIES
  684.     strCookieReport += (strCookieReport.IsEmpty() ? "" : ", ");
  685.     strCookieReport += *pTempCookie->pCookieName;
  686.     strCookieReport += "=";
  687.     strCookieReport += *pTempCookie->pCookieValue;
  688. #endif
  689. }
  690.     }
  691. }
  692.     }
  694. #ifdef _WINDOWS
  695.     if (!_pInternetGetCookie || m_bMemoryOnly)
  696.     {
  697. goto cleanup;
  698.     }
  700.     host_length = strlen(pHost);
  702.     if (pPath)
  703.     {
  704. path_length = strlen(pPath);
  705.     }
  707.     pURL = new char[host_length + path_length + 8];
  708.     sprintf(pURL, "http://%s%s", pHost, pPath); /* Flawfinder: ignore */
  710.     if (_pInternetGetCookie(pURL, NULL, pData, &dwSize) && !pData && dwSize)
  711.     {
  712. pData = new char[dwSize+1];
  714. if (!_pInternetGetCookie(pURL, NULL, pData, &dwSize))
  715. {
  716.     goto cleanup;
  717. }
  719. cp = pData;
  721. while (pComma = (char*) ::HXFindChar(cp, ';'))
  722. {
  723.     *pComma = '';
  724.     pComma++;
  726.     if (pEqualSign = (char*) ::HXFindChar(cp, '='))
  727.     {
  728. *pEqualSign = '';
  729. pEqualSign++;
  731.          pNewCookie = new CookieStruct;
  732. bAdded = FALSE;
  734. // copy
  735. pNewCookie->pCookieValue = new CHXString(pEqualSign);
  736. pNewCookie->pCookieName = new CHXString(cp);
  737. pNewCookie->pPath = new CHXString(pPath);
  738. pNewCookie->pHost = new CHXString(pHost);
  739. pNewCookie->expires = 0;
  740. pNewCookie->bIsDomain = FALSE;
  741. pNewCookie->bMemoryOnly = FALSE;
  743. if(pNewCookie->pCookieName)
  744. {
  745.     pNewCookie->pCookieName->TrimLeft();
  746.     pNewCookie->pCookieName->TrimRight();
  747. }
  749. if (!WasCookieAdded(pCookiesFound1, pNewCookie))
  750. {
  751.     if (!pCookiesFound2)
  752.     {
  753. pCookiesFound2 = new CHXSimpleList();
  754. pCookiesFound2->AddTail(pNewCookie);
  755. bAdded = TRUE;
  756.     }
  757.     else if (!WasCookieAdded(pCookiesFound2, pNewCookie))
  758.     {
  759. pCookiesFound2->AddTail(pNewCookie);
  760. bAdded = TRUE;
  761.     }
  762. }
  764. if (!bAdded)
  765. {
  766.     HX_DELETE(pNewCookie);
  767. }
  768.     }
  770.     cp = pComma;
  771. }
  773. if (pEqualSign = (char*) ::HXFindChar(cp, '='))
  774. {
  775.     *pEqualSign = '';
  776.     pEqualSign++;
  778.     pNewCookie = new CookieStruct;
  779.     bAdded = FALSE;
  781.     // copy
  782.     pNewCookie->pCookieValue = new CHXString(pEqualSign);
  783.     pNewCookie->pCookieName = new CHXString(cp);
  784.     pNewCookie->pPath = NULL;
  785.     pNewCookie->pHost = NULL;
  786.     pNewCookie->expires = 0;
  787.     pNewCookie->bIsDomain = FALSE;
  788.     pNewCookie->bMemoryOnly = FALSE;
  790.     if(pNewCookie->pCookieName)
  791.     {
  792.         pNewCookie->pCookieName->TrimLeft();
  793.         pNewCookie->pCookieName->TrimRight();
  794.     }
  796.     if (!WasCookieAdded(pCookiesFound1, pNewCookie))
  797.     {
  798. if (!pCookiesFound2)
  799. {
  800.     pCookiesFound2 = new CHXSimpleList();
  801.     pCookiesFound2->AddTail(pNewCookie);
  802.     bAdded = TRUE;
  803. }
  804. else if (!WasCookieAdded(pCookiesFound2, pNewCookie))
  805. {
  806.     pCookiesFound2->AddTail(pNewCookie);
  807.     bAdded = TRUE;
  808. }
  809.     }
  811.     if (!bAdded)
  812.     {
  813. HX_DELETE(pNewCookie);
  814.     }
  815. }
  816.     }
  817. #endif /* _WINDOWS */
  819. cleanup:
  821.     if (pCookiesFound1)
  822.     {
  823. for (i = pCookiesFound1->Begin(); i != pCookiesFound1->End(); ++i)
  824. {
  825.     pTempCookie = (CookieStruct*) (*i);
  827.     if(pTempCookie->pCookieName && pTempCookie->pCookieValue)
  828.     {
  829. ::SaveStringToHeader(pValues,
  830.      (const char*)*(pTempCookie->pCookieName),
  831.      (char*)(const char*)*(pTempCookie->pCookieValue));
  832.     }
  833. }
  834.     }
  836.     if (pCookiesFound2)
  837.     {
  838. for (i = pCookiesFound2->Begin(); i != pCookiesFound2->End(); ++i)
  839. {
  840.     pTempCookie = (CookieStruct*) (*i);
  842.     if(pTempCookie->pCookieName && pTempCookie->pCookieValue)
  843.     {
  844. ::SaveStringToHeader(pValues,
  845.      (const char*)*(pTempCookie->pCookieName),
  846.      (char*)(const char*)*(pTempCookie->pCookieValue));
  847.     }
  849.     HX_DELETE(pTempCookie);
  850. }
  851.     }
  853.     if (m_pCookiesHelper)
  854.     {
  855. hr = m_pCookiesHelper->UnPack(pValues, pCookies);
  856.     }
  858. #ifdef REPORT_COOKIES
  859.     IHXBuffer* pBuff = NULL;
  860.     if (m_pPreferences
  861. && m_pPreferences->ReadPref("CookieData", pBuff) == HXR_OK
  862. && 0 == stricmp((const char*)pBuff->GetBuffer(), "console"))
  863.     {
  864. CHXString str;
  865. str.Format("Cookies requested, getting host: %s  path: %s  cookies: %s",
  866. pHost, pPath, 
  867. strCookieReport.IsEmpty() ? "<no player cookies>" : (const char *) strCookieReport);
  868. ::CFShow(CHXCFString(str));
  869.     }
  870.     HX_RELEASE(pBuff);
  871. #endif
  873.     if(!strPlayerCookies.IsEmpty())
  874.     {
  875. pPlayerCookies = new CHXBuffer;
  876. pPlayerCookies->AddRef();
  877. pPlayerCookies->Set((const UCHAR*)(const char*)strPlayerCookies, strPlayerCookies.GetLength() + 1);
  878.     }
  880.     HX_DELETE(pCookiesFound1);
  881.     HX_DELETE(pCookiesFound2);
  882.     HX_VECTOR_DELETE(pData);
  883.     HX_VECTOR_DELETE(pURL);
  885.     HX_RELEASE(pValues);
  886.    
  887.     return hr;
  888. }
  890. HX_RESULT     
  891. HXCookies::PrepareCookiesPath(void)
  892. {
  893.     HX_RESULT hr = HXR_OK;
  894. #ifndef _VXWORKS
  895.     const char* pRMCookiesPath = NULL;
  896.     IHXBuffer* pBuffer = NULL;
  898. #if !defined(_CARBON) && !defined(_MAC_MACHO) /* figured out every time at runtime on the Mac since paths are not stable between runs */
  899.     if (m_pPreferences && (m_pPreferences->ReadPref("CookiesPath", pBuffer) == HXR_OK))
  900.     {
  901. m_pRMCookiesPath = new char[pBuffer->GetSize() + 1];
  902. strcpy(m_pRMCookiesPath, (const char*)pBuffer->GetBuffer()); /* Flawfinder: ignore */
  903.     }
  904.     HX_RELEASE(pBuffer);
  905. #endif
  907.     if( !m_pRMCookiesPath )
  908.     {
  909. if (m_pPreferences && (m_pPreferences->ReadPref("UserSDKDataPath", pBuffer) == HXR_OK))
  910. {
  911.     pRMCookiesPath = (char*) pBuffer->GetBuffer();
  912. }
  913. else
  914. {
  915. #if defined(_CARBON) || defined(_MAC_MACHO)
  916. CHXString strSDKPath = CHXFileSpecUtils::GetAppDataDir(HXVER_SDK_PRODUCT).GetPathName();
  917. #elif defined(_UNIX)
  918.     pRMCookiesPath = getenv("HOME");
  919.     HX_ASSERT( pRMCookiesPath );     
  920. #else
  921.     pRMCookiesPath = GetDLLAccessPath()->GetPath(DLLTYPE_COMMON);
  922. #endif        
  923. }
  925.         if( pRMCookiesPath )
  926.         {
  927.         
  928.             m_pRMCookiesPath = new char[strlen(pRMCookiesPath) + strlen(RM_COOKIE_FILE_NAME)+2];
  929.     ::strcpy(m_pRMCookiesPath, pRMCookiesPath); /* Flawfinder: ignore */
  930.     if (m_pRMCookiesPath[::strlen(m_pRMCookiesPath)-1] != OS_SEPARATOR_CHAR)
  931.     {
  932. strcat(m_pRMCookiesPath, OS_SEPARATOR_STRING); /* Flawfinder: ignore */
  933.     }
  935.     strcat(m_pRMCookiesPath, RM_COOKIE_FILE_NAME); /* Flawfinder: ignore */
  936.             
  937.     HX_RELEASE(pBuffer);
  938.             pBuffer = new CHXBuffer();
  939.             pBuffer->AddRef();
  940.             
  941.             pBuffer->Set((const unsigned char*)m_pRMCookiesPath, strlen(m_pRMCookiesPath) + 1);    
  942.             
  943.             if (m_pPreferences)
  944.             {
  945.                 m_pPreferences->WritePref("CookiesPath", pBuffer);
  946.             }
  948.             HX_RELEASE(pBuffer);
  949.         }
  950.    }
  951. #endif
  953. #ifdef _WINDOWS
  954.     HKEY    hMainAppKey = NULL;
  955.     HKEY    hBiffKey = NULL;
  956.     HKEY    hUsersKey = NULL;
  957.     HKEY    hServersKey = NULL;
  958.     HKEY    hCookiesKey = NULL;
  959.     INT32   lSize = _MAX_PATH - 1;
  960.     UINT32  ulSize = _MAX_PATH - 1;
  961.     UINT32  ulType = 0;
  962.     char    regKey[_MAX_PATH] = {0}; /* Flawfinder: ignore */
  963.     char*   pPath = NULL;
  964.     char*   pUser = NULL;
  965.     char*   pValue = NULL;
  966.     char*   pCursor = NULL;
  968.     // Netscape Browser 4.0+
  969.     if (RegOpenKeyEx(HKEY_CURRENT_USER, 
  970.      OS_STRING("Software\Netscape\Netscape Navigator\biff"), 
  971.      0,
  972.      KEY_READ, &hBiffKey) == ERROR_SUCCESS) 
  973.     {
  974. pUser = new char[_MAX_PATH];
  975. memset(pUser, 0, _MAX_PATH);
  977. if (RegQueryValueEx(hBiffKey, OS_STRING("CurrentUser"), 0, &ulType, (LPBYTE)pUser, &ulSize) == ERROR_SUCCESS) 
  978. {
  979.     SafeSprintf(regKey, _MAX_PATH, "Software\Netscape\Netscape Navigator\biff\users\%s", pUser);
  980.     
  981.     if (RegOpenKeyEx(HKEY_CURRENT_USER, OS_STRING(regKey), 0, KEY_READ, &hUsersKey) == ERROR_SUCCESS)
  982.     {
  983. pValue = new char[_MAX_PATH];
  984. memset(pValue, 0, _MAX_PATH);
  986. ulSize = _MAX_PATH - 1;
  987. if (RegQueryValueEx(hUsersKey, OS_STRING("defaultServer"), 0, &ulType, (LPBYTE)pValue, &ulSize) == ERROR_SUCCESS)
  988. {
  989.     SafeSprintf(regKey, _MAX_PATH, "Software\Netscape\Netscape Navigator\biff\users\%s\servers\%s",
  990.     pUser, pValue);
  992.     if (RegOpenKeyEx(HKEY_CURRENT_USER, OS_STRING(regKey), 0, KEY_READ, &hServersKey) == ERROR_SUCCESS)
  993.     {
  994. pPath = new char[_MAX_PATH];
  995. memset(pPath, 0, _MAX_PATH);
  997. ulSize = _MAX_PATH - 1;
  998. if (RegQueryValueEx(hServersKey, OS_STRING("popstatePath"), 0, &ulType, (LPBYTE)pPath, &ulSize) == ERROR_SUCCESS)
  999. {
  1000.     // pPath ="..mailpopstate.dat"
  1001.     // the actual location of cookies is 1 level up
  1002.     if (pCursor = ::HXReverseFindChar(pPath, '\'))
  1003.     {
  1004. *pCursor = '';
  1005.     
  1006. if (pCursor = ::HXReverseFindChar(pPath, '\'))
  1007. {
  1008.     *pCursor = '';
  1010.     m_pNSCookiesPath = new char[strlen(pPath) + 13];
  1011.     sprintf(m_pNSCookiesPath, "%s\%s", pPath, RM_COOKIE_FILE_NAME); /* Flawfinder: ignore */
  1012.     goto cleanup;
  1013. }
  1014.     }
  1015. }
  1016.     }
  1017. }
  1018.     }
  1019. }
  1020.     }
  1022.     // Netscape Browser 3.0+
  1023.     if (RegOpenKeyEx(HKEY_CURRENT_USER, OS_STRING("Software\Netscape\Netscape Navigator\Cookies"), 0,
  1024. KEY_READ, &hCookiesKey) == ERROR_SUCCESS) 
  1025.     {
  1026. HX_VECTOR_DELETE(pPath);
  1027. pPath = new char[_MAX_PATH];
  1028. memset(pPath, 0, _MAX_PATH);
  1030. ulSize = _MAX_PATH - 1;
  1031. if (RegQueryValueEx(hCookiesKey, OS_STRING("Cookie File"), 0, &ulType, (LPBYTE)pPath, &ulSize) == ERROR_SUCCESS)
  1032. {
  1033.     m_pNSCookiesPath = new char[strlen(pPath) + 1];
  1034.     strcpy(m_pNSCookiesPath, pPath); /* Flawfinder: ignore */
  1035. }
  1036.     }
  1038. cleanup:
  1040.     HX_RELEASE(pBuffer);
  1042.     if (hMainAppKey)
  1043.     {
  1044. RegCloseKey(hMainAppKey);
  1045.     }
  1047.     if (hBiffKey)
  1048.     {
  1049. RegCloseKey(hBiffKey);
  1050.     }
  1052.     if (hUsersKey)
  1053.     {
  1054. RegCloseKey(hUsersKey);
  1055.     }
  1057.     if (hServersKey)
  1058.     {
  1059. RegCloseKey(hServersKey);
  1060.     }
  1062.     if (hCookiesKey)
  1063.     {
  1064. RegCloseKey(hCookiesKey);
  1065.     }
  1067.     HX_VECTOR_DELETE(pUser);
  1068.     HX_VECTOR_DELETE(pPath);
  1069.     HX_VECTOR_DELETE(pValue);    
  1070. #endif /* _WINDOWS */
  1072.     return hr;
  1073. }
  1075. void
  1076. HXCookies::ResetCookies(CHXSimpleList* pCookieList)
  1077. {
  1078.     CookieStruct*   pCookie = NULL;
  1080.     while (pCookieList && pCookieList->GetCount() > 0)
  1081.     {
  1082. pCookie = (CookieStruct*) pCookieList->RemoveHead();
  1083. HX_DELETE(pCookie);
  1084.     }
  1085. }
  1087. HX_RESULT
  1088. HXCookies::FileReadLine(FILE* fp, char* pLine, UINT32 ulLineBuf, UINT32* pBytesRead)
  1089. {
  1090. #ifdef _OPENWAVE
  1091.     return HXR_NOTIMPL;
  1092. #else
  1093.     HX_RESULT hr = HXR_OK;
  1094.     UINT32 i = 0;
  1095.     UINT32 ulBytesRead = 0;
  1096.     char* pTmpBuf = NULL;
  1098.     if (!fp)
  1099.     {
  1100. hr = HXR_FAILED;
  1101. goto cleanup;
  1102.     }
  1104.     if (ulLineBuf < 1) 
  1105.     {
  1106.         *pBytesRead = 0;
  1107.         goto cleanup;
  1108.     }
  1110.     ulBytesRead = fread(pLine, sizeof(char), ulLineBuf, fp);
  1111.     pTmpBuf = pLine;
  1113.     if (ulBytesRead)
  1114.     {
  1115. while (i < ulBytesRead) 
  1116. {
  1117. #ifdef _MACINTOSH
  1118.     if (pTmpBuf[i] == 10 || pTmpBuf[i] == 13)
  1119. #else
  1120.     if (pTmpBuf[i] == 10)
  1121. #endif
  1122.     {   // LF
  1123. if (pTmpBuf[i+1])
  1124. {
  1125.     pTmpBuf[i+1] = '';
  1126. }
  1128. // Back the file pointer up.
  1129. fseek(fp, (long)((i + 1) - ulBytesRead), SEEK_CUR);
  1130. *pBytesRead = i + 1;
  1131. break;
  1132.     }
  1133.     i++;
  1134. }
  1135.     }
  1136.     else
  1137.     {
  1138. hr = HXR_FAILED;
  1139.     }
  1140.     
  1141. cleanup:
  1143.     return hr;
  1144. #endif /* _OPENWAVE */
  1145. }
  1147. CookieStruct*
  1148. HXCookies::CheckForPrevCookie(char * path,
  1149.        char * hostname,
  1150.        char * name)
  1151. {
  1152.     int     nResult = 0;
  1153.     const char*     pValue = NULL;
  1154.     BOOL     bFound = FALSE;
  1155.     CookieStruct*   pCookie = NULL;
  1156.     CHXSimpleList::Iterator  i;
  1158.     if (!m_pRMCookies)
  1159.     {
  1160. goto cleanup;
  1161.     }
  1163.     for (i = m_pRMCookies->Begin(); i != m_pRMCookies->End(); ++i)
  1164.     {
  1165. pCookie = (CookieStruct*) (*i);
  1167.         if(path && hostname && 
  1168.    pCookie->pPath && 
  1169.    pCookie->pHost && 
  1170.    pCookie->pCookieName &&
  1171.    !pCookie->pCookieName->Compare(name) &&
  1172.    !pCookie->pPath->Compare(path) &&     
  1173.    !pCookie->pHost->CompareNoCase(hostname))
  1174. {
  1175.             bFound = TRUE;
  1176.     break;
  1177. }
  1178.     }
  1180. cleanup:    
  1181.     return bFound?pCookie:NULL;
  1182. }
  1184. HX_RESULT
  1185. HXCookies::OpenCookies(char* pCookieFile, BOOL bRMCookies, CHXSimpleList*& pCookiesList)
  1186. {
  1187. #ifdef _OPENWAVE
  1188.     return HXR_NOTIMPL;
  1189. #else
  1190.     HX_RESULT     hr = HXR_OK;
  1191.     char*     pHost = NULL;
  1192.     char*     pPath = NULL;
  1193.     char*     pCookieName = NULL; 
  1194.     char*     pCookieValue = NULL;
  1195.     char*     pIsDomain = NULL;
  1196.     char*     pXXX = NULL;
  1197.     char*     pExpires = NULL;
  1198.     char*     pBuffer = new char[LINE_BUFFER_SIZE]; /* Flawfinder: ignore */
  1199.     UINT32     ulBytesRead = 0;
  1200.     FILE*     fp = NULL;
  1201.     CookieStruct*   pNewCookie = NULL;
  1202.  
  1203.     pCookiesList = NULL;
  1205.     if (!pBuffer)
  1206.     {
  1207. hr = HXR_FAILED;
  1208. goto cleanup;
  1209.     }
  1211.     pBuffer[0] = '';
  1213.     if (!pCookieFile)
  1214.     {
  1215. hr = HXR_FAILED;
  1216. goto cleanup;
  1217.     }
  1219. #ifdef _WINDOWS
  1220.     if (bRMCookies)
  1221.     {
  1222. if (!m_pLock)
  1223. {
  1224. #ifdef THREADS_SUPPORTED            
  1225.     HXEvent::MakeEvent(m_pLock, "CookieFileLock", FALSE);
  1226. #else            
  1227.     HXEvent::MakeStubEvent(m_pLock, "CookieFileLock", FALSE);
  1228. #endif            
  1229. }
  1230. else
  1231. {
  1232.     m_pLock->Wait();
  1233. }
  1234.     }
  1235. #endif /* _WINDOWS */
  1237.     if (bRMCookies)
  1238.     {
  1239. if(CheckCookies() == HXR_FAIL)
  1240. {
  1241.           hr = HXR_FAILED;
  1242.     goto cleanup;
  1243. }
  1244.     }
  1246.     if (!(fp = fopen(pCookieFile, "r+b")))
  1247.     {
  1248. hr = HXR_FAILED;
  1249. goto cleanup;
  1250.     }
  1252. #if defined (_UNIX) && !defined(_SUN) && !defined(_HPUX) && !defined(_IRIX) && !defined(_AIX) && !defined(_OSF1)
  1253.     if (bRMCookies)
  1254.     {
  1255. m_fileID = fileno(fp);    
  1256. flock(m_fileID, LOCK_EX);
  1257.     }
  1258. #endif /* _UNIX */
  1260.     /* format is:
  1261.      *
  1262.      * host t is_domain t path t xxx t expires t name t cookie
  1263.      *
  1264.      * if this format isn't respected we move onto the next line in the file.
  1265.      *
  1266.      * is_domain is TRUE or FALSE   -- defaulting to FALSE
  1267.      * xxx is TRUE or FALSE     -- should default to TRUE
  1268.      * expires is a time_t integer
  1269.      * cookie can have tabs
  1270.      */
  1271.     while(HXR_OK == FileReadLine(fp, &pBuffer[0], LINE_BUFFER_SIZE, &ulBytesRead))
  1272.     {
  1273. if (*pBuffer == '#' || *pBuffer == CR || *pBuffer == LF || *pBuffer == 0)
  1274. {
  1275.     continue;
  1276. }
  1278. pHost = pBuffer;
  1279.     
  1280. if(!(pIsDomain = strchr(pHost, 't')))
  1281. {
  1282.     continue;
  1283. }
  1284. *pIsDomain++ = '';
  1285. if(*pIsDomain == CR || *pIsDomain == LF || *pIsDomain == 0)
  1286. {
  1287.     continue;
  1288. }
  1290. if(!(pPath = strchr(pIsDomain, 't')))
  1291. {
  1292.     continue;
  1293. }
  1294. *pPath++ = '';
  1295. if(*pPath == CR || *pPath == LF || *pPath == 0)
  1296. {
  1297.     continue;
  1298. }
  1300. if(!(pXXX = strchr(pPath, 't')))
  1301. {
  1302.     continue;
  1303. }
  1304. *pXXX++ = '';
  1305. if(*pXXX == CR || *pXXX == LF || *pXXX == 0)
  1306. {
  1307.     continue;
  1308. }
  1310. if(!(pExpires = strchr(pXXX, 't')))
  1311. {
  1312.     continue;
  1313. }
  1314. *pExpires++ = '';
  1315. if(*pExpires == CR || *pExpires == LF || *pExpires == 0)
  1316. {
  1317.     continue;
  1318. }
  1320. if(!(pCookieName = strchr(pExpires, 't')))
  1321. {
  1322.     continue;
  1323. }
  1324. *pCookieName++ = '';
  1325. if(*pCookieName == CR || *pCookieName == LF || *pCookieName == 0)
  1326. {
  1327.     continue;
  1328. }
  1330. if(!(pCookieValue = strchr(pCookieName, 't')))
  1331. {
  1332.     continue;
  1333. }
  1334. *pCookieValue++ = '';
  1335. if(*pCookieValue == CR || *pCookieValue == LF || *pCookieValue == 0)
  1336. {
  1337.     continue;
  1338. }
  1340. // remove the 'n' from the end of the cookie
  1341. pCookieValue = ::StripLine(pCookieValue);
  1343. // construct a new cookie_struct
  1344. pNewCookie = new CookieStruct;
  1345. if(!pNewCookie)
  1346. {
  1347.     hr = HXR_OUTOFMEMORY;
  1348.     goto cleanup;
  1349. }
  1351. memset(pNewCookie, 0, sizeof(CookieStruct));
  1353. /* copy
  1354.  */
  1355. pNewCookie->pCookieValue = new CHXString(pCookieValue);
  1356. pNewCookie->pCookieName = new CHXString(pCookieName);
  1357. pNewCookie->pPath = new CHXString(pPath);
  1358. pNewCookie->pHost = new CHXString(pHost);
  1360. #ifdef _MACINTOSH
  1361. pNewCookie->expires = (time_t)atoi64(pExpires);
  1362. #else
  1363. pNewCookie->expires = atol(pExpires);
  1364. #endif
  1366. if(!strcasecmp(pIsDomain, "TRUE"))
  1367. {
  1368.     pNewCookie->bIsDomain = TRUE;
  1369. }
  1370. else
  1371. {
  1372.     pNewCookie->bIsDomain = FALSE;
  1373. }
  1375. pNewCookie->bMemoryOnly = FALSE;
  1377. if (!pCookiesList)
  1378. {
  1379.     pCookiesList = new CHXSimpleList();
  1380. }
  1382. hr = AddCookie(pNewCookie, pCookiesList);
  1383.     }
  1385.     UpdateModificationTime();
  1387. cleanup:
  1389. #if defined (_UNIX) && !defined(_SUN) && !defined(_HPUX) && !defined(_IRIX) && !defined(_AIX) && !defined(_OSF1)
  1390.     if (bRMCookies)
  1391.     {
  1392. flock(m_fileID, LOCK_UN);
  1393.     }
  1394. #endif /* _UNIX */
  1396.     if (fp)
  1397.     {
  1398. fclose(fp);
  1399.     }
  1401. #ifdef _WINDOWS
  1402.     if (bRMCookies && m_pLock)
  1403.     {
  1404. m_pLock->SignalEvent();
  1405.     }
  1406. #endif /* _WINDOWS */
  1408.     delete [] pBuffer;
  1409.     
  1410.     return hr;
  1411. #endif /* _OPENWAVE */
  1412. }
  1414. HX_RESULT
  1415. HXCookies::SaveCookies(void)
  1416. {
  1417. #ifdef _OPENWAVE
  1418.     return HXR_NOTIMPL;
  1419. #else
  1420.     HX_RESULT     hr = HXR_OK;
  1421.     FILE*     fp = NULL;
  1422.     INT32     len = 0;
  1423.     char     date_string[36] = {0}; /* Flawfinder: ignore */
  1424.     time_t     cur_date = time(NULL);
  1425.     CookieStruct*   pTempCookie = NULL;
  1426.     CHXSimpleList::Iterator  i;
  1428.     if (!m_pRMCookies || !m_pRMCookiesPath)
  1429.     {
  1430. goto cleanup;
  1431.     }
  1433. #ifdef _WINDOWS
  1434.     if (!m_pLock)
  1435.     {
  1436. #ifdef THREADS_SUPPORTED        
  1437. HXEvent::MakeEvent(m_pLock, "CookieFileLock", FALSE);
  1438. #else        
  1439. HXEvent::MakeStubEvent(m_pLock, "CookieFileLock", FALSE);
  1440. #endif
  1441.     }
  1442.     else
  1443.     {
  1444. m_pLock->Wait();
  1445.     }
  1446. #endif /* _WINDOWS */
  1448.     if (!(fp = fopen(m_pRMCookiesPath, "w")))
  1449.     {
  1450. hr = HXR_FAILED;
  1451. goto cleanup;
  1452.     }
  1454. #ifdef _UNIX
  1455.     //Make the permisions on the cookies file User read/write only.
  1456.     if( chmod( m_pRMCookiesPath, S_IRUSR | S_IWUSR ) != 0 )
  1457.     {
  1458.         HX_ASSERT( "Can't change permision on cookies file." == NULL );
  1459.     }
  1460.     
  1461. #endif    
  1463. #if defined (_UNIX) && !defined(_SUN) && !defined(_HPUX) && !defined(_IRIX) && !defined(_AIX) && !defined(_OSF1)
  1464.     m_fileID = fileno(fp);    
  1465.     flock(m_fileID, LOCK_EX);
  1466. #endif /* _UNIX */
  1468.     fwrite(RM_COOKIE_CAPTION, sizeof(char), strlen(RM_COOKIE_CAPTION), fp);
  1470.     for (i = m_pRMCookies->Begin(); i != m_pRMCookies->End(); ++i)
  1471.     {
  1472. pTempCookie = (CookieStruct*) (*i);
  1474. /* format shall be:
  1475.    *
  1476.  * host t is_domain t path t secure t expires t name t cookie
  1477.  *
  1478.  * is_domain is TRUE or FALSE
  1479.  * secure is TRUE or FALSE  
  1480.  * expires is a time_t integer
  1481.  * cookie can have tabs
  1482.  */
  1483. if(pTempCookie->expires < cur_date)
  1484. {
  1485.     continue;  /* don't write entry if cookie has expired 
  1486. * or has no expiration date
  1487. */
  1488. }
  1490. len = fwrite((const char*)*(pTempCookie->pHost), sizeof(char), pTempCookie->pHost->GetLength(), fp);
  1491. if (len < 0)
  1492. {
  1493.     hr = HXR_FAILED;
  1494.     goto cleanup;
  1495. }
  1496. fwrite("t", sizeof(char), 1, fp);
  1498. if(pTempCookie->bIsDomain)
  1499. {
  1500.     fwrite("TRUE", sizeof(char), 4, fp);
  1501. }
  1502. else
  1503. {
  1504.     fwrite("FALSE", sizeof(char), 5, fp);
  1505. }     
  1506. fwrite("t", sizeof(char), 1, fp);
  1508. fwrite((const char*)*(pTempCookie->pPath), sizeof(char), pTempCookie->pPath->GetLength(), fp);
  1509. fwrite("t", sizeof(char), 1, fp);
  1511. fwrite("FALSE", sizeof(char), 5, fp);
  1512. fwrite("t", sizeof(char), 1, fp);
  1514. sprintf(date_string, "%lu", pTempCookie->expires); /* Flawfinder: ignore */
  1515. fwrite(date_string, sizeof(char), strlen(date_string), fp);
  1516. fwrite("t", sizeof(char), 1, fp);
  1518. fwrite((const char*)*(pTempCookie->pCookieName), sizeof(char), 
  1519. pTempCookie->pCookieName->GetLength(), fp);
  1520. fwrite("t", sizeof(char), 1, fp);
  1522. fwrite((const char*)*(pTempCookie->pCookieValue), sizeof(char), 
  1523. pTempCookie->pCookieValue->GetLength(), fp);
  1524. fwrite(LINEBREAK, sizeof(char), LINEBREAK_LEN, fp);
  1526. //once saved to disk, make sure the memory only flag is false
  1527. pTempCookie->bMemoryOnly = FALSE;
  1528.     }
  1530.     UpdateModificationTime();    
  1531.     m_bSaveCookies = FALSE;
  1533. cleanup:
  1535. #if defined (_UNIX) && !defined(_SUN) && !defined(_HPUX) && !defined(_IRIX) && !defined(_AIX) && !defined(_OSF1)
  1536.     flock(m_fileID, LOCK_UN);
  1537. #endif /* _UNIX */
  1539.     if (fp)
  1540.     {
  1541. fclose(fp);
  1542.     }
  1544. #ifdef _WINDOWS
  1545.     if (m_pLock)
  1546.     {
  1547. m_pLock->SignalEvent();
  1548.     }
  1549. #endif /* _WINDOWS */
  1551.     SecureCookies();
  1553.     return(hr);
  1554. #endif /* _OPENWAVE */
  1555. }
  1557. HX_RESULT
  1558. HXCookies::AddCookie(CookieStruct* pCookie, CHXSimpleList*& pCookiesList)
  1559. {
  1560.     HX_RESULT     hr = HXR_OK;
  1561.     BOOL     bShorterPathFound = FALSE;
  1562.     CookieStruct*   pTempCookie = NULL;
  1563.     LISTPOSITION    position;
  1565.     if (!pCookie || !pCookiesList)
  1566.     {
  1567. hr = HXR_FAILED;
  1568. goto cleanup;
  1569.     }
  1571.     /* add it to the list so that it is before any strings of
  1572.      * smaller length
  1573.      */
  1574.     position = pCookiesList->GetHeadPosition();
  1575.     while (position != NULL)
  1576.     {
  1577. pTempCookie = (CookieStruct*) pCookiesList->GetNext(position);
  1579. if (strlen(*pCookie->pPath) > strlen(*pTempCookie->pPath))
  1580. {
  1581.     // Remember that we found a shorter path
  1582.     bShorterPathFound = TRUE;
  1584.     // If the position is null, then event was the first
  1585.     // item in the list, and we need to do some fancy footwork...
  1586.     if (!position)
  1587.     {
  1588. POSITION theTail = pCookiesList->GetTailPosition();
  1589. pCookiesList->InsertBefore(theTail,(void*) pCookie);
  1590.     }
  1591.     // otherwise, roll after one...
  1592.     else
  1593.     {
  1594. pCookiesList->GetPrev(position);
  1596. if (!position)
  1597. {
  1598.     pCookiesList->AddHead((void*) pCookie);
  1599. }
  1600. else
  1601. {
  1602.     pCookiesList->InsertBefore(position,(void*) pCookie);
  1603. }
  1604.     }
  1606.     break;
  1607. }
  1608.     }
  1610.     // If we didn't find an earlier packet, then we should insert at
  1611.     // the head of the list...
  1612.     if (!bShorterPathFound)
  1613.     {
  1614. pCookiesList->AddTail((void*) pCookie);
  1615.     }
  1617. cleanup:
  1619.     return hr;
  1620. }
  1622. BOOL
  1623. HXCookies::WasCookieAdded(CHXSimpleList* pCookiesList, CookieStruct* pCookie)
  1624. {
  1625.     BOOL bResult = FALSE;
  1626.     CookieStruct*  pTempCookie = NULL;
  1627.     CHXSimpleList::Iterator  i;
  1629.     if (!pCookiesList || !pCookie)
  1630.     {
  1631. goto cleanup;
  1632.     }
  1634.     for (i = pCookiesList->Begin(); i != pCookiesList->End(); ++i)
  1635.     {
  1636. pTempCookie = (CookieStruct*) (*i);
  1638. if (pTempCookie->pCookieName && pCookie->pCookieName 
  1639. && *(pTempCookie->pCookieName) == *(pCookie->pCookieName) 
  1640. && pTempCookie->pHost && pCookie->pHost)
  1641. {
  1642.     if(DoesDomainMatch(*pTempCookie->pHost, *pCookie->pHost))
  1643.     {
  1644. bResult = TRUE;
  1645. break;
  1646.     }
  1647. }
  1648.     }
  1650. cleanup:
  1652.     return bResult;
  1653. }
  1656. BOOL HXCookies::DoesDomainMatch(const char* szDomain, const char* szDomainToParse)
  1657. {
  1658.     BOOL bMatches = FALSE;
  1659.     CHXString cHostCopy;
  1660.     CHXString cDomainCopy;
  1661.     CHXString cHostRight;
  1663.     if(!szDomain || !szDomainToParse || !strlen(szDomain) || !strlen(szDomainToParse))
  1664.     {
  1665. goto cleanup;
  1666.     }
  1668.     cHostCopy = szDomainToParse;
  1669.     cDomainCopy = szDomain;
  1670.     cDomainCopy.MakeLower();
  1672.     // Now we compare the domain (from the cookie itself) with
  1673.     // the rightmost characters of the host. For instance,
  1674.     // a domain of ".bar.com" would match with a host (passed in)
  1675.     // of "foo.bar.com", "www.bar.com", etc. but would NOT match
  1676.     // a host of "bar.com".
  1677.     cHostRight = cHostCopy.Right(cDomainCopy.GetLength());
  1678.     if (cHostRight != cDomainCopy)
  1679.     {
  1680.         // no match
  1681.         goto cleanup;
  1682.     }
  1683.     else if (cDomainCopy.GetAt(0) != '.' && cHostCopy.GetLength() > cDomainCopy.GetLength() &&
  1684.                  cHostCopy.GetAt(cHostCopy.GetLength() - cDomainCopy.GetLength() - 1) != '.')
  1685.     {
  1686.        // no match
  1687.         goto cleanup;
  1688.     }
  1689.     bMatches = TRUE;
  1691. cleanup:
  1692.     return bMatches;
  1693. }
  1696. BOOL
  1697. HXCookies::IsCookieEnabled()
  1698. {
  1699.     BOOL bResult = TRUE;
  1700.     IHXBuffer* pBuffer = NULL;
  1702.     if (!m_pPreferences)
  1703.     {
  1704. if (HXR_OK != m_pContext->QueryInterface(IID_IHXPreferences, (void**)&m_pPreferences))
  1705. {
  1706.     m_pPreferences = NULL;
  1707. }
  1708.     }
  1710.     if (m_pPreferences &&
  1711. m_pPreferences->ReadPref("CookiesEnabled", pBuffer) == HXR_OK)
  1712.     {
  1713. if (strcmp((const char*)pBuffer->GetBuffer(), "0") == 0)
  1714. {
  1715.     bResult = FALSE;
  1716. }
  1718. HX_RELEASE(pBuffer);
  1719.     } 
  1720.     return bResult;
  1721. }
  1723. void     
  1724. HXCookies::UpdateModificationTime(void)
  1725. {
  1726. #ifdef _OPENWAVE
  1727.     // XXXSAB implement this!!!
  1728. #else
  1729.     struct stat status;
  1731.     if (!m_pRMCookiesPath)
  1732.     {
  1733. goto cleanup;
  1734.     }
  1736. #ifndef _VXWORKS
  1737.     if (0 == stat(m_pRMCookiesPath, &status))
  1738.     {
  1739. m_lastModification = status.st_mtime;
  1740.     }
  1741. #endif /* _VXWORKS */
  1743. cleanup:
  1745.     return;
  1746. #endif
  1747. }
  1749. BOOL     
  1750. HXCookies::IsCookieFileModified(void)
  1751. {
  1752. #ifdef _OPENWAVE
  1753.     // XXXSAB implement this!!!
  1754.     return FALSE;
  1755. #else
  1756.     BOOL bResult = FALSE;
  1757.     struct stat status;
  1759.     if (!m_pRMCookiesPath)
  1760.     {
  1761. goto cleanup;
  1762.     }
  1764. #ifndef _VXWORKS
  1765.     if (0 == stat(m_pRMCookiesPath, &status) &&
  1766. status.st_mtime != m_lastModification)
  1767.     {
  1768. bResult = TRUE;
  1769.     }
  1770. #endif /* _VXWORKS */
  1772. cleanup:
  1774.     return bResult;
  1775. #endif
  1776. }
  1778. HX_RESULT
  1779. HXCookies::MergeCookieList(CHXSimpleList* pFromList, CHXSimpleList* pToList)
  1780. {
  1781.     HX_RESULT     hr = HXR_OK;
  1782.     CookieStruct*   pCookie = NULL;
  1783.     CHXSimpleList::Iterator  i;
  1785.     if (!pFromList)
  1786.     {
  1787. goto cleanup;
  1788.     }
  1790.     for (i = pFromList->Begin(); HXR_OK == hr && i != pFromList->End(); ++i)
  1791.     {
  1792. pCookie = (CookieStruct*) (*i);
  1794. if (pCookie->bMemoryOnly && !WasCookieAdded(pToList, pCookie))
  1795. {
  1796.     CookieStruct* pNewCookie = new CookieStruct;
  1797.     pNewCookie->pPath = new CHXString(*pCookie->pPath);
  1798.     pNewCookie->pHost = new CHXString(*pCookie->pHost);
  1799.     pNewCookie->pCookieName = new CHXString(*pCookie->pCookieName);
  1800.     pNewCookie->pCookieValue = new CHXString(*pCookie->pCookieValue);
  1801.     pNewCookie->expires = pCookie->expires;
  1802.     pNewCookie->bIsDomain = pCookie->bIsDomain;
  1803.     pNewCookie->bMemoryOnly = pCookie->bMemoryOnly;
  1804.     hr = AddCookie(pNewCookie, pToList);
  1805. }
  1806.     }
  1808. cleanup:
  1810.     return hr;
  1811. }
  1813. HX_RESULT
  1814. HXCookies::SyncRMCookies(BOOL bSave)
  1815. {
  1816.     HX_RESULT     hr = HXR_OK;
  1817.     CHXSimpleList*  pNewRMCookies = NULL;
  1818.     CHXSimpleList::Iterator i;
  1819.     CookieStruct* pCookie = NULL;
  1820.     BOOL bCookieFileModified = FALSE;
  1822.     if (!m_bInitialized)
  1823.     {
  1824. hr = HXR_FAILED;
  1825. goto cleanup;
  1826.     }
  1828.     bCookieFileModified = IsCookieFileModified();
  1829.     if (bCookieFileModified)
  1830.     {
  1831. if (HXR_OK == OpenCookies(m_pRMCookiesPath, TRUE, pNewRMCookies))
  1832. {
  1833.     if (m_bSaveCookies)
  1834.     {
  1835. MergeCookieList(m_pRMCookies, pNewRMCookies);
  1836.     }
  1837.      
  1838.     ResetCookies(m_pRMCookies);
  1839.     HX_DELETE(m_pRMCookies);
  1841.     m_pRMCookies = pNewRMCookies;
  1842. }          
  1843.     }
  1845.     if (bSave && m_bSaveCookies)
  1846.     {
  1847. if(m_pRMCookies && bCookieFileModified && pNewRMCookies == NULL)
  1848. {
  1849.     //this means there are no more cookies on disk, and we need to look at what's in memory, and keep
  1850.     //only cookies that have bMemoryOnly set
  1851.     pNewRMCookies = new CHXSimpleList;
  1853.     while (m_pRMCookies && m_pRMCookies->GetCount() > 0 && pNewRMCookies)
  1854.     {
  1855.      pCookie = (CookieStruct*) m_pRMCookies->RemoveHead();
  1856. if(pCookie->bMemoryOnly)
  1857. {
  1858.     CookieStruct* pNewCookie = new CookieStruct;
  1859.     pNewCookie->pPath = new CHXString(*pCookie->pPath);
  1860.     pNewCookie->pHost = new CHXString(*pCookie->pHost);
  1861.     pNewCookie->pCookieName = new CHXString(*pCookie->pCookieName);
  1862.     pNewCookie->pCookieValue = new CHXString(*pCookie->pCookieValue);
  1863.     pNewCookie->expires = pCookie->expires;
  1864.     pNewCookie->bIsDomain = pCookie->bIsDomain;
  1865.     pNewCookie->bMemoryOnly = pCookie->bMemoryOnly;
  1866.     AddCookie(pNewCookie, pNewRMCookies);
  1867. }
  1868.      HX_DELETE(pCookie);
  1869.     }
  1870.     HX_DELETE(m_pRMCookies);
  1871.     m_pRMCookies = pNewRMCookies;
  1872. }
  1873. hr = SaveCookies();
  1874.     }
  1876. cleanup:
  1878.     return hr;
  1879. }
  1881. #ifdef _TEST
  1882. void
  1883. HXCookies::DumpCookies(void)
  1884. {
  1885.     CHXSimpleList* pCookies = NULL;
  1886.     CookieStruct*  pCookie = NULL;
  1887.     CHXSimpleList::Iterator  i;
  1889.     for (int l = 0; l < 2; l++)
  1890.     {
  1891. switch (l)
  1892. {
  1893. case 0:
  1894.     pCookies = m_pNSCookies;
  1895.     break;
  1896. case 1:
  1897.     pCookies = m_pRMCookies;
  1898.     break;
  1899. default:
  1900.     break;
  1901. }
  1903. if (pCookies)
  1904. {
  1905.     printf("Total cookies: %lun", pCookies->GetCount());
  1906.     
  1907.     for (i = pCookies->Begin(); i != pCookies->End(); ++i)
  1908.     {
  1909. pCookie = (CookieStruct*) (*i);
  1911. printf("%st%st%sn",
  1912.        (const char*)*(pCookie->pHost),
  1913.        (const char*)*(pCookie->pCookieName),
  1914.        (const char*)*(pCookie->pCookieValue));
  1915.     }
  1916. }
  1917.     }
  1919.     return;
  1920. }
  1921. #endif // _TEST
  1926. //IRPCookies
  1927. STDMETHODIMP HXCookies::GetExpiredCookies(const char* pHost,
  1928.          const char*        pPath,
  1929.          REF(IHXBuffer*)   pCookies)
  1930. {
  1931.     HX_RESULT     hr = HXR_OK;
  1932.     char*     cp = NULL;
  1933.     char*     pComma = NULL;
  1934.     char*     pEqualSign = NULL;
  1935.     char*     pData = NULL;
  1936.     char*     pURL = NULL;
  1937.     int     l = 0;
  1938.     int     host_length = 0;
  1939.     int     path_length = 0;
  1940.     int     domain_length = 0;
  1941.     BOOL     bAdded = FALSE;
  1942.     UINT32     dwSize = 0;    
  1943.     time_t     cur_time = time(NULL);
  1944.     CookieStruct*   pTempCookie = NULL;
  1945.     CookieStruct*   pNewCookie = NULL;
  1946.     CHXSimpleList*  pCookiesFound1 = NULL;
  1947.     //CHXSimpleList*  pCookiesFound2 = NULL;
  1948.     CHXSimpleList*  pCookiesList = NULL;
  1949.     IHXValues*     pValues = NULL;
  1950.     CHXSimpleList::Iterator  i;
  1951.     CHXString       cHostCopy;
  1952.     INT32           lColon;
  1953.     
  1954.     pCookies = NULL;
  1956.     if (!IsCookieEnabled())
  1957.     {
  1958. goto cleanup;
  1959.     }
  1961.     if (!m_bInitialized)
  1962.     {
  1963. hr = Initialize();
  1965. if (HXR_OK != hr)
  1966. {
  1967.     goto cleanup;
  1968. }
  1969.     }
  1970.     else
  1971.     {
  1972. SyncRMCookies(FALSE);
  1973.     }
  1975.     if (!pHost || !m_pCookiesHelper)
  1976.     {
  1977. hr = HXR_FAILED;
  1978. goto cleanup;
  1979.     }
  1981.     // return string to build    
  1982.     if (!(pValues = new CHXHeader()))
  1983.     {
  1984. hr = HXR_OUTOFMEMORY;
  1985. goto cleanup;
  1986.     }
  1988.     pValues->AddRef();
  1990.     cHostCopy = pHost;
  1991.     lColon    = cHostCopy.Find(':');
  1992.     if (lColon >= 0)
  1993.     {
  1994. cHostCopy = cHostCopy.Left(lColon);
  1995.     }
  1996.     cHostCopy.MakeLower();
  1998.     // search for all cookies(Netscape only for now)
  1999.     for (l = 0; l < 2; l++)
  2000.     {
  2001. switch (l)
  2002. {
  2003. case 0:
  2004.     pCookiesList = m_pRMCookies;
  2005.     break;
  2006. case 1:
  2007.     pCookiesList = m_pNSCookies;
  2008.     break;
  2009. default:
  2010.     break;
  2011. }
  2013. if (!pCookiesList)
  2014. {
  2015.     continue;
  2016. }
  2018. for (i = pCookiesList->Begin(); i != pCookiesList->End(); ++i)
  2019. {
  2020.     pTempCookie = (CookieStruct*) (*i);
  2021.     
  2022.     if (!pTempCookie->pHost)
  2023.     {
  2024. continue;
  2025.     }
  2027.     // check the host or domain first
  2028.     if(pTempCookie->bIsDomain)
  2029.     {
  2030. domain_length = pTempCookie->pHost->GetLength();
  2032. CHXString cDomainCopy(*(pTempCookie->pHost));
  2033. cDomainCopy.MakeLower();
  2035. // Now we compare the domain (from the cookie itself) with
  2036. // the rightmost characters of the host. For instance,
  2037. // a domain of ".bar.com" would match with a host (passed in)
  2038. // of "foo.bar.com", "www.bar.com", etc. but would NOT match
  2039. // a host of "bar.com".
  2040. CHXString cHostRight = cHostCopy.Right(cDomainCopy.GetLength());
  2041. if (cHostRight != cDomainCopy)
  2042. {
  2043.     // no match
  2044.     continue;
  2045. }
  2046.     }
  2047.     else if(strcasecmp((const char*)*(pTempCookie->pHost), pHost))
  2048.     {
  2049. // hostname matchup failed.
  2050. continue;
  2051.     }
  2053.     // shorter strings always come last so there can be no
  2054.     // ambiquity             
  2055.     if(pTempCookie->pPath && 
  2056.        !strncmp(pPath, (const char*)*(pTempCookie->pPath), pTempCookie->pPath->GetLength()))
  2057.     {
  2058. // check for expired cookies
  2059. if(pTempCookie->expires && (pTempCookie->expires < cur_time))
  2060. {
  2061.     if (!pCookiesFound1)
  2062.     {
  2063.         pCookiesFound1 = new CHXSimpleList();
  2064.     }
  2065.     pCookiesFound1->AddTail(pTempCookie);
  2066. }
  2067.     }
  2068. }
  2069.     }
  2071. #ifdef _WINDOWS
  2072.     if (!_pInternetGetCookie || m_bMemoryOnly)
  2073.     {
  2074. goto cleanup;
  2075.     }
  2077.     host_length = strlen(pHost);
  2079.     if (pPath)
  2080.     {
  2081. path_length = strlen(pPath);
  2082.     }
  2084.     pURL = new char[host_length + path_length + 8];
  2085.     sprintf(pURL, "http://%s%s", pHost, pPath); /* Flawfinder: ignore */
  2087.     if (_pInternetGetCookie(pURL, NULL, pData, &dwSize) && !pData && dwSize)
  2088.     {
  2089. pData = new char[dwSize+1];
  2091. if (!_pInternetGetCookie(pURL, NULL, pData, &dwSize))
  2092. {
  2093.     goto cleanup;
  2094. }
  2096. cp = pData;
  2098. while (pComma = (char*) ::HXFindChar(cp, ';'))
  2099. {
  2100.     *pComma = '';
  2101.     pComma++;
  2103.     if (pEqualSign = (char*) ::HXFindChar(cp, '='))
  2104.     {
  2105. *pEqualSign = '';
  2106. pEqualSign++;
  2108. pNewCookie = new CookieStruct;
  2109. bAdded = FALSE;
  2111. // copy
  2112. pNewCookie->pCookieValue = new CHXString(pEqualSign);
  2113. pNewCookie->pCookieName = new CHXString(cp);
  2114. pNewCookie->pPath = NULL;
  2115. pNewCookie->pHost = NULL;
  2116. pNewCookie->expires = 0;
  2117. pNewCookie->bIsDomain = FALSE;
  2118. pNewCookie->bMemoryOnly = FALSE;
  2120. if (!WasCookieAdded(pCookiesFound1, pNewCookie))
  2121. {
  2122.     //if (!pCookiesFound2)
  2123.     //{
  2124.     // pCookiesFound2 = new CHXSimpleList();
  2125.     // pCookiesFound2->AddTail(pNewCookie);
  2126.     // bAdded = TRUE;
  2127.     //}
  2128.     //else if (!WasCookieAdded(pCookiesFound2, pNewCookie))
  2129.     //{
  2130.     // pCookiesFound2->AddTail(pNewCookie);
  2131.     // bAdded = TRUE;
  2132.     //}
  2133. }
  2135. if (!bAdded)
  2136. {
  2137.     HX_DELETE(pNewCookie);
  2138. }
  2139.     }
  2141.     cp = pComma;
  2142. }
  2144. if (pEqualSign = (char*) ::HXFindChar(cp, '='))
  2145. {
  2146.     *pEqualSign = '';
  2147.     pEqualSign++;
  2149.     pNewCookie = new CookieStruct;
  2150.     bAdded = FALSE;
  2152.     // copy
  2153.     pNewCookie->pCookieValue = new CHXString(pEqualSign);
  2154.     pNewCookie->pCookieName = new CHXString(cp);
  2155.     pNewCookie->pPath = NULL;
  2156.     pNewCookie->pHost = NULL;
  2157.     pNewCookie->expires = 0;
  2158.     pNewCookie->bIsDomain = FALSE;
  2159.     pNewCookie->bMemoryOnly = FALSE;
  2161.     if (!WasCookieAdded(pCookiesFound1, pNewCookie))
  2162.     {
  2163. //if (!pCookiesFound2)
  2164. //{
  2165. //    pCookiesFound2 = new CHXSimpleList();
  2166. //    pCookiesFound2->AddTail(pNewCookie);
  2167. //    bAdded = TRUE;
  2168. //}
  2169. //else if (!WasCookieAdded(pCookiesFound2, pNewCookie))
  2170. //{
  2171. //    pCookiesFound2->AddTail(pNewCookie);
  2172. //    bAdded = TRUE;
  2173. //}
  2174.     }
  2176.     if (!bAdded)
  2177.     {
  2178. HX_DELETE(pNewCookie);
  2179.     }
  2180. }
  2181.     }
  2182. #endif /* _WINDOWS */
  2184. cleanup:
  2186.     if (pCookiesFound1)
  2187.     {
  2188. for (i = pCookiesFound1->Begin(); i != pCookiesFound1->End(); ++i)
  2189. {
  2190.     pTempCookie = (CookieStruct*) (*i);
  2192.     if(pTempCookie->pCookieName && pTempCookie->pCookieValue)
  2193.     {
  2194. ::SaveStringToHeader(pValues,
  2195.      (const char*)*(pTempCookie->pCookieName),
  2196.      (char*)(const char*)*(pTempCookie->pCookieValue));
  2197.     }
  2198. }
  2199.     }
  2201.     //if (pCookiesFound2)
  2202.     //{
  2203.     // for (i = pCookiesFound2->Begin(); i != pCookiesFound2->End(); ++i)
  2204.     // {
  2205.     //     pTempCookie = (CookieStruct*) (*i);
  2206.     //
  2207.     //     if(pTempCookie->pCookieName && pTempCookie->pCookieValue)
  2208.     //     {
  2209.     // ::SaveStringToHeader(pValues,
  2210.     //      (const char*)*(pTempCookie->pCookieName),
  2211.     //      (char*)(const char*)*(pTempCookie->pCookieValue));
  2212.     //     }
  2213.     //
  2214.     //     HX_DELETE(pTempCookie);
  2215.     // }
  2216.     //}
  2218.     if (m_pCookiesHelper)
  2219.     {
  2220. hr = m_pCookiesHelper->UnPack(pValues, pCookies);
  2221.     }
  2223.     HX_DELETE(pCookiesFound1);
  2224.     //HX_DELETE(pCookiesFound2);
  2225.     HX_VECTOR_DELETE(pData);
  2226.     HX_VECTOR_DELETE(pURL);
  2228.     HX_RELEASE(pValues);
  2229.    
  2230.     return hr;
  2231. }
  2233. HX_RESULT HXCookies::SecureCookies()
  2234. {
  2235.     return HXR_OK;
  2236. }
  2238. HX_RESULT HXCookies::CheckCookies()
  2239. {
  2240.     return HXR_OK;
  2241. }