# Port umleiten: lesen und schreiben für MCServer-Client über Skype



## CorperateRaider (28. Feb 2015)

Hey Leute ich würde gerne eine Art Portüberbrückung basteln: später soll sie mal MCServer über Skype kommunizieren lassen. Bis jetzt funktioniert es so, dass man schon vom Server mit der Portüberbrückung die MOTD und die Spieleranzahl, sowie welche Spieler online sind lesen kann, doch wenn ich mich versuche einzuloggen kommt, wenn ich schon auf dem Server stehe, bzw. manchmal auch deutlich schneller die Nachricht "Internal Exception: io.netty.handler.codec.DecoderException: java.io.IOException: Bad compressed data format" in Minecraft und "java.net.SocketException: Software caused connection abort: recv failed" in der Javakonsole.

Ich vermute es liegt am Datenabschickpunkt(PrintWriter.flush()) - wie bekomme ich den richtigen Zeitpunkt heraus bzw. was ist der Fehler?

mein Code - sorry, dass es die Tabulatoren aus Eclipse nicht genommen hat -.-:

```
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;



public class ECHO {
	@SuppressWarnings("resource")
	public static void main(String[] args) throws IOException, InterruptedException{
	
		////////////////////////////////////////////
		//			Server: spricht mit Client
		
		ExecutorService executor = Executors.newFixedThreadPool(16);
		
		ServerSocket server = new ServerSocket(5555);
		System.out.println("Server gestarted!");
		
		executor.execute(new Handler(server.accept(), server));		
		System.out.println("Client empfangen.");
		
		Thread takt = new Thread(new sendTakt());// die Klasse sendTakt versucht zu warten, bis eine Nachricht über den Port    gesendet wurde und sendet dann weiter
		takt.start();
		
		////////////////////////////////////////////
		//			Client: spricht mit Server
		
		Socket myClient = new Socket("localhost", 25565);
		
		toServer = new PrintWriter(myClient.getOutputStream());
		
		writeToServer(-1);// die bereits empfangenen Bits, die noch nicht gesendet werden konnten, weil der MCClient noch keine Verbindung hatte, werden gesendet...
		
		BufferedReader reader = new BufferedReader(new InputStreamReader(myClient.getInputStream()));
		
		Thread t = new Thread(new sendTakt());
		t.start();
		
		while(true){
			Thread.sleep(0,200);
			writeToClient(reader.read());
			if(server.isClosed()){
				System.exit(1);
			}
		}
	}
	
	static PrintWriter toServer, toClient;
	
	static ArrayList<Integer> toSendToServer = new ArrayList<Integer>();
	
	static void writeToClient(int s){
		if(s!=-1){
			toClient.write(s);
			lastC=System.nanoTime();
		}	
	}
	
	static long lastS,lastC;
	
	static void writeToServer(int s){
		if(toServer!=null){
			for(int i:toSendToServer){
				toServer.write(i);
			}
			toSendToServer = new ArrayList<Integer>();
			if(s!=-1){
				toServer.write(s);
				lastS=System.nanoTime();
			}
		}else if(s!=-1){
			toSendToServer.add(s);
		}
	}
}

class sendTakt implements Runnable{

	public sendTakt(){
		ECHO.lastC=ECHO.lastS=System.nanoTime()+1000000000;
	}
	
	@Override
	public void run() {
		while(true){
			if(System.nanoTime()>ECHO.lastS+1000){
				ECHO.toServer.flush();
				ECHO.lastS=System.nanoTime()+10000;
			}
			if(System.nanoTime()>ECHO.lastC+1000){
				ECHO.toClient.flush();
				ECHO.lastC=System.nanoTime()+10000;
			}
		}
	}
	
}

class Handler implements Runnable{

	Socket client;
	
	public Handler(Socket client, ServerSocket server) throws IOException{
		this.client=client;
	}

	@Override
	public void run() {
		try {
			ECHO.toClient = new PrintWriter(client.getOutputStream());
			BufferedReader reader = new BufferedReader(new InputStreamReader(client.getInputStream()));
			
			ECHO.writeToServer(-1);//wie oben
			while(true){
				if(!client.isConnected()){
					break;
				}
				Thread.sleep(0, 200);
				ECHO.writeToServer(reader.read());
			}
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
			System.exit(1);
		}
	}
}
```


----------

