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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
XMLURL.cpp
资源名称：xerces-c-src1_6_0.tar.gz　[点击查看]
上传用户：huihehuasu
上传日期：2007-01-10
资源大小：6948k
文件大小：33k
源码类别：

xml/soap/webservice

开发平台：

C/C++

XMLURL.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-2001 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  57. /*
  58.  * $Id: XMLURL.cpp,v 1.20 2001/10/10 23:16:46 jasons Exp $
  59.  */
  62. // ---------------------------------------------------------------------------
  63. //  Includes
  64. // ---------------------------------------------------------------------------
  65. #include <util/BinFileInputStream.hpp>
  66. #include <util/Janitor.hpp>
  67. #include <util/PlatformUtils.hpp>
  68. #include <util/RuntimeException.hpp>
  69. #include <util/TransService.hpp>
  70. #include <util/XMLURL.hpp>
  71. #include <util/XMLNetAccessor.hpp>
  72. #include <util/XMLString.hpp>
  73. #include <util/XMLUniDefs.hpp>
  74. #include <util/XMLUni.hpp>
  78. // ---------------------------------------------------------------------------
  79. //  Local types
  80. //
  81. //  TypeEntry
  82. //      This structure defines a single entry in the list of URL types. Each
  83. //      entry indicates the prefix for that type of URL, and the SourceTypes
  84. //      value it maps to.
  85. // ---------------------------------------------------------------------------
  86. struct ProtoEntry
  87. {
  88.     XMLURL::Protocols   protocol;
  89.     const XMLCh*        prefix;
  90.     unsigned int        defPort;
  91. };
  94. // ---------------------------------------------------------------------------
  95. //  Local data
  96. //
  97. //  gXXXString
  98. //      These are the strings for our prefix types. They all have to be
  99. //      Unicode strings all the time, so we can't just do regular strings.
  100. //
  101. //  gProtoList
  102. //      The list of URL types that we support and some info related to each
  103. //      one.
  104. //
  105. //  gMaxProtoLen
  106. //      The length of the longest protocol string
  107. //
  108. //      NOTE:!!! Be sure to keep this up to date if new protocols are added!
  109. // ---------------------------------------------------------------------------
  110. static const XMLCh  gFileString[] =
  111. {
  112.         chLatin_f, chLatin_i, chLatin_l, chLatin_e, chNull
  113. };
  115. static const XMLCh gFTPString[]  =
  116. {
  117.         chLatin_f, chLatin_t, chLatin_p, chNull
  118. };
  120. static const XMLCh gHTTPString[] =
  121. {
  122.         chLatin_h, chLatin_t, chLatin_t, chLatin_p, chNull
  123. };
  125. static ProtoEntry gProtoList[XMLURL::Protocols_Count] =
  126. {
  127.         { XMLURL::File     , gFileString    , 0  }
  128.     ,   { XMLURL::HTTP     , gHTTPString    , 80 }
  129.     ,   { XMLURL::FTP      , gFTPString     , 21 }
  130. };
  132. // !!! Keep these up to date with list above!
  133. static const unsigned int gMaxProtoLen = 4;
  136. // ---------------------------------------------------------------------------
  137. //  Local methods
  138. // ---------------------------------------------------------------------------
  139. static bool isHexDigit(const XMLCh toCheck)
  140. {
  141.     if ((toCheck >= chDigit_0) && (toCheck <= chDigit_9)
  142.     ||  (toCheck >= chLatin_A) && (toCheck <= chLatin_Z)
  143.     ||  (toCheck >= chLatin_a) && (toCheck <= chLatin_z))
  144.     {
  145.         return true;
  146.     }
  147.     return false;
  148. }
  150. static unsigned int xlatHexDigit(const XMLCh toXlat)
  151. {
  152.     if ((toXlat >= chDigit_0) && (toXlat <= chDigit_9))
  153.         return (unsigned int)(toXlat - chDigit_0);
  155.     if ((toXlat >= chLatin_A) && (toXlat <= chLatin_Z))
  156.         return (unsigned int)(toXlat - chLatin_A) + 10;
  158.     return (unsigned int)(toXlat - chLatin_a) + 10;
  159. }
  163. // ---------------------------------------------------------------------------
  164. //  XMLURL: Public, static methods
  165. // ---------------------------------------------------------------------------
  166. XMLURL::Protocols XMLURL::lookupByName(const XMLCh* const protoName)
  167. {
  168.     for (unsigned int index = 0; index < XMLURL::Protocols_Count; index++)
  169.     {
  170.         if (!XMLString::compareIString(gProtoList[index].prefix, protoName))
  171.             return gProtoList[index].protocol;
  172.     }
  173.     return XMLURL::Unknown;
  174. }
  178. // ---------------------------------------------------------------------------
  179. //  XMLURL: Constructors and Destructor
  180. // ---------------------------------------------------------------------------
  181. XMLURL::XMLURL() :
  183.     fFragment(0)
  184.     , fHost(0)
  185.     , fPassword(0)
  186.     , fPath(0)
  187.     , fPortNum(0)
  188.     , fProtocol(XMLURL::Unknown)
  189.     , fQuery(0)
  190.     , fUser(0)
  191.     , fURLText(0)
  192. {
  193. }
  195. XMLURL::XMLURL(const XMLCh* const    baseURL
  196.              , const XMLCh* const    relativeURL) :
  198.     fFragment(0)
  199.     , fHost(0)
  200.     , fPassword(0)
  201.     , fPath(0)
  202.     , fPortNum(0)
  203.     , fProtocol(XMLURL::Unknown)
  204.     , fQuery(0)
  205.     , fUser(0)
  206.     , fURLText(0)
  207. {
  208. try
  209. {
  210. setURL(baseURL, relativeURL);
  211. }
  212.     catch(...)
  213.     {
  214.         cleanup();
  215.         throw;
  216.     }
  217. }
  219. XMLURL::XMLURL(const XMLCh* const    baseURL
  220.              , const char* const     relativeURL) :
  222.     fFragment(0)
  223.     , fHost(0)
  224.     , fPassword(0)
  225.     , fPath(0)
  226.     , fPortNum(0)
  227.     , fProtocol(XMLURL::Unknown)
  228.     , fQuery(0)
  229.     , fUser(0)
  230.     , fURLText(0)
  231. {
  232.     XMLCh* tmpRel = XMLString::transcode(relativeURL);
  233.     ArrayJanitor<XMLCh> janRel(tmpRel);
  234. try
  235. {
  236. setURL(baseURL, tmpRel);
  237. }
  238.     catch(...)
  239.     {
  240.         cleanup();
  241.         throw;
  242.     }
  243. }
  245. XMLURL::XMLURL(const XMLURL&         baseURL
  246.              , const XMLCh* const    relativeURL) :
  248.     fFragment(0)
  249.     , fHost(0)
  250.     , fPassword(0)
  251.     , fPath(0)
  252.     , fPortNum(0)
  253.     , fProtocol(XMLURL::Unknown)
  254.     , fQuery(0)
  255.     , fUser(0)
  256.     , fURLText(0)
  257. {
  258. try
  259. {
  260. setURL(baseURL, relativeURL);
  261. }
  262.     catch(...)
  263.     {
  264.         cleanup();
  265.         throw;
  266.     }
  267. }
  269. XMLURL::XMLURL(const  XMLURL&        baseURL
  270.              , const char* const     relativeURL) :
  272.     fFragment(0)
  273.     , fHost(0)
  274.     , fPassword(0)
  275.     , fPath(0)
  276.     , fPortNum(0)
  277.     , fProtocol(XMLURL::Unknown)
  278.     , fQuery(0)
  279.     , fUser(0)
  280.     , fURLText(0)
  281. {
  282.     XMLCh* tmpRel = XMLString::transcode(relativeURL);
  283.     ArrayJanitor<XMLCh> janRel(tmpRel);
  284. try
  285. {
  286. setURL(baseURL, tmpRel);
  287. }
  288.     catch(...)
  289.     {
  290.         cleanup();
  291.         throw;
  292.     }
  294. }
  296. XMLURL::XMLURL(const XMLCh* const urlText) :
  298.     fFragment(0)
  299.     , fHost(0)
  300.     , fPassword(0)
  301.     , fPath(0)
  302.     , fPortNum(0)
  303.     , fProtocol(XMLURL::Unknown)
  304.     , fQuery(0)
  305.     , fUser(0)
  306.     , fURLText(0)
  307. {
  308. try
  309. {
  310.     setURL(urlText);
  311. }
  312.     catch(...)
  313.     {
  314.         cleanup();
  315.         throw;
  316.     }
  317. }
  319. XMLURL::XMLURL(const char* const urlText) :
  321.     fFragment(0)
  322.     , fHost(0)
  323.     , fPassword(0)
  324.     , fPath(0)
  325.     , fPortNum(0)
  326.     , fProtocol(XMLURL::Unknown)
  327.     , fQuery(0)
  328.     , fUser(0)
  329.     , fURLText(0)
  330. {
  331.     XMLCh* tmpText = XMLString::transcode(urlText);
  332.     ArrayJanitor<XMLCh> janRel(tmpText);
  333. try
  334. {
  335.     setURL(tmpText);
  336. }
  337.     catch(...)
  338.     {
  339.         cleanup();
  340.         throw;
  341.     }
  342. }
  344. XMLURL::XMLURL(const XMLURL& toCopy) :
  346.     fFragment(XMLString::replicate(toCopy.fFragment))
  347.     , fHost(XMLString::replicate(toCopy.fHost))
  348.     , fPassword(XMLString::replicate(toCopy.fPassword))
  349.     , fPath(XMLString::replicate(toCopy.fPath))
  350.     , fPortNum(toCopy.fPortNum)
  351.     , fProtocol(toCopy.fProtocol)
  352.     , fQuery(XMLString::replicate(toCopy.fQuery))
  353.     , fUser(XMLString::replicate(toCopy.fUser))
  354.     , fURLText(XMLString::replicate(toCopy.fURLText))
  355. {
  356. }
  358. XMLURL::~XMLURL()
  359. {
  360.     cleanup();
  361. }
  364. // ---------------------------------------------------------------------------
  365. //  XMLURL: Public operators
  366. // ---------------------------------------------------------------------------
  367. XMLURL& XMLURL::operator=(const XMLURL& toAssign)
  368. {
  369.     if (this == &toAssign)
  370.         return *this;
  372.     // Clean up our stuff
  373.     cleanup();
  375.     // And copy his stuff
  376.     fFragment = XMLString::replicate(toAssign.fFragment);
  377.     fHost = XMLString::replicate(toAssign.fHost);
  378.     fPassword = XMLString::replicate(toAssign.fPassword);
  379.     fPath = XMLString::replicate(toAssign.fPath);
  380.     fProtocol = toAssign.fProtocol;
  381.     fQuery = XMLString::replicate(toAssign.fQuery);
  382.     fUser = XMLString::replicate(toAssign.fUser);
  383.     fURLText = XMLString::replicate(toAssign.fURLText);
  385.     return *this;
  386. }
  388. bool XMLURL::operator==(const XMLURL& toCompare) const
  389. {
  390.     //
  391.     //  Compare the two complete URLs (which have been processed the same
  392.     //  way so they should now be the same even if they came in via different
  393.     //  relative parts.
  394.     //
  395.     if (XMLString::compareString(getURLText(), toCompare.getURLText()))
  396.         return false;
  398.     return true;
  399. }
  403. // ---------------------------------------------------------------------------
  404. //  XMLURL: Getter methods
  405. // ---------------------------------------------------------------------------
  406. unsigned int XMLURL::getPortNum() const
  407. {
  408.     //
  409.     //  If it was not provided explicitly, then lets return the default one
  410.     //  for the protocol.
  411.     //
  412.     if (!fPortNum)
  413.     {
  414.         if (fProtocol == Unknown)
  415.             return 0;
  416.         return gProtoList[fProtocol].defPort;
  417.     }
  418.     return fPortNum;
  419. }
  422. const XMLCh* XMLURL::getProtocolName() const
  423. {
  424.     // Check to see if its ever been set
  425.     if (fProtocol == Unknown)
  426.         ThrowXML(MalformedURLException, XMLExcepts::URL_NoProtocolPresent);
  428.     return gProtoList[fProtocol].prefix;
  429. }
  432. // ---------------------------------------------------------------------------
  433. //  XMLURL: Setter methods
  434. // ---------------------------------------------------------------------------
  435. void XMLURL::setURL(const XMLCh* const urlText)
  436. {
  437.     //
  438.     //  Try to parse the URL.
  439.     //
  440.     cleanup();
  441.     parse(urlText);
  442. }
  444. void XMLURL::setURL(const XMLCh* const    baseURL
  445.                   , const XMLCh* const    relativeURL)
  446. {
  447.     cleanup();
  449.     // Parse our URL string
  450.     parse(relativeURL);
  452. //
  453. //  If its relative and the base is non-null and non-empty, then
  454. //  parse the base URL string and conglomerate them.
  455. //
  456. if (isRelative() && baseURL)
  457. {
  458. if (*baseURL)
  459. {
  460. XMLURL basePart(baseURL);
  461. if (!conglomerateWithBase(basePart, false))
  462. {
  463. cleanup();
  464. ThrowXML(MalformedURLException, XMLExcepts::URL_RelativeBaseURL);
  465. }
  466. }
  467. }
  468. }
  470. void XMLURL::setURL(const XMLURL&         baseURL
  471.                   , const XMLCh* const    relativeURL)
  472. {
  473.     cleanup();
  475. // Parse our URL string
  476.     parse(relativeURL);
  478.     // If its relative, then conglomerate with the base URL
  479.     if (isRelative())
  480. conglomerateWithBase(baseURL);
  481. }
  484. // ---------------------------------------------------------------------------
  485. //  XMLURL: Miscellaneous methods
  486. // ---------------------------------------------------------------------------
  487. bool XMLURL::isRelative() const
  488. {
  489.     // If no protocol then relative
  490.     if (fProtocol == Unknown)
  491.         return true;
  493.     // If no path, or the path is not absolute, then relative
  494.     if (!fPath)
  495.         return true;
  497.     if (*fPath != chForwardSlash)
  498.         return true;
  500.     return false;
  501. }
  504. BinInputStream* XMLURL::makeNewStream() const
  505. {
  506.     //
  507.     //  If its a local host, then we short circuit it and use our own file
  508.     //  stream support. Otherwise, we just let it fall through and let the
  509.     //  installed network access object provide a stream.
  510.     //
  511.     if (fProtocol == XMLURL::File)
  512.     {
  513.         if (!fHost || !XMLString::compareIString(fHost, XMLUni::fgLocalHostString))
  514.         {
  515.             //
  516.             //  We have to play a little trick here. If its really a Windows
  517.             //  style fully qualified path, we have to toss the leading /
  518.             //  character.
  519.             //
  520.             const XMLCh* realPath = fPath;
  521.             if (*fPath == chForwardSlash)
  522.             {
  523.                 if (XMLString::stringLen(fPath) > 3)
  524.                 {
  525.                     if (*(fPath + 2) == chColon)
  526.                     {
  527.                         const XMLCh chDrive = *(fPath + 1);
  528.                         if (((chDrive >= chLatin_A) && (chDrive <= chLatin_Z))
  529.                         ||  ((chDrive >= chLatin_a) && (chDrive <= chLatin_z)))
  530.                         {
  531.                             realPath = fPath + 1;
  532.                         }
  533.                     }
  535.                     // Similarly for UNC paths
  536.                     if ( *(fPath + 1) == *(fPath + 2) &&
  537.                          (*(fPath + 1) == chForwardSlash ||
  538.                           *(fPath + 1) == chBackSlash) )
  539.                     {
  540.                         realPath = fPath + 1;
  541.                     }
  542.                 }
  543.             }
  545.             BinFileInputStream* retStrm = new BinFileInputStream(realPath);
  546.             if (!retStrm->getIsOpen())
  547.             {
  548.                 delete retStrm;
  549.                 return 0;
  550.             }
  551.             return retStrm;
  552.         }
  553.     }
  555.     //
  556.     //  If we don't have have an installed net accessor object, then we
  557.     //  have to just throw here.
  558.     //
  559.     if (!XMLPlatformUtils::fgNetAccessor)
  560.         ThrowXML(MalformedURLException, XMLExcepts::URL_UnsupportedProto);
  562.     // Else ask the net accessor to create the stream
  563.     return XMLPlatformUtils::fgNetAccessor->makeNew(*this);
  564. }
  566. void XMLURL::makeRelativeTo(const XMLCh* const baseURLText)
  567. {
  568.     // If this one is not relative, don't bother
  569.     if (!isRelative())
  570.         return;
  572.     XMLURL baseURL(baseURLText);
  573.     conglomerateWithBase(baseURL);
  574. }
  576. void XMLURL::makeRelativeTo(const XMLURL& baseURL)
  577. {
  578.     // If this one is not relative, don't bother
  579.     if (!isRelative())
  580.         return;
  581.     conglomerateWithBase(baseURL);
  582. }
  587. // ---------------------------------------------------------------------------
  588. //  XMLURL: Private helper methods
  589. // ---------------------------------------------------------------------------
  591. //
  592. //  This method will take the broken out parts of the URL and build up the
  593. //  full text. We don't do this unless someone asks us to, since its often
  594. //  never required.
  595. //
  596. void XMLURL::buildFullText()
  597. {
  598.     // Calculate the worst case size of the buffer required
  599.     unsigned int bufSize = gMaxProtoLen + 1
  600.                            + XMLString::stringLen(fFragment) + 1
  601.                            + XMLString::stringLen(fHost) + 2
  602.                            + XMLString::stringLen(fPassword) + 1
  603.                            + XMLString::stringLen(fPath)
  604.                            + XMLString::stringLen(fQuery) + 1
  605.                            + XMLString::stringLen(fUser) + 1
  606.                            + 32;
  608.     // Clean up the existing buffer and allocate another
  609.     delete [] fURLText;
  610.     fURLText = new XMLCh[bufSize];
  611.     *fURLText = 0;
  613.     XMLCh* outPtr = fURLText;
  614.     if (fProtocol != Unknown)
  615.     {
  616.         XMLString::catString(fURLText, getProtocolName());
  617.         outPtr += XMLString::stringLen(fURLText);
  618.         *outPtr++ = chColon;
  619.         *outPtr++ = chForwardSlash;
  620.         *outPtr++ = chForwardSlash;
  621.     }
  623.     if (fUser)
  624.     {
  625.         XMLString::copyString(outPtr, fUser);
  626.         outPtr += XMLString::stringLen(fUser);
  628.         if (fPassword)
  629.         {
  630.             *outPtr++ = chColon;
  631.             XMLString::copyString(outPtr, fPassword);
  632.             outPtr += XMLString::stringLen(fPassword);
  633.         }
  635.         *outPtr++ = chAt;
  636.     }
  638.     if (fHost)
  639.     {
  640.         XMLString::copyString(outPtr, fHost);
  641.         outPtr += XMLString::stringLen(fHost);
  643.         //
  644.         //  If the port is zero, then we don't put it in. Else we need
  645.         //  to because it was explicitly provided.
  646.         //
  647.         if (fPortNum)
  648.         {
  649.             *outPtr++ = chColon;
  651.             XMLCh tmpBuf[16];
  652.             XMLString::binToText(fPortNum, tmpBuf, 16, 10);
  653.             XMLString::copyString(outPtr, tmpBuf);
  654.             outPtr += XMLString::stringLen(tmpBuf);
  655.         }
  656.     }
  658.     if (fPath)
  659.     {
  660.         XMLString::copyString(outPtr, fPath);
  661.         outPtr += XMLString::stringLen(fPath);
  662.     }
  664.     if (fQuery)
  665.     {
  666.         *outPtr++ = chQuestion;
  667.         XMLString::copyString(outPtr, fQuery);
  668.         outPtr += XMLString::stringLen(fQuery);
  669.     }
  671.     if (fFragment)
  672.     {
  673.         *outPtr++ = chPound;
  674.         XMLString::copyString(outPtr, fFragment);
  675.         outPtr += XMLString::stringLen(fFragment);
  676.     }
  678.     // Cap it off in case the last op was not a string copy
  679.     *outPtr = 0;
  680. }
  683. //
  684. //  Just a central place to handle cleanup, since its done from a number
  685. //  of different spots.
  686. //
  687. void XMLURL::cleanup()
  688. {
  689.     delete [] fFragment;
  690.     delete [] fHost;
  691.     delete [] fPassword;
  692.     delete [] fPath;
  693.     delete [] fQuery;
  694.     delete [] fUser;
  695.     delete [] fURLText;
  697.     fFragment = 0;
  698.     fHost = 0;
  699.     fPassword = 0;
  700.     fPath = 0;
  701.     fQuery = 0;
  702.     fUser = 0;
  703.     fURLText = 0;
  705.     fProtocol = Unknown;
  706.     fPortNum = 0;
  707. }
  710. //This function  has been modified to take a bool parameter and the
  711. //functionality inside looks irrational but is only to make
  712. //solaris 2.7 CC 5.0 optimized build happy.
  714. bool XMLURL::conglomerateWithBase(const XMLURL& baseURL, bool useExceptions)
  715. {
  716.     // The base URL cannot be relative
  717.     if (baseURL.isRelative())
  718.     {
  719.         if (useExceptions)
  720. ThrowXML(MalformedURLException, XMLExcepts::URL_RelativeBaseURL);
  721.         else
  722.             return false;
  723.     }
  725.     //
  726.     //  Check a special case. If all we have is a fragment, then we want
  727.     //  to just take the base host and path, plus our fragment.
  728.     //
  729.     if ((fProtocol == Unknown)
  730.     &&  !fHost
  731.     &&  !fPath
  732.     &&  fFragment)
  733.     {
  734.         // Just in case, make sure we don't leak the user or password values
  735.         delete [] fUser;
  736.         fUser = 0;
  737.         delete [] fPassword;
  738.         fPassword = 0;
  740.         // Copy over the protocol and port number as is
  741.         fProtocol = baseURL.fProtocol;
  742.         fPortNum = baseURL.fPortNum;
  744.         // Replicate the base fields that are provided
  745.         fHost = XMLString::replicate(baseURL.fHost);
  746.         fUser = XMLString::replicate(baseURL.fUser);
  747.         fPassword = XMLString::replicate(baseURL.fPassword);
  748.         fPath = XMLString::replicate(baseURL.fPath);
  749.         return true;
  750.     }
  752.     //
  753.     //  All we have to do is run up through our fields and, for each one
  754.     //  that we don't have, use the based URL's. Once we hit one field
  755.     //  that we have, we stop.
  756.     //
  757.     if (fProtocol != Unknown)
  758.         return true;
  759.     fProtocol = baseURL.fProtocol;
  761.     //
  762.     //  If the protocol is not file, and we either already have our own
  763.     //  host, or the base does not have one, then we are done.
  764.     //
  765.     if (fProtocol != File)
  766.     {
  767.         if (fHost || !baseURL.fHost)
  768.             return true;
  769.     }
  771.     // Replicate all of the hosty stuff if the base has one
  772.     if (baseURL.fHost)
  773.     {
  774.         // Just in case, make sure we don't leak a user or password field
  775.         delete [] fUser;
  776.         fUser = 0;
  777.         delete [] fPassword;
  778.         fPassword = 0;
  779.         delete [] fHost;
  780.         fHost = 0;
  782.         fHost = XMLString::replicate(baseURL.fHost);
  783.         fUser = XMLString::replicate(baseURL.fUser);
  784.         fPassword = XMLString::replicate(baseURL.fPassword);
  786.         fPortNum = baseURL.fPortNum;
  787.     }
  789.     // If we have a path and its absolute, then we are done
  790.     const bool hadPath = (fPath != 0);
  791.     if (hadPath)
  792.     {
  793.         if (*fPath == chForwardSlash)
  794.             return true;
  795.     }
  797.     // Its a relative path, so weave them together.
  798.     if (baseURL.fPath)
  799.         weavePaths(baseURL.fPath);
  801.     // If we had any original path, then we are done
  802.     if (hadPath)
  803.         return true;
  805.     // We had no original path, so go on to deal with the query/fragment parts
  806.     if (fQuery || !baseURL.fQuery)
  807.         return true;
  808.     fQuery = XMLString::replicate(baseURL.fQuery);
  810.     if (fFragment || !baseURL.fFragment)
  811.         return true;
  812.     fFragment = XMLString::replicate(baseURL.fFragment);
  813. return true;
  814. }
  817. void XMLURL::parse(const XMLCh* const urlText)
  818. {
  819.     // Simplify things by checking for the psycho scenarios first
  820.     if (!*urlText)
  821.         ThrowXML(MalformedURLException, XMLExcepts::URL_NoProtocolPresent);
  823.     //
  824.     //  The first thing we will do is to check for a file name, so that
  825.     //  we don't waste time thinking its a URL. If its in the form x:
  826.     //  or x:/ and x is an ASCII letter, then assume that's the deal.
  827.     //
  828.     if (((*urlText >= chLatin_A) && (*urlText <= chLatin_Z))
  829.     ||  ((*urlText >= chLatin_a) && (*urlText <= chLatin_z)))
  830.     {
  831.         if (*(urlText + 1) == chColon)
  832.         {
  833.             if ((*(urlText + 2) == chForwardSlash)
  834.             ||  (*(urlText + 2) == chBackSlash))
  835.             {
  836.                 ThrowXML(MalformedURLException, XMLExcepts::URL_NoProtocolPresent);
  837.             }
  838.         }
  839.     }
  841.     // Get a copy of the URL that we can modify
  842.     XMLCh* srcCpy = XMLString::replicate(urlText);
  843.     ArrayJanitor<XMLCh> janSrcCopy(srcCpy);
  845.     //
  846.     //  Get a pointer now that we can run up thrown the source as we parse
  847.     //  bits and pieces out of it.
  848.     //
  849.     XMLCh* srcPtr = srcCpy;
  851.     // Run up past any spaces
  852.     while (*srcPtr)
  853.     {
  854.         if (!XMLPlatformUtils::fgTransService->isSpace(*srcPtr))
  855.             break;
  856.         srcPtr++;
  857.     }
  859.     // Make sure it wasn't all space
  860.     if (!*srcPtr)
  861.         ThrowXML(MalformedURLException, XMLExcepts::URL_NoProtocolPresent);
  863.     //
  864.     //  Ok, the next thing we have to do is to find either a / or : character.
  865.     //  If the : is first, we assume we have a protocol. If the / is first,
  866.     //  then we skip to the host processing.
  867.     //
  868.     static const XMLCh listOne[]    = { chColon, chForwardSlash, chNull };
  869.     static const XMLCh listTwo[]    = { chAt, chNull };
  870.     static const XMLCh listThree[]  = { chColon, chNull };
  871.     static const XMLCh listFour[]   = { chForwardSlash, chNull };
  872.     static const XMLCh listFive[]   = { chPound, chQuestion, chNull };
  873.     static const XMLCh listSix[]    = { chPound, chNull };
  874.     XMLCh* ptr1 = XMLString::findAny(srcPtr, listOne);
  875.     XMLCh* ptr2;
  877.     // If we found a protocol, then deal with it
  878.     if (ptr1)
  879.     {
  880.         if (*ptr1 == chColon)
  881.         {
  882.             // Cap the string at the colon
  883.             *ptr1 = 0;
  885.             // And try to find it in our list of protocols
  886.             fProtocol = lookupByName(srcPtr);
  888.             if (fProtocol == Unknown)
  889.             {
  890.                 ThrowXML1
  891.                 (
  892.                     MalformedURLException
  893.                     , XMLExcepts::URL_UnsupportedProto1
  894.                     , srcPtr
  895.                 );
  896.             }
  898.             // And move our source pointer up past what we've processed
  899.             srcPtr = (ptr1 + 1);
  900.         }
  901.     }
  903.     //
  904.     //  Ok, next we need to see if we have any host part. If the next
  905.     //  two characters are //, then we need to check, else move on.
  906.     //
  907.     if ((*srcPtr == chForwardSlash) && (*(srcPtr + 1) == chForwardSlash))
  908.     {
  909.         // Move up past the slashes
  910.         srcPtr += 2;
  912.         //
  913.         //  If we aren't at the end of the string, then there has to be a
  914.         //  host part at this point. we will just look for the next / char
  915.         //  or end of string and make all of that the host for now.
  916.         //
  917.         if (*srcPtr)
  918.         {
  919.             // Search from here for a / character
  920.             ptr1 = XMLString::findAny(srcPtr, listFour);
  922.             //
  923.             //  If we found something, then the host is between where
  924.             //  we are and what we found. Else the host is the rest of
  925.             //  the content and we are done. If its empty, leave it null.
  926.             //
  927.             if (ptr1)
  928.             {
  929.                 if (ptr1 != srcPtr)
  930.                 {
  931.                     delete [] fHost;
  932.                     fHost = new XMLCh[(ptr1 - srcPtr) + 1];
  933.                     ptr2 = fHost;
  934.                     while (srcPtr < ptr1)
  935.                         *ptr2++ = *srcPtr++;
  936.                     *ptr2 = 0;
  937.                 }
  938.             }
  939.              else
  940.             {
  941.                 delete [] fHost;
  942.                 fHost = XMLString::replicate(srcPtr);
  944.                 // Update source pointer to the end
  945.                 srcPtr += XMLString::stringLen(fHost);
  946.             }
  947.         }
  948.     } 
  949.     else 
  950.     {
  951.     //
  952.     // http protocol requires two forward slashes
  953.     // we didn't get them, so throw an exception
  954.     //
  955. if (fProtocol == HTTP) {
  956.                 ThrowXML1
  957.                 (
  958.                     MalformedURLException
  959.                     , XMLExcepts::URL_ExpectingTwoSlashes
  960.                     , "Found 'http' protocol"
  961.                 );
  962. }
  963.     }
  965.     //
  966.     //  If there was a host part, then we have to grovel through it for
  967.     //  all the bits and pieces it can hold.
  968.     //
  969.     if (fHost)
  970.     {
  971.         //
  972.         //  Look for a '@' character, which indicates a user name. If we
  973.         //  find one, then everything between the start of the host data
  974.         //  and the character is the user name.
  975.         //
  976.         ptr1 = XMLString::findAny(fHost, listTwo);
  977.         if (ptr1)
  978.         {
  979.             // Get this info out as the user name
  980.             *ptr1 = 0;
  981.             delete [] fUser;
  982.             fUser = XMLString::replicate(fHost);
  983.             ptr1++;
  985.             // And now cut these chars from the host string
  986.             XMLString::cut(fHost, ptr1 - fHost);
  988.             // Is there a password inside the user string?
  989.             ptr2 = XMLString::findAny(fUser, listThree);
  990.             if (ptr2)
  991.             {
  992.                 // Remove it from the user name string
  993.                 *ptr2 = 0;
  995.                 // And copy out the remainder to the password field
  996.                 ptr2++;
  997.                 delete [] fPassword;
  998.                 fPassword = XMLString::replicate(ptr2);
  999.             }
  1000.         }
  1002.         //
  1003.         //  Ok, so now we are at the actual host name, if any. If we are
  1004.         //  not at the end of the host data, then lets see if we have a
  1005.         //  port trailing the
  1006.         //
  1007.         ptr1 = XMLString::findAny(fHost, listThree);
  1008.         if (ptr1)
  1009.         {
  1010.             // Remove it from the host name
  1011.             *ptr1 = 0;
  1013.             // Try to convert it to a numeric port value and store it
  1014.             ptr1++;
  1015.             if (!XMLString::textToBin(ptr1, fPortNum))
  1016.                 ThrowXML(MalformedURLException, XMLExcepts::URL_BadPortField);
  1017.         }
  1019.         // If the host ended up empty, then toss is
  1020.         if (!*fHost)
  1021.         {
  1022.             delete[] fHost;
  1023.             fHost = 0;
  1024.         }
  1025.     }
  1027.     // If we are at the end, then we are done now
  1028.     if (!*srcPtr)
  1029. {
  1030.         return;
  1031. }
  1033.     //
  1034.     //  Next is the path part. It can be absolute, i.e. starting with a
  1035.     //  forward slash character, or relative. Its basically everything up
  1036.     //  to the end of the string or to any trailing query or fragment.
  1037.     //
  1038.     ptr1 = XMLString::findAny(srcPtr, listFive);
  1039.     if (!ptr1)
  1040.     {
  1041.         delete [] fPath;
  1042.         fPath = XMLString::replicate(srcPtr);
  1043.         return;
  1044.     }
  1046.     // Everything from where we are to what we found is the path
  1047.     if (ptr1 > srcPtr)
  1048.     {
  1049.         delete [] fPath;
  1050.         fPath = new XMLCh[(ptr1 - srcPtr) + 1];
  1051.         ptr2 = fPath;
  1052.         while (srcPtr < ptr1)
  1053.             *ptr2++ = *srcPtr++;
  1054.         *ptr2 = 0;
  1055.     }
  1057.     //
  1058.     //  If we found a fragment, then it is the rest of the string and we
  1059.     //  are done.
  1060.     //
  1061.     if (*srcPtr == chPound)
  1062.     {
  1063.         srcPtr++;
  1064.         delete [] fFragment;
  1065.         fFragment = XMLString::replicate(srcPtr);
  1066.         return;
  1067.     }
  1069.     //
  1070.     //  The query is either the rest of the string, or up to the fragment
  1071.     //  separator.
  1072.     //
  1073.     srcPtr++;
  1074.     ptr1 = XMLString::findAny(srcPtr, listSix);
  1075.     delete [] fQuery;
  1076.     if (!ptr1)
  1077.     {
  1078.         fQuery = XMLString::replicate(srcPtr);
  1079.         return;
  1080.     }
  1081.      else
  1082.     {
  1083.         fQuery = new XMLCh[(ptr1 - srcPtr) + 1];
  1084.         ptr2 = fQuery;
  1085.         while (srcPtr < ptr1)
  1086.             *ptr2++ = *srcPtr++;
  1087.         *ptr2 = 0;
  1088.     }
  1090.     // If we are not at the end now, then everything else is the fragment
  1091.     if (*srcPtr == chPound)
  1092.     {
  1093.         srcPtr++;
  1094.         delete [] fFragment;
  1095.         fFragment = XMLString::replicate(srcPtr);
  1096.     }
  1097. }
  1100. void XMLURL::weavePaths(const XMLCh* const basePart)
  1101. {
  1102.     // Watch for stupid stuff
  1103.     if (!basePart)
  1104.         return;
  1105.     if (!*basePart)
  1106.         return;
  1108.     //
  1109.     //  Ok, lets start at the end of the base path and work backwards and
  1110.     //  our path part and work forwards. For each leading . we see, we just
  1111.     //  eat it. For each leading .. we see, we eat it and throw away one
  1112.     //  level in the source URL.
  1113.     //
  1114.     //  If the last character in the base part is a forward slash, back
  1115.     //  up one first before we look for the last slash.
  1116.     //
  1117.     const XMLCh* basePtr = basePart + (XMLString::stringLen(basePart) - 1);
  1118.     if (*basePtr == chForwardSlash)
  1119.         basePtr--;
  1121.     while ((basePtr >= basePart)
  1122.     &&     ((*basePtr != chForwardSlash) && (*basePtr != chBackSlash)))
  1123.     {
  1124.         basePtr--;
  1125.     }
  1127.     if (basePtr < basePart)
  1128.         return;
  1130.     // Create a buffer as large as both parts
  1131.     XMLCh* tmpBuf = new XMLCh[XMLString::stringLen(fPath)
  1132.                               + XMLString::stringLen(basePart)
  1133.                               + 2];
  1134.     //
  1135.     //  If we have no path part, then copy the base part up to the
  1136.     //  base pointer
  1137.     //
  1138.     if (!fPath)
  1139.     {
  1140.         XMLCh* bufPtr = tmpBuf;
  1141.         const XMLCh* tmpPtr = basePart;
  1142.         while (tmpPtr <= basePtr)
  1143.             *bufPtr++ = *tmpPtr++;
  1144.         *bufPtr = 0;
  1146.         fPath = tmpBuf;
  1147.         return;
  1148.     }
  1150.     // After this, make sure the buffer gets handled if we exit early
  1151.     ArrayJanitor<XMLCh> janBuf(tmpBuf);
  1153.     //
  1154.     //  We have some path part, so we need to check to see if we ahve to
  1155.     //  weave any of the parts together.
  1156.     //
  1157.     XMLCh* pathPtr = fPath;
  1158.     while (true)
  1159.     {
  1160.         // If it does not start with some period, then we are done
  1161.         if (*pathPtr != chPeriod)
  1162.             break;
  1164.         unsigned int periodCount = 1;
  1165.         pathPtr++;
  1166.         if (*pathPtr == chPeriod)
  1167.         {
  1168.             pathPtr++;
  1169.             periodCount++;
  1170.         }
  1172.         // Has to be followed by a / or  or the null to mean anything
  1173.         if ((*pathPtr != chForwardSlash) && (*pathPtr != chBackSlash)
  1174.         &&  *pathPtr)
  1175.         {
  1176.             break;
  1177.         }
  1178.         if (*pathPtr)
  1179.             pathPtr++;
  1181.         // If its one period, just eat it, else move backwards in the base
  1182.         if (periodCount == 2)
  1183.         {
  1184.             basePtr--;
  1185.             while ((basePtr >= basePart)
  1186.             &&     ((*basePtr != chForwardSlash) && (*basePtr != chBackSlash)))
  1187.             {
  1188.                 basePtr--;
  1189.             }
  1191.             // There are not enough levels to handle all the .. parts
  1192.             if (basePtr < basePart)
  1193.                 ThrowXML(MalformedURLException, XMLExcepts::URL_BaseUnderflow);
  1194.         }
  1195.     }
  1197.     // Copy the base part up to the base pointer
  1198.     XMLCh* bufPtr = tmpBuf;
  1199.     const XMLCh* tmpPtr = basePart;
  1200.     while (tmpPtr <= basePtr)
  1201.         *bufPtr++ = *tmpPtr++;
  1203.     // And then copy on the rest of our path
  1204.     XMLString::copyString(bufPtr, pathPtr);
  1206.     // Now delete our path and make the new buffer our path
  1207.     delete [] fPath;
  1208.     janBuf.orphan();
  1209.     fPath = tmpBuf;
  1210. }