/*
* Copyright 2004,2005 The Apache Software Foundation.
*
* Licensed 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.
*/
package org.apache.axis2.handlers.addressing;
import org.apache.axiom.om.OMAttribute;
import org.apache.axiom.soap.SOAP12Constants;
import org.apache.axiom.soap.SOAPHeader;
import org.apache.axiom.soap.SOAPHeaderBlock;
import org.apache.axis2.AxisFault;
import org.apache.axis2.addressing.AddressingConstants;
import org.apache.axis2.addressing.EndpointReference;
import org.apache.axis2.addressing.EndpointReferenceHelper;
import org.apache.axis2.addressing.AddressingFaultsHelper;
import org.apache.axis2.addressing.RelatesTo;
import org.apache.axis2.client.Options;
import org.apache.axis2.context.MessageContext;
import org.apache.axis2.util.JavaUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import javax.xml.namespace.QName;
import java.util.ArrayList;
import java.util.Iterator;
public abstract class AddressingInHandler extends AddressingHandler implements AddressingConstants {
private static final long serialVersionUID = 3907988439637261572L;
private static final Log log = LogFactory.getLog(AddressingInHandler.class);
private static final boolean isDebugEnabled = log.isDebugEnabled();
public InvocationResponse invoke(MessageContext msgContext) throws AxisFault {
// if another handler has already processed the addressing headers, do not do anything here.
if (JavaUtils.isTrueExplicitly(msgContext.getProperty(IS_ADDR_INFO_ALREADY_PROCESSED))) {
if(isDebugEnabled) {
log.debug("Another handler has processed the addressing headers. Nothing to do here.");
}
return InvocationResponse.CONTINUE;
}
// check whether someone has explicitly set which addressing handler should run.
String namespace = (String) msgContext.getProperty(WS_ADDRESSING_VERSION);
if (namespace == null) {
namespace = addressingNamespace;
}
else if (!namespace.equals(addressingNamespace)) {
if(isDebugEnabled) {
log.debug("This addressing handler does not match the specified namespace, " + namespace);
}
return InvocationResponse.CONTINUE;
}
SOAPHeader header = null;
if(msgContext.isHeaderPresent()) {
header = msgContext.getEnvelope().getHeader();
}
// if there are not headers put a flag to disable addressing temporary
if (header == null) {
msgContext.setProperty(DISABLE_ADDRESSING_FOR_OUT_MESSAGES, Boolean.TRUE);
return InvocationResponse.CONTINUE;
}
if(isDebugEnabled) {
log.debug("Starting " + addressingVersion + " IN handler ...");
}
ArrayList addressingHeaders;
addressingHeaders = header.getHeaderBlocksWithNSURI(namespace);
if (addressingHeaders != null && addressingHeaders.size() > 0) {
msgContext.setProperty(WS_ADDRESSING_VERSION, namespace);
msgContext.setProperty(DISABLE_ADDRESSING_FOR_OUT_MESSAGES, Boolean.FALSE);
if(isDebugEnabled) {
log.debug(addressingVersion + " Headers present in the SOAP message. Starting to process ...");
}
extractAddressingInformation(header, msgContext, addressingHeaders, namespace);
msgContext.setProperty(IS_ADDR_INFO_ALREADY_PROCESSED, Boolean.TRUE);
} else {
msgContext.setProperty(DISABLE_ADDRESSING_FOR_OUT_MESSAGES, Boolean.TRUE);
if(isDebugEnabled) {
log.debug("No Headers present corresponding to " + addressingVersion);
}
}
return InvocationResponse.CONTINUE;
}
protected Options extractAddressingInformation(SOAPHeader header, MessageContext messageContext,
ArrayList addressingHeaders, String namespace) throws AxisFault {
Options messageContextOptions = messageContext.getOptions();
ArrayList checkedHeaderNames = new ArrayList(7); // Up to 7 header names to be recorded
ArrayList duplicateHeaderNames = new ArrayList(1); // Normally will not be used for more than 1 header
// Per the SOAP Binding spec "headers with an incorrect cardinality MUST NOT be used" So these variables
// are used to keep track of invalid cardinality headers so they are not deserialised.
boolean ignoreTo = false, ignoreFrom = false, ignoreReplyTo = false, ignoreFaultTo = false, ignoreMessageID = false, ignoreAction = false;
// First pass just check for duplicates
Iterator addressingHeadersIt = addressingHeaders.iterator();
while (addressingHeadersIt.hasNext()) {
SOAPHeaderBlock soapHeaderBlock = (SOAPHeaderBlock) addressingHeadersIt.next();
if (SOAP12Constants.SOAP_ROLE_NONE.equals(soapHeaderBlock.getRole()))
continue;
if (WSA_TO.equals(soapHeaderBlock.getLocalName())) {
ignoreTo = checkDuplicateHeaders(WSA_TO, checkedHeaderNames, duplicateHeaderNames);
} else if (WSA_FROM.equals(soapHeaderBlock.getLocalName())) {
ignoreFrom = checkDuplicateHeaders(WSA_FROM, checkedHeaderNames, duplicateHeaderNames);
} else if (WSA_REPLY_TO.equals(soapHeaderBlock.getLocalName())) {
ignoreReplyTo = checkDuplicateHeaders(WSA_REPLY_TO, checkedHeaderNames, duplicateHeaderNames);
} else if (WSA_FAULT_TO.equals(soapHeaderBlock.getLocalName())) {
ignoreFaultTo = checkDuplicateHeaders(WSA_FAULT_TO, checkedHeaderNames, duplicateHeaderNames);
} else if (WSA_MESSAGE_ID.equals(soapHeaderBlock.getLocalName())) {
ignoreMessageID = checkDuplicateHeaders(WSA_MESSAGE_ID, checkedHeaderNames, duplicateHeaderNames);
} else if (WSA_ACTION.equals(soapHeaderBlock.getLocalName())) {
ignoreAction = checkDuplicateHeaders(WSA_ACTION, checkedHeaderNames, duplicateHeaderNames);
}
}
// Now extract information
Iterator addressingHeadersIt2 = addressingHeaders.iterator();
while (addressingHeadersIt2.hasNext()) {
SOAPHeaderBlock soapHeaderBlock = (SOAPHeaderBlock) addressingHeadersIt2.next();
if (SOAP12Constants.SOAP_ROLE_NONE.equals(soapHeaderBlock.getRole()))
continue;
if (WSA_TO.equals(soapHeaderBlock.getLocalName()) && !ignoreTo) {
extractToEPRInformation(soapHeaderBlock, messageContextOptions, header, namespace);
} else if (WSA_FROM.equals(soapHeaderBlock.getLocalName()) && !ignoreFrom) {
extractFromEPRInformation(soapHeaderBlock, namespace, messageContext);
} else if (WSA_REPLY_TO.equals(soapHeaderBlock.getLocalName()) && !ignoreReplyTo) {
extractReplyToEPRInformation(soapHeaderBlock, namespace, messageContext);
} else if (WSA_FAULT_TO.equals(soapHeaderBlock.getLocalName()) && !ignoreFaultTo) {
extractFaultToEPRInformation(soapHeaderBlock, namespace, messageContext);
} else if (WSA_MESSAGE_ID.equals(soapHeaderBlock.getLocalName()) && !ignoreMessageID) {
messageContextOptions.setMessageId(soapHeaderBlock.getText());
soapHeaderBlock.setProcessed();
} else if (WSA_ACTION.equals(soapHeaderBlock.getLocalName()) && !ignoreAction) {
extractActionInformation(soapHeaderBlock, namespace, messageContext);
} else if (WSA_RELATES_TO.equals(soapHeaderBlock.getLocalName())) {
extractRelatesToInformation(soapHeaderBlock, namespace, messageContextOptions);
}
}
// Now that all the valid wsa headers have been read, throw an exception if there was an invalid cardinality
// This means that if for example there are multiple MessageIDs and a FaultTo, the FaultTo will be respected.
if(!duplicateHeaderNames.isEmpty()){
// Simply choose the first problem header we came across as we can only fault for one of them.
AddressingFaultsHelper.triggerInvalidCardinalityFault(messageContext, (String)duplicateHeaderNames.get(0));
}
// check for the presence of madatory addressing headers
checkForMandatoryHeaders(checkedHeaderNames, messageContext);
// provide default values for headers that have not been found.
setDefaults(checkedHeaderNames, messageContext);
return messageContextOptions;
}
protected abstract void checkForMandatoryHeaders(ArrayList alreadyFoundAddrHeader, MessageContext messageContext) throws AxisFault;
protected abstract void setDefaults(ArrayList alreadyFoundAddrHeader, MessageContext messageContext) throws AxisFault;
private boolean checkDuplicateHeaders(String addressingHeaderName, ArrayList checkedHeaderNames, ArrayList duplicateHeaderNames) {//throws AxisFault {
// If the header name has been seen before then we should return true and add it to the list
// of duplicate header names. Otherwise it is the first time we've seen the header so add it
// to the checked liat and return false.
boolean shouldIgnore = checkedHeaderNames.contains(addressingHeaderName);
if(shouldIgnore){
duplicateHeaderNames.add(addressingHeaderName);
}else{
checkedHeaderNames.add(addressingHeaderName);
}
return shouldIgnore;
}
protected abstract void extractToEprReferenceParameters(EndpointReference toEPR, SOAPHeader header, String namespace);
private void extractRelatesToInformation(SOAPHeaderBlock soapHeaderBlock, String addressingNamespace, Options messageContextOptions) {
String address = soapHeaderBlock.getText();
OMAttribute relationshipType =
soapHeaderBlock.getAttribute(
new QName(AddressingConstants.WSA_RELATES_TO_RELATIONSHIP_TYPE));
String relationshipTypeDefaultValue =
Submission.WSA_NAMESPACE.equals(addressingNamespace)
? Submission.WSA_DEFAULT_RELATIONSHIP_TYPE
: Final.WSA_DEFAULT_RELATIONSHIP_TYPE;
RelatesTo relatesTo =
new RelatesTo(
address,
relationshipType == null
? relationshipTypeDefaultValue
: relationshipType.getAttributeValue());
messageContextOptions.addRelatesTo(relatesTo);
soapHeaderBlock.setProcessed();
}
private void extractFaultToEPRInformation(SOAPHeaderBlock soapHeaderBlock, String addressingNamespace, MessageContext messageContext) throws AxisFault {
Options messageContextOptions = messageContext.getOptions();
EndpointReference epr = messageContextOptions.getFaultTo();
if (epr == null) {
epr = new EndpointReference("");
messageContextOptions.setFaultTo(epr);
}
extractEPRInformation(soapHeaderBlock, epr, addressingNamespace, messageContext);
soapHeaderBlock.setProcessed();
}
private void extractReplyToEPRInformation(SOAPHeaderBlock soapHeaderBlock, String addressingNamespace, MessageContext messageContext) throws AxisFault {
Options messageContextOptions = messageContext.getOptions();
EndpointReference epr = messageContextOptions.getReplyTo();
if (epr == null) {
epr = new EndpointReference("");
messageContextOptions.setReplyTo(epr);
}
extractEPRInformation(soapHeaderBlock, epr, addressingNamespace, messageContext);
soapHeaderBlock.setProcessed();
}
private void extractFromEPRInformation(SOAPHeaderBlock soapHeaderBlock, String addressingNamespace, MessageContext messageContext) throws AxisFault {
Options messageContextOptions = messageContext.getOptions();
EndpointReference epr = messageContextOptions.getFrom();
if (epr == null) {
epr = new EndpointReference(""); // I don't know the address now. Let me pass the empty string now and fill this
// once I process the Elements under this.
messageContextOptions.setFrom(epr);
}
extractEPRInformation(soapHeaderBlock, epr, addressingNamespace, messageContext);
soapHeaderBlock.setProcessed();
}
private void extractToEPRInformation(SOAPHeaderBlock soapHeaderBlock, Options messageContextOptions, SOAPHeader header, String namespace) {
EndpointReference epr;
//here the addressing epr overidde what ever already there in the message context
epr = new EndpointReference(soapHeaderBlock.getText());
messageContextOptions.setTo(epr);
// check for reference parameters
extractToEprReferenceParameters(epr, header, namespace);
soapHeaderBlock.setProcessed();
}
//We assume that any action that already exists in the message context must be the
//soapaction. We compare that action to the WS-Addressing action, and if they are
//different we throw a fault.
private void extractActionInformation(SOAPHeaderBlock soapHeaderBlock, String addressingNamespace, MessageContext messageContext) throws AxisFault {
Options messageContextOptions = messageContext.getOptions();
String soapAction = messageContextOptions.getAction();
if (soapAction != null && !"".equals(soapAction)) {
if (!soapAction.equals(soapHeaderBlock.getText())) {
AddressingFaultsHelper.triggerActionMismatchFault(messageContext);
}
}
else {
messageContextOptions.setAction(soapHeaderBlock.getText());
}
soapHeaderBlock.setProcessed();
}
/**
* Given the soap header block, this should extract the information within EPR.
*
* @param headerBlock
* @param epr
* @param addressingNamespace
*/
private void extractEPRInformation(SOAPHeaderBlock headerBlock, EndpointReference epr, String addressingNamespace, MessageContext messageContext) throws AxisFault {
try {
EndpointReferenceHelper.fromOM(epr, headerBlock, addressingNamespace);
}
catch (AxisFault af) {
AddressingFaultsHelper.triggerMissingAddressInEPRFault(messageContext, headerBlock.getLocalName());
}
}
}