// ---------------------------------------------------------------------------
// LocalFileInputSource: InputSource interface implementation
// ---------------------------------------------------------------------------
BinInputStream* LocalFileInputSource::makeStream() const
{
BinFileInputStream* retStrm = new (getMemoryManager()) BinFileInputStream(getSystemId(), getMemoryManager());
if (!retStrm->getIsOpen())
{
delete retStrm;
return 0;
}
return retStrm;
}
BinInputStream *ZeroPaddedStdInInputSource::makeStream() const {
BinFileInputStream* retStream = new (getMemoryManager()) ZeroSeparatedBinFileInputStream(
XMLPlatformUtils::openStdInHandle(getMemoryManager())
);
if (!retStream->getIsOpen()) {
delete retStream;
return 0;
}
return retStream;
}
XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// StdInInputSource: Implementation of the input source interface
// ---------------------------------------------------------------------------
BinInputStream* StdInInputSource::makeStream() const
{
// Open a binary file stream for the standard input file handle
BinFileInputStream* retStream = new (getMemoryManager()) BinFileInputStream
(
XMLPlatformUtils::openStdInHandle(getMemoryManager())
);
if (!retStream->getIsOpen())
{
delete retStream;
return 0;
}
return retStream;
}
BinInputStream* XMLURL::makeNewStream() const
{
//
// If its a local host, then we short circuit it and use our own file
// stream support. Otherwise, we just let it fall through and let the
// installed network access object provide a stream.
//
if (fProtocol == XMLURL::File)
{
if (!fHost || !XMLString::compareIStringASCII(fHost, XMLUni::fgLocalHostString))
{
XMLCh* realPath = XMLString::replicate(fPath, fMemoryManager);
ArrayJanitor<XMLCh> basePathName(realPath, fMemoryManager);
//
// Need to manually replace any character reference %xx first
// HTTP protocol will be done automatically by the netaccessor
//
int end = XMLString::stringLen(realPath);
int percentIndex = XMLString::indexOf(realPath, chPercent, 0, fMemoryManager);
while (percentIndex != -1) {
if (percentIndex+2 >= end ||
!isHexDigit(realPath[percentIndex+1]) ||
!isHexDigit(realPath[percentIndex+2]))
{
XMLCh value1[4];
XMLString::moveChars(value1, &(realPath[percentIndex]), 3);
value1[3] = chNull;
ThrowXMLwithMemMgr2(MalformedURLException
, XMLExcepts::XMLNUM_URI_Component_Invalid_EscapeSequence
, realPath
, value1
, fMemoryManager);
}
unsigned int value = (xlatHexDigit(realPath[percentIndex+1]) * 16) + xlatHexDigit(realPath[percentIndex+2]);
realPath[percentIndex] = XMLCh(value);
int i =0;
for (i = percentIndex + 1; i < end - 2 ; i++)
realPath[i] = realPath[i+2];
realPath[i] = chNull;
end = i;
percentIndex = XMLString::indexOf(realPath, chPercent, percentIndex, fMemoryManager);
}
BinFileInputStream* retStrm = new (fMemoryManager) BinFileInputStream(realPath, fMemoryManager);
if (!retStrm->getIsOpen())
{
delete retStrm;
return 0;
}
return retStrm;
}
}
//
// If we don't have have an installed net accessor object, then we
// have to just throw here.
//
if (!XMLPlatformUtils::fgNetAccessor)
ThrowXMLwithMemMgr(MalformedURLException, XMLExcepts::URL_UnsupportedProto, fMemoryManager);
// Else ask the net accessor to create the stream
return XMLPlatformUtils::fgNetAccessor->makeNew(*this);
}
BinInputStream * XSECURIResolverGenericUnix::resolveURI(const XMLCh * uri) {
XSEC_USING_XERCES(BinInputStream);
XSEC_USING_XERCES(XMLUri);
XSEC_USING_XERCES(XMLUni);
XSEC_USING_XERCES(Janitor);
XSEC_USING_XERCES(BinFileInputStream);
XMLUri * xmluri;
if (uri == NULL) {
throw XSECException(XSECException::ErrorOpeningURI,
"XSECURIResolverGenericUnix - anonymous references not supported in default URI Resolvers");
}
// Create the appropriate XMLUri objects
if (mp_baseURI != NULL) {
XMLUri * turi;
#if XERCES_VERSION_MAJOR == 2 && XERCES_VERSION_MINOR < 3
// XMLUri relative paths are broken, so we need to strip out ".."
XSECAutoPtrXMLCh b(mp_baseURI);
XSECAutoPtrXMLCh r(uri);
int index = 0;
while (XMLString::startsWith(&(r.get()[index]), DOTDOT_SLASH)) {
// Strip the last segment of the base
int lastIndex = XMLString::lastIndexOf(b.get(), XERCES_CPP_NAMESPACE_QUALIFIER chForwardSlash);
if (lastIndex > 0)
const_cast<XMLCh*>(b.get())[lastIndex] = 0;
index += 3;
}
XSECnew(turi, XMLUri(b.get()));
Janitor<XMLUri> j_turi(turi);
XSECnew(xmluri, XMLUri(turi, &(r.get()[index])));
#else
XSECnew(turi, XMLUri(mp_baseURI));
Janitor<XMLUri> j_turi(turi);
XSECnew(xmluri, XMLUri(turi, uri));
#endif
}
else {
XSECnew(xmluri, XMLUri(uri));
}
Janitor<XMLUri> j_xmluri(xmluri);
// Determine what kind of URI this is and how to handle it.
if (!XMLString::compareIString(xmluri->getScheme(), gFileScheme)) {
// This is a file. We only really understand if this is localhost
// XMLUri has already cleaned of escape characters (%xx)
if (xmluri->getHost() == NULL || xmluri->getHost()[0] == chNull ||
!XMLString::compareIString(xmluri->getHost(), XMLUni::fgLocalHostString)) {
// Clean hex escapes
XMLCh * realPath = cleanURIEscapes(xmluri->getPath());
// Localhost
BinFileInputStream* retStrm = new BinFileInputStream(realPath);
XSEC_RELEASE_XMLCH(realPath);
if (!retStrm->getIsOpen())
{
delete retStrm;
return 0;
}
return retStrm;
}
else {
throw XSECException(XSECException::ErrorOpeningURI,
"XSECURIResolverGenericUnix - unable to open non-localhost file");
}
}
// Is the scheme a HTTP?
if (!XMLString::compareIString(xmluri->getScheme(), gHttpScheme)) {
// Pass straight to our local XSECBinHTTPUriInputStream
XSECBinHTTPURIInputStream *ret;
XSECnew(ret, XSECBinHTTPURIInputStream(*xmluri));
return ret;
}
throw XSECException(XSECException::ErrorOpeningURI,
"XSECURIResolverGenericUnix - unknown URI scheme");
}