It duplicates content when transferring it via java socket

Question

I have written a client-socket "system" that is supposed to upload a file. Although, when I attempt to upload, content duplicates. I'm pretty sure that it is because the program doesn't recognise the eof. I've found something like "Object stream", but I don't fancy importing new classes. I reckon that I don't really require that. But I wanna know how what the problem precisely is and how to hanle it.

package client;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;

public class Client {

    private Socket socket;
    private DataInputStream in;
    private DataOutputStream out;

    public static void main(String[] args) {
        new Client();

    }
    public Client()
    {
        try {
            socket = new Socket("127.0.0.1", 5010);
        
            in = new DataInputStream(socket.getInputStream());
            out = new DataOutputStream(socket.getOutputStream());
            
            this.sendFile("./some.txt");
            
            in.close();
            out.close();
            socket.close();
        }
        catch(UnknownHostException ex)
        {
            System.out.println("unknown host");
        }
        catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    private void sendFile(String path)
    {
        int bytes = 0;
        File file = new File(path);
        FileInputStream input;
        try {
            input = new FileInputStream(file);
            
            long size = file.length();
            //long size = file.getTotalSpace();
            System.out.println(size);
            // send a file's size
            out.writeLong(size);
            byte[] buffer = new byte[1024];
            int i = 0, r=0;
            //while((bytes = input.read(buffer,0,buffer.length))!=-1)
            while(size > 0 && (bytes = input.read(buffer,0,(int)Math.min(buffer.length, size)))!=-1)
            {
                System.out.println("\n -------------"+(++i));
                for (byte b : buffer)
                    try
                    {
                        if ((char)b == '\n' || r == 0)
                            System.out.print("\n" + (++r));
                        System.out.print((char)b);
                        
                    }
                    catch(NullPointerException ex)
                    {
                        
                    }
                out.write(buffer, 0, bytes);
                out.flush();
                size -= bytes;
            }
            
            input.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}

package server;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {

    private ServerSocket ss;
    private Socket cs;
    private DataInputStream in;
    private DataOutputStream out;
    public static void main(String[] args) {
        
        new Server();
    }
    public Server()
    {
        try {
            ss = new ServerSocket(5010);
            cs = ss.accept(); 
            
            in = new DataInputStream(cs.getInputStream());
            out = new DataOutputStream(cs.getOutputStream());
            
            this.receiveFile("./uploaded.txt");
            
            in.close();
            out.close();
            cs.close();
            ss.close();
        } 
        catch (IOException e) {
            e.printStackTrace();
        }
    }
    private void receiveFile(String path)
    {
        int bytes = 0;
        try {
            File file = new File(path);
            file.createNewFile();
            FileOutputStream output = new FileOutputStream(file);
            
            long size = in.readLong();
            byte[] buffer = new byte[1024];
            
            int i = 0;
            
            while(size>0 && (bytes = in.read(buffer, 0, (int)Math.min(buffer.length, size))) != -1)
            {
                System.out.println("\n -------------"+(++i));
                for (byte b : buffer)
                    try
                    {
                        System.out.print((char)b);
                    }
                    catch(NullPointerException ex)
                    {
                        
                    }
                output.write(buffer, 0, bytes);
                size -= bytes;
                
            }
            
            output.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

Answer 1

The problem was that I didn't check if the size were 0 on the client side.

Answer 2

That try catch should NOT be in the for loop !!!! It only needs single code use by wrapping. Also use counting metering conventionally the number of bytes with a conventional numeric "for" loop, Not for(byte b : buffer). Note: byte is not strictly numeric, it will only reach to 255 in the for counter! It depends the quantity bytes required iterated over and should be as many as are packaged to it over the connection.

In the read you need to obtain the number of bytes sent andmark that into the write length to take from the array, so it would be better to instantiate the array based on the number of bytes or maximum bytes the the client sender has sent or negotiated as the maximum allowed (see the api docs for the stream. NB ObjectStream does not apply , it's for RMI)

Of counting into the byte[] buffer array, you should remove it from the method and put it as a global. In the method , instantiate a new "buffer" array on the global variable each iteration of the loop according to the number of bytes read as it's new length.

The code does not appear to be particularly safe or debugable. You might try carefully constructing it starting again from scratch.