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

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

Symbian

开发平台：

Visual C++

hxurl.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: hxurl.cpp,v 1.25.2.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.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. #include "hlxclib/string.h"
  51. #include "hlxclib/stdlib.h"
  52. //#include "hlxclib/stdio.h"
  53. #include <ctype.h>
  55. #include "hxcom.h"
  56. #include "hxtypes.h"
  57. #include "hxresult.h"
  58. #include "hxcomm.h"
  59. #include "tparse.h"
  60. #include "dbcs.h"
  61. #include "protdefs.h"
  62. #include "hxstrutl.h"
  63. #include "hxslist.h"
  64. #include "hxurl.h"
  65. #include "ihxpckts.h"
  66. #include "chxminiccf.h"
  68. #include "hxheap.h"
  69. #ifdef _DEBUG
  70. #undef HX_THIS_FILE
  71. static const char HX_THIS_FILE[] = __FILE__;
  72. #endif
  74. /* We should really define it in a common header file */
  75. #if defined (_WINDOWS ) || defined (WIN32) || defined(_SYMBIAN)
  76. #define OS_SEPARATOR_CHAR '\'
  77. #define OS_SEPARATOR_STRING "\"
  78. #elif defined (_UNIX) || defined(_OPENWAVE)
  79. #define OS_SEPARATOR_CHAR '/'
  80. #define OS_SEPARATOR_STRING "/"
  81. #elif defined (_MACINTOSH)
  82. #define OS_SEPARATOR_CHAR ':'
  83. #define OS_SEPARATOR_STRING ":"
  84. #else
  85. #error "undefined platform hxurl.cpp"
  86. #endif // defined (_WINDOWS ) || defined (WIN32)
  88. CHXURL::CHXURL (const char* pszURL)
  89. :m_LastError (HXR_OK)
  90. ,m_pActualURL(NULL)
  91.                 ,m_pszURL(NULL)
  92.                 ,m_pszEscapedURL(NULL)
  93. ,m_pszOptions (NULL)
  94. ,m_pszHost (NULL)
  95. ,m_pszPort (NULL)
  96. ,m_pszUsername(NULL)
  97. ,m_pszPassword(NULL)
  98. ,m_unProtocol(fileProtocol)
  99.                 ,m_unDefaultPort(0)
  100. ,m_bNetworkProtocol (FALSE)
  101. ,m_pszResource (NULL)
  102. ,m_pProperties (NULL)
  103. ,m_pOptions (NULL)
  104.                 ,m_pCCF(CreateCCF())
  105. {
  106.     if (m_pCCF)
  107.     {
  108. m_pCCF->AddRef();
  109.     }
  110.     
  111.     ConstructURL(pszURL);
  112. }
  114. CHXURL::CHXURL (const char* pszURL, IUnknown* pContext)
  115. :m_LastError (HXR_OK)
  116. ,m_pActualURL(NULL)
  117.                 ,m_pszURL(NULL)
  118.                 ,m_pszEscapedURL(NULL)
  119. ,m_pszOptions (NULL)
  120. ,m_pszHost (NULL)
  121. ,m_pszPort (NULL)
  122. ,m_pszUsername(NULL)
  123. ,m_pszPassword(NULL)
  124. ,m_unProtocol(fileProtocol)
  125.                 ,m_unDefaultPort(0)
  126. ,m_bNetworkProtocol (FALSE)
  127. ,m_pszResource (NULL)
  128. ,m_pProperties (NULL)
  129. ,m_pOptions (NULL)
  130.                 ,m_pCCF(0)
  131. {
  132.     if (pContext)
  133.     {
  134. pContext->QueryInterface(IID_IHXCommonClassFactory, (void**)&m_pCCF);
  135.     }
  136.     
  137.     ConstructURL(pszURL);
  138. }
  140. void CHXURL::ConstructURL(const char* pszURL)
  141. {
  142.     char*   pszInputURL = NULL;
  143.     char*   pszTemp = NULL;
  144.     char*   pFragment = NULL;
  145.     char*   pNewURL = NULL;
  146.     char*   pResource = NULL;
  147.     char*   pszDollarSign = NULL;
  149.     HX_ASSERT(pszURL != NULL);
  151.     if (!pszURL)
  152.     {
  153. m_LastError = HXR_INVALID_PATH;
  154. return;
  155.     }
  156.     
  157.     if (!m_pCCF)
  158.     {
  159. m_LastError = HXR_UNEXPECTED;
  160. return;
  161.     }
  163.     pszInputURL = new char[strlen(pszURL) + 1];
  164.     if(!pszInputURL)
  165.     {
  166.         m_LastError = HXR_OUTOFMEMORY;
  167.         return;
  168.     }
  169.     strcpy(pszInputURL, pszURL); /* Flawfinder: ignore */
  171.     // Keep permanent copy of input url
  172.     m_pszEscapedURL = new char[strlen(pszInputURL)+1];
  173.     strcpy(m_pszEscapedURL, pszInputURL); /* Flawfinder: ignore */
  175.     // IHXValues 
  176.     if (m_pCCF)
  177.     {
  178. m_pCCF->CreateInstance(CLSID_IHXValues, (void**)&m_pProperties);
  179. m_pCCF->CreateInstance(CLSID_IHXValues, (void**)&m_pOptions);
  180.     }
  182.     // protocol: determine whether it's network or local
  183.     if (0 == StringNCompare(pszInputURL, "http:", 5))
  184.     {
  185. m_unProtocol = httpProtocol;
  186. m_unDefaultPort = DEFAULT_HTTP_PORT;
  187.     }
  188.     else if (0 == StringNCompare(pszInputURL, "chttp:", 6))
  189.     {
  190. m_unProtocol = httpProtocol;
  191. m_unDefaultPort = DEFAULT_HTTP_PORT;
  192.     }
  193.     else if (0 == StringNCompare(pszInputURL, "pnm:", 4))
  194.     {
  195. m_unProtocol = pnmProtocol;
  196. m_bNetworkProtocol = TRUE;
  197. m_unDefaultPort = DEFAULT_PNA_PORT;
  198.     }
  199.     else if (0 == StringNCompare(pszInputURL, "rtsp:", 5))
  200.     {
  201. m_unProtocol = rtspProtocol;
  202. m_bNetworkProtocol = TRUE;
  203. m_unDefaultPort = DEFAULT_RTSP_PORT;
  204.     }
  205.     else if (0 == StringNCompare(pszInputURL, "helix-sdp:", 10))
  206.     {
  207. m_unProtocol = helixSDPProtocol;
  208. m_bNetworkProtocol = TRUE;
  209. m_unDefaultPort = DEFAULT_RTSP_PORT;
  210.     }
  211.     else if (0 == StringNCompare(pszInputURL, "https:", 6))
  212.     {
  213. m_unProtocol = httpsProtocol;
  214. m_unDefaultPort = DEFAULT_HTTPS_PORT;
  215.     }
  217.     if (m_pProperties)
  218.     {
  219. m_pProperties->SetPropertyULONG32(PROPERTY_PROTOCOL, (ULONG32)m_unProtocol);
  220.     }
  221.     else
  222.     {
  223. m_LastError = HXR_UNEXPECTED;
  224. goto cleanup;
  225.     }
  227.     // no need to further parse helix-sdp protocol
  228.     if (helixSDPProtocol != m_unProtocol)
  229.     {
  230.         // separate fragment from the URL
  231.         if (0!=(pszTemp = (char*) ::HXFindChar(pszInputURL, '#')))
  232.         {
  233.     // save fragment
  234.     pFragment = pszTemp + 1;
  235.     ::SaveStringToHeader(m_pProperties, PROPERTY_FRAGMENT, pFragment);
  236.     *pszTemp = '';
  237.         }
  239.         // HP - allow '$' in directory/file name
  240.         //
  241.         // still need to take care of that obsolete $ sign option:
  242.         // rtsp://moe.cr.prognet.com/ambush.rm$1:00
  243.         // time after the $ is assumed to be the start time.
  244.         //
  245.         // the solution is to compare the string following the $ to 
  246.         // a properly formed time. If the string is a time and only 
  247.         // a time, then we know its the old-style start-time option
  248.         // otherwise, '$' is part of the directory/file name and we
  249.         // will keep it.
  250.         pszDollarSign = (char*) ::HXFindChar(pszInputURL, '$');
  251.         while (pszDollarSign)
  252.         {
  253.     pszTemp = pszDollarSign + 1;
  255.     if (::TimeParse(pszTemp))
  256.     {
  257.         *pszDollarSign = '';
  258.         INT32 lLen = (2 * strlen(pszURL)) + 8;
  259.         pNewURL = new char[lLen];
  260.         memset(pNewURL, 0, lLen);
  261.           
  262.         // upgrade to a new URL
  263.         SafeSprintf(pNewURL, lLen, "%s?start=%s", pszInputURL, pszTemp);
  265.         HX_VECTOR_DELETE(pszInputURL);
  266.         pszInputURL = pNewURL;
  267.         break;
  268.     }
  270.     pszDollarSign = (char*) ::HXFindChar(pszTemp, '$');
  271.         }
  272.     }
  274. #if !defined(_MACINTOSH) && !defined(_MAC_UNIX)
  275.     // on Mac, unescaping can put /'s and ?'s back into file and folder names, which is deadly inside URLs
  276.     //if (0 == StringNCompare(pszInputURL, "file:", 5))
  277.     {
  278. // we only unescape the URL on local source since we are
  279. // *responding* instead of *requesting* for the given source
  280. Unescape(pszInputURL);
  281.     }
  282. #endif
  284.     if (!CompressURL(pszInputURL, m_pszURL))
  285.     {
  286. // make a copy of the URL
  287. m_pszURL = new char[strlen(pszInputURL)+1];
  288. strcpy(m_pszURL, pszInputURL); /* Flawfinder: ignore */
  289.     }
  291.     m_pActualURL = new char[strlen(m_pszURL)+1];
  292.     strcpy(m_pActualURL, m_pszURL); /* Flawfinder: ignore */
  294.     ::SaveStringToHeader(m_pProperties, PROPERTY_URL, m_pszURL);
  296.     // no need to further parse helix-sdp protocol
  297.     if (helixSDPProtocol != m_unProtocol)
  298.     {
  299.         // separate options from the URL
  300.         if (0 != (pszTemp = (char*) ::HXFindChar(m_pszURL, '?')))
  301.         {
  302.     // options
  303.     m_pszOptions = pszTemp + 1;
  304.         }
  305.        
  306.         // collect protocol, host, port and resource info
  307.         ParseURL (m_pszURL);
  308.     
  309.         // collect other options info if it has 
  310.         if (m_pszOptions)
  311.         {
  312.     if (HXR_INCOMPLETE == CollectOptions(m_pszOptions) && m_pszResource)
  313.     {
  314.              // bad options and remove it from the URL
  315.              pszTemp = (char*) ::HXFindChar(m_pszResource, '?');
  316.         if (pszTemp)
  317.         {
  318.     *pszTemp = '';
  320.     ParseResource();
  321.         }
  322.     }
  323.         }   
  324.     }
  326. cleanup:
  328.     HX_VECTOR_DELETE(pszInputURL);
  329. }
  331. CHXURL::~CHXURL ()
  332. {
  333.     HX_VECTOR_DELETE(m_pActualURL);
  334.     HX_VECTOR_DELETE(m_pszURL);
  335.     HX_VECTOR_DELETE(m_pszEscapedURL);
  337.     HX_RELEASE(m_pProperties);
  338.     HX_RELEASE(m_pOptions);
  340.     HX_RELEASE(m_pCCF);
  341. }
  343. CHXURL::CHXURL(const CHXURL& rhs) 
  344.     :m_LastError (HXR_OK)
  345.     ,m_pActualURL(NULL)
  346.     ,m_pszURL(NULL)
  347.     ,m_pszOptions (NULL)
  348.     ,m_pszHost (NULL)
  349.     ,m_pszPort (NULL)
  350.     ,m_pszUsername(NULL)
  351.     ,m_pszPassword(NULL)
  352.     ,m_unProtocol (fileProtocol)
  353.     ,m_bNetworkProtocol (FALSE)
  354.     ,m_pszResource (NULL)
  355.     ,m_pProperties (NULL)
  356.     ,m_pOptions (NULL)
  357.     ,m_pCCF(rhs.m_pCCF)
  358. {
  359.     if (m_pCCF)
  360.     {
  361. m_pCCF->AddRef();
  362.     }
  364.     ConstructURL(rhs.GetEscapedURL());
  365. }
  367. CHXURL& CHXURL::operator=(const CHXURL& rhs)
  368. {
  369.     if (&rhs != this)
  370.     {
  371. // Clean out old data
  372. HX_VECTOR_DELETE(m_pActualURL);
  373. HX_VECTOR_DELETE(m_pszURL);
  374.         HX_VECTOR_DELETE(m_pszEscapedURL);
  375. HX_RELEASE(m_pProperties);
  376. HX_RELEASE(m_pOptions);
  377. HX_RELEASE(m_pCCF);
  378. m_LastError = HXR_OK;
  379. m_pszOptions = NULL;
  380. m_pszHost = NULL;
  381. m_pszPort = NULL;
  382. m_pszUsername = NULL;
  383. m_pszPassword = NULL;
  384. m_unProtocol = fileProtocol;
  385. m_bNetworkProtocol = FALSE;
  386. m_pszResource = NULL;
  388. ConstructURL(rhs.GetEscapedURL());
  389. m_pCCF = rhs.m_pCCF;
  391. if (m_pCCF)
  392. {
  393.     m_pCCF->AddRef();
  394. }
  395.     }
  397.     return *this;
  398. }
  400. HX_RESULT CHXURL::ParseURL (char* pszURL)
  401. {
  402.     char* pszOption = NULL;
  403.     char* pszTemp = NULL;
  404.     char* pszSlash = NULL;
  405.     char* pszCursor = NULL;    
  407.     if (HXR_OK != m_LastError)
  408.     {
  409. goto cleanup;
  410.     }
  412.     pszCursor = pszURL;
  413.     
  414.     //
  415.     // let's start
  416.     //
  418.     // find the scheme - note that ParseURL only succeeds
  419.     // for absolute URLs
  420.     m_LastError = HXR_INVALID_PROTOCOL; // assume the worst
  421.     pszTemp = (char *) FindURLSchemeEnd(pszURL);
  422.     if (pszTemp)
  423.     {
  424. char* pScheme = new_string(pszURL, pszTemp - pszURL);
  426. m_LastError = HXR_OK;
  427. ::SaveStringToHeader(m_pProperties, PROPERTY_SCHEME, pScheme);
  429. delete[] pScheme;
  430.     }
  432.     if(HXR_OK != m_LastError)
  433.     {
  434. goto cleanup;
  435.     }
  437.     pszCursor = pszTemp + 1;
  438.   
  439.     if(strncmp(pszCursor, "//", 2) == 0)
  440.     {
  441. pszCursor += 2; // skip '//'
  442.     }
  443.     else if(strncmp(pszCursor, "/", 1) == 0)
  444.     {
  445. pszCursor += 1; // skip '/' (ill-formed url?)
  446.     }
  448.     if (fileProtocol == m_unProtocol)
  449.     {
  450. // resource
  451. if (*(m_pszResource = pszCursor) == '')
  452. {
  453.     m_LastError = HXR_INVALID_URL_PATH;
  454.     goto cleanup;
  455. }
  456.     }
  457.     // network URL + http
  458.     else
  459.     {
  460. // First check for optional username and password parameters.
  461. // The colon is also optional if either username or password
  462. // is not given Form in context:
  463. // protocol://username:password@host:port/resource (From RFC
  464. // 1738)
  465. pszTemp = (char*) ::HXFindChar(pszCursor, ':');
  466. pszSlash = (char*) ::HXFindChar(pszCursor, '/');
  467. pszOption = (char*) ::HXFindChar(pszCursor, '@');
  469. // There is a username or password if we see a '@' character
  470. // according to RFC 1738 this is a reserved character
  471. if (pszOption && pszOption < pszSlash)
  472. {
  473.     // Username
  474.     if (*(m_pszUsername = pszCursor) == '')
  475.     {
  476. m_LastError = HXR_INVALID_URL_HOST;
  477. goto cleanup;
  478.     }
  480.     // If the is a ':' and it is before the '@' then we have a
  481.     // password, so zero terminate the username and move the
  482.     // cursor to the password
  483.     if (pszTemp && (pszTemp < pszOption))
  484.     {
  485. *pszTemp = '';
  486. pszCursor = pszTemp+1;
  487.     }
  488.     // There is no ':' so move the cursor to the '@' character
  489.     // so it will be a zero terminated empty string
  490.     else
  491. pszCursor = pszOption;
  493.     // Password
  494.     if (*(m_pszPassword = pszCursor) == '')
  495.     {
  496. m_LastError = HXR_INVALID_URL_HOST;
  497. goto cleanup;
  498.     }
  500.     // Zero terminate password and move the cursor to the hostname
  501.     *pszOption = '';
  503.     if (m_pszUsername)
  504.     {
  505. ::SaveStringToHeader(m_pProperties, PROPERTY_USERNAME, m_pszUsername);
  506.     }
  508.     if (m_pszPassword)
  509.     {
  510. ::SaveStringToHeader(m_pProperties, PROPERTY_PASSWORD, m_pszPassword);
  511.     }
  513.     pszCursor = pszOption+1;
  514. }
  516. // host
  517. if (*(m_pszHost = pszCursor) == '')
  518. {
  519.     m_LastError = HXR_INVALID_URL_HOST;
  520.     goto cleanup;
  521. }
  523. // port
  524. pszTemp = (char*) ::HXFindChar(pszCursor, '/');
  525. if (pszTemp)
  526. {
  527.     *pszTemp = '';
  528.     pszCursor = pszTemp+1;
  529. }
  530. else
  531. {
  532.     // it's legal to have RTSP or HTTP URLs with no resource.
  534.             // The correct behavior for RTSP would be not to flag this as
  535.             // an error but the client core treats the lack of a resource
  536.             // as a failure. The correct change would be to have the client
  537.             // core check explicitly for a resource but legacy code rears its
  538.             // ugly head... so we flag the error (client core is happy) but
  539.             // go ahead and parse the rest of the headers (so you can still 
  540.             // get the host:port if you need to). */
  541.     if (m_unProtocol != httpProtocol && m_unProtocol != rtspProtocol)
  542.     {
  543. m_LastError = HXR_INVALID_URL_PATH;                
  544.     }
  545.     pszCursor = NULL;
  546. }
  549. // port
  550. pszTemp = (char*) ::HXFindChar(m_pszHost, ':');
  552. if (pszTemp)
  553. {
  554.     *pszTemp = '';
  555.   
  556.     if (*(m_pszPort = pszTemp+1) == '')
  557.     {
  558. m_LastError = HXR_INVALID_URL_HOST;
  559. goto cleanup;
  560.     }
  561. }
  563. if (m_pszHost)
  564. {
  565.     ::SaveStringToHeader(m_pProperties, PROPERTY_HOST, m_pszHost);
  566. }
  568. if (m_pszPort)
  569. {
  570.     m_pProperties->SetPropertyULONG32(PROPERTY_PORT, (ULONG32)atol(m_pszPort));
  571. }
  572. else if (m_unDefaultPort > 0)
  573. {
  574.     m_pProperties->SetPropertyULONG32(PROPERTY_PORT, (ULONG32)m_unDefaultPort);
  575. }
  577. if (pszCursor && (*(m_pszResource = pszCursor) == '' && m_unProtocol != httpProtocol && m_unProtocol != rtspProtocol))
  578. {
  579.     m_LastError = HXR_INVALID_URL_PATH;
  580.     goto cleanup;
  581. }
  582.     }
  584.     //
  585.     // other options?
  586.     //
  588.     /*
  589.     // 1.0 player
  590.     if (pszTemp = (char*) ::HXFindChar(pszCursor, '$'))
  591.     {
  592. *pszTemp = '';
  593. pszCursor = pszTemp+1;
  595. if (*(m_pszStartTime = pszCursor) == '')
  596. {
  597.     m_LastError = HXR_FAILED;
  598.     goto cleanup;
  599. }
  600.     }
  601.     */
  603. cleanup:
  605.     ParseResource();
  607.     return m_LastError;
  608. }
  610. void
  611. CHXURL::TrimOffSpaces(char*& pszString)
  612. {
  613.     if( NULL == pszString ) 
  614.         return;
  615.     
  616.     char* pszValue = pszString;
  617.     char* pszCursor = pszString;
  618.     
  619.     // trim off the leading spaces 
  620.     while (*pszCursor == ' ')
  621.     {
  622.         pszCursor++;
  623.     }
  625.     pszValue = pszCursor;
  627.     // trim off the tailing spaces
  628.     if( strlen(pszCursor) != 0 )
  629.     {
  630.         pszCursor = pszCursor + strlen(pszCursor) - 1;
  631.         
  632.         while (*pszCursor == ' ' )
  633.         {
  634.             pszCursor--;
  635.         }
  636.         ++pszCursor;
  637.         if( *pszCursor != '' )
  638.             *pszCursor = '';
  639.     }
  640.     
  641.     pszString = pszValue;
  642. }
  644. HX_RESULT
  645. CHXURL::CollectOptions (char* pszOptions)
  646. {
  647.     HX_RESULT hr = HXR_OK;
  648.     char*   pszCursor = NULL;
  649.     char*   pszKey = NULL;
  650.     char*   pszValue = NULL;
  651.     char*   pszTemp = NULL;
  652.     BOOL    bValueQuoted = FALSE;
  653.   
  654.     if (HXR_OK != m_LastError)
  655.     {
  656. return m_LastError;
  657.     }
  659.     pszCursor = pszOptions;
  661.     char* pszEndOptions = pszOptions + strlen(pszOptions);
  663.     // let's start parsing
  664.     while (pszCursor < pszEndOptions)
  665.     {
  666. //
  667. // collect one value pair at a time
  668. //
  670. // <key>="<value>" or <key>=<value> 
  671. pszKey = pszCursor;
  673. if (!(pszTemp = (char*) ::HXFindChar(pszCursor, '=')))
  674. {
  675.     hr = HXR_FAILED;
  676.     goto cleanup;
  677. }
  678. *pszTemp = '';
  680. pszCursor = pszTemp + 1;
  682. // remove all the spaces between '=' and actual value
  683. while (*pszCursor == ' ')
  684. {
  685.     pszCursor++;
  686. }
  688. // "<value>"
  689. if (*pszCursor == '"')
  690. {
  691.     bValueQuoted = TRUE;
  692.     pszCursor += 1;
  693. }
  695. pszValue = pszCursor;
  697. if (bValueQuoted)
  698. {
  699.     if (!(pszTemp = (char*) ::HXFindChar(pszCursor, '"')))
  700.     {
  701. hr = HXR_INCOMPLETE;
  702. goto cleanup;
  703.     }
  704.     *pszTemp = '';
  706.     pszCursor = pszTemp + 1;
  707. }
  709. if ((pszTemp = (char*) ::HXFindChar(pszCursor, '&')) != 0)
  710. {
  711.     *pszTemp = '';
  712.     
  713.     // move cursor to the next pair
  714.     pszCursor = pszTemp + 1;
  715. }
  716. else
  717. {
  718.     // move cursor to the end of this URL
  719.     pszCursor += strlen(pszValue);
  720. }
  722. // trim off leading/tailing spaces
  723. TrimOffSpaces(pszKey);
  724. TrimOffSpaces(pszValue);
  726.         // decode each value (option) since it may be URL-encoded.
  727.         CHXString strUnescapedOptionValue;
  728.         CHXURL::decodeURL(pszValue, strUnescapedOptionValue);
  729.         pszValue = (char *)(const char *)strUnescapedOptionValue;
  731. // save to the header
  732. if (!strcasecmp("Start", pszKey)
  733.     || !strcasecmp("End", pszKey)
  734.     || !strcasecmp("Delay", pszKey)
  735.     || !strcasecmp("Duration", pszKey))
  736. {
  737.     m_pOptions->SetPropertyULONG32(pszKey, (ULONG32) ::TimeParse(pszValue) * 100);
  738. }
  739. else if (bValueQuoted || !IsNumber(pszValue))
  740. {
  741.     IHXBuffer* pBuffer = NULL;
  743.     if (m_pCCF)
  744.     {
  745. m_pCCF->CreateInstance(CLSID_IHXBuffer, (void**)&pBuffer);
  746.     }
  748.     if (!pBuffer)
  749.     {
  750. hr = HXR_OUTOFMEMORY;
  751. goto cleanup;
  752.     }
  753.     pBuffer->Set((UCHAR*)pszValue, strlen(pszValue)+1);
  755.     m_pOptions->SetPropertyBuffer(pszKey, (IHXBuffer*) pBuffer);
  757.     pBuffer->Release();
  758. }
  759. else
  760. {
  761.     m_pOptions->SetPropertyULONG32(pszKey, (ULONG32) atol(pszValue));
  762. }
  764. bValueQuoted = FALSE;
  765. pszKey = NULL;
  766. pszValue = NULL;
  767.     }
  768.     
  769. cleanup:
  771.     return hr;
  772. }
  774. BOOL
  775. CHXURL::IsTimeValue (char* pszValue)
  776. {
  777.     int     i = 0;
  778.     char*   pszData = NULL;
  779.     char*   pszTemp = NULL;
  781.     // time value format: hh:mm:ss
  782.     if (isdigit(*pszValue) &&
  783. isdigit(*(pszValue+1)) &&
  784. *(pszValue+2) == ':' &&
  785. isdigit(*(pszValue+3)) &&
  786. isdigit(*(pszValue+4)) &&
  787. *(pszValue+5) == ':' &&
  788. isdigit(*(pszValue+6)) &&
  789. isdigit(*(pszValue+7)))
  790.     {
  791. for (i = 0; i < 3; i++)
  792. {
  793.     pszData = pszValue;
  795.     if (i < 2)
  796.     {
  797. pszTemp = (char*) ::HXFindChar(pszValue, ':');
  798. pszTemp = '';
  799.     }
  801.     switch (i)
  802.     {
  803.     case 0: // hh
  804. if (atoi(pszData) >= 24)
  805. {
  806.     return FALSE;
  807. }
  808. break;
  809.     case 1: // mm
  810. if (atoi(pszData) >= 60)
  811. {
  812.     return FALSE;
  813. }
  814. break;
  815.     case 2: // ss
  816. if (atoi(pszData) >= 60)
  817. {
  818.     return FALSE;
  819. }
  820. break;
  821.     default:
  822. break;
  823.     }
  825.     pszValue = pszTemp + 1;
  826. }
  828. return TRUE;
  829.     }
  831.     return FALSE;
  832. }    
  834. BOOL
  835. CHXURL::IsNumber(char* pszValue)
  836. {
  837.     char* pszCursor = pszValue;
  839.     while (*pszCursor != '')
  840.     {
  841. if (!isdigit(*pszCursor))
  842. {
  843.     return FALSE;
  844. }
  846. pszCursor++;
  847.     }
  849.     return TRUE;
  850. }
  852. // case insensitive compare
  853. int
  854. CHXURL::StringNCompare (const char* pszStr1, const char* pszStr2, size_t nChars)
  855. {
  856. #ifdef _WINDOWS
  857.     return strnicmp (pszStr1, pszStr2, nChars);
  858. #elif defined(_MACINTOSH)
  859.     return strnicmp (pszStr1, pszStr2, nChars);
  860. #elif defined(_UNIX) || defined(_OPENWAVE)
  861.     return strncasecmp (pszStr1, pszStr2, nChars);
  862. #elif defined(_SYMBIAN)
  863.     return strnicmp(pszStr1, pszStr2, nChars);
  864. #elif
  865. #   error "undefined platform....."    
  866. #else
  867.     return -1;
  868. #endif
  869. }
  871. void
  872. CHXURL::AddOption(char* pKey, char* pValue)
  873. {
  874.     // trim off leading/tailing spaces
  875.     TrimOffSpaces(pKey);
  876.     TrimOffSpaces(pValue);
  877.     
  878.     // save to the header
  879.     if (IsNumber(pValue))
  880.     {
  881. m_pOptions->SetPropertyULONG32(pKey, (ULONG32) atol(pValue));
  882.     }
  883.     else
  884.     {
  885. IHXBuffer*  pBuffer = NULL;
  887. if (m_pCCF)
  888. {
  889.     m_pCCF->CreateInstance(CLSID_IHXBuffer, (void**)&pBuffer);
  890. }
  892. if (pBuffer)
  893. {
  894.     pBuffer->Set((UCHAR*)pValue, strlen(pValue)+1);
  896.     m_pOptions->SetPropertyBuffer(pKey, (IHXBuffer*) pBuffer);
  898.     pBuffer->Release();
  899. }
  900.     }
  901. }
  903. void
  904. CHXURL::AddOption(char* pKey, UINT32 ulValue)
  905. {
  906.     TrimOffSpaces(pKey);
  907.     m_pOptions->SetPropertyULONG32(pKey, ulValue);
  908. }
  910. IHXValues*
  911. CHXURL::GetProperties(void)
  912. {
  913.     if (m_pProperties)
  914.     {
  915. m_pProperties->AddRef();
  916.     }
  918.     return m_pProperties;
  919. }
  921. IHXValues*
  922. CHXURL::GetOptions(void)
  923. {
  924.     if (m_pOptions)
  925.     {
  926. m_pOptions->AddRef();
  927.     }
  929.     return m_pOptions;
  930. }
  932. char*
  933. CHXURL::GetAltURL(BOOL& bDefault)
  934. {
  935.     IHXBuffer* pValue = NULL;
  936.     char* pAltURL = NULL;
  937.     char* pURL = NULL;
  938.     char* pCursor1 = NULL;
  939.     char* pCursor2 = NULL;
  941.     bDefault = FALSE;
  943.     if (HXR_OK != m_LastError)
  944.     {
  945. goto cleanup;
  946.     }
  948.     // retrieve Alt-URL if it exists in the option list
  949.     if (HXR_OK == m_pOptions->GetPropertyBuffer("altURL", pValue) && pValue)
  950.     {     
  951. // allocate mem. for m_pszAltURL
  952. pAltURL = new char[pValue->GetSize()];
  953. SafeStrCpy(pAltURL, (const char*)pValue->GetBuffer(), pValue->GetSize());
  954.     }
  955.     else if (HXR_OK == m_pProperties->GetPropertyBuffer("url", pValue) && pValue)
  956.     {
  957. if (m_unProtocol == pnmProtocol ||
  958.     m_unProtocol == rtspProtocol)
  959. {
  960.     bDefault = TRUE;
  961.     
  962.     // The +1 is NOT for the NULL terminator since the size already has space for it.  The +1 is actually because
  963.     // if the URL contains a pnm:// the code below will potentially add a http:// which is one more character than
  964.     // a pnm URL.  A rtsp:// URL will work correctly 
  965.             INT32 lSize = pValue->GetSize() + 1;
  966.     pAltURL = new char[lSize];
  967.     memset(pAltURL, 0, lSize);
  969.     pURL = (char*)pValue->GetBuffer();
  970.     
  971.     switch (m_unProtocol)
  972.     {
  973.     case pnmProtocol:
  974. SafeSprintf(pAltURL, lSize, "http:%s", pURL + 4);
  975. break;
  976.     case rtspProtocol:
  977. SafeSprintf(pAltURL, lSize, "http:%s", pURL + 5);
  978. break;
  979.     default:
  980. break;
  981.     }
  983.     // exclude the port from the URL
  984.     if (m_pszPort)
  985.     {
  986. pCursor1 = strstr(pAltURL, m_pszPort);
  987.                 pCursor2 = pCursor1 + strlen(m_pszPort);
  988.                 pCursor1--; // back up over the ':'
  989.                 
  990.                 while(*pCursor2)
  991.                 {
  992.                     *pCursor1++ = *pCursor2++;
  993.                 }
  995.                 *pCursor1 = '';
  996.     }
  997. }
  998.     }
  1000. cleanup:
  1002.     HX_RELEASE(pValue);
  1004.     return pAltURL;
  1005. }
  1007. void
  1008. CHXURL::ParseResource(void)
  1009. {
  1010.     char* pszTemp = NULL;
  1011.     char* pResource = NULL;
  1012.     char* pPath = NULL;
  1013.     char* pFullPath = NULL;
  1015.     if (m_pszResource && (*m_pszResource != ''))
  1016.     {
  1017. ::SaveStringToHeader(m_pProperties, PROPERTY_RESOURCE, m_pszResource);
  1019. ::StrAllocCopy(pResource, m_pszResource);
  1021. pszTemp = ::HXFindChar(pResource, '?');
  1022. if (pszTemp)
  1023. {
  1024.     *pszTemp = '';
  1025. }
  1027.         pFullPath = new char[strlen(pResource) + 2];
  1028. SafeSprintf(pFullPath, strlen(pResource)+2, "/%s", pResource);
  1029. ::SaveStringToHeader(m_pProperties, PROPERTY_FULLPATH, pFullPath);
  1031. pszTemp = ::HXReverseFindChar(pResource, '/');
  1032. if (pszTemp)
  1033. {
  1034.     *pszTemp = '';
  1035.     
  1036.     pPath = new char[strlen(pResource)+2];
  1037.     SafeSprintf(pPath, strlen(pResource)+2, "/%s", pResource);
  1039.     ::SaveStringToHeader(m_pProperties, PROPERTY_PATH, pPath);
  1040. }
  1041. else
  1042. {
  1043.     ::SaveStringToHeader(m_pProperties, PROPERTY_PATH, "/");
  1044. }
  1046. HX_VECTOR_DELETE(pFullPath);
  1047. HX_VECTOR_DELETE(pPath);
  1048. HX_VECTOR_DELETE(pResource);
  1049.     }
  1050.     else if (m_unProtocol == rtspProtocol)
  1051.     {
  1052. ::SaveStringToHeader(m_pProperties, PROPERTY_RESOURCE, "");
  1053. ::SaveStringToHeader(m_pProperties, PROPERTY_FULLPATH, "");
  1054. ::SaveStringToHeader(m_pProperties, PROPERTY_PATH, "");
  1055.     }
  1056. }
  1059. HX_RESULT
  1060. CHXURL::GeneratePrefixRootFragment(const char* pURL, CHXString& urlPrefix, 
  1061.    CHXString& urlRoot, char*& pURLFragment)
  1062. {
  1063.     BOOL bHasHost = FALSE;
  1065.     CHXURL urlObj(pURL);
  1066.     IHXValues* pHeader = urlObj.GetProperties();
  1067.     if(!pHeader)
  1068.     {
  1069. return HXR_FAIL;
  1070.     }
  1072.     IHXBuffer* pBuffer = 0;
  1073.     ULONG32 ulTemp;
  1075.     if(HXR_OK == pHeader->GetPropertyBuffer(PROPERTY_SCHEME, pBuffer))
  1076.     {
  1077. urlPrefix = (const char*)pBuffer->GetBuffer();
  1078. urlPrefix += "://";
  1079. pBuffer->Release();
  1080.     }
  1081.     if(HXR_OK == pHeader->GetPropertyBuffer(PROPERTY_HOST, pBuffer))
  1082.     {
  1083. urlPrefix += (const char*)pBuffer->GetBuffer();
  1084. pBuffer->Release();
  1085. bHasHost = TRUE;
  1086.     }
  1087.     if(HXR_OK == pHeader->GetPropertyULONG32(PROPERTY_PORT, ulTemp))
  1088.     {
  1089.   char szTemp[10]; /* Flawfinder: ignore */
  1090. SafeSprintf(szTemp, sizeof(szTemp), ":%d", (UINT16)ulTemp);
  1091. urlPrefix += szTemp;
  1092.     }
  1094.     // set root
  1095.     urlRoot = urlPrefix;
  1097.     if(bHasHost)
  1098.     {
  1099. urlPrefix += "/";
  1100.     }
  1102.     if(HXR_OK == pHeader->GetPropertyBuffer(PROPERTY_RESOURCE, pBuffer))
  1103.     {
  1104. const char* pResource = (const char*)pBuffer->GetBuffer();
  1105. const char  cDelimiter1  = '/';
  1106. const char  cDelimiter2  = '\';
  1107. const char  cOSDelimiter = OS_SEPARATOR_CHAR;
  1109. CHXString   strURLWork = pResource; 
  1111. char* pFirstChar    = strURLWork.GetBuffer(strURLWork.GetLength());
  1112. char* pLastChar     = NULL;
  1113. char* pOptions     = NULL;
  1114. char* pFragment     = NULL;
  1116. pOptions = strchr(pFirstChar, '?');
  1118. if (pOptions)
  1119. {
  1120.     pLastChar = pOptions -1;
  1121. }
  1122. else
  1123. {
  1124.     pLastChar = pFirstChar + strlen(pFirstChar)-1;
  1125. }
  1127. while ((pLastChar > pFirstChar) && 
  1128.    (*pLastChar != cDelimiter1) && (*pLastChar != cDelimiter2) &&
  1129.    (*pLastChar != cOSDelimiter))
  1130. {
  1131. pLastChar--;
  1132. }
  1133. // If we hit a delimiter before hitting the end, back up one character!
  1134. if(pLastChar > pFirstChar) 
  1135. {
  1136.     *(++pLastChar) = '';
  1137.     
  1138.     urlPrefix += pFirstChar;
  1139. }
  1140. pBuffer->Release();
  1141.     }
  1143.     if(HXR_OK == pHeader->GetPropertyBuffer(PROPERTY_FRAGMENT, pBuffer))
  1144.     {
  1145. const char* pFragment = (const char*)pBuffer->GetBuffer();
  1146. pURLFragment = new_string(pFragment);
  1147. pBuffer->Release();
  1148.     }
  1150.     HX_RELEASE(pHeader);
  1152.     return HXR_OK;
  1153. }
  1155. BOOL 
  1156. CHXURL::CompressURL(const char* pURL, char*& pCompressURL)
  1157. {
  1158.     HX_ASSERT(pURL != NULL);
  1160.     if (!pURL)
  1161.     {
  1162. return FALSE;
  1163.     }
  1165.     pCompressURL     = NULL;
  1167.     BOOL bNeedToCompress    = FALSE; 
  1168.     char separator1     = '\';
  1169.     char separator2     = '/';
  1170.     char* pWalker     = (char*) pURL;
  1172.     while (*pWalker)
  1173.     {
  1174. /* 
  1175.  *   /./ || /. || ./ || . || 
  1176.  *   /../ || /.. || ../ || ..
  1177.  */
  1178. if ((*pWalker     == separator1 || *pWalker == separator2) &&
  1179.     (*(pWalker+1)   == '.') &&
  1180.     ((*(pWalker+2)   == separator1 || *(pWalker+2) == separator2) ||
  1181.      ((*(pWalker+2)   == '.') &&
  1182.      (*(pWalker+3)   == separator1 || *(pWalker+3) == separator2))))
  1183. {
  1184.     // we need to commpress it
  1185.     bNeedToCompress = TRUE;
  1186.     break;
  1187. }
  1189. /* Do not process options in the URL (stuff after ?) */
  1190. if (*pWalker == '?')
  1191. {
  1192.     break;
  1193. }
  1195. pWalker++;
  1196.     }
  1198.     if (!bNeedToCompress)
  1199.     {
  1200. return FALSE;
  1201.     }
  1203.     UINT32 ulURLLength;
  1204.     char* pTempURL;
  1205.     char* pOptions;
  1207.     ulURLLength = strlen(pURL) + 1;
  1208.     pTempURL = new char[ulURLLength];
  1209.     ::strcpy(pTempURL, pURL); /* Flawfinder: ignore */
  1211.     pOptions = strchr(pTempURL, '?');
  1213.     /* We will only compress till before the options and then paste the options
  1214.      * at the end
  1215.      */
  1216.     if (pOptions)
  1217.     {
  1218. *pOptions = '';
  1219.     }
  1221.     CHXSimpleList* pList;
  1222.     char* pToken;
  1223.     UINT16 uNumToBeDiscarded;
  1224.     CHXSimpleList* pNewList;
  1225.     
  1226.     pList    = new CHXSimpleList;
  1227.     pNewList = new CHXSimpleList;
  1228.     uNumToBeDiscarded = 0;
  1230.     pWalker = pToken = pTempURL;    
  1231.     while (*pWalker)
  1232.     {
  1233. if (*pWalker == '/' || *pWalker == '\')
  1234. {
  1235.     *pWalker = '';
  1236.     pList->AddTail(pToken);
  1237.     pToken = pWalker+1;
  1238. }
  1239. pWalker++;
  1240.     }
  1242.     pList->AddTail(pToken);
  1244.     while (pList->GetCount() > 0)
  1245.     {
  1246. pToken = (char*) pList->RemoveTail();
  1247. if (::strcmp(pToken, ".") == 0)
  1248. {
  1249.     /* ignore it */    
  1250. }
  1251. else if (::strcmp(pToken, "..") == 0)
  1252. {
  1253.     uNumToBeDiscarded++;
  1254. }
  1255. else if (uNumToBeDiscarded > 0)
  1256. {
  1257.     uNumToBeDiscarded--;
  1258. }
  1259. else
  1260. {
  1261.     pNewList->AddTail(pToken);
  1262. }
  1263.     }
  1265. // /Valid content that starts with "../../" will trigger this, so turn it off
  1266. // unless someone wants to refine it:
  1267. #if defined(ALLOW_IRRITATING_ASSERTS_FOR_VALID_CONTENT)
  1268.     // This will trigger with malformed urls with two additional ellipses(..)
  1269.     HX_ASSERT(uNumToBeDiscarded == 0 && pNewList->GetCount() > 0);
  1270. #endif
  1272.     if (uNumToBeDiscarded > 0 || pNewList->GetCount() == 0)
  1273.     {
  1274. bNeedToCompress = FALSE;
  1275. goto exit;
  1276.     }
  1278.     pCompressURL = new char[ulURLLength];
  1279.     *pCompressURL = '';
  1280.     while (pNewList->GetCount() > 0)
  1281.     {
  1282. pToken = (char*) pNewList->RemoveTail();
  1283. SafeStrCat(pCompressURL, (const char*) pToken, ulURLLength);
  1285. if (!pNewList->IsEmpty())
  1286. {
  1287.     SafeStrCat(pCompressURL, "/", ulURLLength);
  1288. }
  1289.     }
  1291.     if (pOptions)
  1292.     {
  1293. SafeStrCat(pCompressURL, "?", ulURLLength);
  1294. SafeStrCat(pCompressURL, (const char*) (pOptions+1), ulURLLength);
  1295.     }
  1297. exit:
  1298.     HX_VECTOR_DELETE(pTempURL);
  1299.     HX_DELETE(pList);
  1300.     HX_DELETE(pNewList);
  1301.     return bNeedToCompress;
  1302. }
  1304. HX_RESULT
  1305. CHXURL::encodeURL(const char* pURL, CHXString& encodedURL)
  1306. {
  1307.     HX_RESULT rc = HXR_OK;
  1309.     char    hexBuf[3] = {0}; /* Flawfinder: ignore */
  1310.     char*   pEncodeBuf = new char[(strlen(pURL)+1)*3];    // overkill
  1311.     char*   pEncodePtr = pEncodeBuf;
  1312.     const   char* pURLPtr = pURL;
  1314.     while(*pURLPtr)
  1315.     {
  1316.      // according to the URL encoding spec. from
  1317. // http://www.isi.edu/in-notes/rfc1738.txt
  1318. if (*pURLPtr <= 0x1f ||
  1319.     *pURLPtr >= 0x7f ||
  1320.     HXIsEqual(pURLPtr, ' ') ||
  1321. //     HXIsEqual(pURLPtr, '<') ||
  1322. //     HXIsEqual(pURLPtr, '>') ||
  1323. //     HXIsEqual(pURLPtr, '"') ||
  1324. //     HXIsEqual(pURLPtr, '#') ||
  1325. //     HXIsEqual(pURLPtr, '%') ||
  1326.     HXIsEqual(pURLPtr, '{') ||
  1327.     HXIsEqual(pURLPtr, '}') ||
  1328.     HXIsEqual(pURLPtr, '|') ||
  1329.     HXIsEqual(pURLPtr, '\') ||
  1330.     HXIsEqual(pURLPtr, '^') ||
  1331.     HXIsEqual(pURLPtr, '~') ||
  1332.     HXIsEqual(pURLPtr, '[') ||
  1333.     HXIsEqual(pURLPtr, ']') ||
  1334.     HXIsEqual(pURLPtr, '`') ||
  1335.     HXIsEqual(pURLPtr, ',') ||
  1336.     HXIsEqual(pURLPtr, ';'))
  1337. {     
  1338.     SafeSprintf(hexBuf, sizeof(hexBuf), "%02x", (UCHAR)*pURLPtr);
  1339.     *pEncodePtr++ = '%';
  1340.     *pEncodePtr++ = hexBuf[0];
  1341.     *pEncodePtr++ = hexBuf[1];
  1342.     
  1343.     if (HXIsLeadByte(*pURLPtr))
  1344.     {
  1345. SafeSprintf(hexBuf, sizeof(hexBuf), "%02x", (UCHAR)*(pURLPtr+1));
  1346. *pEncodePtr++ = '%';
  1347. *pEncodePtr++ = hexBuf[0];
  1348. *pEncodePtr++ = hexBuf[1];
  1349.     }     
  1350. }
  1351. else
  1352. {
  1353.     *pEncodePtr++ = *pURLPtr;
  1354. }
  1356. pURLPtr = HXGetNextChar(pURLPtr) ;
  1357.     }
  1358.     *pEncodePtr = '';
  1360.     encodedURL = pEncodeBuf;
  1361.     delete[] pEncodeBuf;
  1363.     return rc;
  1364. }
  1366. HX_RESULT
  1367. CHXURL::decodeURL(const char* pURL, CHXString& decodedURL)
  1368. {
  1369.     HX_RESULT rc = HXR_OK;
  1371.     //XXXBAB - reimplement using CHXString::GetBuffer()/SetBuffer()
  1372.     // to avoid memcpy
  1374.     char* pDecodeBuf = new char[strlen(pURL)+1];
  1375.     char* pDecodePtr = pDecodeBuf;
  1376.     const char* pURLPtr = pURL;
  1378.     while(*pURLPtr)
  1379.     {
  1380. switch(*pURLPtr)
  1381. {
  1382.     case '%':
  1383.     {
  1384. char hexBuf[3]; /* Flawfinder: ignore */
  1385. if(pURLPtr[1] &&    // check for overbound condition
  1386.    pURLPtr[2])
  1387. {
  1388.     pURLPtr++;  // walk past '%'
  1389.     hexBuf[0] = *pURLPtr++;
  1390.     hexBuf[1] = *pURLPtr;
  1391.     hexBuf[2] = '';
  1392.     *pDecodePtr++ = (char)strtol(hexBuf, NULL, 16);
  1393. }
  1394.     }
  1395.     break;
  1397.     default:
  1398.     {
  1399. *pDecodePtr++ = *pURLPtr;
  1400.     }
  1401.     break;
  1402. }
  1403. pURLPtr++;
  1404.     }
  1405.     *pDecodePtr = '';
  1407.     decodedURL = pDecodeBuf;
  1408.     delete[] pDecodeBuf;
  1410.     return rc;
  1411. }
  1413. const char* CHXURL::FindURLSchemeEnd(const char *pszURL)
  1414. {
  1415.     const char *pszTemp;
  1417.     for (pszTemp = pszURL; *pszTemp; pszTemp++)
  1418.     {
  1419. if(*pszTemp == ':')
  1420. {
  1421.     return pszTemp;
  1422. }
  1423. else if(*pszTemp == '$' ||
  1424. *pszTemp == '#' ||
  1425. *pszTemp == '?' ||
  1426. *pszTemp == '/' ||
  1427. *pszTemp == '\')
  1428. {
  1429.     return NULL;
  1430. }
  1431.     }
  1432.     
  1433.     return NULL;
  1434. }
  1436. void
  1437. CHXURL::Unescape(char* s)
  1438. {
  1439. /*
  1440.  * Remove URL hex escapes from s... done in place.  The basic concept for
  1441.  * this routine is borrowed from the WWW library HTUnEscape() routine.
  1442.  */
  1443.     char* p = NULL;
  1444.     BOOL bProcessingOptionsPastQuestionMark = FALSE;
  1446.     for (p = s; *s != ''; ++s)
  1447.     {
  1448.         if ( (!bProcessingOptionsPastQuestionMark) && (*s == '%') )
  1449. {
  1450.     if (*++s != '') 
  1451.     {
  1452. *p = Unhex( *s ) << 4;
  1453.     }
  1455.     if (*++s != '') 
  1456.     {
  1457. *p++ += Unhex( *s );
  1458.     }
  1459. } 
  1460. else 
  1461. {
  1462.             if (*s == '?')
  1463.             {
  1464.                 bProcessingOptionsPastQuestionMark = TRUE;
  1465.             }
  1466.     *p++ = *s;
  1467. }
  1468.     }
  1470.     *p = '';
  1471. }
  1473. int
  1474. CHXURL::Unhex(char c)
  1475. {
  1476.     return (c >= '0' && c <= '9' ? c - '0'
  1477.     : c >= 'A' && c <= 'F' ? c - 'A' + 10
  1478.     : c - 'a' + 10 );
  1479. }
  1481. void 
  1482. CHXURL::TestCompressURL()
  1483. {
  1484. #ifdef _DEBUG
  1485.     /* Brad made me do it...:( */
  1486.     char* pTestCompressURL = NULL;
  1487.     BOOL bTestCompress = FALSE;
  1488.     CHXURL url("blah");
  1489.     
  1490.     HX_VERIFY(url.CompressURL("http://blah.real.com/test/../foo.smi", pTestCompressURL) == TRUE &&
  1491.       ::strcmp(pTestCompressURL, "http://blah.real.com/foo.smi") == 0);
  1492.     HX_VECTOR_DELETE(pTestCompressURL);
  1494.     HX_VERIFY(url.CompressURL("http://blah.real.com/test/foo.smi?foo/../.", pTestCompressURL) == FALSE);
  1495.     HX_VECTOR_DELETE(pTestCompressURL);
  1497.     HX_VERIFY(url.CompressURL("http://blah.real.com/test/./foo.smi", pTestCompressURL) == TRUE &&
  1498.       ::strcmp(pTestCompressURL, "http://blah.real.com/test/foo.smi") == 0);
  1499.     HX_VECTOR_DELETE(pTestCompressURL);
  1501.     HX_VERIFY(url.CompressURL("http://blah.real.com/test/.blah/foo.smi", pTestCompressURL) == FALSE);
  1502.     HX_VECTOR_DELETE(pTestCompressURL);
  1504.     HX_VERIFY(url.CompressURL("http://blah.real.com/test/..foo.smi", pTestCompressURL) == FALSE);
  1505.     HX_VECTOR_DELETE(pTestCompressURL);
  1507.     HX_VERIFY(url.CompressURL("rtsp://blah.real.com/test/blah/../../foo.smi?end=./../blah", pTestCompressURL)  == TRUE &&
  1508.       ::strcmp(pTestCompressURL, "rtsp://blah.real.com/foo.smi?end=./../blah") == 0);
  1509.     HX_VECTOR_DELETE(pTestCompressURL);
  1510. #endif
  1511. }
  1513. IHXCommonClassFactory* CHXURL::CreateCCF()
  1514. {
  1515.     return  new CHXMiniCCF();
  1516. }