# socket exception + timing probleme



## duddel123 (29. Nov 2004)

hi leute,

meine serverclient applikation kann daten von a nach b schaufeln!
der server schickt "send" zum client der darauf hin ein jpg file ausliest und zum server schickt, danach, möchte ich aber das der client wieder aif ein command reagieren kann! Es funktioniert auch, allerdings wirft mir die Konsole trotzdem noch immer eine 
	
	
	
	





```
java.net.ConnectException: Connection refused: connect
```
 Exception aus.
Wie gesagt der Datentransport als solches funktioniert aber trotzdem!
ich vermute ein Timing Problem, aber ich komm leider nicht drauf was das noch sein könnte:

hier der Server!

```
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;


/*
 * Created on 27.08.2004
 *
 */

/**
 * 

 * 
 * @author 	
 * @version 1.0
 */

public class TCPThreadServer extends Thread {

		// Bereit halten der Variablen.
	private int Port;
	private String IP=null;
	private String ZielDatei=null; 
	private Socket client=null;
	private BufferedReader clientIn=null;
	private PrintWriter clientOut=null;
	private String cRemoteClient=null;
	private BufferedInputStream incoming=null;
	private File targetFile=null;
	private FileOutputStream out=null;
	private BufferedReader userIn=null;
	private Object command=null;
	private Object response=null;
	private ServerSocket servSock=null;
	
	
	/**
	 * 1ter Konstruktor von TCPThreadServer. Ihm wird eine Referenz von dem Socket 
	 * des verbundenen Clients übergeben.
	 */
	public TCPThreadServer() {
		


		try { 
          	
           	Port=12345;

			servSock = new ServerSocket(Port);        
		
			System.out.println("Warte auf Verbindung...");      
		                   

		    while(true) {                             

				Socket client = servSock.accept();

				new TCPThreadServer(client, servSock).start();
		    }  			
  		}
			// Fange Exception auf.
 		catch(IOException err) { 
  			err.printStackTrace();
  		}
		
	
 	}
	
	
	/**
	 * 2ter Konstruktor von TCPThreadServer. Er wird instanziert, indem der
	 * 1te Konstruktor ihm bei einer akzeptierten Client Verbindung ein SocketObjekt
	 * uebergibt.
	 */	
	public TCPThreadServer(Socket client, ServerSocket servSock) {
		try {
			this.client= client;
			this.servSock=servSock;
			
			System.out.println("Client verbunden von " + client.getInetAddress());   
			
			clientIn = new BufferedReader( new InputStreamReader(client.getInputStream()));
			
			clientOut = new PrintWriter(client.getOutputStream(),true);

		  	userIn=new BufferedReader(new InputStreamReader(System.in));			
			
		}
			// Fange Exception auf.
		catch(Exception err) {
			err.printStackTrace();
	    } 
 	}//Konstruktor
 	
 	/**
 	 * "run" wird aufgerufen, wenn der Thread gestartet wird. Hier findet 
 	 * die gesamte Abhandlung des Clients statt.
 	 * 
 	 * Lege ein InputStream auf die Client Verbindung und erstelle danach
 	 * ein targetFile vom Typ File. Oeffne ausserdem ein FileOutputStream um
 	 * die eingehenden Daten des Client in die ZielDatei zuschreiben.
 	 * Nachdem 
 	 */
	public void run() {
 		try {

		   		System.out.print("Eingabe: ");
		   		command=userIn.readLine();
  				System.out.println("das wurde an client gesendet: " +command);
   				clientOut.println(command);
   				clientOut.flush();

	   			receiveFile(incoming, out);   				
		}
 		

        catch(Exception e) {
        	System.out.println("Fehler in der TCPThreadServer run():");
        	e.printStackTrace();
        }


	}// run


	/**
	 * @throws IOException
	 * 
	 */
	private void receiveFile(BufferedInputStream incoming,FileOutputStream out) throws IOException {

		
		ZielDatei="c:/angekommen.JPG";

		incoming = new BufferedInputStream(client.getInputStream());
    	targetFile = new File(ZielDatei);
    	out = new FileOutputStream(targetFile);
    	
        long read = (long)incoming.read();
        while(read!=-1) {
        	out.write((int) read);
        	read = (long)incoming.read();
        }
        

        out.close();
        client.close();
        servSock.close();

        System.out.println("receive durchlaufen");
		
	}

}
```

hier der Client

```
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

/*
 * Created on 27.08.2004
 *
 */

/**

 * 
 * @author 
 * @version 1.0
 */

public class TCPClient extends Thread{

		// Bereit halten der Variablen
	private int Port;
	private String IP=null;
	private String QuellDatei=null;
	
		// Socket Variable bereit halten
    public static Socket serverconnection = null;
	private BufferedOutputStream outgoing=null;
	private FileInputStream fis=null;
	private BufferedReader serverIn=null;
	private PrintWriter serverOut=null;
	private Object command=null;
	private File sourceFile=null;
	private BufferedReader userIn=null;
	private String abc=null;
   
   
		// Konstruktor	   
    TCPClient(){
 		

      	IP="192.168.0.3";
      	

         Port=12345;
 
         userIn=new BufferedReader(new InputStreamReader(System.in));

           
           	try {
			 serverconnection = new Socket(InetAddress.getByName(IP),Port);
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
     	
 		new TCPClient(serverconnection).start();
          
    }//Konstruktor
  


    /**
	 * @param serverconnection
	 */
	public TCPClient(Socket serverconnection) {

		this.serverconnection=serverconnection;
		
 		try {
			serverIn = new BufferedReader( new InputStreamReader(serverconnection.getInputStream()));
		} catch (IOException e) {
			e.printStackTrace();
		}
 		try {
			serverOut = new PrintWriter(new PrintWriter(serverconnection.getOutputStream()));
		} catch (IOException e1) {
			e1.printStackTrace();
		}
		sourceFile = new File("c:/1.JPG");

	}

	public void run() {
    	
    	
    	
    	
   	System.out.println("Client wartet auf command...");
    	try {
			command=serverIn.readLine();
		} catch (IOException e) {
			e.printStackTrace();
		}
    

     	if (command.equals("send")){
     		System.out.println("habe send erhalten");     		
   		
     		try {
				sendFile();
			} catch (IOException e1) {
				e1.printStackTrace();
			}        		

     	}

   	
     	
     	
           try {
               serverconnection.close();
               System.out.println(" Die Verbindung zum Server wurde wieder geschlossen ");
             }
             catch(IOException e) {
                System.err.println(e);
                e.printStackTrace();
            }

     	

     	new TCPClient();
    	
    }// run
    
   
    
	/**
	 * @throws IOException
	 * 
	 */
	private void sendFile() throws IOException {
    	
      fis=new FileInputStream(sourceFile);
      outgoing = new BufferedOutputStream(serverconnection.getOutputStream());

      long read = (long) fis.read();
         	while (read!=-1) {
				outgoing.write((int) read);
				read = (long) fis.read();
         	}


         
       outgoing.close();
       System.out.println("send durchlaufen");
	}//sendFile

}
```

dank im voraus...


----------



## DTR (29. Nov 2004)

Hallo,



			
				duddel123 hat gesagt.:
			
		

> ```
> /**
> * @throws IOException
> *
> ...


----------



## duddel123 (30. Nov 2004)

hey vielen dank für die präzise Fehleranalyse, daran lag es!

Ausserdem muss noch aus der ()
	
	
	
	





```
/** 
    * @throws IOException 
    * 
    */ 
   private void receiveFile(BufferedInputStream incoming,FileOutputStream out) throws IOException { 

       
      ZielDatei="c:/angekommen.JPG"; 

      incoming = new BufferedInputStream(client.getInputStream()); 
       targetFile = new File(ZielDatei); 
       out = new FileOutputStream(targetFile); 
        
        long read = (long)incoming.read(); 
        while(read!=-1) { 
           out.write((int) read); 
           read = (long)incoming.read(); 
        } 
        

        out.close(); 
        client.close(); 
        servSock.close(); 

        System.out.println("receive durchlaufen");
```


```
//        servSock.close();
```

geändert werden, damit neue clients sich verbinden koennen!!

danke noch mal...


----------

