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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
cookies.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：53k
源码类别：

Symbian

开发平台：

Visual C++

cookies.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: cookies.cpp,v 1.19.20.4 2004/07/09 01:48:15 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  *                 Phil Dibowitz
  48.  * 
  49.  * ***** END LICENSE BLOCK ***** */
  51. #include "hxcom.h"
  52. #include "hxtypes.h"
  53. #include "hlxclib/string.h"
  54. // #include "hlxclib/stdio.h"
  55. #include "safestring.h"
  57. #ifdef _MACINTOSH
  58. #ifdef _CARBON
  59. #ifdef _MAC_MACHO
  60. #include <sys/stat.h>
  61. #else
  62. #include <stat.h>
  63. #endif
  64. #else /* _CARBON */
  65. #include <stat.mac.h>
  66. #endif /* _CARBON */
  67. #else /* _MACINTOSH */
  68. #include "hlxclib/sys/types.h"
  69. #include "hlxclib/sys/stat.h"
  70. #endif /* _MACINTOSH */
  72. #include "hlxclib/time.h"
  74. #if defined(_AIX)
  75. #include <ctype.h>
  76. #endif
  78. #ifdef _WINDOWS
  79. #include "hlxclib/windows.h"
  80. #include <wininet.h>
  81. #include "hlxclib/io.h"
  82. #endif /* _WINDOWS */
  84. #if defined(_CARBON) || defined(_MAC_MACHO)
  85. #include "hxver.h" // for HXVER_SDK_PRODUCT
  86. #endif
  88. #ifdef _CARBON
  89. #include "cfwrappers.h"
  90. #endif
  92. #include "hxresult.h"
  93. #include "hxslist.h"
  94. #include "chxpckts.h"
  95. #include "hxstrutl.h"
  96. #include "dbcs.h"
  97. #include "dllpath.h"
  98. #include "hxprefs.h"
  99. #include "hxthread.h"
  100. #include "ihxcookies.h"
  101. #include "cookhlpr.h"
  102. #include "ihxcookies2.h"
  103. #include "hxdate.h"
  104. #include "cookies.h"
  105. #include "md5.h"
  106. #include "filespecutils.h"
  108. #ifdef _UNIX
  109. #include <sys/types.h>
  110. #include <sys/stat.h>
  111. #endif
  113. #if defined (_UNIX) && !defined(_SUN) && !defined(_HPUX) && !defined(_IRIX) && !defined(_OSF1)
  114. #include <sys/file.h>
  115. #endif /* UNIX */
  117. #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"
  119. #if defined(_UNIX) && !defined(_MAC_UNIX)
  120. #  define RM_COOKIE_FILE_NAME "Cookies_6_0"
  121. #else
  122. #  define RM_COOKIE_FILE_NAME "cookies.txt"
  123. #endif
  125. /* We should really define it in a common header file */
  126. #if defined (_WINDOWS ) || defined (WIN32) || defined(_SYMBIAN)
  127. #define OS_SEPARATOR_CHAR '\'
  128. #define OS_SEPARATOR_STRING "\"
  129. #elif defined (_UNIX) || defined (_OPENWAVE)
  130. #define OS_SEPARATOR_CHAR '/'
  131. #define OS_SEPARATOR_STRING "/"
  132. #elif defined (_MACINTOSH)
  133. #define OS_SEPARATOR_CHAR ':'
  134. #define OS_SEPARATOR_STRING ":"
  135. #endif /* defined (_WINDOWS ) || defined (WIN32) */
  137. HXCookies::HXCookies(IUnknown* pContext, BOOL bMemoryOnly)
  138. : m_lRefCount(0)
  139. , m_bSaveCookies(FALSE)
  140. , m_bMemoryOnly(bMemoryOnly)
  141. , m_pNSCookiesPath(NULL)
  142. , m_pNSCookies(NULL)
  143. , m_pRMCookiesPath(NULL)
  144. , m_pRMCookies(NULL)
  145. , m_pCookiesHelper(NULL)
  146. , m_pPreferences(NULL)
  147. , m_bInitialized(FALSE)
  148. , m_lastModification(0)
  149. , m_pContext(NULL)
  150. #ifdef _WINDOWS
  151. , m_hLib(NULL)
  152. , m_pLock(NULL)
  153. , _pInternetSetCookie(NULL)
  154. , _pInternetGetCookie(NULL)
  155. #elif _UNIX
  156. , m_fileID(0)
  157. #endif /* _WINDOWS */
  158. {    
  159.     if (pContext)
  160.     {
  161. m_pContext = pContext;
  162. m_pContext->AddRef();
  163.     }
  164. }
  166. HXCookies::~HXCookies()
  167. {
  168.     Close();
  169. }
  171. STDMETHODIMP
  172. HXCookies::QueryInterface(REFIID riid, void**ppvObj)
  173. {
  174.     QInterfaceList qiList[] =
  175.     {
  176. { GET_IIDHANDLE(IID_IUnknown), this },
  177. { GET_IIDHANDLE(IID_IHXCookies), (IHXCookies*) this },
  178. { GET_IIDHANDLE(IID_IHXCookies2), (IHXCookies2*) this }
  179.     };
  181.     if (QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj) == HXR_OK)
  182.     {
  183.         return HXR_OK;
  184.     }
  185.     else if (IsEqualIID(riid, IID_IHXCookiesHelper) && m_pCookiesHelper)
  186.     {
  187. return m_pCookiesHelper->QueryInterface(riid, ppvObj);
  188.     }
  190.     *ppvObj = NULL;
  191.     return HXR_NOINTERFACE;
  192. }
  194. /////////////////////////////////////////////////////////////////////////
  195. //  Method:
  196. // IUnknown::AddRef
  197. //  Purpose:
  198. // Everyone usually implements this the same... feel free to use
  199. // this implementation.
  200. //
  201. STDMETHODIMP_(ULONG32) 
  202. HXCookies::AddRef()
  203. {
  204.     return InterlockedIncrement(&m_lRefCount);
  205. }
  207. /////////////////////////////////////////////////////////////////////////
  208. //  Method:
  209. // IUnknown::Release
  210. //  Purpose:
  211. // Everyone usually implements this the same... feel free to use
  212. // this implementation.
  213. //
  214. STDMETHODIMP_(ULONG32) 
  215. HXCookies::Release()
  216. {
  217.     if (InterlockedDecrement(&m_lRefCount) > 0)
  218.     {
  219.         return m_lRefCount;
  220.     }
  222.     delete this;
  223.     return 0;
  224. }
  226. HX_RESULT    
  227. HXCookies::Initialize(void)
  228. {
  229.     HX_RESULT hr = HXR_OK;
  230.     
  231.     if (!m_pContext || !IsCookieEnabled())
  232.     {
  233. hr = HXR_FAILED;
  234. goto cleanup;
  235.     }
  237.     m_pContext->QueryInterface(IID_IHXCookiesHelper, (void**) &m_pCookiesHelper);
  238.     if (!m_pCookiesHelper)
  239.     {
  240.         HXCookiesHelper* pHelper = new HXCookiesHelper();
  241.         if (pHelper)
  242. {
  243.             pHelper->QueryInterface(IID_IHXCookiesHelper, (void**) &m_pCookiesHelper);
  244. }
  245.     }
  247.     if (!m_bMemoryOnly)
  248.     {
  249. #ifdef _WINDOWS
  250.         if (m_hLib = LoadLibrary(OS_STRING("wininet.dll")))
  251. {
  252.             _pInternetSetCookie = (INTERNETSETCOOKIE)GetProcAddress(m_hLib, OS_STRING("InternetSetCookieA"));
  253.     _pInternetGetCookie = (INTERNETGETCOOKIE)GetProcAddress(m_hLib, OS_STRING("InternetGetCookieA"));
  254. }
  255. #endif /* _WINDOWS */
  257.         PrepareCookiesPath();
  259.         if (m_pNSCookiesPath)
  260. {
  261.     OpenCookies(m_pNSCookiesPath, FALSE, m_pNSCookies);
  262. }
  264.         if (m_pRMCookiesPath)
  265. {
  266.     OpenCookies(m_pRMCookiesPath, TRUE, m_pRMCookies);
  267.         }
  268.     }
  270.     m_bInitialized = TRUE;
  272. cleanup:
  274.     return hr;
  275. }
  277. void
  278. HXCookies::Close(void)
  279. {
  280.     if (m_bSaveCookies && !m_bMemoryOnly)
  281.     {
  282. SaveCookies();
  283.     }
  285.     ResetCookies(m_pNSCookies);
  286.     ResetCookies(m_pRMCookies);
  288.     HX_DELETE(m_pNSCookies);
  289.     HX_DELETE(m_pRMCookies);
  291.     HX_VECTOR_DELETE(m_pNSCookiesPath);
  292.     HX_VECTOR_DELETE(m_pRMCookiesPath);
  294.     HX_RELEASE(m_pPreferences);
  295.     HX_RELEASE(m_pCookiesHelper);
  296.     HX_RELEASE(m_pContext);
  298.     m_bInitialized = FALSE;
  300. #ifdef _WINDOWS
  301.     if (m_hLib)
  302.     {
  303. FreeLibrary(m_hLib);
  304. m_hLib = NULL;
  305.     }
  307.     HX_DELETE(m_pLock);
  308. #endif /* _WINDOWS */
  309. }
  311. STDMETHODIMP 
  312. HXCookies::SetCookies(const char* pHost, const char* pPath, IHXBuffer* pCookies)
  313. {
  314.     HX_RESULT     hr = HXR_OK;
  315.     int     host_length = 0;
  316.     int     path_length = 0;
  317.     int     domain_length = 0;
  318.     char*     pURL = NULL;
  319.     char*     path_from_header = NULL;
  320.     char*     domain_from_header = NULL;
  321.     char*     name_from_header = NULL;
  322.     char*     cookie_from_header = NULL;
  323.     char*     dot = NULL;
  324.     char*     slash = NULL;
  325.     BOOL     bIsDomain = FALSE;
  326.     time_t     expires=0;
  327.     IHXBuffer*     pBuffer = NULL;
  328.     IHXValues*     pValues = NULL;    
  329.     CookieStruct*   pNewCookie = NULL;
  330.     
  331.     if (!IsCookieEnabled())
  332.     {
  333. goto cleanup;
  334.     }
  336.     if (!m_bInitialized)
  337.     {
  338. hr = Initialize();
  340. if (HXR_OK != hr)
  341. {
  342.     goto cleanup;
  343. }
  344.     }
  346.     if (!m_pCookiesHelper || !pCookies || !pHost)
  347.     {
  348. hr = HXR_FAILED;
  349. goto cleanup;
  350.     }
  352.     if (HXR_OK != m_pCookiesHelper->Pack(pCookies, pValues))
  353.     {
  354. hr = HXR_FAILED;
  355. goto cleanup;
  356.     }
  358.     if (HXR_OK == pValues->GetPropertyBuffer("path", pBuffer) && pBuffer)
  359.     {
  360. ::StrAllocCopy(path_from_header, (char*)pBuffer->GetBuffer());
  361.     }
  362.     HX_RELEASE(pBuffer);
  364.     if (HXR_OK == pValues->GetPropertyBuffer("domain", pBuffer) && pBuffer)
  365.     {
  366.         // verify that this host has the authority to set for
  367.         // this domain.   We do this by making sure that the
  368.         // host is in the domain
  369.         // We also require that a domain have at least two
  370.         // periods to prevent domains of the form ".com"
  371.         // and ".edu"
  372. //
  373. // also make sure that there is more stuff after
  374. // the second dot to prevent ".com."
  375. ::StrAllocCopy(domain_from_header, (char*)pBuffer->GetBuffer());
  377.         dot = strchr(domain_from_header, '.');
  378.     
  379. if(dot)
  380. {
  381.             dot = strchr(dot+1, '.');
  382. }
  384. if(!dot || *(dot+1) == '') 
  385. {
  386.     // did not pass two dot test. FAIL
  387.     hr = HXR_FAILED;
  388.     goto cleanup;
  389. }
  391. domain_length = strlen(domain_from_header);
  392. host_length = strlen(pHost);
  394. // check to see if the host is in the domain
  395. if(domain_length > host_length || 
  396.    strcasecmp(domain_from_header, &pHost[host_length-domain_length]))
  397. {
  398.     hr = HXR_FAILED;
  399.     goto cleanup;
  400. }
  402. bIsDomain = TRUE;
  403.     }
  404.     HX_RELEASE(pBuffer);
  406.     if (HXR_OK == pValues->GetPropertyBuffer("name", pBuffer) && pBuffer)
  407.     {
  408. ::StrAllocCopy(name_from_header, (char*)pBuffer->GetBuffer());
  409.     }
  410.     HX_RELEASE(pBuffer);
  412.     if (HXR_OK == pValues->GetPropertyBuffer("value", pBuffer) && pBuffer)
  413.     {
  414. ::StrAllocCopy(cookie_from_header, (char*)pBuffer->GetBuffer());
  415.     }
  416.     HX_RELEASE(pBuffer);
  418.     if (HXR_OK == pValues->GetPropertyBuffer("expires", pBuffer) && pBuffer)
  419.     {
  420. expires = ::ParseDate((char*)pBuffer->GetBuffer());
  421.     }
  422.     HX_RELEASE(pBuffer);
  424.     if(!path_from_header && pPath)
  425.     {
  426.         // strip down everything after the last slash
  427.         // to get the path.
  428. CHXString strPath = pPath;
  429. INT32 nIndex = strPath.ReverseFind('/');
  431. if (nIndex != -1)
  432. {
  433.     strPath = strPath.Left(nIndex + 1);
  434. }
  436. ::StrAllocCopy(path_from_header, (char*) (const char*) strPath);
  437.     }
  439.     if(!domain_from_header && pHost)
  440.     {
  441. ::StrAllocCopy(domain_from_header, (char*)pHost); 
  442.     }
  443.     
  444.     m_bSaveCookies = TRUE;
  446.     // We have decided we are going to insert a cookie into the list
  447.     // Get the cookie lock so that we can munge on the list
  449.     pNewCookie = CheckForPrevCookie(path_from_header, 
  450.     domain_from_header, 
  451.     name_from_header);
  453.     if(pNewCookie) 
  454.     {
  455. HX_DELETE(pNewCookie->pCookieValue);
  456. HX_DELETE(pNewCookie->pCookieName);
  457. HX_DELETE(pNewCookie->pPath);
  458.         HX_DELETE(pNewCookie->pHost);
  459.         
  460. pNewCookie->pCookieValue = new CHXString(cookie_from_header);
  461. pNewCookie->pCookieName = new CHXString(name_from_header);
  462.         pNewCookie->pPath = new CHXString(path_from_header);
  463.         pNewCookie->pHost = new CHXString(domain_from_header);
  464.         pNewCookie->expires = expires;
  465.         pNewCookie->bIsDomain = bIsDomain;
  466. pNewCookie->bMemoryOnly = TRUE;
  467.     }
  468.     else 
  469.     {
  470. pNewCookie = new CookieStruct;
  472.         // copy
  473. pNewCookie->pCookieValue = new CHXString(cookie_from_header);
  474. pNewCookie->pCookieName = new CHXString(name_from_header);
  475.         pNewCookie->pPath = new CHXString(path_from_header);
  476.         pNewCookie->pHost = new CHXString(domain_from_header);
  477.         pNewCookie->expires = expires;
  478.         pNewCookie->bIsDomain = bIsDomain;
  479. pNewCookie->bMemoryOnly = TRUE;
  481. if (!m_pRMCookies)
  482. {
  483.     m_pRMCookies = new CHXSimpleList();
  484. }
  486. hr = AddCookie(pNewCookie, m_pRMCookies);
  487.     }
  489. #ifdef _WINDOWS
  490.     if (!m_bMemoryOnly)
  491.     {
  492.         if (!_pInternetSetCookie)
  493. {
  494.     goto cleanup;
  495. }
  497. host_length = strlen(pHost);
  499. if (pPath)
  500. {
  501.     path_length = strlen(pPath);
  502. }
  504. pURL = new char[host_length + path_length + 8];
  505. sprintf(pURL, "http://%s%s", pHost, pPath); /* Flawfinder: ignore */
  507. _pInternetSetCookie(pURL, NULL, (const char*)pCookies->GetBuffer());
  508.     }
  509. #endif /* _WINDOWS */
  511. cleanup:
  513.     HX_RELEASE(pBuffer);
  514.     HX_RELEASE(pValues);
  516.     HX_VECTOR_DELETE(pURL);
  517.     HX_VECTOR_DELETE(path_from_header);
  518.     HX_VECTOR_DELETE(domain_from_header);
  519.     HX_VECTOR_DELETE(name_from_header);
  520.     HX_VECTOR_DELETE(cookie_from_header);
  521.     
  522.     return hr;
  523. }
  525. STDMETHODIMP 
  526. HXCookies::GetCookies(const char* pHost, const char* pPath, REF(IHXBuffer*) pCookies)
  527. {
  528.     IHXBuffer* pPlayerCookies = NULL;
  529.     HX_RESULT res = GetCookiesInternal(pHost, pPath, pCookies, pPlayerCookies);
  530.     HX_RELEASE(pPlayerCookies);
  531.     return res;
  532. }
  534. STDMETHODIMP HXCookies::GetCookies(const char*     pHost,
  535.       const char*     pPath,
  536.       REF(IHXBuffer*)   pCookies,
  537.       REF(IHXBuffer*)   pPlayerCookies)
  538. {
  539.     return GetCookiesInternal(pHost, pPath, pCookies, pPlayerCookies);
  540. }
  543. #if defined(_CARBON) || defined(_MAC_MACHO)
  544. #define REPORT_COOKIES 1
  545. #endif
  547. HX_RESULT HXCookies::GetCookiesInternal(const char* pHost,
  548.  const char*     pPath,
  549.  REF(IHXBuffer*)   pCookies,
  550.  REF(IHXBuffer*)   pPlayerCookies)
  551. {
  552.     HX_RESULT     hr = HXR_OK;
  553.     char*     cp = NULL;
  554.     char*     pComma = NULL;
  555.     char*     pEqualSign = NULL;
  556.     char*     pData = NULL;
  557.     char*     pURL = NULL;
  558.     int     l = 0;
  559.     int     host_length = 0;
  560.     int     path_length = 0;
  561.     BOOL     bAdded = FALSE;
  562. UINT32     dwSize = 0;    
  563.     time_t     cur_time = time(NULL);
  564.     CookieStruct*   pTempCookie = NULL;
  565.     CookieStruct*   pNewCookie = NULL;
  566.     CHXSimpleList*  pCookiesFound1 = NULL;
  567.     CHXSimpleList*  pCookiesFound2 = NULL;
  568.     CHXSimpleList*  pCookiesList = NULL;
  569.     IHXValues*     pValues = NULL;
  570.     CHXSimpleList::Iterator  i;
  571.     CHXString       cHostCopy;
  572.     INT32           lColon;
  573.     BOOL     bIsPlayerCookieList = FALSE;
  574.     CHXString     strPlayerCookies;
  575. #ifdef REPORT_COOKIES
  576.     CHXString strCookieReport;
  577. #endif
  578.     
  579.     pCookies = NULL;
  580.     pPlayerCookies = NULL;
  582.     if (!IsCookieEnabled())
  583.     {
  584. goto cleanup;
  585.     }
  587.     if (!m_bInitialized)
  588.     {
  589. hr = Initialize();
  591. if (HXR_OK != hr)
  592. {
  593.     goto cleanup;
  594. }
  595.     }
  596.     else
  597.     {
  598. SyncRMCookies(FALSE);
  599.     }
  601.     if (!pHost || !m_pCookiesHelper)
  602.     {
  603. hr = HXR_FAILED;
  604. goto cleanup;
  605.     }
  607.     // return string to build    
  608.     if (!(pValues = new CHXHeader()))
  609.     {
  610. hr = HXR_OUTOFMEMORY;
  611. goto cleanup;
  612.     }
  614.     pValues->AddRef();
  616.     cHostCopy = pHost;
  617.     lColon    = cHostCopy.Find(':');
  618.     if (lColon >= 0)
  619.     {
  620. cHostCopy = cHostCopy.Left(lColon);
  621.     }
  622.     cHostCopy.MakeLower();
  624.     // search for all cookies(Netscape only for now)
  625.     for (l = 0; l < 2; l++)
  626.     {
  627. switch (l)
  628. {
  629. case 0:
  630.     pCookiesList = m_pRMCookies;
  631.     bIsPlayerCookieList = TRUE;
  632.     break;
  633. case 1:
  634.     pCookiesList = m_pNSCookies;
  635.     bIsPlayerCookieList = FALSE;
  636.     break;
  637. default:
  638.     break;
  639. }
  641. if (!pCookiesList)
  642. {
  643.     continue;
  644. }
  646. for (i = pCookiesList->Begin(); i != pCookiesList->End(); ++i)
  647. {
  648.     pTempCookie = (CookieStruct*) (*i);
  649.     
  650.     if (!pTempCookie->pHost)
  651.     {
  652. continue;
  653.     }
  654.     
  655.     // check the host or domain first
  656.     if(pTempCookie->bIsDomain)
  657.     {
  658. if (!DoesDomainMatch(*pTempCookie->pHost, cHostCopy))
  659. {
  660.     continue;
  661. }
  662.     }
  663.     else if(strcasecmp((const char*)*(pTempCookie->pHost), pHost))
  664.     {
  665. // hostname matchup failed.
  666. continue;
  667.     }
  669.     // shorter strings always come last so there can be no
  670.     // ambiquity             
  671.     if(pTempCookie->pPath && 
  672.        !strncmp(pPath, (const char*)*(pTempCookie->pPath), pTempCookie->pPath->GetLength()))
  673.     {
  674. // check for expired cookies
  675. if(pTempCookie->expires && (pTempCookie->expires < cur_time))
  676. {
  677.     m_bSaveCookies = TRUE;
  678.     continue;
  679. }
  681. if (!pCookiesFound1)
  682. {
  683.     pCookiesFound1 = new CHXSimpleList();
  684.     pCookiesFound1->AddTail(pTempCookie);
  685. }
  686. else if (!WasCookieAdded(pCookiesFound1, pTempCookie))
  687. {
  688.     pCookiesFound1->AddTail(pTempCookie);
  689. }
  690. if(bIsPlayerCookieList)
  691. {
  692.     if(!strPlayerCookies.IsEmpty())
  693.     {
  694.         strPlayerCookies += "|";
  695.     }
  696.     strPlayerCookies += *pTempCookie->pCookieName;
  697. #ifdef REPORT_COOKIES
  698.     strCookieReport += (strCookieReport.IsEmpty() ? "" : ", ");
  699.     strCookieReport += *pTempCookie->pCookieName;
  700.     strCookieReport += "=";
  701.     strCookieReport += *pTempCookie->pCookieValue;
  702. #endif
  703. }
  704.     }
  705. }
  706.     }
  708. #ifdef _WINDOWS
  709.     if (!_pInternetGetCookie || m_bMemoryOnly)
  710.     {
  711. goto cleanup;
  712.     }
  714.     host_length = strlen(pHost);
  716.     if (pPath)
  717.     {
  718. path_length = strlen(pPath);
  719.     }
  721.     pURL = new char[host_length + path_length + 8];
  722.     sprintf(pURL, "http://%s%s", pHost, pPath); /* Flawfinder: ignore */
  724.     if (_pInternetGetCookie(pURL, NULL, pData, &dwSize) && !pData && dwSize)
  725.     {
  726. pData = new char[dwSize+1];
  728. if (!_pInternetGetCookie(pURL, NULL, pData, &dwSize))
  729. {
  730.     goto cleanup;
  731. }
  733. cp = pData;
  735. while (pComma = (char*) ::HXFindChar(cp, ';'))
  736. {
  737.     *pComma = '';
  738.     pComma++;
  740.     if (pEqualSign = (char*) ::HXFindChar(cp, '='))
  741.     {
  742. *pEqualSign = '';
  743. pEqualSign++;
  745.          pNewCookie = new CookieStruct;
  746. bAdded = FALSE;
  748. // copy
  749. pNewCookie->pCookieValue = new CHXString(pEqualSign);
  750. pNewCookie->pCookieName = new CHXString(cp);
  751. pNewCookie->pPath = new CHXString(pPath);
  752. pNewCookie->pHost = new CHXString(pHost);
  753. pNewCookie->expires = 0;
  754. pNewCookie->bIsDomain = FALSE;
  755. pNewCookie->bMemoryOnly = FALSE;
  757. if(pNewCookie->pCookieName)
  758. {
  759.     pNewCookie->pCookieName->TrimLeft();
  760.     pNewCookie->pCookieName->TrimRight();
  761. }
  763. if (!WasCookieAdded(pCookiesFound1, pNewCookie))
  764. {
  765.     if (!pCookiesFound2)
  766.     {
  767. pCookiesFound2 = new CHXSimpleList();
  768. pCookiesFound2->AddTail(pNewCookie);
  769. bAdded = TRUE;
  770.     }
  771.     else if (!WasCookieAdded(pCookiesFound2, pNewCookie))
  772.     {
  773. pCookiesFound2->AddTail(pNewCookie);
  774. bAdded = TRUE;
  775.     }
  776. }
  778. if (!bAdded)
  779. {
  780.     HX_DELETE(pNewCookie);
  781. }
  782.     }
  784.     cp = pComma;
  785. }
  787. if (pEqualSign = (char*) ::HXFindChar(cp, '='))
  788. {
  789.     *pEqualSign = '';
  790.     pEqualSign++;
  792.     pNewCookie = new CookieStruct;
  793.     bAdded = FALSE;
  795.     // copy
  796.     pNewCookie->pCookieValue = new CHXString(pEqualSign);
  797.     pNewCookie->pCookieName = new CHXString(cp);
  798.     pNewCookie->pPath = NULL;
  799.     pNewCookie->pHost = NULL;
  800.     pNewCookie->expires = 0;
  801.     pNewCookie->bIsDomain = FALSE;
  802.     pNewCookie->bMemoryOnly = FALSE;
  804.     if(pNewCookie->pCookieName)
  805.     {
  806.         pNewCookie->pCookieName->TrimLeft();
  807.         pNewCookie->pCookieName->TrimRight();
  808.     }
  810.     if (!WasCookieAdded(pCookiesFound1, pNewCookie))
  811.     {
  812. if (!pCookiesFound2)
  813. {
  814.     pCookiesFound2 = new CHXSimpleList();
  815.     pCookiesFound2->AddTail(pNewCookie);
  816.     bAdded = TRUE;
  817. }
  818. else if (!WasCookieAdded(pCookiesFound2, pNewCookie))
  819. {
  820.     pCookiesFound2->AddTail(pNewCookie);
  821.     bAdded = TRUE;
  822. }
  823.     }
  825.     if (!bAdded)
  826.     {
  827. HX_DELETE(pNewCookie);
  828.     }
  829. }
  830.     }
  831. #endif /* _WINDOWS */
  833. cleanup:
  835.     if (pCookiesFound1)
  836.     {
  837. for (i = pCookiesFound1->Begin(); i != pCookiesFound1->End(); ++i)
  838. {
  839.     pTempCookie = (CookieStruct*) (*i);
  841.     if(pTempCookie->pCookieName && pTempCookie->pCookieValue)
  842.     {
  843. ::SaveStringToHeader(pValues,
  844.      (const char*)*(pTempCookie->pCookieName),
  845.      (char*)(const char*)*(pTempCookie->pCookieValue));
  846.     }
  847. }
  848.     }
  850.     if (pCookiesFound2)
  851.     {
  852. for (i = pCookiesFound2->Begin(); i != pCookiesFound2->End(); ++i)
  853. {
  854.     pTempCookie = (CookieStruct*) (*i);
  856.     if(pTempCookie->pCookieName && pTempCookie->pCookieValue)
  857.     {
  858. ::SaveStringToHeader(pValues,
  859.      (const char*)*(pTempCookie->pCookieName),
  860.      (char*)(const char*)*(pTempCookie->pCookieValue));
  861.     }
  863.     HX_DELETE(pTempCookie);
  864. }
  865.     }
  867.     if (m_pCookiesHelper)
  868.     {
  869. hr = m_pCookiesHelper->UnPack(pValues, pCookies);
  870.     }
  872. #ifdef REPORT_COOKIES
  873. // if the preference "CookieData" is set to "console" then write the cookie requests to the console
  874.     IHXBuffer* pBuff = NULL;
  875.     if (m_pPreferences
  876. && m_pPreferences->ReadPref("CookieData", pBuff) == HXR_OK
  877. && 0 == stricmp((const char*)pBuff->GetBuffer(), "console"))
  878.     {
  879. CHXString str;
  880. str.Format("Cookies requested, getting host: %s  path: %s  cookies: %s",
  881. pHost, pPath, 
  882. strCookieReport.IsEmpty() ? "<no cookies>" : (const char *) strCookieReport);
  883. #if defined(_CARBON) || defined(_MAC_MACHO)
  884. CFStringRef stringRef = ::CFStringCreateWithCString( kCFAllocatorDefault, (const char*) str, kCFStringEncodingUTF8 );
  885. ::CFShow(stringRef);
  886. ::CFRelease(stringRef);
  887. #endif
  888.     }
  889.     HX_RELEASE(pBuff);
  890. #endif
  892.     if(!strPlayerCookies.IsEmpty())
  893.     {
  894. pPlayerCookies = new CHXBuffer;
  895. pPlayerCookies->AddRef();
  896. pPlayerCookies->Set((const UCHAR*)(const char*)strPlayerCookies, strPlayerCookies.GetLength() + 1);
  897.     }
  899.     HX_DELETE(pCookiesFound1);
  900.     HX_DELETE(pCookiesFound2);
  901.     HX_VECTOR_DELETE(pData);
  902.     HX_VECTOR_DELETE(pURL);
  904.     HX_RELEASE(pValues);
  905.    
  906.     return hr;
  907. }
  909. HX_RESULT     
  910. HXCookies::PrepareCookiesPath(void)
  911. {
  912.     HX_RESULT hr = HXR_OK;
  913. #ifndef _VXWORKS
  914.     const char* pRMCookiesPath = NULL;
  915.     IHXBuffer* pBuffer = NULL;
  917. #if !defined(_CARBON) && !defined(_MAC_MACHO) /* figured out every time at runtime on the Mac since paths are not stable between runs */
  918.     if (m_pPreferences && (m_pPreferences->ReadPref("CookiesPath", pBuffer) == HXR_OK))
  919.     {
  920. m_pRMCookiesPath = new char[pBuffer->GetSize() + 1];
  921. strcpy(m_pRMCookiesPath, (const char*)pBuffer->GetBuffer()); /* Flawfinder: ignore */
  922.     }
  923.     HX_RELEASE(pBuffer);
  924. #endif
  926.     if( !m_pRMCookiesPath )
  927.     {
  928. if (m_pPreferences && (m_pPreferences->ReadPref("UserSDKDataPath", pBuffer) == HXR_OK))
  929. {
  930.     pRMCookiesPath = (char*) pBuffer->GetBuffer();
  931. }
  932. else
  933. {
  934. #if defined(_CARBON) || defined(_MAC_MACHO)
  935. CHXString strSDKPath = CHXFileSpecUtils::GetAppDataDir(HXVER_SDK_PRODUCT).GetPathName();
  936. #elif defined(_UNIX)
  937.     pRMCookiesPath = getenv("HOME");
  938.     HX_ASSERT( pRMCookiesPath );     
  939. #else
  940.     pRMCookiesPath = GetDLLAccessPath()->GetPath(DLLTYPE_COMMON);
  941. #endif        
  942. }
  944.         if( pRMCookiesPath )
  945.         {
  946.         
  947.             m_pRMCookiesPath = new char[strlen(pRMCookiesPath) + strlen(RM_COOKIE_FILE_NAME)+2];
  948.     ::strcpy(m_pRMCookiesPath, pRMCookiesPath); /* Flawfinder: ignore */
  949.     if (m_pRMCookiesPath[::strlen(m_pRMCookiesPath)-1] != OS_SEPARATOR_CHAR)
  950.     {
  951. strcat(m_pRMCookiesPath, OS_SEPARATOR_STRING); /* Flawfinder: ignore */
  952.     }
  954.     strcat(m_pRMCookiesPath, RM_COOKIE_FILE_NAME); /* Flawfinder: ignore */
  955.             
  956.     HX_RELEASE(pBuffer);
  957.             pBuffer = new CHXBuffer();
  958.             pBuffer->AddRef();
  959.             
  960.             pBuffer->Set((const unsigned char*)m_pRMCookiesPath, strlen(m_pRMCookiesPath) + 1);    
  961.             
  962.             if (m_pPreferences)
  963.             {
  964.                 m_pPreferences->WritePref("CookiesPath", pBuffer);
  965.             }
  967.             HX_RELEASE(pBuffer);
  968.         }
  969.    }
  970. #endif
  972. #ifdef _WINDOWS
  973.     HKEY    hMainAppKey = NULL;
  974.     HKEY    hBiffKey = NULL;
  975.     HKEY    hUsersKey = NULL;
  976.     HKEY    hServersKey = NULL;
  977.     HKEY    hCookiesKey = NULL;
  978.     INT32   lSize = _MAX_PATH - 1;
  979.     UINT32  ulSize = _MAX_PATH - 1;
  980.     UINT32  ulType = 0;
  981.     char    regKey[_MAX_PATH] = {0}; /* Flawfinder: ignore */
  982.     char*   pPath = NULL;
  983.     char*   pUser = NULL;
  984.     char*   pValue = NULL;
  985.     char*   pCursor = NULL;
  987.     // Netscape Browser 4.0+
  988.     if (RegOpenKeyEx(HKEY_CURRENT_USER, 
  989.      OS_STRING("Software\Netscape\Netscape Navigator\biff"), 
  990.      0,
  991.      KEY_READ, &hBiffKey) == ERROR_SUCCESS) 
  992.     {
  993. pUser = new char[_MAX_PATH];
  994. memset(pUser, 0, _MAX_PATH);
  996. if (RegQueryValueEx(hBiffKey, OS_STRING("CurrentUser"), 0, &ulType, (LPBYTE)pUser, &ulSize) == ERROR_SUCCESS) 
  997. {
  998.     SafeSprintf(regKey, _MAX_PATH, "Software\Netscape\Netscape Navigator\biff\users\%s", pUser);
  999.     
  1000.     if (RegOpenKeyEx(HKEY_CURRENT_USER, OS_STRING(regKey), 0, KEY_READ, &hUsersKey) == ERROR_SUCCESS)
  1001.     {
  1002. pValue = new char[_MAX_PATH];
  1003. memset(pValue, 0, _MAX_PATH);
  1005. ulSize = _MAX_PATH - 1;
  1006. if (RegQueryValueEx(hUsersKey, OS_STRING("defaultServer"), 0, &ulType, (LPBYTE)pValue, &ulSize) == ERROR_SUCCESS)
  1007. {
  1008.     SafeSprintf(regKey, _MAX_PATH, "Software\Netscape\Netscape Navigator\biff\users\%s\servers\%s",
  1009.     pUser, pValue);
  1011.     if (RegOpenKeyEx(HKEY_CURRENT_USER, OS_STRING(regKey), 0, KEY_READ, &hServersKey) == ERROR_SUCCESS)
  1012.     {
  1013. pPath = new char[_MAX_PATH];
  1014. memset(pPath, 0, _MAX_PATH);
  1016. ulSize = _MAX_PATH - 1;
  1017. if (RegQueryValueEx(hServersKey, OS_STRING("popstatePath"), 0, &ulType, (LPBYTE)pPath, &ulSize) == ERROR_SUCCESS)
  1018. {
  1019.     // pPath ="..mailpopstate.dat"
  1020.     // the actual location of cookies is 1 level up
  1021.     if (pCursor = ::HXReverseFindChar(pPath, '\'))
  1022.     {
  1023. *pCursor = '';
  1024.     
  1025. if (pCursor = ::HXReverseFindChar(pPath, '\'))
  1026. {
  1027.     *pCursor = '';
  1029.     m_pNSCookiesPath = new char[strlen(pPath) + 13];
  1030.     sprintf(m_pNSCookiesPath, "%s\%s", pPath, RM_COOKIE_FILE_NAME); /* Flawfinder: ignore */
  1031.     goto cleanup;
  1032. }
  1033.     }
  1034. }
  1035.     }
  1036. }
  1037.     }
  1038. }
  1039.     }
  1041.     // Netscape Browser 3.0+
  1042.     if (RegOpenKeyEx(HKEY_CURRENT_USER, OS_STRING("Software\Netscape\Netscape Navigator\Cookies"), 0,
  1043. KEY_READ, &hCookiesKey) == ERROR_SUCCESS) 
  1044.     {
  1045. HX_VECTOR_DELETE(pPath);
  1046. pPath = new char[_MAX_PATH];
  1047. memset(pPath, 0, _MAX_PATH);
  1049. ulSize = _MAX_PATH - 1;
  1050. if (RegQueryValueEx(hCookiesKey, OS_STRING("Cookie File"), 0, &ulType, (LPBYTE)pPath, &ulSize) == ERROR_SUCCESS)
  1051. {
  1052.     m_pNSCookiesPath = new char[strlen(pPath) + 1];
  1053.     strcpy(m_pNSCookiesPath, pPath); /* Flawfinder: ignore */
  1054. }
  1055.     }
  1057. cleanup:
  1059.     HX_RELEASE(pBuffer);
  1061.     if (hMainAppKey)
  1062.     {
  1063. RegCloseKey(hMainAppKey);
  1064.     }
  1066.     if (hBiffKey)
  1067.     {
  1068. RegCloseKey(hBiffKey);
  1069.     }
  1071.     if (hUsersKey)
  1072.     {
  1073. RegCloseKey(hUsersKey);
  1074.     }
  1076.     if (hServersKey)
  1077.     {
  1078. RegCloseKey(hServersKey);
  1079.     }
  1081.     if (hCookiesKey)
  1082.     {
  1083. RegCloseKey(hCookiesKey);
  1084.     }
  1086.     HX_VECTOR_DELETE(pUser);
  1087.     HX_VECTOR_DELETE(pPath);
  1088.     HX_VECTOR_DELETE(pValue);    
  1089. #endif /* _WINDOWS */
  1091.     return hr;
  1092. }
  1094. void
  1095. HXCookies::ResetCookies(CHXSimpleList* pCookieList)
  1096. {
  1097.     CookieStruct*   pCookie = NULL;
  1099.     while (pCookieList && pCookieList->GetCount() > 0)
  1100.     {
  1101. pCookie = (CookieStruct*) pCookieList->RemoveHead();
  1102. HX_DELETE(pCookie);
  1103.     }
  1104. }
  1106. HX_RESULT
  1107. HXCookies::FileReadLine(FILE* fp, char* pLine, UINT32 ulLineBuf, UINT32* pBytesRead)
  1108. {
  1109. #ifdef _OPENWAVE
  1110.     return HXR_NOTIMPL;
  1111. #else
  1112.     HX_RESULT hr = HXR_OK;
  1113.     UINT32 i = 0;
  1114.     UINT32 ulBytesRead = 0;
  1115.     char* pTmpBuf = NULL;
  1117.     if (!fp)
  1118.     {
  1119. hr = HXR_FAILED;
  1120. goto cleanup;
  1121.     }
  1123.     if (ulLineBuf < 1) 
  1124.     {
  1125.         *pBytesRead = 0;
  1126.         goto cleanup;
  1127.     }
  1129.     ulBytesRead = fread(pLine, sizeof(char), ulLineBuf, fp);
  1130.     pTmpBuf = pLine;
  1132.     if (ulBytesRead)
  1133.     {
  1134. while (i < ulBytesRead) 
  1135. {
  1136. #ifdef _MACINTOSH
  1137.     if (pTmpBuf[i] == 10 || pTmpBuf[i] == 13)
  1138. #else
  1139.     if (pTmpBuf[i] == 10)
  1140. #endif
  1141.     {   // LF
  1142. if (pTmpBuf[i+1])
  1143. {
  1144.     pTmpBuf[i+1] = '';
  1145. }
  1147. // Back the file pointer up.
  1148. fseek(fp, (long)((i + 1) - ulBytesRead), SEEK_CUR);
  1149. *pBytesRead = i + 1;
  1150. break;
  1151.     }
  1152.     i++;
  1153. }
  1154.     }
  1155.     else
  1156.     {
  1157. hr = HXR_FAILED;
  1158.     }
  1159.     
  1160. cleanup:
  1162.     return hr;
  1163. #endif /* _OPENWAVE */
  1164. }
  1166. CookieStruct*
  1167. HXCookies::CheckForPrevCookie(char * path,
  1168.        char * hostname,
  1169.        char * name)
  1170. {
  1171.     int     nResult = 0;
  1172.     const char*     pValue = NULL;
  1173.     BOOL     bFound = FALSE;
  1174.     CookieStruct*   pCookie = NULL;
  1175.     CHXSimpleList::Iterator  i;
  1177.     if (!m_pRMCookies)
  1178.     {
  1179. goto cleanup;
  1180.     }
  1182.     for (i = m_pRMCookies->Begin(); i != m_pRMCookies->End(); ++i)
  1183.     {
  1184. pCookie = (CookieStruct*) (*i);
  1186.         if(path && hostname && 
  1187.    pCookie->pPath && 
  1188.    pCookie->pHost && 
  1189.    pCookie->pCookieName &&
  1190.    !pCookie->pCookieName->Compare(name) &&
  1191.    !pCookie->pPath->Compare(path) &&     
  1192.    !pCookie->pHost->CompareNoCase(hostname))
  1193. {
  1194.             bFound = TRUE;
  1195.     break;
  1196. }
  1197.     }
  1199. cleanup:    
  1200.     return bFound?pCookie:NULL;
  1201. }
  1203. HX_RESULT
  1204. HXCookies::OpenCookies(char* pCookieFile, BOOL bRMCookies, CHXSimpleList*& pCookiesList)
  1205. {
  1206. #ifdef _OPENWAVE
  1207.     return HXR_NOTIMPL;
  1208. #else
  1209.     HX_RESULT     hr = HXR_OK;
  1210.     char*     pHost = NULL;
  1211.     char*     pPath = NULL;
  1212.     char*     pCookieName = NULL; 
  1213.     char*     pCookieValue = NULL;
  1214.     char*     pIsDomain = NULL;
  1215.     char*     pXXX = NULL;
  1216.     char*     pExpires = NULL;
  1217.     char*     pBuffer = new char[LINE_BUFFER_SIZE]; /* Flawfinder: ignore */
  1218.     UINT32     ulBytesRead = 0;
  1219.     FILE*     fp = NULL;
  1220.     CookieStruct*   pNewCookie = NULL;
  1221.  
  1222.     pCookiesList = NULL;
  1224.     if (!pBuffer)
  1225.     {
  1226. hr = HXR_FAILED;
  1227. goto cleanup;
  1228.     }
  1230.     pBuffer[0] = '';
  1232.     if (!pCookieFile)
  1233.     {
  1234. hr = HXR_FAILED;
  1235. goto cleanup;
  1236.     }
  1238. #ifdef _WINDOWS
  1239.     if (bRMCookies)
  1240.     {
  1241. if (!m_pLock)
  1242. {
  1243. #ifdef THREADS_SUPPORTED            
  1244.     HXEvent::MakeEvent(m_pLock, "CookieFileLock", FALSE);
  1245. #else            
  1246.     HXEvent::MakeStubEvent(m_pLock, "CookieFileLock", FALSE);
  1247. #endif            
  1248. }
  1249. else
  1250. {
  1251.     m_pLock->Wait();
  1252. }
  1253.     }
  1254. #endif /* _WINDOWS */
  1256.     if (bRMCookies)
  1257.     {
  1258. if(CheckCookies() == HXR_FAIL)
  1259. {
  1260.           hr = HXR_FAILED;
  1261.     goto cleanup;
  1262. }
  1263.     }
  1265.     if (!(fp = fopen(pCookieFile, "r+b")))
  1266.     {
  1267. hr = HXR_FAILED;
  1268. goto cleanup;
  1269.     }
  1271. #if defined (_UNIX) && !defined(_SUN) && !defined(_HPUX) && !defined(_IRIX) && !defined(_AIX) && !defined(_OSF1)
  1272.     if (bRMCookies)
  1273.     {
  1274. m_fileID = fileno(fp);    
  1275. flock(m_fileID, LOCK_EX);
  1276.     }
  1277. #endif /* _UNIX */
  1279.     /* format is:
  1280.      *
  1281.      * host t is_domain t path t xxx t expires t name t cookie
  1282.      *
  1283.      * if this format isn't respected we move onto the next line in the file.
  1284.      *
  1285.      * is_domain is TRUE or FALSE   -- defaulting to FALSE
  1286.      * xxx is TRUE or FALSE     -- should default to TRUE
  1287.      * expires is a time_t integer
  1288.      * cookie can have tabs
  1289.      */
  1290.     while(HXR_OK == FileReadLine(fp, &pBuffer[0], LINE_BUFFER_SIZE, &ulBytesRead))
  1291.     {
  1292. if (*pBuffer == '#' || *pBuffer == CR || *pBuffer == LF || *pBuffer == 0)
  1293. {
  1294.     continue;
  1295. }
  1297. pHost = pBuffer;
  1298.     
  1299. if(!(pIsDomain = strchr(pHost, 't')))
  1300. {
  1301.     continue;
  1302. }
  1303. *pIsDomain++ = '';
  1304. if(*pIsDomain == CR || *pIsDomain == LF || *pIsDomain == 0)
  1305. {
  1306.     continue;
  1307. }
  1309. if(!(pPath = strchr(pIsDomain, 't')))
  1310. {
  1311.     continue;
  1312. }
  1313. *pPath++ = '';
  1314. if(*pPath == CR || *pPath == LF || *pPath == 0)
  1315. {
  1316.     continue;
  1317. }
  1319. if(!(pXXX = strchr(pPath, 't')))
  1320. {
  1321.     continue;
  1322. }
  1323. *pXXX++ = '';
  1324. if(*pXXX == CR || *pXXX == LF || *pXXX == 0)
  1325. {
  1326.     continue;
  1327. }
  1329. if(!(pExpires = strchr(pXXX, 't')))
  1330. {
  1331.     continue;
  1332. }
  1333. *pExpires++ = '';
  1334. if(*pExpires == CR || *pExpires == LF || *pExpires == 0)
  1335. {
  1336.     continue;
  1337. }
  1339. if(!(pCookieName = strchr(pExpires, 't')))
  1340. {
  1341.     continue;
  1342. }
  1343. *pCookieName++ = '';
  1344. if(*pCookieName == CR || *pCookieName == LF || *pCookieName == 0)
  1345. {
  1346.     continue;
  1347. }
  1349. if(!(pCookieValue = strchr(pCookieName, 't')))
  1350. {
  1351.     continue;
  1352. }
  1353. *pCookieValue++ = '';
  1354. if(*pCookieValue == CR || *pCookieValue == LF || *pCookieValue == 0)
  1355. {
  1356.     continue;
  1357. }
  1359. // remove the 'n' from the end of the cookie
  1360. pCookieValue = ::StripLine(pCookieValue);
  1362. // construct a new cookie_struct
  1363. pNewCookie = new CookieStruct;
  1364. if(!pNewCookie)
  1365. {
  1366.     hr = HXR_OUTOFMEMORY;
  1367.     goto cleanup;
  1368. }
  1370. memset(pNewCookie, 0, sizeof(CookieStruct));
  1372. /* copy
  1373.  */
  1374. pNewCookie->pCookieValue = new CHXString(pCookieValue);
  1375. pNewCookie->pCookieName = new CHXString(pCookieName);
  1376. pNewCookie->pPath = new CHXString(pPath);
  1377. pNewCookie->pHost = new CHXString(pHost);
  1379. #ifdef _MACINTOSH
  1380. pNewCookie->expires = (time_t)atoi64(pExpires);
  1381. #else
  1382. pNewCookie->expires = atol(pExpires);
  1383. #endif
  1385. if(!strcasecmp(pIsDomain, "TRUE"))
  1386. {
  1387.     pNewCookie->bIsDomain = TRUE;
  1388. }
  1389. else
  1390. {
  1391.     pNewCookie->bIsDomain = FALSE;
  1392. }
  1394. pNewCookie->bMemoryOnly = FALSE;
  1396. if (!pCookiesList)
  1397. {
  1398.     pCookiesList = new CHXSimpleList();
  1399. }
  1401. hr = AddCookie(pNewCookie, pCookiesList);
  1402.     }
  1404.     UpdateModificationTime();
  1406. cleanup:
  1408. #if defined (_UNIX) && !defined(_SUN) && !defined(_HPUX) && !defined(_IRIX) && !defined(_AIX) && !defined(_OSF1)
  1409.     if (bRMCookies)
  1410.     {
  1411. flock(m_fileID, LOCK_UN);
  1412.     }
  1413. #endif /* _UNIX */
  1415.     if (fp)
  1416.     {
  1417. fclose(fp);
  1418.     }
  1420. #ifdef _WINDOWS
  1421.     if (bRMCookies && m_pLock)
  1422.     {
  1423. m_pLock->SignalEvent();
  1424.     }
  1425. #endif /* _WINDOWS */
  1427.     delete [] pBuffer;
  1428.     
  1429.     return hr;
  1430. #endif /* _OPENWAVE */
  1431. }
  1433. HX_RESULT
  1434. HXCookies::SaveCookies(void)
  1435. {
  1436. #ifdef _OPENWAVE
  1437.     return HXR_NOTIMPL;
  1438. #else
  1439.     HX_RESULT     hr = HXR_OK;
  1440.     FILE*     fp = NULL;
  1441.     INT32     len = 0;
  1442.     char     date_string[36] = {0}; /* Flawfinder: ignore */
  1443.     time_t     cur_date = time(NULL);
  1444.     CookieStruct*   pTempCookie = NULL;
  1445.     CHXSimpleList::Iterator  i;
  1447.     if (!m_pRMCookies || !m_pRMCookiesPath)
  1448.     {
  1449. goto cleanup;
  1450.     }
  1452. #ifdef _WINDOWS
  1453.     if (!m_pLock)
  1454.     {
  1455. #ifdef THREADS_SUPPORTED        
  1456. HXEvent::MakeEvent(m_pLock, "CookieFileLock", FALSE);
  1457. #else        
  1458. HXEvent::MakeStubEvent(m_pLock, "CookieFileLock", FALSE);
  1459. #endif
  1460.     }
  1461.     else
  1462.     {
  1463. m_pLock->Wait();
  1464.     }
  1465. #endif /* _WINDOWS */
  1467.     if (!(fp = fopen(m_pRMCookiesPath, "w")))
  1468.     {
  1469. hr = HXR_FAILED;
  1470. goto cleanup;
  1471.     }
  1473. #ifdef _UNIX
  1474.     //Make the permisions on the cookies file User read/write only.
  1475.     if( chmod( m_pRMCookiesPath, S_IRUSR | S_IWUSR ) != 0 )
  1476.     {
  1477.         HX_ASSERT( "Can't change permision on cookies file." == NULL );
  1478.     }
  1479.     
  1480. #endif    
  1482. #if defined (_UNIX) && !defined(_SUN) && !defined(_HPUX) && !defined(_IRIX) && !defined(_AIX) && !defined(_OSF1)
  1483.     m_fileID = fileno(fp);    
  1484.     flock(m_fileID, LOCK_EX);
  1485. #endif /* _UNIX */
  1487.     fwrite(RM_COOKIE_CAPTION, sizeof(char), strlen(RM_COOKIE_CAPTION), fp);
  1489.     for (i = m_pRMCookies->Begin(); i != m_pRMCookies->End(); ++i)
  1490.     {
  1491. pTempCookie = (CookieStruct*) (*i);
  1493. /* format shall be:
  1494.    *
  1495.  * host t is_domain t path t secure t expires t name t cookie
  1496.  *
  1497.  * is_domain is TRUE or FALSE
  1498.  * secure is TRUE or FALSE  
  1499.  * expires is a time_t integer
  1500.  * cookie can have tabs
  1501.  */
  1502. if(pTempCookie->expires < cur_date)
  1503. {
  1504.     continue;  /* don't write entry if cookie has expired 
  1505. * or has no expiration date
  1506. */
  1507. }
  1509. len = fwrite((const char*)*(pTempCookie->pHost), sizeof(char), pTempCookie->pHost->GetLength(), fp);
  1510. if (len < 0)
  1511. {
  1512.     hr = HXR_FAILED;
  1513.     goto cleanup;
  1514. }
  1515. fwrite("t", sizeof(char), 1, fp);
  1517. if(pTempCookie->bIsDomain)
  1518. {
  1519.     fwrite("TRUE", sizeof(char), 4, fp);
  1520. }
  1521. else
  1522. {
  1523.     fwrite("FALSE", sizeof(char), 5, fp);
  1524. }     
  1525. fwrite("t", sizeof(char), 1, fp);
  1527. fwrite((const char*)*(pTempCookie->pPath), sizeof(char), pTempCookie->pPath->GetLength(), fp);
  1528. fwrite("t", sizeof(char), 1, fp);
  1530. fwrite("FALSE", sizeof(char), 5, fp);
  1531. fwrite("t", sizeof(char), 1, fp);
  1533. sprintf(date_string, "%lu", pTempCookie->expires); /* Flawfinder: ignore */
  1534. fwrite(date_string, sizeof(char), strlen(date_string), fp);
  1535. fwrite("t", sizeof(char), 1, fp);
  1537. fwrite((const char*)*(pTempCookie->pCookieName), sizeof(char), 
  1538. pTempCookie->pCookieName->GetLength(), fp);
  1539. fwrite("t", sizeof(char), 1, fp);
  1541. fwrite((const char*)*(pTempCookie->pCookieValue), sizeof(char), 
  1542. pTempCookie->pCookieValue->GetLength(), fp);
  1543. fwrite(LINEBREAK, sizeof(char), LINEBREAK_LEN, fp);
  1545. //once saved to disk, make sure the memory only flag is false
  1546. pTempCookie->bMemoryOnly = FALSE;
  1547.     }
  1549.     UpdateModificationTime();    
  1550.     m_bSaveCookies = FALSE;
  1552. cleanup:
  1554. #if defined (_UNIX) && !defined(_SUN) && !defined(_HPUX) && !defined(_IRIX) && !defined(_AIX) && !defined(_OSF1)
  1555.     flock(m_fileID, LOCK_UN);
  1556. #endif /* _UNIX */
  1558.     if (fp)
  1559.     {
  1560. fclose(fp);
  1561.     }
  1563. #ifdef _WINDOWS
  1564.     if (m_pLock)
  1565.     {
  1566. m_pLock->SignalEvent();
  1567.     }
  1568. #endif /* _WINDOWS */
  1570.     SecureCookies();
  1572.     return(hr);
  1573. #endif /* _OPENWAVE */
  1574. }
  1576. HX_RESULT
  1577. HXCookies::AddCookie(CookieStruct* pCookie, CHXSimpleList*& pCookiesList)
  1578. {
  1579.     HX_RESULT     hr = HXR_OK;
  1580.     BOOL     bShorterPathFound = FALSE;
  1581.     CookieStruct*   pTempCookie = NULL;
  1582.     LISTPOSITION    position;
  1584.     if (!pCookie || !pCookiesList)
  1585.     {
  1586. hr = HXR_FAILED;
  1587. goto cleanup;
  1588.     }
  1590.     /* add it to the list so that it is before any strings of
  1591.      * smaller length
  1592.      */
  1593.     position = pCookiesList->GetHeadPosition();
  1594.     while (position != NULL)
  1595.     {
  1596. pTempCookie = (CookieStruct*) pCookiesList->GetNext(position);
  1598. if (strlen(*pCookie->pPath) > strlen(*pTempCookie->pPath))
  1599. {
  1600.     // Remember that we found a shorter path
  1601.     bShorterPathFound = TRUE;
  1603.     // If the position is null, then event was the first
  1604.     // item in the list, and we need to do some fancy footwork...
  1605.     if (!position)
  1606.     {
  1607. POSITION theTail = pCookiesList->GetTailPosition();
  1608. pCookiesList->InsertBefore(theTail,(void*) pCookie);
  1609.     }
  1610.     // otherwise, roll after one...
  1611.     else
  1612.     {
  1613. pCookiesList->GetPrev(position);
  1615. if (!position)
  1616. {
  1617.     pCookiesList->AddHead((void*) pCookie);
  1618. }
  1619. else
  1620. {
  1621.     pCookiesList->InsertBefore(position,(void*) pCookie);
  1622. }
  1623.     }
  1625.     break;
  1626. }
  1627.     }
  1629.     // If we didn't find an earlier packet, then we should insert at
  1630.     // the head of the list...
  1631.     if (!bShorterPathFound)
  1632.     {
  1633. pCookiesList->AddTail((void*) pCookie);
  1634.     }
  1636. cleanup:
  1638.     return hr;
  1639. }
  1641. BOOL
  1642. HXCookies::WasCookieAdded(CHXSimpleList* pCookiesList, CookieStruct* pCookie)
  1643. {
  1644.     BOOL bResult = FALSE;
  1645.     CookieStruct*  pTempCookie = NULL;
  1646.     CHXSimpleList::Iterator  i;
  1648.     if (!pCookiesList || !pCookie)
  1649.     {
  1650. goto cleanup;
  1651.     }
  1653.     for (i = pCookiesList->Begin(); i != pCookiesList->End(); ++i)
  1654.     {
  1655. pTempCookie = (CookieStruct*) (*i);
  1657. if (pTempCookie->pCookieName && pCookie->pCookieName 
  1658. && *(pTempCookie->pCookieName) == *(pCookie->pCookieName) 
  1659. && pTempCookie->pHost && pCookie->pHost)
  1660. {
  1661.     if(DoesDomainMatch(*pTempCookie->pHost, *pCookie->pHost))
  1662.     {
  1663. bResult = TRUE;
  1664. break;
  1665.     }
  1666. }
  1667.     }
  1669. cleanup:
  1671.     return bResult;
  1672. }
  1675. BOOL HXCookies::DoesDomainMatch(const char* szDomain, const char* szDomainToParse)
  1676. {
  1677.     BOOL bMatches = FALSE;
  1678.     CHXString cHostCopy;
  1679.     CHXString cDomainCopy;
  1680.     CHXString cHostRight;
  1682.     if(!szDomain || !szDomainToParse || !strlen(szDomain) || !strlen(szDomainToParse))
  1683.     {
  1684. goto cleanup;
  1685.     }
  1687.     cHostCopy = szDomainToParse;
  1688.     cDomainCopy = szDomain;
  1689.     cDomainCopy.MakeLower();
  1691.     // Now we compare the domain (from the cookie itself) with
  1692.     // the rightmost characters of the host. For instance,
  1693.     // a domain of ".bar.com" would match with a host (passed in)
  1694.     // of "foo.bar.com", "www.bar.com", etc. but would NOT match
  1695.     // a host of "bar.com".
  1696.     cHostRight = cHostCopy.Right(cDomainCopy.GetLength());
  1697.     if (cHostRight != cDomainCopy)
  1698.     {
  1699.         // no match
  1700.         goto cleanup;
  1701.     }
  1702.     else if (cDomainCopy.GetAt(0) != '.' && cHostCopy.GetLength() > cDomainCopy.GetLength() &&
  1703.                  cHostCopy.GetAt(cHostCopy.GetLength() - cDomainCopy.GetLength() - 1) != '.')
  1704.     {
  1705.        // no match
  1706.         goto cleanup;
  1707.     }
  1708.     bMatches = TRUE;
  1710. cleanup:
  1711.     return bMatches;
  1712. }
  1715. BOOL
  1716. HXCookies::IsCookieEnabled()
  1717. {
  1718.     BOOL bResult = TRUE;
  1719.     IHXBuffer* pBuffer = NULL;
  1721.     if (!m_pPreferences)
  1722.     {
  1723. if (HXR_OK != m_pContext->QueryInterface(IID_IHXPreferences, (void**)&m_pPreferences))
  1724. {
  1725.     m_pPreferences = NULL;
  1726. }
  1727.     }
  1729.     if (m_pPreferences &&
  1730. m_pPreferences->ReadPref("CookiesEnabled", pBuffer) == HXR_OK)
  1731.     {
  1732. if (strcmp((const char*)pBuffer->GetBuffer(), "0") == 0)
  1733. {
  1734.     bResult = FALSE;
  1735. }
  1737. HX_RELEASE(pBuffer);
  1738.     } 
  1739.     return bResult;
  1740. }
  1742. void     
  1743. HXCookies::UpdateModificationTime(void)
  1744. {
  1745. #ifdef _OPENWAVE
  1746.     // XXXSAB implement this!!!
  1747. #else
  1748.     struct stat status;
  1750.     if (!m_pRMCookiesPath)
  1751.     {
  1752. goto cleanup;
  1753.     }
  1755. #ifndef _VXWORKS
  1756.     if (0 == stat(m_pRMCookiesPath, &status))
  1757.     {
  1758. m_lastModification = status.st_mtime;
  1759.     }
  1760. #endif /* _VXWORKS */
  1762. cleanup:
  1764.     return;
  1765. #endif
  1766. }
  1768. BOOL     
  1769. HXCookies::IsCookieFileModified(void)
  1770. {
  1771. #ifdef _OPENWAVE
  1772.     // XXXSAB implement this!!!
  1773.     return FALSE;
  1774. #else
  1775.     BOOL bResult = FALSE;
  1776.     struct stat status;
  1778.     if (!m_pRMCookiesPath)
  1779.     {
  1780. goto cleanup;
  1781.     }
  1783. #ifndef _VXWORKS
  1784.     if (0 == stat(m_pRMCookiesPath, &status) &&
  1785. status.st_mtime != m_lastModification)
  1786.     {
  1787. bResult = TRUE;
  1788.     }
  1789. #endif /* _VXWORKS */
  1791. cleanup:
  1793.     return bResult;
  1794. #endif
  1795. }
  1797. HX_RESULT
  1798. HXCookies::MergeCookieList(CHXSimpleList* pFromList, CHXSimpleList* pToList)
  1799. {
  1800.     HX_RESULT     hr = HXR_OK;
  1801.     CookieStruct*   pCookie = NULL;
  1802.     CHXSimpleList::Iterator  i;
  1804.     if (!pFromList)
  1805.     {
  1806. goto cleanup;
  1807.     }
  1809.     for (i = pFromList->Begin(); HXR_OK == hr && i != pFromList->End(); ++i)
  1810.     {
  1811. pCookie = (CookieStruct*) (*i);
  1813. if (pCookie->bMemoryOnly && !WasCookieAdded(pToList, pCookie))
  1814. {
  1815.     CookieStruct* pNewCookie = new CookieStruct;
  1816.     pNewCookie->pPath = new CHXString(*pCookie->pPath);
  1817.     pNewCookie->pHost = new CHXString(*pCookie->pHost);
  1818.     pNewCookie->pCookieName = new CHXString(*pCookie->pCookieName);
  1819.     pNewCookie->pCookieValue = new CHXString(*pCookie->pCookieValue);
  1820.     pNewCookie->expires = pCookie->expires;
  1821.     pNewCookie->bIsDomain = pCookie->bIsDomain;
  1822.     pNewCookie->bMemoryOnly = pCookie->bMemoryOnly;
  1823.     hr = AddCookie(pNewCookie, pToList);
  1824. }
  1825.     }
  1827. cleanup:
  1829.     return hr;
  1830. }
  1832. HX_RESULT
  1833. HXCookies::SyncRMCookies(BOOL bSave)
  1834. {
  1835.     HX_RESULT     hr = HXR_OK;
  1836.     CHXSimpleList*  pNewRMCookies = NULL;
  1837.     CHXSimpleList::Iterator i;
  1838.     CookieStruct* pCookie = NULL;
  1839.     BOOL bCookieFileModified = FALSE;
  1841.     if (!m_bInitialized)
  1842.     {
  1843. hr = HXR_FAILED;
  1844. goto cleanup;
  1845.     }
  1847.     bCookieFileModified = IsCookieFileModified();
  1848.     if (bCookieFileModified)
  1849.     {
  1850. if (HXR_OK == OpenCookies(m_pRMCookiesPath, TRUE, pNewRMCookies))
  1851. {
  1852.     if (m_bSaveCookies)
  1853.     {
  1854. MergeCookieList(m_pRMCookies, pNewRMCookies);
  1855.     }
  1856.      
  1857.     ResetCookies(m_pRMCookies);
  1858.     HX_DELETE(m_pRMCookies);
  1860.     m_pRMCookies = pNewRMCookies;
  1861. }          
  1862.     }
  1864.     if (bSave && m_bSaveCookies)
  1865.     {
  1866. if(m_pRMCookies && bCookieFileModified && pNewRMCookies == NULL)
  1867. {
  1868.     //this means there are no more cookies on disk, and we need to look at what's in memory, and keep
  1869.     //only cookies that have bMemoryOnly set
  1870.     pNewRMCookies = new CHXSimpleList;
  1872.     while (m_pRMCookies && m_pRMCookies->GetCount() > 0 && pNewRMCookies)
  1873.     {
  1874.      pCookie = (CookieStruct*) m_pRMCookies->RemoveHead();
  1875. if(pCookie->bMemoryOnly)
  1876. {
  1877.     CookieStruct* pNewCookie = new CookieStruct;
  1878.     pNewCookie->pPath = new CHXString(*pCookie->pPath);
  1879.     pNewCookie->pHost = new CHXString(*pCookie->pHost);
  1880.     pNewCookie->pCookieName = new CHXString(*pCookie->pCookieName);
  1881.     pNewCookie->pCookieValue = new CHXString(*pCookie->pCookieValue);
  1882.     pNewCookie->expires = pCookie->expires;
  1883.     pNewCookie->bIsDomain = pCookie->bIsDomain;
  1884.     pNewCookie->bMemoryOnly = pCookie->bMemoryOnly;
  1885.     AddCookie(pNewCookie, pNewRMCookies);
  1886. }
  1887.      HX_DELETE(pCookie);
  1888.     }
  1889.     HX_DELETE(m_pRMCookies);
  1890.     m_pRMCookies = pNewRMCookies;
  1891. }
  1892. hr = SaveCookies();
  1893.     }
  1895. cleanup:
  1897.     return hr;
  1898. }
  1900. #ifdef _TEST
  1901. void
  1902. HXCookies::DumpCookies(void)
  1903. {
  1904.     CHXSimpleList* pCookies = NULL;
  1905.     CookieStruct*  pCookie = NULL;
  1906.     CHXSimpleList::Iterator  i;
  1908.     for (int l = 0; l < 2; l++)
  1909.     {
  1910. switch (l)
  1911. {
  1912. case 0:
  1913.     pCookies = m_pNSCookies;
  1914.     break;
  1915. case 1:
  1916.     pCookies = m_pRMCookies;
  1917.     break;
  1918. default:
  1919.     break;
  1920. }
  1922. if (pCookies)
  1923. {
  1924.     printf("Total cookies: %lun", pCookies->GetCount());
  1925.     
  1926.     for (i = pCookies->Begin(); i != pCookies->End(); ++i)
  1927.     {
  1928. pCookie = (CookieStruct*) (*i);
  1930. printf("%st%st%sn",
  1931.        (const char*)*(pCookie->pHost),
  1932.        (const char*)*(pCookie->pCookieName),
  1933.        (const char*)*(pCookie->pCookieValue));
  1934.     }
  1935. }
  1936.     }
  1938.     return;
  1939. }
  1940. #endif // _TEST
  1945. //IRPCookies
  1946. STDMETHODIMP HXCookies::GetExpiredCookies(const char* pHost,
  1947.          const char*        pPath,
  1948.          REF(IHXBuffer*)   pCookies)
  1949. {
  1950.     HX_RESULT     hr = HXR_OK;
  1951.     char*     cp = NULL;
  1952.     char*     pComma = NULL;
  1953.     char*     pEqualSign = NULL;
  1954.     char*     pData = NULL;
  1955.     char*     pURL = NULL;
  1956.     int     l = 0;
  1957.     int     host_length = 0;
  1958.     int     path_length = 0;
  1959.     int     domain_length = 0;
  1960.     BOOL     bAdded = FALSE;
  1961.     UINT32     dwSize = 0;    
  1962.     time_t     cur_time = time(NULL);
  1963.     CookieStruct*   pTempCookie = NULL;
  1964.     CookieStruct*   pNewCookie = NULL;
  1965.     CHXSimpleList*  pCookiesFound1 = NULL;
  1966.     //CHXSimpleList*  pCookiesFound2 = NULL;
  1967.     CHXSimpleList*  pCookiesList = NULL;
  1968.     IHXValues*     pValues = NULL;
  1969.     CHXSimpleList::Iterator  i;
  1970.     CHXString       cHostCopy;
  1971.     INT32           lColon;
  1972.     
  1973.     pCookies = NULL;
  1975.     if (!IsCookieEnabled())
  1976.     {
  1977. goto cleanup;
  1978.     }
  1980.     if (!m_bInitialized)
  1981.     {
  1982. hr = Initialize();
  1984. if (HXR_OK != hr)
  1985. {
  1986.     goto cleanup;
  1987. }
  1988.     }
  1989.     else
  1990.     {
  1991. SyncRMCookies(FALSE);
  1992.     }
  1994.     if (!pHost || !m_pCookiesHelper)
  1995.     {
  1996. hr = HXR_FAILED;
  1997. goto cleanup;
  1998.     }
  2000.     // return string to build    
  2001.     if (!(pValues = new CHXHeader()))
  2002.     {
  2003. hr = HXR_OUTOFMEMORY;
  2004. goto cleanup;
  2005.     }
  2007.     pValues->AddRef();
  2009.     cHostCopy = pHost;
  2010.     lColon    = cHostCopy.Find(':');
  2011.     if (lColon >= 0)
  2012.     {
  2013. cHostCopy = cHostCopy.Left(lColon);
  2014.     }
  2015.     cHostCopy.MakeLower();
  2017.     // search for all cookies(Netscape only for now)
  2018.     for (l = 0; l < 2; l++)
  2019.     {
  2020. switch (l)
  2021. {
  2022. case 0:
  2023.     pCookiesList = m_pRMCookies;
  2024.     break;
  2025. case 1:
  2026.     pCookiesList = m_pNSCookies;
  2027.     break;
  2028. default:
  2029.     break;
  2030. }
  2032. if (!pCookiesList)
  2033. {
  2034.     continue;
  2035. }
  2037. for (i = pCookiesList->Begin(); i != pCookiesList->End(); ++i)
  2038. {
  2039.     pTempCookie = (CookieStruct*) (*i);
  2040.     
  2041.     if (!pTempCookie->pHost)
  2042.     {
  2043. continue;
  2044.     }
  2046.     // check the host or domain first
  2047.     if(pTempCookie->bIsDomain)
  2048.     {
  2049. domain_length = pTempCookie->pHost->GetLength();
  2051. CHXString cDomainCopy(*(pTempCookie->pHost));
  2052. cDomainCopy.MakeLower();
  2054. // Now we compare the domain (from the cookie itself) with
  2055. // the rightmost characters of the host. For instance,
  2056. // a domain of ".bar.com" would match with a host (passed in)
  2057. // of "foo.bar.com", "www.bar.com", etc. but would NOT match
  2058. // a host of "bar.com".
  2059. CHXString cHostRight = cHostCopy.Right(cDomainCopy.GetLength());
  2060. if (cHostRight != cDomainCopy)
  2061. {
  2062.     // no match
  2063.     continue;
  2064. }
  2065.     }
  2066.     else if(strcasecmp((const char*)*(pTempCookie->pHost), pHost))
  2067.     {
  2068. // hostname matchup failed.
  2069. continue;
  2070.     }
  2072.     // shorter strings always come last so there can be no
  2073.     // ambiquity             
  2074.     if(pTempCookie->pPath && 
  2075.        !strncmp(pPath, (const char*)*(pTempCookie->pPath), pTempCookie->pPath->GetLength()))
  2076.     {
  2077. // check for expired cookies
  2078. if(pTempCookie->expires && (pTempCookie->expires < cur_time))
  2079. {
  2080.     if (!pCookiesFound1)
  2081.     {
  2082.         pCookiesFound1 = new CHXSimpleList();
  2083.     }
  2084.     pCookiesFound1->AddTail(pTempCookie);
  2085. }
  2086.     }
  2087. }
  2088.     }
  2090. #ifdef _WINDOWS
  2091.     if (!_pInternetGetCookie || m_bMemoryOnly)
  2092.     {
  2093. goto cleanup;
  2094.     }
  2096.     host_length = strlen(pHost);
  2098.     if (pPath)
  2099.     {
  2100. path_length = strlen(pPath);
  2101.     }
  2103.     pURL = new char[host_length + path_length + 8];
  2104.     sprintf(pURL, "http://%s%s", pHost, pPath); /* Flawfinder: ignore */
  2106.     if (_pInternetGetCookie(pURL, NULL, pData, &dwSize) && !pData && dwSize)
  2107.     {
  2108. pData = new char[dwSize+1];
  2110. if (!_pInternetGetCookie(pURL, NULL, pData, &dwSize))
  2111. {
  2112.     goto cleanup;
  2113. }
  2115. cp = pData;
  2117. while (pComma = (char*) ::HXFindChar(cp, ';'))
  2118. {
  2119.     *pComma = '';
  2120.     pComma++;
  2122.     if (pEqualSign = (char*) ::HXFindChar(cp, '='))
  2123.     {
  2124. *pEqualSign = '';
  2125. pEqualSign++;
  2127. pNewCookie = new CookieStruct;
  2128. bAdded = FALSE;
  2130. // copy
  2131. pNewCookie->pCookieValue = new CHXString(pEqualSign);
  2132. pNewCookie->pCookieName = new CHXString(cp);
  2133. pNewCookie->pPath = NULL;
  2134. pNewCookie->pHost = NULL;
  2135. pNewCookie->expires = 0;
  2136. pNewCookie->bIsDomain = FALSE;
  2137. pNewCookie->bMemoryOnly = FALSE;
  2139. if (!WasCookieAdded(pCookiesFound1, pNewCookie))
  2140. {
  2141.     //if (!pCookiesFound2)
  2142.     //{
  2143.     // pCookiesFound2 = new CHXSimpleList();
  2144.     // pCookiesFound2->AddTail(pNewCookie);
  2145.     // bAdded = TRUE;
  2146.     //}
  2147.     //else if (!WasCookieAdded(pCookiesFound2, pNewCookie))
  2148.     //{
  2149.     // pCookiesFound2->AddTail(pNewCookie);
  2150.     // bAdded = TRUE;
  2151.     //}
  2152. }
  2154. if (!bAdded)
  2155. {
  2156.     HX_DELETE(pNewCookie);
  2157. }
  2158.     }
  2160.     cp = pComma;
  2161. }
  2163. if (pEqualSign = (char*) ::HXFindChar(cp, '='))
  2164. {
  2165.     *pEqualSign = '';
  2166.     pEqualSign++;
  2168.     pNewCookie = new CookieStruct;
  2169.     bAdded = FALSE;
  2171.     // copy
  2172.     pNewCookie->pCookieValue = new CHXString(pEqualSign);
  2173.     pNewCookie->pCookieName = new CHXString(cp);
  2174.     pNewCookie->pPath = NULL;
  2175.     pNewCookie->pHost = NULL;
  2176.     pNewCookie->expires = 0;
  2177.     pNewCookie->bIsDomain = FALSE;
  2178.     pNewCookie->bMemoryOnly = FALSE;
  2180.     if (!WasCookieAdded(pCookiesFound1, pNewCookie))
  2181.     {
  2182. //if (!pCookiesFound2)
  2183. //{
  2184. //    pCookiesFound2 = new CHXSimpleList();
  2185. //    pCookiesFound2->AddTail(pNewCookie);
  2186. //    bAdded = TRUE;
  2187. //}
  2188. //else if (!WasCookieAdded(pCookiesFound2, pNewCookie))
  2189. //{
  2190. //    pCookiesFound2->AddTail(pNewCookie);
  2191. //    bAdded = TRUE;
  2192. //}
  2193.     }
  2195.     if (!bAdded)
  2196.     {
  2197. HX_DELETE(pNewCookie);
  2198.     }
  2199. }
  2200.     }
  2201. #endif /* _WINDOWS */
  2203. cleanup:
  2205.     if (pCookiesFound1)
  2206.     {
  2207. for (i = pCookiesFound1->Begin(); i != pCookiesFound1->End(); ++i)
  2208. {
  2209.     pTempCookie = (CookieStruct*) (*i);
  2211.     if(pTempCookie->pCookieName && pTempCookie->pCookieValue)
  2212.     {
  2213. ::SaveStringToHeader(pValues,
  2214.      (const char*)*(pTempCookie->pCookieName),
  2215.      (char*)(const char*)*(pTempCookie->pCookieValue));
  2216.     }
  2217. }
  2218.     }
  2220.     //if (pCookiesFound2)
  2221.     //{
  2222.     // for (i = pCookiesFound2->Begin(); i != pCookiesFound2->End(); ++i)
  2223.     // {
  2224.     //     pTempCookie = (CookieStruct*) (*i);
  2225.     //
  2226.     //     if(pTempCookie->pCookieName && pTempCookie->pCookieValue)
  2227.     //     {
  2228.     // ::SaveStringToHeader(pValues,
  2229.     //      (const char*)*(pTempCookie->pCookieName),
  2230.     //      (char*)(const char*)*(pTempCookie->pCookieValue));
  2231.     //     }
  2232.     //
  2233.     //     HX_DELETE(pTempCookie);
  2234.     // }
  2235.     //}
  2237.     if (m_pCookiesHelper)
  2238.     {
  2239. hr = m_pCookiesHelper->UnPack(pValues, pCookies);
  2240.     }
  2242.     HX_DELETE(pCookiesFound1);
  2243.     //HX_DELETE(pCookiesFound2);
  2244.     HX_VECTOR_DELETE(pData);
  2245.     HX_VECTOR_DELETE(pURL);
  2247.     HX_RELEASE(pValues);
  2248.    
  2249.     return hr;
  2250. }
  2252. HX_RESULT HXCookies::SecureCookies()
  2253. {
  2254.     return HXR_OK;
  2255. }
  2257. HX_RESULT HXCookies::CheckCookies()
  2258. {
  2259.     return HXR_OK;
  2260. }