* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

*

* Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.

*

* The contents of this file are subject to the terms of either the GNU

* General Public License Version 2 only ("GPL") or the Common Development

* and Distribution License("CDDL") (collectively, the "License").  You

* may not use this file except in compliance with the License. You can obtain

* a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html

* or glassfish/bootstrap/legal/LICENSE.txt.  See the License for the specific

* language governing permissions and limitations under the License.

*

* When distributing the software, include this License Header Notice in each

* file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.

* Sun designates this particular file as subject to the "Classpath" exception

* as provided by Sun in the GPL Version 2 section of the License file that

* accompanied this code.  If applicable, add the following below the License

* Header, with the fields enclosed by brackets [] replaced by your own

* identifying information: "Portions Copyrighted [year]

* [name of copyright owner]"

*

* Contributor(s):

*

* If you wish your version of this file to be governed by only the CDDL or

* only the GPL Version 2, indicate your decision by adding "[Contributor]

* elects to include this software in this distribution under the [CDDL or GPL

* Version 2] license."  If you don't indicate a single choice of license, a

* recipient has the option to distribute your version of this file under

* either the CDDL, the GPL Version 2 or to extend the choice of license to

* its licensees as provided above.  However, if you add GPL Version 2 code

* and therefore, elected the GPL Version 2 license, then the option applies

* only if the new code is made subject to such option by the copyright

* holder.

*/

* Web service related utilities.

*

* @author Kenneth Saks

*/

    // proprietary property for enabling logging of stub requests/responses

    public static final String CLIENT_TRANSPORT_LOG_PROPERTY =

      "com.sun.enterprise.webservice.client.transport.log";

    // xslt processing parameters for final wsdl transformation

    public static final String ENDPOINT_ADDRESS_PARAM_NAME =

        "endpointAddressParam";

    public final String WSDL_IMPORT_NAMESPACE_PARAM_NAME =

        "wsdlImportNamespaceParam";

    public static final String WSDL_IMPORT_LOCATION_PARAM_NAME =

        "wsdlImportLocationParam";

    public static final String WSDL_INCLUDE_LOCATION_PARAM_NAME =

        "wsdlIncludeLocationParam";

    public final String SCHEMA_IMPORT_NAMESPACE_PARAM_NAME =

        "schemaImportNamespaceParam";

    public static final String SCHEMA_IMPORT_LOCATION_PARAM_NAME =

        "schemaImportLocationParam";   

    public static final String SCHEMA_INCLUDE_LOCATION_PARAM_NAME =

        "schemaIncludeLocationParam";   

    // @@@ These are jaxrpc-implementation specific MessageContextProperties

    // that should be added to jaxrpc spi

    private static final String ONE_WAY_OPERATION =

        "com.sun.xml.rpc.server.OneWayOperation";

    private static final String CLIENT_BAD_REQUEST =

        "com.sun.xml.rpc.server.http.ClientBadRequest";

   

    private static final String SECURITY_POLICY_NAMESPACE_URI =

            "http://schemas.xmlsoap.org/ws/2005/07/securitypolicy";

    private static Logger logger =

        LogDomains.getLogger(LogDomains.EJB_LOGGER);

    private static Logger deploymentLogger =

        LogDomains.getLogger(LogDomains.DPL_LOGGER);

       

    private JaxRpcObjectFactory rpcFactory;

    public WsUtil() {

        rpcFactory = JaxRpcObjectFactory.newInstance();

    }

    /**

     * Notification of server startup, good place for services initialization

     */

    public static void start() {

        // force monitoring initialization

        WebServiceEngineImpl.getInstance();

        ApplicationLoaderEventListener listener = ServiceEngineUtil.getListener();

        ApplicationLoaderEventNotifier.getInstance().addListener(listener);

    }

    /**

     * Serve up the FINAL wsdl associated with this web service.

     * @return true for success, false for failure

     */

    public boolean handleGet(HttpServletRequest request,

                             HttpServletResponse response,

                             WebServiceEndpoint endpoint) throws IOException {

        MimeHeaders headers = getHeaders(request);

        if( hasSomeTextXmlContent(headers) ) {

            String message = "Received HTTP GET containing text/xml " +

                " content for endpoint " + endpoint.getEndpointName() +

                " at " + endpoint.getEndpointAddressUri() +

                " . HTTP POST should be used instead.";

                       

            writeInvalidMethodType(response, message);

           

            logger.info(message);

           

            return false;

        }

       

        URL wsdlUrl = null;

        String requestUriRaw = request.getRequestURI();

        String requestUri    = (requestUriRaw.charAt(0) == '/') ?

            requestUriRaw.substring(1) : requestUriRaw;

        String queryString = request.getQueryString();

        WebService webService = endpoint.getWebService();

        if( queryString == null ) {

            // Get portion of request uri representing location within a module

            String wsdlPath = endpoint.getWsdlContentPath(requestUri);

            if( wsdlPath != null) {

                ModuleDescriptor module =

                    webService.getBundleDescriptor().getModuleDescriptor();

                if( wsdlPath.equals(webService.getWsdlFileUri())){

                    // If the request is for the main wsdl document, return

                    // the final wsdl instead of the wsdl from the module.

                    wsdlUrl = webService.getWsdlFileUrl();

                } else if( isWsdlContent(wsdlPath,

                                         webService.getBundleDescriptor()) ) {

                    // For relative document imports. These documents do not

                    // require modification during deployment, so serve them

                    // up directly from the packaged module.  isWsdlContent()

                    // check ensures we don't serve up arbitrary content from

                    // the module.

                    URL finalWsdlUrl = webService.getWsdlFileUrl();

                    String finalWsdlPath = finalWsdlUrl.getPath();

                    // remove the final wsdl uri from the above path

                    String wsdlDirPath = finalWsdlPath.substring(0, finalWsdlPath.length()-webService.getWsdlFileUri().length());

                    File wsdlDir = new File(wsdlDirPath);

                    File wsdlFile = new File(wsdlDir, wsdlPath.replace('/', File.separatorChar));

                    try {

                        wsdlUrl = wsdlFile.toURL();

                    } catch(MalformedURLException mue) {

                        logger.log(Level.INFO, "Failure serving WSDL for " +

                                   webService.getName(), mue);

                    }

                       

                }

            }

        } else if( queryString.equalsIgnoreCase("WSDL") ) {

            wsdlUrl = webService.getWsdlFileUrl();

        }

        boolean success = false;

        if( wsdlUrl != null ) {

           

            InputStream is = null;

            try {

                response.setContentType("text/xml");

                response.setStatus(HttpServletResponse.SC_OK);

                // if the requested file is the main wsdl document, we are going

                // to reprocess it through the XML transformer to change the final

                // endpoint URL correct for this particular web server instance.

                // This is necessary in the case of SE/EE installations where

                // the application can be running on different machines and ports

                // than the one they were deployed on (DAS).

                if (wsdlUrl.toURI().equals(webService.getWsdlFileUrl().toURI())) {

                    // get the application module ID

                    try {

                        String moduleID = endpoint.getBundleDescriptor().getApplication().getRegistrationName();

                        WebServerInfo wsi = getWebServerInfo(moduleID, request);

                        URL url = webService.getWsdlFileUrl();

                        File originalWsdlFile = new File(url.getPath()+"__orig");

                        if(!originalWsdlFile.exists()) {

                            originalWsdlFile = new File(url.getPath());

                        }

                        generateFinalWsdl(originalWsdlFile.toURL(), webService, wsi, response.getOutputStream());

                    } catch(Exception e) {

                        // if this fail, we revert to service the untouched

                        // repository item.

                        URLConnection urlCon = wsdlUrl.openConnection();

                        urlCon.setUseCaches(false);

                        is = urlCon.getInputStream();                   

                        ArchivistUtils.copy(is, response.getOutputStream());                       

                    }

                } else {

                    // Copy bytes into output. Disable caches to avoid jar URL

                    // caching problem.

                    URLConnection urlCon = wsdlUrl.openConnection();

                    urlCon.setUseCaches(false);

                    is = urlCon.getInputStream();                   

                    ArchivistUtils.copy(is, response.getOutputStream());

                }

                success = true;

                if( logger.isLoggable(Level.FINE) ) {

                    logger.fine("Serving up final wsdl " + wsdlUrl + " for " +

                                request.getRequestURL() +

                                (queryString != null ? ("?"+queryString) : ""));

                }

            } catch(Exception e) {

                logger.log(Level.INFO, "Failure serving WSDL for web service " +

                           webService.getName(), e);

            } finally {

                if(is != null) {

                    try {

                        is.close();

                    } catch(IOException ex) {}

                }

            }

        }

        if( !success ) {

            String message =

                "Invalid wsdl request " +  request.getRequestURL() +

                (queryString != null ? ("?"+queryString) : "") +

                " for web service "+ webService.getName();

               

            logger.info(message);

            writeInvalidMethodType(response, message);

        }

       

        return success;

    }

    /**

     * All wsdl files and wsdl imported files live under a well-known

     * wsdl directory.

     * @param uri module uri

     */

    public boolean isWsdlContent(String uri, BundleDescriptor bundle) {

        String wsdlDir = getWsdlDir(bundle);

        return (uri != null) && uri.startsWith(wsdlDir);

    }

    /**

     * @return module-specific dedicated wsdl directory

     */

    public String getWsdlDir(BundleDescriptor bundle) {

        boolean isWar = (bundle instanceof WebBundleDescriptor);

        return isWar ? "WEB-INF/wsdl" : "META-INF/wsdl";

    }

    /**

     * Set up a stub for request/response SOAP message logging.

     */

    public void setClientTransportLog(ServiceReferenceDescriptor serviceRef,

                                      Stub stub, String transportLogUrlStr) {

        try {

           

            final String logUrlString  = transportLogUrlStr;

            OutputStream os = (OutputStream)

                java.security.AccessController.doPrivileged

                (new java.security.PrivilegedExceptionAction() {

                    public java.lang.Object run() throws Exception {

                        URL transportLogUrl = new URL(logUrlString);

                        File transportFile =new File(transportLogUrl.getFile());

                        return new FileOutputStream(transportFile, true);

                    }

                });

            ClientTransportFactory transportFactory =

                rpcFactory.createClientTransportFactory(

                        ClientTransportFactoryTypes.HTTP, os);

            if( stub instanceof StubBase ) {

                ((StubBase)stub)._setTransportFactory(transportFactory);

                logger.info("Logging client transport for service-ref " +

                            serviceRef.getName() + " to file " +

                            transportLogUrlStr);

            }

        } catch(PrivilegedActionException pae) {

            logger.log(Level.INFO, "", pae.getCause());

        } catch(Throwable t) {

            logger.log(Level.INFO, "", t);

        }

    }

    /**

     * Collect all relative imports from a web service's main wsdl document.

     *

     *@param wsdlRelativeImports outupt param in which wsdl relative imports

     * will be added

     *

     *@param schemaRelativeImports outupt param in which schema relative

     * imports will be added

     */

    public void parseRelativeImports(URL wsdlFileUrl,

                                      Collection wsdlRelativeImports,

                                      Collection wsdlIncludes,

                                      Collection schemaRelativeImports,

                                       Collection schemaIncludes)

        throws Exception {

       

        // We will use our little parser rather than using JAXRPC's heavy weight WSDL parser

        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

        factory.setNamespaceAware(true);

        InputStream is = null;

        try {

            DocumentBuilder builder = factory.newDocumentBuilder();

            is = wsdlFileUrl.openStream();

            Document document = builder.parse(is);

            procesSchemaImports(document, schemaRelativeImports);

            procesWsdlImports(document, wsdlRelativeImports);

            procesSchemaIncludes(document, schemaIncludes);

            procesWsdlIncludes(document, wsdlIncludes);

        } catch (SAXParseException spe) {

            // Error generated by the parser

            logger.log(Level.SEVERE,"\n** Parsing error" + ", line " +

                spe.getLineNumber() + ", uri " + spe.getSystemId());

            // Use the contained exception, if any

            Exception x = spe;

            if (spe.getException() != null) {

                x = spe.getException();

            }

            x.printStackTrace();

        } catch (Exception sxe) {

            logger.log(Level.SEVERE, "Error parsing WSDL" + sxe.getMessage());

        } finally {

            try {

                if(is != null) {

                    is.close();

                }

            } catch (IOException io) {}

        }

    }

    private void addImportsAndIncludes(NodeList list, Collection result,

                        String namespace, String location) throws SAXException,

                        ParserConfigurationException, IOException, SAXParseException {

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

            String givenLocation = null;

            Node element = list.item(i);

            NamedNodeMap attrs = element.getAttributes();

            Node n= attrs.getNamedItem(location);

            if(n != null) {

                givenLocation = n.getNodeValue();

            }

            if((givenLocation == null) ||

                ((givenLocation != null) && givenLocation.startsWith("http"))) {

                continue;

            }

            Import imp = new Import();

            imp.setLocation(givenLocation);

            if(namespace != null) {

                n = attrs.getNamedItem(namespace);

                if(n != null) {

                    imp.setNamespace(n.getNodeValue());

                }

            }

            result.add(imp);

        }       

        return;

    }

   

    private void procesSchemaImports(Document document, Collection schemaImportCollection) throws SAXException,

                ParserConfigurationException, IOException, SAXParseException {

        NodeList schemaImports =

                         document.getElementsByTagNameNS("http://www.w3.org/2001/XMLSchema", "import");

        addImportsAndIncludes(schemaImports, schemaImportCollection, "namespace", "schemaLocation");

    }

    private void procesWsdlImports(Document document, Collection wsdlImportCollection) throws SAXException,

                ParserConfigurationException, IOException, SAXParseException {

        NodeList wsdlImports =

                         document.getElementsByTagNameNS("http://schemas.xmlsoap.org/wsdl/", "import");

        addImportsAndIncludes(wsdlImports, wsdlImportCollection, "namespace", "location");

    }       

    private void procesSchemaIncludes(Document document, Collection schemaIncludeCollection) throws SAXException,

                ParserConfigurationException, IOException, SAXParseException {

        NodeList schemaIncludes =

                         document.getElementsByTagNameNS("http://www.w3.org/2001/XMLSchema", "include");

        addImportsAndIncludes(schemaIncludes, schemaIncludeCollection, null, "schemaLocation");

    }

    private void procesWsdlIncludes(Document document, Collection wsdlIncludesCollection) throws SAXException,

                ParserConfigurationException, IOException, SAXParseException {

        NodeList wsdlIncludes =

                         document.getElementsByTagNameNS("http://schemas.xmlsoap.org/wsdl/", "include");

        addImportsAndIncludes(wsdlIncludes, wsdlIncludesCollection, null, "location");

    }       

    /**

     * Transform the deployed WSDL document for a given webservice by

     * replacing the ENDPOINT ADDRESS for each port with the actual

     * endpoint address on which it will be listening. 

     *

     */

    public void generateFinalWsdl(URL wsdlFileUrl, WebService webService, WebServerInfo wsi,

                                  File finalWsdlFile) throws Exception {

        // Before generating final WSDL, ensure that the @WebService svcName/portName

        // attributes (if any) match with those in wsdl - lets do this only for jaxws ervices

        if(webService.getMappingFileUri() == null) {

            for(WebServiceEndpoint endpoint : webService.getEndpoints()) {

                DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();

                InputSource inputSource =

                        new InputSource(new BufferedInputStream(new FileInputStream(wsdlFileUrl.getPath())));

                Document wsdlDoc =

                        dFactory.newDocumentBuilder().parse(new BufferedInputStream(new FileInputStream(wsdlFileUrl.getPath())));

                XPathFactory xPathFactory = XPathFactory.newInstance();

                XPath xPath = xPathFactory.newXPath();

                NamespaceContext context =

                        new com.sun.enterprise.webservice.monitoring.NamespaceContextImpl(wsdlDoc);

                xPath.setNamespaceContext(context);

                String xpathExpression = "/:definitions/:service/@name";

                String expStr = xPath.evaluate(xpathExpression, inputSource);

                if (!endpoint.getWsdlService().getLocalPart().equals(expStr)) {

                    throw new Exception(localStrings.getLocalString(

                            "enterprise.webservice.serviceNameMismatch",

                            "There is a mismatch in the serviceName specified with @WebService annotation in the endpoint implementation and the serviceName found in the WSDL; ServiceName in WSDL={0}; ServiceName in endpoint={1}",

                            new Object[] {expStr,endpoint.getWsdlService().getLocalPart()}));

                }               

               

                inputSource =

                        new InputSource(new BufferedInputStream(new FileInputStream(wsdlFileUrl.getPath())));

                xpathExpression = "/:definitions/:service/:port/@name";

                expStr = xPath.evaluate(xpathExpression, inputSource);

                if (!endpoint.getWsdlPort().getLocalPart().equals(expStr)) {

                    throw new Exception(localStrings.getLocalString(

                            "enterprise.webservice.portNameMismatch",

                            "There is a mismatch in the portName specified with @WebService annotation in the endpoint implementation and the portName found in the WSDL; PortName in WSDL={0}; PortName in endpoint={1}",

                            new Object[] {expStr,endpoint.getWsdlPort().getLocalPart()}));

                }

            }

        }

*/

       

        OutputStream outputStream =

            new BufferedOutputStream(new FileOutputStream(finalWsdlFile));

        generateFinalWsdl(wsdlFileUrl, webService, wsi, outputStream);

                                     

    }

   

    public void generateFinalWsdl(URL wsdlFileUrl, WebService webService, WebServerInfo wsi,

                                  OutputStream outputStream) throws Exception {

                                     

        Switch theSwitch = Switch.getSwitch();

        String webServiceName = webService.getName();

        Collection wsdlRelativeImports = new HashSet();

        Collection wsdlIncludes = new HashSet();

        Collection schemaRelativeImports = new HashSet();

        Collection schemaIncludes = new HashSet();

        if( webService.hasUrlPublishing() ) {

            parseRelativeImports(wsdlFileUrl, wsdlRelativeImports,

                         wsdlIncludes, schemaRelativeImports, schemaIncludes);

        }

       

        Collection endpoints = webService.getEndpoints();

        // a WSDL file can contain several ports associated to a service.

        // however Deployment descriptors can be expressed in two ways

        // to describe such a scenario in webservices.xml :

        //  - One webservice-description with 2 port-components

        //  - Two webservice-description with 1 port-component

        // The issue with #1, is that we need to configure the XSL with

        // the two ports so that the resulting unique WSDL has the correct

        // endpoint information and the JAXRPC stubs generated correctly.

        // So we need to check if this bundle is declaring more webservice

        // descriptor pointing to the same WSDL file...

        Collection endpointsCopy = new ArrayList();

        endpointsCopy.addAll(endpoints);

       

        BundleDescriptor bundle = webService.getBundleDescriptor();

        WebServicesDescriptor wsd = bundle.getWebServices();

        Collection webServices = wsd.getWebServices();

        if (webServices.size()>1) {

            for (Iterator wsIter = webServices.iterator();wsIter.hasNext();) {

                WebService aWS = (WebService) wsIter.next();

                if (webService.getName().equals(aWS.getName())) {

                    continue;

                }

                // this is another web service defined in the same bundle.

                // let's check if it points to the same WSDL file

                if ((webService.getWsdlFileUri() != null) &&

                     (aWS.getWsdlFileUri() != null) &&

                     (webService.getWsdlFileUri().equals(aWS.getWsdlFileUri()))) {

                    endpointsCopy.addAll(aWS.getEndpoints());

                } else if ((webService.getWsdlFileUrl() != null) &&

                     (aWS.getWsdlFileUrl() != null) &&

                     ((webService.getWsdlFileUrl().toString())

                        .equals(aWS.getWsdlFileUrl().toString()))) {

                    endpointsCopy.addAll(aWS.getEndpoints());

                }

            }

        }

       

        // Load the wsdl file bytes with caching turned off.  This is

        // to avoid a jar url consistency problem that can arise if we

        // overwrite the module file later on in deployment.

        InputStream wsdlInputStream = new BufferedInputStream(wsdlFileUrl.openStream());

        Source XsltWsdlDocument = new StreamSource(wsdlInputStream);

        Templates templates = createTemplatesFor

            (endpointsCopy, wsdlRelativeImports, wsdlIncludes,

                schemaRelativeImports, schemaIncludes);

                                                

        Transformer transformer = templates.newTransformer();

        // WSDL is associated with webservice, but url is endpoint-specific,

        // so let WebService choose which endpoint to use.

        WebServiceEndpoint endpointForImport =

            webService.pickEndpointForRelativeImports();

        URL root= wsi.getWebServerRootURL(endpointForImport.isSecure());

        URL finalWsdlUrl = endpointForImport.composeFinalWsdlUrl(root);

       

        int wsdlImportNum = 0;

        for(Iterator iter = wsdlRelativeImports.iterator(); iter.hasNext();){

            Import next = (Import) iter.next();

            transformer.setParameter

                (WSDL_IMPORT_NAMESPACE_PARAM_NAME + wsdlImportNum,

                 next.getNamespace());

           

            // Convert each relative import into an absolute import, using

            // the final wsdl's Url as the context

            URL relativeUrl  = new URL(finalWsdlUrl, next.getLocation());

            transformer.setParameter

                (WSDL_IMPORT_LOCATION_PARAM_NAME + wsdlImportNum, relativeUrl);

           

            wsdlImportNum++;

        }

        int schemaImportNum = 0;

        for(Iterator iter = schemaRelativeImports.iterator(); iter.hasNext();){

            Import next = (Import) iter.next();