* Copyright (c) 2002, 2009 IBM Corporation, Parasoft and others.

* All rights reserved.   This program and the accompanying materials

* are made available under the terms of the Eclipse Public License v1.0

* which accompanies this distribution, and is available at

* http://www.eclipse.org/legal/epl-v10.html

*

* Contributors:

*   IBM      - Initial API and implementation

*   Parasoft - Initial API and implementation

*******************************************************************************/

* The WSDL validator will verify that the WSDL and associated XML schema definitions

* are in conformance with the profile.

*

* @version 1.0.1

* @author Peter Brittenham (peterbr@us.ibm.com)

* @author Jim Clune

* @author Graham Turrell (gturrell@uk.ibm.com)

* @author Neil Delima (nddelima@ca.ibm.com)

*/

  extends BaseValidatorImpl

  implements LogValidator

  /**

  * WSDL document.

  */

  private WSDLDocument wsdlDocument;

  /**

   * Log entry.

   */

  protected MessageEntry logEntry;

  protected Log log;

 

  private boolean testable;

  private AnalyzerConfig analyzerConfig;

  public void init(AnalyzerContext analyzerContext,

          ProfileAssertions assertions,

          ReportArtifact reportArtifact,

          AnalyzerConfig analyzerConfig,

          Reporter reporter)

          throws WSIException {

      super.init(analyzerContext, assertions.getArtifact(getArtifactType()),

              reportArtifact, reporter);

      testable = analyzerConfig.getLogLocation() != null;

      this.analyzerConfig = analyzerConfig;

      this.wsdlDocument = (WSDLDocument) analyzerContext.getWsdlDocument();

  }

  /* (non-Javadoc)

   * @see org.wsi.test.profile.validator.MessageValidator#init(org.eclipse.wst.wsi.internal.core.analyzer.AnalyzerContext, org.wsi.test.profile.ProfileArtifact, org.wsi.test.report.ReportArtifact, org.wsi.wsdl.WSDLDocument, org.wsi.test.report.Reporter)

   */

  public void init(

    AnalyzerContext analyzerContext,

    ProfileArtifact profileArtifact,

    ReportArtifact reportArtifact,

    WSDLDocument wsdlDocument,

    Reporter reporter)

    throws WSIException

  {

    // BaseValidatorImpl

    super.init(analyzerContext, profileArtifact, reportArtifact, reporter);

    this.analyzerConfig = Utils.getAnalyzerConfig(reporter);

    testable = ((analyzerConfig != null) && (analyzerConfig.getLogLocation() != null)); 

    // Save input references

    this.wsdlDocument = wsdlDocument;

  }

  /**

   * Returns wsdlDocument

   * @return wsdlDocument

   */

  public WSDLDocument getWSDLDocument()

  {

    return wsdlDocument;

  }

  /* (non-Javadoc)

   * @see org.wsi.test.profile.validator.MessageValidator#validate(org.wsi.test.profile.validator.EntryContext)

   */

  public void validate(EntryContext entryContext) throws WSIException

  {

    //Entry entry = null;

    // Save log entry to be referenced by other methods

    this.logEntry = entryContext.getMessageEntry();

    // Get reference to the analyzer config object

    AnalyzerConfig analyzerConfig =

      reporter.getReport().getReportContext().getAnalyzer().getAnalyzerConfig();

    /* If Service Description (WSDL/UDDI) NOT supplied in analyzer config OR

     * Service Description IS supplied and the current message correlates to it...

     */

    if ((!analyzerConfig.isWSDLReferenceSet())

      || messageCorrelatesToService(

        entryContext,

        analyzerConfig.getCorrelationType()))

    {

      // now inner classes moved out from the validator

      //String classPrefix = this.getClass().getName() + "$";

      String classPrefix = this.getClass().getPackage().getName()+".";

      // Process assertions for this artifact against the target context

      processAssertions(classPrefix, entryContext);

    }

  }

  /**

   * Check whether the message correlates to the service under test.

   * Use the request part of the request-response pair, from which the correlation of the response is implied.

   * Entities from the Service under test are determined once for all.

   * @param entryContext    an entry context.

   * @param correlationType a correlation type.

   * @return true if the message correlates to the service under test.

   * @throws WSIException if correlation type is not appropriate.

   */

  private boolean messageCorrelatesToService(

    EntryContext entryContext,

    String correlationType)

    throws WSIException

  {

    URI[] endpoints = null;

    boolean correlation = false;

    /* TEMP: Get it from analyzer config passed in on init method

    CandidateInfo candidate = entryContext

                              .getAnalyzerContext()

                              .getCandidateInfo();

    */

    CandidateInfo candidate = analyzerContext.getCandidateInfo();

    // Service reference

    ServiceReference serviceReference = analyzerContext.getServiceReference();

    // Get the definition element

    Definition definition = candidate.getWsdlDocument().getDefinitions();

    Binding binding = null;

    if (serviceReference.getWSDLElement().isPort())

    {

      // Get service

      Service service =

        definition.getService(

          serviceReference.getWSDLElement().getParentElementQName());

      // Get port

      Port port = service.getPort(serviceReference.getWSDLElement().getName());

      // Get binding

      binding = port.getBinding();

    }

    else if (serviceReference.getWSDLElement().isBinding())

    {

      // Get binding

      binding =

        definition.getBinding(serviceReference.getWSDLElement().getQName());

    }

    if (binding == null)

    {

      return false;

    }

    if ((endpoints = hostAndPortCorrelation(entryContext)) != null

      && urlPathCorrelation(entryContext, endpoints))

    {

      /* If correlation type is "endpoint", this is all the correlation that can be done.

       * (Note - this is incomplete correlation since >1 service could be associated with the endpoint.

       *  Therefore , if messages for different services on the same endpoint appear in the log file

       *  and correlation type is "endpoint", all those messages will be analyzed).

       */

      if (correlationType

        .equals(WSIConstants.ATTRVAL_CORRELATION_TYPE_ENDPOINT))

      {

        correlation = true;

      }

      else

      {

        // always allow GET requests right through if they've passed Endpoint Correlation

        String requestType = getHttpRequestType(entryContext);

        if ((requestType != null) && requestType.equalsIgnoreCase("GET"))

        {

          correlation = true;

        }

        else

        {

          // The correlationType is not "endpoint" so continue on to processing for at least

          // "namespace" correlation...

          // get the operation signature (input & output) from request & response messages...    

          // and do a quick DOM parse

          Document requestMessage = entryContext.getRequestDocument();

          // Check if namespace is found in request message only

          if (namespaceCorrelation(binding, requestMessage))

          {

            // If namespace found and the correlation type is namespace, then process messages

            if (correlationType

              .equals(WSIConstants.ATTRVAL_CORRELATION_TYPE_NAMESPACE))

            {

              correlation = true;

            }

            // If operation is found and correlation type is operation, then process messages

            else if (

              (operationCorrelation(binding, requestMessage))

                && (correlationType

                  .equals(WSIConstants.ATTRVAL_CORRELATION_TYPE_OPERATION)))

            {

              correlation = true;

            }

            else

            {

              // this should never happen if config schema was followed correctly

              throw new WSIException(

                "Bad correlation type found in config: " + correlationType);

            }

          }

        }

      }

    }

    return correlation;

  }

  /**

   *  Correlation Check 1: Service Description endpoint vs HTTP Header (test 1)

   *  Check if receiverHostAndPort from request message log matches host & port from WSDL SOAP binding for

   *  the Service under test.

   *  If it does not, stop processing this message pair.

   * @param entryContext an entry context.

   * @return if receiverHostAndPort from request message log matches

   *         host & port from WSDL SOAP binding for the Service.

   * @throws WSIException if problem occurs during correlation check.

   */

  private URI[] hostAndPortCorrelation(EntryContext entryContext)

    throws WSIException

  {

    // get <receiverHostAndPort> from request message

    String httpHostAndPort = entryContext.getRequest().getReceiverHostAndPort();

    // Search endpoint list for a match with <receiverHostAndPort>

    /* TEMP: Get it from analyzer config passed in on init method

    return entryContext.getAnalyzerContext()

                       .getCandidateInfo()

                       .getEndPoints(httpHostAndPort);

    */

    return analyzerContext.getCandidateInfo().getEndPoints(httpHostAndPort);

  }

  /**

   * Correlation Check 2: Service Description endpoint vs HTTP Header (test 2)

   *

   * Use analyzer config host & port, plus URL path (from request message header HTTP POST)

   * to look for the corresponding endpoint in the Service Definition.

   * If it does not, stop processing this message pair.

   * @param entryContext an entry context.

   * @param endpoints an array of endpoints.

   * @return true if corresponding endpoints are found in the Service Definition.

   * @throws WSIException if problem occurs during correlation check.

   */

  private boolean urlPathCorrelation(

    EntryContext entryContext,

    URI[] endpoints)

    throws WSIException

  {

    // compares: protocol (must be http for POST), host, port and path.

    // get POST URI path from message using Tokenizer 

    Vector requestLine =

      getHttpRequest(entryContext.getRequest().getHTTPHeaders());

    if (requestLine == null)

    {

      return false; // an unexpected HTTP request type !

    }

    String requestPath = (String) requestLine.get(1);

    // Path immediately follows POST

    // compare path with those in the previous generated URI list 

    Vector filteredEndpoints = new Vector();

    for (int i = 0; i < endpoints.length; i++)

    {

      if (endpoints[i].toString().endsWith(requestPath))

      {

        filteredEndpoints.add(endpoints[i]);

      }

    }

    if (filteredEndpoints.size() == 0)

      return false;

    // this URI should be unique in the WSDL - there should be at most one match

    // but if we have at least one, that's sufficient to accept the message

    return true;

  }

  /**

   * Correlation Check 3: Service Description namespace.

   *

   * Determine if the Service Description declares the namespace that appears in the (request?) message soap body.

   * Location of relevent namespace :

   * Operation type                      - Message Namespace: (compare with)  Service Definition Namespace:

   * (from message? endpoint? where?)

   * rpc-literal                           &lt;soap:Body&gt; child namespace.        &lt;soapbind:body&gt; namespace.

   * doc-literal                       &lt;soap:Body&gt; child namespace.       targetNameSpace of schema that

   *                                                                          defines  &lt;soap:body&gt; child.

   * If it doesn't match, stop processing this message pair.

   * @param binding a binding.

   * @param request a request.

   * @return true if description declared in the description are the

   *         same as those that appear in the message soap body.

   * @throws WSIException if problem occurs during correlationcheck.                                                                      

   */

  private boolean namespaceCorrelation(Binding binding, Document request)

    throws WSIException

  {

    boolean namespaceFound = false;

    String bindingStyle = WSIConstants.ATTRVAL_SOAP_BIND_STYLE_DOC;

    // Get operation namespace from the request soap message

    String soapOpNS = getSoapBodyChild(request).getNamespaceURI();

    // Get soapbind:binding

    SOAPBinding soapBinding = null;

    if ((soapBinding = WSDLUtils.getSoapBinding(binding)) != null)

    {

      bindingStyle = soapBinding.getStyle();

    }

    // Go through each operation in the binding and check for namespace match

    Iterator operations = binding.getBindingOperations().iterator();

    while (operations.hasNext() && !(namespaceFound))

    {

      BindingOperation bindingOperation = (BindingOperation) operations.next();

      // If rpc-literal, then look at namespace attribute on soapbind:body

      if (WSDLUtils.isRpcLiteral(bindingStyle, bindingOperation))

      {

        // Get soapbind:body element

        SOAPBody soapBody = WSDLUtils.getInputSoapBody(bindingOperation);

        if ((soapBody.getNamespaceURI() != null)

          && (soapBody.getNamespaceURI().equals(soapOpNS)))

        {

          namespaceFound = true;

        }

      }

      // If doc-literal, then check namespace

      else if (WSDLUtils.isDocLiteral(bindingStyle, bindingOperation))

      {

        int partCount;

        Iterator partsIterator = null;

        // Get first part name from soapbind:body element parts attribute

        String partName = getFirstPartName(bindingOperation);

        // Get the list of parts from the message          

        Map partsMap = null;

        if ((partsMap =

          bindingOperation.getOperation().getInput().getMessage().getParts())

          != null)

        {

          partsIterator = partsMap.values().iterator();

          // If the part name wasn't specified on the soapbind:body element, then process just the first one

          if (partName == null)

            partCount = 1;

          else

            partCount = partsMap.size();

          for (int i = 0; i < partCount && !namespaceFound; i++)

          {

            // Get next part

            Part part = (Part) partsIterator.next();

            // If part name matches or there is no part name, then check namespace

            if ((partName == null)

              || ((partName != null) && (part.getName().equals(partName))))

            {

              if ((part.getElementName().getNamespaceURI() != null)

                && (part.getElementName().getNamespaceURI().equals(soapOpNS)))

              {

                namespaceFound = true;

              }

            }

          }

        }

      }

    }

    return namespaceFound;

  }

  /**

  * Correlation Check 4 : Service Description "operation"

  *

  * Check if the message content matches any of the candidate operation definitions

  * for request and response in the Service Description.

  * 

  * For both request and response, look for the soap body child element name

  * in the list of candidate operation names.

  * @param binding        a binding.

  * @param requestMessage a request message.

  * @return true if the message content matches any of the candidate

  *         operation definitions for request and response in the

  *         Service Description.

  * @throws WSIException if problem occurs during correlationcheck.

  */

  private boolean operationCorrelation(

    Binding binding,

    Document requestMessage)

    throws WSIException

  {

    boolean operationFound = false;

    String bindingStyle = WSIConstants.ATTRVAL_SOAP_BIND_STYLE_DOC;

    // Get soapbind:binding

    SOAPBinding soapBinding = null;

    if ((soapBinding = WSDLUtils.getSoapBinding(binding)) != null)

    {

      bindingStyle = soapBinding.getStyle();

    }

    // Get the first child element from the soap body

    Element soapBodyChild = getSoapBodyChild(requestMessage);

    // If there is a child element, then check it

    if (soapBodyChild != null)

    {

      // Get operation name from the soap:body

      String operationName = soapBodyChild.getLocalName();

      // Get operation QName

      QName operationQName =

        new QName(soapBodyChild.getNamespaceURI(), operationName);

      // Go through each operation in the binding and check for namespace match

      Iterator operations = binding.getBindingOperations().iterator();

      while (operations.hasNext() && !(operationFound))

      {

        BindingOperation bindingOperation =

          (BindingOperation) operations.next();

        // If rpc-literal, then look at namespace attribute on soapbind:body

        if (WSDLUtils.isRpcLiteral(bindingStyle, bindingOperation))

        {

          // Get soapbind:body element

          if (bindingOperation.getName().equals(operationName))

            operationFound = true;

        }

        // If doc-literal, then check namespace

        else if (WSDLUtils.isDocLiteral(bindingStyle, bindingOperation))

        {

          int partCount;

          Iterator partsIterator = null;

          // Get first part name from soapbind:body element parts attribute

          String partName = getFirstPartName(bindingOperation);

          // Get the list of parts from the message          

          Map partsMap = null;

          if ((partsMap =

            bindingOperation.getOperation().getInput().getMessage().getParts())

            != null)

          {

            partsIterator = partsMap.values().iterator();

            // If the part name wasn't specified on the soapbind:body element, then process just the first one

            if (partName == null)

              partCount = 1;

            else

              partCount = partsMap.size();

            for (int i = 0; i < partCount && !operationFound; i++)

            {

              // Get next part

              Part part = (Part) partsIterator.next();

              // If part name matches or there is no part name, then check namespace

              if ((partName == null)

                || ((partName != null) && (part.getName().equals(partName))))

              {

                if ((part.getElementName() != null)

                  && (part.getElementName().equals(operationQName)))

                {

                  operationFound = true;

                }

              }

            }

          }

        }

      }

    }

    // Go through each operation to find a match

    return operationFound;

  }

  /**

   * Create failure detail.

   * @param message       a message.

   * @param entryContext  an entry context.

   * @return failure detail.

   */

  public FailureDetail createFailureDetail(

    String message,

    EntryContext entryContext)

  {

    FailureDetail failureDetail = reporter.createFailureDetail();

    failureDetail.setFailureMessage(message);

    failureDetail.setElementLocation(

      entryContext.getMessageEntry().getElementLocation());

    return failureDetail;

  }

  /* (non-Javadoc)

   * @see org.wsi.test.profile.validator.impl.BaseValidatorImpl#isNotApplicable(org.wsi.test.profile.TestAssertion)

   */

  protected boolean isNotApplicable(TestAssertion testAssertion)

  {

    boolean notApplicable = false;

    // If the additional entry is not available, then set notApplicable

    if (testAssertion.getAdditionalEntryTypeList().getWSDLInput() != null

      && !testAssertion.getAdditionalEntryTypeList().getWSDLInput().equals("none")

      && analyzerContext.getServiceReference().getWSDLLocation() == null)

    {

      notApplicable = true;

    }

    return notApplicable;

  }

  /**

   * Get POST request.

   * @param httpHeader an HTTP

   * @return POST request.

   */

  public Vector getPostRequest(String httpHeader)

  {

    //Request-Line   = Method SP Request-URI SP HTTP-Version CRLF

    Vector requestLine = new Vector();

    String startLine = null;

    StringTokenizer httpMessageTokenizer =

      new StringTokenizer(httpHeader, "\n\r\f");

    if (httpMessageTokenizer.hasMoreTokens())

    {

      startLine = httpMessageTokenizer.nextToken();

    }

    if (startLine.startsWith("POST"))

    {

      StringTokenizer startLineTokenizer =

        new StringTokenizer(startLine, "\u0020");

      while (startLineTokenizer.hasMoreTokens())

      {

        requestLine.add(startLineTokenizer.nextToken());

      }

    }

    return requestLine;

  }

  /**

   * Get HTTP request.

   * @param httpHeader an HTTP

   * @return HTTP request.

  */

  private Vector getHttpRequest(String httpHeader)

  {

    //Request-Line   = Method SP Request-URI SP HTTP-Version CRLF

    Vector requestLine = new Vector();

    String startLine = null;

    StringTokenizer httpMessageTokenizer =

      new StringTokenizer(httpHeader, "\n\r\f");

    if (httpMessageTokenizer.hasMoreTokens())

    {

      startLine = httpMessageTokenizer.nextToken();

    }

    if (startLine.startsWith("POST") || startLine.startsWith("GET"))

    {

      StringTokenizer startLineTokenizer =

        new StringTokenizer(startLine, "\u0020");

      while (startLineTokenizer.hasMoreTokens())

      {

        requestLine.add(startLineTokenizer.nextToken());

      }

    }

    else

    {

      requestLine = null; // signify not POST or GET

    }

    return requestLine;

  }

  /**

   * Get HTTP request type.

   * @param entryContext an entry context.

   * @return HTTP request type.

   */

  private String getHttpRequestType(EntryContext entryContext)

  {

    //Request-Line   = Method SP Request-URI SP HTTP-Version CRLF

    String httpHeader = entryContext.getRequest().getHTTPHeaders();

    String httpRequestType = null;

    String startLine = null;

    StringTokenizer httpMessageTokenizer =

      new StringTokenizer(httpHeader, "\n\r\f");

    if (httpMessageTokenizer.hasMoreTokens())

    {

      startLine = httpMessageTokenizer.nextToken();

      StringTokenizer startLineTokenizer =

        new StringTokenizer(startLine, "\u0020");

      if (startLineTokenizer.hasMoreTokens())

      {

        httpRequestType = startLineTokenizer.nextToken();

      }

    }

    return httpRequestType;

  }

  /**

   * Determine if the message is a response for a one-way operation.

   * @param entryContext an entry context.

   * @return true if the message is a response for a one-way operation.

   */

  public boolean isOneWayResponse(EntryContext entryContext)

  {

    boolean oneway = false;

    // TEMP: If this is a response message and there is no content, then set one-way to true

    // TEMP: Need to find a way to determine if the response is for a one-way message

    if (entryContext

      .getMessageEntry()

      .getType()

      .equalsIgnoreCase(MessageEntry.TYPE_RESPONSE)

      && entryContext.getMessageEntry().getMessage().length() == 0)

    {

      oneway = true;

    }

    return oneway;

  }

  /**

   * messageIsDocLitSchemaValid.

   *

   * Validates the doc-lit messages against the schema found in a candidate wsdl document.

   *

   * Identify (or be given) a reference in the wsdl to elements (found in &lt;wsdl:types&gt;&lt;schema&gt;...)

   * that are immediate children elements in the soap body.

   * @param entryContext an entry context.

   * @return true if the document literal message is compliant to the

   *         schema found in a candidate WSDL document.

   * @throws WSIException if there is a parsing problem during validation.

   */

  public boolean messageIsDocLitSchemaValid(EntryContext entryContext)

    throws WSIException

  {

    // This method should use a validating parser that is capable of acceppting multiple schema references

    // programmatically. Then, every schema in candidate wsdl can be passed in to the validator. This avoids the

    // need to pinpoint a particular schema element from all candidate wsdl:types, corresponding to the

    // wsdl:operation being used. The pinpointing is an incomplete workaround for parsers not capable

    // of accepting arrays of scehma references

    // [ i.e. the DOM factory.setAttribute(JAXP_SCHEMA SOURCE, Object[] {...}) ]

    // get all xs:schema from all candidate wsdl:types                   

    // add each <schema> to an array and pass this array to the validating parser

    // when validating the/each soap body child.

    // use the referenced WSDL file and its imported files to find schemas

    List schemaWSDLs = new ArrayList();

    List inlineSchemas = new ArrayList();

    List schemaStrings = new ArrayList();

    Definition[] allDefs =

      analyzerContext.getCandidateInfo().getDefinitions();

    for (int thisDef = 0; thisDef < allDefs.length; thisDef++)

    {

      schemaWSDLs.add(allDefs[thisDef].getDocumentBaseURI());

    }

    Iterator fileIterator = schemaWSDLs.iterator();

    while (fileIterator.hasNext())

    {

      // parse file if possible

      Document wsdlDoc = null;

      String wsdlURI = (String) fileIterator.next();

      try

      {

        wsdlDoc = XMLUtils.parseXMLDocumentURL(wsdlURI, null);

      }

      catch (Exception e)

      {

        continue;

      }

      Element root = wsdlDoc.getDocumentElement();

      // find the schema

      NodeList schemaElements = root.getElementsByTagNameNS(

        WSITag.ELEM_XSD_SCHEMA.getNamespaceURI(),

        WSITag.ELEM_XSD_SCHEMA.getLocalPart());

      for (int elem = 0; elem < schemaElements.getLength(); elem++)

      {    

        Element schema = (Element) schemaElements.item(elem);

        // copying all the NS declarations from wsdl:definitions wsdl:types

        copyNSDeclarations(root, schema);

        copyNSDeclarations((Element) schema.getParentNode(), schema);

        // Replacing all relative schemaLocation URIs with absolute ones

        replaceRelativeURIs(schema, wsdlURI);

        inlineSchemas.add(schema);

      }

    }

    // Note that the Xerces parser ONLY accepts an array

    // of schemas with unique namespaces.

    if (!duplicateNamespacesDetected(inlineSchemas))

    {

      // Serialize the schema elements inside the Types, then use this as

      // the schema string for the validation

      Iterator i = inlineSchemas.iterator();

      while (i.hasNext())

      {

      Element schema = (Element)i.next();

        String schemaString = DOM2Writer.nodeToString(schema);

        schemaStrings.add(schemaString);

      }

      NodeList elementList = entryContext.getMessageEntryDocument()

        .getElementsByTagNameNS(WSITag.ELEM_SOAP_BODY.getNamespaceURI(),

            WSITag.ELEM_SOAP_BODY.getLocalPart());

      if (elementList == null || elementList.getLength() != 1)

      {

        // should only be a single soap body !

        return false; // probably an error condition though

      }

      NodeList soapBodyChildList = ((Element)elementList.item(0)).getChildNodes();

      for (int child = 0; child < soapBodyChildList.getLength(); child++)

      {

        Node soapBodyChild = soapBodyChildList.item(child);

        if (soapBodyChild.getNodeType() == Node.ELEMENT_NODE)

        {

          // do all for now

          try

          {

            // Write out element tree to String

            String messageContent = DOM2Writer.nodeToString(soapBodyChild);

            // parse the child element, validating against the schema

            XMLUtils.parseXML(messageContent, schemaStrings);

          }

          catch (WSIException e)

          {

            if (e.getTargetException() instanceof SAXException)

            {

              // validation failed

              throw new WSIException(e.getTargetException().getMessage());

            }

            throw e;

          }

          catch (Exception e)

          {

            throw new WSIException("Validating Parsing problem", e);

            // Bad things have happened

          }

        }

      }  

    }

    return true;

  }

  /**

   * Copy the namespace declarations.

   * @param parent a message.

   * @param child a stripped message.

   */

  private void copyNSDeclarations(Element parent, Element child)

  {

    NamedNodeMap nodeMap = parent.getAttributes();

    for (int nodeId = 0; nodeId < nodeMap.getLength(); nodeId++)

    {

      Node node = nodeMap.item(nodeId);

      if ((node.getNodeType() == Node.ATTRIBUTE_NODE)

        && (node.getNodeName().startsWith("xmlns:")))

      {

        String nodeName = node.getNodeName();

        // If an NS being copied is not the same as the child element has, copy it

        if (!child.getNodeName().startsWith(

          nodeName.substring(nodeName.indexOf(":") + 1) + ":"))

        {

          child.setAttribute(nodeName, node.getNodeValue());

        }

      }

    }

  }

  /**

   * Replaces all relative URIs for schemaLocation attributes.

   * @param schema an xsd:schema element.

   * @param wsdlURI an URI of WSDL that contains xsd:schema being processed.

   */

  private void replaceRelativeURIs(Element schema, String wsdlURI)

  {

    // Retrieving all xsd:import elements

    NodeList imports = schema.getElementsByTagNameNS(

      WSITag.ELEM_XSD_IMPORT.getNamespaceURI(),

      WSITag.ELEM_XSD_IMPORT.getLocalPart());

    // Going through the elements

    for (int i = 0; i < imports.getLength(); i++)

    {

      Element imp = (Element) imports.item(i);

      // Getting the schemaLocation attribute

      Attr schemaLocation =

        XMLUtils.getAttribute(imp, WSITag.ATTR_XSD_SCHEMALOCATION);

      // If the attribute is present

      if (schemaLocation != null)

      {

        // Trying to create an URI object using attribute's value

        URI uri = null;

        try

        {

          uri = new URI(schemaLocation.getValue());

        }

        catch (Exception e) {}

        // If the value is not an absolute URI (the URI constructor throws the

        // MalformedURIException), creating the absolute URI using wsdlURI

        if (uri == null)

        {

          String newURI = wsdlURI.substring(0, wsdlURI.lastIndexOf("/") + 1)

            + schemaLocation.getValue();

          try

          {

            uri = new URI(newURI);

            // Setting a new URI as a value for the schemaLocation attribute

            schemaLocation.setValue(uri.toString());

          }

          catch (Exception e) {}

        }

      }

    }

  }

  /**

   * Returns binding operation matched for SOAP message.

   * @param entryType message entry type.

   * @param doc a message.

   * @return any binding operation matched, null if it is not found.

   */

  public BindingOperation getOperationMatch(EntryType entryType, Document doc)

  {

    BindingOperation bindingOperation = null;

    try

    {

      // Getting the name of the first SOAP Body child element

      QName operation = getOperationFromMessage(doc);

      if (operation != null)

      {

        // Retrieving all the RPC binding operations from wsdl:binding

        BindingOperation[] rpcBindingOps = getMatchingBindingOps(

          WSIConstants.ATTRVAL_SOAP_BIND_STYLE_RPC,

          analyzerContext.getCandidateInfo().getBindings());

        // Retrieving binding operation by the given operation name

        bindingOperation = getOperationMatch(

          entryType, operation, rpcBindingOps);

        // If no one RPC operation matched

        if(bindingOperation == null)

        {

          // Retrieving all the document binding operations from wsdl:binding

          BindingOperation[] docBindingOperations = getMatchingBindingOps(

            WSIConstants.ATTRVAL_SOAP_BIND_STYLE_DOC,

            analyzerContext.getCandidateInfo().getBindings());

          // Retrieving binding operation by given element name

          BindingOperation[] potentialDocLitOps =

            getDocLitOperations(entryType, operation, docBindingOperations);

          // If there is exactly one operation matched

          if (potentialDocLitOps.length == 1)

            bindingOperation = potentialDocLitOps[0];

        }

      }

    }

    catch (Exception e) {}

    return bindingOperation;

  }

  /**

   * Match either Input or Output.

   * @param messageEntryType message entry type.

   * @param soapMessage soap message.

   * @param op binding operations.

   * @return matched operation.

   */

  public BindingOperation getOperationMatch(

    EntryType messageEntryType,

    Document soapMessage,

    BindingOperation[] op)

  {

    // Get operation from message

    QName operation = getOperationFromMessage(soapMessage);

    // list of QNames

    return getOperationMatch(messageEntryType, operation, op);

  }

  /**

   * Match either Input or Output.

   * @param messageEntryType message entry type.

   * @param operation SOAP operation name.

   * @param op binding operations.

   * @return matched operation.

   */

  public BindingOperation getOperationMatch(

    EntryType messageEntryType,

    QName operation,

    BindingOperation[] op)

  {

    QName checkOperation;

    // Look for a candidate operation in the wsdl that matches this signature.

    for (int k = 0; k < op.length; k++)

    {

      String name = null;

      List extensibles = null;

      BindingOperation bindingOp = op[k];

      if (messageEntryType.isType(MessageValidator.TYPE_MESSAGE_REQUEST)

        && (bindingOp.getOperation().getInput() != null))

      {

        name = bindingOp.getOperation().getName();

        extensibles = bindingOp.getBindingInput().getExtensibilityElements();

      }

      else if (

        messageEntryType.isType(MessageValidator.TYPE_MESSAGE_RESPONSE)

          && (bindingOp.getOperation().getOutput() != null))

      {

        name = bindingOp.getOperation().getName() + "Response";

        extensibles = bindingOp.getBindingOutput().getExtensibilityElements();

      }

      // Get soap:body

      SOAPBody soapBody = getSoapBody(extensibles);

      if (soapBody == null)

        checkOperation = new QName(name);

      else

        checkOperation = new QName(soapBody.getNamespaceURI(), name);

      if (operation != null && operation.equals(checkOperation))

      {

        return (bindingOp);

      }

    }

    return null;

  }

  /**

   * Match either Input or Output.

   * @param messageEntryType a message entry type.

   * @param soapMessage a soap message.

   * @param op binsing operations.

   * @return matched operation.

   */

  public BindingOperation getOperationPartsMatch(

    EntryType messageEntryType,

    Document soapMessage,

    BindingOperation[] op)

  {

    Map parts = getPartListFromMessage(soapMessage); // list of QNames

    // Look for a candidate operation in the wsdl that matches this signature.

    for (int k = 0; k < op.length; k++)

    {

      Message wsdlMessage = null;

      List extensibles = null;

      BindingOperation bindingOp = op[k];

      if (messageEntryType.isType(MessageValidator.TYPE_MESSAGE_REQUEST)

        && (bindingOp.getOperation().getInput() != null))

      {

        wsdlMessage = bindingOp.getOperation().getInput().getMessage();

        extensibles = bindingOp.getBindingInput().getExtensibilityElements();

      }

      else if (

        messageEntryType.isType(MessageValidator.TYPE_MESSAGE_RESPONSE)

          && (bindingOp.getOperation().getOutput() != null))

      {

        wsdlMessage = bindingOp.getOperation().getOutput().getMessage();

        extensibles = bindingOp.getBindingOutput().getExtensibilityElements();

      }

      //wsdlFaultParts = op[k].getFaults();

      // ADD: check for case when response message is a fault

      if (sameParts(parts, wsdlMessage, getSoapHeader(extensibles)))

      {

        return (bindingOp);

      }

    }

    return null;

  }

  /**

   * BindingOperation getOperationPartsMatch(..).

   *

   * Find one or more matching binding operations from the WSDL corresponding to the

   * given request-response signature.

   *

   * This overloaded version is intended for possible Correlation only (not assertions),

   * since it checks for an operation signature on a request-response pair.

   * Assertions now check request & response messages independently.

   * @param requestMessage a request message.

   * @param responseMessage a response message.

   * @param op binding operations.

   * @return matched operation.

   */

  //private BindingOperation getOperationPartsMatch(

  //  Document requestMessage,

  //  Document responseMessage,

  //  BindingOperation[] op)

  //{

  //  Map inParts = getPartListFromMessage(requestMessage); // list of QNames

  //  Map outParts = getPartListFromMessage(responseMessage);

  //  // list of QNames

  //

  //  // Look for a candidate operation in the wsdl that matches this signature.

  //  for (int k = 0; k < op.length; k++)

  //  {

  //

  //    //Map wsdlFaultParts = null;

  //    Message wsdlInMessage = null;

  //    Message wsdlOutMessage = null;

  //

  //    BindingOperation bindingOp = op[k];

  //    if (bindingOp.getOperation().getInput() != null)

  //    {

  //      wsdlInMessage = bindingOp.getOperation().getInput().getMessage();

  //    }

  //

  //    if (bindingOp.getOperation().getOutput() != null)

  //    {

  //      wsdlOutMessage = bindingOp.getOperation().getOutput().getMessage();

  //    }

  //    //wsdlFaultParts = op[k].getFaults();

  //    // ADD: check for case when response message is a fault

  //

  //    if (sameParts(inParts,

  //      wsdlInMessage,

  //      getSoapHeader(bindingOp.getBindingInput().getExtensibilityElements())))

  //    {

  //      // match on the request - now check response if its not a fault

  //      if (responseMessage != null && isFault(responseMessage))

  //      {

  //        return (bindingOp);

  //      }

  //      else if (

  //        sameParts(

  //          outParts,

  //          wsdlOutMessage,

  //          getSoapHeader(

  //            bindingOp.getBindingOutput().getExtensibilityElements())))

  //      {

  //        // It does match so treat this as a relevant message pair.

  //        // Let the message through for validation.

  //        //ADD: could pass the operations list back to the entryContext for the message.

  //        return (bindingOp);

  //      }

  //    }

  //  }

  //  return null;

  //}

  /**

   * Get the soap:body from a List of extensibility elements.

   * @param extElems a list of extensibility elements.

   * @return the soap:body from a List of extensibility elements.

   */

  private SOAPBody getSoapBody(List extElems)

  {

    // Find the soap body

    if (extElems != null)

    {

      for (int i = 0; i < extElems.size(); i++)

      {

        ExtensibilityElement extElem = (ExtensibilityElement) extElems.get(i);

        if (extElem.getElementType().equals(WSITag.WSDL_SOAP_BODY))

        {

          return (SOAPBody) extElem;

        }

        // If the element is mime:multipartRelated

        else if (extElem.getElementType().equals(WSITag.WSDL_MIME_MULTIPART))

        {

          // Getting the mime:part elements of the mime:multipartRelated

          List mimeParts = ((MIMEMultipartRelated) extElem).getMIMEParts();

          // Going through all the mime:part elements

          for (int j = 0; j < mimeParts.size(); j++)

          {

            // Collecting all the mime:content elements of this mime:part

            SOAPBody soapBody = getSoapBody(

              ((MIMEPart) mimeParts.get(j)).getExtensibilityElements());

            if (soapBody != null)

              return soapBody;

          }

        }

      }

    }

    return null;

  }

  /**

   * Get the SOAPHeader from a List of extensibility elements.

   * @param extensibles a list of extensibility elements.

   * @return the SOAPHeader from a List of extensibility elements.

   */

  private SOAPHeader getSoapHeader(List extensibles)

  {

    SOAPHeader soapHeader = null;

    // find the soap header

    if (extensibles != null)

    {

      Iterator i = extensibles.iterator();

      while (i.hasNext() && soapHeader == null)

      {

        try

        {

          soapHeader = (SOAPHeader) i.next();

        }

        catch (ClassCastException c)

        {

        }

      }

    }

    return soapHeader;

  }

  /**

   * Get first part name from soapbind:body element.

   */

  private String getFirstPartName(BindingOperation bindingOperation)

  {

    String partName = null;

    List extList = null;

    Iterator partsIterator = null;

    // Determine if there is a list of parts by finding the soapbind:body element

    if ((extList =

      bindingOperation.getBindingInput().getExtensibilityElements())

      != null)

    {

      List partsList = null;

      Iterator extIterator = extList.iterator();

      while (extIterator.hasNext() && (partName == null))

      {

        Object extElement = extIterator.next();

        if (extElement instanceof SOAPBody)

        {

          if ((partsList = ((SOAPBody) extElement).getParts()) != null)

          {

            partsIterator = partsList.iterator();

            // Since this is a doc literal binding there should be only one part name

            if (partsIterator.hasNext())

              partName = (String) partsIterator.next();

          }

        }

      }

    }

    return partName;

  }

  public BindingOperation[] getDocLitOperations(

    EntryType messageType,

    QName partElementQName,

    BindingOperation[] wsdlOperations)

  {

    if (messageType.isType(EntryType.getEntryType(MessageValidator.TYPE_MESSAGE_REQUEST)))

    {

      return getInputDocLitOperations(partElementQName, wsdlOperations);

    }

    else if (messageType.isType(EntryType.getEntryType(MessageValidator.TYPE_MESSAGE_RESPONSE)))

    {

      return getOutputDocLitOperations(partElementQName, wsdlOperations);

    }

    else

    {

      return null; // should be one or the other

    }

  }

  private BindingOperation[] getInputDocLitOperations(

    QName partElementQName,

    BindingOperation[] wsdlOperations)

  {

    Vector potentialOps = new Vector();

    for (int i = 0; i < wsdlOperations.length; i++)

    {

      if (wsdlOperations[i].getOperation().getInput() != null)

      {

        Message message = wsdlOperations[i].getOperation().getInput().getMessage();

        // If SOAP Body child element is not present and wsdl:message does not have any wsdl:parts, that is the match

        if (partElementQName == null)

        {

          if (message.getParts().isEmpty())

            potentialOps.add(wsdlOperations[i]);

          continue;

        }

        Iterator partsIt = message.getParts().values().iterator();

        while (partsIt.hasNext())

        {

          Part nextPart = (Part) partsIt.next();

          if (partElementQName.equals(nextPart.getElementName()))

          {

            // matching part found (doc-lit) - add to list of possible operation matches

            potentialOps.add(wsdlOperations[i]);

            break;

          }

        }

      }

    }

    return (BindingOperation[]) potentialOps.toArray(new BindingOperation[0]);

  }

  private BindingOperation[] getOutputDocLitOperations(

    QName partElementQName,

    BindingOperation[] wsdlOperations)

  {

    Vector potentialOps = new Vector();

    for (int i = 0; i < wsdlOperations.length; i++)

    {

      if (wsdlOperations[i].getOperation().getOutput() != null)

      {

        Message message = wsdlOperations[i].getOperation().getOutput().getMessage();

        // If SOAP Body child element is not present and wsdl:message does not have any wsdl:parts, that is the match

        if (partElementQName == null)

        {

          if (message.getParts().isEmpty())

            potentialOps.add(wsdlOperations[i]);

          continue;

        }

        Iterator partsIt = message.getParts().values().iterator();

        while (partsIt.hasNext())

        {

          Part nextPart = (Part) partsIt.next();

          if (partElementQName.equals(nextPart.getElementName()))

          {

            // matching part found (doc-lit) - add to list of possible operation matches

            potentialOps.add(wsdlOperations[i]);

            break;

          }