Detect "end of file" while send n numbers files over a socket?

Question

Hi!
I�m trying to find a way to detect "end of file" while send n numbers files over a socket.
What i'm looking for is how to detect on the client side when the file i�m sending is downloaded.
Here is the example i�m working on.
Client side.
import java.io.*;
import java.net.*;
public class fileTransfer {
    private InputStream fromServer;
    public fileTransfer(String fileName) throws FileNotFoundException, IOException {
        Socket socket = new Socket("localhost", 2006);
        fromServer = socket.getInputStream();
        for(int i=0; i<10; i++)
            receive(new File(i+fileName));
    private void receive(File uploadedFile) throws FileNotFoundException, IOException {
        uploadedFile.createNewFile();
        FileOutputStream toFile = new FileOutputStream(uploadedFile);
        byte[] buffer = new byte[4096];
        int bytesRead = 0;
        while ((bytesRead = fromServer.read(buffer)) != -1) {
            toFile.write(buffer, 0, bytesRead);
    public static void main(String[] args) {
        try {
            new fileTransfer("testa.jpg");
        } catch (Exception ex) {ex.printStackTrace();}
}Server side.
import java.io.*;
import java.net.*;
public class fileTransferSend {
    Socket serv = null;
    OutputStream toClient;
    public fileTransferSend(String fileName) throws FileNotFoundException, IOException {
        StartServer();       
        for(int i =0; i<10; i++)
            send(new File(fileName));
    public void StartServer() throws IOException {
        ServerSocket ssocket = new ServerSocket(2006);
        System.out.println("Waiting for incomming");
        serv = ssocket.accept();
        System.out.println("incomming");
        toClient = serv.getOutputStream();
    private void send(File f) throws FileNotFoundException, IOException {
        if(f.exists() && f.canRead()) {
            FileInputStream fromFile = new FileInputStream(f);
            try {
                byte[] buffer = new byte[4096]; // 4K
                int bytesRead = 0;
                System.out.println("sending: "+f.getName());
                while ((bytesRead = fromFile.read(buffer)) != -1) {
                    toClient.flush();
                    toClient.write(buffer, 0, bytesRead);
            finally {
                //toClient.close();
                fromFile.close();
        } else {
            System.out.println("no files");
    public static void main(String[] args) {
        try {
            new fileTransferSend("test.jpg");
        }catch(Exception e) {e.printStackTrace();}
I know that the client never reads -1 becuase i doesn�t close the stream.
Is there anyway to tell the client that the file is downloaded?

Answer 1

A common (and easy) TCP/IP protocol is to send length, followed by data.
Because TCP/IP is a stream-oriented protocol, a receiver can never absolutely determine where the first packet ends and the second packet begins. So it is common to send the length of the packet, followed by the packet itself.
In your case, you could send length of file, followed by file data. It should be fairly easy to obtain file length and send that as a 32-bit (or 64-bit value). Here is an idea (not code) for the receiver:
receive (4) // where 4 = number bytes to receive
unsigned length = convert 4 bytes to unsigned integer
while (length != 0)
n = receive ( length ) // where n = number bytes actually received, and length = number bytes desired
Or, you can use the concept of an "Escape" character in the stream. Arbitrarily choose an ESCAPE character of 0x1B (although it could be any 8-bit value). When the receiver detects an ESCAPE char, the next character can be either control or data. So for end of file you might send 0x1B 0x00. If the byte to be sent is 0x1B, then send 0x1B 0x1B. The receiver would look something like this:
b = read one byte from stream
if (b == 0x1B)
b = read one byte from stream
if (b == 0x00) then end of file
else place b in buffer
else
place b in buffer
Later.