Java.io.StreamCorruptedException: Invalid Code Type: 00

Question

So basically I write a multiplayer client-server game. I have a SeverCommunicationThread that creates a gameThread, if it receives a RequestForGame, creates a gameThread. When I throw a RequestForGame exception, java.io.StreamCorruptedException is thrown: invalid code like: 00 I assume this because both streams try to read the same ObjectInputStream, I don’t have much understanding of how it works, I just know how use it. Could you help me understand what the problem is and how to fix it? Thanks:)

public class ServerCommunicationThread extends Thread{ private Socket connectionSocket; private ObjectInputStream inFromClient; private ObjectOutputStream outToClient; private String nickname; private ServerModelManager model; public ServerCommunicationThread(Socket connectionSocket, ServerModelManager model) throws IOException { this.connectionSocket = connectionSocket; inFromClient = new ObjectInputStream(connectionSocket.getInputStream()); outToClient = new ObjectOutputStream(connectionSocket.getOutputStream()); this.model = model; start(); } public void run() { try { String nickname = (String) inFromClient.readObject(); if (model.exists(nickname)){ System.out.println(nickname + " already exists"); outToClient.writeObject(new MessageForClient("Please choose another nickname")); } else { System.out.println(nickname + " connected, adding to list"); model.addClient(nickname, connectionSocket,outToClient,inFromClient); this.nickname=nickname; } while(true){ Object o= inFromClient.readObject();//StreamCorruptedexception if(o instanceof RequestForGame) { RequestForGame r=(RequestForGame)o; String userToPlayWith=r.getUserToPlayWith(); if(userToPlayWith.equals(nickname)) { String message="Playing with yourself makes your palms hairy, choose another opponent"; outToClient.writeObject(message); } else { System.out.println("received request to play with "+userToPlayWith+". starting game"); ClientRepresentative client1=model.getClient(nickname); ClientRepresentative client2=model.getClient(userToPlayWith); ServerGameThread s=new ServerGameThread(client2,client1,client2.getInStream(),client1.getInStream(),client1.getOutStream(),client2.getOutStream()); } } else if(o instanceof String) { String s=(String) o; if(s.equals("i want to quit")) { model.deleteClient(nickname); inFromClient.close(); String q="quit"; outToClient.writeObject(q); connectionSocket.close(); System.out.println(nickname+"has quit without exc"); } } } } catch (EOFException e) { System.out.println(nickname+" has quit"); } catch (SocketException e) { System.out.println(nickname+" has quit"); } catch (Exception e) { e.printStackTrace(); } } } public class ServerGameThread extends Thread { private ClientRepresentative client1,client2; private ObjectInputStream inFromClient1,inFromClient2; private ObjectOutputStream outToClient1,outToClient2; private Field gameField; public ServerGameThread(ClientRepresentative client1, ClientRepresentative client2,ObjectInputStream inFromClient1,ObjectInputStream inFromClient2,ObjectOutputStream outToClient1,ObjectOutputStream outToClient2) { System.out.println("startin game thred"); this.client1=client1;//client 1 goes first this.client2=client2;//client 2 started game this.inFromClient1=inFromClient1; this.inFromClient2=inFromClient2; this.outToClient1=outToClient1; this.outToClient2=outToClient2; gameField=new Field(); System.out.println("check"); start(); } public void run() { System.out.println("Starting game. players: "+client1.getNickname()+";"+client2.getNickname()); try { outToClient1.writeObject(gameField); outToClient2.writeObject(gameField); while(true) { try { System.out.println("listening to "+client1.getNickname()); Object o1=inFromClient1.readObject();//read move from client 1.**//StreamCorruptedexception** while(!(o1 instanceof PlayerMove)) { o1=inFromClient1.readObject();//read move from client 1. } PlayerMove move1=(PlayerMove)o1; System.out.println("received move "+move1+" sending to "+client2.getNickname()); outToClient2.writeObject(move1); System.out.println("listening to "+client2.getNickname()); Object o2=inFromClient2.readObject();//read move from client 1. while(!(o2 instanceof PlayerMove)) { o2=inFromClient2.readObject();//read move from client 1. } PlayerMove move2=(PlayerMove)o2; System.out.println("received move "+move2+" sending to "+client1.getNickname()); outToClient1.writeObject(move2); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } 

model.addClient method, although I don't think the problem is here

  public void addClient(String nickname, Socket clientSocket,ObjectOutputStream stream,ObjectInputStream inStream) { clients.addClient(nickname, clientSocket,stream,inStream);//add to arraylist //send client list to all clients String[] users=this.getAvailableClients(); ObjectOutputStream[] streams=clients.getOutStreams(); for(int i=0;i<streams.length;i++) { try { streams[i].writeObject(users); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } 

Proxy server on the client side, which sends objects to the server, methods are launched using user actions in the graphical interface

  public class Proxy { final int PORT = 1337; String host; String nickname; private Socket clientSocket; private ObjectOutputStream outToServer; private ObjectInputStream inFromServer; private ClientModelManager manager; public Proxy(String nickname,String host,ClientModelManager manager) { this.nickname=nickname; this.host=host; this.manager=manager; this.connect(nickname); } public void connect(String nick) { Socket clientSocket; try { clientSocket = new Socket(host, PORT); System.out.println("client socket created"); outToServer = new ObjectOutputStream(clientSocket.getOutputStream()); inFromServer=new ObjectInputStream(clientSocket.getInputStream()); outToServer.flush(); outToServer.writeObject(nick); ClientReceiverThread t=new ClientReceiverThread(inFromServer,manager); t.start(); } catch (Exception e) { e.printStackTrace(); } } public void makeRequest(String user) { try { outToServer.writeObject(new RequestForGame(user)); } catch(IOException e) { e.printStackTrace(); } } public void quit() { try { outToServer.writeObject(new String("i want to quit")); //clientSocket.close(); } catch (IOException e) { e.printStackTrace(); } } public void sendMove(PlayerMove move) { try { outToServer.writeObject(move); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } 

}

Answer 1

This problem can occur if you build a new ObjectInputStream or ObjectOutputStream on top of the same socket instead of using the same socket for life; if you use a different type of stream over the same socket; or if you use streams of objects to read or write something that is not an object, and you exit synchronization.

Answer 2

This can also happen if the JVM reading the serialized object does not have the correct / jar class files for the object. This usually results in a ClassNotFoundException , but if you have different versions of jar / class and serialVersionUID not been changed between versions, a StreamCorruptedException is StreamCorruptedException . (This exception may also be possible if there is a conflict of class names. For example: a jar containing another class with the same fully qualified class name, although they probably also need the same serilVersionUID ).

Make sure the client side has the correct version of jars and class files.

Answer 3

Another possibility that I came across is where if you implement the normal deserialization procedure for a class by adding this method:

 private void readObject( ObjectInputStream objectInputStream ) throws IOException 

then objectInputStream.defaultReadObject () must be called and called before further reading the input stream to properly initialize the object.

I skipped this and although the object returning without exception was thrown, it was the next reading of the stream of objects that vaguely raised an exception of an invalid type.

This link contains additional information about the process: http://osdir.com/ml/java.sun.jini/2003-10/msg00204.html .

Answer 4

If an ObjectInputStream is created only once, and then a link to another stream is simply passed, then simply enclose access to this object inside the synchronized block to make sure that only one stream can access this object at a time.

Whenever you read from an ObjectInputStream , just access it inside the synchronized block if it is shared between multiple threads.

---

Code example: (do this for all occurrences of readObject() )

 ... String nickname = null; synchronized (inFromClient) { nickname = (String) inFromClient.readObject(); } 

Answer 5

I also had this exception. This happened because I used two threads for the Server class and the Client class. I used a single thread to send and receive objects. Then everything was fine. This is an easy way to solve the problem if you are not familiar with synchronized .

Answer 6

java.io.StreamCorruptedException: invalid type code: 00

I recently ran into this problem, but didn't do what the OP did. There was a quick Google search and did not find anything that was too useful, and because I think I decided, I comment on my decision.

TL; DR: no need to write multiple streams at the same time to the same output stream (instead, in turn). There will be problems when the client side is trying to read the data. The solution puts a write lock on the output.

I am doing something very similar to OP, creating a multi-user (client-server) game. I have a stream similar to OP that listens for traffic. What was happening on my side of the server was that there were several threads on the server that wrote to the client thread at the same time (I don’t think it was possible, the game was a semi-turnaround base). The client thread that read the incoming traffic threw this exception. To solve this problem, I basically put the lock on the part that the client thread wrote (on the server side) so that each thread on the server side should have a lock before writing to the stream.