/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed 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 org.apache.axis.utils ;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.URL;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.ResourceBundle;
import java.util.Vector;
import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTabbedPane;
import javax.swing.JTable;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.ListSelectionModel;
import javax.swing.SwingConstants;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.border.TitledBorder;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.plaf.basic.BasicButtonListener;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableColumn;
import javax.swing.table.TableModel;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.PlainDocument;
/**
* TCP monitor to log http messages and responses, both SOAP and plain HTTP.
* If you want to choose a different Swing look and feel, set the property
* tcpmon.laf to the classname of the new look and feel
* @author Doug Davis (dug@us.ibm.com)
* @author Steve Loughran
*/
public class tcpmon extends JFrame {
private JTabbedPane notebook = null ;
private static final int STATE_COLUMN = 0 ;
private static final int TIME_COLUMN = 1 ;
private static final int INHOST_COLUMN = 2 ;
private static final int OUTHOST_COLUMN = 3 ;
private static final int REQ_COLUMN = 4 ;
private static final String DEFAULT_HOST="127.0.0.1";
private static final int DEFAULT_PORT=8080;
/**
* this is the admin page
*/
class AdminPage extends JPanel {
public JRadioButton listenerButton, proxyButton ;
public JLabel hostLabel, tportLabel;
public NumberField port;
public HostnameField host;
public NumberField tport ;
public JTabbedPane noteb ;
public JCheckBox HTTPProxyBox ;
public HostnameField HTTPProxyHost;
public NumberField HTTPProxyPort ;
public JLabel HTTPProxyHostLabel, HTTPProxyPortLabel ;
public JLabel delayTimeLabel, delayBytesLabel;
public NumberField delayTime, delayBytes;
public JCheckBox delayBox;
public AdminPage( JTabbedPane notebook, String name ) {
JPanel mainPane = null ;
JButton addButton = null ;
this.setLayout( new BorderLayout() );
noteb = notebook ;
GridBagLayout layout = new GridBagLayout();
GridBagConstraints c = new GridBagConstraints();
mainPane = new JPanel(layout);
c.anchor = GridBagConstraints.WEST ;
c.gridwidth = GridBagConstraints.REMAINDER;
mainPane.add( new JLabel(getMessage("newTCP00", "Create a new TCP/IP Monitor...") + " "), c );
// Add some blank space
mainPane.add( Box.createRigidArea(new Dimension(1, 5)), c );
// The listener info
///////////////////////////////////////////////////////////////////
JPanel tmpPanel = new JPanel(new GridBagLayout());
c.anchor = GridBagConstraints.WEST ;
c.gridwidth = 1 ;
tmpPanel.add( new JLabel(getMessage("listenPort00", "Listen Port #") + " "), c );
c.anchor = GridBagConstraints.WEST ;
c.gridwidth = GridBagConstraints.REMAINDER ;
tmpPanel.add( port = new NumberField(4), c );
mainPane.add( tmpPanel, c );
mainPane.add( Box.createRigidArea(new Dimension(1, 5)), c );
// Group for the radio buttons
ButtonGroup btns = new ButtonGroup();
c.anchor = GridBagConstraints.WEST ;
c.gridwidth = GridBagConstraints.REMAINDER ;
mainPane.add( new JLabel(getMessage("actAs00", "Act as a...") ), c );
// Target Host/Port section
///////////////////////////////////////////////////////////////////
c.anchor = GridBagConstraints.WEST ;
c.gridwidth = GridBagConstraints.REMAINDER ;
final String listener = getMessage("listener00", "Listener");
mainPane.add( listenerButton = new JRadioButton( listener ), c );
btns.add( listenerButton );
listenerButton.setSelected( true );
listenerButton.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent event) {
if (listener.equals(event.getActionCommand())) {
boolean state = listenerButton.isSelected();
tport.setEnabled( state );
host.setEnabled( state );
hostLabel.setForeground(state ? Color.black : Color.gray);
tportLabel.setForeground(state ? Color.black : Color.gray);
}
}
}
);
c.anchor = GridBagConstraints.WEST ;
c.gridwidth = 1 ;
mainPane.add( Box.createRigidArea(new Dimension(25, 0)) );
mainPane.add( hostLabel = new JLabel(getMessage("targetHostname00", "Target Hostname") + " "), c );
c.anchor = GridBagConstraints.WEST ;
c.gridwidth = GridBagConstraints.REMAINDER ;
host = new HostnameField(30);
mainPane.add( host, c );
host.setText(DEFAULT_HOST);
c.anchor = GridBagConstraints.WEST ;
c.gridwidth = 1 ;
mainPane.add( Box.createRigidArea(new Dimension(25, 0)) );
mainPane.add( tportLabel = new JLabel(getMessage("targetPort00", "Target Port #") + " "), c );
c.anchor = GridBagConstraints.WEST ;
c.gridwidth = GridBagConstraints.REMAINDER ;
tport = new NumberField(4);
mainPane.add( tport, c );
tport.setValue(DEFAULT_PORT);
// Act as proxy section
///////////////////////////////////////////////////////////////////
c.anchor = GridBagConstraints.WEST ;
c.gridwidth = GridBagConstraints.REMAINDER ;
final String proxy = getMessage("proxy00", "Proxy");
mainPane.add( proxyButton = new JRadioButton( proxy ), c);
btns.add( proxyButton );
proxyButton.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent event) {
if (proxy.equals(event.getActionCommand())) {
boolean state = proxyButton.isSelected();
tport.setEnabled( !state );
host.setEnabled( !state );
hostLabel.setForeground(state ? Color.gray : Color.black);
tportLabel.setForeground(state ? Color.gray : Color.black);
}
}
}
);
// Spacer
/////////////////////////////////////////////////////////////////
c.anchor = GridBagConstraints.WEST ;
c.gridwidth = GridBagConstraints.REMAINDER ;
mainPane.add( Box.createRigidArea(new Dimension(1, 10)), c );
// Options section
///////////////////////////////////////////////////////////////////
JPanel opts = new JPanel(new GridBagLayout());
opts.setBorder( new TitledBorder(getMessage("options00", "Options")) );
c.anchor = GridBagConstraints.WEST ;
c.gridwidth = GridBagConstraints.REMAINDER ;
mainPane.add( opts, c );
// HTTP Proxy Support section
///////////////////////////////////////////////////////////////////
c.anchor = GridBagConstraints.WEST ;
c.gridwidth = GridBagConstraints.REMAINDER ;
final String proxySupport = getMessage("proxySupport00", "HTTP Proxy Support");
opts.add(HTTPProxyBox = new JCheckBox(proxySupport), c);
c.anchor = GridBagConstraints.WEST ;
c.gridwidth = 1 ;
opts.add( HTTPProxyHostLabel = new JLabel(getMessage("hostname00", "Hostname") + " "), c );
HTTPProxyHostLabel.setForeground( Color.gray );
c.anchor = GridBagConstraints.WEST ;
c.gridwidth = GridBagConstraints.REMAINDER ;
opts.add( HTTPProxyHost = new HostnameField(30), c );
HTTPProxyHost.setEnabled( false );
c.anchor = GridBagConstraints.WEST ;
c.gridwidth = 1 ;
opts.add( HTTPProxyPortLabel = new JLabel(getMessage("port00", "Port #") + " "), c );
HTTPProxyPortLabel.setForeground( Color.gray );
c.anchor = GridBagConstraints.WEST ;
c.gridwidth = GridBagConstraints.REMAINDER ;
opts.add( HTTPProxyPort = new NumberField(4), c );
HTTPProxyPort.setEnabled( false );
HTTPProxyBox.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent event) {
if (proxySupport.equals(event.getActionCommand())) {
boolean b = HTTPProxyBox.isSelected();
Color color = b ? Color.black : Color.gray ;
HTTPProxyHost.setEnabled( b );
HTTPProxyPort.setEnabled( b );
HTTPProxyHostLabel.setForeground( color );
HTTPProxyPortLabel.setForeground( color );
}
}
}
);
// Set default proxy values...
String tmp = System.getProperty( "http.proxyHost" );
if ( tmp != null && tmp.equals("") ) {
tmp = null ;
}
HTTPProxyBox.setSelected( tmp != null );
HTTPProxyHost.setEnabled( tmp != null );
HTTPProxyPort.setEnabled( tmp != null );
HTTPProxyHostLabel.setForeground( tmp != null ? Color.black : Color.gray);
HTTPProxyPortLabel.setForeground( tmp != null ? Color.black : Color.gray);
if ( tmp != null ) {
HTTPProxyBox.setSelected( true );
HTTPProxyHost.setText( tmp );
tmp = System.getProperty( "http.proxyPort" );
if ( tmp != null && tmp.equals("") ) {
tmp = null ;
}
if ( tmp == null ) {
tmp = "80" ;
}
HTTPProxyPort.setText( tmp );
}
//add byte delay fields
opts.add(Box.createRigidArea(new Dimension(1, 10)), c);
c.anchor = GridBagConstraints.WEST;
c.gridwidth = GridBagConstraints.REMAINDER;
final String delaySupport = getMessage("delay00", "Simulate Slow Connection");
opts.add(delayBox = new JCheckBox(delaySupport), c);
//bytes per pause
c.anchor = GridBagConstraints.WEST;
c.gridwidth = 1;
delayBytesLabel=new JLabel(getMessage("delay01", "Bytes per Pause"));
opts.add(delayBytesLabel, c);
delayBytesLabel.setForeground(Color.gray);
c.anchor = GridBagConstraints.WEST;
c.gridwidth = GridBagConstraints.REMAINDER;
opts.add(delayBytes = new NumberField(6), c);
delayBytes.setEnabled(false);
//delay interval
c.anchor = GridBagConstraints.WEST;
c.gridwidth = 1;
delayTimeLabel = new JLabel(getMessage("delay02", "Delay in Milliseconds"));
opts.add(delayTimeLabel, c);
delayTimeLabel.setForeground(Color.gray);
c.anchor = GridBagConstraints.WEST;
c.gridwidth = GridBagConstraints.REMAINDER;
opts.add(delayTime = new NumberField(6), c);
delayTime.setEnabled(false);
//enabler callback
delayBox.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
if (delaySupport.equals(event.getActionCommand())) {
boolean b = delayBox.isSelected();
Color color = b ? Color.black : Color.gray;
delayBytes.setEnabled(b);
delayTime.setEnabled(b);
delayBytesLabel.setForeground(color);
delayTimeLabel.setForeground(color);
}
}
}
);
// Spacer
//////////////////////////////////////////////////////////////////
mainPane.add( Box.createRigidArea(new Dimension(1, 10)), c );
// ADD Button
///////////////////////////////////////////////////////////////////
c.anchor = GridBagConstraints.WEST ;
c.gridwidth = GridBagConstraints.REMAINDER ;
final String add = getMessage("add00", "Add");
mainPane.add( addButton = new JButton( add ), c );
this.add( new JScrollPane( mainPane ), BorderLayout.CENTER );
// addButton.setEnabled( false );
addButton.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent event) {
if ( add.equals(event.getActionCommand()) ) {
String text ;
Listener l = null ;
int lPort;
lPort=port.getValue(0);
if(lPort==0) {
//no port, button does nothing
return;
}
String tHost = host.getText();
int tPort = 0 ;
tPort=tport.getValue(0);
SlowLinkSimulator slowLink=null;
if(delayBox.isSelected()) {
int bytes= delayBytes.getValue(0);
int time = delayTime.getValue(0);
slowLink=new SlowLinkSimulator(bytes,time);
}
try {
l = new Listener( noteb, null, lPort, tHost, tPort,
proxyButton.isSelected(), slowLink);
} catch (Exception e){
e.printStackTrace();
}
// Pick-up the HTTP Proxy settings
///////////////////////////////////////////////////
text = HTTPProxyHost.getText();
if ( "".equals(text) ) {
text = null ;
}
l.HTTPProxyHost = text ;
text = HTTPProxyPort.getText();
int proxyPort=HTTPProxyPort.getValue(-1);
if(proxyPort!=-1) {
l.HTTPProxyPort = Integer.parseInt(text);
}
//reset the port
port.setText(null);
/* but not, any more, the target port and host
values
host.setText(null);
tport.setText(null);
*/
}
}
}
);
notebook.addTab( name, this );
notebook.repaint();
notebook.setSelectedIndex( notebook.getTabCount() - 1 );
}
}
/**
* wait for incoming connections, spawn a connection thread when
* stuff comes in.
*/
class SocketWaiter extends Thread {
ServerSocket sSocket = null ;
Listener listener ;
int port ;
boolean pleaseStop = false ;
public SocketWaiter(Listener l, int p) {
listener = l ;
port = p ;
start();
}
public void run() {
try {
listener.setLeft( new JLabel(getMessage("wait00", " Waiting for Connection...") ) );
listener.repaint();
sSocket = new ServerSocket( port );
for (; ; ) {
Socket inSocket = sSocket.accept();
if ( pleaseStop ) {
break ;
}
new Connection( listener, inSocket );
inSocket = null ;
}
} catch ( Exception exp ) {
if ( !"socket closed".equals(exp.getMessage()) ) {
JLabel tmp = new JLabel( exp.toString() );
tmp.setForeground( Color.red );
listener.setLeft( tmp );
listener.setRight( new JLabel("") );
listener.stop();
}
}
}
/**
* force a halt by connecting to self and then closing the server socket
*/
public void halt() {
try {
pleaseStop = true ;
new Socket( "127.0.0.1", port );
if ( sSocket != null ) {
sSocket.close();
}
} catch ( Exception e ) {
e.printStackTrace();
}
}
}
/**
* class to simulate slow connections by slowing down the system
*/
static class SlowLinkSimulator {
private int delayBytes;
private int delayTime;
private int currentBytes;
private int totalBytes;
/**
* construct
* @param delayBytes bytes per delay; set to 0 for no delay
* @param delayTime delay time per delay in milliseconds
*/
public SlowLinkSimulator(int delayBytes, int delayTime) {
this.delayBytes = delayBytes;
this.delayTime = delayTime;
}
/**
* construct by copying delay bytes and time, but not current
* count of bytes
* @param that source of data
*/
public SlowLinkSimulator(SlowLinkSimulator that) {
this.delayBytes=that.delayBytes;
this.delayTime=that.delayTime;
}
/**
* how many bytes have gone past?
* @return
*/
public int getTotalBytes() {
return totalBytes;
}
/**
* log #of bytes pumped. Will pause when necessary. This method is not
* synchronized
* @param bytes
*/
public void pump(int bytes) {
totalBytes+=bytes;
if(delayBytes==0) {
//when not delaying, we are just a byte counter
return;
}
currentBytes += bytes;
if(currentBytes>delayBytes) {
//we have overshot. lets find out how far
int delaysize=currentBytes/delayBytes;
long delay=delaysize*(long)delayTime;
//move byte counter down to the remainder of bytes
currentBytes=currentBytes%delayBytes;
//now wait
try {
Thread.sleep(delay);
} catch (InterruptedException e) {
; //ignore the exception
}
}
}
/**
* get the current byte count
* @return
*/
public int getCurrentBytes() {
return currentBytes;
}
/**
* set the current byte count
* @param currentBytes
*/
public void setCurrentBytes(int currentBytes) {
this.currentBytes = currentBytes;
}
}
/**
* this class handles the pumping of data from the incoming socket to the
* outgoing socket
*/
class SocketRR extends Thread {
Socket inSocket = null ;
Socket outSocket = null ;
JTextArea textArea ;
InputStream in = null ;
OutputStream out = null ;
boolean xmlFormat ;
boolean numericEnc ;
volatile boolean done = false ;
TableModel tmodel = null ;
int tableIndex = 0 ;
String type = null;
Connection myConnection = null;
SlowLinkSimulator slowLink;
public SocketRR(Connection c, Socket inputSocket, InputStream inputStream,
Socket outputSocket, OutputStream outputStream,
JTextArea _textArea, boolean format, boolean numeric,
TableModel tModel, int index, final String type, SlowLinkSimulator slowLink) {
inSocket = inputSocket ;
in = inputStream ;
outSocket = outputSocket ;
out = outputStream ;
textArea = _textArea ;
xmlFormat = format ;
numericEnc= numeric ;
tmodel = tModel ;
tableIndex = index ;
this.type = type;
myConnection = c;
this.slowLink= slowLink;
start();
}
public boolean isDone() {
return ( done );
}
public void run() {
try {
byte[] buffer = new byte[4096];
byte[] tmpbuffer = new byte[8192];
String message = null;
int saved = 0 ;
int len ;
int i1, i2 ;
int i ;
int reqSaved = 0 ;
int tabWidth = 3 ;
boolean atMargin = true ;
int thisIndent = -1,
nextIndent = -1,
previousIndent = -1;
//if ( inSocket != null ) inSocket.setSoTimeout( 10 );
//if ( outSocket != null ) outSocket.setSoTimeout( 10 );
if ( tmodel != null ) {
String tmpStr = (String) tmodel.getValueAt(tableIndex,
REQ_COLUMN);
if ( !"".equals(tmpStr) ) {
reqSaved = tmpStr.length();
}
}
a:
for ( ; ; ) {
if ( done ) {
break;
}
//try{
//len = in.available();
//}catch(Exception e){len=0;}
len = buffer.length ;
// Used to be 1, but if we block it doesn't matter
// however 1 will break with some servers, including apache
if ( len == 0 ) {
len = buffer.length;
}
if ( saved + len > buffer.length) {
len = buffer.length - saved ;
}
int len1 = 0;
while ( len1 == 0 ) {
try {
len1 = in.read(buffer, saved, len);
}
catch ( Exception ex ) {
if ( done && saved == 0 ) {
break a;
}
len1 = -1;
break;
}
}
len = len1;
if ( len == -1 && saved == 0 ) {
break ;
}
if ( len == -1) {
done = true;
}
// No matter how we may (or may not) format it, send it
// on unformatted - we don't want to mess with how its
// sent to the other side, just how its displayed
if ( out != null && len > 0 ) {
slowLink.pump(len);
out.write( buffer, saved, len );
}
if ( tmodel != null && reqSaved < 50 ) {
String old = (String) tmodel.getValueAt( tableIndex,
REQ_COLUMN);
old = old + new String(buffer, saved, len);
if ( old.length() > 50 ) {
old = old.substring(0, 50);
}
reqSaved = old.length();
if ( (i = old.indexOf('\n')) > 0 ) {
old = old.substring(0, i - 1);
reqSaved = 50 ;
}
tmodel.setValueAt( old, tableIndex, REQ_COLUMN );
}
if ( xmlFormat ) {
// Do XML Formatting
boolean inXML = false ;
int bufferLen = saved ;
if ( len != -1 ) {
bufferLen += len ;
}
i1 = 0 ;
i2 = 0 ;
saved = 0 ;
for ( ; i1 < bufferLen ; i1++ ) {
// Except when we're at EOF, saved last char
if ( len != -1 && i1 + 1 == bufferLen ) {
saved = 1;
break;
}
thisIndent = -1;
if ( buffer[i1] == '<' && buffer[i1 + 1] != '/' ) {
previousIndent = nextIndent++;
thisIndent = nextIndent;
inXML = true ;
}
if ( buffer[i1] == '<' && buffer[i1 + 1] == '/' ) {
if (previousIndent > nextIndent) {
thisIndent = nextIndent;
}
previousIndent = nextIndent--;
inXML = true ;
}
if ( buffer[i1] == '/' && buffer[i1 + 1] == '>' ) {
previousIndent = nextIndent--;
inXML = true ;
}
if ( thisIndent != -1 ) {
if ( thisIndent > 0 ) {
tmpbuffer[i2++] = (byte) '\n';
}
for ( i = tabWidth * thisIndent; i > 0; i-- ) {
tmpbuffer[i2++] = (byte) ' ';
}
}
atMargin = ( buffer[i1] == '\n' || buffer[i1] == '\r');
if ( !inXML || !atMargin ) {
tmpbuffer[i2++] = buffer[i1];
}
}
message = new String( tmpbuffer, 0, i2, getEncoding() );
if (numericEnc) {
textArea.append( StringUtils.escapeNumericChar(message) );
} else {
textArea.append( StringUtils.unescapeNumericChar(message) );
}
// Shift saved bytes to the beginning
for ( i = 0 ; i < saved ; i++ ) {
buffer[i] = buffer[bufferLen - saved + i];
}
}
else {
message = new String( buffer, 0, len, getEncoding() );
if (numericEnc) {
textArea.append( StringUtils.escapeNumericChar(message) );
} else {
textArea.append( StringUtils.unescapeNumericChar(message) );
}
}
// this.sleep(3); // Let other threads have a chance to run
}
// this.sleep(3); // Let other threads have a chance to run
// halt();
// Only set the 'done' flag if we were reading from a
// Socket - if we were reading from an input stream then
// we'll let the other side control when we're done
// if ( inSocket != null ) done = true ;
}
catch ( Throwable t ) {
t.printStackTrace();
}
finally {
done = true ;
try {
if (out != null) {
out.flush();
if (null != outSocket) {
outSocket.shutdownOutput();
} else {
out.close();
}
out = null;
}
}
catch (Exception e) {
;
}
try {
if (in != null) {
if (inSocket != null) {
inSocket.shutdownInput();
} else {
in.close();
}
in = null;
}
}
catch (Exception e) {
;
}
myConnection.wakeUp();
}
}
private String getEncoding() {
try {
return XMLUtils.getEncoding();
} catch (Throwable t){
return "UTF-8";
}
}
public void halt() {
try {
if ( inSocket != null ) {
inSocket.close();
}
if ( outSocket != null ) {
outSocket.close();
}
inSocket = null ;
outSocket = null ;
if ( in != null ) {
in.close();
}
if ( out != null ) {
out.close();
}
in = null ;
out = null ;
done = true;
}
catch ( Exception e ) {
e.printStackTrace();
}
}
}
/**
* a connection listens to a single current connection
*/
class Connection extends Thread {
Listener listener ;
boolean active ;
String fromHost ;
String time ;
JTextArea inputText = null ;
JScrollPane inputScroll = null ;
JTextArea outputText = null ;
JScrollPane outputScroll = null ;
Socket inSocket = null ;
Socket outSocket = null ;
Thread clientThread = null ;
Thread serverThread = null ;
SocketRR rr1 = null ;
SocketRR rr2 = null ;
InputStream inputStream = null ;
String HTTPProxyHost = null ;
int HTTPProxyPort = 80 ;
private SlowLinkSimulator slowLink;
public Connection(Listener l) {
listener = l ;
HTTPProxyHost = l.HTTPProxyHost ;
HTTPProxyPort = l.HTTPProxyPort ;
slowLink =l.slowLink;
}
public Connection(Listener l, Socket s ) {
this (l);
inSocket = s ;
start();
}
public Connection(Listener l, InputStream in ) {
this (l);
inputStream = in ;
start();
}
public void run() {
try {
active = true ;
HTTPProxyHost = System.getProperty( "http.proxyHost" );
if ( HTTPProxyHost != null && HTTPProxyHost.equals("") ) {
HTTPProxyHost = null ;
}
if ( HTTPProxyHost != null ) {
String tmp = System.getProperty( "http.proxyPort" );
if ( tmp != null && tmp.equals("") ) {
tmp = null ;
}
if ( tmp == null ) {
HTTPProxyPort = 80 ;
} else {
HTTPProxyPort = Integer.parseInt( tmp );
}
}
if ( inSocket != null ) {
fromHost = (inSocket.getInetAddress()).getHostName();
} else {
fromHost = "resend" ;
}
String dateformat=getMessage("dateformat00", "yyyy-MM-dd HH:mm:ss");
DateFormat df = new SimpleDateFormat(dateformat);
time = df.format( new Date() );
int count = listener.connections.size();
listener.tableModel.insertRow(count + 1, new Object[] {
getMessage("active00", "Active"),
time,
fromHost,
listener.hostField.getText(), ""
}
);
listener.connections.add( this );
inputText = new JTextArea( null, null, 20, 80 );
inputScroll = new JScrollPane( inputText );
outputText = new JTextArea( null, null, 20, 80 );
outputScroll = new JScrollPane( outputText );
ListSelectionModel lsm = listener.connectionTable.getSelectionModel();
if ( count == 0 || lsm.getLeadSelectionIndex() == 0 ) {
listener.outPane.setVisible( false );
int divLoc = listener.outPane.getDividerLocation();
listener.setLeft( inputScroll );
listener.setRight( outputScroll );
listener.removeButton.setEnabled(false);
listener.removeAllButton.setEnabled(true);
listener.saveButton.setEnabled(true);
listener.resendButton.setEnabled(true);
listener.outPane.setDividerLocation(divLoc);
listener.outPane.setVisible( true );
}
String targetHost = listener.hostField.getText();
int targetPort = Integer.parseInt(listener.tPortField.getText());
int listenPort = Integer.parseInt(listener.portField.getText());
InputStream tmpIn1 = inputStream ;
OutputStream tmpOut1 = null ;
InputStream tmpIn2 = null ;
OutputStream tmpOut2 = null ;
if ( tmpIn1 == null ) {
tmpIn1 = inSocket.getInputStream();
}
if ( inSocket != null ) {
tmpOut1 = inSocket.getOutputStream();
}
String bufferedData = null ;
StringBuffer buf = null ;
int index = listener.connections.indexOf( this );
if (listener.isProxyBox.isSelected() || HTTPProxyHost != null) {
// Check if we're a proxy
byte[] b = new byte[1];
buf = new StringBuffer();
String s ;
for ( ; ; ) {
int len ;
len = tmpIn1.read(b, 0, 1);
if ( len == -1 ) {
break ;
}
s = new String( b );
buf.append( s );
if ( b[0] != '\n' ) {
continue ;
}
break ;
}
bufferedData = buf.toString();
inputText.append( bufferedData );
if ( bufferedData.startsWith( "GET " ) ||
bufferedData.startsWith( "POST " ) ||
bufferedData.startsWith( "PUT " ) ||
bufferedData.startsWith( "DELETE " ) ) {
int start, end ;
URL url ;
start = bufferedData.indexOf( ' ' ) + 1;
while ( bufferedData.charAt(start) == ' ' ) {
start++ ;
}
end = bufferedData.indexOf( ' ', start );
String urlString = bufferedData.substring( start, end );
if ( urlString.charAt(0) == '/' ) {
urlString = urlString.substring(1);
}
if ( listener.isProxyBox.isSelected() ) {
url = new URL( urlString );
targetHost = url.getHost();
targetPort = url.getPort();
if ( targetPort == -1 ) {
targetPort = 80 ;
}
listener.tableModel.setValueAt( targetHost, index + 1,
OUTHOST_COLUMN );
bufferedData = bufferedData.substring( 0, start) +
url.getFile() +
bufferedData.substring( end );
}
else {
url = new URL( "http://" + targetHost + ":" +
targetPort + "/" + urlString );
listener.tableModel.setValueAt( targetHost, index + 1,
OUTHOST_COLUMN );
bufferedData = bufferedData.substring( 0, start) +
url.toExternalForm() +
bufferedData.substring( end );
targetHost = HTTPProxyHost ;
targetPort = HTTPProxyPort ;
}
}
}
else {
//
// Change Host: header to point to correct host
//
byte[] b1 = new byte[1];
buf = new StringBuffer();
String s1;
String lastLine = null ;
for ( ; ; ) {
int len ;
len = tmpIn1.read(b1, 0, 1);
if ( len == -1 ) {
break ;
}
s1 = new String( b1 );
buf.append( s1 );
if ( b1[0] != '\n' ) {
continue ;
}
// we have a complete line
String line = buf.toString();
buf.setLength(0);
// check to see if we have found Host: header
if (line.startsWith("Host: ")) {
// we need to update the hostname to target host
String newHost = "Host: " + targetHost + ":" + listenPort + "\r\n";
bufferedData = bufferedData.concat(newHost);
break ;
}
// add it to our headers so far
if (bufferedData == null) {
bufferedData = line;
} else {
bufferedData = bufferedData.concat(line);
}
// failsafe
if (line.equals("\r\n")) {
break;
}
if ("\n".equals(lastLine) && line.equals("\n")) {
break ;
}
lastLine = line ;
}
if ( bufferedData != null ) {
inputText.append( bufferedData );
int idx = bufferedData.length() < 50 ? bufferedData.length() : 50;
s1 = bufferedData.substring( 0, idx );
int i = s1.indexOf('\n');
if ( i > 0 ) {
s1 = s1.substring(0, i - 1);
}
s1 = s1 + " " +
" ";
s1 = s1.substring(0, 51);
listener.tableModel.setValueAt( s1, index + 1,
REQ_COLUMN );
}
}
if ( targetPort == -1 ) {
targetPort = 80 ;
}
outSocket = new Socket(targetHost, targetPort );
tmpIn2 = outSocket.getInputStream();
tmpOut2 = outSocket.getOutputStream();
if ( bufferedData != null ) {
byte[] b = bufferedData.getBytes();
tmpOut2.write( b );
slowLink.pump(b.length);
}
boolean format = listener.xmlFormatBox.isSelected();
boolean numeric = listener.numericBox.isSelected();
//this is the channel to the endpoint
rr1 = new SocketRR(this, inSocket, tmpIn1, outSocket,
tmpOut2, inputText, format, numeric,
listener.tableModel, index + 1, "request:", slowLink);
//create the response slow link from the inbound slow link
SlowLinkSimulator responseLink = new SlowLinkSimulator(slowLink);
//this is the channel from the endpoint
rr2 = new SocketRR( this, outSocket, tmpIn2, inSocket,
tmpOut1, outputText, format, numeric,
null, 0, "response:", responseLink);
while ( rr1 != null || rr2 != null ) {
// Only loop as long as the connection to the target
// machine is available - once that's gone we can stop.
// The old way, loop until both are closed, left us
// looping forever since no one closed the 1st one.
// while( !rr2.isDone() )
if (null != rr1 && rr1.isDone()) {
if ( index >= 0 && rr2 != null) {
listener.tableModel.setValueAt(getMessage("resp00", "Resp"),
1 + index, STATE_COLUMN );
}
rr1 = null;
}
if (null != rr2 && rr2.isDone()) {
if ( index >= 0 && rr1 != null ) {
listener.tableModel.setValueAt(getMessage("req00", "Req"),
1 + index, STATE_COLUMN );
}
rr2 = null;
}
// Thread.sleep( 10 );
synchronized ( this) {
this.wait(1000); //Safety just incase we're not told to wake up.
}
}
// System.out.println("Done ");
// rr1.halt();
// rr2.halt();
active = false ;
/*
if ( inSocket != null ) {
inSocket.close();
inSocket = null ;
}
outSocket.close();
outSocket = null ;
*/
if ( index >= 0 ) {
listener.tableModel.setValueAt(getMessage("done00", "Done"),
1 + index, STATE_COLUMN );
}
}
catch ( Exception e ) {
StringWriter st = new StringWriter();
PrintWriter wr = new PrintWriter(st);
int index = listener.connections.indexOf( this );
if ( index >= 0 ) {
listener.tableModel.setValueAt( getMessage("error00", "Error"), 1 + index, STATE_COLUMN );
}
e.printStackTrace(wr);
wr.close();
if(outputText!=null) {
outputText.append( st.toString() );
} else {
//something went wrong before we had the output area
System.out.println(st.toString());
}
halt();
}
}
synchronized void wakeUp() {
this.notifyAll();
}
public void halt() {
try {
if ( rr1 != null ) {
rr1.halt();
}
if ( rr2 != null ) {
rr2.halt();
}
if ( inSocket != null ) {
inSocket.close();
}
inSocket = null ;
if ( outSocket != null ) {
outSocket.close();
}
outSocket = null ;
}
catch ( Exception e ) {
e.printStackTrace();
}
}
public void remove() {
int index = -1;
try {
halt();
index = listener.connections.indexOf( this );
listener.tableModel.removeRow( index + 1 );
listener.connections.remove( index );
}
catch ( Exception e ) {
System.err.println("index:=" + index + this );
e.printStackTrace();
}
}
}
/**
* this is one of the tabbed panels that acts as the actual proxy
*/
class Listener extends JPanel {
public Socket inputSocket = null ;
public Socket outputSocket = null ;
public JTextField portField = null ;
public JTextField hostField = null ;
public JTextField tPortField = null ;
public JCheckBox isProxyBox = null ;
public JButton stopButton = null ;
public JButton removeButton = null ;
public JButton removeAllButton = null ;
public JCheckBox xmlFormatBox = null ;
public JCheckBox numericBox = null ;
public JButton saveButton = null ;
public JButton resendButton = null ;
public JButton switchButton = null ;
public JButton closeButton = null ;
public JTable connectionTable = null ;
public DefaultTableModel tableModel = null ;
public JSplitPane outPane = null ;
public ServerSocket sSocket = null ;
public SocketWaiter sw = null ;
public JPanel leftPanel = null ;
public JPanel rightPanel = null ;
public JTabbedPane notebook = null ;
public String HTTPProxyHost = null ;
public int HTTPProxyPort = 80 ;
public int delayBytes = 0;
public int delayTime = 0;
public SlowLinkSimulator slowLink;
public final Vector connections = new Vector();
/**
* create a listener
* @param _notebook
* @param name
* @param listenPort
* @param host
* @param targetPort
* @param isProxy
* @param slowLink optional reference to a slow connection
*/
public Listener(JTabbedPane _notebook, String name,
int listenPort, String host, int targetPort,
boolean isProxy, SlowLinkSimulator slowLink) {
notebook = _notebook ;
if ( name == null ) {
name = getMessage("port01", "Port") + " " + listenPort ;
}
//set the slow link to the passed down link
if(slowLink!=null) {
this.slowLink=slowLink;
} else {
//or make up a no-op one.
this.slowLink=new SlowLinkSimulator(0,0);
}
this.setLayout( new BorderLayout() );
// 1st component is just a row of labels and 1-line entry fields
/////////////////////////////////////////////////////////////////////
JPanel top = new JPanel();
top.setLayout( new BoxLayout(top, BoxLayout.X_AXIS) );
top.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
final String start = getMessage("start00", "Start");
top.add( stopButton = new JButton( start ) );
top.add( Box.createRigidArea(new Dimension(5, 0)) );
top.add( new JLabel( " " + getMessage("listenPort01", "Listen Port:") + " ", SwingConstants.RIGHT ) );
top.add( portField = new JTextField( "" + listenPort, 4 ) );
top.add( new JLabel( " " + getMessage("host00", "Host:"), SwingConstants.RIGHT ) );
top.add( hostField = new JTextField( host, 30 ) );
top.add( new JLabel( " " + getMessage("port02", "Port:") + " ", SwingConstants.RIGHT ) );
top.add( tPortField = new JTextField( "" + targetPort, 4 ) );
top.add( Box.createRigidArea(new Dimension(5, 0)) );
top.add( isProxyBox = new JCheckBox(getMessage("proxy00", "Proxy")) );
isProxyBox.addChangeListener( new BasicButtonListener(isProxyBox) {
public void stateChanged(ChangeEvent event) {
JCheckBox box = (JCheckBox) event.getSource();
boolean state = box.isSelected();
tPortField.setEnabled( !state );
hostField.setEnabled( !state );
}
}
);
isProxyBox.setSelected(isProxy);
portField.setEditable(false);
portField.setMaximumSize(new Dimension(50, Short.MAX_VALUE) );
hostField.setEditable(false);
hostField.setMaximumSize(new Dimension(85, Short.MAX_VALUE) );
tPortField.setEditable(false);
tPortField.setMaximumSize(new Dimension(50, Short.MAX_VALUE) );
stopButton.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent event) {
if ( getMessage("stop00", "Stop").equals(event.getActionCommand()) ) {
stop();
}
if ( start.equals(event.getActionCommand()) ) {
start();
}
}
}
);
this.add( top, BorderLayout.NORTH );
// 2nd component is a split pane with a table on the top
// and the request/response text areas on the bottom
/////////////////////////////////////////////////////////////////////
tableModel = new DefaultTableModel(new String[] {
getMessage("state00", "State"),
getMessage("time00", "Time"),
getMessage("requestHost00", "Request Host"),
getMessage("targetHost", "Target Host"),
getMessage("request00", "Request...")
} , 0 );
tableModel.addRow( new Object[] {
"---", getMessage("mostRecent00", "Most Recent"), "---", "---", "---"
}
);
connectionTable = new JTable(1, 2);
connectionTable.setModel( tableModel );
connectionTable.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
// Reduce the STATE column and increase the REQ column
TableColumn col ;
col = connectionTable.getColumnModel().getColumn(STATE_COLUMN);
col.setMaxWidth( col.getPreferredWidth() / 2 );
col = connectionTable.getColumnModel().getColumn(REQ_COLUMN);
col.setPreferredWidth( col.getPreferredWidth() * 2 );
ListSelectionModel sel = connectionTable.getSelectionModel();
sel.addListSelectionListener( new ListSelectionListener() {
public void valueChanged(ListSelectionEvent event) {
if (event.getValueIsAdjusting()) {
return ;
}
ListSelectionModel m = (ListSelectionModel) event.getSource();
int divLoc = outPane.getDividerLocation();
if (m.isSelectionEmpty()) {
setLeft( new JLabel(" " + getMessage("wait00", "Waiting for Connection...") ) );
setRight( new JLabel("") );
removeButton.setEnabled(false);
removeAllButton.setEnabled(false);
saveButton.setEnabled(false);
resendButton.setEnabled(false);
}
else {
int row = m.getLeadSelectionIndex();
if ( row == 0 ) {
if ( connections.size() == 0 ) {
setLeft(new JLabel(" " + getMessage("wait00", "Waiting for connection...")));
setRight(new JLabel(""));
removeButton.setEnabled(false);
removeAllButton.setEnabled(false);
saveButton.setEnabled(false);
resendButton.setEnabled(false);
}
else {
Connection conn = (Connection) connections.lastElement();
setLeft( conn.inputScroll );
setRight( conn.outputScroll );
removeButton.setEnabled(false);
removeAllButton.setEnabled(true);
saveButton.setEnabled(true);
resendButton.setEnabled(true);
}
}
else {
Connection conn = (Connection) connections.get(row - 1);
setLeft( conn.inputScroll );
setRight( conn.outputScroll );
removeButton.setEnabled(true);
removeAllButton.setEnabled(true);
saveButton.setEnabled(true);
resendButton.setEnabled(true);
}
}
outPane.setDividerLocation(divLoc);
}
}
);
JPanel tablePane = new JPanel();
tablePane.setLayout( new BorderLayout() );
JScrollPane tableScrollPane = new JScrollPane( connectionTable );
tablePane.add( tableScrollPane, BorderLayout.CENTER );
JPanel buttons = new JPanel();
buttons.setLayout( new BoxLayout(buttons, BoxLayout.X_AXIS) );
buttons.setBorder( BorderFactory.createEmptyBorder(5, 5, 5, 5) );
final String removeSelected = getMessage("removeSelected00", "Remove Selected");
buttons.add( removeButton = new JButton(removeSelected) );
buttons.add( Box.createRigidArea(new Dimension(5, 0)) );
final String removeAll = getMessage("removeAll00", "Remove All");
buttons.add( removeAllButton = new JButton(removeAll) );
tablePane.add( buttons, BorderLayout.SOUTH );
removeButton.setEnabled( false );
removeButton.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent event) {
if ( removeSelected.equals(event.getActionCommand()) ) {
remove();
}
}
}
);
removeAllButton.setEnabled( false );
removeAllButton.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent event) {
if ( removeAll.equals(event.getActionCommand()) ) {
removeAll();
}
}
}
);
// Add Response Section
/////////////////////////////////////////////////////////////////////
JPanel pane2 = new JPanel();
pane2.setLayout( new BorderLayout() );
leftPanel = new JPanel();
leftPanel.setAlignmentX( Component.LEFT_ALIGNMENT );
leftPanel.setLayout( new BoxLayout(leftPanel, BoxLayout.Y_AXIS) );
leftPanel.add( new JLabel(" " + getMessage("request01", "Request")) );
leftPanel.add( new JLabel(" " + getMessage("wait01", "Waiting for connection") ));
rightPanel = new JPanel();
rightPanel.setLayout( new BoxLayout(rightPanel, BoxLayout.Y_AXIS) );
rightPanel.add( new JLabel(" " + getMessage("response00", "Response")) );
rightPanel.add( new JLabel("") );
outPane = new JSplitPane(0, leftPanel, rightPanel );
outPane.setDividerSize(4);
pane2.add( outPane, BorderLayout.CENTER );
JPanel bottomButtons = new JPanel();
bottomButtons.setLayout( new BoxLayout(bottomButtons, BoxLayout.X_AXIS));
bottomButtons.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
bottomButtons.add( xmlFormatBox = new JCheckBox( getMessage("xmlFormat00", "XML Format") ) );
bottomButtons.add( numericBox = new JCheckBox( getMessage("numericEnc00", "Numeric" ) ) );
bottomButtons.add( Box.createRigidArea(new Dimension(5, 0)) );
final String save = getMessage("save00", "Save");
bottomButtons.add( saveButton = new JButton( save ) );
bottomButtons.add( Box.createRigidArea(new Dimension(5, 0)) );
final String resend = getMessage("resend00", "Resend");
bottomButtons.add( resendButton = new JButton( resend ) );
bottomButtons.add( Box.createRigidArea(new Dimension(5, 0)) );
final String switchStr = getMessage("switch00", "Switch Layout");
bottomButtons.add( switchButton = new JButton( switchStr ) );
bottomButtons.add( Box.createHorizontalGlue() );
final String close = getMessage("close00", "Close");
bottomButtons.add( closeButton = new JButton( close ) );
pane2.add( bottomButtons, BorderLayout.SOUTH );
saveButton.setEnabled( false );
saveButton.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent event) {
if ( save.equals(event.getActionCommand()) ) {
save();
}
}
}
);
resendButton.setEnabled( false );
resendButton.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent event) {
if ( resend.equals(event.getActionCommand()) ) {
resend();
}
}
}
);
switchButton.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent event) {
if (switchStr.equals(event.getActionCommand()) ) {
int v = outPane.getOrientation();
if ( v == 0 ) {
// top/bottom
outPane.setOrientation(1);
}
else {
// left/right
outPane.setOrientation(0);
}
outPane.setDividerLocation(0.5);
}
}
}
);
closeButton.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent event) {
if (close.equals(event.getActionCommand()) ) {
close();
}
}
}
);
JSplitPane pane1 = new JSplitPane( 0 );
pane1.setDividerSize(4);
pane1.setTopComponent( tablePane );
pane1.setBottomComponent( pane2 );
pane1.setDividerLocation( 150 );
this.add( pane1, BorderLayout.CENTER );
//
////////////////////////////////////////////////////////////////////
sel.setSelectionInterval(0, 0);
outPane.setDividerLocation( 150 );
notebook.addTab( name, this );
start();
}
public void setLeft(Component left) {
leftPanel.removeAll();
leftPanel.add(left);
}
public void setRight(Component right) {
rightPanel.removeAll();
rightPanel.add(right);
}
public void start() {
int port = Integer.parseInt( portField.getText() );
portField.setText( "" + port );
int i = notebook.indexOfComponent( this );
notebook.setTitleAt( i, getMessage("port01", "Port") + " " + port );
int tmp = Integer.parseInt( tPortField.getText() );
tPortField.setText( "" + tmp );
sw = new SocketWaiter( this, port );
stopButton.setText( getMessage("stop00", "Stop") );
portField.setEditable(false);
hostField.setEditable(false);
tPortField.setEditable(false);
isProxyBox.setEnabled(false);
}
public void close() {
stop();
notebook.remove( this );
}
public void stop() {
try {
for ( int i = 0 ; i < connections.size() ; i++ ) {
Connection conn = (Connection) connections.get( i );
conn.halt();
}
sw.halt();
stopButton.setText( getMessage("start00", "Start") );
portField.setEditable(true);
hostField.setEditable(true);
tPortField.setEditable(true);
isProxyBox.setEnabled(true);
}
catch ( Exception e ) {
e.printStackTrace();
}
}
public void remove() {
ListSelectionModel lsm = connectionTable.getSelectionModel();
int bot = lsm.getMinSelectionIndex();
int top = lsm.getMaxSelectionIndex();
for ( int i = top ; i >= bot ; i-- ) {
((Connection) connections.get(i - 1)).remove();
}
if ( bot > connections.size() ) {
bot = connections.size();
}
lsm.setSelectionInterval(bot, bot);
}
public void removeAll() {
ListSelectionModel lsm = connectionTable.getSelectionModel();
lsm.clearSelection();
while ( connections.size() > 0 ) {
((Connection) connections.get(0)).remove();
}
lsm.setSelectionInterval(0, 0);
}
public void save() {
JFileChooser dialog = new JFileChooser( "." );
int rc = dialog.showSaveDialog( this );
if ( rc == JFileChooser.APPROVE_OPTION ) {
try {
File file = dialog.getSelectedFile();
FileOutputStream out = new FileOutputStream( file );
ListSelectionModel lsm = connectionTable.getSelectionModel();
rc = lsm.getLeadSelectionIndex();
int n = 0;
for (Iterator i = connections.iterator();i.hasNext();n++) {
Connection conn = (Connection)i.next();
if (lsm.isSelectedIndex(n + 1) ||
(!(i.hasNext()) && lsm.getLeadSelectionIndex() == 0)) {
rc = Integer.parseInt( portField.getText() );
out.write("\n==============\n".getBytes());
out.write( ((getMessage("listenPort01", "Listen Port:") + " " + rc + "\n" )).getBytes() );
out.write( (getMessage("targetHost01", "Target Host:") + " " + hostField.getText() +
"\n" ).getBytes() );
rc = Integer.parseInt( tPortField.getText() );
out.write( ((getMessage("targetPort01", "Target Port:") + " " + rc + "\n" )).getBytes() );
out.write( (("==== " + getMessage("request01", "Request") + " ====\n" )).getBytes() );
out.write( conn.inputText.getText().getBytes() );
out.write( (("==== " + getMessage("response00", "Response") + " ====\n" )).getBytes() );
out.write( conn.outputText.getText().getBytes() );
out.write("\n==============\n".getBytes());
}
}
out.close();
}
catch ( Exception e ) {
e.printStackTrace();
}
}
}
public void resend() {
int rc ;
try {
ListSelectionModel lsm = connectionTable.getSelectionModel();
rc = lsm.getLeadSelectionIndex();
if ( rc == 0 ) {
rc = connections.size();
}
Connection conn = (Connection) connections.get( rc - 1 );
if ( rc > 0 ) {
lsm.clearSelection();
lsm.setSelectionInterval(0, 0);
}
InputStream in = null ;
String text = conn.inputText.getText();
// Fix Content-Length HTTP headers
if ( text.startsWith("POST ") || text.startsWith("GET ") ) {
// System.err.println("IN CL" );
int pos1, pos2, pos3 ;
String body, headers, headers1, header2 ;
pos3 = text.indexOf( "\n\n" );
if ( pos3 == -1 ) {
pos3 = text.indexOf( "\r\n\r\n" );
if ( pos3 != -1 ) {
pos3 = pos3 + 4 ;
}
}
else {
pos3 += 2 ;
}
headers = text.substring( 0, pos3 );
pos1 = headers.indexOf( "Content-Length:" );
// System.err.println("pos1: " + pos1 );
// System.err.println("pos3: " + pos3 );
if ( pos1 != -1 ) {
int newLen = text.length() - pos3 ;
pos2 = headers.indexOf( "\n", pos1 );
System.err.println("CL: " + newLen );
System.err.println("Hdrs: '" + headers + "'" );
System.err.println("subTEXT: '" +
text.substring(pos3, pos3 + newLen) + "'");
text = headers.substring(0, pos1) +
"Content-Length: " + newLen + "\n" +
headers.substring(pos2 + 1) +
text.substring(pos3) ;
System.err.println("\nTEXT: '" + text + "'" );
}
}
in = new ByteArrayInputStream( text.getBytes() );
new Connection( this, in );
}
catch ( Exception e ) {
e.printStackTrace();
}
}
}
public tcpmon(int listenPort, String targetHost, int targetPort, boolean embedded) {
super ( getMessage("tcpmon00", "TCPMonitor") );
notebook = new JTabbedPane();
this.getContentPane().add( notebook );
new AdminPage( notebook, getMessage("admin00", "Admin") );
if ( listenPort != 0 ) {
Listener l = null ;
if ( targetHost == null ) {
l = new Listener( notebook, null, listenPort,
targetHost, targetPort, true, null);
} else {
l = new Listener( notebook, null, listenPort,
targetHost, targetPort, false, null);
}
notebook.setSelectedIndex( 1 );
l.HTTPProxyHost = System.getProperty( "http.proxyHost" );
if ( l.HTTPProxyHost != null && l.HTTPProxyHost.equals("") ) {
l.HTTPProxyHost = null ;
}
if ( l.HTTPProxyHost != null ) {
String tmp = System.getProperty( "http.proxyPort" );
if ( tmp != null && tmp.equals("") ) {
tmp = null ;
}
if ( tmp == null ) {
l.HTTPProxyPort = 80 ;
} else {
l.HTTPProxyPort = Integer.parseInt( tmp );
}
}
}
if(!embedded) {
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
}
this.pack();
this.setSize( 600, 600 );
this.setVisible( true );
}
public tcpmon(int listenPort, String targetHost, int targetPort) {
this(listenPort, targetHost, targetPort, false);
}
/**
* set up the L&F
*/
private static void setupLookAndFeel(boolean nativeLookAndFeel) throws Exception {
String classname= UIManager.getCrossPlatformLookAndFeelClassName();
if(nativeLookAndFeel) {
classname= UIManager.getSystemLookAndFeelClassName();
}
String lafProperty= System.getProperty("tcpmon.laf", "");
if(lafProperty.length()>0) {
classname=lafProperty;
}
try {
UIManager.setLookAndFeel(classname);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (UnsupportedLookAndFeelException e) {
e.printStackTrace();
}
}
/**
* this is our main method
* @param args
*/
public static void main(String[] args) {
try {
//switch between swing L&F here
setupLookAndFeel(true);
if ( args.length == 3 ) {
int p1 = Integer.parseInt( args[0] );
int p2 = Integer.parseInt( args[2] );
new tcpmon( p1, args[1], p2 );
}
else if ( args.length == 1 ) {
int p1 = Integer.parseInt( args[0] );
new tcpmon( p1, null, 0 );
}
else if ( args.length != 0 ) {
System.err.println( getMessage("usage00", "Usage:")
+ " tcpmon [listenPort targetHost targetPort]\n");
}
else {
new tcpmon(0, null, 0);
}
}
catch ( Throwable exp ) {
exp.printStackTrace();
}
}
// Message resource bundle.
private static ResourceBundle messages = null;
/**
* Get the message with the given key. There are no arguments for this message.
*/
public static String getMessage(String key, String defaultMsg) {
try {
if (messages == null) {
initializeMessages();
}
return messages.getString(key);
} catch (Throwable t) {
// If there is any problem whatsoever getting the internationalized
// message, return the default.
return defaultMsg;
}
} // getMessage
/**
* Load the resource bundle messages from the properties file. This is ONLY done when it is
* needed. If no messages are printed (for example, only Wsdl2java is being run in non-
* verbose mode) then there is no need to read the properties file.
*/
private static void initializeMessages() {
messages = ResourceBundle.getBundle("org.apache.axis.utils.tcpmon");
} // initializeMessages
/**
* a text field with a restricted set of characters
*/
static class RestrictedTextField extends JTextField {
protected String validText;
public RestrictedTextField(String validText) {
setValidText(validText);
}
public RestrictedTextField(int columns, String validText) {
super(columns);
setValidText(validText);
}
public RestrictedTextField(String text, String validText) {
super(text);
setValidText(validText);
}
public RestrictedTextField(String text, int columns, String validText) {
super(text, columns);
setValidText(validText);
}
private void setValidText(String validText) {
this.validText = validText;
}
/**
* fascinatingly, this method is called in the super() constructor,
* meaning before we are fully initialized. C++ doesnt actually permit
* such a situation, but java clearly does...
* @return a new document
*/
public Document createDefaultModel() {
return new RestrictedDocument();
}
/**
* this class strips out invaid chars
*/
class RestrictedDocument extends PlainDocument {
/**
* Constructs a plain text document. A default model using
* <code>GapContent</code> is constructed and set.
*/
public RestrictedDocument() {
}
/**
* add a string; only those chars in the valid text list are allowed
* @param offset
* @param string
* @param attributes
* @throws BadLocationException
*/
public void insertString(int offset, String string, AttributeSet attributes)
throws BadLocationException {
if (string == null) {
return;
}
int len = string.length();
StringBuffer buffer = new StringBuffer(string.length());
for (int i = 0; i < len; i++) {
char ch = string.charAt(i);
if (validText.indexOf(ch) >= 0) {
buffer.append(ch);
}
}
super.insertString(offset, new String(buffer), attributes);
}
} //end class NumericDocument
}
/**
* because we cant use Java1.4's JFormattedTextField, here is
* a class that accepts numbers only
*/
static class NumberField extends RestrictedTextField {
private static final String VALID_TEXT = "0123456789";
/**
* Constructs a new <code>TextField</code>. A default model is created,
* the initial string is <code>null</code>,
* and the number of columns is set to 0.
*/
public NumberField() {
super(VALID_TEXT);
}
/**
* Constructs a new empty <code>TextField</code> with the specified
* number of columns.
* A default model is created and the initial string is set to
* <code>null</code>.
*
* @param columns the number of columns to use to calculate
* the preferred width; if columns is set to zero, the
* preferred width will be whatever naturally results from
* the component implementation
*/
public NumberField(int columns) {
super(columns, VALID_TEXT);
}
/**
* get the int value of a field, any invalid (non int) field returns
* the default
* @param def default value
* @return the field contents
*/
public int getValue(int def) {
int result = def;
String text = getText();
if (text != null && text.length() != 0) {
try {
result = Integer.parseInt(text);
} catch (NumberFormatException e) {
}
}
return result;
}
/**
* set the text to a numeric value
* @param value number to assign
*/
public void setValue(int value) {
setText(Integer.toString(value));
}
} //end class NumericTextField
/**
* hostname fields
*/
static class HostnameField extends RestrictedTextField {
//list of valid chars in a hostname
private static final String VALID_TEXT =
"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWZYZ-.";
public HostnameField(int columns) {
super(columns, VALID_TEXT);
}
public HostnameField() {
super(VALID_TEXT);
}
}
}
|
