XMLUri.hpp Source File

00001 /*
00002  * Copyright 2001-2004 The Apache Software Foundation.
00003  * 
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  * 
00008  *      http://www.apache.org/licenses/LICENSE-2.0
00009  * 
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 
00017 /*
00018  * $Id: XMLUri.hpp,v 1.18 2004/09/08 13:56:25 peiyongz Exp $
00019  * $Log: XMLUri.hpp,v $
00020  * Revision 1.18  2004/09/08 13:56:25  peiyongz
00021  * Apache License Version 2.0
00022  *
00023  * Revision 1.17  2004/05/25 18:11:47  peiyongz
00024  * normalizeURI() added
00025  *
00026  * Revision 1.16  2004/01/12 22:01:02  cargilld
00027  * Minor performance change for handling reserved and unreserved characters.
00028  *
00029  * Revision 1.15  2003/12/17 00:18:35  cargilld
00030  * Update to memory management so that the static memory manager (one used to call Initialize) is only for static data.
00031  *
00032  * Revision 1.14  2003/12/11 22:21:25  neilg
00033  * fixes for the URI implementation to take registry names into account; much thanks to Michael Glavassevich
00034  *
00035  * Revision 1.13  2003/12/02 17:50:21  neilg
00036  * additional fix for bug 25118; once again, thanks to Jeroen Whitmond
00037  *
00038  * Revision 1.12  2003/10/01 00:20:41  knoaman
00039  * Add a static method to check whether a given string is a valid URI.
00040  *
00041  * Revision 1.11  2003/09/25 22:23:25  peiyongz
00042  * Implementation of Serialization/Deserialization
00043  *
00044  * Revision 1.10  2003/07/25 10:15:16  gareth
00045  * Patch by Michael Glavassevich
00046  *
00047  * The patch fixes Bugzilla #19787, #20006, #20009, #20010 and #20287, and
00048  * several other issues. A summary of the changes is listed below:
00049  *
00050  * 1. Added '[' and ']' to reserved characters as per RFC 2732.
00051  * 2. '[' and ']' added in RFC 2732, are not allowed in path segments, but
00052  * may appear in the opaque part.
00053  * 3. No URI can begin with a ':'.
00054  * 4. URI has no scheme if ':' occurs in a URI after '?' or '#', it's part of
00055  * the query string or fragment.
00056  * 5. Whitespace (even escaped as %20) is not permitted in the authority
00057  * portion of a URI.
00058  * 6. IPv4 addresses must match 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT "."
00059  * 1*3DIGIT. Since RFC 2732.
00060  * 7. IPv4 addresses are 32-bit, therefore no segment may be larger than 255.
00061  * This isn't expressed by the grammar.
00062  * 8. Hostnames cannot end with a '-'.
00063  * 9. Labels in a hostname must be 63 bytes or less [RFC 1034].
00064  * 10. Hostnames may be no longer than 255 bytes [RFC 1034]. (That
00065  * restriction was already there. I just moved it inwards.
00066  * 11. Added support for IPv6 references added in RFC 2732. URIs such as
00067  * http://[::ffff:1.2.3.4] are valid. The BNF in RFC 2373 isn't correct. IPv6
00068  * addresses are read according to section 2.2 of RFC 2373.
00069  *
00070  * Revision 1.9  2003/05/16 06:01:53  knoaman
00071  * Partial implementation of the configurable memory manager.
00072  *
00073  * Revision 1.8  2003/05/15 19:07:46  knoaman
00074  * Partial implementation of the configurable memory manager.
00075  *
00076  * Revision 1.7  2003/01/06 19:43:18  tng
00077  * New feature StandardUriConformant to force strict standard uri conformance.
00078  *
00079  * Revision 1.6  2002/11/21 15:42:39  gareth
00080  * Implemented copy constructor and operator =. Patch by Jennifer Schachter.
00081  *
00082  * Revision 1.5  2002/11/04 15:22:05  tng
00083  * C++ Namespace Support.
00084  *
00085  * Revision 1.4  2002/09/23 18:41:00  tng
00086  * DOM L3: Support baseURI.   Add fURIText to XMLUri.   Added by Gareth Reakes and Thomas Ford.
00087  *
00088  * Revision 1.3  2002/08/23 20:45:24  tng
00089  * .Memory leak fix: XMLUri data not deleted if constructor failed.
00090  *
00091  * Revision 1.2  2002/02/20 18:17:02  tng
00092  * [Bug 5977] Warnings on generating apiDocs.
00093  *
00094  * Revision 1.1.1.1  2002/02/01 22:22:17  peiyongz
00095  * sane_include
00096  *
00097  * Revision 1.3  2001/08/29 19:03:03  peiyongz
00098  * Bugzilla# 2816:on AIX 4.2, xlC 3 r ev.1, Compilation error on inline method
00099  *
00100  * Revision 1.2  2001/08/16 14:09:44  peiyongz
00101  * Removed unused ctors and methods
00102  *
00103  * Revision 1.1  2001/08/10 16:23:41  peiyongz
00104  * XMLUri: creation
00105  *
00106  *
00107  */
00108 
00109 #if !defined(XMLURI_HPP)
00110 #define XMLURI_HPP
00111 
00112 #include <xercesc/util/XMemory.hpp>
00113 #include <xercesc/util/XMLString.hpp>
00114 
00115 #include <xercesc/internal/XSerializable.hpp>
00116 #include <xercesc/framework/XMLBuffer.hpp>
00117 
00118 XERCES_CPP_NAMESPACE_BEGIN
00119 
00120 /*
00121  * This class is a direct port of Java's URI class, to distinguish
00122  * itself from the XMLURL, we use the name XMLUri instead of
00123  * XMLURI.
00124  *
00125  * TODO: how to relate XMLUri and XMLURL since URL is part of URI.
00126  *
00127  */
00128 
00129 class  XMLUri : public XSerializable, public XMemory
00130 {
00131 public:
00132 
00133     // -----------------------------------------------------------------------
00134     //  Constructors and Destructor
00135     // -----------------------------------------------------------------------
00136 
00165     XMLUri(const XMLCh* const    uriSpec,
00166            MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
00167 
00184     XMLUri(const XMLUri* const  baseURI
00185          , const XMLCh* const   uriSpec
00186          , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
00187 
00191     XMLUri(const XMLUri& toCopy);
00192     XMLUri& operator=(const XMLUri& toAssign);
00193 
00194     virtual ~XMLUri();
00195 
00196     // -----------------------------------------------------------------------
00197     //  Getter methods
00198     // -----------------------------------------------------------------------
00204     const XMLCh* getUriText() const;
00205 
00211      const XMLCh* getScheme() const;
00212 
00218      const XMLCh* getUserInfo() const;
00219 
00220 
00226      const XMLCh* getHost() const;
00227 
00233      int getPort() const;
00234      
00240      const XMLCh* getRegBasedAuthority() const;
00241 
00248      const XMLCh* getPath() const;
00249 
00257      const XMLCh* getQueryString() const;
00258 
00266      const XMLCh* getFragment() const;
00267 
00268     // -----------------------------------------------------------------------
00269     //  Setter methods
00270     // -----------------------------------------------------------------------
00271 
00279      void setScheme(const XMLCh* const newScheme);
00280 
00288      void setUserInfo(const XMLCh* const newUserInfo);
00289 
00300      void setHost(const XMLCh* const newHost);
00301 
00311      void setPort(int newPort);
00312      
00321      void setRegBasedAuthority(const XMLCh* const newRegAuth);
00322 
00343      void setPath(const XMLCh* const newPath);
00344 
00353      void setQueryString(const XMLCh* const newQueryString);
00354 
00363      void setFragment(const XMLCh* const newFragment);
00364 
00365      // -----------------------------------------------------------------------
00366     //  Miscellaneous methods
00367     // -----------------------------------------------------------------------
00368 
00376     static bool isURIString(const XMLCh* const uric);
00377 
00381     static bool isValidURI( const XMLUri* const baseURI
00382                           , const XMLCh* const uriStr);
00386     static bool isValidURI( bool haveBaseURI
00387                           , const XMLCh* const uriStr);
00388 
00389 
00390     static void normalizeURI(const XMLCh*     const systemURI,
00391                                    XMLBuffer&       normalizedURI);
00392 
00393     /***
00394      * Support for Serialization/De-serialization
00395      ***/
00396     DECL_XSERIALIZABLE(XMLUri)
00397 
00398     XMLUri(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
00399 
00400 private:
00401 
00402     static const XMLCh MARK_OR_RESERVED_CHARACTERS[];
00403     static const XMLCh RESERVED_CHARACTERS[];
00404     static const XMLCh MARK_CHARACTERS[];
00405     static const XMLCh SCHEME_CHARACTERS[];
00406     static const XMLCh USERINFO_CHARACTERS[];
00407     static const XMLCh REG_NAME_CHARACTERS[];
00408     static const XMLCh PATH_CHARACTERS[];
00409 
00410     //helper method for getUriText
00411     void buildFullText();
00412 
00413     // -----------------------------------------------------------------------
00414     //  Private helper methods
00415     // -----------------------------------------------------------------------
00416 
00422     static bool isReservedCharacter(const XMLCh theChar);
00423     
00429     static bool isPathCharacter(const XMLCh theChar);
00430 
00436     static bool isUnreservedCharacter(const XMLCh theChar);
00437 
00443     static bool isReservedOrUnreservedCharacter(const XMLCh theChar);
00444 
00452     static bool isConformantSchemeName(const XMLCh* const scheme);
00453 
00459     static void isConformantUserInfo(const XMLCh* const userInfo
00460         , MemoryManager* const manager);
00461     
00469     static bool isValidServerBasedAuthority(const XMLCh* const host
00470                                            , const int hostLen
00471                                            , const int port
00472                                            , const XMLCh* const userinfo
00473                                            , const int userLen);
00474                                            
00482     static bool isValidServerBasedAuthority(const XMLCh* const host
00483                                            , const int port
00484                                            , const XMLCh* const userinfo
00485                                            , MemoryManager* const manager);
00486       
00494     static bool isValidRegistryBasedAuthority(const XMLCh* const authority
00495                                              , const int authLen);
00496 
00504     static bool isValidRegistryBasedAuthority(const XMLCh* const authority);
00505 
00523      static bool isWellFormedAddress(const XMLCh* const addr
00524          , MemoryManager* const manager);
00525      
00535      static bool isWellFormedIPv4Address(const XMLCh* const addr, const int length);
00536      
00550      static bool isWellFormedIPv6Reference(const XMLCh* const addr, const int length);
00551      
00567      static int scanHexSequence (const XMLCh* const addr, int index, int end, int& counter);
00568 
00576      bool isGenericURI();
00577 
00578     // -----------------------------------------------------------------------
00579     //  Miscellaneous methods
00580     // -----------------------------------------------------------------------
00581 
00587      void initialize(const XMLUri& toCopy);
00588 
00603      void initialize(const XMLUri* const baseURI
00604                    , const XMLCh*  const uriSpec);
00605 
00612      void initializeScheme(const XMLCh* const uriSpec);
00613 
00621      void initializeAuthority(const XMLCh* const uriSpec);
00622 
00629      void initializePath(const XMLCh* const uriSpec);
00630 
00635      void cleanUp();
00636 
00637     static bool isConformantSchemeName(const XMLCh* const scheme,
00638                                        const int schemeLen);
00639     static bool processScheme(const XMLCh* const uriStr, int& index);
00640     static bool processAuthority(const XMLCh* const uriStr, const int authLen);
00641     static bool isWellFormedAddress(const XMLCh* const addr, const int addrLen);
00642     static bool processPath(const XMLCh* const pathStr, const int pathStrLen,
00643                             const bool isSchemePresent);
00644 
00645     // -----------------------------------------------------------------------
00646     //  Data members
00647     //
00648     //  for all the data member, we own it,
00649     //  responsible for the creation and/or deletion for
00650     //  the memory allocated.
00651     //
00652     // -----------------------------------------------------------------------
00653     XMLCh*          fScheme;
00654     XMLCh*          fUserInfo;
00655     XMLCh*          fHost;
00656     int             fPort;
00657     XMLCh*          fRegAuth;
00658     XMLCh*          fPath;
00659     XMLCh*          fQueryString;
00660     XMLCh*          fFragment;
00661     XMLCh*          fURIText;
00662     MemoryManager*  fMemoryManager;
00663 };
00664 
00665 // ---------------------------------------------------------------------------
00666 //  XMLUri: Getter methods
00667 // ---------------------------------------------------------------------------
00668 inline const XMLCh* XMLUri::getScheme() const
00669 {
00670     return fScheme;
00671 }
00672 
00673 inline const XMLCh* XMLUri::getUserInfo() const
00674 {
00675     return fUserInfo;
00676 }
00677 
00678 inline const XMLCh* XMLUri::getHost() const
00679 {
00680     return fHost;
00681 }
00682 
00683 inline int XMLUri::getPort() const
00684 {
00685     return fPort;
00686 }
00687 
00688 inline const XMLCh* XMLUri::getRegBasedAuthority() const
00689 {
00690     return fRegAuth;
00691 }
00692 
00693 inline const XMLCh* XMLUri::getPath() const
00694 {
00695     return fPath;
00696 }
00697 
00698 inline const XMLCh* XMLUri::getQueryString() const
00699 {
00700     return fQueryString;
00701 }
00702 
00703 inline const XMLCh* XMLUri::getFragment() const
00704 {
00705     return fFragment;
00706 }
00707 
00708 inline const XMLCh* XMLUri::getUriText() const
00709 {
00710     //
00711     //  Fault it in if not already. Since this is a const method and we
00712     //  can't use mutable members due the compilers we have to support,
00713     //  we have to cast off the constness.
00714     //
00715     if (!fURIText)
00716         ((XMLUri*)this)->buildFullText();
00717 
00718     return fURIText;
00719 }
00720 
00721 // ---------------------------------------------------------------------------
00722 //  XMLUri: Helper methods
00723 // ---------------------------------------------------------------------------
00724 inline bool XMLUri::isReservedOrUnreservedCharacter(const XMLCh theChar)
00725 {
00726    return (XMLString::isAlphaNum(theChar) ||
00727            XMLString::indexOf(MARK_OR_RESERVED_CHARACTERS, theChar) != -1);
00728 }
00729 
00730 inline bool XMLUri::isReservedCharacter(const XMLCh theChar)
00731 {
00732     return (XMLString::indexOf(RESERVED_CHARACTERS, theChar) != -1);
00733 }
00734 
00735 inline bool XMLUri::isPathCharacter(const XMLCh theChar)
00736 {
00737     return (XMLString::indexOf(PATH_CHARACTERS, theChar) != -1);
00738 }
00739 
00740 inline bool XMLUri::isUnreservedCharacter(const XMLCh theChar)
00741 {
00742     return (XMLString::isAlphaNum(theChar) ||
00743             XMLString::indexOf(MARK_CHARACTERS, theChar) != -1);
00744 }
00745 
00746 XERCES_CPP_NAMESPACE_END
00747 
00748 #endif