/*
* 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.
*/
package org.apache.axis2.jaxws.handler;
import org.apache.axiom.soap.RolePlayer;
import org.apache.axiom.soap.SOAP11Constants;
import org.apache.axiom.soap.SOAP12Constants;
import org.apache.axiom.soap.SOAPConstants;
import org.apache.axiom.soap.SOAPEnvelope;
import org.apache.axiom.soap.SOAPHeaderBlock;
import org.apache.axis2.AxisFault;
import org.apache.axis2.Constants;
import org.apache.axis2.context.MessageContext;
import org.apache.axis2.context.OperationContext;
import org.apache.axis2.description.AxisService;
import org.apache.axis2.description.Parameter;
import org.apache.axis2.i18n.Messages;
import org.apache.axis2.jaxws.description.EndpointDescription;
import org.apache.axis2.util.JavaUtils;
import org.apache.axis2.util.LoggingControl;
import org.apache.axis2.wsdl.WSDLConstants;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import javax.xml.namespace.QName;
import javax.xml.ws.handler.Handler;
import javax.xml.ws.handler.soap.SOAPHandler;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
/*
* Utility class to perform static utility type of operations on Handlers.
*/
public class HandlerUtils {
private static Log log = LogFactory.getLog(HandlerUtils.class);
/**
* registerHandlerHeaders will invoke getHeaders on SOAPHandlers and return a List of headers
* that are Understood by the handlers.
* @param msgContext
* @param handlers
*/
public static List<QName> registerSOAPHandlerHeaders(MessageContext msgContext, List<Handler> handlers){
List<QName> understood = new ArrayList<QName>();
if(msgContext == null){
return understood;
}
for(Handler handler:handlers){
if(handler instanceof SOAPHandler){
SOAPHandler soapHandler = (SOAPHandler)handler;
//Invoking getHeaders.
if(log.isDebugEnabled()){
log.debug("Invoking getHeader() on SOAPHandler");
}
Set<QName> headers = soapHandler.getHeaders();
if(headers!=null){
for(QName header:headers){
if(!understood.contains(header)){
if(log.isDebugEnabled()){
log.debug("Adding Header QName" + header + " to uderstoodHeaderQName List");
}
//Adding this to understood header list.
understood.add(header);
}
}
}
}
}
return understood;
}
/**
* checkMustUnderstand will validate headers that where delegated by Axis Engine
* to MessageReceiver for mustUnderstand check.
*
* Note that there is other JAX-WS related mustUnderstand checking occuring elsewhere:
* @see org.apache.axis2.jaxws.dispatchers.MustUnderstandValidationDispatcher
* @see org.apache.axis2.jaxws.dispatchers.MustUnderstandChecker
*
* @param msgContext Contains the SOAPEnvelope and optionally a list of headers not
* understood by the AxisEngine
* @param understood A list of header QNames understood by JAX-WS, for example those understood
* by associated application handlers. Can be null.
* @param additionalRoles An instance of RolePlayer for any addtional roles played by JAX-WS
* for example, roles configured for associated handlers. Can be null.
*
* @throws AxisFault if any headers marked mustUndersand are not understood.
*/
public static void checkMustUnderstand(MessageContext msgContext, List<QName> understood, List<String> additionalRoles) throws AxisFault {
if (msgContext == null || !msgContext.isHeaderPresent()) {
return;
}
SOAPEnvelope envelope = msgContext.getEnvelope();
if (envelope.getHeader() == null) {
return;
}
if(log.isDebugEnabled()){
log.debug("Reading UnprocessedHeaderNames from Message Context properties");
}
List<QName> unprocessed = (List)msgContext.getProperty(Constants.UNPROCESSED_HEADER_QNAMES);
// Add to the unprocessed header list any headers that are unprocssed and mustUnderstand
// for addtional roles, for example those played by associated JAXWS handlers
if (additionalRoles != null) {
if (log.isDebugEnabled()) {
log.debug("Adding any mustUnderstand headers based on additonal SOAP roles: " + additionalRoles);
}
HandlerRolePlayer handlerRolePlayer = new HandlerRolePlayer(additionalRoles);
Iterator headerBlocks = envelope.getHeader().getHeadersToProcess(handlerRolePlayer);
while (headerBlocks.hasNext()) {
SOAPHeaderBlock shb = (SOAPHeaderBlock) headerBlocks.next();
if (unprocessed == null) {
unprocessed = new ArrayList<QName>();
}
if (!shb.isProcessed() && shb.getMustUnderstand()) {
unprocessed.add(shb.getQName());
if (log.isDebugEnabled()) {
log.debug("Added header to unprocessed list: " + shb.getQName());
}
}
}
}
if(unprocessed == null || unprocessed.size() == 0){
if(log.isDebugEnabled()){
log.debug("UNPROCESSED_HEADER_QNAMES not found.");
}
return;
}
//lets go thru each header only if @HandlerChain is present
if(!canUnderstand(msgContext)){
QName[] qNames = unprocessed.toArray(new QName[0]);
String[] headerNames = new String[qNames.length];
for(int i=0; i<qNames.length; i++){
headerNames[i] ="{" + qNames[i].getNamespaceURI()+ "}" + qNames[i].getLocalPart();
}
QName faultQName = envelope.getVersion().getMustUnderstandFaultCode();
throw new AxisFault(Messages.getMessage("mustunderstandfailed2", headerNames), faultQName);
}
checkUnprocessed(envelope, unprocessed, understood, msgContext);
//resetting the FAULTY_HEADER_QNAME to null.
msgContext.setProperty(Constants.UNPROCESSED_HEADER_QNAMES, null);
}
private static void checkUnprocessed(SOAPEnvelope envelope, List<QName> unprocessed, List<QName> understood, MessageContext msgContext) throws AxisFault{
for (QName headerQName : unprocessed) {
if (understood != null && !understood.isEmpty()) {
if (understood.contains(headerQName)) {
if (LoggingControl.debugLoggingAllowed && log.isDebugEnabled()) {
log.debug("MustUnderstand header registered as understood on AxisOperation: " + headerQName);
}
continue;
}
}
if (LoggingControl.debugLoggingAllowed && log.isDebugEnabled()) {
log.debug("MustUnderstand header not processed or registered as understood " + headerQName);
}
// Throw a MustUnderstand fault for the current SOAP version
String prefix = envelope.getNamespace().getPrefix();
if (!msgContext.isSOAP11()) {
if (prefix == null || "".equals(prefix)) {
prefix = SOAPConstants.SOAP_DEFAULT_NAMESPACE_PREFIX;
}
// TODO: should we be using a prefix on the faultcode? What about
// the QName object Constants.FAULT_SOAP12_MUSTUNDERSTAND?
throw new AxisFault(Messages.getMessage("mustunderstandfailed",
prefix,
headerQName.toString()),
SOAP12Constants.FAULT_CODE_MUST_UNDERSTAND);
} else {
// TODO: should we be using a prefix on the faultcode? What about
// the QName object Constants.FAULT_MUSTUNDERSTAND?
throw new AxisFault(Messages.getMessage("mustunderstandfailed",
prefix,
headerQName.toString()),
SOAP11Constants.FAULT_CODE_MUST_UNDERSTAND);
}
}
}
private static boolean canUnderstand(MessageContext msgContext){
//JAXWSMessageReceiver will only commit to handling must understand if @HandlerChain annotation is present on the
//Endpoint. This will indicate to AxisEngine that Faulty Header names are understood however the mustUnderstand
//Check will be performed in HandlerUtils class after Handlers are injected in application.
AxisService axisSvc = msgContext.getAxisService();
if (axisSvc.getParameter(EndpointDescription.AXIS_SERVICE_PARAMETER) != null) {
Parameter param = axisSvc.getParameter(EndpointDescription.AXIS_SERVICE_PARAMETER);
EndpointDescription ed = (EndpointDescription)param.getValue();
//Lets check if there is a Handler implementation present using Metadata layer.
//HandlerChain annotation can be present in Service Endpoint or ServiceEndpointInterface.
// ed.getHandlerChain() looks for HandlerAnnotation at both Endpoint and at SEI.
if(log.isDebugEnabled()){
log.debug("Check to see if a jaxws handler is configured.");
}
if(ed.getHandlerChain()!=null){
return true;
}
return false;
}
else{
//If we cannot get to ServiceDescription to check for HandlerChain annotation we will return true;
return true;
}
}
/**
* isHighFidelity
*
* The JAX-WS engine attempts to stream data as fast as possible.
* For example, the message payload may be transformed into a JAXB object early in the processing.
* Unfortunately such transformations are lossy, some information is lost.
* An installed SOAP handler will see different namespaces (etc) then the original message.
*
* If the a customer enables the "jaxws.payload.highFidelity" flag, then lossy transformations are
* avoided until necessary.
*
* @see Constants.JAXWS_HIGH_FIDELITY
*
* @param mc
* @return true if high fidelity is requested
*/
public static boolean isHighFidelity(MessageContext mc) {
boolean rc = _isHighFidelity(mc);
// If not true, check the OUT MessageContext.
// On the client, we need this setting when we receive (inbound)
// the message; however the customer set it on the outbound context.
if (!rc) {
rc = _isHighFidelity(getRelatedMessageContext(mc));
}
return rc;
}
/**
* @param mc
* @return
*/
private static MessageContext getRelatedMessageContext(MessageContext mc) {
if (log.isDebugEnabled()) {
log.debug("Enter getRelatedMessageContext for:" + mc);
}
MessageContext relatedMC = null;
if (mc != null) {
OperationContext oc = mc.getOperationContext();
if (oc != null) {
try {
relatedMC = oc.getMessageContext(WSDLConstants.MESSAGE_LABEL_IN_VALUE);
if (relatedMC == mc) {
relatedMC = oc.getMessageContext(WSDLConstants.MESSAGE_LABEL_OUT_VALUE);
}
} catch (AxisFault e) {
// TODO This should never occur in this scenario, swallow and continue
}
}
}
if (log.isDebugEnabled()) {
log.debug("Exit getRelatedMessageContext related messageContext is" + relatedMC);
}
return relatedMC;
}
/**
* isHighFidelity
*
* The JAX-WS engine attempts to stream data as fast as possible.
* For example, the message payload may be transformed into a JAXB object early in the processing.
* Unfortunately such transformations are lossy, some information is lost.
* An installed SOAP handler will see different namespaces (etc) then the original message.
*
* If the a customer enables the "jaxws.payload.highFidelity" flag, then lossy transformations are
* avoided until necessary.
*
* @see Constants.JAXWS_HIGH_FIDELITY
*
* @param mc
* @return true if high fidelity is requested
*/
private static boolean _isHighFidelity(MessageContext mc) {
boolean value = false;
if (mc == null) {
if (log.isDebugEnabled()) {
log.debug("_isHighFidelity returns false due to missing MessageContext");
}
return false;
}
// First examine the high fidelity flag on the context hierarchy
Boolean highFidelity = (Boolean) mc.getProperty(
org.apache.axis2.jaxws.Constants.JAXWS_PAYLOAD_HIGH_FIDELITY);
if (highFidelity != null) {
value = highFidelity.booleanValue();
if (log.isDebugEnabled()) {
log.debug("_isHighFidelity returns " + value + " per Context property " +
org.apache.axis2.jaxws.Constants.JAXWS_PAYLOAD_HIGH_FIDELITY);
}
return value;
}
// Second examine the deprecated jaxb streaming flag
Boolean jaxbStreaming = (Boolean) mc.getProperty(
org.apache.axis2.jaxws.Constants.JAXWS_ENABLE_JAXB_PAYLOAD_STREAMING);
if (jaxbStreaming != null) {
value = !jaxbStreaming.booleanValue();
if (log.isDebugEnabled()) {
log.debug("_isHighFidelity returns " + value + " per inspection of Context property " +
org.apache.axis2.jaxws.Constants.JAXWS_ENABLE_JAXB_PAYLOAD_STREAMING);
}
return value;
}
// Now look at the high fidelity parameter
Parameter p = mc.getParameter(org.apache.axis2.jaxws.Constants.JAXWS_PAYLOAD_HIGH_FIDELITY);
if (p != null) {
value = JavaUtils.isTrue(p.getValue());
if (log.isDebugEnabled()) {
log.debug("_isHighFidelity returns " + value + " per inspection of Configuration property " +
org.apache.axis2.jaxws.Constants.JAXWS_PAYLOAD_HIGH_FIDELITY);
}
return value;
}
if (log.isDebugEnabled()) {
log.debug("_isHighFidelity returns the default: false");
}
return false;
}
}
class HandlerRolePlayer implements RolePlayer {
List<String> roles = new ArrayList<String>();
HandlerRolePlayer(List<String> additionalRoles) {
roles.addAll(additionalRoles);
}
public List getRoles() {
return roles;
}
public boolean isUltimateDestination() {
return false;
}
}