Klassen Funktionen aus anderen Klassen benutzen

[merasil]

Hallo ihr
ich bin gerade an der Umsetzung einer Client/Server Kommunikation mit Sockets und dabei auf ein Problem gestoßen, welches eher allgemeiner Natur ist.
Ich habe mir die StreamInput und Output Methoden in ne eigene Klasse mit eigener Methode gepackt um nicht ständig einen kompletten Block von diesen Anweisungen schreiben zu müssen.
Seit dem klappt aber irgendwie nichts mehr richtig und ich komme einfach nicht drauf warum
Aus irgendeinen Grund macht der Server erst was mit dem eingehenden Stream nachdem ich die Programmausführung des Clients abgebrochen habe. Das Senden von Client zu Server scheint zu funktionieren... Zumindest sagt das eine erste Wireshark-Analyse.
Hier der Code für den Server:

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;


public class Server {
    private static boolean listening;
    private static boolean dhke;
    private static int key;
    private static int p = 17;
    private static int g = 2;
    private static int secret = 7;
   
    public static String functions(String s) {
        String[] cmd = s.split(" ");
       
        switch(cmd[0]) {
            case "UPPERCASE":
                return "OK "+cmd[1].toUpperCase();
            case "LOWERCASE":
                return "OK "+cmd[1].toLowerCase();
            case "SPIEGELN":
                char[] reverse = cmd[1].toCharArray();
                String reversed = "";
                for(int i = reverse.length-1; i > -1; i--) {
                    reversed += reverse[i];
                }
                return "OK "+reversed;
            case "DHKE":
                dhke = true;
                return "Bitte Geheimnis eingeben:";
            case "BYE":
                return "BYE";
            case "SHUTDOWN":
                if(cmd[1].equals("xyz1234")) {
                   listening = false;
                    return "BYE";
                }
                return "WRONG PASSWORD!";
            default:
                return "UNGÜLTIGER BEFEHL";
        }
    }
   
    public static void main(String[] args) throws IOException{
        ServerSocket ss = new ServerSocket(1234);
        String inp;
        String answer;
       
        listening = true;
       
        while(listening) {
            try (Socket s = ss.accept()) {
                inp = COC.readStream(s);
                System.out.println("Stream gelesen");
                answer = functions(inp);
                System.out.println("Funktion ausgeführt");
                COC.writeStream(s, answer);
                if (dhke == true) {
                    COC.writeStream(s, "Primzahl:");
                    COC.writeStream(s, String.valueOf(p));
                    COC.writeStream(s, "Generator:");
                    COC.writeStream(s, String.valueOf(g));
                    inp = COC.readStream(s);
                   
                    key = DHKE.KeyCalc(secret, Integer.parseInt(inp), p);
                    int pubKey = DHKE.PubKeyCalc(secret, g, p);
                   
                    answer = String.valueOf(pubKey);
                    COC.writeStream(s, answer);
                }
            s.close();
            }
        }
    }
}

Code vom Client:

import java.io.*;
import java.net.Socket;
import java.util.Scanner;

public class Client {
    private static int key;
    private static int secret;
    private static int p;
    private static int g;
   
    public static void main(String[] args) throws IOException {
        boolean writing = true;
        String inp;
        String answer;
        String cmd;
       
        while(writing) {
            System.out.println("Bitte Command eingeben:");
            Scanner sc = new Scanner(System.in);
            cmd = sc.nextLine();
           
            try (Socket s = new Socket("127.0.0.1", 1234)) {
                COC.writeStream(s, cmd);
                inp = COC.readStream(s);
                System.out.println(inp);
               
                if(inp.equals("Bitte Geheimnis eingeben:")) {
                    System.out.print(COC.readStream(s));
                    p = Integer.parseInt(COC.readStream(s));
                    System.out.println(p);
                    System.out.print(COC.readStream(s));
                    g = Integer.parseInt(COC.readStream(s));
                    System.out.println(g);
                   
                    int pubKey = DHKE.PubKeyCalc(secret, g, p);
                    answer = String.valueOf(pubKey);
                   
                    COC.writeStream(s, answer);
                    inp = COC.readStream(s);
                   
                    key = DHKE.KeyCalc(secret, Integer.parseInt(inp), p);
                    System.out.println(key);
                }  
               
                if (inp.equals("BYE")) {
                    writing = false;
                }
                //COC.connClose(s);
                s.close();
            }
        }
    }
}

Hier der Code der COC

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;

public class COC {   
    public static void connClose(Socket s) throws IOException {
        s.close();
    }
   
    public static String readStream(Socket s) throws IOException {
        InputStream rein = s.getInputStream();
        BufferedReader buff = new BufferedReader(new InputStreamReader(rein));
       
        String answer = buff.readLine();
        System.out.println("gelesen");
        return answer;
    }
   
    public static void writeStream(Socket s, String answer) throws IOException {
        OutputStream raus = s.getOutputStream();
        PrintStream ps = new PrintStream(raus, true);
       
        ps.print(answer);
        System.out.println("geschrieben");
    }
}

 

[horst43]

Du öffnest jedes Mal einen neuen Socket, wiederverwende den alten. Das while im Client ist überflüssig.

 

[merasil]

Du öffnest jedes Mal einen neuen Socket, wiederverwende den alten. Das while im Client ist überflüssig.

Das while beim client brauch ich wenn ich mehrere Commands rübersenden will. Aber du hast recht, man könnte es zumindest weiter nach unten im Code verschieben, dass kein neuer Socket aufgemacht wird bis ich fertig bin im Client...
Aber beim Server mache ich doch nur einen neuen Socket auf wenn sich jemand verbindet oder? Ich übergebe ja an COC.writeStream bzw. COC.readStream den Socket s, welchen ich vorher erstellt habe... Oder sehe ich das ganz falsch?

 

[merasil]

NVM... Hab den Fehler. In der COC.writeStream hab ich statt println nur print