/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: TestTool.java,v $
* $Revision: 1.4 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 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
******************************************************************************/
/*
* initalizes 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 = (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 = (XXMLSignature)UnoRuntime.queryInterface(
XXMLSignature.class, xmlSignatureObj);
Object xmlEncryptionObj = m_xRemoteServiceManager.createInstanceWithContext(
XMLEncryption_comp, m_xRemoteContext);
if (xmlEncryptionObj == null)
{
freeComponents();
return false;
}
m_xXMLEncryption = (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 = (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 = (XPropertySet)UnoRuntime.queryInterface(
XPropertySet.class, initialObject);
Object context = xPropertySet.getPropertyValue("DefaultContext");
m_xRemoteContext = (XComponentContext)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);
StringBuffer commandBuffer = new StringBuffer();
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 StringBuffer();
}
}
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));
}
}
}