Everything so far

Everything I've been working on locally

.classpath

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

.gitignore

@@ -1,3 +1,6 @@
+.settings/
+.metadata/
+bin/
 *.class
 
 # Mobile Tools for Java (J2ME)

.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>TankernnChat</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

client.properties

@@ -0,0 +1,5 @@
+#Configuration for chat client
+#Fri May 08 15:24:33 CEST 2015
+port=25566
+host=tankernn.eu
+username=noscoper2

server.properties

@@ -0,0 +1 @@
+port=25566

src/client/ChatClient.java

@@ -0,0 +1,75 @@
+package client;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Properties;
+import java.util.Scanner;
+
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JTextField;
+
+public class ChatClient {
+	static Properties prop = new Properties();
+	static File confFile = new File("client.properties");
+	
+	public static void main (String[] arg) {
+		try {
+			prop.load(new FileInputStream(confFile));
+		} catch (FileNotFoundException e) {
+			prop.setProperty("host", "tankernn.eu");
+			prop.setProperty("port", "25566");
+			prop.setProperty("username", "Username");
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		
+		JTextField hostBox = new JTextField(prop.getProperty("host"));
+		JTextField portBox = new JTextField(prop.getProperty("port"));
+		JTextField userBox = new JTextField(prop.getProperty("username"));
+		final JComponent[] inputs = new JComponent[] {
+				new JLabel("Host:"), hostBox,
+				new JLabel("Port:"), portBox,
+				new JLabel("Username:"), userBox
+		};
+		
+		String host, username, portString;
+		
+		JOptionPane.showMessageDialog(null, inputs, "Chat settings", JOptionPane.PLAIN_MESSAGE);
+		
+		host = hostBox.getText();
+		prop.setProperty("host", host);
+		username = userBox.getText();
+		prop.setProperty("username", username);
+		
+		portString = portBox.getText();
+		Scanner sc = new Scanner(portString);
+		int port = sc.nextInt();
+		sc.close();
+		prop.setProperty("port", portString);
+
+		writeConfFile();
+		
+		try {
+			System.out.println("Connecting to " + host + " on port number " + port);
+			new ChatWindow(host, port, username);
+		} catch (IOException ex1) {
+			ex1.printStackTrace();
+		}
+		
+	}
+	
+	static void writeConfFile() {
+		try {
+			if (!confFile.exists())
+				confFile.createNewFile();
+			prop.store(new FileOutputStream(confFile), "Configuration for chat client");
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+}

src/client/ChatWindow.java

@@ -0,0 +1,161 @@
+package client;
+
+import java.awt.BorderLayout;
+import java.awt.Dimension;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.File;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.PrintWriter;
+import java.net.Socket;
+import java.net.SocketException;
+
+import javax.swing.*;
+
+import common.Message;
+
+@SuppressWarnings("serial")
+public class ChatWindow extends JFrame implements ActionListener, Runnable{
+	Thread getMessages;
+	static File confFile = new File("client.properties");
+	
+	String adress;
+	int port;
+	String username;
+	
+	Socket so;
+	ObjectInputStream objIn;
+	static PrintWriter out;
+	
+	GridBagLayout g = new GridBagLayout();
+	GridBagConstraints con = new GridBagConstraints();
+	JPanel right = new JPanel();
+	JLabel lblUsersOnline = new JLabel("Users online:");
+	DefaultListModel<String> model = new DefaultListModel<String>();
+	JList<String> userList = new JList<String>(model);
+	JButton reconnect = new JButton("Reconnect");
+	
+	Console chat = new Console();
+	JScrollPane scroll = new JScrollPane(chat);
+	JTextField skriv = new JTextField();
+	
+	public ChatWindow(String adress, int port, String username) throws IOException {
+		this.adress = adress;
+		this.port = port;
+		this.username = username;
+		
+		connect(adress, port, username);
+		
+		userList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+		userList.setLayoutOrientation(JList.VERTICAL);
+		
+		right.setLayout(g);
+		
+		con.weighty = 1;
+		con.gridy = 0;
+		con.gridheight = 1;
+		g.setConstraints(lblUsersOnline, con);
+		right.add(lblUsersOnline);
+		
+		con.fill = GridBagConstraints.BOTH;
+		con.weighty = 20;
+		con.gridy = 1; con.gridx = 0;
+		g.setConstraints(userList, con);
+		right.add(userList);
+		
+		con.weighty = 1;
+		con.gridy = 21;
+		con.gridheight = 1;
+		g.setConstraints(reconnect, con);
+		right.add(reconnect);
+		
+		reconnect.addActionListener(this);
+		
+		setLayout(new BorderLayout());
+		add(chat, BorderLayout.NORTH); add(skriv, BorderLayout.SOUTH); add(right, BorderLayout.EAST);
+		
+		add(scroll);
+		scroll.setMinimumSize(new Dimension(100, 100));
+		scroll.setViewportView(chat);
+		scroll.setSize(500, 130);
+		
+		skriv.addActionListener(this);
+		chat.setSize(500, 450);
+		chat.setEditable(false);
+		
+		setSize(500, 500);
+		setVisible(true);
+		setTitle("Chat | Username: " + username);
+		setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
+	}
+	
+	public void getMessages() throws SocketException, IOException, ClassNotFoundException {
+		while(!getMessages.isInterrupted()) {
+			Object fromServer = objIn.readObject();
+			if (fromServer instanceof Message) {
+				Message mess = ((Message)fromServer);
+				chat.log(mess);
+				
+				model = new DefaultListModel<String>();
+				for (int i = 0; i < mess.usersOnline.length; i++)
+					model.addElement(mess.usersOnline[i]);
+				
+				userList.setModel(model);
+			} else if (fromServer instanceof String)
+				chat.log((String) fromServer);
+		}
+		throw new SocketException("Disconnected from host!");
+	}
+	
+	static void send(String text) {
+		out.println(text);
+	}
+	
+	void connect(String adress, int port, String username) throws IOException {
+		if (getMessages != null)
+			getMessages.interrupt();
+		
+		if (so != null) {
+			so.close();
+			objIn.close();
+			out.close();
+		}
+		
+		chat.log("Connecting to " + adress + " on port " + port + ".");
+		so =		new Socket(adress, port);
+		objIn =	new ObjectInputStream(so.getInputStream());
+		out =		new PrintWriter(so.getOutputStream(), true);
+		
+		send(username);
+		
+		getMessages = new Thread(this);
+		getMessages.start();
+	}
+	
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		if (e.getSource() == skriv) {
+			send(skriv.getText());
+			skriv.setText("");
+		}
+		else if (e.getSource() == reconnect) {
+			try {
+				connect(adress, port, username);
+			} catch (IOException e1) {
+				e1.printStackTrace();
+			}
+		}
+	}
+
+	@Override
+	public void run() {
+		try {
+			getMessages();
+		} catch (ClassNotFoundException | IOException e) {
+			chat.log(e.toString());
+		}
+	}
+}

src/client/Console.java

@@ -0,0 +1,44 @@
+package client;
+
+import java.awt.Color;
+
+import javax.swing.*;
+import javax.swing.text.*;
+
+import common.Message;
+
+@SuppressWarnings("serial")
+public class Console extends JTextPane implements Runnable {
+	
+	String str;
+	SimpleAttributeSet style;
+	
+	void log(String str) {
+		this.str = str;
+		style = new SimpleAttributeSet();
+		StyleConstants.setForeground(style, Color.RED);
+		StyleConstants.setBold(style, true);
+		
+		SwingUtilities.invokeLater(this);
+	}
+	
+	void log(Message mess) {
+		this.str = mess.toString();
+		this.style = mess.style;
+		
+		SwingUtilities.invokeLater(this);
+	}
+	
+	@Override
+	public void run() {
+		StyledDocument doc = this.getStyledDocument();
+		
+		try
+		{
+		    doc.insertString(doc.getLength(), str + "\n", style);
+		}
+		catch(Exception e) {
+			System.out.println(e);
+		}
+	}
+}

src/command/Ban.java

@@ -0,0 +1,38 @@
+package command;
+
+import server.Client;
+import server.Server;
+
+public class Ban extends Command {
+
+	@Override
+	public void execute(String[] args, Client caller) {
+		try {
+			Server.bannedIps.add(Server.getUserByName(args[0]).sock.getInetAddress().toString());
+			Server.getUserByName(args[0]).disconnect(false);
+		} catch (NullPointerException e) {
+			caller.send("No such user!");
+		}
+	}
+
+	@Override
+	public String setName() {
+		return "ban";
+	}
+
+	@Override
+	public String setPermission() {
+		return "server.ban";
+	}
+
+	@Override
+	public String writeDescription() {
+		return "Bans a user. (/ban <username>)";
+	}
+
+	@Override
+	public int setMinArgNumber() {
+		return 1;
+	}
+
+}

src/command/Channel.java

@@ -0,0 +1,46 @@
+package command;
+
+import common.Message;
+
+import server.Client;
+import server.Server;
+
+public class Channel extends Command {
+
+	@Override
+	public void execute(String[] args, Client caller) {
+		if (caller.equals(Server.OPClient)) {
+			caller.send(new Message("Client-only command."));
+			return;
+		}
+		
+		try {
+			Server.getChannelByName(args[0]).addUser(caller);
+		} catch (NullPointerException ex) {
+			caller.send(new Message("No such channel!"));
+			return;
+		}
+		caller.primaryChannel = Server.getChannelByName(args[0]);
+	}
+
+	@Override
+	public String setName() {
+		return "channel";
+	}
+
+	@Override
+	public String setPermission() {
+		return "noob.channel";
+	}
+
+	@Override
+	public String writeDescription() {
+		return "Sets specified channel as primary (/channel <channel>)";
+	}
+
+	@Override
+	public int setMinArgNumber() {
+		return 1;
+	}
+
+}

src/command/Command.java

@@ -0,0 +1,20 @@
+package command;
+
+import server.Client;
+
+public abstract class Command {
+	public String name, permission = "*";
+	public int argNumber;
+	
+	public Command () {
+		name = setName();
+		argNumber = setMinArgNumber();
+		permission = setPermission();
+	}
+
+	public abstract void execute (String[] args, Client caller);
+	public abstract String setName ();
+	public abstract String setPermission ();
+	public abstract String writeDescription ();
+	public abstract int setMinArgNumber ();
+}

src/command/Exit.java

@@ -0,0 +1,33 @@
+package command;
+
+import server.Client;
+
+public class Exit extends Command{
+
+	@Override
+	public void execute(String[] args, Client caller) {
+		caller.send("Shutting down server!");
+		System.exit(0);
+	}
+
+	@Override
+	public String setName() {
+		return "exit";
+	}
+
+	@Override
+	public int setMinArgNumber() {
+		return 0;
+	}
+
+	@Override
+	public String writeDescription() {
+		return "Exits the server.";
+	}
+
+	@Override
+	public String setPermission() {
+		return "server.exit";
+	}
+
+}

src/command/Help.java

@@ -0,0 +1,41 @@
+package command;
+
+import server.Client;
+import server.CommandHandler;
+
+public class Help extends Command {
+
+	@Override
+	public void execute(String[] args, Client caller) {
+		String help = "Help for all commands:" + "\n";
+		for (int i = 0; i < CommandHandler.commands.length; i++) {
+			help += CommandHandler.commands[i].name + ": ";
+			help += "\t";
+			help += CommandHandler.commands[i].writeDescription();
+			if (i + 1 < CommandHandler.commands.length)
+				help += "\n";
+		}
+		caller.send(help);
+	}
+
+	@Override
+	public String setName() {
+		return "help";
+	}
+
+	@Override
+	public int setMinArgNumber() {
+		return 0;
+	}
+
+	@Override
+	public String writeDescription() {
+		return "Writes the descriptions for all commands.";
+	}
+
+	@Override
+	public String setPermission() {
+		return "noob.help";
+	}
+
+}

src/command/Kick.java

@@ -0,0 +1,36 @@
+package command;
+
+import server.Client;
+import server.Server;
+
+public class Kick extends Command {
+
+	@Override
+	public void execute(String[] args, Client caller) {
+		try {
+			Server.getUserByName(args[0]).disconnect(false);
+		} catch (NullPointerException ex) {
+			caller.send("No user called " + args[0] + "!");
+		}
+	}
+
+	@Override
+	public String setName() {
+		return "kick";
+	}
+
+	@Override
+	public int setMinArgNumber() {
+		return 1;
+	}
+
+	@Override
+	public String writeDescription() {
+		return "Kicks a user. (/kick <username>)";
+	}
+
+	@Override
+	public String setPermission() {
+		return "server.kick";
+	}
+}

src/command/List.java

@@ -0,0 +1,33 @@
+package command;
+
+import server.Client;
+import server.Server;
+
+public class List extends Command {
+	
+	@Override
+	public void execute(String[] args, Client caller) {
+		caller.send("Users online are:" + Server.getUsersOnline());
+	}
+
+	@Override
+	public String setName() {
+		return "list";
+	}
+
+	@Override
+	public int setMinArgNumber() {
+		return 0;
+	}
+
+	@Override
+	public String writeDescription() {
+		return "Lists all users online.";
+	}
+
+	@Override
+	public String setPermission() {
+		return "noob.list";
+	}
+
+}

src/command/PrivateMessage.java

@@ -0,0 +1,48 @@
+package command;
+
+import common.Message;
+
+import server.Client;
+import server.Server;
+
+public class PrivateMessage extends Command {
+
+	@Override
+	public void execute(String[] args, Client caller) {
+		if (caller.equals(Server.getUserByName(args[0])))
+			return;
+		
+		String content = "";
+		for (int i = 1; i < args.length -1; i++) {
+			content += args[i] + " ";
+		}
+		Message mess = new Message("PM", caller.username, content);
+		try {
+			Client reciever = Server.getUserByName(args[0]);
+			reciever.send(mess); caller.send(mess);
+		} catch (Exception ex) {
+			caller.send("No such user!");
+		}
+	}
+
+	@Override
+	public String setName() {
+		return "pm";
+	}
+
+	@Override
+	public String setPermission() {
+		return "noob.pm";
+	}
+
+	@Override
+	public String writeDescription() {
+		return "Sends a private message to a user";
+	}
+
+	@Override
+	public int setMinArgNumber() {
+		return 2;
+	}
+
+}

src/common/Message.java

@@ -0,0 +1,58 @@
+package common;
+
+import java.awt.Color;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import javax.swing.text.SimpleAttributeSet;
+import javax.swing.text.StyleConstants;
+
+import server.Server;
+
+@SuppressWarnings("serial")
+public class Message implements java.io.Serializable {
+	public String content, channel, sender;
+	public SimpleAttributeSet style = new SimpleAttributeSet();
+	public String[] usersOnline;
+	
+	public Message(String channel, String send, String con) {
+		this.sender = send;
+		this.channel = channel;
+		this.content = con;
+		usersOnline = Server.getUsersOnline();
+		
+		if (channel.equals("PM")) {
+			StyleConstants.setForeground(style, Color.GRAY);
+		}
+	}
+	
+	public Message(String send, String con) {
+		this("Info", send, con);
+		StyleConstants.setForeground(style, Color.BLUE);
+	}
+	
+	public Message(String con) {
+		this("SERVER", con);
+	}
+	
+	public boolean validate() {
+		if (content.equals("") || content == null) {
+			return false;
+		}
+		return true;
+	}
+	
+	@Override
+	public String toString() {
+		DateFormat dateFormat = new SimpleDateFormat("[HH:mm:ss]");
+		Date time = new Date();
+		String timestamp = dateFormat.format(time);
+		
+		String messEntry;
+		
+		messEntry =  timestamp + "<" + channel + ">" + sender + ": " + content;
+		
+		return messEntry;
+	}
+}

src/server/Ban.java

@@ -0,0 +1,11 @@
+package server;
+
+public class Ban {
+	String ip, reason;
+	int duration;
+	public Ban (String ip, int duration, String reason) {
+		this.ip = ip;
+		this.duration = duration;
+		this.reason = reason;
+	}
+}

src/server/Channel.java

@@ -0,0 +1,66 @@
+package server;
+
+import common.Message;
+
+public class Channel {
+	Client[] users = new Client[Server.maxUsers];
+	
+	public String name;
+	
+	public Channel(String name) {
+		this.name = name;
+	}
+	
+	void broadcast(Client sender, String content) {
+		Message mess = new Message(name, sender.username, content);
+		 if (mess.validate()) {
+			for (int i = 0; i < users.length; i++){
+				if (!positionFree(i))
+					users[i].send(mess);
+			}
+			Server.OPClient.send(mess.toString());
+		}
+	}
+	 
+	boolean hasUser(Client user) {
+		for (int i = 0; i < users.length; i++)
+			if (!positionFree(i))
+				if (users[i].equals(user))
+					return true;
+		return false;
+	}
+	
+	public boolean addUser(Client user) {
+		if (hasUser(user))
+			return true;
+		
+		for (int i = 0; i < users.length; i++)
+			if (positionFree(i)) {
+				users[i] = user;
+				return true;
+			}
+		return false;
+	}
+	
+	public boolean removeUser(Client user) {
+		for (int i = 0; i < users.length; i++)
+			if (users[i].equals(user)) {
+				users[i] = null;
+				return true;
+			}
+		return false;
+	}
+	
+	public String getUsersInChannel() {
+		String usersInChannel = "";
+		for (int i = 0; i < users.length; i++)
+			if (!positionFree(i)) {
+				usersInChannel += users[i].username + "\n" ;
+			}
+		return usersInChannel;
+	}
+	
+	boolean positionFree(int pos) {
+		return users[pos] == null || !users[pos].isConnected();
+	}
+}

src/server/Client.java

@@ -0,0 +1,148 @@
+package server;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.ObjectOutputStream;
+import java.net.Socket;
+
+import javax.swing.Timer;
+
+import common.Message;
+
+public class Client implements Runnable, ActionListener {
+	Thread readuser;
+	
+	BufferedReader in;
+	ObjectOutputStream objOut;
+	
+	public String username;
+	public Socket sock;
+	
+	String[] permissions;
+	
+	int messLastPeriod = 0;
+	Timer timer = new Timer(3000, this);
+	
+	public Channel primaryChannel = Server.channels[0];
+	
+	public Client(Socket s) {
+		sock = s;
+		
+		try {
+			in = new BufferedReader(new InputStreamReader(sock.getInputStream()));
+			objOut = new ObjectOutputStream(sock.getOutputStream());
+			username = in.readLine();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		
+		if (!validateUser()) {
+			disconnect(false);
+			return;
+		}
+		
+		permissions = new String[] {"noob.*"};
+		
+		send(new Message("Welcome to the server! Enjoy your stay!"));
+		
+		readuser = new Thread(this, username);
+		readuser.start();
+		
+		timer.start();
+	}
+	
+	public Client() {}
+	
+	private boolean validateUser() {
+		if (username.contains(" ")){
+			send("No spaces in usernames please!");
+			return false;
+		}
+		
+		for (int i = 0; i < Server.clients.length; i++) {
+			if (!Server.positionFree(i))
+				if (Server.clients[i].username.equalsIgnoreCase(username)) {
+					send("Username already taken!");
+					return false;
+				}
+		}
+		
+		if (Server.bannedIps.contains(sock.getInetAddress().toString())) {
+			send("You are banned from this server!");
+			return false;
+		}
+		
+		return true;
+	}
+	
+	public void disconnect(boolean output) {
+		if (timer.isRunning())
+			timer.stop();
+		
+		if (readuser != null)
+			readuser.interrupt();
+		
+		try {
+			sock.close();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		if (output)
+			Server.broadcast(new Message(username + " has disconnected."));
+	}
+	
+	public void disconnect() {
+		disconnect(true);
+	}
+	
+	public boolean isConnected() {
+		return !sock.isClosed();
+	}
+	
+	boolean hasPermission(String commandPermission) {
+		for (int i = 0; i < permissions.length; i++) {
+			if (commandPermission.startsWith(permissions[i].replace(".*", ".")) || commandPermission.equalsIgnoreCase(permissions[i]) || permissions[i].equalsIgnoreCase("*"))
+				return true;
+		}
+		return false;
+	}
+
+	@Override
+	public void run() {
+		String lastMess;
+		try {
+			while (!readuser.isInterrupted() && ((lastMess = in.readLine()) != null)) {
+				if (lastMess.startsWith("/")) {
+					String[] commandarray = lastMess.substring(1).split(" ");
+					CommandHandler.executeCommand(commandarray, this);
+				} else {
+					messLastPeriod++;
+					if (messLastPeriod > 5) {
+						send("No spamming!");
+						disconnect(false);
+					} else
+						primaryChannel.broadcast(this, lastMess);
+				}
+			}
+			disconnect();
+		} catch (IOException e) {
+			disconnect();
+		}
+	}
+	
+	public void send(Object message) {
+		try {
+			objOut.writeObject(message);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		messLastPeriod = 0;
+	}
+}

src/server/CommandHandler.java

@@ -0,0 +1,46 @@
+package server;
+
+import command.*;
+
+public class CommandHandler {
+	
+	public static Command[] commands;
+	
+	public CommandHandler() {
+		commands = new Command[7];
+		commands[0] = new command.Kick();
+		commands[1] = new command.List();
+		commands[2] = new command.Exit();
+		commands[3] = new command.Help();
+		commands[4] = new command.PrivateMessage();
+		commands[5] = new command.Channel();
+		commands[6] = new command.Ban();
+	}
+	
+	public static void executeCommand(String[] command, Client caller) {
+		for (int i = 0; i < commands.length; i++) { //Go through all commands
+			if ((commands[i].name).equals(command[0])) { //Look for command with correct name
+				if (caller.hasPermission(commands[i].permission)) //Check if the client has permission
+					if (command.length -1 >= commands[i].argNumber) { //Check the number of arguments
+						commands[i].execute(removeFirst(command), caller); //Execute command
+						return;
+					} else {
+						caller.send("More arguments required!");
+						return;
+					}
+				else {
+					caller.send("Not enough permissions!");
+					return;
+				}
+			}
+		}
+		caller.send("No such command!");
+	}
+	
+	private static String[] removeFirst(String[] command) {
+		for (int i = 0; i < command.length -1; i++) {
+			command[i] = command[i +1];
+		}
+		return command;
+	}
+}

src/server/LocalClient.java

@@ -0,0 +1,22 @@
+package server;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+public class LocalClient extends Client {
+	
+	public LocalClient() { //Constructor for local client, the server, with full permissions
+		in = new BufferedReader(new InputStreamReader(System.in));
+		
+		username = "SERVER";
+		permissions = new String[] {"*"};
+		
+		readuser = new Thread(this, username);
+		readuser.start();
+	}
+	
+	@Override
+	public void send(Object message) {
+		System.out.println(message);
+	}
+}

src/server/Pong.java

@@ -0,0 +1,25 @@
+package server;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.Timer;
+
+public class Pong implements ActionListener {
+	
+	Timer tim = new Timer(100, this);
+	
+	Client player1; Client player2;
+	
+	public Pong (Client p1, Client p2) {
+		player1 = p1;
+		player2 = p2;
+		
+		// TODO Initialize game here
+	}
+
+	@Override
+	public void actionPerformed(ActionEvent arg0) {
+		// TODO Update game logic here
+	}
+}

src/server/Server.java

@@ -0,0 +1,146 @@
+package server;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.util.ArrayList;
+import java.util.Properties;
+import java.util.Scanner;
+
+import common.Message;
+import server.CommandHandler;
+import server.Channel;
+
+public class Server {
+	
+	static Properties prop = new Properties();
+	static int port, maxUsers = 20, maxChannels = 10;
+	static final String version = "0.2";
+	
+	public static ArrayList<String> bannedIps = new ArrayList<String>();
+	public static Channel[] channels = new Channel[maxChannels];
+	public static Client[] clients = new Client[maxUsers];
+	
+	static ServerSocket so;
+	public static LocalClient OPClient;
+	
+	public static void main(String[] arg){
+		System.out.println("Starting ChatServer version " + version + "...");
+		
+		System.out.println("Loadning properties file!");
+		try {
+			prop.load(new FileInputStream("server.properties"));
+		} catch (FileNotFoundException ex1) {
+			try {
+				new File("server.properties").createNewFile();
+				prop.setProperty("port", "25566");
+				prop.store(new FileWriter("server.properties"), "ChatServer config file");
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			
+		} catch (IOException e) {
+			System.out.println("Could not load properties!");
+			e.printStackTrace();
+		}
+		System.out.println("Reading portnumber from properties!");
+		Scanner sc = new Scanner(prop.getProperty("port"));
+		port = sc.nextInt();
+		sc.close();
+		
+		System.out.println("Setting up socket!");
+		try {
+			so = new ServerSocket(port);
+		} catch(IOException ex) {
+			System.out.println("Error setting up socket! Server already running?");
+			System.exit(0);
+		}
+		
+		System.out.println("Starting main channel!");
+		channels[0] = new Channel("Main");
+		
+		System.out.println("Starting commandhandler!");
+		new CommandHandler();
+		
+		System.out.println("Creating virtual local client!");
+		OPClient = new LocalClient();
+		
+		System.out.println("Server started successfully!");
+		
+		getClients();
+	}
+	
+	static void getNewClient() throws IOException {
+		Client newClient = new Client(Server.so.accept());
+		for (int i = 0; i < clients.length; i++)
+			if (positionFree(i)) {
+				clients[i] = newClient;
+				channels[0].addUser(newClient);
+				Server.broadcast(new Message(clients[i].username + " has connected."));
+				return;
+			}
+	}
+
+	static void getClients() {
+		while(true) {
+			try {
+				getNewClient();
+			} catch (Exception ex) {
+				System.out.println("Could not get new client!");
+				ex.printStackTrace();
+			}
+		}
+	}
+	
+	public static Client getUserByName(String name) throws NullPointerException {
+		for (int i = 0; i < clients.length; i++) {
+			if (!positionFree(i))
+				if (clients[i].username.equals(name))
+					return clients[i];
+		}
+		throw new NullPointerException();
+	}
+	
+	public static Channel getChannelByName(String name) {
+		for (int i = 0; i < channels.length; i++) {
+			if (channels[i] != null)
+				if (channels[i].name.equals(name)) {
+					return channels[i];
+				}
+		}
+		return null;
+	}
+	
+	static boolean positionFree(int pos) {
+		return clients[pos] == null || !clients[pos].isConnected();
+	}
+
+	public static void broadcast(Message mess) {
+		for (int i = 0; i < clients.length; i++)
+			if (!positionFree(i))
+				clients[i].send(mess);
+		OPClient.send(mess.toString());
+	}
+	
+	public static void broadcast(Object mess) {
+		for (int i = 0; i < clients.length; i++)
+			if (!positionFree(i))
+				clients[i].send(mess);
+	}
+
+	public static String[] getUsersOnline() {
+		ArrayList<String> usersOnline = new ArrayList<String>();
+		for (int i = 0; i < clients.length; i++)
+			if (!Server.positionFree(i)) {
+				usersOnline.add(clients[i].username);
+			}
+		String[] usersOnlineStr = new String[usersOnline.size()];
+		for (int i = 0; i < usersOnline.size(); i++)
+			usersOnlineStr[i] = usersOnline.get(i);
+		return usersOnlineStr;
+	
+	}
+}

src/server/exceptions/ChannelFullException.java

@@ -0,0 +1,17 @@
+package server.exceptions;
+
+public class ChannelFullException extends Exception {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 3596284335004083523L;
+	
+	public ChannelFullException (String message) {
+		super(message);
+	}
+
+	public ChannelFullException() {
+		super();
+	}
+}