modules/jaxws/src/org/apache/axis2/jaxws/spi/handler/BaseHandlerResolver.java

/*
 * 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.spi.handler;

import org.apache.axis2.java.security.AccessController;
import org.apache.axis2.jaxws.ExceptionFactory;
import org.apache.axis2.jaxws.description.impl.DescriptionUtils;
import org.apache.axis2.jaxws.description.xml.handler.HandlerChainType;
import org.apache.axis2.jaxws.description.xml.handler.HandlerChainsType;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import javax.xml.namespace.QName;
import javax.xml.ws.handler.HandlerResolver;
import javax.xml.ws.handler.PortInfo;
import java.io.InputStream;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * This class can be subclassed to produce different implementations of {@link HandlerResolver}
 *
 */
public abstract class BaseHandlerResolver implements HandlerResolver {

    private static Log log = LogFactory.getLog(BaseHandlerResolver.class);

    // TODO should probably use constants defined elsewhere
    protected static final Map<String, String> protocolBindingsMap =
        new HashMap<String, String>(5);

    protected HandlerChainsType handlerChainsType;
    
    protected BaseHandlerResolver() {
    }
    
    protected BaseHandlerResolver(String file) {
        ClassLoader classLoader = this.getClass().getClassLoader();
        String className = this.getClass().getName();
        InputStream is =
            DescriptionUtils.openHandlerConfigStream(file, className, classLoader);
        
        if(is == null) {
            log.warn("Unable to load handlers from file: " + file);                    
        } else {
            handlerChainsType = DescriptionUtils.loadHandlerChains(is, classLoader);
        }
    }
    
    protected static boolean chainResolvesToPort(HandlerChainType hct, PortInfo portinfo) {
        
        List<String> protocolBindings = hct.getProtocolBindings();
        if (protocolBindings != null) {
            boolean match = true;
            for (Iterator<String> it = protocolBindings.iterator() ; it.hasNext();) {
                match = false;  // default to false in the protocol bindings until we find a match
                String protocolBinding = it.next();
                protocolBinding = protocolBinding.startsWith("##") ? protocolBindingsMap.get(protocolBinding) : protocolBinding;
                // if the protocolBindingsMap returns null, it would mean someone has some nonsense ##binding
                if ((protocolBinding != null) && (protocolBinding.equals(portinfo.getBindingID()))) {
                    match = true;
                    break;
                }
            }
            if (match == false) {
                // we've checked all the protocolBindings, but didn't find a match, no need to continue
                return match;
            }
        }

        /*
         * need to figure out how to get the namespace declaration out of the port-name-pattern and service-name-pattern
         */
        
        if (!doesPatternMatch(portinfo.getPortName(), hct.getPortNamePattern())) {
                // we've checked the port-name-pattern, and didn't find a match, no need to continue
                return false;
        }
        
        if (!doesPatternMatch(portinfo.getServiceName(), hct.getServiceNamePattern())) {
                // we've checked the service-name-pattern, and didn't find a match, no need to continue
                return false;
        }

        return true;
    }
    
    protected static Class loadClass(String clazz) throws ClassNotFoundException {
        try {
            return forName(clazz, true, getContextClassLoader());
        } catch (ClassNotFoundException e) {
            throw e;
        }
    }
    
    /**
     * Returns true of the specified qName matches the pattern.
     * Some customers may have become dependent on the older
     * algorithm.  So first the "official" algorithm is used
     * and if that fails, the older algorithm is used.
     * @param qName QName
     * @param pattern QName
     * @return true or false
     */
    public static boolean doesPatternMatch(QName qName, QName pattern) {
        
        // Validate pattern only generates warnings if the pattern qname
        // does not align with the specification. 
        validatePattern(pattern);
        
        // Try the official pattern match algorithm
        boolean match = doesPatternMatch_Official(qName, pattern);
        
        // Customers may be dependent on the old algorithm, so this is retained.
        if (!match) {
            if (log.isDebugEnabled()) {
                log.debug("The offical matching algorithm failed.  Re-attempting with the prior algorithm");
            }
            match = doesPatternMatch_Old(qName, pattern);
            if (log.isDebugEnabled()) {
                log.debug("The old matching algorithm returns " + match);
            }
        }
        return match;
    }

    /**
     * The old match algorithm combines the namespace and localpart into
     * a single string to do the matching.  Unfortunately this will cause
     * the pure wildcard (*) pattern to fail.  And in addition, it may cause
     * other patterns to succeed.  Prefer the doesPatternMatch_Official algorithm
     * @param portInfoQName
     * @param pattern
     * @return
     */
    private static boolean doesPatternMatch_Old(QName portInfoQName, QName pattern) {
      if (pattern == null)
          return true;
     
      // build up the strings according to the regular expression defined at http://java.sun.com/xml/ns/javaee/javaee_web_services_1_2.xsd
      // use the prefix, not the literal namespace
      String portInfoPrefix = portInfoQName.getNamespaceURI(); //Prefix();
      String portInfoLocalPart = portInfoQName.getLocalPart();
      String portInfoString = ((portInfoPrefix == null) || (portInfoPrefix.equals(""))) ? "" : portInfoPrefix + ":";
      portInfoString += portInfoLocalPart;
      
      String patternStringPrefix = pattern.getNamespaceURI(); //Prefix();
      String patternInfoLocalPart = pattern.getLocalPart();
      String patternString = ((patternStringPrefix == null) || (patternStringPrefix.equals(""))) ? "" : patternStringPrefix + ":";
      patternString += patternInfoLocalPart;
      
      // now match the portInfoQName to the user pattern
      // But first, convert the user pattern to a regular expression.  Remember, the only non-QName character allowed is "*", which
      // is a wildcard, with obvious restrictions on what characters can match (for example, a .java filename cannot contain perentheses).
      // We'll just use part of the above reg ex to form the appropriate restrictions on the user-specified "*" character:
      Pattern userp = Pattern.compile(patternString.replace("*", "(\\w|\\.|-|_)*"));
      Matcher userm = userp.matcher(portInfoString);
      boolean match = userm.matches();
      if (log.isDebugEnabled()) {
          if (!match) {
              log.debug("Pattern match failed: \"" + portInfoString + "\" does not match \"" + patternString + "\"");
          } else {
              log.debug("Pattern match succeeded: \"" + portInfoString + "\" matches \"" + patternString + "\"");
          }
      }
      return match;
      
  }
    
    /**
     * Determine if the indicated qname matches the pattern
     * @param qName
     * @param pattern
     * @return
     */
    private static boolean doesPatternMatch_Official(QName qName, QName pattern) {
        if (log.isDebugEnabled()) {
            log.debug("entry pattern=" + pattern + " qname=" + qName);
        }
        if (pattern == null) {
            if (log.isDebugEnabled()) {
                log.debug("Successful Match: Pattern is null");
            }
            return true;
        }
        
        // Do a pattern match on the local part of the qname.
        String patternLocalPart = pattern.getLocalPart();
        String localPart = qName.getLocalPart();
        
        // Replace the wildcard (*) references in the QName with an appropriate regular expression.
        String regEx = patternLocalPart.replace("*", "(\\w|\\.|-|_)*");
        Pattern userp = Pattern.compile(regEx);
        Matcher userm = userp.matcher(localPart);
        boolean match = userm.matches();
        if (!match) {
            if (log.isDebugEnabled()) {
                log.debug("No Match: The local name does not match the regex pattern: " + regEx);
            }
            return false;
        } 
        
        
        // Now do the matching with the namespace.
        // If the entire pattern is a wildcard (*), then all namespaces are acceptable.
        // For example:
        //     <port-name-pattern>*</port-name-pattern>
        // 
        // In such cases, the assumption is that the pattern namespace will be empty.
        String patternNamespace = pattern.getNamespaceURI();
        String namespace = qName.getNamespaceURI();
        if (patternNamespace.length() == 0) {  // By definition, a namespace will never be null.
            if (log.isDebugEnabled()) {
                log.debug("Successful Match: The local name matches and the pattern namespace is empty.");
            }
            return true;
        }
        
        // If a namespace is specified, it will be done via a prefix.  For example:
        //    <port-name-pattern>p:MyPortName</port-name-pattern>
        // Thus according to the current pattern structure there is no way to 
        // specify wildcards for the namespace portion of the match
        if (patternNamespace.equals(namespace)) {
            if (log.isDebugEnabled()) {
                log.debug("Successful Match: The local names and namespaces match.");
            }
            return true;
        }
        
        if (log.isDebugEnabled()) {
            log.debug("No Match");
        }
        return false;   
    }
    
    
    private static void validatePattern(QName pattern) {
        if (pattern == null) {
            if (log.isDebugEnabled()) {
                log.debug("The pattern qname is null.  This is accepted and interpretted as a wildcard");
            }
            return;
        }
        String patternStringPrefix = pattern.getPrefix();
        String patternInfoLocalPart = pattern.getLocalPart();
        String patternString = ((patternStringPrefix == null) || (patternStringPrefix.equals(""))) ? "" : patternStringPrefix + ":";
        patternString += patternInfoLocalPart;

        /*
         * Below pattern is ported from:  http://java.sun.com/xml/ns/javaee/javaee_web_services_1_2.xsd
         * Schema regular expressions are defined differently from Java regular expressions which are different from Perl regular
         * expressions.  I've converted the pattern defined in the above linked schema to its Java equivalent, as best as I can.
         * 
         * Schema reg ex:  "\*|([\i-[:]][\c-[:]]*:)?[\i-[:]][\c-[:]]*\*?"
         * Java reg ex:  "\\*|((\\w|_)(\\w|\\.|-|_)*:)?(\\w|_)(\\w|\\.|-|_)*\\*?"
         */

        // first, confirm the defined pattern is legal
        Pattern p = Pattern.compile("\\*|((\\w|_)(\\w|\\.|-|_)*:)?(\\w|_)(\\w|\\.|-|_)*\\*?");
        Matcher m = p.matcher(patternString);
        if (!m.matches()) {
            // pattern defined by user in handler chain xml file is illegal -- report it but continue
            log.warn("Pattern defined by user is illegal:  \"" + patternString + "\" does not match regular expression in schema http://java.sun.com/xml/ns/javaee/javaee_web_services_1_2.xsd.  Pattern matching should now be considered \"best-effort.\"");
        }
    }

    /**
     * Return the class for this name
     *
     * @return Class
     */
    private static Class forName(final String className, final boolean initialize,
                                 final ClassLoader classLoader) throws ClassNotFoundException {
        // NOTE: This method must remain protected because it uses AccessController
        Class cl = null;
        try {
            cl = (Class)AccessController.doPrivileged(
                    new PrivilegedExceptionAction() {
                        public Object run() throws ClassNotFoundException {
                            try{
                                if (log.isDebugEnabled()) {
                                    log.debug("HandlerResolverImpl attempting to load Class: "+className);
                                }
                                return Class.forName(className, initialize, classLoader);
                            } catch (Throwable e) {
                                // TODO Should the exception be swallowed ?
                                if (log.isDebugEnabled()) {
                                    log.debug("HandlerResolverImpl cannot load the following class Throwable Exception Occured: " + className);
                                }
                                throw new ClassNotFoundException("HandlerResolverImpl cannot load the following class Throwable Exception Occured:" + className);
                            }
                        }
                    }
            );
        } catch (PrivilegedActionException e) {
            if (log.isDebugEnabled()) {
                log.debug("Exception thrown from AccessController: " + e);
            }
            throw (ClassNotFoundException)e.getException();
        }

        return cl;
    }


    /** @return ClassLoader */
    private static ClassLoader getContextClassLoader() {
        // NOTE: This method must remain private because it uses AccessController
        ClassLoader cl = null;
        try {
            cl = (ClassLoader)AccessController.doPrivileged(
                    new PrivilegedExceptionAction() {
                        public Object run() throws ClassNotFoundException {
                            return Thread.currentThread().getContextClassLoader();
                        }
                    }
            );
        } catch (PrivilegedActionException e) {
            if (log.isDebugEnabled()) {
                log.debug("Exception thrown from AccessController: " + e);
            }
            throw ExceptionFactory.makeWebServiceException(e.getException());
        }

        return cl;
    }
    
    static {
        protocolBindingsMap.put("##SOAP11_HTTP",        "http://schemas.xmlsoap.org/wsdl/soap/http");
        protocolBindingsMap.put("##SOAP11_HTTP_MTOM",   "http://schemas.xmlsoap.org/wsdl/soap/http?mtom=true");
        protocolBindingsMap.put("##SOAP12_HTTP",        "http://www.w3.org/2003/05/soap/bindings/HTTP/");
        protocolBindingsMap.put("##SOAP12_HTTP_MTOM",   "http://www.w3.org/2003/05/soap/bindings/HTTP/?mtom=true");
        protocolBindingsMap.put("##XML_HTTP",           "http://www.w3.org/2004/08/wsdl/http");
    }
}