| /************************************************************** | |
| * | |
| * 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 com.sun.star.xml.security.uno; | |
| import javax.xml.parsers.DocumentBuilder; | |
| import javax.xml.parsers.DocumentBuilderFactory; | |
| import javax.xml.parsers.ParserConfigurationException; | |
| import java.io.File; | |
| import java.io.IOException; | |
| import java.io.FileOutputStream; | |
| import java.io.FileInputStream; | |
| import java.io.InputStream; | |
| import java.io.ByteArrayInputStream; | |
| import java.io.UnsupportedEncodingException; | |
| import org.w3c.dom.Document; | |
| import org.w3c.dom.Node; | |
| import org.w3c.dom.NodeList; | |
| /* Basic GUI components */ | |
| import javax.swing.JFrame; | |
| import javax.swing.JPanel; | |
| import javax.swing.JScrollPane; | |
| import javax.swing.JTree; | |
| import javax.swing.JButton; | |
| import javax.swing.JCheckBox; | |
| import javax.swing.JTextArea; | |
| import javax.swing.JTextField; | |
| import javax.swing.JFileChooser; | |
| import javax.swing.ToolTipManager; | |
| import javax.swing.JTable; | |
| import javax.swing.JLabel; | |
| import javax.swing.BorderFactory; | |
| /* GUI components for right-hand side */ | |
| import javax.swing.JSplitPane; | |
| import javax.swing.JOptionPane; | |
| import javax.swing.JTabbedPane; | |
| /* GUI support classes */ | |
| import java.awt.BorderLayout; | |
| import java.awt.Dimension; | |
| import java.awt.Container; | |
| import java.awt.Toolkit; | |
| import java.awt.event.WindowEvent; | |
| import java.awt.event.WindowAdapter; | |
| import java.awt.event.ActionEvent; | |
| import java.awt.event.ActionListener; | |
| /* For creating borders */ | |
| import javax.swing.border.EmptyBorder; | |
| import javax.swing.border.BevelBorder; | |
| import javax.swing.border.CompoundBorder; | |
| /* For creating a TreeModel */ | |
| import javax.swing.tree.TreePath; | |
| import java.util.Vector; | |
| /* UNO classes */ | |
| import com.sun.star.uno.UnoRuntime; | |
| import com.sun.star.bridge.XUnoUrlResolver; | |
| import com.sun.star.lang.XMultiComponentFactory; | |
| import com.sun.star.beans.XPropertySet; | |
| import com.sun.star.uno.XComponentContext; | |
| import com.sun.star.xml.sax.XDocumentHandler; | |
| import com.sun.star.xml.crypto.*; | |
| import com.sun.star.xml.crypto.sax.*; | |
| public class TestTool extends JFrame implements ActionListener | |
| { | |
| /* | |
| * xml security framewrok component names | |
| */ | |
| public static String SIGNATURECREATOR_COMPONENT = "com.sun.star.xml.crypto.sax.SignatureCreator"; | |
| public static String SIGNATUREVERIFIER_COMPONENT = "com.sun.star.xml.crypto.sax.SignatureVerifier"; | |
| public static String ENCRYPTOR_COMPONENT = "com.sun.star.xml.crypto.sax.Encryptor"; | |
| public static String DECRYPTOR_COMPONENT = "com.sun.star.xml.crypto.sax.Decryptor"; | |
| public static String SAXEVENTKEEPER_COMPONENT = "com.sun.star.xml.crypto.sax.SAXEventKeeper"; | |
| /* | |
| * Java-based component names | |
| */ | |
| public static String SEINITIALIZER_COMPONENT_JAVA = "com.sun.star.xml.security.bridge.jxsec.SEInitializer_JxsecImpl"; | |
| public static String XMLSIGNATURE_COMPONENT_JAVA = "com.sun.star.xml.security.bridge.jxsec.XMLSignature_JxsecImpl"; | |
| public static String XMLENCRYPTION_COMPONENT_JAVA = "com.sun.star.xml.security.bridge.jxsec.XMLEncryption_JxsecImpl"; | |
| public static String XMLDOCUMENTWRAPPER_COMPONENT_JAVA = "com.sun.star.xml.security.bridge.jxsec.XMLDocumentWrapper_JxsecImpl"; | |
| /* | |
| * C-based component names | |
| */ | |
| public static String SEINITIALIZER_COMPONENT_C = "com.sun.star.xml.crypto.SEInitializer"; | |
| public static String XMLSIGNATURE_COMPONENT_C = "com.sun.star.xml.crypto.XMLSignature"; | |
| public static String XMLENCRYPTION_COMPONENT_C = "com.sun.star.xml.crypto.XMLEncryption"; | |
| public static String XMLDOCUMENTWRAPPER_COMPONENT_C = "com.sun.star.xml.wrapper.XMLDocumentWrapper"; | |
| /* url resolver name */ | |
| public static String UNOURLRESOLVER = "com.sun.star.bridge.UnoUrlResolver"; | |
| /* | |
| * connection URL | |
| */ | |
| private String m_unoURL = "uno:socket,host=localhost,port=2002;urp;StarOffice.ServiceManager"; | |
| /* key file */ | |
| private String m_javaTokenFile = null; | |
| private String m_nssTokenPath = null; | |
| /* User Interfaces */ | |
| private JButton m_goButton; | |
| private JButton m_stepButton; | |
| private JButton m_startButton; | |
| private JButton m_openButton; | |
| private JCheckBox m_isExportingButton; | |
| private JCheckBox m_isJavaComponentButton; | |
| private JButton m_saveButton; | |
| private JButton m_batchButton; | |
| private JTree m_leftTree; | |
| private JTextArea m_leftTextArea; | |
| private JTree m_middleTree; | |
| private JTree m_rightTree; | |
| private JTabbedPane m_leftTabPane; | |
| private JTextArea m_bufferNodeTextArea; | |
| private JLabel m_saxChainLabel; | |
| private JTextField m_saxEventText; | |
| private JTable m_unsolvedReferenceTable; | |
| /* | |
| * whether a batch file is running, | |
| * if so, no message box is popped up | |
| */ | |
| private boolean m_bIsBatchRunning = false; | |
| /* | |
| * whether the UI needs to be updated. | |
| * when user click the "go" button, the UI needs | |
| * not to be updated step by step for performance | |
| * reason | |
| */ | |
| private boolean m_bIsUIUpdateSuppressed = false; | |
| /* | |
| * three DOM tree adapter | |
| */ | |
| private DomToTreeModelAdapter m_leftTreeModelAdapter; | |
| private DomToTreeModelAdapter m_middleTreeModelAdapter; | |
| private DomToTreeModelAdapter m_rightTreeModelAdapter; | |
| /* | |
| * the current directory, which reserves the default | |
| * location when user open/save a file. | |
| */ | |
| private File m_currentDirectory = null; | |
| /* | |
| * the log file | |
| */ | |
| private FileOutputStream m_logFileOutputStream = null; | |
| /* | |
| * the thread which is parsing the current XML | |
| * file | |
| */ | |
| private ParsingThread m_parsingThread; | |
| /* | |
| * whether is exporting or importing | |
| */ | |
| private boolean m_bIsExporting; | |
| /* | |
| * whether java based component or c based component | |
| * is used now | |
| */ | |
| private boolean m_bIsJavaBased; | |
| /* | |
| * XML security component interface | |
| */ | |
| private XComponentContext m_xRemoteContext = null; | |
| private XMultiComponentFactory m_xRemoteServiceManager = null; | |
| private XXMLSecurityContext m_xXMLSecurityContext = null; | |
| private XXMLSignature m_xXMLSignature = null; | |
| private XXMLEncryption m_xXMLEncryption = null; | |
| private XSEInitializer m_xSEInitializer = null; | |
| /* | |
| * SAX event collector for the middle tree and the right tree | |
| */ | |
| private SAXEventCollector m_rightTreeEventCollector = null; | |
| private SAXEventCollector m_middleTreeEventCollector = null; | |
| /* | |
| * security framework controller | |
| */ | |
| private XMLSecurityFrameworkController m_xmlSecurityFrameworkController = null; | |
| /* org.w3c.dom.Document */ | |
| private Document m_document; | |
| /* represents whether "Go" or "Step" */ | |
| private boolean stepMode = true; | |
| /************************************************************************************** | |
| * private methods | |
| **************************************************************************************/ | |
| /****************************************************************************** | |
| * UI related methods | |
| ******************************************************************************/ | |
| /* | |
| * initializes the UI. | |
| */ | |
| private void initUI() | |
| { | |
| m_leftTreeModelAdapter = new DomToTreeModelAdapter(m_document); | |
| m_middleTreeModelAdapter = new DomToTreeModelAdapter(m_document); | |
| m_rightTreeModelAdapter = new DomToTreeModelAdapter(m_document); | |
| m_parsingThread = null; | |
| m_leftTree.setModel(m_leftTreeModelAdapter); | |
| m_middleTree.setModel(m_middleTreeModelAdapter); | |
| m_rightTree.setModel(m_rightTreeModelAdapter); | |
| } | |
| /* | |
| * constructs the user interface. | |
| */ | |
| private Container buildUI(int width, int height) | |
| { | |
| JPanel mainPanel = new JPanel(); | |
| int frameHeight = height-40; | |
| int leftWindowWidth = (width-40)/3; | |
| int middleWindowWidth = leftWindowWidth; | |
| int rightWindowWidth = leftWindowWidth; | |
| int leftPaneWidth = leftWindowWidth+middleWindowWidth; | |
| int frameWidth = leftPaneWidth + rightWindowWidth; | |
| /* Make a nice border */ | |
| EmptyBorder emptyBorder = new EmptyBorder(5,5,5,5); | |
| BevelBorder bevelBorder = new BevelBorder(BevelBorder.LOWERED); | |
| CompoundBorder compoundBorder = new CompoundBorder(emptyBorder,bevelBorder); | |
| mainPanel.setBorder(new CompoundBorder(compoundBorder,emptyBorder)); | |
| /* Set up the tree */ | |
| m_leftTreeModelAdapter = new DomToTreeModelAdapter(m_document); | |
| m_middleTreeModelAdapter = new DomToTreeModelAdapter(m_document); | |
| m_rightTreeModelAdapter = new DomToTreeModelAdapter(m_document); | |
| m_leftTree = new JTree(m_leftTreeModelAdapter); | |
| m_leftTextArea = new JTextArea(); | |
| m_middleTree = new JTree(m_middleTreeModelAdapter); | |
| m_rightTree = new JTree(m_rightTreeModelAdapter); | |
| ToolTipManager.sharedInstance().registerComponent(m_leftTree); | |
| ToolTipManager.sharedInstance().registerComponent(m_middleTree); | |
| ToolTipManager.sharedInstance().registerComponent(m_rightTree); | |
| /* Builds left tab pane */ | |
| JScrollPane leftTreePane = new JScrollPane(m_leftTree); | |
| JScrollPane leftTextPane = new JScrollPane(m_leftTextArea); | |
| m_leftTabPane= new JTabbedPane(); | |
| m_leftTabPane.add("Tree View",leftTreePane); | |
| m_leftTabPane.add("Text View",leftTextPane); | |
| /* Builds middle tree pane */ | |
| JScrollPane middleTreePane = new JScrollPane(m_middleTree); | |
| /* Builds right tree pane */ | |
| JScrollPane rightTreePane = new JScrollPane(m_rightTree); | |
| rightTreePane.setBorder(BorderFactory.createCompoundBorder( | |
| BorderFactory.createTitledBorder("Result"), | |
| BorderFactory.createEmptyBorder(8,8,8,8))); | |
| m_leftTabPane.setPreferredSize( | |
| new Dimension( leftWindowWidth, frameHeight )); | |
| middleTreePane.setPreferredSize( | |
| new Dimension( middleWindowWidth, frameHeight )); | |
| rightTreePane.setPreferredSize( | |
| new Dimension( rightWindowWidth, frameHeight )); | |
| /* Builds the SAX event text box */ | |
| m_saxEventText = new JTextField(); | |
| /* Builds the unsolved reference table */ | |
| m_unsolvedReferenceTable = new JTable( | |
| new UnsolvedReferenceTableModel(this)); | |
| /* Builds the BufferNode information text area */ | |
| m_bufferNodeTextArea = new JTextArea(); | |
| /* Builds the SAX chain information label */ | |
| m_saxChainLabel = new JLabel(); | |
| /* Builds the left pane */ | |
| JPanel tabPaneWithSaxEventPane = new JPanel(); | |
| tabPaneWithSaxEventPane.setLayout(new BorderLayout()); | |
| tabPaneWithSaxEventPane.add("Center",m_leftTabPane); | |
| tabPaneWithSaxEventPane.add("South",new JScrollPane(m_saxEventText)); | |
| JSplitPane leftPane = | |
| new JSplitPane( JSplitPane.VERTICAL_SPLIT, | |
| tabPaneWithSaxEventPane, | |
| new JScrollPane(m_unsolvedReferenceTable)); | |
| leftPane.setBorder(BorderFactory.createCompoundBorder( | |
| BorderFactory.createTitledBorder("Original"), | |
| BorderFactory.createEmptyBorder(8,8,8,8))); | |
| leftPane.setContinuousLayout( true ); | |
| leftPane.setDividerLocation( frameHeight*2/3 ); | |
| leftPane.setPreferredSize( | |
| new Dimension( leftWindowWidth, frameHeight )); | |
| /* Builds the middle pane */ | |
| JPanel bufferNodeWithSaxChainPane = new JPanel(); | |
| bufferNodeWithSaxChainPane.setLayout(new BorderLayout()); | |
| bufferNodeWithSaxChainPane.add("Center",m_bufferNodeTextArea); | |
| bufferNodeWithSaxChainPane.add("South",new JScrollPane(m_saxChainLabel)); | |
| JSplitPane middlePane = | |
| new JSplitPane( JSplitPane.VERTICAL_SPLIT, | |
| middleTreePane, | |
| new JScrollPane(bufferNodeWithSaxChainPane)); | |
| middlePane.setBorder(BorderFactory.createCompoundBorder( | |
| BorderFactory.createTitledBorder("Insight SAXEventKeeper"), | |
| BorderFactory.createEmptyBorder(8,8,8,8))); | |
| middlePane.setContinuousLayout( true ); | |
| middlePane.setDividerLocation( frameHeight/2+5 ); | |
| middlePane.setPreferredSize( | |
| new Dimension( middleWindowWidth, frameHeight )); | |
| /* Builds the whole frame pane */ | |
| JSplitPane leftWithMiddlePane = | |
| new JSplitPane( JSplitPane.HORIZONTAL_SPLIT, | |
| leftPane, | |
| middlePane ); | |
| leftWithMiddlePane.setContinuousLayout( true ); | |
| leftWithMiddlePane.setDividerLocation( leftWindowWidth ); | |
| leftWithMiddlePane.setPreferredSize( | |
| new Dimension( leftPaneWidth + 10, frameHeight+10 )); | |
| JSplitPane framePane = | |
| new JSplitPane( JSplitPane.HORIZONTAL_SPLIT, | |
| leftWithMiddlePane, | |
| rightTreePane ); | |
| framePane.setContinuousLayout( true ); | |
| framePane.setDividerLocation(leftPaneWidth+10 ); | |
| framePane.setPreferredSize( | |
| new Dimension( frameWidth + 20, frameHeight+10 )); | |
| /* Adds all GUI components to the main panel */ | |
| mainPanel.setLayout(new BorderLayout()); | |
| mainPanel.add("Center", framePane ); | |
| m_openButton = new JButton("Open..."); | |
| m_openButton.addActionListener(this); | |
| m_goButton = new JButton("Go!"); | |
| m_goButton.addActionListener(this); | |
| m_stepButton = new JButton("Step"); | |
| m_stepButton.addActionListener(this); | |
| m_startButton = new JButton("Start"); | |
| m_startButton.addActionListener(this); | |
| m_startButton.setEnabled(false); | |
| m_isExportingButton = new JCheckBox("export, not import", true); | |
| m_isJavaComponentButton = new JCheckBox("use java component", false); | |
| m_saveButton = new JButton("Save..."); | |
| m_saveButton.addActionListener(this); | |
| m_batchButton = new JButton("Batch..."); | |
| m_batchButton.addActionListener(this); | |
| JPanel buttonPanel = new JPanel(); | |
| buttonPanel.add(m_batchButton); | |
| buttonPanel.add(m_openButton); | |
| buttonPanel.add(m_startButton); | |
| buttonPanel.add(m_goButton); | |
| buttonPanel.add(m_stepButton); | |
| buttonPanel.add(m_isExportingButton); | |
| buttonPanel.add(m_isJavaComponentButton); | |
| buttonPanel.add(m_saveButton); | |
| mainPanel.add("South", buttonPanel); | |
| enableGoButton(false); | |
| return mainPanel; | |
| } | |
| /* | |
| * enables/disables the Go(and Step) button. | |
| */ | |
| private void enableGoButton(boolean enabled) | |
| { | |
| m_goButton.setEnabled(enabled); | |
| m_stepButton.setEnabled(enabled); | |
| } | |
| /* | |
| * updates the unsolved reference information. | |
| */ | |
| private void updatesUnsolvedReferencesInformation() | |
| { | |
| m_unsolvedReferenceTable.setModel(new UnsolvedReferenceTableModel(this)); | |
| } | |
| /* | |
| * adjusts the view of the tree in order to make the | |
| * particular Node into the focus tree leaf. | |
| */ | |
| private void updatesTree(Node node, JTree tree) | |
| { | |
| int i=0; | |
| int currentLine = 0; | |
| while (i<tree.getRowCount()) | |
| { | |
| TreePath treePath = tree.getPathForRow(i); | |
| tree.expandPath(treePath); | |
| AdapterNode adapterNode = (AdapterNode)treePath.getLastPathComponent(); | |
| if (node == adapterNode.getNode()) | |
| { | |
| tree.addSelectionPath(treePath); | |
| currentLine = i; | |
| } | |
| ++i; | |
| } | |
| tree.setCellRenderer(new XMLTreeCellRanderer(node)); | |
| tree.scrollRowToVisible(currentLine); | |
| } | |
| /****************************************************************************** | |
| * action listener related methods. | |
| ******************************************************************************/ | |
| /* | |
| * reads in a document, either the document is a file or | |
| * is a text paragraph. | |
| */ | |
| private void openDocument() | |
| { | |
| if (m_leftTabPane.getSelectedIndex() == 0) | |
| { | |
| File f = openFile(); | |
| if (f != null) | |
| { | |
| parseFile(f); | |
| } | |
| } | |
| else | |
| { | |
| String text = m_leftTextArea.getText(); | |
| try | |
| { | |
| parseStream(new ByteArrayInputStream(text.getBytes("UTF-8"))); | |
| } | |
| catch(UnsupportedEncodingException e) | |
| { | |
| e.printStackTrace(); | |
| } | |
| m_leftTabPane.setSelectedIndex(0); | |
| } | |
| } | |
| /* | |
| * save the result tree to a file. | |
| */ | |
| private void saveResult() | |
| { | |
| saveFile(); | |
| } | |
| /* | |
| * selects a batch file to excute. | |
| */ | |
| private void openBatch() | |
| { | |
| File f = openFile(); | |
| if (f != null) | |
| { | |
| runBatch(f); | |
| } | |
| } | |
| /* | |
| * makes the current operation to an end. | |
| */ | |
| private void endMission() | |
| { | |
| enableGoButton(false); | |
| m_parsingThread = null; | |
| if (m_xmlSecurityFrameworkController != null) | |
| { | |
| m_xmlSecurityFrameworkController.endMission(); | |
| } | |
| updatesUIs(); | |
| m_xmlSecurityFrameworkController = null; | |
| freeComponents(); | |
| System.gc(); | |
| } | |
| /****************************************************************************** | |
| * UNO component related methods | |
| ******************************************************************************/ | |
| /* | |
| * connects the SO server. | |
| */ | |
| private void connectSO(String unoUrlString) | |
| { | |
| if (unoUrlString != null) | |
| { | |
| m_unoURL = new String(unoUrlString); | |
| } | |
| try | |
| { | |
| m_xRemoteServiceManager = getRemoteServiceManager(m_unoURL); | |
| } | |
| catch(Exception e) | |
| { | |
| e.printStackTrace(); | |
| } | |
| } | |
| /* | |
| * creates UNO components. | |
| */ | |
| private boolean createComponents() | |
| { | |
| try | |
| { | |
| String SEInitializer_comp; | |
| String XMLSignature_comp; | |
| String XMLEncryption_comp; | |
| String tokenPath; | |
| if (m_bIsJavaBased) | |
| { | |
| SEInitializer_comp = SEINITIALIZER_COMPONENT_JAVA; | |
| XMLSignature_comp = XMLSIGNATURE_COMPONENT_JAVA; | |
| XMLEncryption_comp = XMLENCRYPTION_COMPONENT_JAVA; | |
| tokenPath = m_javaTokenFile; | |
| } | |
| else | |
| { | |
| SEInitializer_comp = SEINITIALIZER_COMPONENT_C; | |
| XMLSignature_comp = XMLSIGNATURE_COMPONENT_C; | |
| XMLEncryption_comp = XMLENCRYPTION_COMPONENT_C; | |
| tokenPath = m_nssTokenPath; | |
| } | |
| Object seInitializerObj = m_xRemoteServiceManager.createInstanceWithContext( | |
| SEInitializer_comp, m_xRemoteContext); | |
| if (seInitializerObj == null) | |
| { | |
| freeComponents(); | |
| return false; | |
| } | |
| m_xSEInitializer = UnoRuntime.queryInterface( | |
| XSEInitializer.class, seInitializerObj); | |
| m_xXMLSecurityContext = m_xSEInitializer.createSecurityContext(tokenPath); | |
| Object xmlSignatureObj = m_xRemoteServiceManager.createInstanceWithContext( | |
| XMLSignature_comp, m_xRemoteContext); | |
| if (xmlSignatureObj == null) | |
| { | |
| freeComponents(); | |
| return false; | |
| } | |
| m_xXMLSignature = UnoRuntime.queryInterface( | |
| XXMLSignature.class, xmlSignatureObj); | |
| Object xmlEncryptionObj = m_xRemoteServiceManager.createInstanceWithContext( | |
| XMLEncryption_comp, m_xRemoteContext); | |
| if (xmlEncryptionObj == null) | |
| { | |
| freeComponents(); | |
| return false; | |
| } | |
| m_xXMLEncryption = UnoRuntime.queryInterface( | |
| XXMLEncryption.class, xmlEncryptionObj); | |
| return true; | |
| } | |
| catch(Exception e) | |
| { | |
| freeComponents(); | |
| e.printStackTrace(); | |
| return false; | |
| } | |
| } | |
| /* | |
| * frees UNO components. | |
| */ | |
| private void freeComponents() | |
| { | |
| try | |
| { | |
| if (m_xXMLSecurityContext != null) | |
| { | |
| m_xSEInitializer.freeSecurityContext(m_xXMLSecurityContext); | |
| m_xXMLSecurityContext = null; | |
| } | |
| m_xXMLSignature = null; | |
| m_xXMLEncryption = null; | |
| m_xSEInitializer = null; | |
| } | |
| catch(Exception e) | |
| { | |
| e.printStackTrace(); | |
| } | |
| } | |
| /* | |
| * getRemoteServiceManager | |
| */ | |
| private XMultiComponentFactory getRemoteServiceManager(String unoUrl) throws java.lang.Exception | |
| { | |
| if (m_xRemoteContext == null) | |
| { | |
| /* | |
| * First step: create local component context, get local servicemanager and | |
| * ask it to create a UnoUrlResolver object with an XUnoUrlResolver interface | |
| */ | |
| XComponentContext xLocalContext = | |
| com.sun.star.comp.helper.Bootstrap.createInitialComponentContext(null); | |
| XMultiComponentFactory xLocalServiceManager = xLocalContext.getServiceManager(); | |
| Object urlResolver = xLocalServiceManager.createInstanceWithContext( | |
| UNOURLRESOLVER, xLocalContext ); | |
| /* | |
| * query XUnoUrlResolver interface from urlResolver object | |
| */ | |
| XUnoUrlResolver xUnoUrlResolver = UnoRuntime.queryInterface( | |
| XUnoUrlResolver.class, urlResolver ); | |
| /* | |
| * Second step: use xUrlResolver interface to import the remote StarOffice.ServiceManager, | |
| * retrieve its property DefaultContext and get the remote servicemanager | |
| */ | |
| Object initialObject = xUnoUrlResolver.resolve( unoUrl ); | |
| XPropertySet xPropertySet = UnoRuntime.queryInterface( | |
| XPropertySet.class, initialObject); | |
| Object context = xPropertySet.getPropertyValue("DefaultContext"); | |
| m_xRemoteContext = UnoRuntime.queryInterface( | |
| XComponentContext.class, context); | |
| } | |
| return m_xRemoteContext.getServiceManager(); | |
| } | |
| /****************************************************************************** | |
| * XML related methods | |
| ******************************************************************************/ | |
| /* | |
| * removes all empty text node inside the particular element | |
| */ | |
| private void removeEmptyText(Node node) | |
| { | |
| int type = node.getNodeType(); | |
| NodeList children; | |
| int i; | |
| switch (type) | |
| { | |
| case Node.DOCUMENT_NODE: | |
| case Node.ELEMENT_NODE: | |
| Node child = node.getFirstChild(); | |
| while (child!= null) | |
| { | |
| Node nextSibling = child.getNextSibling(); | |
| int childType = child.getNodeType(); | |
| if (childType==Node.TEXT_NODE) | |
| { | |
| String message = child.getNodeValue().trim(); | |
| if (message == null || message.length()<=0) | |
| { | |
| node.removeChild(child); | |
| } | |
| } | |
| else if (childType == Node.ELEMENT_NODE) | |
| { | |
| removeEmptyText(child); | |
| } | |
| child = nextSibling; | |
| } | |
| break; | |
| } | |
| } | |
| /* | |
| * reads a stream, and parses it into the original tree. | |
| */ | |
| private void parseStream(InputStream is) | |
| { | |
| try | |
| { | |
| DocumentBuilderFactory factory = | |
| DocumentBuilderFactory.newInstance(); | |
| m_document = null; | |
| m_startButton.setEnabled(false); | |
| initUI(); | |
| /* factory.setValidating(true); */ | |
| /* factory.setNamespaceAware(true); */ | |
| try | |
| { | |
| DocumentBuilder builder = factory.newDocumentBuilder(); | |
| m_document = builder.parse(is); | |
| m_startButton.setEnabled(true); | |
| initUI(); | |
| } | |
| catch (ParserConfigurationException pce) | |
| { | |
| pce.printStackTrace(); | |
| } | |
| catch (IOException ioe) | |
| { | |
| ioe.printStackTrace(); | |
| } | |
| } | |
| catch(Exception exce) | |
| { | |
| System.out.println("input stream Exception"); | |
| } | |
| } | |
| /****************************************************************************** | |
| * file operation related methods | |
| ******************************************************************************/ | |
| /* | |
| * opens a file, and parses it into the original tree. | |
| */ | |
| private void parseFile(File name) | |
| { | |
| try | |
| { | |
| FileInputStream fis = new FileInputStream(name); | |
| parseStream(fis); | |
| fis.close(); | |
| } | |
| catch(Exception exce) | |
| { | |
| System.out.println("open file Exception"); | |
| } | |
| } | |
| /* | |
| * selects a file to open | |
| */ | |
| private File openFile() | |
| { | |
| File rc = null; | |
| JFileChooser fileChooser= new JFileChooser(); | |
| fileChooser.setDialogTitle("Select File To Open"); | |
| fileChooser.setDialogType(JFileChooser.OPEN_DIALOG); | |
| fileChooser.setApproveButtonText("Ok"); | |
| if (m_currentDirectory == null) | |
| { | |
| fileChooser.rescanCurrentDirectory(); | |
| } | |
| else | |
| { | |
| fileChooser.setCurrentDirectory(m_currentDirectory); | |
| } | |
| fileChooser.setFileFilter(new XMLFileFilter()); | |
| int result = fileChooser.showDialog(this,null); | |
| if (result==fileChooser.APPROVE_OPTION) | |
| { | |
| m_currentDirectory = fileChooser.getCurrentDirectory(); | |
| rc = fileChooser.getSelectedFile(); | |
| } | |
| return rc; | |
| } | |
| private void saveFile() | |
| { | |
| JFileChooser fileChooser= new JFileChooser(); | |
| fileChooser.setDialogTitle("Select File To Save"); | |
| fileChooser.setDialogType(JFileChooser.SAVE_DIALOG); | |
| fileChooser.setApproveButtonText("Ok"); | |
| if (m_currentDirectory == null) | |
| { | |
| fileChooser.rescanCurrentDirectory(); | |
| } | |
| else | |
| { | |
| fileChooser.setCurrentDirectory(m_currentDirectory); | |
| } | |
| fileChooser.setFileFilter(new XMLFileFilter()); | |
| int result = fileChooser.showDialog(this,null); | |
| if (result==fileChooser.APPROVE_OPTION) | |
| { | |
| try | |
| { | |
| m_currentDirectory = fileChooser.getCurrentDirectory(); | |
| saveFile(fileChooser.getSelectedFile()); | |
| } | |
| catch(Exception exce) | |
| { | |
| System.out.println("save file Exception"); | |
| exce.printStackTrace(); | |
| } | |
| } | |
| } | |
| /* | |
| * excutes a batch file. | |
| */ | |
| private void runBatch(File f) | |
| { | |
| FileInputStream fis = null; | |
| try | |
| { | |
| fis = new FileInputStream(f); | |
| StringBuilder commandBuffer = new StringBuilder(); | |
| m_logFileOutputStream = new FileOutputStream("TestTool-log.txt"); | |
| m_bIsBatchRunning = true; | |
| int ch = 0; | |
| while (ch != -1) | |
| { | |
| ch = fis.read(); | |
| if (ch != 0x0a && ch != -1) | |
| { | |
| if (ch != 0x0d) | |
| { | |
| commandBuffer.append((char)ch); | |
| } | |
| } | |
| else | |
| { | |
| String command = new String(commandBuffer); | |
| if (command.startsWith("Open ")) | |
| { | |
| m_logFileOutputStream.write(("start \""+command+"\" ...\n").getBytes()); | |
| String fileName = command.substring(5); | |
| parseFile(new File(fileName)); | |
| m_logFileOutputStream.write("command end \n\n".getBytes()); | |
| } | |
| else if (command.startsWith("Use Java Component")) | |
| { | |
| m_logFileOutputStream.write(("start \""+command+"\" ...\n").getBytes()); | |
| m_isJavaComponentButton.setSelected(true); | |
| m_logFileOutputStream.write("command end \n\n".getBytes()); | |
| } | |
| else if (command.startsWith("Use C++ Component")) | |
| { | |
| m_logFileOutputStream.write(("start \""+command+"\" ...\n").getBytes()); | |
| m_isJavaComponentButton.setSelected(false); | |
| m_logFileOutputStream.write("command end \n\n".getBytes()); | |
| } | |
| else if (command.startsWith("Go ")) | |
| { | |
| m_logFileOutputStream.write(("start \""+command+"\" ...\n").getBytes()); | |
| String opera = command.substring(3); | |
| if (opera.equals("Sign") || opera.equals("Encrypt")) | |
| { | |
| m_isExportingButton.setSelected(true); | |
| } | |
| else | |
| { | |
| m_isExportingButton.setSelected(false); | |
| } | |
| startsUp(); | |
| if (m_parsingThread != null) | |
| { | |
| m_bIsUIUpdateSuppressed = true; | |
| try{ | |
| while (m_parsingThread.nextStep()); | |
| endMission(); | |
| } | |
| catch(Exception e) | |
| { | |
| System.out.println("exception happen during batch:"+e); | |
| e.printStackTrace(); | |
| } | |
| m_bIsUIUpdateSuppressed = false; | |
| updatesUIs(); | |
| } | |
| m_logFileOutputStream.write("command end \n\n".getBytes()); | |
| } | |
| else if (command.startsWith("Save ")) | |
| { | |
| m_logFileOutputStream.write(("start \""+command+"\" ...\n").getBytes()); | |
| String fileName = command.substring(5); | |
| saveFile(new File(fileName)); | |
| m_logFileOutputStream.write("command end \n\n".getBytes()); | |
| } | |
| commandBuffer = new StringBuilder(); | |
| } | |
| } | |
| m_bIsBatchRunning = false; | |
| m_logFileOutputStream.close(); | |
| m_logFileOutputStream = null; | |
| fis.close(); | |
| fis = null; | |
| } | |
| catch(java.io.IOException e) | |
| { | |
| e.printStackTrace(); | |
| } | |
| } | |
| /* | |
| * save the current result tree to a particular file. | |
| */ | |
| private void saveFile(File f) | |
| { | |
| try{ | |
| FileOutputStream fos = new FileOutputStream(f); | |
| SAXEventPrinter.display((Document)m_rightTreeEventCollector.getDocument(), | |
| 0,fos,false); | |
| fos.close(); | |
| }catch(Exception e) | |
| { | |
| e.printStackTrace(); | |
| } | |
| } | |
| /****************************************************************************** | |
| * others | |
| ******************************************************************************/ | |
| /* | |
| * starts up the operation. | |
| */ | |
| private void startsUp() | |
| { | |
| if (m_parsingThread != null) | |
| { | |
| m_parsingThread = null; | |
| } | |
| m_bIsExporting = m_isExportingButton.isSelected(); | |
| m_bIsJavaBased = m_isJavaComponentButton.isSelected(); | |
| if (createComponents()) | |
| { | |
| m_rightTreeEventCollector = new SAXEventCollector(this); | |
| m_parsingThread = new ParsingThread( | |
| m_document, | |
| null, | |
| this); | |
| m_xmlSecurityFrameworkController = | |
| new XMLSecurityFrameworkController( | |
| this, | |
| m_bIsExporting, | |
| m_bIsJavaBased, | |
| m_rightTreeEventCollector, | |
| m_parsingThread, | |
| m_xXMLSecurityContext, | |
| m_xXMLSignature, | |
| m_xXMLEncryption, | |
| m_xRemoteServiceManager, | |
| m_xRemoteContext); | |
| enableGoButton(true); | |
| } | |
| else | |
| { | |
| showMessage("Error in creating XML Security Components!"); | |
| } | |
| } | |
| /************************************************************************************** | |
| * protected methods | |
| **************************************************************************************/ | |
| /****************************************************************************** | |
| * UI related methods | |
| ******************************************************************************/ | |
| /* | |
| * updates the sax chain information. | |
| */ | |
| protected void updatesSAXChainInformation(String chainStr) | |
| { | |
| m_saxChainLabel.setText(chainStr); | |
| } | |
| /* | |
| * update the current SAX event information. | |
| */ | |
| protected void updatesCurrentSAXEventInformation(String event) | |
| { | |
| m_saxEventText.setText(event); | |
| } | |
| /* | |
| * updates all information in the UI. | |
| */ | |
| protected void updatesUIs() | |
| { | |
| if (!m_bIsUIUpdateSuppressed) | |
| { | |
| m_leftTree.clearSelection(); | |
| updatesTree(null, m_leftTree); | |
| if (m_xmlSecurityFrameworkController != null) | |
| { | |
| String bufferNodeTreeText = m_xmlSecurityFrameworkController.getBufferNodeTreeInformation(); | |
| if (bufferNodeTreeText == null) | |
| { | |
| m_middleTree.setVisible(false); | |
| m_bufferNodeTextArea.setText("No XML Security Related"); | |
| } | |
| else | |
| { | |
| m_middleTreeEventCollector = new SAXEventCollector(null); | |
| m_xmlSecurityFrameworkController.getDocument(m_middleTreeEventCollector); | |
| m_middleTreeModelAdapter = new DomToTreeModelAdapter(m_middleTreeEventCollector.getDocument()); | |
| m_middleTree.setModel(m_middleTreeModelAdapter); | |
| updatesTree(null, m_middleTree); | |
| m_middleTree.setVisible(true); | |
| m_bufferNodeTextArea.setText(bufferNodeTreeText); | |
| } | |
| } | |
| else | |
| { | |
| m_middleTree.setVisible(false); | |
| m_bufferNodeTextArea.setText("No XMLImporter/XMLExporter"); | |
| } | |
| if (m_rightTreeEventCollector != null) | |
| { | |
| m_rightTreeModelAdapter = new DomToTreeModelAdapter((Document)m_rightTreeEventCollector.getDocument()); | |
| m_rightTree.setModel(m_rightTreeModelAdapter); | |
| updatesTree((Node)m_rightTreeEventCollector.getCurrentElement(), m_rightTree); | |
| } | |
| updatesUnsolvedReferencesInformation(); | |
| } | |
| } | |
| /* | |
| * shows a message. | |
| */ | |
| protected void showMessage(String msg) | |
| { | |
| if (m_bIsBatchRunning) | |
| { | |
| try | |
| { | |
| if (!msg.startsWith("Message from : SAXEventKeeper")) | |
| { | |
| byte [] b = msg.getBytes(); | |
| m_logFileOutputStream.write(" ".getBytes()); | |
| for (int i=0; i<b.length; ++i) | |
| { | |
| m_logFileOutputStream.write(b[i]); | |
| if (b[i] == '\n') | |
| { | |
| m_logFileOutputStream.write(" ".getBytes()); | |
| } | |
| } | |
| m_logFileOutputStream.write("\n ==============================\n".getBytes()); | |
| } | |
| } | |
| catch(IOException e) | |
| { | |
| e.printStackTrace(); | |
| } | |
| } | |
| else | |
| { | |
| if (stepMode) | |
| { | |
| JOptionPane optionPane = new JOptionPane(); | |
| optionPane.showMessageDialog(this, msg, "TestTool Notification", JOptionPane.INFORMATION_MESSAGE); | |
| } | |
| else | |
| { | |
| Object[] options = { "OK", "Go back to step mode" }; | |
| if (1 == JOptionPane.showOptionDialog(this, msg, "TestTool Notification", | |
| JOptionPane.DEFAULT_OPTION, JOptionPane.PLAIN_MESSAGE, | |
| null, options, options[0])) | |
| { | |
| stepMode = true; | |
| } | |
| } | |
| } | |
| } | |
| /****************************************************************************** | |
| * information retrieving | |
| ******************************************************************************/ | |
| /* | |
| * gets all unsolved reference ids. | |
| * a reference id is the value of the id attribute of an | |
| * referenced element. | |
| */ | |
| protected Vector getUnsolvedReferenceIds() | |
| { | |
| Vector rc; | |
| if (m_xmlSecurityFrameworkController == null) | |
| { | |
| rc = new Vector(); | |
| } | |
| else | |
| { | |
| rc = ((XMLSecurityFrameworkController)m_xmlSecurityFrameworkController). | |
| getUnsolvedReferenceIds(); | |
| } | |
| return rc; | |
| } | |
| /* | |
| * gets all unsolved reference keeper ids. | |
| * a reference keeper id is the id which the SAXEventKeeper uses | |
| * to identify the corresponding BufferNode. | |
| */ | |
| protected Vector getUnsolvedReferenceKeeperIds() | |
| { | |
| Vector rc; | |
| if (m_xmlSecurityFrameworkController == null) | |
| { | |
| rc = new Vector(); | |
| } | |
| else | |
| { | |
| rc = ((XMLSecurityFrameworkController)m_xmlSecurityFrameworkController). | |
| getUnsolvedReferenceKeeperIds(); | |
| } | |
| return rc; | |
| } | |
| /* | |
| * gets all unsolved references' remaining numbers. | |
| * a remaining number is that how many claims have not been found for | |
| * a unsolved reference. | |
| */ | |
| protected Vector getUnsolvedReferenceRefNum() | |
| { | |
| Vector rc; | |
| if (m_xmlSecurityFrameworkController == null) | |
| { | |
| rc = new Vector(); | |
| } | |
| else | |
| { | |
| rc = ((XMLSecurityFrameworkController)m_xmlSecurityFrameworkController). | |
| getUnsolvedReferenceRefNum(); | |
| } | |
| return rc; | |
| } | |
| /************************************************************************************** | |
| * public methods | |
| **************************************************************************************/ | |
| /****************************************************************************** | |
| * action listener related methods. | |
| ******************************************************************************/ | |
| /* | |
| * action listening method. | |
| */ | |
| public void actionPerformed(ActionEvent e) | |
| { | |
| if (e.getSource().equals(m_startButton)) | |
| { | |
| endMission(); | |
| startsUp(); | |
| } | |
| if (e.getSource().equals(m_goButton)) | |
| { | |
| if (m_parsingThread != null) | |
| { | |
| stepMode = false; | |
| boolean notOver; | |
| while ( notOver = m_parsingThread.nextStep()) | |
| { | |
| if (stepMode) break; | |
| } | |
| if (!notOver) endMission(); | |
| } | |
| } | |
| if (e.getSource().equals(m_stepButton)) | |
| { | |
| if (m_parsingThread != null) | |
| { | |
| if (!m_parsingThread.nextStep()) | |
| { | |
| endMission(); | |
| } | |
| } | |
| } | |
| if (e.getSource().equals(m_openButton)) | |
| { | |
| openDocument(); | |
| } | |
| if (e.getSource().equals(m_saveButton)) | |
| { | |
| saveResult(); | |
| } | |
| if (e.getSource().equals(m_batchButton)) | |
| { | |
| openBatch(); | |
| } | |
| } | |
| /* | |
| * void-consturctor method | |
| */ | |
| public TestTool() | |
| { | |
| getRootPane().putClientProperty("defeatSystemEventQueueCheck", Boolean.TRUE); | |
| try | |
| { | |
| m_currentDirectory = new File(System.getProperty("user.dir")); | |
| } | |
| catch(Exception e) | |
| { | |
| System.out.println("getProperty error :"+e); | |
| } | |
| } | |
| /* | |
| * consturctor method with a specific connection URL | |
| */ | |
| public TestTool(String connecturl) | |
| { | |
| this(); | |
| m_unoURL = new String(connecturl); | |
| } | |
| public static void main(String argv[]) | |
| { | |
| Dimension screenSize = | |
| Toolkit.getDefaultToolkit().getScreenSize(); | |
| TestTool tt; | |
| if (argv.length < 1) | |
| { | |
| System.out.println("Usage: java TestTool [javaTokenFile] [nssTokenPath] [xml file]?"); | |
| return; | |
| } | |
| boolean hasFile = false; | |
| boolean hasBatch = false; | |
| String fileName = null; | |
| if (argv.length >= 3) | |
| { | |
| if (argv[2].startsWith("-b")) | |
| { | |
| fileName = argv[2].substring(2); | |
| hasBatch = true; | |
| } | |
| else | |
| { | |
| fileName = argv[2]; | |
| hasFile = true; | |
| } | |
| } | |
| tt = new TestTool(); | |
| tt.m_javaTokenFile = new String(argv[0]); | |
| tt.m_nssTokenPath = new String(argv[1]); | |
| tt.connectSO(null); | |
| /* Set up a GUI framework */ | |
| JFrame myFrame = new JFrame("XML Security Components Tester"); | |
| myFrame.addWindowListener( | |
| new WindowAdapter() { | |
| public void windowClosing(WindowEvent e) {System.exit(0);} | |
| } | |
| ); | |
| myFrame.setContentPane(tt.buildUI(screenSize.width, screenSize.height)); | |
| myFrame.pack(); | |
| int w = screenSize.width-30; | |
| int h = screenSize.height-30; | |
| myFrame.setLocation(screenSize.width/2 - w/2, | |
| screenSize.height/2 - h/2); | |
| myFrame.setSize(w, h); | |
| myFrame.setVisible(true); | |
| if (hasFile) | |
| { | |
| tt.parseFile(new File(fileName)); | |
| } | |
| else if (hasBatch) | |
| { | |
| tt.runBatch(new File(fileName)); | |
| } | |
| } | |
| } |