/*
    *  XNap - A P2P framework and client.
    *
    *  See the file AUTHORS for copyright information.
    *
    *  This program is free software; you can redistribute it and/or modify
    *  it under the terms of the GNU General Public License as published by
    *  the Free Software Foundation.
    *
   *  This program is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *  GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *  along with this program; if not, write to the Free Software
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
  package org.xnap.plugin.opennap.net;
  
  import java.io.BufferedInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InterruptedIOException;
  import java.io.OutputStream;
  import java.net.ServerSocket;
  import java.net.Socket;
  import java.net.SocketException;
  import java.util.List;
  import java.util.Vector;
  
  import org.apache.log4j.Logger;
  import org.xnap.plugin.opennap.net.msg.MessageHandler;
  import org.xnap.plugin.opennap.net.msg.client.ChangeDataPortMessage;
  import org.xnap.util.PortRange;
  
  // FIX: a DOS attack is easily possible by connecting to the listener
  // and not sending data...
  public class OpenNapListener  {
  
      //--- Constant(s) ---
  
      //--- Data field(s) ---
  
      protected static Logger logger = Logger.getLogger(ListenerThread.class);
  
      private PortRange range = null;
      private ListenerThread runner = null;
  
      private List listeners = new Vector();
      
      //--- Constructor(s) ---
      
      public OpenNapListener(PortRange range) 
      {
  		setPortRange(range);
      }
  
      public OpenNapListener()
      {
      }
      
      //--- Method(s) ---
      
      public void addSocketListener(SocketListener s)
      {
  		listeners.add(s);
      }
  
      public void removeSocketListener(SocketListener s)
      {
  		listeners.remove(s);
      }
  
      public int getPort()
      {
  		return (runner != null) ? runner.getPort() : 0;
      }
  
      public void die() 
      {
  		if (runner != null) {
  			runner.die();
  			runner = null;
  		}
      }
  
      private void start(int port)
      {
  		if (range != null) {
  			ServerSocket socket = null;
  
  			if (port != 0) {
  				try {
  					// try to open the socket on port first
  					socket = new ServerSocket(port);
  				} 
  				catch (IOException e) {
 				}
 			}
 
 			if (socket == null) {
 				// bind to next free port
 				for (PortRange.IntIterator i = range.random(); i.hasNext();) {
 					try {
 						socket = new ServerSocket(i.next());
 						break;
 					} 
 					catch (IOException e) {
 					}
 				}
 			}
 
 			if (socket != null) {
 				runner = new ListenerThread(socket);
 				runner.start();
 			}
 			else {
 				logger.debug("could not start listener on "
 							 + range.toString());
 			}
 		}
     }
 
     private void restart(int port)
     {
 		int oldPort = getPort();
 
 		die();
 		start(port);
 
 		if (oldPort != getPort()) {
 			// notify servers of changed port
 			MessageHandler.send(new ChangeDataPortMessage(getPort()));
 		}
 
     }
 
     private void restart()
     {
 		restart(0);
     }
     
     /***
      * Sets a new port range and restarts socket thread if needed.
      */
     public void setPortRange(PortRange newValue)
     {
 		PortRange oldValue = range;
 		range = newValue;
 	
 		if (newValue != null && newValue.contains(getPort())) {
 			// no need to restart the listener
 			return;
 		}
 
 		restart();
     }
 
     private void fireSocketReceived(IncomingSocket s)
     {
         Object[] l = listeners.toArray();
 
 		if (l != null) {
 			for (int i = l.length - 1; i >= 0; i--) {
 				if (((SocketListener)l[i]).socketReceived(s)) {
 					return;
 				}
 			}
 		}
 
 		s.close();
     }
 
     //--- Inner Class(es) ---
 
     private class ListenerThread extends Thread {
 	
 		private ServerSocket listenerSocket = null;
 		private boolean die = false;
 	
 		public ListenerThread(ServerSocket listenerSocket)
 		{
 			super("OpenNapListener :" + listenerSocket.getLocalPort());
 	    
 			this.listenerSocket = listenerSocket;
 		}
 
 		public void die()
 		{
 			die = true;
 		}
 
 		public int getPort()
 		{
 			return listenerSocket.getLocalPort();
 		}
 
 		private void handleSocket(Socket s)
 		{
 			InputStream in = null;
 			OutputStream out = null;
 	    
 			try {
 				in = new BufferedInputStream(s.getInputStream());
 				out = s.getOutputStream();
 		
 				out.write('1');
 				out.flush();
 		
 				byte data[] = new byte[2048];
 				in.mark(8);
 				int i = in.read(data, 0, 8);
 		
 				if (i > 0) {
 					String response = new String(data, 0, i);
 		    
 					logger.debug("received: " + response);
 					in.reset();
 		    
 					if (response.startsWith("GETLIST")) {
 						in.skip(7);
 						fireSocketReceived(new BrowseUploadSocket(s, in));
 						logger.debug("creating BrowseUploadSocket");
 					}
 					else if (response.startsWith("GET")) {
 						in.skip(3);
 						fireSocketReceived(new UploadSocket(s, in));
 						logger.debug("creating UploadSocket");
 					}
 					else if (response.startsWith("SENDLIST")) {
 						// add to queue for reverse direct browse threads
 						in.skip(8);
 						fireSocketReceived(new BrowseDownloadSocket(s, in));
 						logger.debug("creating BrowseDownloadSocket");
 					}
 					else if (response.startsWith("SEND")) {
 						in.skip(4);
 						// add to queue for reverse download threads
 						fireSocketReceived(new DownloadSocket(s, in));
 						logger.debug("creating DownloadSocket");
 					}
 					else {
 						throw new IOException("invalid request: " + response);
 					}
 
 				}
 				else {
 					throw new IOException("empty request");
 				}
 			} 
 			catch (IOException e) {
 				logger.warn("invalid listener request", e);
 		
 				try {
 					if (s != null) {
 						s.close();
 					}
 					if (in != null) {
 						in.close();
 					}
 					if (out != null) {
 						out.close();
 					}
 				} 
 				catch (IOException ioe) {
 				}
 			}
 		}
 	
 
 		public void run() 
 		{
 			boolean restart = false;
 			logger.debug("started listener on port " + getPort());
 	    
 			try {
 				listenerSocket.setSoTimeout(10 * 1000);
 			} 
 			catch(SocketException e) {
 				restart = true;
 				die = true;
 			}
 	    
 			while(!die) {
 				Socket socket = null;
 				try {
 					socket = listenerSocket.accept();
 					// only wait 10 seconds for a request, otherwise
 					// the listener might be blocked forever.
 					socket.setSoTimeout(30 * 1000);
 				}
 				catch(InterruptedIOException e) {
 					continue;		
 				}
 				catch(IOException e) {
 					restart = true;
 					break;
 				}
 		
 				if (socket != null) {
 					handleSocket(socket);
 				}
 			}
 	
 			try {
 				listenerSocket.close();
 			} 
 			catch(IOException e) {
 			}
 
 			logger.debug("stopped listener on port " + getPort());
 	    
 			if (restart) {
 				// the thread has died unexpectively, restart it
 				logger.debug("listener died unexpectively, restarting");
 				restart(getPort());
 			}
 		}
 	
     }
 
 }