CSDN博客

img yellowicq

soap监视器

发表于2003/3/25 9:38:00  1894人阅读

1.soap监视器原理:soap监视器通过tcpip协议截获和转发soap请求,并且显示相关的soap封装信息,使开发人员可以轻松的调试web服务,它的原理如下:

2.系统类图:

3.程序源代码:

package estore.client.util;

/*
 * EStore
 *
 * Copyright (c) 2003 YL Group.  All rights reserved.
 *
 */

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.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;
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.awt.event.WindowEvent;
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;

/**
 * TCP monitor to log http messages and responses, both SOAP and plain HTTP.
 * @author yellowicq(yellowicq@xinhuanet.com)
 */

public class TCPMonitor
    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.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);
            }
            l = new Listener(noteb, null, lPort, tHost, tPort,
                             proxyButton.isSelected(), slowLink);

            // 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);
          }
        }
      }
      );

      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) {
        LogPage.LogInfor(e.getMessage());
      }
    }
  }

  /**
   * 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;
    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,
                    TableModel tModel, int index, final String type,
                    SlowLinkSimulator slowLink) {
      inSocket = inputSocket;
      in = inputStream;
      outSocket = outputSocket;
      out = outputStream;
      textArea = _textArea;
      xmlFormat = format;
      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];
        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 (tmodel != null) {
          String tmpStr = (String) tmodel.getValueAt(tableIndex,
              REQ_COLUMN);

          if (!"".equals(tmpStr)) {
            reqSaved = tmpStr.length();
          }
        }

        a:
        for (; ; ) {
          if (done) {
            break;
          }

          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];
              }
            }

            textArea.append(new String(tmpbuffer, 0, i2));

            // Shift saved bytes to the beginning
            for (i = 0; i < saved; i++) {
              buffer[i] = buffer[bufferLen - saved + i];
            }
          }
          else {
            textArea.append(new String(buffer, 0, len));
          }
        }
      }
      catch (Exception e) {
        LogPage.LogInfor(e.getMessage());
      }
      finally {
        done = true;
        try {
          if (out != null) {
            out.flush();
            if (null != outSocket) {
              outSocket.shutdownOutput();
            }
            else {
              out.close();
            }
            out = null;
          }
        }
        catch (Exception e) {
          LogPage.LogInfor(e.getMessage());
        }
        try {
          if (in != null) {
            if (inSocket != null) {
              inSocket.shutdownInput();
            }
            else {
              in.close();
            }
            in = null;
          }
        }
        catch (Exception e) {
          LogPage.LogInfor(e.getMessage());;
        }
        myConnection.wakeUp();
      }
    }

    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) {
        LogPage.LogInfor(e.getMessage());
      }
    }
  }

  /**
   * 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());

        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 ")) {
            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 + "/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();

        //this is the channel to the endpoint
        rr1 = new SocketRR(this, inSocket, tmpIn1, outSocket,
                           tmpOut2, inputText, format,
                           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,
                           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.
          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;
          }

          synchronized (this) {
            this.wait(1000); //Safety just incase we're not told to wake up.
          }
        }

        active = false;

        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
          LogPage.LogInfor("outputText is null,so log the infor as /n'"+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) {
        LogPage.LogInfor(e.getMessage());
      }
    }

    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) {
        LogPage.LogInfor("index:=" + index + this);
      }
    }
  }


  /**
   * this is the log page
   */
  class LogPage
      extends JPanel {
    // Monitor log section
    ///////////////////////////////////////////////////////////////////
    public  JPanel logPanel = new JPanel(new BorderLayout());
    public static JTextArea textArea = null;
    public LogPage(JTabbedPane notebook, String name) {
      logPanel.setBorder(new TitledBorder(TCPMonitor.getMessage("log01", "TCP Monitor Log")));
      textArea = new JTextArea(null, null, 27, 93);
      logPanel.add(new JScrollPane(textArea),BorderLayout.CENTER);
      this.setLayout(new BorderLayout());
      this.add(logPanel, BorderLayout.CENTER);
      notebook.addTab(name, this);
      notebook.repaint();
      notebook.setSelectedIndex(notebook.getTabCount() - 1);
      textArea.setEditable(true);
    }

    public static void LogInfor(String infor) {
      textArea.append(infor+"/n");
    }
  }
//EOC

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

0 0

相关博文

我的热门文章

img
取 消
img