server.java

自己用java编的tftp服务器 可以在局域网内传输小的文件.

import java.io.*;
import java.nio.*;
import java.net.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.MaskFormatter;
import java.util.Date;

class Server extends JFrame implements ActionListener
{
	private JTextArea txtArea;
	private JTabbedPane tabbedPane = new JTabbedPane();
	private JPopupMenu popupMenu = new JPopupMenu();
	private JLabel[] labels;
		private JLabel lblPort;
		private JLabel lblTimeout;
		private JLabel lblRetries;	
	private JTextField[] fields;
		private JTextField txtPort;
		private JTextField txtTimeout;
		private JTextField txtRetries;
	private JPanel panelOpt;
	private JPanel panelOptBtn;
	private JButton[] buttons;
		private JButton btnApply;
		private JButton btnReset;
	private JCheckBox chkVerbose;
	private String fileToRead;
	private String fileToWrite;
	private DatagramSocket socket;
	private DatagramPacket receivePacket;
	private boolean ackReceived = true;
	private boolean sendEndPacket = false;
	private boolean verboseOutput = true;
	private boolean socketInitialised=false;
	private boolean tryingResend=false;
	private boolean chngPort = false;
	private boolean chngTimeout = false;
	private boolean chngRetries = false;
	private boolean chngVerbose = false;
	private int firstTime = 0;
	private int maxTimeout = 6000;
	private int maxRetries = 3;
	private int retries = 0;
	private int myCount = 0;
	public static int s = 69;

	private byte sendData[] = new byte[512];
	private byte backupData[] = new byte[512];
	private byte test[]= new byte[512];
	private DatagramPacket backupPacket = new DatagramPacket(sendData,sendData.length);
	private ByteBuffer bbuf = ByteBuffer.allocate(512);

	public Server()
	{	
        createGUI();
        // Call openSocket()
		openSocket();
	}//end public Server()

	public void createGUI()
	{
		//Labels
		lblPort = new JLabel("Server Port (Default = 69)");
		lblTimeout = new JLabel("Request Timout (Milliseconds)");
		lblRetries = new JLabel("Retries");
		JLabel[] labels = {lblPort, lblTimeout, lblRetries};
		
		//Fields
		txtPort = new JTextField(Integer.toString(s));
		txtPort.setColumns(5);
		txtPort.setName("Port Field");
		txtTimeout = new JTextField(Integer.toString(maxTimeout));
		txtTimeout.setColumns(4);
		txtTimeout.setName("Timeout Field");
		txtRetries = new JTextField(Integer.toString(maxRetries));
		txtRetries.setColumns(4);
		txtRetries.setName("Retries Field");
		//Add key press listners
		txtPort.addKeyListener(new pressKey(txtPort));
		txtTimeout.addKeyListener(new pressKey(txtTimeout));
		txtRetries.addKeyListener(new pressKey(txtRetries));

		JTextField[] fields = {txtPort, txtTimeout, txtRetries};
		
		//CheckBox
		chkVerbose = new JCheckBox("Verbose Output Enabled", true);
		chkVerbose.addActionListener(this);
		
		//Buttons
		btnApply = new JButton("Apply");
		btnApply.addActionListener(this);
		btnApply.setEnabled(false);
		btnReset = new JButton("Reset");
		btnReset.addActionListener(this);
		
		JButton[] buttons = {btnApply, btnReset};
		
		//Create Options Panel
		panelOpt = new JPanel(new FlowLayout(FlowLayout.CENTER,20,20));
		panelOpt.setBorder(BorderFactory.createEmptyBorder(10,10,50,10));
		
		//Add components
		int numLabels = labels.length;
		for (int i = 0; i < numLabels; i++)
		{
			panelOpt.add(labels[i]);
			panelOpt.add(fields[i]);
		}
		
		//Add the output checkbox to panel
		panelOpt.add(chkVerbose);

		//Add Buttons
		panelOptBtn = new JPanel();
		
		int numButtons = buttons.length;
		for (int i = 0; i < numButtons; i++)
		{
			panelOptBtn.add(buttons[i]);
		}

		panelOpt.add(panelOptBtn, BorderLayout.SOUTH);
		
		txtArea = new JTextArea();
		
		JScrollPane scrollpane;
		scrollpane = new JScrollPane(txtArea,
							JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
							JScrollPane. HORIZONTAL_SCROLLBAR_AS_NEEDED);

		tabbedPane.addTab("Display", scrollpane);
        tabbedPane.addTab("Options", panelOpt);
        tabbedPane.addChangeListener(new paneChangeListner(tabbedPane));
		//Add the tabbed pane to this panel.
        add(tabbedPane);
        
        //The following line enables scrolling tabs.
        tabbedPane.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
        
        // Create the right click popup menu
    	JMenuItem clearMenuItem = new JMenuItem("Clear Output");
    	clearMenuItem.addActionListener(this);
    	popupMenu.add(clearMenuItem);
    	
        //Add listener to the text area for popup menu.
        MouseListener popupListener = new popupListener(popupMenu);
        popupMenu.addMouseListener(popupListener);
        txtArea.addMouseListener(popupListener);
     }//end public void createGUI()

	public static void setSocket(int socketToUse)
	{
		s = socketToUse;
	}//end public static void setSocket(int socketToUse)
	
	public void openSocket()
	{
		try
		{
			socket = new DatagramSocket(s);
			displayMessage("\n[INFO] Server ready on port: " + s);
			socketInitialised=true;
		}
					
		catch (SocketException e)
		{
			//e.printStackTrace();
			displayMessage("\nERROR: Could not open socket!");
			socketInitialised=false;
		}
	}//end public void openSocket()
	
	public void waitForRequest() throws IOException
	{
		if (socketInitialised==true)
		{
			byte receiveData[] = new byte[512];
			receivePacket = new DatagramPacket(receiveData, receiveData.length);
			try
			{
				socket.receive(receivePacket);
			}
			catch (SocketException e)
			{
				e.printStackTrace();
				System.out.println("WFR: Socket Exception");
			}
			fileToRead = new String(receivePacket.getData(),
									0, receivePacket.getLength());
			displayMessage("\nReceived request from host: "
					+ receivePacket.getAddress()
					+ "\nRequest accepted");
			// Begin socketTimout
			socket.setSoTimeout(maxTimeout);
			sendFile();
		}//end if (socketInitialised==true)
	}//end public void waitForRequest() throws IOException

	public void waitForAck() throws IOException
	{
		if (socketInitialised==true)
		{
			byte receiveData[] = new byte[512];
			receivePacket = new DatagramPacket(receiveData, receiveData.length);
			
			try
			{
				socket.receive(receivePacket);
				
				if(verboseOutput)
				{
					displayMessage("\nReceived ACK from host: "+
										receivePacket.getAddress());
				}
				
				ackReceived = true;	
				tryingResend = false;
			}
			
			catch (SocketTimeoutException e)
			{
				displayMessage("\nERROR: Request timed out whilst waiting for ACK");
				// Call to attempt resend of packet
				sendRetry();
			}
		}//end if (socketInitialised==true)	
	}//end public void waitForAck() throws IOException

	public void sendFile()
	{
		int c;
		try
		{
			FileInputStream in = new FileInputStream(fileToRead);
	 		
	 		displayMessage("\nBeginning transfer of " + fileToRead);
	 		
	 		// Get the size of the file
	 		File file = new File(fileToRead);
        	long fileLength = file.length();
            displayMessage(" (" + fileLength + " BYTES)\n");
 	
			int count = 1;
			
			while ((c = in.read(sendData)) != -1)
			{
				if (firstTime != 0)
				{
					waitForAck();
				}//end if (firstTime != 0)
				
				if (ackReceived == true)
				{	
					// This is the position in the file
					// calculated as each packet is 512 bytes
					// hence multiplied by the count gives the
					// position in file
					// This is the case until the last packet
					// which is calculated differently
					long offset = (512*count);
					
					/*DEBUG
					displayMessage("\n offset = " + offset);
					displayMessage("\n fileLength = " + fileLength);
				    */
				    
				    // if location is smaller than file
					if (offset<fileLength)
					{
						if(verboseOutput)
						{
				    		displayMessage("\nSending Packet #" + count);
				    	}

						DatagramPacket sendPacket = new DatagramPacket(sendData,
							sendData.length, receivePacket.getAddress(),
							receivePacket.getPort());

						// Create the backup packet
						backupPacket = sendPacket;

	    				try
						{
							FileOutputStream outTest = new FileOutputStream("bakPckt");
							outTest.write(backupPacket.getData());
							outTest.close();
							myCount++;
						}
						catch (IOException e)
						{
							displayMessage("\nERROR: Unable to create file.");
							displayMessage("\n       During creation of backup packet.");
						}	
						/*
						// Convert the bytes into a string
						String s="";
						for(int i=0; i<sendData.length; i++)
							{
								s+=(char)sendData[i];
							}
						displayMessage("\n ORIG: " + s);
						*/
						
						// Send packet
						socket.send(sendPacket);

					}//end if (offset<fileLength)
				
					// The final DATA packet must contain less than a full-sized block
					// of data to signal that it is the last.
					// The offset is now greater than the filesize as our packet is
					// 512 BYTES.
					// Hence we must calculate the exact size to make the packet.
					if (offset>fileLength)
					{
						long toSubtract = (offset-fileLength);
						long newSize = (512-toSubtract);
			
						//displayMessage("\n NewSize = " + newSize);
						
						if(verboseOutput)
						{
							displayMessage("\n Sending Final Packet (a) #" + count);
						}
						
						DatagramPacket sendPacket = new DatagramPacket(sendData,
							(int)newSize, receivePacket.getAddress(),
							receivePacket.getPort());

						// Create the backup packet
						backupPacket = sendPacket;

	    				try
						{
							FileOutputStream outTest = new FileOutputStream("bakPckt");
							outTest.write(backupPacket.getData());
							outTest.close();
							myCount++;
						}
						catch (IOException e)
						{
							displayMessage("\nERROR: Unable to create file.");
							displayMessage("\n       During creation of backup packet.");
						}
							socket.send(sendPacket);
							endTransfer();
					}//end if (offset>fileLength)
				
					// If the size of the transferred file is an exact multiple of the
					// block-size, the source sends a final DATA packet containing 0
					// bytes of data to signify end of transfer.
					if (offset==fileLength)
					{
						if(verboseOutput)
						{
							displayMessage("\n Sending Final Packet (b) #" + count);
						}
						
						DatagramPacket sendPacket = new DatagramPacket(sendData,
							sendData.length, receivePacket.getAddress(),
							receivePacket.getPort());
							
						// Create the backup packet
						backupPacket = sendPacket;

	    				try
						{
							FileOutputStream outTest = new FileOutputStream("bakPckt");
							outTest.write(backupPacket.getData());
							outTest.close();
							myCount++;
						}
						catch (IOException e)
						{
							displayMessage("\nERROR: Unable to create file.");
							displayMessage("\n       During creation of backup packet.");
						}

						socket.send(sendPacket);				
						sendEndPacket = true;
					}//end if (offset==fileLength)
				
					// This is the 0BYTE end packet
					if (sendEndPacket == true)
					{
						if(verboseOutput)
						{
							displayMessage("\n Sending END Packet" + count);
						}
						DatagramPacket sendPacket = new DatagramPacket(sendData,
							0, receivePacket.getAddress(),
							receivePacket.getPort());
							
						// Create the backup packet
						backupPacket = sendPacket;

	    				try
						{
							FileOutputStream outTest = new FileOutputStream("bakPckt");
							outTest.write(backupPacket.getData());
							outTest.close();
							myCount++;
						}
						catch (IOException e)
						{
							displayMessage("\nERROR: Unable to create file.");
							displayMessage("\n       During creation of backup packet.");
						}

						socket.send(sendPacket);
						
						// Signal successful transfer