Hi Chris,

Further to the last post I now have the following acting in the thread,
and the whole file transfer thing works great. However if I try to
perform an ordinary chat session, the server hangs. The real thing that
is bugging me is that when I send a file, all control messages get
through (i.e. FILE_WARNING, FILE_ACKNOWLEDGE), so why not CHAT
messages? The code I have is:-

class ClientThread implements Runnable, ApplicationConstants{

    private DataInputStream dis;
    private Socket socket;
    private boolean isDone = false;
    private boolean uploadingFile = false;
    private Thread thread;
    private User user;
    private int uploadSize = MAXIMUM_MESSAGE_SIZE;

    public ClientThread(Socket socket, User user){

        System.out.println("This is " + user.getUserName() + "'s Thread! and
upload size is " + uploadSize);

        try{
            //set the socket
            this.socket = socket;
            //set the user
            this.user = user;
            //create the input stream to listen for incoming messages
            dis = new DataInputStream(socket.getInputStream());
            //create the thread
            thread = new Thread(this,"ClientThread");
            //start the thread
            thread.start();
        }
        catch(Exception e){
            System.out.println("service constructor"+e);
        }
    }

    //thread is running and continuously listening for a message from its
client
    public void run(){
        byte [] data;

        //read in the data
        while(!isDone){
            try{
                //if an ordinary message is being sent do this
                if(!uploadingFile){
                    System.out.println("Listening for normal messages in " +
user.getUserName() + "'s Thread");
                    //set max size of message
                    data = new byte[uploadSize];
                    System.out.println("Upload size is " + uploadSize);
                    //read in the byte array
                    dis.read(data,0,uploadSize);
                }
                //if a file is being sent then do this
                else{
                    System.out.println("Listening for file messages in " +
user.getUserName() + "'s Thread");
                    data = new byte[uploadSize];
                    dis.readFully(data,0,uploadSize);
                }

                //Convert into a message object
                Message message = (Message)ConvertData.bytesToMessage(data);

                //Checks if a file is going to be sent. If so, increase the
                //size of the byte array to accomodate the file size and the
                //message objects.
                if(message.getMessageHeader() == FILE_WARNING){
                    System.out.println("I received a FILE_WARNING");
                    //increase size of upload
                    uploadSize = ((int)message.getFileSize());
                    //set uploadingFile to true
                    uploadingFile = true;
                    //acknowledge to sender that server is ready for the file
                    message.setMessageHeader(FILE_ACKNOWLEDGE);
                    //output the message back to the sender of the file
                    Server.outputToSingleClient(message);
                }
                //file received ok so set array back to default level and pass
                //the message to the Server to deal
                else if(message.getMessageHeader() == FILE_SENDING){
                    System.out.println("I received a FILE_SENDING");
                    //set size of array back to default
                    uploadSize = MAXIMUM_MESSAGE_SIZE;
                    //set uploadingFile back to false
                    uploadingFile = false;
                    //now process the message
                    Server.processClientMessage(message);
                }
                //pass to the server for processing
                else{
                Server.processClientMessage(message);
                }
            }
            //Error in the thread
            catch(Exception e){
                System.out.println("In the exception block of the thread " + e);

                uploadSize = MAXIMUM_MESSAGE_SIZE;
                //set isDone to true
                isDone = true;
                //remove the user from the list
                Server.removeFromUserList(user);
                //send a CLIENT_LOGOUT message to all other users
                Message message = new Message(CLIENT_LOGOUT);
                //set the user as this user
                message.setUser(user);
                //get Server to xend this message to all clients left on the list
                Server.outputToAllClients(message);
                //try to close the socket
                try{
                    socket.close();
                }
                catch(Exception se){
                    System.out.println("Error closing the socket " + se);
                }
            }
        }
    }
}

Any light that can be shed on this will really be appreciated.

Kind regards,

Chris