git-svn-id: svn://imanolbarba.net/PAD@25 c2ee353e-ed0d-4329-bf56-03aec153487f

Imanol-Mikel Barba Sabariego
1 parent 791d4e1f
Showing 16 changed files with 402 additions and 381 deletions
JChatClient/bin/client
JChatClient/src/client.cpp
JChatClient/src/include/client.h
JChatClient/src/include/server.h
JChatServer/bin/pad/prac2/Connection.class
JChatServer/bin/pad/prac2/JChat.class
JChatServer/bin/pad/prac2/MyServerSocket.class
JChatServer/bin/pad/prac2/MySocket.class
JChatServer/bin/pad/prac2/Server.class
JChatServer/bin/pad/prac2/Worker.class
JChatServer/src/pad/prac2/Connection.java
JChatServer/src/pad/prac2/JChat.java
JChatServer/src/pad/prac2/MyServerSocket.java
JChatServer/src/pad/prac2/MySocket.java
JChatServer/src/pad/prac2/Server.java
JChatServer/src/pad/prac2/Worker.java
@@ -5,13 +5,7 @@
 *
 * En este fichero se implementa un cliente para poder usar con el servidor creado, usando la clase Socket.
 */
-#include "Socket.h"
-#include <iostream>
-#include "SocketException.h"
-#include <sstream>
-#include <signal.h>
-#include <cstdlib>
-#include <sys/time.h>
+#include "client.h"
  
 using namespace std;
  
@@ -22,24 +16,50 @@ bool connected, finished;
 el signal SIGPIPE. */
 void exitClient(int signal/*!<Parámetro que captura el signal recibido*/)
 {
-	cout << "Server connection terminated unexpectedly" << endl << "Exiting" << endl;
-	exit(-1);
+	if(signal == SIGPIPE)
+	{
+		cout << "Server connection terminated unexpectedly" << endl << "Exiting" << endl;
+		exit(-1);
+	}
+}
+
+void killThread(thread_args *t_arg)
+{
+	(t_arg->s)->Close();
+	pthread_mutex_lock(t_arg->mutex);
+	if(t_arg->s != 0)
+	{
+		delete t_arg->s;
+		t_arg->s = 0;
+	}
+	if(t_arg != 0)
+	{
+		delete t_arg;
+		t_arg = 0;
+	}
+	pthread_exit(NULL);
 }
  
 bool connect(Socket& s)
 {
-	string host;
+	string host, nick;
 	int port;
-	cout << "Hostname: ";
+	/*cout << "Hostname: ";
 	cin >> host;
 	cout << "Port: ";
-	cin >> port;
+	cin >> port;*/
+	cout << "Nickname: ";
+	cin >> nick;
 	cin.ignore();
+	host = "localhost";
+	port = 3001;
+
 	try
 	{
 		s.Connect(host,port);
 		cout << "Connected" << endl;
 		connected = true;
+		s << nick;
 	}
 	catch(SocketException& e)
 	{
@@ -47,32 +67,68 @@ bool connect(Socket&amp; s)
 	}
 }
  
-void speedTest(Socket& s)
+void* sendThread(void* args)
 {
-	string data = "", answer;
-	double size;
-	double start, duration;
-	cout << "Size in MB: ";
-	cin >> size;
-	cin.ignore();
-	for(long int i = 0; i < size*1e6; i++ )
+	string send;
+	struct thread_args *t_arg = (struct thread_args*)args;
+	while(true)
 	{
-		data += (char)( 65 + i % 26);
+		cout << "> ";
+		getline(cin,send);
+		if(cin.eof())
+		{
+			send = "/disconnect";
+		}
+		try
+		{
+			*(t_arg->s) << send;
+			if(send == "/disconnect" || send == "/exit")
+			{
+				break;
+			}
+		}
+		catch(SocketException& e)
+		{
+			cout << e.description() << endl;
+			cout << "Exiting" << endl;
+			(t_arg->s)->Close();
+        	exit(-1);
+		}
 	}
-	cout << "Data generated, commencing transfer" << endl;
-	struct timeval  st, ed;
-	gettimeofday(&st, NULL);
-	s << data;
-	cout << "Data sent" << endl;
-	s >> answer;
-	gettimeofday(&ed, NULL);
-	start = (st.tv_sec) + (st.tv_usec) / 1e6;
-	duration = ((ed.tv_sec) + (ed.tv_usec) / 1e6) - start;
-	if(answer == "ACK")
+	killThread(t_arg);
+}
+
+void* recvThread(void* args)
+{
+	string recv;
+	struct thread_args *t_arg = (struct thread_args*)args;
+	while(true)
 	{
-		cout << "Transferred " << size << " MB  in " << duration << " seconds" << endl;
-		cout << "Data rate: " << size/duration << " MB/s" <<  endl;
+		*(t_arg->s) >> recv;
+		if(recv == "DISC_OK")
+		{
+			cout << "Disconnecting" << endl;
+			(t_arg->s)->Close();
+	    	connected = false;
+	    	pthread_cond_signal(t_arg->condition);
+	    	break;
+		}
+		else if(recv == "EXIT_OK")
+		{
+			cout << "Exiting" << endl;
+			(t_arg->s)->Close();
+			connected = false;
+			finished = true;
+			pthread_cond_signal(t_arg->condition);
+			break;
+		}
+		else
+		{
+			*(t_arg->s) >> recv;
+			cout << recv << endl;
+		}
 	}
+	killThread(t_arg);
 }
  
 //! Método principal del cliente
@@ -80,71 +136,43 @@ void speedTest(Socket&amp; s)
 int main()
 {
 	signal(SIGPIPE, exitClient);
-	signal(SIGINT, exitClient);
 	Socket s;
 	connected = finished = false;
-	string send, recv;
+	pthread_mutex_t mutex;
+	pthread_mutex_init(&mutex,0);
+	pthread_cond_t condition;
+	pthread_cond_init(&condition,0);
+	thread_args *sArgs = new thread_args;
+	thread_args *rArgs = new thread_args;
+	pthread_t recv, send;
 	s.Create();
-	while (!exit)
+	while (!finished)
 	{
 		connect(s);
+		pthread_mutex_lock(&mutex);
+		sArgs->mutex = &mutex;
+		sArgs->condition = &condition;
+		sArgs->s = &s;
+
+		rArgs->mutex = &mutex;
+		rArgs->condition = &condition;
+		rArgs->s = &s;
+
+		pthread_create(&send,NULL,sendThread,(void *)sArgs);
+		pthread_create(&recv,NULL,recvThread,(void *)rArgs);
+
 		while(connected)
 		{
-			cout << "> ";
-			getline(cin,send);
-			if(cin.eof())
-			{
-				send = "/disconnect";
-			}
-			try
-			{
-				s << send;
-				if(send == "/disconnect")
-				{
-					s >> recv;
-					if(recv == "OK")
-					{
-						cout << "Disconnecting" << endl;
-						s.Close();
-		            	connected = false;
-					}
-				}
-				else if(send == "/exit")
-				{
-					s >> recv;
-					if(recv == "OK")
-					{
-						cout << "Exiting" << endl;
-						s.Close();
-						connected = false;
-						finished = true;
-					}
-				}
-				else if(send == "/test")
-				{
-					speedTest(s);
-				}
-				else
-				{
-					s >> recv;
-					cout << "Received: " << recv << endl;
-				}
-			}
-			catch(SocketException& e)
-			{
-				cout << e.description() << endl;
-				cout << "Exiting" << endl;
-				s.Close();
-	        	return -1;
-			}
+			pthread_cond_wait(&condition,&mutex);
 		}
+		pthread_mutex_unlock(&mutex);
 	}
+	pthread_cond_destroy(&condition);
+	pthread_mutex_destroy(&mutex);
 }
  
-/* TO-DO
+/* TODO
  *
- * spawn 2 IO threads
- * connect/disconnect commands
  * list nicks
  * unicast message
  */
 \ No newline at end of file
+#ifndef CLIENT_H_
+#define CLIENT_H_
+
+#include "Socket.h"
+#include <iostream>
+#include "SocketException.h"
+#include <sstream>
+#include <signal.h>
+#include <cstdlib>
+#include <sys/time.h>
+
+//!Argumentos de los threads
+/**
+\brief Este struct define los argumentos que recibe un thread abierto por la aplicación servidor al recibir una conexión entrante 
+\author Imanol Barba Sabariego
+\date 11/06/2013 */ 
+struct thread_args
+{
+    //! Variable de control de la exclusión mútua entre threads
+    /** Esta variable se usa para bloquear otros threads en operaciones de exclusion mútua donde se modifican variables compartidas */
+    pthread_mutex_t *mutex;
+    //! Variable de notificación a otros threads
+    /*! \brief Esta variable se usa para notificar a otros threads cuando deben realizar otras acciones. 
+
+    *Actualmente se usa para notificar al thread principal cuando el thread que lo invoca ha terminado, en caso de que el principal haya
+    quedado bloqueado y no admita más conexiones.* */
+    pthread_cond_t *condition;
+    //! Puntero al socket
+    /*! \brief Esta variable representa el puntero al socket que proviene de la conexión entrante recibida por el servidor. Con este, el thread 
+    puede recibir y enviar los datos. */
+    Socket *s;
+};
+
+
+
+#endif /* CLIENT_H_ */
 \ No newline at end of file
-/** @file 
-* \brief Header de la clase Server
-* \author Imanol Barba Sabariego
-* \date 11/06/2013
-*
-* En este fichero se define la clase Server y algunos métodos globales usados por ésta para la gestión de threads y otros aspectos.
-*/
-
-#ifndef SERVER_H_
-#define SERVER_H_
-
-#include "Socket.h"
-#include "SocketException.h"
-#include <iostream>
-#include <sstream>
-#include <signal.h>
-#include <fstream>
-#include <list>
-#include <fstream>
-
-//! Numero de conexiones permitidas activas (en espera o activas)
-/*! Esta constante controla cuantas conexiones puede haber en espera o cuantas puede haber establecias en cualquier momento: habrá N activas
-y N en espera como mucho, no N en espera o activas. */
-#define N 5
-//! Ruta al fichero de configuración
-/*! Ruta relativa o absoluta al fichero de configuración, de no existir o ser inválido el programa no funcionará. */
-#define CONFFILE "socket.conf"
-//! Nombre del socket del módulo de control
-/*! Nombre y ruta del socket UNIX del módulo de control */
-
-using namespace std;
-
-//! Clase de aplicación servidor
-/**
-Esta clase define un objeto con los métodos y atributos necesarios para lanzar una aplicación servidor y atender las conexiones. Para realizar
-la comunicación con el cliente, usa un objeto de la clase Socket
-*/
-class Server
-{
-        private:
-            //! Contador de threads
-            /*! Esta variable se encarga de mantener la cuenta de threads activos, por tanto, el número de conexiones que estan siendo antendidas
-            simultáneamente. */
-        	int nWorkers;
-            //! Variable de apagado
-            /*! Esta variable controla el apagado del servidor, al ponerla a true, la siguiente iteración del bucle que atiende las conexiones
-            no se producirá y el programa terminará. */
-            bool shutdownServer;
-            //! Contador de ID de thread
-            /*! Esta variable contiene el ID del próximo thread que se creará, por tanto, indica el número de conexiones que han sido atendidas desde
-            el inicio del servidor */
-            int workerID;
-            //! Pila de threads terminados
-            /*! Esta variable contiene una lista de threads que han finalizado su ejecución. A cada iteración del bucle que atiende conexiones,
-            se libera toda la memoria de los threads que hay almacenados aquí. */
-            list<pthread_t*> stoppedThreads;
-            //! Pila de threads empezados
-            /*! \brief Esta variable contiene una lista de threads que han empezado su ejecución. Si el programa finalizara prematuramente, se liberarían los punteros
-            de los threads almacenados en esta pila.
-
-            __NOTA: No se liberará la memoria asignada a los argumentos de los threads, dando lugar a memory leaks; sin embargo, esto se produciria al finalizar
-            el programa, por tanto no es relevante.__ */
-            list<pthread_t*> startedThreads;
-            //! Socket de comunicación
-            /*! Esta variable contiene el objeto de la clase Socket que la aplicación servidor usa para poder atender las peticiones. Su función
-            es quedarse escuchando el el puerto e IP introducidas en el fichero de configuración y crear un objeto de la clase Socket para cada
-            petición de cada cliente nuevo, siendo este último objeto creado el que se usa para la comuncación. */
-            Socket ss;
-
-        public:
-            //! Constructor de la clase Server
-            /*! Incializa los argumentos inciales del servidor */
-        	Server() : nWorkers(0), workerID(0), shutdownServer(false) {}
-            //! Getter del número de threads activos
-            /*! Devuelve el número de threads activos en ese instante, por tanto, del número de conexiones que están siendo atendidas. */
-            int getNWorkers();
-            //! Setter del número de threads activos
-            /*! Establece el número de threads activos, para poder cambiarlo cuando alguno de los threads activos finaliza */
-            void setNWorkers(int n /*!<Nuevo número de threads activos*/);
-            //! Getter de la pila de threads activos
-            /*! Devuelve un contenedor con la lista de threads que estan activos, para terminarlos en caso de que el programa finalice prematuramente */
-            list<pthread_t*>* getStartedThreads();
-            //! Getter de la pila de threads terminados
-            /*! Devuelve un contenedor con la lista de threads que han terminado, para poder liberar la memoria que se le ha asignado */
-            list<pthread_t*>* getStoppedThreads();
-            //! Método de inicialización del servidor
-            /*! Incializa el servidor en el puerto e IP especificados para empezar a recibir conexiones entrantes */
-            void startServer(string i /*!<IP donde se aceptan las conexiones */, int p/*!<Puerto donde se aceptan las conexiones*/);
-            //! Método para liberar memória de threads
-            /*! Este método se llama para que libere la memoria de todos los threads que se le proporcionan por argumento */
-            void freeRAM(list<pthread_t*> *threadList/*!<Contenedor con los threads a liberar */);
-            //! Método para terminar el servidor
-            /*! Este método inicia la secuencia de finalización del servidor */
-            void requestExit();
-};
-
-//!Argumentos de los threads
-/**
-\brief Este struct define los argumentos que recibe un thread abierto por la aplicación servidor al recibir una conexión entrante 
-\author Imanol Barba Sabariego
-\date 11/06/2013 */ 
-struct thread_args
-{
-    //! Variable de control de la exclusión mútua entre threads
-    /** Esta variable se usa para bloquear otros threads en operaciones de exclusion mútua donde se modifican variables compartidas */
-    pthread_mutex_t *mutex;
-    //! Variable de notificación a otros threads
-    /*! \brief Esta variable se usa para notificar a otros threads cuando deben realizar otras acciones. 
-
-    *Actualmente se usa para notificar al thread principal cuando el thread que lo invoca ha terminado, en caso de que el principal haya
-    quedado bloqueado y no admita más conexiones.* */
-    pthread_cond_t *condition;
-    //! Puntero al thread
-    /*! \brief Esta variable representa el puntero del propio thread. Al finalizar, este enviará su puntero a la lista de threads terminados,
-    donde la memoria asignada al thread se destruirá. */
-    pthread_t *thread;
-    //! Puntero al socket
-    /*! \brief Esta variable representa el puntero al socket que proviene de la conexión entrante recibida por el servidor. Con este, el thread 
-    puede recibir y enviar los datos. */
-    Socket *s;
-    //! Puntero al servidor
-    /*! \brief Esta variable representa el puntero al servidor de la aplicación. Con este puntero, los threads se mueven a la pila de threads 
-    terminados una vez terminan la ejecución para que el thread principal (el propio servidor), vaya liberando la memoria asignada. */
-    Server *serv;
-    //! ID del thread
-    /*! \brief Identifica al thread con un ID único */
-    int id;
-};
-
-//! Método de finalización de Threads
-/*! \brief Éste método se ejecuta para liberar la memoria de los argumentos del thread y mandarlo a la pila de threads terminados. */
-void killThread(thread_args *t_arg /*!<Puntero al struct que contiene los argumentos del thread */);
-//! Método gestión de conexiones
-/*! \brief Éste método es el que los threads ejecutan al crearse, aquí es donde se define el comportamiento del servidor, ya que cada conexión
-se gestionará como aquí se detalla.
-
-_Por defecto, el comportamiento que lleva programado es el de un servidor "echo", esperará que el cliente le envíe un mensaje y responderá con el 
-mismo mensaje._ */
-void *WorkerThread(void* args /*!< Puntero al struct de los argumentos del thread casteado a tipo void**/);
-//! Método auxiliar de procesado de texto
-/*! \brief Éste método usa para procesar las entradas de texto del fichero de configuración para adaptarlas a un formato adecuado.
-
-_De momento se limita a eliminar whitespace (tabulaciones, saltos de línea y espacios)._ */
-void processText(string *str/*!<Línea de texto a procesar*/);
-//! Método de lectura de configuración
-/*! \brief Éste método lee el fichero de configuración espeficado para obtener parámetros de configuración para el funcionamiento del servidor. */
-bool readConf(string *ip/*!Puntero donde se almacena la IP leída*/, int *port/*!<Puntero donde se almacena el puerto leído*/);
-
-#endif /* SERVER_H_ */
 package pad.prac2;
  
-public class Connection
+public class Connection extends Thread
 {
+	private MySocket socket;
+	private Server serv;
+	private boolean sleep, kill;
+	
+	public Connection(Server s)
+	{
+		serv = s;
+		kill = false;
+		sleep = true;
+	}
+	
+	public void sendMessage(String message)
+	{
+		socket.sendMsg(message);
+	}
+	
+	public void awake()
+	{
+		synchronized(this)
+		{
+			sleep = false;
+			this.notify();
+		}
+	}
+	
+	public void finish()
+	{
+		kill = true;
+		sleep = false;
+		socket.close();
+		this.notify();
+	}
+	
+	public void setSock(MySocket s)
+	{
+		socket = s;
+	}
+	
+	public void run()
+	{
+		while(!kill)
+		{
+			while(sleep)
+			{
+				try
+				{
+					synchronized(this)
+					{
+						wait();
+					}
+				} 
+				catch (InterruptedException e)
+				{
+					e.printStackTrace();
+				}
+			}
+			String str = socket.recvMsg();
+			serv.addToChatroom(this, str);
+			if(!kill)
+			{
+				while(true)
+				{
+					str = socket.recvMsg();
+					if(str != null)
+					{
+						if(str == "/disconnect")
+						{
+							socket.sendMsg("DISC_OK");
+							kill = true;
+							System.out.println(serv.getNickname(this) + " disconnected");
+						}
+						else if(str == "/exit")
+						{
+							socket.sendMsg("EXIT_OK");
+							kill = true;
+							System.out.println(serv.getNickname(this) + " disconnected");
+						}
+						else
+						{
+							System.out.println("FROM " + serv.getNickname(this) + ": " + str);
+							serv.sendToChat(this,str);
+						}
+					}
+					else
+					{
+						break;
+					}
+				}
+				sleep = true;
+			}
+			serv.finishWorker(this);
+		}
+	}
  
 }
@@ -6,23 +6,29 @@ public class JChat
 {
 	public static void main(String[] args)
 	{
+		
 		String ip;
 		int port, roomSize;
-		Scanner in = new Scanner(System.in);
+		/*Scanner in = new Scanner(System.in);
 		System.out.print("IP: ");
 		ip = in.nextLine();
 		System.out.print("Port: ");
 		port = in.nextInt();
 		System.out.print("Size of chatroom: ");
 		roomSize = in.nextInt();
-		in.close();
-		Server serv = new Server(ip,port,roomSize);
+		in.close();*/
+		ip = "localhost";
+		port = 3001;
+		roomSize = 3;
+		final Server serv = new Server(ip,port,roomSize);
+		Runtime.getRuntime().addShutdownHook(new Thread() 
+		{
+			public void run() 
+			{
+				System.out.println("JChat: interrupt catched, killing server...");
+	            serv.killServer();
+	        }
+		});
 		serv.startServer();
 	}
-	/*
-	 * TODO
-	 * 
-	 * capture SIGINT
-	 * 
-	 */
 }
@@ -16,7 +16,9 @@ public class MyServerSocket extends ServerSocket
 	{
 		try
 		{
-			MySocket incoming = (MySocket)super.accept();
+			MySocket incoming = new MySocket();
+			super.implAccept(incoming);
+			incoming.initializeStreams();
 			return incoming;
 		}
 		catch(IOException ioExc)
@@ -31,7 +33,7 @@ public class MyServerSocket extends ServerSocket
 		SocketAddress addr = new InetSocketAddress(ip,port);
 		try
 		{
-			super.bind(addr);
+			super.bind(addr, 5);
 		}
 		catch(IOException ioExc)
 		{
@@ -16,27 +16,32 @@ public class MySocket extends Socket
 	public MySocket()
 	{
 		super();
+	}
+	
+	public void connect(String host, int port)
+	{
+		SocketAddress addr = new InetSocketAddress(host,port);
 		try
 		{
-			output = new PrintWriter(super.getOutputStream());
-			input = new BufferedReader(new InputStreamReader(super.getInputStream()));
+			super.connect(addr);
+			initializeStreams();
 		}
 		catch(IOException ioExc)
 		{
-			System.out.println("TCP: Error initializing socket");
+			System.out.println("TCP: Error occured while connecting to remote host");
 		}
 	}
  
-	public void connect(String host, int port)
+	public void initializeStreams()
 	{
-		SocketAddress addr = new InetSocketAddress(host,port);
 		try
 		{
-			super.connect(addr);
+			output = new PrintWriter(super.getOutputStream());
+			input = new BufferedReader(new InputStreamReader(super.getInputStream()));
 		}
 		catch(IOException ioExc)
 		{
-			System.out.println("TCP: Error occured while connecting to remote host");
+			System.out.println("TCP: Error initializing socket");
 		}
 	}
  
@@ -54,6 +59,27 @@ public class MySocket extends Socket
 		}
 	}
  
+	public void sendMsg(String msg)
+	{
+		String length = new Integer(msg.length()).toString();
+		this.write(length+'\0', length.length()+1);
+		this.write(msg,msg.length());
+	}
+	
+	public String recvMsg()
+	{
+		String len,str;
+		int length;
+		len = this.readLine();
+		if(len == null)
+		{
+			return len;
+		}
+		length = Integer.parseInt(len);
+		str = this.read(length);
+		return str;
+	}
+	
 	public void write(String str, int bytes)
 	{
 		output.print(str.substring(0,bytes));
@@ -78,7 +104,18 @@ public class MySocket extends Socket
 	{
 		try
 		{
-			return input.readLine();
+			String line = "";
+			char[] c = new char[1];
+			while(true)
+			{
+				input.read(c,0,1);
+				if(c[0] == '\0')
+				{
+					break;
+				}
+				line += c[0];
+			}
+			return line;
 		}
 		catch(IOException ioExc)
 		{
 package pad.prac2;
  
-import java.io.BufferedReader;
 import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.PrintWriter;
-import java.util.Collection;
 import java.util.Iterator;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
  
 public class Server
 {
 	private MyServerSocket ss;
-	private BufferedReader stdin;
-	private PrintWriter stdout;
 	private int roomSize;
-	private boolean run;
-	
-	private Worker[] rWorkerPool;
-	private Worker[] wWorkerPool;
-	
-	private ConcurrentHashMap<String,MySocket> activeConnections;
+	private boolean kill;
+	private Connection[] workerPool;
+	private int freeWorkers;
+	private Lock lock;
+	private Condition availableWorkers;
+	private ConcurrentHashMap<Connection,String> activeConnections;
  
 	public Server(String ip, int port, int rS)
 	{
 		try
 		{
 			ss = new MyServerSocket();
-			stdout = new PrintWriter(System.out);
-			stdin = new BufferedReader(new InputStreamReader(System.in));
+			lock = new ReentrantLock();
+			activeConnections = new ConcurrentHashMap<Connection,String>();
 			roomSize = rS;
-			rWorkerPool = new Worker[roomSize];
-			wWorkerPool = new Worker[roomSize];
+			freeWorkers = roomSize;
+			kill = false;
+			availableWorkers = lock.newCondition();
+			workerPool = new Connection[roomSize];
+			for(int i = 0; i < roomSize; i++)
+			{
+				workerPool[i] = new Connection(this);
+				workerPool[i].start();
+			}
+			ss.bind(ip, port);
 		}
 		catch(IOException ioExc)
 		{
@@ -38,39 +44,96 @@ public class Server
 		}
 	}
  
-	public void startServer()
+	public void sendToChat(Connection origin, String message)
 	{
-		
+		lock.lock();
+		String nickname = activeConnections.get(origin);
+		Set<Connection> connections = activeConnections.keySet();
+		Iterator<Connection> it = connections.iterator();
+		Connection conn;
+		while(it.hasNext())
+		{
+			conn = it.next();
+			if(conn != origin)
+			{
+				conn.sendMessage(nickname + ": " + message);
+			}
+		}
+		lock.unlock();
 	}
  
-	public void startWorker(Worker r, Worker w, MySocket s)
+	public void startServer()
 	{
-		if(r == null)
+		while(!kill)
 		{
-			r = new Worker(s,null,stdout);
+			MySocket incoming = ss.accept();
+			if(incoming != null)
+			{
+				System.out.println("Accepted connection from " + incoming.getInetAddress());
+				
+				startWorker(incoming);
+			}
 		}
-		r.awake();
-		if(w == null)
+		
+	}
+	
+	public void startWorker(MySocket s)
+	{
+		lock.lock();
+		while(freeWorkers == 0)
 		{
-			w = new Worker(s,stdin,null);
+			try
+			{
+				lock.unlock();
+				availableWorkers.await();
+				lock.lock();
+			}
+			catch(InterruptedException intExc)
+			{
+				intExc.printStackTrace();
+			}
 		}
-		w.awake();
+		workerPool[roomSize - freeWorkers].setSock(s);
+		workerPool[roomSize - freeWorkers].awake();
+		workerPool[roomSize - freeWorkers] = null;
+		freeWorkers--;
+		lock.unlock();
+	}
+	
+	public String getNickname(Connection c)
+	{
+		return activeConnections.get(c);
+	}
+	
+	public void finishWorker(Connection c)
+	{
+		lock.lock();
+		freeWorkers++;
+		workerPool[roomSize - freeWorkers] = c;
+		availableWorkers.signal();
+		lock.unlock();
+	}
+	
+	public void addToChatroom(Connection c, String nickName)
+	{
+		activeConnections.put(c, nickName);
+		System.out.println(nickName + " has entered the room");
 	}
  
-	public void finishWorkers()
+	public void finishConnections()
 	{
-		Collection<Worker> worerke= activeConnections.values();
-		Iterator<MySocket> it = sockets.iterator();
+		Set<Connection> conns = activeConnections.keySet();
+		Iterator<Connection> it = conns.iterator();
 		while(it.hasNext())
 		{
-			it.next().close();
+			it.next().finish();
 		}
 	}
  
 	public void killServer()
 	{
-		run = false;
+		kill = true;
 		ss.close();
-		finishWorkers();
+		finishConnections();
 	}
 }
-package pad.prac2;
-
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.PrintWriter;
-
-public class Worker extends Thread
-{
-	private PrintWriter output;
-	private BufferedReader input;
-	private MySocket sock;
-	private boolean run;
-	private boolean kill;
-	private boolean sleep;
-	private Server serv;
-	
-	public Worker(Server srv, MySocket s, BufferedReader i, PrintWriter o)
-	{
-		sock = s;
-		output = o;
-		input = i;
-		run = false;
-		kill = false;
-		sleep = true;
-		serv = srv;
-	}
-	
-	public void finish()
-	{
-		kill = true;
-		run = false;
-		sleep = false;
-		sock.close();
-	}
-	
-	public void run()
-	{
-		while(!kill)
-		{
-			while(sleep)
-			{
-				try
-				{
-					wait();
-				} 
-				catch (InterruptedException e)
-				{
-					e.printStackTrace();
-				}
-			}
-			while(run)
-			{
-				if(output == null && input != null)
-				{
-					String str, length;
-					while(true)
-					{
-						try
-						{
-							str = input.readLine();
-							length = new Integer(str.length()).toString();
-							sock.write(length, length.length());
-							sock.write(str, str.length());
-						}
-						catch(IOException ioExc)
-						{
-							run = false;
-							sleep = true;
-							break;
-						}
-					}
-				}
-				else if(input == null && output != null)
-				{
-					String len, str;
-					while((len = sock.readLine()) != null)
-					{
-						int length = Integer.parseInt(len);
-						str = sock.read(length);
-						output.println(str);
-					}
-					run = false;
-					sleep = true;
-				}
-			}
-		}
-	}
-	
-	public void awake()
-	{
-		run = true;
-		sleep = false;
-		this.notify();
-	}
-}