Banana-Coding.com - Java Knuddels Emulator

Quellcode

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package mhclient;

import java.applet.Applet;
import java.applet.AppletContext;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ConnectException;
import java.net.NoRouteToHostException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 *
 * @author Marc
 */
class ChatApplet extends Applet implements Runnable{
	private static ChatApplet instance;
	
	static {
		instance	= new ChatApplet();
	}
	private String server_host;
	private int server_port;
	private AppletContext applet_context;
	private String applet_location;
	private String java_version;
	private String java_software;
	private Socket server_socket;
	private InputStream server_socket_input;
	private OutputStream server_socket_output;
	private final String client_version = "V0.1aaa";
	private boolean server_connected;
	
	public ChatApplet() {
		this("", 0);
	}
	
	public ChatApplet(String server_host, int server_port) {
		this.server_host		= server_host;
		this.server_port		= server_port;
	}
    	
    	protected void initApplet() {
		System.out.println("BananaClient "+this.client_version);
		
		this.applet_context		= getAppletContext();
		this.applet_location	= getDocumentBase().toString();
		this.java_version		= System.getProperty("java.version");
		this.java_software		= System.getProperty("java.vm.vendor").toLowerCase();
		
		try {
			this.server_port	= 2710;
		} catch (Exception localException10) {
			System.err.println("ERROR: No port!");
		}
		
		if(this.server_host == null) {
			this.server_host	= "127.0.0.1";
		}
	}
    	
    	protected void startApplet() {
		try {
                    	
			this.server_socket		= new Socket("localhost", 2710);
			this.server_socket_input	= this.server_socket.getInputStream();
			this.server_socket_output	= this.server_socket.getOutputStream();
			this.server_connected		= true;
                    	System.err.println(this.server_socket.toString());
		} catch(NoRouteToHostException error_firewall) {
			this.server_connected		= false;
			System.out.println("Server nicht erreichbar. (Firewall)" + error_firewall);
		} catch(ConnectException error_maintenance) {
			this.server_connected		= false;
			System.out.println("Server wird zur Zeit gewartet.  \nNeuer Versuch in " + error_maintenance);
		} catch (UnknownHostException error_host) {
			this.server_connected		= false;
			System.out.println("Server nicht erreichbar. (Host not Found)" + error_host);
		} catch (IOException error_io) {
			this.server_connected		= false;
			System.out.println("Verbindungsfehler. (IO)" + error_io);
		}
		
		if((java_version == null) || (java_version.length() == 0)) {
			java_version = "unknown";
		}
		
		if(this.server_connected) {
			new Thread(instance).start();
			this.firstshake(PacketCreator.startConnection());
			send(PacketCreator.setHandshake(this.client_version));
		}
	}
	
	public static ChatApplet get() {
		return instance;
	}
	
	@Override
	public void run() {
    	while(true){
        	try{
            	InputStream test = server_socket_input;
           	
            	byte[] buffer		= Protocol.decode(server_socket_input);
				String packet		= new String(buffer);
				String[] tokens		= packet.split("\0");
				String opcode		= tokens[0];
                            	System.err.println(packet);
				System.err.println("[ >>> ] " + packet.replace("\0", "\\0"));
        	}catch(Exception e){
            	if(e.getMessage() != "InputStream is null!"){
                	System.out.println(e.getMessage());
            	}
        	}
    	}
	}

	private void firstshake(String message) {
    	if(this.server_socket != null && server_socket.isConnected()) {
			try {
				this.server_socket_output.write(message.getBytes("UTF8"));
				System.err.println("[ >>> ] " + message.replace("\0", "\\0"));
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	private void send(String message) {
    	if(this.server_socket != null && server_socket.isConnected()) {
			try {
				this.server_socket_output.write(Protocol.encode(message.getBytes("UTF8")));
				System.err.println("[ >>> ] " + message.replace("\0", "\\0"));
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	
}

Quellcode

package global;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import tools.database.ConnectionPool;
import tools.database.PoolConnection;

/**
 *
 * @author Flav
 */
public class Server {
	private final static Server instance;
	private final Map<String, Client> clients;
	private Client butler;


	static {
    	instance = new Server();
	}

	public Server() {
    	clients = new HashMap<String, Client>();
    	butler = new Client(null);

	}

	public static Server get() {
    	return instance;
	}

	public Client getButler() {
    	return butler;
	}

	public Client getClient(String name) {
    	synchronized (clients) {
        	return clients.get(name.toLowerCase());
    	}
	}

	public Collection<Client> getClients() {
    	synchronized (clients) {
        	return clients.values();
    	}
	}



	public void removeClient(String name) {
    	synchronized (clients) {
        	clients.remove(name.toLowerCase());
    	}
	}




	private void loadConfigs() {
    	PoolConnection pcon = ConnectionPool.getConnection();
    	Statement stmt = null;

    	try {
        	Connection con = pcon.connect();
        	stmt = con.createStatement();
        	System.out.println("Loading butler");
        	ResultSet rs = stmt.executeQuery("SELECT `name` FROM `accounts` ORDER BY `id` LIMIT 1");
        	rs.next();
        	//butler.login(rs.getString("name"));
        	rs.close();
        	System.out.println("Loading channel styles");
        	rs = stmt.executeQuery("SELECT * FROM `channelstyles`");
       	// Map<Integer, ChannelStyle> channelStyles = new HashMap<Integer, ChannelStyle>();

        	while (rs.next()) {
            	//channelStyles.put(rs.getInt("id"), new ChannelStyle(rs));
        	}

        	rs.close();
        	System.out.println("Loading channels");
        	rs = stmt.executeQuery("SELECT * FROM `channels`");

        	while (rs.next()) {
            	//Channel channel = new Channel(rs, channelStyles.get(rs.getInt("style")));
            	//butler.joinChannel(channel);
            	//channel.addClient(butler);
            	//channels.put(rs.getString("name").toLowerCase(), channel);
        	}

        	rs.close();
        	System.out.println("Loading smileys");
        	rs = stmt.executeQuery("SELECT `code`, `replacement` FROM `smileys`");

        	while (rs.next()) {
            	//smileys.put(rs.getString("code"), rs.getString("replacement"));
        	}
    	} catch (SQLException e) {
        	e.printStackTrace();
    	} finally {
        	if (stmt != null) {
            	try {
                	stmt.close();
            	} catch (SQLException e) {
            	}
        	}

        	pcon.close();
    	}
	}

	private void listen(int port) {
    	try {
        	ServerSocket listener = new ServerSocket(port);
        	System.out.println(String.format("Listening on port %s", port));

        	while (true) {
            	Socket socket = listener.accept();
            	clients.put(null, butler);
            	new SessionHandler(socket).start();
        	}
    	} catch (IOException e) {
        	e.printStackTrace();
    	}
	}

	public static void main(String[] args) {
    	int port;
    	if (args.length > 0) {
        	port = Integer.parseInt(args[0]);
    	} else {
        	port = 2710; // default
    	}

    	instance.loadConfigs();
    	instance.listen(port);
    	
	}
}

Quellcode

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package global;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

/**
 *
 * @author Marc
 */
public class Client {
	private final List<Channel> channels;
	private final Socket socket;
	private OutputStream out;
	private String butler = "Chuck";
	private String appletVersion;


	public Client(Socket socket) {
    	channels = new ArrayList<Channel>();
    	if(socket!=null){
    	System.out.println(socket.toString());
    	}
    	this.socket = socket;

    	if (socket == null) {
        	return;
    	}

    	try {
        	out = socket.getOutputStream();
    	} catch (IOException e) {
    	}
	}

	public String getName() {
    	return butler;
	}

	public void send(String message) {
    	if (socket != null && socket.isConnected()) {
        	try {
            	out.write(Protocol.encode(message.getBytes("UTF8")));
            	System.err.println("[ >>> ] "+ message.replace("\0", "\\0"));
            	System.out.println("Send to:"+ this.socket.toString());
        	} catch (IOException e) {
            	e.printStackTrace();
        	}
    	}
	}

	void setAppletVersion(String version) {
    	this.appletVersion = version;
	}
	
}