view.java

The WLAN Traffic Visualizer is a platform independent Java program providing accurate measurement of

		trainPanel.redraw();
	}

	// Main helper functions

	public void setTotalPacketCountLabel(int c) {
		infoBar.totalPCountLabel.setText(Integer.toString(c));
	}

	public void setGridLabel(String string) {
		infoBar.gridLabel.setText(string);
	}

	private String selectCaptureFile() throws Exception {

		class FcAccessory extends JPanel {
			JTextField packetFilterField = new JTextField("");

			public FcAccessory() {
				setAlignmentX(5);
				JLabel label = new JLabel("Specify capture filter (optionally):");
				JTextArea ta = new JTextArea("\nFilter examples (Wireshark format):\n\n" +
						"-Rframe.number>10000&&frame.number<20000\n"+
				"-Rwlan.addr==xx:xx:xx:xx:xx:xx||wlan.fc.type_subtype==0x08");

				setLayout(new FlowLayout(FlowLayout.LEFT));
				packetFilterField.setColumns(35);
				add(label);
				add(packetFilterField);
				packetFilterField.setText(packetFilter.trim());
				add(ta);
				setPreferredSize(new Dimension(400, 0));
			}
		}

		captureFile = null;
		FcAccessory fcAcc = new FcAccessory();

		// System.out.println("Selecting capture file...");
		JFileChooser fc = new JFileChooser();
		fc.setAccessory(fcAcc);
		fc.setCurrentDirectory(new File(Main.properties.getProperty("log.dir")));
		FileNameExtensionFilter filter = new FileNameExtensionFilter("Capture files", "pcap", "cap", "apc", "pkt", "wtvcap");
		fc.setFileFilter(filter);
		fc.setDialogTitle("Select capture file");

		if (fc.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
			captureFile = fc.getSelectedFile().getCanonicalPath();
			Main.properties.updateProperty("log.dir", fc.getCurrentDirectory().getCanonicalPath());
		}

		packetFilter = " "+fcAcc.packetFilterField.getText();

		if (captureFile == null)
			throw (new Exception("No capture file selected"));

		if (System.getProperty("os.name").toLowerCase().contains("linux"))
			if (captureFile.contains(" "))
				throw (new Exception("Space in Linux log path not supported"));
		return captureFile;
	}

	private String getIface(String candidateCaptureFile) {
		String selected;

		class InterfaceList extends Command implements Callable<StringBuffer> {
			StringBuffer sb = new StringBuffer();

			@Override
			public void newLine(String line) throws InterruptedException {
				sb.append(line + "\n");
			}

			@Override
			public StringBuffer call() throws Exception {
				String cmd = Main.tsharkExe + " -D";
				execute(cmd);
				return sb;
			}
		}

		InterfaceList interfaceList = new InterfaceList();
		StringBuffer list;
		try {
			list = interfaceList.call();
			selected = JOptionPane.showInputDialog(
					"Starting capture to file " + candidateCaptureFile + "\n\n"+
					"Enter wireless interface name or number:\n" + list);
			if (selected != null && selected.equals("")) {
				selected = null;
			}
		} catch (Exception e) {
			JOptionPane.showMessageDialog(null, e.getMessage());
			selected = null;
			e.printStackTrace();
		}
		return selected;
	}

	public static String addQuotesForWindows(String file) {
		if (System.getProperty("os.name").toLowerCase().contains("windows"))
			file = "\"" + file + "\"";
		return file;
	};

	private void prepareCapture(ArrayList<Packet> list) {
		model.init(list);
		trainPanel.init(this, model.getPackets(), model.getTransaction(), getAddedPackets(), mouseHandler);
		Main.myLogging.clear();
	}

	@SuppressWarnings("unchecked")
	private void recallCapture(String fileName) {
		ArrayList<Packet> packets;

		try {
			packets = (ArrayList<Packet>)Main.load(new File(fileName));
		} catch (InvalidClassException e) {
			fireMyEvent(MY_EVENT.CAPTURE_ABORT);
			JOptionPane.showMessageDialog(
					null,
					"Invalid wtvcap file format",
					"Error",
					JOptionPane.ERROR_MESSAGE);
			e.printStackTrace();
			return;
		} catch (Exception e) {
			fireMyEvent(MY_EVENT.CAPTURE_ABORT);
			return;
		}

		prepareCapture((ArrayList<Packet>)packets);
		trainPanel.firstPacket(null);
		trainPanel.lastPacket();
	}

	private void runCapture(String cmd) {
		prepareCapture(null);

		try {
			capture = new Capture(cmd, comboBar.getModeValue(), heapMonitor);
		} catch (Exception e) {
			e.printStackTrace();
			JOptionPane.showMessageDialog(null, e.getMessage());

			fireMyEvent(MY_EVENT.CAPTURE_ABORT);
			return;
		}
		trainPanel.firstPacket(capture.getPacketQ());
		try {
			capture.run();
		} catch (LowMemException e) {
			lowMemMessage();
		} catch (IOException e) {
			//			 e.printStackTrace();
			// JOptionPane.showMessageDialog(null,e.getMessage());
		} catch (Exception e) {
			// System.out.println(e.getMessage());
			e.printStackTrace();
			JOptionPane.showMessageDialog(null, e.getMessage());
			fireMyEvent(MY_EVENT.CAPTURE_ABORT);
			System.out.println("Abort");
			return;
		}
		trainPanel.lastPacket();

		// System.out.println("Packet count: "+packets.size());
	}

	ArrayList<Packet> getAddedPackets() {
		if (availability != null)
			return availability.extraPackets;
		else
			return null;
	}

	private void showPacketDetails(Packet r) throws Exception {
		if (captureFile.endsWith(".wtvcap")) {
			JOptionPane.showMessageDialog(null, "Packet details not available");
			return;
		}
		packetDetails.update(r, addQuotesForWindows(captureFile));
		tabbedPane.setSelectedComponent(packetDetails);
	}

	private void setSummaryText() {
		summary.totalTextArea.setText(getSummary());
		summary.viewTextArea.setText("Frame numbers\t"+getViewPacketSpan()+availability.getAvailability());
		summary.fillTransTextArea.setText(availability.getFillTransactionDetails());
		summary.extraTextArea.setText(availability.getExtra());
	}

	private String getViewPacketSpan() {
		return 
		trainPanel.getViewFirstPacket().frameNumber + " ... " +
		trainPanel.getViewLastPacket().frameNumber + "\n";
	}

	private String getSummary() {
		StringBuffer sb = new StringBuffer();
		sb.append("Capture file\t" + captureFile + "\n");
		sb.append("Capture duration\t" + Main.usToSec(model.getTransaction().getCaptureSpan()) + "\n");
		sb.append("Packet count\t" + model.getPackets().size() + "\n");
		sb.append("Avg. packet size\t" + String.format("%.1f", model.getTransaction().getAveragePacketLength()) + "\n");
		sb.append("Byte count\t" + model.getTransaction().getByteCount() + "\n");
		double packetsPerSec = 1E6 * model.getPackets().size() / (double) model.getTransaction().getCaptureSpan();
		double bytesPerSec = 1E6 * model.getTransaction().getByteCount() / (double) model.getTransaction().getCaptureSpan();
		sb.append("Avg. throughput\t" + String.format("%.1f", 8 * bytesPerSec / 1E6) + " Mbit/sec (Mbps)\n");
		sb.append("\t" + String.format("%.1f", bytesPerSec) + " bytes/sec\n");
		sb.append("\t" + String.format("%.1f", packetsPerSec) + " packets/sec\n");
		sb.append("Transaction count\t" + model.getTransaction().list.size() + "\n");
		sb.append("Header\t" + model.getPackets().get(0).frameProtocols.split(":")[0]);
		return sb.toString();
	}

	private void setPacketText(Packet r) {
		String s = Packet.getFields(r, '\n').toString();
		s = WlanTvProperties.replaceMacAddrWithAlias(s, true);
		packetPanel.sniffTextArea.setText(s);
		packetPanel.sniffTextArea.setCaretPosition(0);
		s = r.getPacketInfo();
		packetPanel.resultTextArea.setText(s);
		packetPanel.resultTextArea.setCaretPosition(0);
	}

	protected String getViewCaptureTime() {
		return Main.usToSec(availability.getCaptureTime());
	}

	protected int getFillPacketLength() {
		return comboBar.getFillPayloadLenValue();
	}

	protected int getDefaultFillPayloadLength() {
		return (int) model.getTransaction().getAverageUnicastLength();
	}

	protected String getTotalCaptureTime() {
		return Main.usToSec(model.getTransaction().getCaptureSpan());
	}

	protected void setTransactionText(OneTransaction one) {
		packetPanel.transTextArea.setText(one.getTransactionInfo());
		packetPanel.transTextArea.setCaretPosition(0);
	}

	protected int getFillAccessTime() {
		return availability.getFillAccessTime();
	}

	protected boolean showFillPackets() {
		return buttonBar.getAdvancedValue();
	}

	protected boolean showPacketDetails() {
		return buttonBar.getDetailsValue();
	}

	protected boolean showTransactions() {
		return buttonBar.getAdvancedValue();
	}

	// The custom event handler

	// Declare the event. It must extend EventObject.
	public class MyEvent extends EventObject {
		public MyEvent(Object source) {
			super(source);
		}
	}

	// Declare the listener class. It must extend EventListener.
	// A class must implement this interface to get MyEvents.
	public interface MyEventListener extends EventListener {
		public void myEventOccurred(MyEvent evt);
	}

	// Create the listener list
	protected EventListenerList listenerList = new EventListenerList();

	// This methods allows classes to register for MyEvents
	public void addMyEventListener(MyEventListener listener) {
		listenerList.add(MyEventListener.class, listener);
	}

	// This methods allows classes to unregister for MyEvents
	public void removeMyEventListener(MyEventListener listener) {
		listenerList.remove(MyEventListener.class, listener);
	}

	// This private class is used to fire MyEvents
	void fireMyEvent(MY_EVENT myevent) {
		MyEvent evt = new MyEvent(myevent);
		Object[] listeners = listenerList.getListenerList();
		// Each listener occupies two elements - the first is the listener class
		// and the second is the listener instance
		for (int i = 0; i < listeners.length; i += 2) {
			if (listeners[i] == MyEventListener.class) {
				((MyEventListener) listeners[i + 1]).myEventOccurred(evt);
			}
		}
	}

	public void setWaitCursor1() {
		final Cursor c = new Cursor(Cursor.WAIT_CURSOR);
		setCursor(c);
	}

	public void setWaitCursor2() {
		//		final Cursor c = new Cursor(Cursor.CROSSHAIR_CURSOR);
		final Cursor c = Toolkit.getDefaultToolkit().createCustomCursor(
				MyIcons.getImage(this, "calculator.png"), new Point(0,0), "Pencil");
		setCursor(c);
	}

	public void setNormalCursor() {
		final Cursor hourglassCursor = new Cursor(Cursor.DEFAULT_CURSOR);
		setCursor(hourglassCursor);
	}

	public void setTabbedPaneVisible(boolean b) {
		tabbedPane.setVisible(b);
	}

	public void runCapture(String cmdString, String captureFile) {
		this.captureFile = captureFile;
		runCapture(cmdString);
		setTitle("WlanTV - " + captureFile);
	}

	private void lowMemMessage() {
		JOptionPane.showMessageDialog(null, "Capture aborted due to low free memory" +
				"\nTrying to continue with captured packets" +
				"\n" + heapMonitor.getMemReport() +
				"\n\nPlease increase Java heap space if you want to handle greater captures"+
				"\ne.g. run program with \"java -Xms64m -Xmx256m -jar  wlantv.jar\"",
				"Warning",
				JOptionPane.WARNING_MESSAGE);
	}

	public void showFirstPacket() {
		setPacketText(model.getTransaction().list.get(0).packetList.get(0));
		setTransactionText(model.getTransaction().list.get(0));
	}

	public void setLiveLogFolder() {	
		JFileChooser fc = new JFileChooser();
		fc.setDialogTitle("Select live log directory");
		fc.setAcceptAllFileFilterUsed(false);
		fc.setCurrentDirectory(new File(Main.properties.getProperty("livelog.dir",System.getProperty("user.dir"))));
		fc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
		fc.setApproveButtonText("Select");
		fc.setFileFilter(null);

		if (fc.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
			try {
				String logDir = fc.getSelectedFile().getCanonicalPath();
				
				if (System.getProperty("os.name").toLowerCase().contains("linux"))
					if (logDir.contains(" ")) {
						JOptionPane.showMessageDialog(null, "Space in Linux log path not supported");
						return;
					}
				Main.properties.updateProperty("livelog.dir", logDir);
				System.out.println("Log directory changed to " + logDir);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
//		System.out.println(Main.properties.getProperty("livelog.dir")+File.separatorChar+"*");
//		File file = new File(Main.properties.getProperty("livelog.dir")+File.separatorChar+"*");
//		System.out.println("Has write permission " + hasWritePermission(Main.properties.getProperty("livelog.dir")+File.separatorChar+"*"));
//		System.out.println("Can write " + file.setWritable(true));
//		System.out.println("Can write " + file.canWrite());
	}

//	public boolean hasWritePermission(String dir) { 
//		try {
//			AccessController.checkPermission(new FilePermission(dir+File.separatorChar+"*", "write"));
//		} catch (SecurityException e) {
//			return false;
//		}
//		return true;
//	}
}