1 files changed, 317 insertions, 0 deletions
diff --git a/libraries/oscP5/src/netP5/AbstractTcpServer.java b/libraries/oscP5/src/netP5/AbstractTcpServer.java
new file mode 100644
index 0000000..824efbb
--- /dev/null
+++ b/libraries/oscP5/src/netP5/AbstractTcpServer.java
@@ -0,0 +1,317 @@
+/**
+ * A network library for processing which supports UDP, TCP and Multicast.
+ *
+ * (c) 2004-2012
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library 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
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA  02111-1307  USA
+ * 
+ * @author		Andreas Schlegel http://www.sojamo.de
+ * @modified	12/23/2012
+ * @version		0.9.9
+ */
+
+package netP5;
+
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.util.Enumeration;
+import java.util.Vector;
+
+/**
+ * @invisible
+ */
+
+public abstract class AbstractTcpServer implements Runnable, TcpPacketListener {
+
+	protected ServerSocket _myServerSocket;
+
+	protected static int _myPort;
+
+	protected TcpPacketListener _myTcpPacketListener = null;
+
+	protected Vector _myTcpClients;
+
+	protected Thread _myThread;
+
+	public final static int MODE_READLINE = TcpClient.MODE_READLINE;
+
+	public final static int MODE_TERMINATED = TcpClient.MODE_TERMINATED;
+
+	public final static int MODE_NEWLINE = TcpClient.MODE_NEWLINE;
+
+	public final static int MODE_STREAM = TcpClient.MODE_STREAM;
+
+	protected final int _myMode;
+
+	protected Vector _myBanList;
+
+	/**
+	 * @invisible
+	 * @param thePort
+	 *            int
+	 * @param theMode
+	 *            int
+	 */
+	public AbstractTcpServer(
+			final int thePort, 
+			final int theMode) {
+		_myPort = thePort;
+		_myMode = theMode;
+		_myTcpPacketListener = this;
+		init();
+	}
+
+	/**
+	 * @invisible
+	 * @param theTcpPacketListener
+	 *            TcpPacketListener
+	 * @param thePort
+	 *            int
+	 * @param theMode
+	 *            int
+	 */
+	public AbstractTcpServer(
+			final TcpPacketListener theTcpPacketListener,
+			final int thePort, 
+			final int theMode) {
+		_myPort = thePort;
+		_myMode = theMode;
+		_myTcpPacketListener = theTcpPacketListener;
+		init();
+	}
+
+	protected void init() {
+		_myBanList = new Vector();
+		_myServerSocket = null;
+		_myTcpClients = new Vector();
+		try {
+			Thread.sleep(1000);
+		} catch (InterruptedException iex) {
+			Logger.printError("TcpServer.start()",
+					"TcpServer sleep interuption " + iex);
+			return;
+		}
+		try {
+			_myServerSocket = new ServerSocket(_myPort);
+		} catch (IOException e) {
+			Logger.printError("TcpServer.start()", "TcpServer io Exception "
+					+ e);
+			return;
+		}
+
+		_myThread = new Thread(this);
+		_myThread.start();
+		Logger.printProcess("TcpServer", "ServerSocket started @ " + _myPort);
+	}
+
+	/**
+	 * ban an IP address from the server.
+	 * @param theIP
+	 */
+	public void ban(String theIP) {
+		_myBanList.add(theIP);
+		for (int i = _myTcpClients.size() - 1; i >= 0; i--) {
+			if (((TcpClient) _myTcpClients.get(i)).netAddress().address()
+					.equals(theIP)) {
+				((TcpClient) _myTcpClients.get(i)).dispose();
+			}
+		}
+	}
+
+	/**
+	 * remove the ban for an IP address.
+	 * @param theIP
+	 */
+	public void unBan(String theIP) {
+		_myBanList.remove(theIP);
+	}
+	
+
+	private boolean checkBanList(ServerSocket theSocket) {
+		try {
+			String mySocketAddress = theSocket.getInetAddress()
+					.getHostAddress();
+			String mySocketName = theSocket.getInetAddress().getHostName();
+			for (int i = _myBanList.size() - 1; i >= 0; i--) {
+				if (mySocketAddress.equals(_myBanList.get(i))
+						|| mySocketName.equals(_myBanList.get(i))) {
+					return false;
+				}
+			}
+			return true;
+		} catch (Exception e) {
+		}
+		return false;
+	}
+
+	/**
+	 * get the server socket object. more at java.net.ServerSocket
+	 * @return
+	 */
+	public ServerSocket socket() {
+		return _myServerSocket;
+	}
+
+	/**
+	 * @invisible
+	 */
+	public void run() {
+		threadLoop: while (Thread.currentThread() == _myThread) {
+			try {
+				/**
+				 * @author when synchronized, disconnected clients are only
+				 *         removed from _myTcpClients when there is a new
+				 *         connection.
+				 */
+				// synchronized(_myTcpClients) {
+				if (checkBanList(_myServerSocket)) {
+					TcpClient t = new TcpClient(this, _myServerSocket.accept(),
+							_myTcpPacketListener, _myPort, _myMode);
+					if (NetP5.DEBUG) {
+						System.out.println("### new Client @ " + t);
+					}
+					_myTcpClients.addElement(t);
+					Logger.printProcess("TcpServer.run", _myTcpClients.size()
+							+ " currently running.");
+				}
+			}
+			// }
+			catch (IOException e) {
+				Logger.printError("TcpServer", "IOException. Stopping server.");
+				break threadLoop;
+			}
+		}
+		dispose();
+	}
+
+	/**
+	 * send a string to the connected client(s).
+	 * @param theString
+	 */
+	public synchronized void send(final String theString) {
+		try {
+			Enumeration en = _myTcpClients.elements();
+			while (en.hasMoreElements()) {
+				((TcpClient) en.nextElement()).send(theString);
+			}
+		} catch (NullPointerException e) {
+
+		}
+	}
+
+	/**
+	 * send a byte array to the connected client(s).
+	 * @param theBytes
+	 */
+	public synchronized void send(final byte[] theBytes) {
+		try {
+			Enumeration en = _myTcpClients.elements();
+			while (en.hasMoreElements()) {
+				((TcpClient) en.nextElement()).send(theBytes);
+			}
+		} catch (NullPointerException e) {
+
+		}
+	}
+
+	/**
+	 * kill the server.
+	 */
+	public void dispose() {
+		try {
+			_myThread = null;
+
+			if (_myTcpClients != null) {
+				Enumeration en = _myTcpClients.elements();
+				while (en.hasMoreElements()) {
+					remove((TcpClient) en.nextElement());
+				}
+				_myTcpClients = null;
+			}
+
+			if (_myServerSocket != null) {
+				_myServerSocket.close();
+				_myServerSocket = null;
+			}
+		} catch (IOException e) {
+			Logger.printError("TcpServer.dispose", "IOException " + e);
+		}
+	}
+
+	/**
+	 * get the number of connected clients.
+	 * @return
+	 */
+	public int size() {
+		return _myTcpClients.size();
+	}
+
+	/**
+	 * get a list of all connected clients. an array of type TcpClient[]
+	 * will be returned.
+	 * @return
+	 */
+	public TcpClient[] getClients() {
+		TcpClient[] s = new TcpClient[_myTcpClients.size()];
+		_myTcpClients.toArray(s);
+		return s;
+	}
+
+	/**
+	 * get a client at a specific position the client list.
+	 * @param theIndex
+	 * @return
+	 */
+	public TcpClient getClient(final int theIndex) {
+		return (TcpClient) _myTcpClients.elementAt(theIndex);
+	}
+
+	/**
+	 * @invisible
+	 * @param thePacket
+	 *            TcpPacket
+	 * @param thePort
+	 *            int
+	 */
+	public void process(final TcpPacket thePacket, final int thePort) {
+		handleInput(thePacket, thePort);
+	}
+
+	/**
+	 * @invisible
+	 * @param thePacket
+	 *            TcpPacket
+	 * @param thePort
+	 *            int
+	 */
+	public abstract void handleInput(final TcpPacket thePacket,
+			final int thePort);
+
+	/**
+	 * remove a TcpClient from the server's client list.
+	 * @param theTcpClient
+	 *            TCPClientAbstract
+	 */
+	public void remove(AbstractTcpClient theTcpClient) {
+		if (_myTcpPacketListener != null && !_myTcpPacketListener.equals(this)) {
+			_myTcpPacketListener.remove(theTcpClient);
+		}
+		theTcpClient.dispose();
+		_myTcpClients.removeElement(theTcpClient);
+		Logger.printProcess("TcpServer", "removing TcpClient.");
+	}
+
+}