/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* $Id$
*/
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
#include <xercesc/util/Janitor.hpp>
#include <xercesc/util/XMLURL.hpp>
#include <xercesc/util/XMLUri.hpp>
#include <xercesc/util/XMLChar.hpp>
#include <xercesc/util/OutOfMemoryException.hpp>
XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// XMLUri: static data
// ---------------------------------------------------------------------------
// Amended by RFC2732
// reserved = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
// "$" | "," | "[" | "]"
//
const XMLCh XMLUri::RESERVED_CHARACTERS[] =
{
chSemiColon, chForwardSlash, chQuestion, chColon, chAt,
chAmpersand, chEqual, chPlus, chDollarSign, chComma, chOpenSquare,
chCloseSquare, chNull
};
//
// mark = "-" | "_" | "." | "!" | "~" | "*" | "'" |
// "(" | ")"
//
const XMLCh XMLUri::MARK_CHARACTERS[] =
{
chDash, chUnderscore, chPeriod, chBang, chTilde,
chAsterisk, chSingleQuote, chOpenParen, chCloseParen, chNull
};
// combination of MARK and RESERVED
const XMLCh XMLUri::MARK_OR_RESERVED_CHARACTERS[] =
{
chDash, chUnderscore, chPeriod, chBang, chTilde,
chAsterisk, chSingleQuote, chOpenParen, chCloseParen,
chSemiColon, chForwardSlash, chQuestion, chColon, chAt,
chAmpersand, chEqual, chPlus, chDollarSign, chComma, chOpenSquare,
chCloseSquare, chNull
};
//
// scheme = alpha *( alpha | digit | "+" | "-" | "." )
//
const XMLCh XMLUri::SCHEME_CHARACTERS[] =
{
chPlus, chDash, chPeriod, chNull
};
//
// userinfo = *( unreserved | escaped |
// ";" | ":" | "&" | "=" | "+" | "$" | "," )
//
const XMLCh XMLUri::USERINFO_CHARACTERS[] =
{
chSemiColon, chColon, chAmpersand, chEqual, chPlus,
chDollarSign, chPeriod, chNull
};
//
// reg_name = 1*( unreserved | escaped | "$" | "," |
// ";" | ":" | "@" | "&" | "=" | "+" )
//
const XMLCh XMLUri::REG_NAME_CHARACTERS[] =
{
chDollarSign, chComma, chSemiColon, chColon, chAt,
chAmpersand, chEqual, chPlus, chNull
};
// pchar plus ';' and '/'.
// pchar = unreserved | escaped |
// ":" | "@" | "&" | "=" | "+" | "$" | ","
const XMLCh XMLUri::PATH_CHARACTERS[] =
{
chSemiColon, chForwardSlash, chColon, chAt, chAmpersand,
chEqual, chPlus, chDollarSign, chComma, chNull
};
// ---------------------------------------------------------------------------
// Local methods and data
// ---------------------------------------------------------------------------
static const int BUF_LEN = 64;
//
// "Scheme"
// "SchemeSpecificPart"
// "Parameters"
// "UserInfo"
// "Host"
// "Port"
// "RegName"
// "Path"
// "Query"
// "Fragment"
//
static const XMLCh errMsg_SCHEME[] =
{
chLatin_s, chLatin_c, chLatin_h, chLatin_e,
chLatin_m, chLatin_e, chNull
};
static const XMLCh errMsg_SCHEMESPART[] =
{
chLatin_s, chLatin_c, chLatin_h, chLatin_e, chLatin_m, chLatin_e,
chLatin_S, chLatin_p, chLatin_e, chLatin_c, chLatin_i, chLatin_f,
chLatin_i, chLatin_c, chLatin_P, chLatin_a, chLatin_r, chLatin_t,
chNull
};
static const XMLCh errMsg_PARAMS[] =
{
chLatin_p, chLatin_a, chLatin_r, chLatin_a, chLatin_m,
chLatin_e, chLatin_t, chLatin_e, chLatin_r, chLatin_s, chNull
};
static const XMLCh errMsg_USERINFO[] =
{
chLatin_u, chLatin_s, chLatin_e, chLatin_r,
chLatin_i, chLatin_n, chLatin_f, chLatin_o, chNull
};
static const XMLCh errMsg_HOST[] =
{
chLatin_h, chLatin_o, chLatin_s, chLatin_t, chNull
};
static const XMLCh errMsg_PORT[] =
{
chLatin_p, chLatin_o, chLatin_r, chLatin_t, chNull
};
static const XMLCh errMsg_REGNAME[] =
{
chLatin_R, chLatin_e, chLatin_g,
chLatin_N, chLatin_a, chLatin_m, chLatin_e, chNull
};
static const XMLCh errMsg_PATH[] =
{
chLatin_p, chLatin_a, chLatin_t, chLatin_h, chNull
};
static const XMLCh errMsg_QUERY[] =
{
chLatin_q, chLatin_u, chLatin_e, chLatin_r, chLatin_y, chNull
};
static const XMLCh errMsg_FRAGMENT[] =
{
chLatin_f, chLatin_r, chLatin_a, chLatin_g,
chLatin_m, chLatin_e, chLatin_n, chLatin_t, chNull
};
//
// "//"
// "/"
// "./"
// "/."
// "/../"
// "/.."
//
static const XMLCh DOUBLE_SLASH[] =
{
chForwardSlash, chForwardSlash, chNull
};
static const XMLCh SINGLE_SLASH[] =
{
chForwardSlash, chNull
};
static const XMLCh SLASH_DOT_SLASH[] =
{
chForwardSlash, chPeriod, chForwardSlash, chNull
};
static const XMLCh SLASH_DOT[] =
{
chForwardSlash, chPeriod, chNull
};
static const XMLCh SLASH_DOTDOT_SLASH[] =
{
chForwardSlash, chPeriod, chPeriod, chForwardSlash, chNull
};
static const XMLCh SLASH_DOTDOT[] =
{
chForwardSlash, chPeriod, chPeriod, chNull
};
//
// ":/?#"
//
// REVISIT: why?
static const XMLCh SCHEME_SEPARATORS[] =
{
chColon, chForwardSlash, chQuestion, chPound, chNull
};
//
// "?#"
//
static const XMLCh PATH_SEPARATORS[] =
{
chQuestion, chPound, chNull
};
// ---------------------------------------------------------------------------
// XMLUri: Constructors and Helper methods
// ---------------------------------------------------------------------------
// ctor# 2
typedef JanitorMemFunCall<XMLUri> CleanupType;
XMLUri::XMLUri(const XMLCh* const uriSpec,
MemoryManager* const manager)
: fPort(-1)
, fScheme(0)
, fUserInfo(0)
, fHost(0)
, fRegAuth(0)
, fPath(0)
, fQueryString(0)
, fFragment(0)
, fURIText(0)
, fMemoryManager(manager)
{
CleanupType cleanup(this, &XMLUri::cleanUp);
try {
initialize((XMLUri *)0, uriSpec);
}
catch(const OutOfMemoryException&)
{
cleanup.release();
throw;
}
cleanup.release();
}
// ctor# 7 relative ctor
XMLUri::XMLUri(const XMLUri* const baseURI
, const XMLCh* const uriSpec
, MemoryManager* const manager)
: fPort(-1)
, fScheme(0)
, fUserInfo(0)
, fHost(0)
, fRegAuth(0)
, fPath(0)
, fQueryString(0)
, fFragment(0)
, fURIText(0)
, fMemoryManager(manager)
{
CleanupType cleanup(this, &XMLUri::cleanUp);
try {
initialize(baseURI, uriSpec);
}
catch(const OutOfMemoryException&)
{
cleanup.release();
throw;
}
cleanup.release();
}
//Copy constructor
XMLUri::XMLUri(const XMLUri& toCopy)
: XSerializable(toCopy)
, XMemory(toCopy)
, fPort(-1)
, fScheme(0)
, fUserInfo(0)
, fHost(0)
, fRegAuth(0)
, fPath(0)
, fQueryString(0)
, fFragment(0)
, fURIText(0)
, fMemoryManager(toCopy.fMemoryManager)
{
CleanupType cleanup(this, &XMLUri::cleanUp);
try {
initialize(toCopy);
}
catch(const OutOfMemoryException&)
{
cleanup.release();
throw;
}
cleanup.release();
}
XMLUri& XMLUri::operator=(const XMLUri& toAssign)
{
cleanUp();
CleanupType cleanup(this, &XMLUri::cleanUp);
try {
initialize(toAssign);
}
catch(const OutOfMemoryException&)
{
cleanup.release();
throw;
}
cleanup.release();
return *this;
}
XMLUri::~XMLUri()
{
cleanUp();
}
void XMLUri::cleanUp()
{
if (fScheme)
XMLString::release(&fScheme, fMemoryManager);//delete[] fScheme;
if (fUserInfo)
XMLString::release(&fUserInfo, fMemoryManager);//delete[] fUserInfo;
if (fHost)
XMLString::release(&fHost, fMemoryManager);//delete[] fHost;
if (fRegAuth)
XMLString::release(&fRegAuth, fMemoryManager);//delete[] fRegAuth;
if (fPath)
XMLString::release(&fPath, fMemoryManager);//delete[] fPath;
if (fQueryString)
XMLString::release(&fQueryString, fMemoryManager);//delete[] fQueryString;
if (fFragment)
XMLString::release(&fFragment, fMemoryManager);//delete[] fFragment;
XMLString::release(&fURIText, fMemoryManager);//delete[] fURIText;
}
void XMLUri::initialize(const XMLUri& toCopy)
{
//
// assuming that all fields from the toCopy are valid,
// therefore need NOT to go through various setXXX() methods
//
fMemoryManager = toCopy.fMemoryManager;
fScheme = XMLString::replicate(toCopy.fScheme, fMemoryManager);
fUserInfo = XMLString::replicate(toCopy.fUserInfo, fMemoryManager);
fHost = XMLString::replicate(toCopy.fHost, fMemoryManager);
fPort = toCopy.fPort;
fRegAuth = XMLString::replicate(toCopy.fRegAuth, fMemoryManager);
fPath = XMLString::replicate(toCopy.fPath, fMemoryManager);
fQueryString = XMLString::replicate(toCopy.fQueryString, fMemoryManager);
fFragment = XMLString::replicate(toCopy.fFragment, fMemoryManager);
}
void XMLUri::initialize(const XMLUri* const baseURI
, const XMLCh* const uriSpec)
{
// get a trimmed version of uriSpec
// uriSpec will NO LONGER be used in this function.
//
XMLCh* trimmedUriSpec = XMLString::replicate(uriSpec, fMemoryManager);
XMLString::trim(trimmedUriSpec);
ArrayJanitor<XMLCh> janName(trimmedUriSpec, fMemoryManager);
XMLSize_t trimmedUriSpecLen = XMLString::stringLen(trimmedUriSpec);
if ( !baseURI &&
(!trimmedUriSpec || trimmedUriSpecLen == 0))
{
ThrowXMLwithMemMgr1(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Empty
, errMsg_PARAMS
, fMemoryManager);
}
// just make a copy of the base if spec is empty
if (!trimmedUriSpec || trimmedUriSpecLen == 0)
{
initialize(*baseURI);
return;
}
XMLSize_t index = 0;
bool foundScheme = false;
// Check for scheme, which must be before `/', '?' or '#'.
int colonIdx = XMLString::indexOf(trimmedUriSpec, chColon);
int slashIdx = XMLString::indexOf(trimmedUriSpec, chForwardSlash);
int queryIdx = XMLString::indexOf(trimmedUriSpec, chQuestion);
int fragmentIdx = XMLString::indexOf(trimmedUriSpec, chPound);
if ((colonIdx <= 0) ||
(colonIdx > slashIdx && slashIdx != -1) ||
(colonIdx > queryIdx && queryIdx != -1) ||
(colonIdx > fragmentIdx && fragmentIdx != -1))
{
// A standalone base is a valid URI according to spec
if ( colonIdx == 0 || (!baseURI && fragmentIdx != 0) )
{
ThrowXMLwithMemMgr(MalformedURLException, XMLExcepts::XMLNUM_URI_No_Scheme, fMemoryManager);
}
}
else
{
foundScheme = true;
initializeScheme(trimmedUriSpec);
index = XMLString::stringLen(fScheme)+1;
}
// It's an error if we stop here
if (index == trimmedUriSpecLen || (foundScheme && (trimmedUriSpec[index] == chPound)))
{
ThrowXMLwithMemMgr1(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Empty
, errMsg_PATH
, fMemoryManager);
}
// two slashes means generic URI syntax, so we get the authority
XMLCh* authUriSpec = (XMLCh*) fMemoryManager->allocate
(
(trimmedUriSpecLen+1) * sizeof(XMLCh)
);//new XMLCh[trimmedUriSpecLen+1];
ArrayJanitor<XMLCh> authName(authUriSpec, fMemoryManager);
XMLString::subString(authUriSpec, trimmedUriSpec, index, trimmedUriSpecLen, fMemoryManager);
if (((index+1) < trimmedUriSpecLen) &&
XMLString::startsWith(authUriSpec, DOUBLE_SLASH))
{
index += 2;
XMLSize_t startPos = index;
// get authority - everything up to path, query or fragment
XMLCh testChar;
while (index < trimmedUriSpecLen)
{
testChar = trimmedUriSpec[index];
if (testChar == chForwardSlash ||
testChar == chQuestion ||
testChar == chPound )
{
break;
}
index++;
}
// if we found authority, parse it out, otherwise we set the
// host to empty string
if (index > startPos)
{
XMLString::subString(authUriSpec, trimmedUriSpec, startPos, index, fMemoryManager);
initializeAuthority(authUriSpec);
}
else
{
//fHost = 0;
setHost(XMLUni::fgZeroLenString);
}
}
// we need to check if index has exceed the lenght or not
if (index >= trimmedUriSpecLen)
return;
XMLCh* pathUriSpec = (XMLCh*) fMemoryManager->allocate
(
(trimmedUriSpecLen+1) * sizeof(XMLCh)
);//new XMLCh[trimmedUriSpecLen+1];
ArrayJanitor<XMLCh> pathUriSpecName(pathUriSpec, fMemoryManager);
XMLString::subString(pathUriSpec, trimmedUriSpec, index, trimmedUriSpecLen, fMemoryManager);
initializePath(pathUriSpec);
// Resolve relative URI to base URI - see RFC 2396 Section 5.2
// In some cases, it might make more sense to throw an exception
// (when scheme is specified is the string spec and the base URI
// is also specified, for example), but we're just following the
// RFC specifications
if ( baseURI )
{
// check to see if this is the current doc - RFC 2396 5.2 #2
// note that this is slightly different from the RFC spec in that
// we don't include the check for query string being null
// - this handles cases where the urispec is just a query
// string or a fragment (e.g. "?y" or "#s") -
// see <http://www.ics.uci.edu/~fielding/url/test1.html> which
// identified this as a bug in the RFC
if ((!fPath || !*fPath) &&
fScheme == 0 &&
fHost == 0 && fRegAuth == 0)
{
fScheme = XMLString::replicate(baseURI->getScheme(), fMemoryManager);
fMemoryManager->deallocate(fUserInfo);//delete [] fUserInfo;
fUserInfo = XMLString::replicate(baseURI->getUserInfo(), fMemoryManager);
fHost = XMLString::replicate(baseURI->getHost(), fMemoryManager);
fPort = baseURI->getPort();
fRegAuth = XMLString::replicate(baseURI->getRegBasedAuthority(), fMemoryManager);
fMemoryManager->deallocate(fPath);//delete [] fPath;
fPath = XMLString::replicate(baseURI->getPath(), fMemoryManager);
if ( !fQueryString )
{
fQueryString = XMLString::replicate(baseURI->getQueryString(), fMemoryManager);
}
return;
}
// check for scheme - RFC 2396 5.2 #3
// if we found a scheme, it means absolute URI, so we're done
if (fScheme == 0)
{
fScheme = XMLString::replicate(baseURI->getScheme(), fMemoryManager);
}
else
{
return;
}
// check for authority - RFC 2396 5.2 #4
// if we found a host, then we've got a network path, so we're done
if (fHost == 0 && fRegAuth == 0)
{
fMemoryManager->deallocate(fUserInfo);//delete [] fUserInfo;
fUserInfo = XMLString::replicate(baseURI->getUserInfo(), fMemoryManager);
fHost = XMLString::replicate(baseURI->getHost(), fMemoryManager);
fPort = baseURI->getPort();
fRegAuth = XMLString::replicate(baseURI->getRegBasedAuthority(), fMemoryManager);
}
else
{
return;
}
// check for absolute path - RFC 2396 5.2 #5
if ((fPath && *fPath) &&
XMLString::startsWith(fPath, SINGLE_SLASH))
{
return;
}
// if we get to this point, we need to resolve relative path
// RFC 2396 5.2 #6
XMLCh* basePath = XMLString::replicate(baseURI->getPath(), fMemoryManager);
ArrayJanitor<XMLCh> basePathName(basePath, fMemoryManager);
XMLSize_t bufLen = trimmedUriSpecLen+XMLString::stringLen(fPath)+XMLString::stringLen(basePath)+1;
XMLCh* path = (XMLCh*) fMemoryManager->allocate(bufLen * sizeof(XMLCh));//new XMLCh[bufLen];
ArrayJanitor<XMLCh> pathName(path, fMemoryManager);
path[0] = 0;
XMLCh* tmp1 = (XMLCh*) fMemoryManager->allocate(bufLen * sizeof(XMLCh));//new XMLCh[bufLen];
ArrayJanitor<XMLCh> tmp1Name(tmp1, fMemoryManager);
XMLCh* tmp2 = (XMLCh*) fMemoryManager->allocate(bufLen * sizeof(XMLCh));//new XMLCh[bufLen];
ArrayJanitor<XMLCh> tmp2Name(tmp2, fMemoryManager);
// 6a - get all but the last segment of the base URI path
if (basePath)
{
int lastSlash = XMLString::lastIndexOf(basePath, chForwardSlash);
if (lastSlash != -1)
{
XMLString::subString(path, basePath, 0, lastSlash+1, fMemoryManager);
}
}
// 6b - append the relative URI path
XMLString::catString(path, fPath);
// 6c - remove all "./" where "." is a complete path segment
int iIndex = -1;
while ((iIndex = XMLString::patternMatch(path, SLASH_DOT_SLASH)) != -1)
{
XMLString::subString(tmp1, path, 0, iIndex, fMemoryManager);
XMLString::subString(tmp2, path, iIndex+2, XMLString::stringLen(path), fMemoryManager);
path[0] = 0;
XMLString::catString(path, tmp1);
XMLString::catString(path, tmp2);
}
// 6d - remove "." if path ends with "." as a complete path segment
if (XMLString::endsWith(path, SLASH_DOT))
{
path[XMLString::stringLen(path) - 1] = chNull;
}
// 6e - remove all "<segment>/../" where "<segment>" is a complete
// path segment not equal to ".."
iIndex = -1;
int segIndex = -1;
int offset = 1;
while ((iIndex = XMLString::patternMatch(&(path[offset]), SLASH_DOTDOT_SLASH)) != -1)
{
// Undo offset
iIndex += offset;
// Find start of <segment> within substring ending at found point.
XMLString::subString(tmp1, path, 0, iIndex-1, fMemoryManager);
segIndex = XMLString::lastIndexOf(tmp1, chForwardSlash);
// Ensure <segment> exists and != ".."
if (segIndex != -1 &&
(path[segIndex+1] != chPeriod ||
path[segIndex+2] != chPeriod ||
segIndex + 3 != iIndex))
{
XMLString::subString(tmp1, path, 0, segIndex, fMemoryManager);
XMLString::subString(tmp2, path, iIndex+3, XMLString::stringLen(path), fMemoryManager);
path[0] = 0;
XMLString::catString(path, tmp1);
XMLString::catString(path, tmp2);
offset = (segIndex == 0 ? 1 : segIndex);
}
else
{
offset += 4;
}
}// while
// 6f - remove ending "<segment>/.." where "<segment>" is a
// complete path segment
if (XMLString::endsWith(path, SLASH_DOTDOT))
{
// Find start of <segment> within substring ending at found point.
index = XMLString::stringLen(path) - 3;
XMLString::subString(tmp1, path, 0, index-1, fMemoryManager);
segIndex = XMLString::lastIndexOf(tmp1, chForwardSlash);
if (segIndex != -1 &&
(path[segIndex+1] != chPeriod ||
path[segIndex+2] != chPeriod ||
segIndex + 3 != (int)index))
{
path[segIndex+1] = chNull;
}
}
if (getPath())
fMemoryManager->deallocate(fPath);//delete [] fPath;
fPath = XMLString::replicate(path, fMemoryManager);
}
}
// ---------------------------------------------------------------------------
// Components initialization
// ---------------------------------------------------------------------------
//
// authority = server | reg_name
// server = [ [ userinfo "@" ] hostport ]
// hostport = host [ ":" port ]
//
// reg_name = 1*( unreserved | escaped | "$" | "," |
// ";" | ":" | "@" | "&" | "=" | "+" )
//
// userinfo = *( unreserved | escaped |
// ";" | ":" | "&" | "=" | "+" | "$" | "," )
//
void XMLUri::initializeAuthority(const XMLCh* const uriSpec)
{
int index = 0;
XMLSize_t start = 0;
const XMLSize_t end = XMLString::stringLen(uriSpec);
//
// server = [ [ userinfo "@" ] hostport ]
// userinfo is everything up @,
//
XMLCh* userinfo = (XMLCh*) fMemoryManager->allocate
(
(end+1) * sizeof(XMLCh)
);//new XMLCh[end+1];
ArrayJanitor<XMLCh> userName(userinfo, fMemoryManager);
index = XMLString::indexOf(&(uriSpec[start]), chAt);
if ( index != -1)
{
XMLString::subString(userinfo, &(uriSpec[start]), 0, index, fMemoryManager);
index++; // skip the @
start += index;
}
else
{
userinfo = 0;
}
//
// hostport = host [ ":" port ]
// host is everything up to ':', or up to
// and including ']' if followed by ':'.
//
XMLCh* host = (XMLCh*) fMemoryManager->allocate
(
(end+1) * sizeof(XMLCh)
);//new XMLCh[end+1];
ArrayJanitor<XMLCh> hostName(host, fMemoryManager);
// Search for port boundary.
if (start < end && uriSpec[start] == chOpenSquare)
{
index = XMLString::indexOf(&(uriSpec[start]), chCloseSquare);
if (index != -1)
{
// skip the ']'
index = ((start + index + 1) < end
&& uriSpec[start + index + 1] == chColon) ? index+1 : -1;
}
}
else
{
index = XMLString::indexOf(&(uriSpec[start]), chColon);
}
if ( index != -1 )
{
XMLString::subString(host, &(uriSpec[start]), 0, index, fMemoryManager);
index++; // skip the :
start +=index;
}
else
{
XMLString::subString(host, &(uriSpec[start]), 0, end-start, fMemoryManager);
start = end;
}
// port is everything after ":"
XMLCh* portStr = (XMLCh*) fMemoryManager->allocate
(
(end+1) * sizeof(XMLCh)
);//new XMLCh[end+1];
ArrayJanitor<XMLCh> portName(portStr, fMemoryManager);
int port = -1;
if ((host && *host) && // non empty host
(index != -1) && // ":" found
(start < end) ) // ":" is not the last
{
XMLString::subString(portStr, &(uriSpec[start]), 0, end-start, fMemoryManager);
if (portStr && *portStr)
{
port = XMLString::parseInt(portStr, fMemoryManager);
}
} // if > 0
// Check if we have server based authority.
if (isValidServerBasedAuthority(host, port, userinfo, fMemoryManager))
{
if (fHost)
fMemoryManager->deallocate(fHost);//delete [] fHost;
if (fUserInfo)
fMemoryManager->deallocate(fUserInfo);//delete[] fUserInfo;
fHost = XMLString::replicate(host, fMemoryManager);
fPort = port;
fUserInfo = XMLString::replicate(userinfo, fMemoryManager);
return;
}
// This must be registry based authority or the URI is malformed.
setRegBasedAuthority(uriSpec);
}
// scheme = alpha *( alpha | digit | "+" | "-" | "." )
void XMLUri::initializeScheme(const XMLCh* const uriSpec)
{
const XMLCh* tmpPtr = XMLString::findAny(uriSpec, SCHEME_SEPARATORS);
if ( !tmpPtr )
{
ThrowXMLwithMemMgr(MalformedURLException, XMLExcepts::XMLNUM_URI_No_Scheme, fMemoryManager);
}
else
{
XMLCh* scheme = (XMLCh*) fMemoryManager->allocate
(
(XMLString::stringLen(uriSpec) + 1) * sizeof(XMLCh)
);//new XMLCh[XMLString::stringLen(uriSpec)+1];
ArrayJanitor<XMLCh> tmpName(scheme, fMemoryManager);
XMLString::subString(scheme, uriSpec, 0, (tmpPtr - uriSpec), fMemoryManager);
setScheme(scheme);
}
}
void XMLUri::initializePath(const XMLCh* const uriSpec)
{
if ( !uriSpec )
{
ThrowXMLwithMemMgr1(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Empty
, errMsg_PATH
, fMemoryManager);
}
XMLSize_t index = 0;
XMLSize_t start = 0;
XMLSize_t end = XMLString::stringLen(uriSpec);
XMLCh testChar = 0;
// path - everything up to query string or fragment
if (start < end)
{
// RFC 2732 only allows '[' and ']' to appear in the opaque part.
if (!getScheme() || uriSpec[start] == chForwardSlash)
{
// Scan path.
// abs_path = "/" path_segments
// rel_path = rel_segment [ abs_path ]
while (index < end)
{
testChar = uriSpec[index];
if (testChar == chQuestion || testChar == chPound)
{
break;
}
// check for valid escape sequence
if (testChar == chPercent)
{
if (index+2 >= end ||
!XMLString::isHex(uriSpec[index+1]) ||
!XMLString::isHex(uriSpec[index+2]))
{
XMLCh value1[BUF_LEN+1];
XMLString::moveChars(value1, &(uriSpec[index]), 3);
value1[3] = chNull;
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Invalid_EscapeSequence
, errMsg_PATH
, value1
, fMemoryManager);
}
}
else if (!isUnreservedCharacter(testChar) &&
!isPathCharacter(testChar))
{
XMLCh value1[BUF_LEN+1];
value1[0] = testChar;
value1[1] = chNull;
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Invalid_Char
, errMsg_PATH
, value1
, fMemoryManager);
}
index++;
}//while (index < end)
}
else
{
// Scan opaque part.
// opaque_part = uric_no_slash *uric
while (index < end)
{
testChar = uriSpec[index];
if (testChar == chQuestion || testChar == chPound)
{
break;
}
// check for valid escape sequence
if (testChar == chPercent)
{
if (index+2 >= end ||
!XMLString::isHex(uriSpec[index+1]) ||
!XMLString::isHex(uriSpec[index+2]))
{
XMLCh value1[BUF_LEN+1];
XMLString::moveChars(value1, &(uriSpec[index]), 3);
value1[3] = chNull;
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Invalid_EscapeSequence
, errMsg_PATH
, value1
, fMemoryManager);
}
}
// If the scheme specific part is opaque, it can contain '['
// and ']'. uric_no_slash wasn't modified by RFC 2732, which
// I've interpreted as an error in the spec, since the
// production should be equivalent to (uric - '/'), and uric
// contains '[' and ']'.
else if (!isReservedOrUnreservedCharacter(testChar))
{
XMLCh value1[BUF_LEN+1];
value1[0] = testChar;
value1[1] = chNull;
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Invalid_Char
, errMsg_PATH
, value1
, fMemoryManager);
}
index++;
}//while (index < end)
}
} //if (start < end)
if (getPath())
{
fMemoryManager->deallocate(fPath);//delete [] fPath;
}
fPath = (XMLCh*) fMemoryManager->allocate((index+1) * sizeof(XMLCh));//new XMLCh[index+1];
XMLString::subString(fPath, uriSpec, start, index, fMemoryManager);
// query - starts with ? and up to fragment or end
if (testChar == chQuestion)
{
index++;
start = index;
while (index < end)
{
testChar = uriSpec[index];
if (testChar == chPound)
{
break;
}
if (testChar == chPercent)
{
if (index+2 >= end ||
!XMLString::isHex(uriSpec[index+1]) ||
!XMLString::isHex(uriSpec[index+2]))
{
XMLCh value1[BUF_LEN+1];
XMLString::moveChars(value1, &(uriSpec[index]), 3);
value1[3] = chNull;
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Invalid_EscapeSequence
, errMsg_QUERY
, value1
, fMemoryManager);
}
}
else if (!isReservedOrUnreservedCharacter(testChar))
{
XMLCh value1[BUF_LEN+1];
value1[0] = testChar;
value1[1] = chNull;
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Invalid_Char
, errMsg_QUERY
, value1
, fMemoryManager);
}
index++;
}
if (getQueryString())
{
fMemoryManager->deallocate(fQueryString);//delete [] fQueryString;
}
fQueryString = (XMLCh*) fMemoryManager->allocate
(
(index - start + 1) * sizeof(XMLCh)
);//new XMLCh[index - start + 1];
XMLString::subString(fQueryString, uriSpec, start, index, fMemoryManager);
}
// fragment - starts with #
if (testChar == chPound)
{
index++;
start = index;
while (index < end)
{
testChar = uriSpec[index];
if (testChar == chPercent)
{
if (index+2 >= end ||
!XMLString::isHex(uriSpec[index+1]) ||
!XMLString::isHex(uriSpec[index+2]))
{
XMLCh value1[BUF_LEN+1];
XMLString::moveChars(value1, &(uriSpec[index]), 3);
value1[3] = chNull;
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Invalid_EscapeSequence
, errMsg_FRAGMENT
, value1
, fMemoryManager);
}
}
else if (!isReservedOrUnreservedCharacter(testChar))
{
XMLCh value1[BUF_LEN+1];
value1[0] = testChar;
value1[1] = chNull;
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Invalid_Char
, errMsg_FRAGMENT
, value1
, fMemoryManager);
}
index++;
}
if (getFragment())
fMemoryManager->deallocate(fFragment);//delete [] fFragment;
//make sure that there is something following the '#'
if (index > start)
{
fFragment = (XMLCh*) fMemoryManager->allocate
(
(index - start + 1) * sizeof(XMLCh)
);//new XMLCh[index - start + 1];
XMLString::subString(fFragment, uriSpec, start, index, fMemoryManager);
}
else
{
// RFC 2396, 4.0. URI Reference
// URI-reference = [absoulteURI | relativeURI] [# fragment]
//
// RFC 2396, 4.1. Fragment Identifier
// fragment = *uric
//
// empty fragment is valid
fFragment = 0;
}
}
}
// ---------------------------------------------------------------------------
// Setter
// ---------------------------------------------------------------------------
void XMLUri::setScheme(const XMLCh* const newScheme)
{
if ( !newScheme )
{
ThrowXMLwithMemMgr1(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Set_Null
, errMsg_SCHEME
, fMemoryManager);
}
if (!isConformantSchemeName(newScheme))
{
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Not_Conformant
, errMsg_SCHEME
, newScheme
, fMemoryManager);
}
if (getScheme())
{
fMemoryManager->deallocate(fScheme);//delete [] fScheme;
}
fScheme = XMLString::replicate(newScheme, fMemoryManager);
XMLString::lowerCase(fScheme);
}
//
// server = [ [ userinfo "@" ] hostport ]
// hostport = host [":" port]
//
// setUserInfo(), setHost() and setPort() are closely related
// three methods, in a word, userinfo and port has dependency
// on host.
//
// if host is not present, userinfo must be null and port = -1
//
void XMLUri::setUserInfo(const XMLCh* const newUserInfo)
{
if ( newUserInfo &&
!getHost() )
{
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_NullHost
, errMsg_USERINFO
, newUserInfo
, fMemoryManager);
}
isConformantUserInfo(newUserInfo, fMemoryManager);
if (getUserInfo())
{
fMemoryManager->deallocate(fUserInfo);//delete [] fUserInfo;
}
//sometimes we get passed a empty string rather than a null.
//Other procedures rely on it being null
if(newUserInfo && *newUserInfo) {
fUserInfo = XMLString::replicate(newUserInfo, fMemoryManager);
}
else
fUserInfo = 0;
}
void XMLUri::setHost(const XMLCh* const newHost)
{
if ( !newHost )
{
if (getHost())
fMemoryManager->deallocate(fHost);//delete [] fHost;
fHost = 0;
setUserInfo(0);
setPort(-1);
return;
}
if ( *newHost && !isWellFormedAddress(newHost, fMemoryManager))
{
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Not_Conformant
, errMsg_HOST
, newHost
, fMemoryManager);
}
if (getHost())
{
fMemoryManager->deallocate(fHost);//delete [] fHost;
}
fHost = XMLString::replicate(newHost, fMemoryManager);
setRegBasedAuthority(0);
}
void XMLUri::setPort(int newPort)
{
if (newPort >= 0 && newPort <= 65535)
{
if (!getHost())
{
XMLCh value1[BUF_LEN+1];
XMLString::binToText(newPort, value1, BUF_LEN, 10, fMemoryManager);
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_NullHost
, errMsg_PORT
, value1
, fMemoryManager);
}
}
else if (newPort != -1)
{
XMLCh value1[BUF_LEN+1];
XMLString::binToText(newPort, value1, BUF_LEN, 10, fMemoryManager);
ThrowXMLwithMemMgr1(MalformedURLException
, XMLExcepts::XMLNUM_URI_PortNo_Invalid
, value1
, fMemoryManager);
}
fPort = newPort;
}
void XMLUri::setRegBasedAuthority(const XMLCh* const newRegAuth)
{
if ( !newRegAuth )
{
if (getRegBasedAuthority())
fMemoryManager->deallocate(fRegAuth);//delete [] fRegAuth;
fRegAuth = 0;
return;
}
// reg_name = 1*( unreserved | escaped | "$" | "," |
// ";" | ":" | "@" | "&" | "=" | "+" )
else if ( !*newRegAuth || !isValidRegistryBasedAuthority(newRegAuth) )
{
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Not_Conformant
, errMsg_REGNAME
, newRegAuth
, fMemoryManager);
}
if (getRegBasedAuthority())
fMemoryManager->deallocate(fRegAuth);//delete [] fRegAuth;
fRegAuth = XMLString::replicate(newRegAuth, fMemoryManager);
setHost(0);
}
//
// setPath(), setQueryString() and setFragment() are closely
// related three methods as well.
//
void XMLUri::setPath(const XMLCh* const newPath)
{
if (!newPath)
{
if (getPath())
fMemoryManager->deallocate(fPath);//delete [] fPath;
fPath = 0;
setQueryString(0);
setFragment(0);
}
else
{
initializePath(newPath);
}
}
//
// fragment = *uric
//
void XMLUri::setFragment(const XMLCh* const newFragment)
{
if ( !newFragment )
{
if (getFragment())
fMemoryManager->deallocate(fFragment);//delete [] fFragment;
fFragment = 0;
}
else if (!isGenericURI())
{
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_for_GenURI_Only
, errMsg_FRAGMENT
, newFragment
, fMemoryManager);
}
else if ( !getPath() )
{
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_NullPath
, errMsg_FRAGMENT
, newFragment
, fMemoryManager);
}
else if (!isURIString(newFragment))
{
ThrowXMLwithMemMgr1(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Invalid_Char
, errMsg_FRAGMENT
, fMemoryManager);
}
else
{
if (getFragment())
{
fMemoryManager->deallocate(fFragment);//delete [] fFragment;
}
fFragment = XMLString::replicate(newFragment, fMemoryManager);
}
}
//
// query = *uric
//
void XMLUri::setQueryString(const XMLCh* const newQueryString)
{
if ( !newQueryString )
{
if (getQueryString())
fMemoryManager->deallocate(fQueryString);//delete [] fQueryString;
fQueryString = 0;
}
else if (!isGenericURI())
{
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_for_GenURI_Only
, errMsg_QUERY
, newQueryString
, fMemoryManager);
}
else if ( !getPath() )
{
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_NullPath
, errMsg_QUERY
, newQueryString
, fMemoryManager);
}
else if (!isURIString(newQueryString))
{
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Invalid_Char
, errMsg_QUERY
, newQueryString
, fMemoryManager);
}
else
{
if (getQueryString())
{
fMemoryManager->deallocate(fQueryString);//delete [] fQueryString;
}
fQueryString = XMLString::replicate(newQueryString, fMemoryManager);
}
}
// ---------------------------------------------------------------------------
// XMLUri: Public, static methods
// ---------------------------------------------------------------------------
//
// scheme = alpha *( alpha | digit | "+" | "-" | "." )
// alphanum = alpha | digit
//
bool XMLUri::isConformantSchemeName(const XMLCh* const scheme)
{
if ( !scheme )
return false;
const XMLCh* tmpStr = scheme;
if (!XMLString::isAlpha(*tmpStr)) // first: alpha
return false;
// second onwards: ( alpha | digit | "+" | "-" | "." )
tmpStr++;
while (*tmpStr)
{
if ( !XMLString::isAlphaNum(*tmpStr) &&
(XMLString::indexOf(SCHEME_CHARACTERS, *tmpStr) == -1))
return false;
tmpStr++;
}
return true;
}
//
// userinfo = *( unreserved | escaped |
// ";" | ":" | "&" | "=" | "+" | "$" | "," )
//
void XMLUri::isConformantUserInfo(const XMLCh* const userInfo
, MemoryManager* const manager)
{
if ( !userInfo )
return;
const XMLCh* tmpStr = userInfo;
while (*tmpStr)
{
if ( isUnreservedCharacter(*tmpStr) ||
(XMLString::indexOf(USERINFO_CHARACTERS, *tmpStr) != -1))
{
tmpStr++;
}
else if (*tmpStr == chPercent) // '%'
{
if (XMLString::isHex(*(tmpStr+1)) && // 1st hex
XMLString::isHex(*(tmpStr+2)) ) // 2nd hex
{
tmpStr+=3;
}
else
{
XMLCh value1[BUF_LEN+1];
value1[0] = chPercent;
value1[1] = *(tmpStr+1);
value1[2] = *(tmpStr+2);
value1[3] = chNull;
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Invalid_EscapeSequence
, errMsg_USERINFO
, value1
, manager);
}
}
else
{
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Invalid_Char
, errMsg_USERINFO
, userInfo
, manager);
}
} //while
return;
}
bool XMLUri::isValidServerBasedAuthority(const XMLCh* const host,
const XMLSize_t hostLen,
const int port,
const XMLCh* const userinfo,
const XMLSize_t userLen)
{
// The order is important, do not change
if (!isWellFormedAddress(host, hostLen))
return false;
// check port number
if ((port > 65535) || (port < 0 && port != -1))
return false;
// check userinfo
XMLSize_t index = 0;
while (index < userLen)
{
if (isUnreservedCharacter(userinfo[index]) ||
(XMLString::indexOf(USERINFO_CHARACTERS, userinfo[index]) != -1))
{
index++;
}
else if (userinfo[index] == chPercent) // '%'
{
if (XMLString::isHex(userinfo[index+1]) && // 1st hex
XMLString::isHex(userinfo[index+2]) ) // 2nd hex
index +=3;
else
return false;
}
else
return false;
} //while
return true;
}
bool XMLUri::isValidServerBasedAuthority(const XMLCh* const host
, const int port
, const XMLCh* const userinfo
, MemoryManager* const manager)
{
// The order is important, do not change
if (!isWellFormedAddress(host, manager))
return false;
// check port number
if ((port > 65535) || (port < 0 && port != -1))
return false;
// check userinfo
if (!userinfo)
return true;
const XMLCh* tmpStr = userinfo;
while (*tmpStr)
{
if ( isUnreservedCharacter(*tmpStr) ||
(XMLString::indexOf(USERINFO_CHARACTERS, *tmpStr) != -1))
{
tmpStr++;
}
else if (*tmpStr == chPercent) // '%'
{
if (XMLString::isHex(*(tmpStr+1)) && // 1st hex
XMLString::isHex(*(tmpStr+2)) ) // 2nd hex
{
tmpStr+=3;
}
else
return false;
}
else
return false;
} //while
return true;
}
bool XMLUri::isValidRegistryBasedAuthority(const XMLCh* const authority,
const XMLSize_t authLen)
{
// check authority
XMLSize_t index = 0;
while (index < authLen)
{
if (isUnreservedCharacter(authority[index]) ||
(XMLString::indexOf(REG_NAME_CHARACTERS, authority[index]) != -1))
{
index++;
}
else if (authority[index] == chPercent) // '%'
{
if (XMLString::isHex(authority[index+1]) && // 1st hex
XMLString::isHex(authority[index+2]) ) // 2nd hex
index +=3;
else
return false;
}
else
return false;
} //while
return true;
}
bool XMLUri::isValidRegistryBasedAuthority(const XMLCh* const authority)
{
// check authority
if (!authority)
return false;
const XMLCh* tmpStr = authority;
while (*tmpStr)
{
if (isUnreservedCharacter(*tmpStr) ||
(XMLString::indexOf(REG_NAME_CHARACTERS, *tmpStr) != -1))
{
tmpStr++;
}
else if (*tmpStr == chPercent) // '%'
{
if (XMLString::isHex(*(tmpStr+1)) && // 1st hex
XMLString::isHex(*(tmpStr+2)) ) // 2nd hex
{
tmpStr+=3;
}
else
return false;
}
else
return false;
} //while
return true;
}
//
// uric = reserved | unreserved | escaped
// escaped = "%" hex hex
// hex = digit | "A" | "B" | "C" | "D" | "E" | "F" |
// "a" | "b" | "c" | "d" | "e" | "f"
//
bool XMLUri::isURIString(const XMLCh* const uricString)
{
if (!uricString || !*uricString)
return false;
const XMLCh* tmpStr = uricString;
while (*tmpStr)
{
if (isReservedOrUnreservedCharacter(*tmpStr))
{
tmpStr++;
}
else if (*tmpStr == chPercent) // '%'
{
if (XMLString::isHex(*(tmpStr+1)) && // 1st hex
XMLString::isHex(*(tmpStr+2)) ) // 2nd hex
{
tmpStr+=3;
}
else
{
return false;
}
}
else
{
return false;
}
}
return true;
}
//
// host = hostname | IPv4address
//
// hostname = *( domainlabel "." ) toplabel [ "." ]
// domainlabel = alphanum | alphanum *( alphanum | "-" ) alphanum
// toplabel = alpha | alpha *( alphanum | "-" ) alphanum
//
// IPv4address = 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT
//
bool XMLUri::isWellFormedAddress(const XMLCh* const addrString
, MemoryManager* const manager)
{
// Check that we have a non-zero length string.
if (!addrString || !*addrString)
return false;
// Get address length.
XMLSize_t addrStrLen = XMLString::stringLen(addrString);
// Check if the host is a valid IPv6reference.
if (*addrString == chOpenSquare)
{
return isWellFormedIPv6Reference(addrString, addrStrLen);
}
//
// Cannot start with a '.', '-', or end with a '-'.
//
if (*addrString == chPeriod ||
*addrString == chDash ||
addrString[addrStrLen-1] == chDash)
return false;
// rightmost domain label starting with digit indicates IP address
// since top level domain label can only start with an alpha
// see RFC 2396 Section 3.2.2
int lastPeriodPos = XMLString::lastIndexOf(addrString, chPeriod);
// if the string ends with "."
// get the second last "."
if (XMLSize_t(lastPeriodPos + 1) == addrStrLen)
{
XMLCh* tmp2 = (XMLCh*) manager->allocate
(
addrStrLen * sizeof(XMLCh)
);//new XMLCh[addrStrLen];
XMLString::subString(tmp2, addrString, 0, lastPeriodPos, manager);
lastPeriodPos = XMLString::lastIndexOf(tmp2, chPeriod);
manager->deallocate(tmp2);//delete [] tmp2;
if ( XMLString::isDigit(addrString[lastPeriodPos + 1]))
return false;
}
if (XMLString::isDigit(addrString[lastPeriodPos + 1]))
{
return isWellFormedIPv4Address(addrString, addrStrLen);
} // end of IPv4address
else
{
//
// hostname = *( domainlabel "." ) toplabel [ "." ]
// domainlabel = alphanum | alphanum *( alphanum | "-" ) alphanum
// toplabel = alpha | alpha *( alphanum | "-" ) alphanum
// RFC 2396 states that hostnames take the form described in
// RFC 1034 (Section 3) and RFC 1123 (Section 2.1). According
// to RFC 1034, hostnames are limited to 255 characters.
if (addrStrLen > 255) {
return false;
}
unsigned int labelCharCount = 0;
// domain labels can contain alphanumerics and '-"
// but must start and end with an alphanumeric
for (XMLSize_t i = 0; i < addrStrLen; i++)
{
if (addrString[i] == chPeriod)
{
if (((i > 0) &&
(!XMLString::isAlphaNum(addrString[i-1]))) ||
((i + 1 < addrStrLen) &&
(!XMLString::isAlphaNum(addrString[i+1]))) )
{
return false;
}
labelCharCount = 0;
}
else if (!XMLString::isAlphaNum(addrString[i]) &&
addrString[i] != chDash)
{
return false;
}
// RFC 1034: Labels must be 63 characters or less.
else if (++labelCharCount > 63) {
return false;
}
} //for
}
return true;
}
//
// RFC 2732 amended RFC 2396 by replacing the definition
// of IPv4address with the one defined by RFC 2373.
//
// IPv4address = 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT
//
bool XMLUri::isWellFormedIPv4Address(const XMLCh* const addr, const XMLSize_t length)
{
int numDots = 0;
int numDigits = 0;
// IPv4address = 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT
//
// make sure that
// 1) we see only digits and dot separators,
// 2) that any dot separator is preceded and followed by a digit
// 3) that we find 3 dots
// 4) that each segment contains 1 to 3 digits.
// 5) that each segment is not greater than 255.
for (XMLSize_t i = 0; i < length; ++i)
{
if (addr[i] == chPeriod)
{
if ((i == 0) ||
(i+1 == length) ||
!XMLString::isDigit(addr[i+1]))
{
return false;
}
numDigits = 0;
if (++numDots > 3)
return false;
}
else if (!XMLString::isDigit(addr[i]))
{
return false;
}
// Check that that there are no more than three digits
// in this segment.
else if (++numDigits > 3)
{
return false;
}
// Check that this segment is not greater than 255.
else if (numDigits == 3)
{
XMLCh first = addr[i-2];
XMLCh second = addr[i-1];
XMLCh last = addr[i];
if (!(first < chDigit_2 ||
(first == chDigit_2 &&
(second < chDigit_5 ||
(second == chDigit_5 && last <= chDigit_5)))))
{
return false;
}
}
} //for
return (numDots == 3);
}
//
// IPv6reference = "[" IPv6address "]"
//
bool XMLUri::isWellFormedIPv6Reference(const XMLCh* const addr, const XMLSize_t length)
{
XMLSize_t end = length-1;
// Check if string is a potential match for IPv6reference.
if (!(length > 2 && addr[0] == chOpenSquare && addr[end] == chCloseSquare))
{
return false;
}
// Counter for the number of 16-bit sections read in the address.
int counter = 0;
// Scan hex sequence before possible '::' or IPv4 address.
int iIndex = scanHexSequence(addr, 1, end, counter);
if (iIndex == -1)
return false;
XMLSize_t index=(XMLSize_t)iIndex;
// Address must contain 128-bits of information.
if (index == end)
{
return (counter == 8);
}
if (index+1 < end && addr[index] == chColon)
{
if (addr[index+1] == chColon)
{
// '::' represents at least one 16-bit group of zeros.
if (++counter > 8)
{
return false;
}
index += 2;
// Trailing zeros will fill out the rest of the address.
if (index == end)
{
return true;
}
}
// If the second character wasn't ':', in order to be valid,
// the remainder of the string must match IPv4Address,
// and we must have read exactly 6 16-bit groups.
else
{
if (counter == 6)
return isWellFormedIPv4Address(addr+index+1, end-index-1);
else
return false;
}
}
else
{
return false;
}
// 3. Scan hex sequence after '::'.
int prevCount = counter;
iIndex = scanHexSequence(addr, index, end, counter);
if (iIndex == -1)
return false;
index=(XMLSize_t)iIndex;
// If this is the end of the address then
// we've got 128-bits of information.
if (index == end)
{
return true;
}
// The address ends in an IPv4 address, or it is invalid.
// scanHexSequence has already made sure that we have the right number of bits.
XMLSize_t shiftCount = (counter > prevCount) ? index+1 : index;
return isWellFormedIPv4Address(addr + shiftCount, end - shiftCount);
}
//
// For use with isWellFormedIPv6Reference only.
//
int XMLUri::scanHexSequence (const XMLCh* const addr, XMLSize_t index, XMLSize_t end, int& counter)
{
XMLCh testChar = chNull;
int numDigits = 0;
XMLSize_t start = index;
// Trying to match the following productions:
// hexseq = hex4 *( ":" hex4)
// hex4 = 1*4HEXDIG
for (; index < end; ++index)
{
testChar = addr[index];
if (testChar == chColon)
{
// IPv6 addresses are 128-bit, so there can be at most eight sections.
if (numDigits > 0 && ++counter > 8)
{
return -1;
}
// This could be '::'.
if (numDigits == 0 || ((index+1 < end) && addr[index+1] == chColon))
{
return (int)index;
}
numDigits = 0;
}
// This might be invalid or an IPv4address. If it's potentially an IPv4address,
// backup to just after the last valid character that matches hexseq.
else if (!XMLString::isHex(testChar))
{
if (testChar == chPeriod && numDigits < 4 && numDigits > 0 && counter <= 6)
{
int back = (int)index - numDigits - 1;
return (back >= (int)start) ? back : (int)start;
}
return -1;
}
// There can be at most 4 hex digits per group.
else if (++numDigits > 4)
{
return -1;
}
}
return (numDigits > 0 && ++counter <= 8) ? (int)end : -1;
}
bool XMLUri::isGenericURI()
{
return (getHost() != 0);
}
//
// This method will take the broken out parts of the URI and build up the
// full text. We don't do this unless someone asks us to, since its often
// never required.
//
void XMLUri::buildFullText()
{
// Calculate the worst case size of the buffer required
XMLSize_t bufSize = XMLString::stringLen(fScheme) + 1
+ XMLString::stringLen(fFragment) + 1
+ XMLString::stringLen(fHost ? fHost : fRegAuth) + 2
+ XMLString::stringLen(fPath)
+ XMLString::stringLen(fQueryString) + 1
+ XMLString::stringLen(fUserInfo) + 1
+ 32;
// Clean up the existing buffer and allocate another
fMemoryManager->deallocate(fURIText);//delete [] fURIText;
fURIText = (XMLCh*) fMemoryManager->allocate(bufSize * sizeof(XMLCh));//new XMLCh[bufSize];
*fURIText = 0;
XMLCh* outPtr = fURIText;
if (fScheme != 0)
{
XMLString::catString(fURIText, getScheme());
outPtr += XMLString::stringLen(fURIText);
*outPtr++ = chColon;
}
// Authority
if (fHost || fRegAuth)
{
*outPtr++ = chForwardSlash;
*outPtr++ = chForwardSlash;
// Server based authority.
if (fHost)
{
if (fUserInfo)
{
XMLString::copyString(outPtr, fUserInfo);
outPtr += XMLString::stringLen(fUserInfo);
*outPtr++ = chAt;
}
XMLString::copyString(outPtr, fHost);
outPtr += XMLString::stringLen(fHost);
//
// If the port is -1, then we don't put it in. Else we need
// to because it was explicitly provided.
//
if (fPort != -1)
{
*outPtr++ = chColon;
XMLCh tmpBuf[17];
XMLString::binToText(fPort, tmpBuf, 16, 10, fMemoryManager);
XMLString::copyString(outPtr, tmpBuf);
outPtr += XMLString::stringLen(tmpBuf);
}
}
// Registry based authority.
else {
XMLString::copyString(outPtr, fRegAuth);
outPtr += XMLString::stringLen(fRegAuth);
}
}
if (fPath)
{
XMLString::copyString(outPtr, fPath);
outPtr += XMLString::stringLen(fPath);
}
if (fQueryString)
{
*outPtr++ = chQuestion;
XMLString::copyString(outPtr, fQueryString);
outPtr += XMLString::stringLen(fQueryString);
}
if (fFragment)
{
*outPtr++ = chPound;
XMLString::copyString(outPtr, fFragment);
outPtr += XMLString::stringLen(fFragment);
}
// Cap it off in case the last op was not a string copy
*outPtr = 0;
}
// NOTE: no check for NULL value of uriStr (caller responsiblilty)
bool XMLUri::isValidURI(const XMLUri* const baseURI
, const XMLCh* const uriStr
, bool bAllowSpaces/*=false*/)
{
// get a trimmed version of uriStr
// uriStr will NO LONGER be used in this function.
const XMLCh* trimmedUriSpec = uriStr;
while (XMLChar1_0::isWhitespace(*trimmedUriSpec))
trimmedUriSpec++;
XMLSize_t trimmedUriSpecLen = XMLString::stringLen(trimmedUriSpec);
while (trimmedUriSpecLen) {
if (XMLChar1_0::isWhitespace(trimmedUriSpec[trimmedUriSpecLen-1]))
trimmedUriSpecLen--;
else
break;
}
if (trimmedUriSpecLen == 0)
{
if (!baseURI)
return false;
else
return true;
}
XMLSize_t index = 0;
bool foundScheme = false;
// Check for scheme, which must be before `/', '?' or '#'.
int colonIdx = XMLString::indexOf(trimmedUriSpec, chColon);
int slashIdx = XMLString::indexOf(trimmedUriSpec, chForwardSlash);
int queryIdx = XMLString::indexOf(trimmedUriSpec, chQuestion);
int fragmentIdx = XMLString::indexOf(trimmedUriSpec, chPound);
if ((colonIdx <= 0) ||
(colonIdx > slashIdx && slashIdx != -1) ||
(colonIdx > queryIdx && queryIdx != -1) ||
(colonIdx > fragmentIdx && fragmentIdx != -1))
{
// A standalone base is a valid URI according to spec
if (colonIdx == 0 || (!baseURI && fragmentIdx != 0))
return false;
}
else
{
if (!processScheme(trimmedUriSpec, index))
return false;
foundScheme = true;
++index;
}
// It's an error if we stop here
if (index == trimmedUriSpecLen || (foundScheme && (trimmedUriSpec[index] == chPound)))
return false;
// two slashes means generic URI syntax, so we get the authority
const XMLCh* authUriSpec = trimmedUriSpec + index;
if (((index+1) < trimmedUriSpecLen) &&
XMLString::startsWith(authUriSpec, DOUBLE_SLASH))
{
index += 2;
XMLSize_t startPos = index;
// get authority - everything up to path, query or fragment
XMLCh testChar;
while (index < trimmedUriSpecLen)
{
testChar = trimmedUriSpec[index];
if (testChar == chForwardSlash ||
testChar == chQuestion ||
testChar == chPound )
{
break;
}
index++;
}
// if we found authority, parse it out, otherwise we set the
// host to empty string
if (index > startPos)
{
if (!processAuthority(trimmedUriSpec + startPos, index - startPos))
return false;
}
}
// we need to check if index has exceed the lenght or not
if (index < trimmedUriSpecLen)
{
if (!processPath(trimmedUriSpec + index, trimmedUriSpecLen - index, foundScheme, bAllowSpaces))
return false;
}
return true;
}
// NOTE: no check for NULL value of uriStr (caller responsiblilty)
// NOTE: this routine is the same as above, but it uses a flag to
// indicate the existance of a baseURI rather than an XMLuri.
bool XMLUri::isValidURI(bool haveBaseURI, const XMLCh* const uriStr, bool bAllowSpaces/*=false*/)
{
// get a trimmed version of uriStr
// uriStr will NO LONGER be used in this function.
const XMLCh* trimmedUriSpec = uriStr;
while (XMLChar1_0::isWhitespace(*trimmedUriSpec))
trimmedUriSpec++;
XMLSize_t trimmedUriSpecLen = XMLString::stringLen(trimmedUriSpec);
while (trimmedUriSpecLen) {
if (XMLChar1_0::isWhitespace(trimmedUriSpec[trimmedUriSpecLen-1]))
trimmedUriSpecLen--;
else
break;
}
if (trimmedUriSpecLen == 0)
{
if (!haveBaseURI)
return false;
return true;
}
XMLSize_t index = 0;
bool foundScheme = false;
// Check for scheme, which must be before `/', '?' or '#'.
int colonIdx = XMLString::indexOf(trimmedUriSpec, chColon);
int slashIdx = XMLString::indexOf(trimmedUriSpec, chForwardSlash);
int queryIdx = XMLString::indexOf(trimmedUriSpec, chQuestion);
int fragmentIdx = XMLString::indexOf(trimmedUriSpec, chPound);
if ((colonIdx <= 0) ||
(colonIdx > slashIdx && slashIdx != -1) ||
(colonIdx > queryIdx && queryIdx != -1) ||
(colonIdx > fragmentIdx && fragmentIdx != -1))
{
// A standalone base is a valid URI according to spec
if (colonIdx == 0 || (!haveBaseURI && fragmentIdx != 0))
return false;
}
else
{
if (!processScheme(trimmedUriSpec, index))
return false;
foundScheme = true;
++index;
}
// It's an error if we stop here
if (index == trimmedUriSpecLen || (foundScheme && (trimmedUriSpec[index] == chPound)))
return false;
// two slashes means generic URI syntax, so we get the authority
const XMLCh* authUriSpec = trimmedUriSpec + index;
if (((index+1) < trimmedUriSpecLen) &&
XMLString::startsWith(authUriSpec, DOUBLE_SLASH))
{
index += 2;
XMLSize_t startPos = index;
// get authority - everything up to path, query or fragment
XMLCh testChar;
while (index < trimmedUriSpecLen)
{
testChar = trimmedUriSpec[index];
if (testChar == chForwardSlash ||
testChar == chQuestion ||
testChar == chPound )
{
break;
}
index++;
}
// if we found authority, parse it out, otherwise we set the
// host to empty string
if (index > startPos)
{
if (!processAuthority(trimmedUriSpec + startPos, index - startPos))
return false;
}
}
// we need to check if index has exceed the length or not
if (index < trimmedUriSpecLen)
{
if (!processPath(trimmedUriSpec + index, trimmedUriSpecLen - index, foundScheme, bAllowSpaces))
return false;
}
return true;
}
bool XMLUri::isWellFormedAddress(const XMLCh* const addrString,
const XMLSize_t addrStrLen)
{
// Check that we have a non-zero length string.
if (addrStrLen == 0)
return false;
// Check if the host is a valid IPv6reference.
if (*addrString == chOpenSquare)
{
return isWellFormedIPv6Reference(addrString, addrStrLen);
}
//
// Cannot start with a '.', '-', or end with a '-'.
//
if (*addrString == chPeriod ||
*addrString == chDash ||
addrString[addrStrLen-1] == chDash)
return false;
// rightmost domain label starting with digit indicates IP address
// since top level domain label can only start with an alpha
// see RFC 2396 Section 3.2.2
int lastPeriodPos = XMLString::lastIndexOf(chPeriod, addrString, addrStrLen);
// if the string ends with "."
// get the second last "."
if (XMLSize_t(lastPeriodPos + 1) == addrStrLen)
{
lastPeriodPos = XMLString::lastIndexOf(chPeriod, addrString, lastPeriodPos);
if ( XMLString::isDigit(addrString[lastPeriodPos + 1]))
return false;
}
if (XMLString::isDigit(addrString[lastPeriodPos + 1]))
{
return isWellFormedIPv4Address(addrString, addrStrLen);
} // end of IPv4address
else
{
//
// hostname = *( domainlabel "." ) toplabel [ "." ]
// domainlabel = alphanum | alphanum *( alphanum | "-" ) alphanum
// toplabel = alpha | alpha *( alphanum | "-" ) alphanum
// RFC 2396 states that hostnames take the form described in
// RFC 1034 (Section 3) and RFC 1123 (Section 2.1). According
// to RFC 1034, hostnames are limited to 255 characters.
if (addrStrLen > 255) {
return false;
}
unsigned int labelCharCount = 0;
// domain labels can contain alphanumerics and '-"
// but must start and end with an alphanumeric
for (XMLSize_t i = 0; i < addrStrLen; i++)
{
if (addrString[i] == chPeriod)
{
if (((i > 0) &&
(!XMLString::isAlphaNum(addrString[i-1]))) ||
((i + 1 < addrStrLen) &&
(!XMLString::isAlphaNum(addrString[i+1]))) )
{
return false;
}
labelCharCount = 0;
}
else if (!XMLString::isAlphaNum(addrString[i]) &&
addrString[i] != chDash)
{
return false;
}
// RFC 1034: Labels must be 63 characters or less.
else if (++labelCharCount > 63) {
return false;
}
} //for
}
return true;
}
bool XMLUri::processScheme(const XMLCh* const schemeStr, XMLSize_t& index)
{
const XMLCh* tmpPtr = XMLString::findAny(schemeStr, SCHEME_SEPARATORS);
if (tmpPtr) {
index = tmpPtr - schemeStr;
return isConformantSchemeName(schemeStr, index);
}
else {
return false;
}
}
bool XMLUri::isConformantSchemeName( const XMLCh* const scheme
, const XMLSize_t schemeLen)
{
if (!XMLString::isAlpha(*scheme)) // first: alpha
return false;
// second onwards: ( alpha | digit | "+" | "-" | "." )
for (XMLSize_t i=1; i<schemeLen; i++)
{
if ( !XMLString::isAlphaNum(scheme[i]) &&
(XMLString::indexOf(SCHEME_CHARACTERS, scheme[i]) == -1))
return false;
}
return true;
}
bool XMLUri::processAuthority( const XMLCh* const authSpec
, const XMLSize_t authLen)
{
int index = XMLString::indexOf(authSpec, chAt);
XMLSize_t start = 0;
// server = [ [ userinfo "@" ] hostport ]
// userinfo is everything up @,
const XMLCh* userinfo;
int userInfoLen = 0;
if ((index != -1) && (XMLSize_t(index) < authLen))
{
userinfo = authSpec;
userInfoLen = index;
start = index + 1;
}
else
{
userinfo = XMLUni::fgZeroLenString;
}
// hostport = host [ ":" port ]
// host is everything up to ':', or up to
// and including ']' if followed by ':'.
//
// Search for port boundary.
const XMLCh* host;
XMLSize_t hostLen = 0;
if ((start < authLen) && (authSpec[start] == chOpenSquare))
{
index = XMLString::indexOf(&(authSpec[start]), chCloseSquare);
if ((index != -1) && (XMLSize_t(index) < authLen))
{
// skip the ']'
index = ((start + index + 1) < authLen
&& authSpec[start + index + 1] == chColon) ? index+1 : -1;
}
}
else
{
index = XMLString::indexOf(&(authSpec[start]), chColon);
if (index!=-1 && XMLSize_t(index) >= authLen)
index = -1;
}
host = &(authSpec[start]);
if (index != -1)
{
hostLen = index;
start += index + 1; // skip the :
}
else
{
hostLen = authLen - start;
start = authLen;
}
// port is everything after ":"
int port = -1;
if ((hostLen) && // non empty host
(index != -1) && // ":" found
(start < authLen) ) // ":" is not the last
{
const XMLCh* portStr = &(authSpec[start]);
if (*portStr)
{
port = 0;
for (XMLSize_t i=0; i<(authLen - start); i++)
{
if (portStr[i] < chDigit_0 || portStr[i] > chDigit_9)
{
// Assume this is a registry-based authority.
//
port = -1;
hostLen = 0;
host = XMLUni::fgZeroLenString;
userInfoLen = 0;
userinfo = XMLUni::fgZeroLenString;
break;
}
port = (port * 10) + (int) (portStr[i] - chDigit_0);
}
}
}
return isValidServerBasedAuthority(host, hostLen, port, userinfo, userInfoLen)
|| isValidRegistryBasedAuthority(authSpec, authLen);
}
bool XMLUri::processPath(const XMLCh* const pathStr,
const XMLSize_t pathStrLen,
const bool isSchemePresent,
const bool bAllowSpaces/*=false*/)
{
if (pathStrLen != 0)
{
XMLSize_t index = 0;
XMLCh testChar = chNull;
bool isOpaque = (!isSchemePresent || *pathStr == chForwardSlash);
// path - everything up to query string or fragment
//
// RFC 2732 only allows '[' and ']' to appear in the opaque part.
while (index < pathStrLen)
{
testChar = pathStr[index];
if (testChar == chQuestion || testChar == chPound)
break;
if (testChar == chPercent)
{
if (index+2 >= pathStrLen ||
!XMLString::isHex(pathStr[index+1]) ||
!XMLString::isHex(pathStr[index+2]))
return false;
}
else if (testChar==chSpace)
{
if(!bAllowSpaces)
return false;
}
else if (!isUnreservedCharacter(testChar) &&
((isOpaque && !isPathCharacter(testChar)) ||
(!isOpaque && !isReservedCharacter(testChar))))
{
return false;
}
index++;
}
// query - starts with ? and up to fragment or end
// fragment - starts with #
bool isQuery = (testChar == chQuestion);
if (isQuery || testChar == chPound)
{
index++;
while (index < pathStrLen)
{
testChar = pathStr[index];
if (testChar == chPound && isQuery) {
isQuery = false;
index++;
continue;
}
if (testChar == chPercent)
{
if (index+2 >= pathStrLen ||
!XMLString::isHex(pathStr[index+1]) ||
!XMLString::isHex(pathStr[index+2]))
return false;
}
else if (testChar==chSpace)
{
if(!bAllowSpaces)
return false;
}
else if (!isReservedOrUnreservedCharacter(testChar))
{
return false;
}
index++;
}
}
} //if (pathStrLen...)
return true;
}
/***
* [Bug7698]: filenames with embedded spaces in schemaLocation strings not handled properly
*
* This method is called when Scanner/TraverseSchema knows that the URI reference is
* for local file.
*
***/
void XMLUri::normalizeURI(const XMLCh* const systemURI,
XMLBuffer& normalizedURI)
{
const XMLCh* pszSrc = systemURI;
normalizedURI.reset();
while (*pszSrc) {
if ((*(pszSrc) == chPercent)
&& (*(pszSrc+1) == chDigit_2)
&& (*(pszSrc+2) == chDigit_0))
{
pszSrc += 3;
normalizedURI.append(chSpace);
}
else
{
normalizedURI.append(*pszSrc);
pszSrc++;
}
}
}
/***
* Support for Serialization/De-serialization
***/
IMPL_XSERIALIZABLE_TOCREATE(XMLUri)
void XMLUri::serialize(XSerializeEngine& serEng)
{
if (serEng.isStoring())
{
serEng<<fPort;
serEng.writeString(fScheme);
serEng.writeString(fUserInfo);
serEng.writeString(fHost);
serEng.writeString(fRegAuth);
serEng.writeString(fPath);
serEng.writeString(fQueryString);
serEng.writeString(fFragment);
serEng.writeString(fURIText);
}
else
{
serEng>>fPort;
serEng.readString(fScheme);
serEng.readString(fUserInfo);
serEng.readString(fHost);
serEng.readString(fRegAuth);
serEng.readString(fPath);
serEng.readString(fQueryString);
serEng.readString(fFragment);
serEng.readString(fURIText);
}
}
XMLUri::XMLUri(MemoryManager* const manager)
: fPort(-1)
, fScheme(0)
, fUserInfo(0)
, fHost(0)
, fRegAuth(0)
, fPath(0)
, fQueryString(0)
, fFragment(0)
, fURIText(0)
, fMemoryManager(manager)
{
}
XERCES_CPP_NAMESPACE_END