Java UDP (Transfer Any Types & Size of File)

In my previous post, I wrote about how to transfer files from one location to another using UDP connection for client server model. There was a limitation of how much size of data can be passed. Now I will discuss about how to pass any types and size of data using UDP connection.

As the file is larger, we can't send the file simply by using DatagramPacket with the help of our byte array. So what we need to do is that we will first divide the full file into some chunks or small size of byte array, say 1024 bytes each. Then we will count how many byte array is required to transfer the file fully. Then we will use a loop to send all the chunks serially.

We created a DatagramSocket ds, DatagramPacket out, byte array snd of size 1024. We created a File f1 and gave the location of the file to be transfered. Now for getting how many packets are required to transfer the file fully, we divided the file by the length of our byte array. So no_of_pkt will hold how many packets are needed to be sent. We then simply send the value to the server to let the server know that, the next file it will receive, will have no_of_pkt number of packets that are to be transfered.

We created a FileInputStream ff to transfer the packets at a time to the server. Inside the loop, we just created byte array of size 1024 each time of sending a new packet. The server will gradually receive these packets one at a time.

Thread.sleep(10L): Pausing Execution with Sleep. Thread.sleep causes the current thread to suspend execution for a specified period. This is an efficient means of making processor time available to the other threads of an application or other applications that might be running on a computer system. We need this as we have many packets to be send, we will consider each of the sending process as a new different thread.
The server will also receive packets with the same loop stated above and gradually write them in a new file.

Sometimes server can't write all the packets. Packets may loss at the time of transfering process. Client will send all the packets but because server can't get all the data ( approximately 10-20% loss ) we need to wrap our whole program in a try-catch for exception. As each time we are sending and receiving new FileStream, we need to check whether they contain data from the previous packet or not. If they have data from the previous packet, then these types of data loss occurs. We need to handle it accordingly. Simply nullifying the Stream before each packet ( both sending and receiving ) will help.

Java File Transfer Using UDP Connection

What is UDP ?

User Datagram Protocol (UDP) is part of the Internet Protocol suite used by programs running on different computers on a network. UDP is used to send short messages called datagrams but overall, it is an unreliable, connectionless protocol. Basically a client will throw something to the server. And then, the server may or may not take the file, do something to that file and then may or may not send the file to some client. Unlike TCP connection, UDP doesn't need to establish connection between server and client before handling any kind of transfer.

What we will do :

1. Create two new project: one for Server, another for Client
2. Server will show client specific file items in a specific directory
3. Client will then request the server to download a file from that directory by inserting the file name
4. Server will then find the file in the directory, make a copy of it in another desirable directory
5. Close socket

Client Part:

First, we create a public class named UDPClient under UDPClient project. The port number is where (Server) we will send our data. Scanner will be used to take user input for the filename.
A DatagramSocket is the sending or receiving point for a packet delivery service. Each packet sent or received on a DatagramSocket is individually addressed and routed. Multiple packets sent from one machine to another may be routed differently, and may arrive in any order. We created a DatagramSocket named ds.

DatagramPacket is used to implement a connectionless packet delivery service. We created two DatagramPacket named outdata (for sending packet to server), indata(for receiving packet from server).

byte array is required to get the data from the packet as bytes. So we also created them.
Java InetAddress class represents an IP address. The java.net.InetAddress class provides methods to get the IP of any host name. We will get localhost for this purpose.

Now we know that server doesn't know anything about client unlike TCPconnection where firstly connection in established between server and client. So to get our server know about the client, we will send something to server from our client program. I sent address and port number ( it's not necessary, but i did it anyways :P ).
outdata is the DatagramPacket and it takes 4 parameters as input. Serially they are:

#Byte array where the data is stored
#Length of the byte array
#Address of the client
#Port number of the client

Now server knows client's port and address. So from the server (we will discuss it later), some specific file names from specific directory is sent to the client as packet and client will now receive that packet in indata, the DatagramPacket we declared earlier. For receiving a packet only byte array name and length is required, in which we will store our packet. Then converting into string, we simply print out the file names in the screen for the client to choose which file should be downloaded.

String fname will contain the user input file name and we will send it to the server via packet like we did at the first time.

Now after the server get the file name for download, server will send that as a packet and client will receive the file and write it in client's desired path.
public class BufferedWriter extends Writer. Writes text to a character-output stream, buffering characters so as to provide for the efficient writing of single characters, arrays, and strings. We used BufferedWriter to write out the file.
In java, FileOutputStream is a bytes stream class that's used to handle raw binary data. To write the data to file, you have to convert the data into bytes and save it to file.
An OutputStreamWriter is a bridge from character streams to byte streams: Characters written to it are encoded into bytes using a specified charset . ... Each invocation of a write() method causes the encoding converter to be invoked on the given character(s).
Finally we will close the socket.
See the sample code below for UDPClient. Next we will  talk about the server part.

Server Part:

Same as client code before, we declared DatagramSocket, Server needs the address and the port number of the client that is trying to connect with it. So we will get the address and port from the client's file using getAddress() and getPort() method.

Now we have just received the packet here and printed the result. With this server got the address and port number of the client ( So, later server can send packet to the address of the client willingly ).

Now, server will send the file names from the directory. String dirname contains the path of the directory. Then we created a File named f1 to get the files from dirname and then created an array direct[] to contain the list of all the files from f1. Then with some coding we got our file names and send it to the client as packet.

Now, server will get the file name for downloading from the client. String fname holds the file name to be downloaded. Then we check whether the file exists in the direct[] or not. If we find matching, then we preserve the index of the file. Then, File copy = new File(direct[idx].getAbsolutePath()); it will contain the path of the desired file. Then with the help of BufferedReader, we will write the file in String s, and then convert it to bytes for packeting, then we will send it to the client. Finally client will then rewrite the file in it's desired directory which we have already seen above.
Here is the code for UDPServer. Thank you for reading patiently.

Now, let's see how to transfer any size of file here.