Category

Development Platform
Home > SourceCode/Document > Communication-Mobile > Symbian > View Code
hxurl.cpp
Package: helix.src.0812.rar　[view]
Upload User: zhongxx05
Upload Date: 2007-06-06
Package Size: 33641k
Code Size: 35k
Category:

Symbian

Development Platform:

C/C++

hxurl.cpp：Code Content
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #include "hlxclib/string.h"
  37. #include "hlxclib/stdlib.h"
  38. //#include "hlxclib/stdio.h"
  39. #include <ctype.h>
  41. #include "hxcom.h"
  42. #include "hxtypes.h"
  43. #include "hxresult.h"
  44. #include "hxcomm.h"
  45. #include "tparse.h"
  46. #include "dbcs.h"
  47. #include "protdefs.h"
  48. #include "hxstrutl.h"
  49. #include "hxslist.h"
  50. #include "hxurl.h"
  51. #include "ihxpckts.h"
  52. #include "chxminiccf.h"
  54. #include "hxheap.h"
  55. #ifdef _DEBUG
  56. #undef HX_THIS_FILE
  57. static const char HX_THIS_FILE[] = __FILE__;
  58. #endif
  60. /* We should really define it in a common header file */
  61. #if defined (_WINDOWS ) || defined (WIN32) || defined(_SYMBIAN)
  62. #define OS_SEPARATOR_CHAR '\'
  63. #define OS_SEPARATOR_STRING "\"
  64. #elif defined (_UNIX) || defined(_OPENWAVE)
  65. #define OS_SEPARATOR_CHAR '/'
  66. #define OS_SEPARATOR_STRING "/"
  67. #elif defined (_MACINTOSH)
  68. #define OS_SEPARATOR_CHAR ':'
  69. #define OS_SEPARATOR_STRING ":"
  70. #else
  71. #error "undefined platform hxurl.cpp"
  72. #endif // defined (_WINDOWS ) || defined (WIN32)
  74. CHXURL::CHXURL (const char* pszURL)
  75. :m_LastError (HXR_OK)
  76. ,m_pActualURL(NULL)
  77.                 ,m_pszURL(NULL)
  78.                 ,m_pszEscapedURL(NULL)
  79. ,m_pszOptions (NULL)
  80. ,m_pszHost (NULL)
  81. ,m_pszPort (NULL)
  82. ,m_pszUsername(NULL)
  83. ,m_pszPassword(NULL)
  84. ,m_unProtocol(fileProtocol)
  85.                 ,m_unDefaultPort(0)
  86. ,m_bNetworkProtocol (FALSE)
  87. ,m_pszResource (NULL)
  88. ,m_pProperties (NULL)
  89. ,m_pOptions (NULL)
  90.                 ,m_pCCF(CreateCCF())
  91. {
  92.     if (m_pCCF)
  93.     {
  94. m_pCCF->AddRef();
  95.     }
  96.     
  97.     ConstructURL(pszURL);
  98. }
  100. CHXURL::CHXURL (const char* pszURL, IUnknown* pContext)
  101. :m_LastError (HXR_OK)
  102. ,m_pActualURL(NULL)
  103.                 ,m_pszURL(NULL)
  104.                 ,m_pszEscapedURL(NULL)
  105. ,m_pszOptions (NULL)
  106. ,m_pszHost (NULL)
  107. ,m_pszPort (NULL)
  108. ,m_pszUsername(NULL)
  109. ,m_pszPassword(NULL)
  110. ,m_unProtocol(fileProtocol)
  111.                 ,m_unDefaultPort(0)
  112. ,m_bNetworkProtocol (FALSE)
  113. ,m_pszResource (NULL)
  114. ,m_pProperties (NULL)
  115. ,m_pOptions (NULL)
  116.                 ,m_pCCF(0)
  117. {
  118.     if (pContext)
  119.     {
  120. pContext->QueryInterface(IID_IHXCommonClassFactory, (void**)&m_pCCF);
  121.     }
  122.     
  123.     ConstructURL(pszURL);
  124. }
  126. void CHXURL::ConstructURL(const char* pszURL)
  127. {
  128.     char*   pszInputURL = NULL;
  129.     char*   pszTemp = NULL;
  130.     char*   pFragment = NULL;
  131.     char*   pNewURL = NULL;
  132.     char*   pResource = NULL;
  133.     char*   pszDollarSign = NULL;
  135.     HX_ASSERT(pszURL != NULL);
  137.     if (!pszURL)
  138.     {
  139. m_LastError = HXR_INVALID_PATH;
  140. return;
  141.     }
  142.     
  143.     if (!m_pCCF)
  144.     {
  145. m_LastError = HXR_UNEXPECTED;
  146. return;
  147.     }
  149.     pszInputURL = new char[strlen(pszURL) + 1];
  150.     if(!pszInputURL)
  151.     {
  152.         m_LastError = HXR_OUTOFMEMORY;
  153.         return;
  154.     }
  155.     strcpy(pszInputURL, pszURL); /* Flawfinder: ignore */
  157.     // Keep permanent copy of input url
  158.     m_pszEscapedURL = new char[strlen(pszInputURL)+1];
  159.     strcpy(m_pszEscapedURL, pszInputURL); /* Flawfinder: ignore */
  161.     // IHXValues 
  162.     if (m_pCCF)
  163.     {
  164. m_pCCF->CreateInstance(CLSID_IHXValues, (void**)&m_pProperties);
  165. m_pCCF->CreateInstance(CLSID_IHXValues, (void**)&m_pOptions);
  166.     }
  168.     // protocol: determine whether it's network or local
  169.     if (0 == StringNCompare(pszInputURL, "http:", 5))
  170.     {
  171. m_unProtocol = httpProtocol;
  172. m_unDefaultPort = DEFAULT_HTTP_PORT;
  173.     }
  174.     else if (0 == StringNCompare(pszInputURL, "chttp:", 6))
  175.     {
  176. m_unProtocol = httpProtocol;
  177. m_unDefaultPort = DEFAULT_HTTP_PORT;
  178.     }
  179.     else if (0 == StringNCompare(pszInputURL, "pnm:", 4))
  180.     {
  181. m_unProtocol = pnmProtocol;
  182. m_bNetworkProtocol = TRUE;
  183. m_unDefaultPort = DEFAULT_PNA_PORT;
  184.     }
  185.     else if (0 == StringNCompare(pszInputURL, "rtsp:", 5))
  186.     {
  187. m_unProtocol = rtspProtocol;
  188. m_bNetworkProtocol = TRUE;
  189. m_unDefaultPort = DEFAULT_RTSP_PORT;
  190.     }
  191.     else if (0 == StringNCompare(pszInputURL, "helix-sdp:", 10))
  192.     {
  193. m_unProtocol = helixSDPProtocol;
  194. m_bNetworkProtocol = TRUE;
  195. m_unDefaultPort = DEFAULT_RTSP_PORT;
  196.     }
  197.     else if (0 == StringNCompare(pszInputURL, "https:", 6))
  198.     {
  199. m_unProtocol = httpsProtocol;
  200. m_unDefaultPort = DEFAULT_HTTPS_PORT;
  201.     }
  203.     if (m_pProperties)
  204.     {
  205. m_pProperties->SetPropertyULONG32(PROPERTY_PROTOCOL, (ULONG32)m_unProtocol);
  206.     }
  207.     else
  208.     {
  209. m_LastError = HXR_UNEXPECTED;
  210. goto cleanup;
  211.     }
  213.     // no need to further parse helix-sdp protocol
  214.     if (helixSDPProtocol != m_unProtocol)
  215.     {
  216.         // separate fragment from the URL
  217.         if (0!=(pszTemp = (char*) ::HXFindChar(pszInputURL, '#')))
  218.         {
  219.     // save fragment
  220.     pFragment = pszTemp + 1;
  221.     ::SaveStringToHeader(m_pProperties, PROPERTY_FRAGMENT, pFragment);
  222.     *pszTemp = '';
  223.         }
  225.         // HP - allow '$' in directory/file name
  226.         //
  227.         // still need to take care of that obsolete $ sign option:
  228.         // rtsp://moe.cr.prognet.com/ambush.rm$1:00
  229.         // time after the $ is assumed to be the start time.
  230.         //
  231.         // the solution is to compare the string following the $ to 
  232.         // a properly formed time. If the string is a time and only 
  233.         // a time, then we know its the old-style start-time option
  234.         // otherwise, '$' is part of the directory/file name and we
  235.         // will keep it.
  236.         pszDollarSign = (char*) ::HXFindChar(pszInputURL, '$');
  237.         while (pszDollarSign)
  238.         {
  239.     pszTemp = pszDollarSign + 1;
  241.     if (::TimeParse(pszTemp))
  242.     {
  243.         *pszDollarSign = '';
  244.         INT32 lLen = (2 * strlen(pszURL)) + 8;
  245.         pNewURL = new char[lLen];
  246.         memset(pNewURL, 0, lLen);
  247.           
  248.         // upgrade to a new URL
  249.         SafeSprintf(pNewURL, lLen, "%s?start=%s", pszInputURL, pszTemp);
  251.         HX_VECTOR_DELETE(pszInputURL);
  252.         pszInputURL = pNewURL;
  253.         break;
  254.     }
  256.     pszDollarSign = (char*) ::HXFindChar(pszTemp, '$');
  257.         }
  258.     }
  260. #if !defined(_MACINTOSH) && !defined(_MAC_UNIX)
  261.     // on Mac, unescaping can put /'s and ?'s back into file and folder names, which is deadly inside URLs
  262.     //if (0 == StringNCompare(pszInputURL, "file:", 5))
  263.     {
  264. // we only unescape the URL on local source since we are
  265. // *responding* instead of *requesting* for the given source
  266. Unescape(pszInputURL);
  267.     }
  268. #endif
  270.     if (!CompressURL(pszInputURL, m_pszURL))
  271.     {
  272. // make a copy of the URL
  273. m_pszURL = new char[strlen(pszInputURL)+1];
  274. strcpy(m_pszURL, pszInputURL); /* Flawfinder: ignore */
  275.     }
  277.     m_pActualURL = new char[strlen(m_pszURL)+1];
  278.     strcpy(m_pActualURL, m_pszURL); /* Flawfinder: ignore */
  280.     ::SaveStringToHeader(m_pProperties, PROPERTY_URL, m_pszURL);
  282.     // no need to further parse helix-sdp protocol
  283.     if (helixSDPProtocol != m_unProtocol)
  284.     {
  285.         // separate options from the URL
  286.         if (0 != (pszTemp = (char*) ::HXFindChar(m_pszURL, '?')))
  287.         {
  288.     // options
  289.     m_pszOptions = pszTemp + 1;
  290.         }
  291.        
  292.         // collect protocol, host, port and resource info
  293.         ParseURL (m_pszURL);
  294.     
  295.         // collect other options info if it has 
  296.         if (m_pszOptions)
  297.         {
  298.     if (HXR_INCOMPLETE == CollectOptions(m_pszOptions) && m_pszResource)
  299.     {
  300.              // bad options and remove it from the URL
  301.              pszTemp = (char*) ::HXFindChar(m_pszResource, '?');
  302.         if (pszTemp)
  303.         {
  304.     *pszTemp = '';
  306.     ParseResource();
  307.         }
  308.     }
  309.         }   
  310.     }
  312. cleanup:
  314.     HX_VECTOR_DELETE(pszInputURL);
  315. }
  317. CHXURL::~CHXURL ()
  318. {
  319.     HX_VECTOR_DELETE(m_pActualURL);
  320.     HX_VECTOR_DELETE(m_pszURL);
  321.     HX_VECTOR_DELETE(m_pszEscapedURL);
  323.     HX_RELEASE(m_pProperties);
  324.     HX_RELEASE(m_pOptions);
  326.     HX_RELEASE(m_pCCF);
  327. }
  329. CHXURL::CHXURL(const CHXURL& rhs) 
  330.     :m_LastError (HXR_OK)
  331.     ,m_pActualURL(NULL)
  332.     ,m_pszURL(NULL)
  333.     ,m_pszOptions (NULL)
  334.     ,m_pszHost (NULL)
  335.     ,m_pszPort (NULL)
  336.     ,m_pszUsername(NULL)
  337.     ,m_pszPassword(NULL)
  338.     ,m_unProtocol (fileProtocol)
  339.     ,m_bNetworkProtocol (FALSE)
  340.     ,m_pszResource (NULL)
  341.     ,m_pProperties (NULL)
  342.     ,m_pOptions (NULL)
  343.     ,m_pCCF(rhs.m_pCCF)
  344. {
  345.     if (m_pCCF)
  346.     {
  347. m_pCCF->AddRef();
  348.     }
  350.     ConstructURL(rhs.GetEscapedURL());
  351. }
  353. CHXURL& CHXURL::operator=(const CHXURL& rhs)
  354. {
  355.     if (&rhs != this)
  356.     {
  357. // Clean out old data
  358. HX_VECTOR_DELETE(m_pActualURL);
  359. HX_VECTOR_DELETE(m_pszURL);
  360.         HX_VECTOR_DELETE(m_pszEscapedURL);
  361. HX_RELEASE(m_pProperties);
  362. HX_RELEASE(m_pOptions);
  363. HX_RELEASE(m_pCCF);
  364. m_LastError = HXR_OK;
  365. m_pszOptions = NULL;
  366. m_pszHost = NULL;
  367. m_pszPort = NULL;
  368. m_pszUsername = NULL;
  369. m_pszPassword = NULL;
  370. m_unProtocol = fileProtocol;
  371. m_bNetworkProtocol = FALSE;
  372. m_pszResource = NULL;
  374. ConstructURL(rhs.GetEscapedURL());
  375. m_pCCF = rhs.m_pCCF;
  377. if (m_pCCF)
  378. {
  379.     m_pCCF->AddRef();
  380. }
  381.     }
  383.     return *this;
  384. }
  386. HX_RESULT CHXURL::ParseURL (char* pszURL)
  387. {
  388.     char* pszOption = NULL;
  389.     char* pszTemp = NULL;
  390.     char* pszSlash = NULL;
  391.     char* pszCursor = NULL;    
  393.     if (HXR_OK != m_LastError)
  394.     {
  395. goto cleanup;
  396.     }
  398.     pszCursor = pszURL;
  399.     
  400.     //
  401.     // let's start
  402.     //
  404.     // find the scheme - note that ParseURL only succeeds
  405.     // for absolute URLs
  406.     m_LastError = HXR_INVALID_PROTOCOL; // assume the worst
  407.     pszTemp = (char *) FindURLSchemeEnd(pszURL);
  408.     if (pszTemp)
  409.     {
  410. char* pScheme = new_string(pszURL, pszTemp - pszURL);
  412. m_LastError = HXR_OK;
  413. ::SaveStringToHeader(m_pProperties, PROPERTY_SCHEME, pScheme);
  415. delete[] pScheme;
  416.     }
  418.     if(HXR_OK != m_LastError)
  419.     {
  420. goto cleanup;
  421.     }
  423.     pszCursor = pszTemp + 1;
  424.   
  425.     if(strncmp(pszCursor, "//", 2) == 0)
  426.     {
  427. pszCursor += 2; // skip '//'
  428.     }
  429.     else if(strncmp(pszCursor, "/", 1) == 0)
  430.     {
  431. pszCursor += 1; // skip '/' (ill-formed url?)
  432.     }
  434.     if (fileProtocol == m_unProtocol)
  435.     {
  436. // resource
  437. if (*(m_pszResource = pszCursor) == '')
  438. {
  439.     m_LastError = HXR_INVALID_URL_PATH;
  440.     goto cleanup;
  441. }
  442.     }
  443.     // network URL + http
  444.     else
  445.     {
  446. // First check for optional username and password parameters.
  447. // The colon is also optional if either username or password
  448. // is not given Form in context:
  449. // protocol://username:password@host:port/resource (From RFC
  450. // 1738)
  451. pszTemp = (char*) ::HXFindChar(pszCursor, ':');
  452. pszSlash = (char*) ::HXFindChar(pszCursor, '/');
  453. pszOption = (char*) ::HXFindChar(pszCursor, '@');
  455. // There is a username or password if we see a '@' character
  456. // according to RFC 1738 this is a reserved character
  457. if (pszOption && pszOption < pszSlash)
  458. {
  459.     // Username
  460.     if (*(m_pszUsername = pszCursor) == '')
  461.     {
  462. m_LastError = HXR_INVALID_URL_HOST;
  463. goto cleanup;
  464.     }
  466.     // If the is a ':' and it is before the '@' then we have a
  467.     // password, so zero terminate the username and move the
  468.     // cursor to the password
  469.     if (pszTemp && (pszTemp < pszOption))
  470.     {
  471. *pszTemp = '';
  472. pszCursor = pszTemp+1;
  473.     }
  474.     // There is no ':' so move the cursor to the '@' character
  475.     // so it will be a zero terminated empty string
  476.     else
  477. pszCursor = pszOption;
  479.     // Password
  480.     if (*(m_pszPassword = pszCursor) == '')
  481.     {
  482. m_LastError = HXR_INVALID_URL_HOST;
  483. goto cleanup;
  484.     }
  486.     // Zero terminate password and move the cursor to the hostname
  487.     *pszOption = '';
  489.     if (m_pszUsername)
  490.     {
  491. ::SaveStringToHeader(m_pProperties, PROPERTY_USERNAME, m_pszUsername);
  492.     }
  494.     if (m_pszPassword)
  495.     {
  496. ::SaveStringToHeader(m_pProperties, PROPERTY_PASSWORD, m_pszPassword);
  497.     }
  499.     pszCursor = pszOption+1;
  500. }
  502. // host
  503. if (*(m_pszHost = pszCursor) == '')
  504. {
  505.     m_LastError = HXR_INVALID_URL_HOST;
  506.     goto cleanup;
  507. }
  509. // port
  510. pszTemp = (char*) ::HXFindChar(pszCursor, '/');
  511. if (pszTemp)
  512. {
  513.     *pszTemp = '';
  514.     pszCursor = pszTemp+1;
  515. }
  516. else
  517. {
  518.     // it's legal to have RTSP or HTTP URLs with no resource.
  520.             // The correct behavior for RTSP would be not to flag this as
  521.             // an error but the client core treats the lack of a resource
  522.             // as a failure. The correct change would be to have the client
  523.             // core check explicitly for a resource but legacy code rears its
  524.             // ugly head... so we flag the error (client core is happy) but
  525.             // go ahead and parse the rest of the headers (so you can still 
  526.             // get the host:port if you need to). */
  527.     if (m_unProtocol != httpProtocol && m_unProtocol != rtspProtocol)
  528.     {
  529. m_LastError = HXR_INVALID_URL_PATH;                
  530.     }
  531.     pszCursor = NULL;
  532. }
  535. // port
  536. pszTemp = (char*) ::HXFindChar(m_pszHost, ':');
  538. if (pszTemp)
  539. {
  540.     *pszTemp = '';
  541.   
  542.     if (*(m_pszPort = pszTemp+1) == '')
  543.     {
  544. m_LastError = HXR_INVALID_URL_HOST;
  545. goto cleanup;
  546.     }
  547. }
  549. if (m_pszHost)
  550. {
  551.     ::SaveStringToHeader(m_pProperties, PROPERTY_HOST, m_pszHost);
  552. }
  554. if (m_pszPort)
  555. {
  556.     m_pProperties->SetPropertyULONG32(PROPERTY_PORT, (ULONG32)atol(m_pszPort));
  557. }
  558. else if (m_unDefaultPort > 0)
  559. {
  560.     m_pProperties->SetPropertyULONG32(PROPERTY_PORT, (ULONG32)m_unDefaultPort);
  561. }
  563. if (pszCursor && (*(m_pszResource = pszCursor) == '' && m_unProtocol != httpProtocol && m_unProtocol != rtspProtocol))
  564. {
  565.     m_LastError = HXR_INVALID_URL_PATH;
  566.     goto cleanup;
  567. }
  568.     }
  570.     //
  571.     // other options?
  572.     //
  574.     /*
  575.     // 1.0 player
  576.     if (pszTemp = (char*) ::HXFindChar(pszCursor, '$'))
  577.     {
  578. *pszTemp = '';
  579. pszCursor = pszTemp+1;
  581. if (*(m_pszStartTime = pszCursor) == '')
  582. {
  583.     m_LastError = HXR_FAILED;
  584.     goto cleanup;
  585. }
  586.     }
  587.     */
  589. cleanup:
  591.     ParseResource();
  593.     return m_LastError;
  594. }
  596. void
  597. CHXURL::TrimOffSpaces(char*& pszString)
  598. {
  599.     if( NULL == pszString ) 
  600.         return;
  601.     
  602.     char* pszValue = pszString;
  603.     char* pszCursor = pszString;
  604.     
  605.     // trim off the leading spaces 
  606.     while (*pszCursor == ' ')
  607.     {
  608.         pszCursor++;
  609.     }
  611.     pszValue = pszCursor;
  613.     // trim off the tailing spaces
  614.     if( strlen(pszCursor) != 0 )
  615.     {
  616.         pszCursor = pszCursor + strlen(pszCursor) - 1;
  617.         
  618.         while (*pszCursor == ' ' )
  619.         {
  620.             pszCursor--;
  621.         }
  622.         ++pszCursor;
  623.         if( *pszCursor != '' )
  624.             *pszCursor = '';
  625.     }
  626.     
  627.     pszString = pszValue;
  628. }
  630. HX_RESULT
  631. CHXURL::CollectOptions (char* pszOptions)
  632. {
  633.     HX_RESULT hr = HXR_OK;
  634.     char*   pszCursor = NULL;
  635.     char*   pszKey = NULL;
  636.     char*   pszValue = NULL;
  637.     char*   pszTemp = NULL;
  638.     BOOL    bValueQuoted = FALSE;
  639.   
  640.     if (HXR_OK != m_LastError)
  641.     {
  642. return m_LastError;
  643.     }
  645.     pszCursor = pszOptions;
  647.     char* pszEndOptions = pszOptions + strlen(pszOptions);
  649.     // let's start parsing
  650.     while (pszCursor < pszEndOptions)
  651.     {
  652. //
  653. // collect one value pair at a time
  654. //
  656. // <key>="<value>" or <key>=<value> 
  657. pszKey = pszCursor;
  659. if (!(pszTemp = (char*) ::HXFindChar(pszCursor, '=')))
  660. {
  661.     hr = HXR_FAILED;
  662.     goto cleanup;
  663. }
  664. *pszTemp = '';
  666. pszCursor = pszTemp + 1;
  668. // remove all the spaces between '=' and actual value
  669. while (*pszCursor == ' ')
  670. {
  671.     pszCursor++;
  672. }
  674. // "<value>"
  675. if (*pszCursor == '"')
  676. {
  677.     bValueQuoted = TRUE;
  678.     pszCursor += 1;
  679. }
  681. pszValue = pszCursor;
  683. if (bValueQuoted)
  684. {
  685.     if (!(pszTemp = (char*) ::HXFindChar(pszCursor, '"')))
  686.     {
  687. hr = HXR_INCOMPLETE;
  688. goto cleanup;
  689.     }
  690.     *pszTemp = '';
  692.     pszCursor = pszTemp + 1;
  693. }
  695. if ((pszTemp = (char*) ::HXFindChar(pszCursor, '&')) != 0)
  696. {
  697.     *pszTemp = '';
  698.     
  699.     // move cursor to the next pair
  700.     pszCursor = pszTemp + 1;
  701. }
  702. else
  703. {
  704.     // move cursor to the end of this URL
  705.     pszCursor += strlen(pszValue);
  706. }
  708. // trim off leading/tailing spaces
  709. TrimOffSpaces(pszKey);
  710. TrimOffSpaces(pszValue);
  712.         // decode each value (option) since it may be URL-encoded.
  713.         CHXString strUnescapedOptionValue;
  714.         CHXURL::decodeURL(pszValue, strUnescapedOptionValue);
  715.         pszValue = (char *)(const char *)strUnescapedOptionValue;
  717. // save to the header
  718. if (!strcasecmp("Start", pszKey)
  719.     || !strcasecmp("End", pszKey)
  720.     || !strcasecmp("Delay", pszKey)
  721.     || !strcasecmp("Duration", pszKey))
  722. {
  723.     m_pOptions->SetPropertyULONG32(pszKey, (ULONG32) ::TimeParse(pszValue) * 100);
  724. }
  725. else if (bValueQuoted || !IsNumber(pszValue))
  726. {
  727.     IHXBuffer* pBuffer = NULL;
  729.     if (m_pCCF)
  730.     {
  731. m_pCCF->CreateInstance(CLSID_IHXBuffer, (void**)&pBuffer);
  732.     }
  734.     if (!pBuffer)
  735.     {
  736. hr = HXR_OUTOFMEMORY;
  737. goto cleanup;
  738.     }
  739.     pBuffer->Set((UCHAR*)pszValue, strlen(pszValue)+1);
  741.     m_pOptions->SetPropertyBuffer(pszKey, (IHXBuffer*) pBuffer);
  743.     pBuffer->Release();
  744. }
  745. else
  746. {
  747.     m_pOptions->SetPropertyULONG32(pszKey, (ULONG32) atol(pszValue));
  748. }
  750. bValueQuoted = FALSE;
  751. pszKey = NULL;
  752. pszValue = NULL;
  753.     }
  754.     
  755. cleanup:
  757.     return hr;
  758. }
  760. BOOL
  761. CHXURL::IsTimeValue (char* pszValue)
  762. {
  763.     int     i = 0;
  764.     char*   pszData = NULL;
  765.     char*   pszTemp = NULL;
  767.     // time value format: hh:mm:ss
  768.     if (isdigit(*pszValue) &&
  769. isdigit(*(pszValue+1)) &&
  770. *(pszValue+2) == ':' &&
  771. isdigit(*(pszValue+3)) &&
  772. isdigit(*(pszValue+4)) &&
  773. *(pszValue+5) == ':' &&
  774. isdigit(*(pszValue+6)) &&
  775. isdigit(*(pszValue+7)))
  776.     {
  777. for (i = 0; i < 3; i++)
  778. {
  779.     pszData = pszValue;
  781.     if (i < 2)
  782.     {
  783. pszTemp = (char*) ::HXFindChar(pszValue, ':');
  784. pszTemp = '';
  785.     }
  787.     switch (i)
  788.     {
  789.     case 0: // hh
  790. if (atoi(pszData) >= 24)
  791. {
  792.     return FALSE;
  793. }
  794. break;
  795.     case 1: // mm
  796. if (atoi(pszData) >= 60)
  797. {
  798.     return FALSE;
  799. }
  800. break;
  801.     case 2: // ss
  802. if (atoi(pszData) >= 60)
  803. {
  804.     return FALSE;
  805. }
  806. break;
  807.     default:
  808. break;
  809.     }
  811.     pszValue = pszTemp + 1;
  812. }
  814. return TRUE;
  815.     }
  817.     return FALSE;
  818. }    
  820. BOOL
  821. CHXURL::IsNumber(char* pszValue)
  822. {
  823.     char* pszCursor = pszValue;
  825.     while (*pszCursor != '')
  826.     {
  827. if (!isdigit(*pszCursor))
  828. {
  829.     return FALSE;
  830. }
  832. pszCursor++;
  833.     }
  835.     return TRUE;
  836. }
  838. // case insensitive compare
  839. int
  840. CHXURL::StringNCompare (const char* pszStr1, const char* pszStr2, size_t nChars)
  841. {
  842. #ifdef _WINDOWS
  843.     return strnicmp (pszStr1, pszStr2, nChars);
  844. #elif defined(_MACINTOSH)
  845.     return strnicmp (pszStr1, pszStr2, nChars);
  846. #elif defined(_UNIX) || defined(_OPENWAVE)
  847.     return strncasecmp (pszStr1, pszStr2, nChars);
  848. #elif defined(_SYMBIAN)
  849.     return strnicmp(pszStr1, pszStr2, nChars);
  850. #elif
  851. #   error "undefined platform....."    
  852. #else
  853.     return -1;
  854. #endif
  855. }
  857. void
  858. CHXURL::AddOption(char* pKey, char* pValue)
  859. {
  860.     // trim off leading/tailing spaces
  861.     TrimOffSpaces(pKey);
  862.     TrimOffSpaces(pValue);
  863.     
  864.     // save to the header
  865.     if (IsNumber(pValue))
  866.     {
  867. m_pOptions->SetPropertyULONG32(pKey, (ULONG32) atol(pValue));
  868.     }
  869.     else
  870.     {
  871. IHXBuffer*  pBuffer = NULL;
  873. if (m_pCCF)
  874. {
  875.     m_pCCF->CreateInstance(CLSID_IHXBuffer, (void**)&pBuffer);
  876. }
  878. if (pBuffer)
  879. {
  880.     pBuffer->Set((UCHAR*)pValue, strlen(pValue)+1);
  882.     m_pOptions->SetPropertyBuffer(pKey, (IHXBuffer*) pBuffer);
  884.     pBuffer->Release();
  885. }
  886.     }
  887. }
  889. void
  890. CHXURL::AddOption(char* pKey, UINT32 ulValue)
  891. {
  892.     TrimOffSpaces(pKey);
  893.     m_pOptions->SetPropertyULONG32(pKey, ulValue);
  894. }
  896. IHXValues*
  897. CHXURL::GetProperties(void)
  898. {
  899.     if (m_pProperties)
  900.     {
  901. m_pProperties->AddRef();
  902.     }
  904.     return m_pProperties;
  905. }
  907. IHXValues*
  908. CHXURL::GetOptions(void)
  909. {
  910.     if (m_pOptions)
  911.     {
  912. m_pOptions->AddRef();
  913.     }
  915.     return m_pOptions;
  916. }
  918. char*
  919. CHXURL::GetAltURL(BOOL& bDefault)
  920. {
  921.     IHXBuffer* pValue = NULL;
  922.     char* pAltURL = NULL;
  923.     char* pURL = NULL;
  924.     char* pCursor1 = NULL;
  925.     char* pCursor2 = NULL;
  927.     bDefault = FALSE;
  929.     if (HXR_OK != m_LastError)
  930.     {
  931. goto cleanup;
  932.     }
  934.     // retrieve Alt-URL if it exists in the option list
  935.     if (HXR_OK == m_pOptions->GetPropertyBuffer("altURL", pValue) && pValue)
  936.     {     
  937. // allocate mem. for m_pszAltURL
  938. pAltURL = new char[pValue->GetSize()];
  939. SafeStrCpy(pAltURL, (const char*)pValue->GetBuffer(), pValue->GetSize());
  940.     }
  941.     else if (HXR_OK == m_pProperties->GetPropertyBuffer("url", pValue) && pValue)
  942.     {
  943. if (m_unProtocol == pnmProtocol ||
  944.     m_unProtocol == rtspProtocol)
  945. {
  946.     bDefault = TRUE;
  947.     
  948.     // The +1 is NOT for the NULL terminator since the size already has space for it.  The +1 is actually because
  949.     // if the URL contains a pnm:// the code below will potentially add a http:// which is one more character than
  950.     // a pnm URL.  A rtsp:// URL will work correctly 
  951.             INT32 lSize = pValue->GetSize() + 1;
  952.     pAltURL = new char[lSize];
  953.     memset(pAltURL, 0, lSize);
  955.     pURL = (char*)pValue->GetBuffer();
  956.     
  957.     switch (m_unProtocol)
  958.     {
  959.     case pnmProtocol:
  960. SafeSprintf(pAltURL, lSize, "http:%s", pURL + 4);
  961. break;
  962.     case rtspProtocol:
  963. SafeSprintf(pAltURL, lSize, "http:%s", pURL + 5);
  964. break;
  965.     default:
  966. break;
  967.     }
  969.     // exclude the port from the URL
  970.     if (m_pszPort)
  971.     {
  972. pCursor1 = strstr(pAltURL, m_pszPort);
  973.                 pCursor2 = pCursor1 + strlen(m_pszPort);
  974.                 pCursor1--; // back up over the ':'
  975.                 
  976.                 while(*pCursor2)
  977.                 {
  978.                     *pCursor1++ = *pCursor2++;
  979.                 }
  981.                 *pCursor1 = '';
  982.     }
  983. }
  984.     }
  986. cleanup:
  988.     HX_RELEASE(pValue);
  990.     return pAltURL;
  991. }
  993. void
  994. CHXURL::ParseResource(void)
  995. {
  996.     char* pszTemp = NULL;
  997.     char* pResource = NULL;
  998.     char* pPath = NULL;
  999.     char* pFullPath = NULL;
  1001.     if (m_pszResource && (*m_pszResource != ''))
  1002.     {
  1003. ::SaveStringToHeader(m_pProperties, PROPERTY_RESOURCE, m_pszResource);
  1005. ::StrAllocCopy(pResource, m_pszResource);
  1007. pszTemp = ::HXFindChar(pResource, '?');
  1008. if (pszTemp)
  1009. {
  1010.     *pszTemp = '';
  1011. }
  1013.         pFullPath = new char[strlen(pResource) + 2];
  1014. SafeSprintf(pFullPath, strlen(pResource)+2, "/%s", pResource);
  1015. ::SaveStringToHeader(m_pProperties, PROPERTY_FULLPATH, pFullPath);
  1017. pszTemp = ::HXReverseFindChar(pResource, '/');
  1018. if (pszTemp)
  1019. {
  1020.     *pszTemp = '';
  1021.     
  1022.     pPath = new char[strlen(pResource)+2];
  1023.     SafeSprintf(pPath, strlen(pResource)+2, "/%s", pResource);
  1025.     ::SaveStringToHeader(m_pProperties, PROPERTY_PATH, pPath);
  1026. }
  1027. else
  1028. {
  1029.     ::SaveStringToHeader(m_pProperties, PROPERTY_PATH, "/");
  1030. }
  1032. HX_VECTOR_DELETE(pFullPath);
  1033. HX_VECTOR_DELETE(pPath);
  1034. HX_VECTOR_DELETE(pResource);
  1035.     }
  1036.     else if (m_unProtocol == rtspProtocol)
  1037.     {
  1038. ::SaveStringToHeader(m_pProperties, PROPERTY_RESOURCE, "");
  1039. ::SaveStringToHeader(m_pProperties, PROPERTY_FULLPATH, "");
  1040. ::SaveStringToHeader(m_pProperties, PROPERTY_PATH, "");
  1041.     }
  1042. }
  1045. HX_RESULT
  1046. CHXURL::GeneratePrefixRootFragment(const char* pURL, CHXString& urlPrefix, 
  1047.    CHXString& urlRoot, char*& pURLFragment)
  1048. {
  1049.     BOOL bHasHost = FALSE;
  1051.     CHXURL urlObj(pURL);
  1052.     IHXValues* pHeader = urlObj.GetProperties();
  1053.     if(!pHeader)
  1054.     {
  1055. return HXR_FAIL;
  1056.     }
  1058.     IHXBuffer* pBuffer = 0;
  1059.     ULONG32 ulTemp;
  1061.     if(HXR_OK == pHeader->GetPropertyBuffer(PROPERTY_SCHEME, pBuffer))
  1062.     {
  1063. urlPrefix = (const char*)pBuffer->GetBuffer();
  1064. urlPrefix += "://";
  1065. pBuffer->Release();
  1066.     }
  1067.     if(HXR_OK == pHeader->GetPropertyBuffer(PROPERTY_HOST, pBuffer))
  1068.     {
  1069. urlPrefix += (const char*)pBuffer->GetBuffer();
  1070. pBuffer->Release();
  1071. bHasHost = TRUE;
  1072.     }
  1073.     if(HXR_OK == pHeader->GetPropertyULONG32(PROPERTY_PORT, ulTemp))
  1074.     {
  1075.   char szTemp[10]; /* Flawfinder: ignore */
  1076. SafeSprintf(szTemp, sizeof(szTemp), ":%d", (UINT16)ulTemp);
  1077. urlPrefix += szTemp;
  1078.     }
  1080.     // set root
  1081.     urlRoot = urlPrefix;
  1083.     if(bHasHost)
  1084.     {
  1085. urlPrefix += "/";
  1086.     }
  1088.     if(HXR_OK == pHeader->GetPropertyBuffer(PROPERTY_RESOURCE, pBuffer))
  1089.     {
  1090. const char* pResource = (const char*)pBuffer->GetBuffer();
  1091. const char  cDelimiter1  = '/';
  1092. const char  cDelimiter2  = '\';
  1093. const char  cOSDelimiter = OS_SEPARATOR_CHAR;
  1095. CHXString   strURLWork = pResource; 
  1097. char* pFirstChar    = strURLWork.GetBuffer(strURLWork.GetLength());
  1098. char* pLastChar     = NULL;
  1099. char* pOptions     = NULL;
  1100. char* pFragment     = NULL;
  1102. pOptions = strchr(pFirstChar, '?');
  1104. if (pOptions)
  1105. {
  1106.     pLastChar = pOptions -1;
  1107. }
  1108. else
  1109. {
  1110.     pLastChar = pFirstChar + strlen(pFirstChar)-1;
  1111. }
  1113. while ((pLastChar > pFirstChar) && 
  1114.    (*pLastChar != cDelimiter1) && (*pLastChar != cDelimiter2) &&
  1115.    (*pLastChar != cOSDelimiter))
  1116. {
  1117. pLastChar--;
  1118. }
  1119. // If we hit a delimiter before hitting the end, back up one character!
  1120. if(pLastChar > pFirstChar) 
  1121. {
  1122.     *(++pLastChar) = '';
  1123.     
  1124.     urlPrefix += pFirstChar;
  1125. }
  1126. pBuffer->Release();
  1127.     }
  1129.     if(HXR_OK == pHeader->GetPropertyBuffer(PROPERTY_FRAGMENT, pBuffer))
  1130.     {
  1131. const char* pFragment = (const char*)pBuffer->GetBuffer();
  1132. pURLFragment = new_string(pFragment);
  1133. pBuffer->Release();
  1134.     }
  1136.     HX_RELEASE(pHeader);
  1138.     return HXR_OK;
  1139. }
  1141. BOOL 
  1142. CHXURL::CompressURL(const char* pURL, char*& pCompressURL)
  1143. {
  1144.     HX_ASSERT(pURL != NULL);
  1146.     if (!pURL)
  1147.     {
  1148. return FALSE;
  1149.     }
  1151.     pCompressURL     = NULL;
  1153.     BOOL bNeedToCompress    = FALSE; 
  1154.     char separator1     = '\';
  1155.     char separator2     = '/';
  1156.     char* pWalker     = (char*) pURL;
  1158.     while (*pWalker)
  1159.     {
  1160. /* 
  1161.  *   /./ || /. || ./ || . || 
  1162.  *   /../ || /.. || ../ || ..
  1163.  */
  1164. if ((*pWalker     == separator1 || *pWalker == separator2) &&
  1165.     (*(pWalker+1)   == '.') &&
  1166.     ((*(pWalker+2)   == separator1 || *(pWalker+2) == separator2) ||
  1167.      ((*(pWalker+2)   == '.') &&
  1168.      (*(pWalker+3)   == separator1 || *(pWalker+3) == separator2))))
  1169. {
  1170.     // we need to commpress it
  1171.     bNeedToCompress = TRUE;
  1172.     break;
  1173. }
  1175. /* Do not process options in the URL (stuff after ?) */
  1176. if (*pWalker == '?')
  1177. {
  1178.     break;
  1179. }
  1181. pWalker++;
  1182.     }
  1184.     if (!bNeedToCompress)
  1185.     {
  1186. return FALSE;
  1187.     }
  1189.     UINT32 ulURLLength;
  1190.     char* pTempURL;
  1191.     char* pOptions;
  1193.     ulURLLength = strlen(pURL) + 1;
  1194.     pTempURL = new char[ulURLLength];
  1195.     ::strcpy(pTempURL, pURL); /* Flawfinder: ignore */
  1197.     pOptions = strchr(pTempURL, '?');
  1199.     /* We will only compress till before the options and then paste the options
  1200.      * at the end
  1201.      */
  1202.     if (pOptions)
  1203.     {
  1204. *pOptions = '';
  1205.     }
  1207.     CHXSimpleList* pList;
  1208.     char* pToken;
  1209.     UINT16 uNumToBeDiscarded;
  1210.     CHXSimpleList* pNewList;
  1211.     
  1212.     pList    = new CHXSimpleList;
  1213.     pNewList = new CHXSimpleList;
  1214.     uNumToBeDiscarded = 0;
  1216.     pWalker = pToken = pTempURL;    
  1217.     while (*pWalker)
  1218.     {
  1219. if (*pWalker == '/' || *pWalker == '\')
  1220. {
  1221.     *pWalker = '';
  1222.     pList->AddTail(pToken);
  1223.     pToken = pWalker+1;
  1224. }
  1225. pWalker++;
  1226.     }
  1228.     pList->AddTail(pToken);
  1230.     while (pList->GetCount() > 0)
  1231.     {
  1232. pToken = (char*) pList->RemoveTail();
  1233. if (::strcmp(pToken, ".") == 0)
  1234. {
  1235.     /* ignore it */    
  1236. }
  1237. else if (::strcmp(pToken, "..") == 0)
  1238. {
  1239.     uNumToBeDiscarded++;
  1240. }
  1241. else if (uNumToBeDiscarded > 0)
  1242. {
  1243.     uNumToBeDiscarded--;
  1244. }
  1245. else
  1246. {
  1247.     pNewList->AddTail(pToken);
  1248. }
  1249.     }
  1251. // /Valid content that starts with "../../" will trigger this, so turn it off
  1252. // unless someone wants to refine it:
  1253. #if defined(ALLOW_IRRITATING_ASSERTS_FOR_VALID_CONTENT)
  1254.     // This will trigger with malformed urls with two additional ellipses(..)
  1255.     HX_ASSERT(uNumToBeDiscarded == 0 && pNewList->GetCount() > 0);
  1256. #endif
  1258.     if (uNumToBeDiscarded > 0 || pNewList->GetCount() == 0)
  1259.     {
  1260. bNeedToCompress = FALSE;
  1261. goto exit;
  1262.     }
  1264.     pCompressURL = new char[ulURLLength];
  1265.     *pCompressURL = '';
  1266.     while (pNewList->GetCount() > 0)
  1267.     {
  1268. pToken = (char*) pNewList->RemoveTail();
  1269. SafeStrCat(pCompressURL, (const char*) pToken, ulURLLength);
  1271. if (!pNewList->IsEmpty())
  1272. {
  1273.     SafeStrCat(pCompressURL, "/", ulURLLength);
  1274. }
  1275.     }
  1277.     if (pOptions)
  1278.     {
  1279. SafeStrCat(pCompressURL, "?", ulURLLength);
  1280. SafeStrCat(pCompressURL, (const char*) (pOptions+1), ulURLLength);
  1281.     }
  1283. exit:
  1284.     HX_VECTOR_DELETE(pTempURL);
  1285.     HX_DELETE(pList);
  1286.     HX_DELETE(pNewList);
  1287.     return bNeedToCompress;
  1288. }
  1290. HX_RESULT
  1291. CHXURL::encodeURL(const char* pURL, CHXString& encodedURL)
  1292. {
  1293.     HX_RESULT rc = HXR_OK;
  1295.     char    hexBuf[3] = {0}; /* Flawfinder: ignore */
  1296.     char*   pEncodeBuf = new char[(strlen(pURL)+1)*3];    // overkill
  1297.     char*   pEncodePtr = pEncodeBuf;
  1298.     const   char* pURLPtr = pURL;
  1300.     while(*pURLPtr)
  1301.     {
  1302.      // according to the URL encoding spec. from
  1303. // http://www.isi.edu/in-notes/rfc1738.txt
  1304. if (*pURLPtr <= 0x1f ||
  1305.     *pURLPtr >= 0x7f ||
  1306.     HXIsEqual(pURLPtr, ' ') ||
  1307. //     HXIsEqual(pURLPtr, '<') ||
  1308. //     HXIsEqual(pURLPtr, '>') ||
  1309. //     HXIsEqual(pURLPtr, '"') ||
  1310. //     HXIsEqual(pURLPtr, '#') ||
  1311. //     HXIsEqual(pURLPtr, '%') ||
  1312.     HXIsEqual(pURLPtr, '{') ||
  1313.     HXIsEqual(pURLPtr, '}') ||
  1314.     HXIsEqual(pURLPtr, '|') ||
  1315.     HXIsEqual(pURLPtr, '\') ||
  1316.     HXIsEqual(pURLPtr, '^') ||
  1317.     HXIsEqual(pURLPtr, '~') ||
  1318.     HXIsEqual(pURLPtr, '[') ||
  1319.     HXIsEqual(pURLPtr, ']') ||
  1320.     HXIsEqual(pURLPtr, '`') ||
  1321.     HXIsEqual(pURLPtr, ',') ||
  1322.     HXIsEqual(pURLPtr, ';'))
  1323. {     
  1324.     SafeSprintf(hexBuf, sizeof(hexBuf), "%02x", (UCHAR)*pURLPtr);
  1325.     *pEncodePtr++ = '%';
  1326.     *pEncodePtr++ = hexBuf[0];
  1327.     *pEncodePtr++ = hexBuf[1];
  1328.     
  1329.     if (HXIsLeadByte(*pURLPtr))
  1330.     {
  1331. SafeSprintf(hexBuf, sizeof(hexBuf), "%02x", (UCHAR)*(pURLPtr+1));
  1332. *pEncodePtr++ = '%';
  1333. *pEncodePtr++ = hexBuf[0];
  1334. *pEncodePtr++ = hexBuf[1];
  1335.     }     
  1336. }
  1337. else
  1338. {
  1339.     *pEncodePtr++ = *pURLPtr;
  1340. }
  1342. pURLPtr = HXGetNextChar(pURLPtr) ;
  1343.     }
  1344.     *pEncodePtr = '';
  1346.     encodedURL = pEncodeBuf;
  1347.     delete[] pEncodeBuf;
  1349.     return rc;
  1350. }
  1352. HX_RESULT
  1353. CHXURL::decodeURL(const char* pURL, CHXString& decodedURL)
  1354. {
  1355.     HX_RESULT rc = HXR_OK;
  1357.     //XXXBAB - reimplement using CHXString::GetBuffer()/SetBuffer()
  1358.     // to avoid memcpy
  1360.     char* pDecodeBuf = new char[strlen(pURL)+1];
  1361.     char* pDecodePtr = pDecodeBuf;
  1362.     const char* pURLPtr = pURL;
  1364.     while(*pURLPtr)
  1365.     {
  1366. switch(*pURLPtr)
  1367. {
  1368.     case '%':
  1369.     {
  1370. char hexBuf[3]; /* Flawfinder: ignore */
  1371. if(pURLPtr[1] &&    // check for overbound condition
  1372.    pURLPtr[2])
  1373. {
  1374.     pURLPtr++;  // walk past '%'
  1375.     hexBuf[0] = *pURLPtr++;
  1376.     hexBuf[1] = *pURLPtr;
  1377.     hexBuf[2] = '';
  1378.     *pDecodePtr++ = (char)strtol(hexBuf, NULL, 16);
  1379. }
  1380.     }
  1381.     break;
  1383.     default:
  1384.     {
  1385. *pDecodePtr++ = *pURLPtr;
  1386.     }
  1387.     break;
  1388. }
  1389. pURLPtr++;
  1390.     }
  1391.     *pDecodePtr = '';
  1393.     decodedURL = pDecodeBuf;
  1394.     delete[] pDecodeBuf;
  1396.     return rc;
  1397. }
  1399. const char* CHXURL::FindURLSchemeEnd(const char *pszURL)
  1400. {
  1401.     const char *pszTemp;
  1403.     for (pszTemp = pszURL; *pszTemp; pszTemp++)
  1404.     {
  1405. if(*pszTemp == ':')
  1406. {
  1407.     return pszTemp;
  1408. }
  1409. else if(*pszTemp == '$' ||
  1410. *pszTemp == '#' ||
  1411. *pszTemp == '?' ||
  1412. *pszTemp == '/' ||
  1413. *pszTemp == '\')
  1414. {
  1415.     return NULL;
  1416. }
  1417.     }
  1418.     
  1419.     return NULL;
  1420. }
  1422. void
  1423. CHXURL::Unescape(char* s)
  1424. {
  1425. /*
  1426.  * Remove URL hex escapes from s... done in place.  The basic concept for
  1427.  * this routine is borrowed from the WWW library HTUnEscape() routine.
  1428.  */
  1429.     char* p = NULL;
  1430.     BOOL bProcessingOptionsPastQuestionMark = FALSE;
  1432.     for (p = s; *s != ''; ++s)
  1433.     {
  1434.         if ( (!bProcessingOptionsPastQuestionMark) && (*s == '%') )
  1435. {
  1436.     if (*++s != '') 
  1437.     {
  1438. *p = Unhex( *s ) << 4;
  1439.     }
  1441.     if (*++s != '') 
  1442.     {
  1443. *p++ += Unhex( *s );
  1444.     }
  1445. } 
  1446. else 
  1447. {
  1448.             if (*s == '?')
  1449.             {
  1450.                 bProcessingOptionsPastQuestionMark = TRUE;
  1451.             }
  1452.     *p++ = *s;
  1453. }
  1454.     }
  1456.     *p = '';
  1457. }
  1459. int
  1460. CHXURL::Unhex(char c)
  1461. {
  1462.     return (c >= '0' && c <= '9' ? c - '0'
  1463.     : c >= 'A' && c <= 'F' ? c - 'A' + 10
  1464.     : c - 'a' + 10 );
  1465. }
  1467. void 
  1468. CHXURL::TestCompressURL()
  1469. {
  1470. #ifdef _DEBUG
  1471.     /* Brad made me do it...:( */
  1472.     char* pTestCompressURL = NULL;
  1473.     BOOL bTestCompress = FALSE;
  1474.     CHXURL url("blah");
  1475.     
  1476.     HX_VERIFY(url.CompressURL("http://blah.real.com/test/../foo.smi", pTestCompressURL) == TRUE &&
  1477.       ::strcmp(pTestCompressURL, "http://blah.real.com/foo.smi") == 0);
  1478.     HX_VECTOR_DELETE(pTestCompressURL);
  1480.     HX_VERIFY(url.CompressURL("http://blah.real.com/test/foo.smi?foo/../.", pTestCompressURL) == FALSE);
  1481.     HX_VECTOR_DELETE(pTestCompressURL);
  1483.     HX_VERIFY(url.CompressURL("http://blah.real.com/test/./foo.smi", pTestCompressURL) == TRUE &&
  1484.       ::strcmp(pTestCompressURL, "http://blah.real.com/test/foo.smi") == 0);
  1485.     HX_VECTOR_DELETE(pTestCompressURL);
  1487.     HX_VERIFY(url.CompressURL("http://blah.real.com/test/.blah/foo.smi", pTestCompressURL) == FALSE);
  1488.     HX_VECTOR_DELETE(pTestCompressURL);
  1490.     HX_VERIFY(url.CompressURL("http://blah.real.com/test/..foo.smi", pTestCompressURL) == FALSE);
  1491.     HX_VECTOR_DELETE(pTestCompressURL);
  1493.     HX_VERIFY(url.CompressURL("rtsp://blah.real.com/test/blah/../../foo.smi?end=./../blah", pTestCompressURL)  == TRUE &&
  1494.       ::strcmp(pTestCompressURL, "rtsp://blah.real.com/foo.smi?end=./../blah") == 0);
  1495.     HX_VECTOR_DELETE(pTestCompressURL);
  1496. #endif
  1497. }
  1499. IHXCommonClassFactory* CHXURL::CreateCCF()
  1500. {
  1501.     return  new CHXMiniCCF();
  1502. }