xsec/xenc/impl/XENCCipherReferenceImpl.cpp

/**
 * 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.
 */

/*
 * XSEC
 *
 * XENCCipherReference := Implementation for CipherReference element
 *
 * $Id$
 *
 */

#include <xsec/dsig/DSIGTransformList.hpp>
#include <xsec/dsig/DSIGReference.hpp>
#include <xsec/dsig/DSIGTransformList.hpp>
#include <xsec/dsig/DSIGTransformBase64.hpp>
#include <xsec/dsig/DSIGTransformXPath.hpp>
#include <xsec/dsig/DSIGTransformXPathFilter.hpp>
#include <xsec/dsig/DSIGTransformXSL.hpp>
#include <xsec/dsig/DSIGTransformC14n.hpp>
#include <xsec/framework/XSECDefs.hpp>
#include <xsec/framework/XSECEnv.hpp>
#include <xsec/framework/XSECError.hpp>
#include <xsec/utils/XSECSafeBufferFormatter.hpp>

#include "XENCCipherReferenceImpl.hpp"
#include "../../utils/XSECDOMUtils.hpp"

#include <xercesc/util/XMLUniDefs.hpp>
#include <xercesc/util/Janitor.hpp>


XERCES_CPP_NAMESPACE_USE

// --------------------------------------------------------------------------------
//			String Constants
// --------------------------------------------------------------------------------

static XMLCh s_CipherReference[] = {

	chLatin_C,
	chLatin_i,
	chLatin_p,
	chLatin_h,
	chLatin_e,
	chLatin_r,
	chLatin_R,
	chLatin_e,
	chLatin_f,
	chLatin_e,
	chLatin_r,
	chLatin_e,
	chLatin_n,
	chLatin_c,
	chLatin_e,
	chNull
};

static XMLCh s_Transforms[] = {

	chLatin_T,
	chLatin_r,
	chLatin_a,
	chLatin_n,
	chLatin_s,
	chLatin_f,
	chLatin_o,
	chLatin_r,
	chLatin_m,
	chLatin_s,
	chNull
};

XENCCipherReference* XENCCipherReference::create(const XSECEnv* env, const XMLCh * URI)
{

	XENCCipherReferenceImpl* ret = new XENCCipherReferenceImpl(env);
	if (!ret)
		throw XSECException(XSECException::MemoryAllocationFail);
	ret->createBlankCipherReference(URI);
	return ret;
}

// --------------------------------------------------------------------------------
//			Constructors/Destructors
// --------------------------------------------------------------------------------

XENCCipherReferenceImpl::XENCCipherReferenceImpl(const XSECEnv * env) :
mp_env(env),
mp_cipherReferenceElement(NULL),
mp_uriAttr(NULL),
mp_transformsElement(NULL),
mp_transformList(NULL) {

}

XENCCipherReferenceImpl::XENCCipherReferenceImpl(const XSECEnv * env, DOMElement * node) :
mp_env(env),
mp_cipherReferenceElement(node),
mp_uriAttr(NULL),
mp_transformsElement(NULL),
mp_transformList(NULL) {

}


XENCCipherReferenceImpl::~XENCCipherReferenceImpl() {

	if (mp_transformList != NULL)
		delete mp_transformList;

}

// --------------------------------------------------------------------------------
//           Creation of Transforms
// --------------------------------------------------------------------------------

void XENCCipherReferenceImpl::createTransformList(void) {

	// Creates the transforms list
	safeBuffer str;
	const XMLCh * prefix;
	DOMDocument *doc = mp_env->getParentDocument();

	prefix = mp_env->getXENCNSPrefix();
	
	if (mp_transformsElement == NULL) {

		// Need to create a transforms node
		makeQName(str, prefix, "Transforms");
		mp_transformsElement = doc->createElementNS(DSIGConstants::s_unicodeStrURIXENC, str.rawXMLChBuffer());
		mp_env->doPrettyPrint(mp_cipherReferenceElement);
		mp_cipherReferenceElement->appendChild(mp_transformsElement);
		mp_env->doPrettyPrint(mp_transformsElement);
		mp_env->doPrettyPrint(mp_cipherReferenceElement);

		// Create the list
		XSECnew(mp_transformList, DSIGTransformList());
	}

}

void XENCCipherReferenceImpl::addTransform(DSIGTransform * txfm, DOMElement * txfmElt) {

	if (mp_transformList == NULL)
		createTransformList();

	mp_transformsElement->appendChild(txfmElt);
	mp_env->doPrettyPrint(mp_transformsElement);

	mp_transformList->addTransform(txfm);
}


DSIGTransformBase64 * XENCCipherReferenceImpl::appendBase64Transform() {

	DOMElement *txfmElt;
	DSIGTransformBase64 * txfm;

	XSECnew(txfm, DSIGTransformBase64(mp_env));
	txfmElt = txfm->createBlankTransform(mp_env->getParentDocument());

	addTransform(txfm, txfmElt);

	return txfm;

}

DSIGTransformXSL * XENCCipherReferenceImpl::appendXSLTransform(DOMNode * stylesheet) {

	DOMElement *txfmElt;
	DSIGTransformXSL * txfm;

	XSECnew(txfm, DSIGTransformXSL(mp_env));
	txfmElt = txfm->createBlankTransform(mp_env->getParentDocument());
	txfm->setStylesheet(stylesheet);

	addTransform(txfm, txfmElt);

	return txfm;

}

DSIGTransformC14n * XENCCipherReferenceImpl::appendCanonicalizationTransform(const XMLCh* uri) {

	DOMElement *txfmElt;
	DSIGTransformC14n * txfm;

	XSECnew(txfm, DSIGTransformC14n(mp_env));
	txfmElt = txfm->createBlankTransform(mp_env->getParentDocument());
	txfm->setCanonicalizationMethod(uri);

	addTransform(txfm, txfmElt);

	return txfm;

}	

DSIGTransformXPath * XENCCipherReferenceImpl::appendXPathTransform(const char * expr) {

	DOMElement *txfmElt;
	DSIGTransformXPath * txfm;

	XSECnew(txfm, DSIGTransformXPath(mp_env));
	txfmElt = txfm->createBlankTransform(mp_env->getParentDocument());
	txfm->setExpression(expr);

	addTransform(txfm, txfmElt);

	return txfm;
}

DSIGTransformXPathFilter * XENCCipherReferenceImpl::appendXPathFilterTransform(void) {

	DOMElement *txfmElt;
	DSIGTransformXPathFilter * txfm;

	XSECnew(txfm, DSIGTransformXPathFilter(mp_env));
	txfmElt = txfm->createBlankTransform(mp_env->getParentDocument());

	addTransform(txfm, txfmElt);
	mp_env->doPrettyPrint(txfmElt);

	return txfm;
}

// --------------------------------------------------------------------------------
//			Load
// --------------------------------------------------------------------------------

void XENCCipherReferenceImpl::load(void) {

	if (mp_cipherReferenceElement == NULL) {

		// Attempt to load an empty encryptedType element
		throw XSECException(XSECException::CipherReferenceError,
			"XENCCipherReference::load - called on empty DOM");

	}

	if (!strEquals(getXENCLocalName(mp_cipherReferenceElement), s_CipherReference)) {
	
		throw XSECException(XSECException::CipherReferenceError,
			"XENCCipherReference::load - called incorrect node");
	
	}

	// Find the URI attribute
	mp_uriAttr = mp_cipherReferenceElement->getAttributeNodeNS(NULL, DSIGConstants::s_unicodeStrURI);

	if (mp_uriAttr == NULL) {

		throw XSECException(XSECException::CipherReferenceError,
			"XENCCipherReference::load - URI attribute not found");
	
	}

	// See if there are any transforms
	DOMElement * c = findFirstElementChild(mp_cipherReferenceElement);
	if (c != NULL) {

		if (!strEquals(getXENCLocalName(c), s_Transforms)) {

			throw XSECException(XSECException::CipherReferenceError,
				"XENCCipherReference::load - Expected Transforms, found something else");

		}

		mp_transformsElement = c;

		XSECSafeBufferFormatter * formatter;
		XSECnew(formatter, XSECSafeBufferFormatter("UTF-8",XMLFormatter::NoEscapes, 
												XMLFormatter::UnRep_CharRef));
		Janitor<XSECSafeBufferFormatter> j_formatter(formatter);

		mp_transformList = DSIGReference::loadTransforms(c, formatter, mp_env);

	}


}

// --------------------------------------------------------------------------------
//			Create a blank structure
// --------------------------------------------------------------------------------

DOMElement * XENCCipherReferenceImpl::createBlankCipherReference(
						const XMLCh * URI) {

	// Clean up
	if (mp_transformList != NULL) {
		delete mp_transformList;
		mp_transformList = NULL;
	}

	mp_uriAttr = NULL;

	// Get some setup values
	safeBuffer str;
	DOMDocument *doc = mp_env->getParentDocument();
	const XMLCh * prefix = mp_env->getXENCNSPrefix();

	makeQName(str, prefix, s_CipherReference);

	mp_cipherReferenceElement = doc->createElementNS(DSIGConstants::s_unicodeStrURIXENC, str.rawXMLChBuffer());

	// Set the URI Attribute
	mp_cipherReferenceElement->setAttributeNS(NULL, DSIGConstants::s_unicodeStrURI, URI);

	// Find the URI
	mp_uriAttr = mp_cipherReferenceElement->getAttributeNodeNS(NULL, DSIGConstants::s_unicodeStrURI);

	if (mp_uriAttr == NULL) {

		throw XSECException(XSECException::CipherReferenceError,
			"XENCCipherReference::createBlankReference - URI attribute not found after creation");
	
	}

	return mp_cipherReferenceElement;

}

// --------------------------------------------------------------------------------
//			Get Interface methods
// --------------------------------------------------------------------------------

DSIGTransformList * XENCCipherReferenceImpl::getTransforms(void) const {

	return mp_transformList;

}

const XMLCh * XENCCipherReferenceImpl::getURI (void) const {

	if (mp_uriAttr != NULL)
		return mp_uriAttr->getNodeValue();

	return NULL;

}

DOMElement * XENCCipherReferenceImpl::getElement(void) const {

	return mp_cipherReferenceElement;

}