1 /*

     2  * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.

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

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 /**

    24  * @test

    25  * @bug 8004476

    26  * @summary test XSLT extension functions

    27  * @run main/othervm XSLTExFuncTest

    28  */

    29 

    30 import java.io.StringWriter;

    31 import java.security.AllPermission;

    32 import java.security.CodeSource;

    33 import java.security.Permission;

    34 import java.security.PermissionCollection;

    35 import java.security.Permissions;

    36 import java.security.Policy;

    37 import java.security.ProtectionDomain;

    38 import javax.xml.transform.*;

    39 import javax.xml.transform.sax.SAXSource;

    40 import javax.xml.transform.stream.StreamResult;

    41 import org.xml.sax.InputSource;

    42 

    43 /**

    44  * test XSLT extension functions

    45  *

    46  * @author huizhe.wang@oracle.com

    47  */

    48 public class XSLTExFuncTest extends TestBase {

    49 

    50     final static String ENABLE_EXTENSION_FUNCTIONS = "http://www.oracle.com/xml/jaxp/properties/enableExtensionFunctions";

    51     final static String CLASSNAME = "DocumentBuilderFactoryImpl";

    52 

    53     /**

    54      * Creates a new instance of StreamReader

    55      */

    56     public XSLTExFuncTest(String name) {

    57         super(name);

    58     }

    59     boolean hasSM;

    60     String xslFile, xslFileId;

    61     String xmlFile, xmlFileId;

    62 

    63     protected void setUp() {

    64         super.setUp();

    65         xmlFile = filepath + "/tokenize.xml";

    66         xslFile = filepath + "/tokenize.xsl";

    67 

    68         /**

    69          * if (isWindows) { xslFile = "/" + xslFile; }

    70          *

    71          */

    72         xslFileId = "file://" + xslFile;

    73     }

    74 

    75     /**

    76      * @param args the command line arguments

    77      */

    78     public static void main(String[] args) {

    79         XSLTExFuncTest test = new XSLTExFuncTest("OneTest");

    80         test.setUp();

    81 

    82         test.testExtFunc();

    83         test.testExtFuncNotAllowed();

    84         test.testEnableExtFunc();

    85         test.testTemplatesEnableExtFunc();

    86         test.tearDown();

    87 

    88     }

    89 

    90     /**

    91      * by default, extension function is enabled

    92      */

    93     public void testExtFunc() {

    94         TransformerFactory factory = TransformerFactory.newInstance();

    95 

    96         try {

    97             transform(factory);

    98             System.out.println("testExtFunc: OK");

    99         } catch (TransformerConfigurationException e) {

   100             fail(e.getMessage());

   101         } catch (TransformerException ex) {

   102             fail(ex.getMessage());

   103         }

   104     }

   105 

   106     /**

   107      * Security is enabled, extension function not allowed

   108      */

   109     public void testExtFuncNotAllowed() {

   110         Policy p = new SimplePolicy(new AllPermission());

   111         Policy.setPolicy(p);

   112         System.setSecurityManager(new SecurityManager());

   113         TransformerFactory factory = TransformerFactory.newInstance();

   114 

   115         try {

   116             transform(factory);

   117         } catch (TransformerConfigurationException e) {

   118             fail(e.getMessage());

   119         } catch (TransformerException ex) {

   120             //expected since extension function is disallowed

   121             System.out.println("testExtFuncNotAllowed: OK");

   122         } finally {

   123             System.setSecurityManager(null);

   124         }

   125     }

   126 

   127     /**

   128      * Security is enabled, use new feature: enableExtensionFunctions

   129      */

   130     public void testEnableExtFunc() {

   131         Policy p = new SimplePolicy(new AllPermission());

   132         Policy.setPolicy(p);

   133         System.setSecurityManager(new SecurityManager());

   134         TransformerFactory factory = TransformerFactory.newInstance();

   135 

   136         /**

   137          * Use of the extension function 'http://exslt.org/strings:tokenize' is

   138          * not allowed when the secure processing feature is set to true.

   139          * Attempt to use the new property to enable extension function

   140          */

   141         boolean isExtensionSupported = enableExtensionFunction(factory);

   142 

   143         try {

   144             transform(factory);

   145             System.out.println("testEnableExt: OK");

   146         } catch (TransformerConfigurationException e) {

   147             fail(e.getMessage());

   148         } catch (TransformerException e) {

   149             fail(e.getMessage());

   150         } finally {

   151             System.setSecurityManager(null);

   152         }

   153     }

   154 

   155     /**

   156      * use Templates template = factory.newTemplates(new StreamSource( new

   157      * FileInputStream(xslFilename))); // Use the template to create a

   158      * transformer Transformer xformer = template.newTransformer();

   159      *

   160      * @param factory

   161      * @return

   162      */

   163     /**

   164      * Security is enabled, use new feature: enableExtensionFunctions Use the

   165      * template to create a transformer

   166      */

   167     public void testTemplatesEnableExtFunc() {

   168         Policy p = new SimplePolicy(new AllPermission());

   169         Policy.setPolicy(p);

   170         System.setSecurityManager(new SecurityManager());

   171         TransformerFactory factory = TransformerFactory.newInstance();

   172 

   173         /**

   174          * Use of the extension function 'http://exslt.org/strings:tokenize' is

   175          * not allowed when the secure processing feature is set to true.

   176          * Attempt to use the new property to enable extension function

   177          */

   178         boolean isExtensionSupported = enableExtensionFunction(factory);

   179 

   180         try {

   181             SAXSource xslSource = new SAXSource(new InputSource(xslFile));

   182             xslSource.setSystemId(xslFileId);

   183             Templates template = factory.newTemplates(xslSource);

   184             Transformer transformer = template.newTransformer();

   185             StringWriter stringResult = new StringWriter();

   186             Result result = new StreamResult(stringResult);

   187             transformer.transform(new SAXSource(new InputSource(xmlFile)), result);

   188             System.out.println("testTemplatesEnableExtFunc: OK");

   189         } catch (TransformerConfigurationException e) {

   190             fail(e.getMessage());

   191         } catch (TransformerException e) {

   192             fail(e.getMessage());

   193         } finally {

   194             System.setSecurityManager(null);

   195         }

   196     }

   197 

   198     boolean enableExtensionFunction(TransformerFactory factory) {

   199         boolean isSupported = true;

   200         try {

   201             factory.setFeature(ENABLE_EXTENSION_FUNCTIONS, true);

   202         } catch (TransformerConfigurationException ex) {

   203             isSupported = false;

   204         }

   205         return isSupported;

   206     }

   207 

   208     void transform(TransformerFactory factory) throws TransformerConfigurationException, TransformerException {

   209         SAXSource xslSource = new SAXSource(new InputSource(xslFile));

   210         xslSource.setSystemId(xslFileId);

   211         Transformer transformer = factory.newTransformer(xslSource);

   212         StringWriter stringResult = new StringWriter();

   213         Result result = new StreamResult(stringResult);

   214         transformer.transform(new SAXSource(new InputSource(xmlFile)), result);

   215     }

   216 

   217     class SimplePolicy extends Policy {

   218 

   219         private final Permissions perms;

   220 

   221         public SimplePolicy(Permission... permissions) {

   222             perms = new Permissions();

   223             for (Permission permission : permissions) {

   224                 perms.add(permission);

   225             }

   226         }

   227 

   228         @Override

   229         public PermissionCollection getPermissions(CodeSource cs) {

   230             return perms;

   231         }

   232 

   233         @Override

   234         public PermissionCollection getPermissions(ProtectionDomain pd) {

   235             return perms;

   236         }

   237 

   238         @Override

   239         public boolean implies(ProtectionDomain pd, Permission p) {

   240             return perms.implies(p);

   241         }

   242 

   243         //for older jdk

   244         @Override

   245         public void refresh() {

   246         }

   247     }

   248 }