// ---------------------------------------------------------------------------
// This method assumes that currentNode is an xinclude element and parses
// it accordingly, acting on what it finds.
// ---------------------------------------------------------------------------
bool
XIncludeUtils::doDOMNodeXInclude(DOMNode *xincludeNode, DOMDocument *parsedDocument, XMLEntityHandler* entityResolver){
bool modifiedNode = false;
/* the relevant attributes to look for */
const XMLCh *href = NULL;
const XMLCh *parse = NULL;
const XMLCh *xpointer = NULL;
const XMLCh *encoding = NULL;
const XMLCh *accept = NULL;
const XMLCh *acceptlanguage = NULL;
DOMNode *includeParent = xincludeNode->getParentNode();
if(xincludeNode->hasAttributes()) {
/* get all the attributes of the node */
DOMNamedNodeMap *pAttributes = xincludeNode->getAttributes();
XMLSize_t nSize = pAttributes->getLength();
for(XMLSize_t i=0;i<nSize;++i) {
DOMAttr *pAttributeNode = (DOMAttr*) pAttributes->item(i);
const XMLCh *attrName = pAttributeNode->getName();
/* check each attribute against the potential useful names */
if (XMLString::equals(attrName, XIncludeUtils::fgXIIncludeHREFAttrName)){
href = pAttributeNode->getValue();
} else if (XMLString::equals(attrName, XIncludeUtils::fgXIIncludeParseAttrName)){
parse = pAttributeNode->getValue();
} else if (XMLString::equals(attrName, XIncludeUtils::fgXIIncludeXPointerAttrName)){
xpointer = pAttributeNode->getValue();
} else if (XMLString::equals(attrName, XIncludeUtils::fgXIIncludeEncodingAttrName)){
encoding = pAttributeNode->getValue();
} else if (XMLString::equals(attrName, XIncludeUtils::fgXIIncludeAcceptAttrName)){
accept = pAttributeNode->getValue();
} else if (XMLString::equals(attrName, XIncludeUtils::fgXIIncludeAcceptLanguageAttrName)){
acceptlanguage = pAttributeNode->getValue();
} else {
/* if any other attribute is in the xi namespace, it's an error */
const XMLCh *attrNamespaceURI = pAttributeNode->getNamespaceURI();
if (attrNamespaceURI && XMLString::equals(attrNamespaceURI, XIncludeUtils::fgXIIIncludeNamespaceURI)){
} else {
/* ignore - any other attribute is allowed according to spec,
and must be ignored */
}
}
}
}
// 3.1 xi:include Element
// The children property of the xi:include element may include a single xi:fallback element;
// the appearance of more than one xi:fallback element, an xi:include element,
// or any other element from the XInclude namespace is a fatal error.
DOMNode *child;
DOMElement *fallback = NULL;
for (child = xincludeNode->getFirstChild(); child != 0; child=child->getNextSibling()){
if(child->getNodeType()!=DOMNode::ELEMENT_NODE)
continue;
if ( isXIFallbackDOMNode(child) ){
if (fallback != NULL){
/* fatal error - there are more than one fallback children */
XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeMultipleFallbackElems,
parsedDocument->getDocumentURI(), parsedDocument->getDocumentURI());
return false;
}
fallback = (DOMElement*)child;
}
else if(isXIIncludeDOMNode(child) || XMLString::equals(child->getNamespaceURI(), XIncludeUtils::fgXIIIncludeNamespaceURI)) {
/* fatal error - an xi element different from xi:fallback is a child of xi:include */
XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeDisallowedChild,
child->getNodeName(), parsedDocument->getDocumentURI());
return false;
}
}
if (href == NULL){
/* this is an unrecoverable error until we have xpointer support -
if there is an xpointer, the current document is assumed
however, there is no xpointer support yet */
XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeNoHref,
NULL, parsedDocument->getDocumentURI());
return false;
}
/* set up the accept and accept-language values */
if (accept != NULL){
}
if (parse == NULL){
/* use the default, as specified */
parse = XIncludeUtils::fgXIIncludeParseAttrXMLValue;
}
if (xpointer != NULL){
/* not supported yet */
/* Note that finding an xpointer attr along with parse="text" is a Fatal Error
* - http://www.w3.org/TR/xinclude/#include-location */
XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeXPointerNotSupported,
NULL, href);
return false;
}
/* set up the href according to what has gone before */
XIncludeLocation hrefLoc(href);
XIncludeLocation relativeLocation(href);
const XMLCh *includeBase = xincludeNode->getBaseURI();
if (includeBase != NULL){
hrefLoc.prependPath(includeBase);
}
if (getBaseAttrValue(xincludeNode) != NULL){
relativeLocation.prependPath(getBaseAttrValue(xincludeNode));
}
/* Take the relevant action - we need to retrieve the target as a whole before
we can know if it was successful or not, therefore the do* methods do
not modify the parsedDocument. Swapping the results in is left to the
caller (i.e. here) */
DOMText *includedText = NULL;
DOMDocument *includedDoc = NULL;
if (XMLString::equals(parse, XIncludeUtils::fgXIIncludeParseAttrXMLValue)){
/* including a XML element */
includedDoc = doXIncludeXMLFileDOM(hrefLoc.getLocation(), relativeLocation.getLocation(), xincludeNode, parsedDocument, entityResolver);
} else if (XMLString::equals(parse, XIncludeUtils::fgXIIncludeParseAttrTextValue)){
/* including a text value */
includedText = doXIncludeTEXTFileDOM(hrefLoc.getLocation(), relativeLocation.getLocation(), encoding, xincludeNode, parsedDocument, entityResolver);
} else {
/* invalid parse attribute value - fatal error according to the specification */
XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeInvalidParseVal,
parse, parsedDocument->getDocumentURI());
return false;
}
RefVectorOf<DOMNode> delayedProcessing(12,false);
if (includedDoc == NULL && includedText == NULL){
/* there was an error - this is now a resource error
let's see if there is a fallback */
XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeIncludeFailedResourceError,
hrefLoc.getLocation(), parsedDocument->getDocumentURI());
if (includeParent == NULL){
includeParent = parsedDocument;
}
// we could be getting errors trying to insert elements at the root of the document, so we should use replaceChild;
// in order to handle multiple nodes, add them to a document fragment and use that to replace the original node
if (fallback){
/* baseURI fixups - see http://www.w3.org/TR/xinclude/#base for details. */
XMLUri parentURI(includeParent->getBaseURI());
XMLUri includedURI(fallback->getBaseURI());
if (fallback->hasChildNodes()){
DOMDocumentFragment* frag = parsedDocument->createDocumentFragment();
DOMNode *child = fallback->getFirstChild();
/* add the content of the fallback element, and remove the fallback elem itself */
for ( ; child != NULL ; child=child->getNextSibling()){
if (child->getNodeType() == DOMNode::DOCUMENT_TYPE_NODE){
continue;
}
DOMNode *newNode = parsedDocument->importNode(child, true);
/* if the paths differ we need to add a base attribute */
if (newNode->getNodeType()==DOMNode::ELEMENT_NODE && !XMLString::equals(parentURI.getPath(), includedURI.getPath())){
if (getBaseAttrValue(newNode) == NULL){
/* need to calculate the proper path difference to get the relativePath */
((DOMElement*)newNode)->setAttribute(fgXIBaseAttrName, getBaseAttrValue(fallback->getParentNode()));
} else {
/* the included node has base of its own which takes precedence */
XIncludeLocation xil(getBaseAttrValue(newNode));
if (getBaseAttrValue(fallback->getParentNode()) != NULL){
/* prepend any specific base modification of the xinclude node */
xil.prependPath(getBaseAttrValue(fallback->getParentNode()));
}
((DOMElement*)newNode)->setAttribute(fgXIBaseAttrName, xil.getLocation());
}
}
DOMNode *newChild = frag->appendChild(newNode);
// don't process the node now, wait until it is placed in the final position
delayedProcessing.addElement(newChild);
//parseDOMNodeDoingXInclude(newChild, parsedDocument, entityResolver);
}
includeParent->replaceChild(frag, xincludeNode);
frag->release();
for(XMLSize_t i=0;i<delayedProcessing.size();i++)
{
DOMNode* childNode=delayedProcessing.elementAt(i);
parseDOMNodeDoingXInclude(childNode, parsedDocument, entityResolver);
}
modifiedNode = true;
} else {
/* empty fallback element - simply remove it! */
includeParent->removeChild(xincludeNode);
modifiedNode = true;
}
} else {
XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeIncludeFailedNoFallback,
parsedDocument->getDocumentURI(), parsedDocument->getDocumentURI());
return false;
}
} else {
if (includedDoc){
/* record the successful include while we process the children */
addDocumentURIToCurrentInclusionHistoryStack(hrefLoc.getLocation());
DOMDocumentFragment* frag = parsedDocument->createDocumentFragment();
/* need to import the document prolog here */
DOMNode *child = includedDoc->getFirstChild();
for (; child != NULL; child = child->getNextSibling()) {
if (child->getNodeType() == DOMNode::DOCUMENT_TYPE_NODE)
continue;
// check for NOTATION or ENTITY clash
if(child->getNodeType()==DOMNode::ELEMENT_NODE && includedDoc->getDoctype()!=NULL) {
DOMNamedNodeMap *pAttributes = child->getAttributes();
XMLSize_t nSize = pAttributes->getLength();
for(XMLSize_t i=0;i<nSize;++i) {
DOMAttr *pAttributeNode = (DOMAttr*) pAttributes->item(i);
const DOMTypeInfo * typeInfo=pAttributeNode->getSchemaTypeInfo();
if(typeInfo && XMLString::equals(typeInfo->getTypeNamespace(), XMLUni::fgInfosetURIName)) {
if(XMLString::equals(typeInfo->getTypeName(), XMLUni::fgNotationString)) {
const XMLCh* notationName=pAttributeNode->getNodeValue();
DOMNotation* notat=(DOMNotation*)includedDoc->getDoctype()->getNotations()->getNamedItem(notationName);
// ensure we have a DTD
if(parsedDocument->getDoctype()==NULL)
parsedDocument->insertBefore(parsedDocument->createDocumentType(parsedDocument->getDocumentElement()->getNodeName(), NULL,NULL), parsedDocument->getFirstChild());
DOMNotation* myNotation=(DOMNotation*)parsedDocument->getDoctype()->getNotations()->getNamedItem(notationName);
if(myNotation==NULL)
{
// it's missing, add it
parsedDocument->getDoctype()->getNotations()->setNamedItem(parsedDocument->importNode(notat, true));
}
else if(XMLString::equals(myNotation->getPublicId(), notat->getPublicId()) &&
XMLString::equals(myNotation->getSystemId(), notat->getSystemId()) &&
XMLString::equals(myNotation->getBaseURI(), notat->getBaseURI()))
{
// it's duplicate, ignore it
}
else
{
// it's a conflict, report it
XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeConflictingNotation,
notationName, parsedDocument->getDocumentURI());
}
}
else if(XMLString::equals(typeInfo->getTypeName(), XMLUni::fgEntityString)) {
const XMLCh* entityName=pAttributeNode->getNodeValue();
DOMEntity* ent=(DOMEntity*)includedDoc->getDoctype()->getEntities()->getNamedItem(entityName);
// ensure we have a DTD
if(parsedDocument->getDoctype()==NULL)
parsedDocument->insertBefore(parsedDocument->createDocumentType(parsedDocument->getDocumentElement()->getNodeName(), NULL,NULL), parsedDocument->getFirstChild());
DOMEntity* myEnt=(DOMEntity*)parsedDocument->getDoctype()->getEntities()->getNamedItem(entityName);
if(myEnt==NULL)
{
// it's missing, add it
parsedDocument->getDoctype()->getEntities()->setNamedItem(parsedDocument->importNode(ent, true));
}
else if(XMLString::equals(myEnt->getPublicId(), ent->getPublicId()) &&
XMLString::equals(myEnt->getSystemId(), ent->getSystemId()) &&
XMLString::equals(myEnt->getBaseURI(), ent->getBaseURI()))
{
// it's duplicate, ignore it
}
else
{
// it's a conflict, report it
XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeConflictingEntity,
entityName, parsedDocument->getDocumentURI());
}
}
}
}
}
DOMNode *newNode = parsedDocument->importNode(child, true);
DOMNode *newChild = frag->appendChild(newNode);
// don't process the node now, wait until it is placed in the final position
delayedProcessing.addElement(newChild);
//parseDOMNodeDoingXInclude(newChild, parsedDocument, entityResolver);
}
includeParent->replaceChild(frag, xincludeNode);
frag->release();
for(XMLSize_t i=0;i<delayedProcessing.size();i++)
{
DOMNode* childNode=delayedProcessing.elementAt(i);
parseDOMNodeDoingXInclude(childNode, parsedDocument, entityResolver);
}
popFromCurrentInclusionHistoryStack(NULL);
modifiedNode = true;
} else if (includedText){
includeParent->replaceChild(includedText, xincludeNode);
modifiedNode = true;
}
}
if (includedDoc)
includedDoc->release();
return modifiedNode;
}
DOMElement*
SchemaInfo::getTopLevelComponent(const unsigned short compCategory,
const XMLCh* const compName,
const XMLCh* const name) {
if (compCategory >= C_Count)
return 0;
DOMElement* child = XUtil::getFirstChildElement(fSchemaRootElement);
if (!child)
return 0;
ValueVectorOf<DOMElement*>* compList = fTopLevelComponents[compCategory];
if (fTopLevelComponents[compCategory] == 0) {
compList= new (fMemoryManager) ValueVectorOf<DOMElement*>(16, fMemoryManager);
fTopLevelComponents[compCategory] = compList;
}
else {
unsigned int listLen = compList->size();
for (unsigned int i= 0; i < listLen; i++) {
child = compList->elementAt(i);
if (XMLString::equals(child->getAttribute(SchemaSymbols::fgATT_NAME), name))
return child;
}
}
DOMElement* redefParent = (DOMElement*) child->getParentNode();
// Parent is not "redefine"
if (!XMLString::equals(redefParent->getLocalName(),SchemaSymbols::fgELT_REDEFINE))
redefParent = 0;
while (child != 0) {
if (XMLString::equals(child->getLocalName(), compName)) {
compList->addElement(child);
if (XMLString::equals(child->getAttribute(SchemaSymbols::fgATT_NAME), name))
return child;
}
else if (XMLString::equals(child->getLocalName(),SchemaSymbols::fgELT_REDEFINE)
&& (!fFailedRedefineList || !fFailedRedefineList->containsElement(child))) { // if redefine
DOMElement* redefineChild = XUtil::getFirstChildElement(child);
while (redefineChild != 0) {
if ((!fFailedRedefineList || !fFailedRedefineList->containsElement(redefineChild))
&& XMLString::equals(redefineChild->getLocalName(), compName)) {
compList->addElement(redefineChild);
if (XMLString::equals(redefineChild->getAttribute(SchemaSymbols::fgATT_NAME), name))
return redefineChild;
}
redefineChild = XUtil::getNextSiblingElement(redefineChild);
}
}
child = XUtil::getNextSiblingElement(child);
if (child == 0 && redefParent) {
child = XUtil::getNextSiblingElement(redefParent);
redefParent = 0;
}
}
return child;
}
DOMElement*
SchemaInfo::getTopLevelComponent(const unsigned short compCategory,
const XMLCh* const compName,
const XMLCh* const name) {
if (compCategory >= C_Count)
return 0;
DOMElement* child = XUtil::getFirstChildElement(fSchemaRootElement);
if (!child)
return 0;
RefHashTableOf<DOMElement>* compList = fTopLevelComponents[compCategory];
if (fTopLevelComponents[compCategory] == 0) {
compList= new (fMemoryManager) RefHashTableOf<DOMElement>(17, false, fMemoryManager);
fTopLevelComponents[compCategory] = compList;
}
else {
DOMElement* cachedChild = compList->get(name);
if(cachedChild)
return cachedChild;
child = fLastTopLevelComponent[compCategory];
}
DOMElement* redefParent = (DOMElement*) child->getParentNode();
// Parent is not "redefine"
if (!XMLString::equals(redefParent->getLocalName(),SchemaSymbols::fgELT_REDEFINE))
redefParent = 0;
while (child != 0) {
fLastTopLevelComponent[compCategory]=child;
if (XMLString::equals(child->getLocalName(), compName)) {
const XMLCh* cName=child->getAttribute(SchemaSymbols::fgATT_NAME);
compList->put((void*)cName, child);
if (XMLString::equals(cName, name))
return child;
}
else if (XMLString::equals(child->getLocalName(),SchemaSymbols::fgELT_REDEFINE)
&& (!fFailedRedefineList || !fFailedRedefineList->containsElement(child))) { // if redefine
DOMElement* redefineChild = XUtil::getFirstChildElement(child);
while (redefineChild != 0) {
fLastTopLevelComponent[compCategory]=redefineChild;
if ((!fFailedRedefineList || !fFailedRedefineList->containsElement(redefineChild))
&& XMLString::equals(redefineChild->getLocalName(), compName)) {
const XMLCh* rName=redefineChild->getAttribute(SchemaSymbols::fgATT_NAME);
compList->put((void*)rName, redefineChild);
if (XMLString::equals(rName, name))
return redefineChild;
}
redefineChild = XUtil::getNextSiblingElement(redefineChild);
}
}
child = XUtil::getNextSiblingElement(child);
if (child == 0 && redefParent) {
child = XUtil::getNextSiblingElement(redefParent);
redefParent = 0;
}
}
return child;
}
Override::Override(const DOMElement* e, Category& log, const Override* base) : m_base(base), m_acl(NULL)
{
try {
// Load the property set.
load(e,log,this);
// Load any AccessControl provider.
loadACL(e,log);
// Handle nested Paths.
DOMElement* path = XMLHelper::getFirstChildElement(e,Path);
for (int i=1; path; ++i, path=XMLHelper::getNextSiblingElement(path,Path)) {
const XMLCh* n=path->getAttributeNS(NULL,name);
// Skip any leading slashes.
while (n && *n==chForwardSlash)
n++;
// Check for empty name.
if (!n || !*n) {
log.warn("skipping Path element (%d) with empty name attribute", i);
continue;
}
// Check for an embedded slash.
int slash=XMLString::indexOf(n,chForwardSlash);
if (slash>0) {
// Copy the first path segment.
XMLCh* namebuf=new XMLCh[slash + 1];
for (int pos=0; pos < slash; pos++)
namebuf[pos]=n[pos];
namebuf[slash]=chNull;
// Move past the slash in the original pathname.
n=n+slash+1;
// Skip any leading slashes again.
while (*n==chForwardSlash)
n++;
if (*n) {
// Create a placeholder Path element for the first path segment and replant under it.
DOMElement* newpath=path->getOwnerDocument()->createElementNS(shibspconstants::SHIB2SPCONFIG_NS,Path);
newpath->setAttributeNS(NULL,name,namebuf);
path->setAttributeNS(NULL,name,n);
path->getParentNode()->replaceChild(newpath,path);
newpath->appendChild(path);
// Repoint our locals at the new parent.
path=newpath;
n=path->getAttributeNS(NULL,name);
}
else {
// All we had was a pathname with trailing slash(es), so just reset it without them.
path->setAttributeNS(NULL,name,namebuf);
n=path->getAttributeNS(NULL,name);
}
delete[] namebuf;
}
Override* o=new Override(path,log,this);
pair<bool,const char*> name=o->getString("name");
char* dup=strdup(name.second);
for (char* pch=dup; *pch; pch++)
*pch=tolower(*pch);
if (m_map.count(dup)) {
log.warn("Skipping duplicate Path element (%s)",dup);
free(dup);
delete o;
continue;
}
m_map[dup]=o;
free(dup);
}
}
catch (exception&) {
delete m_acl;
for_each(m_map.begin(),m_map.end(),xmltooling::cleanup_pair<string,Override>());
throw;
}
}
