FTP based Client Server project using sockets and threads:

Abstract:
File Transfer Protocol is a standard network protocol used to transfer files from one host to another host over a TCP based network such as internet. This protocol can be used to upload or download files form one host to another. This protocol is based on cilent-server architecture and may use different control and data connections between the client and the server.
I tried to implement FTP to transfer files within and over the network(using internet) using C language.

Architecture:
There may be a server running and waiting for clients to log in(initiate communication). Once any client approaches the server to upload a file, it waits in a queue untill server accepts its request. The server may ask the client to login before further processing its request. Also the server may ask few times for correct password and failing to get that server may refuse to connect to that client.

Implementation:

SERVER-SIDE:
1. I implemented server and used socket() system call to make a socket on the server side.
This call makes a socket in the namespace(address family) but it has no address is assigned to it.
And it also provides mechanisms to communicate with network layer.
2. Then i named that socket using bind() system call.
This system call assignes the address specified by one of its arguments to the socket referred to by
file_descriptor returned by socket().
3. Then i used listen() system call, which implements a listening queue to take requests from various clients to be processed by the server.
4. Finally i used accept() system call to take requests from listening queue and implemented authentication functionality to provide access to the clients.
5. If clients enters correct credentials if may proceed to upload a file.
6. After getting the file server may proceed to handle another request from listening queue.

NOTE: I used accept() in a ‘forever’ loop so that server may be running all the time.
Once the client is successfully logged-in i implemented POSIX threads to take the any number of files(tested for 1000 files) fron that specific client.

CLIENT-SIDE:
1. I implemented client and used socket() system call to make a socket on the client side.
2. Then, i used connect() system call to send request to the server.
3. Now when server is ready to accept the request then client is promped to enter its details along with passwords.
4. Once the authentication is successfully done then client may send any number of files to the server in one go.
5. After successfully sending file client may terminate or re-request the server to send more files.

The above algorithm was implemented and tested using AF_INET (address family) to transfer file within a private network.
File can also be sent over the internet using the above algorithm but for that we may need to acquire the public ip address assigned to us.
Another method is to use a technique referred to as “PORT FORWARDING“.
This technique is only to be used at server’s side and it requires us to configure our router so that it may direct the incomming packets for a particular port address on server’s ip address.

Future scope:
If we are not allowed to change router’s configuration then we can establish a VPN, which is used to directly communicate with a particular machine without even going through the router associated with that machine.

Thank You
HARPREET SINGH
ece.harpreetsingh@gmail.com

In digital forms of data storage, data can be represented by patterns of 0s and 1s.
The more the patterns the more data can be compressed. Text may be compressed upto 40% of its original size. The percent of compression that can be done on a piece of text or a file depends on the type of file and the format of the text used.
Compression of a file may not be useful un till it can be decompressed back to its original form for further usage.

The requirement of compressing a file arises form various reasons, some of which may be
:
1. Security purpose.
2. Transmission purpose.(better bit rates, small latencies, etc)
3. Secrecy of the data or file being transferred.(Only some people may access, understand and manipulate data that is visible to all)
4. Storage purpose.(Efficient use of storage space)
etc,

When a file is compressed using any algorithm, it may be decompressed using more or less of that same algorithm in reverse order. An efficient compression may only be tested upon successful decompression of the compressed file if it generates the original file as it was before compression.
General Idea.
Any text file that has some text in it must be compressed depending on the size of the file and distinct characters it have. The same file may be decompressed using suitable algorithm and it must generate a file having same information of the source file used for compression. The program must be able to find number of distinct characters in the text file and store them in am array. In computer architecture (x86 machines) the data encoding scheme used to store, manipulate and transmit data is ASCII(American Standard Code for Information Interchange). It defines that maximum number of distinct characters available are 256 (i.e., 2^8). I used this very property of ASCII codes in my algorithm for compressing and decompressing files of any length but must have 256 distinct characters.

A simple algorithm used in compressing a text file may be :

1) Open a source file that comtains some text.(this file will be subjected to compression and decompression).
2) Read first character from source file.
3) Store first character in an array.
3) Read a character from this source file.
4) Compare the character with already existing character(s) in the array.
if the character matches with any character present in array goto step 4.
otherwise, modify the size of array by appending this character into it.
NOTE : this array now will have all the distinct characters in the file. This is the “key” used to compress and decompress the source file.
5) Now calculate the code length according to the number of elements in the master array. This is the actual size that my character must use in memory.
6) Seek the file position of the opened file to its begining.
7) Read a character from this file.
8. Compare this character with the one’s in array.
if it is present in array then assign its array index into a variable with appropriate shifting and goto step 7.
otherwise goto step 7.
NOTE: step 8 may differently handle the characters depending the code length and algorithm but the working principle is same.
9) Save the newely available coded word(after shifting) in to a new file. This is the compressed file.
10) Close all opened files.
11) Exit.

A simple algorithm used in decompressing a text file may be :

NOTE : I must have the “key” used in compression.(i.e., array holding distinct characters that were present in the source file)
1) Open the compressed file.
2) Read a character from this file.
3) save the bits of this character in different variables with appropriate shifting.
NOTE: step 3 may differently handle the character depending the code length and algorithm but the working principle is same.
4) Save the new bytes(new variables) in a new file.
5) goto step 2.
6) close all the opened files.
7) Exit.

Now to test the compression algorithm, compare the final newely created file’s information with that of original source file’s.

Conclusion:
I used the above algorithm to successfully compress and decompress many source files having variable text lengths.

Thank You.
HARPREET SINGH
ece.harpreetsingh@gmail.com

This project is implemented to achieve inter-process communication seemlessly, using various communication and synchronization techniques including PIPEs, FIFOs, MESSAGE QUEUES, SHARED MEMORY, SEMAPHORE and SIGNALS.

General Idea:
There may be 1 server and many requesting clients and a few processing clients.
Many requesting clients may send their requests to the server at any point of time and server maintains a database so as to recognize the request and invoke appropriate processing client to calculate the result of the query.
Also server must send the results of the requests to the associated requesting clients without any loss of data.

1.
In my first attempt i implemented 1 server that itself invokes 3 requesting clients using PIPEs and recieves various requests from them.
After having the requests it invokes appropriate processing clients using another set of 3 processing PIPEs to process the requests and calculate respective results to be sent back to appropriate requesting clients.

Problems Encountered:
1) There was a problem in synchronizing the mechanism.
2) Block on read
3) Block on write.

Remedy:
I implemented signals to synchronize the mechanism.

2.
Then to make requesting clients independent of the server i implemented FIFOs to take requests from various requesting clients and to provide them with appropriate results.
I used 1 requesting FIFO to get all the requests from the requesting clients.
After decoding the request server invokes appropriate processing clients to get the result using PIPEs.
Then the server sends the results to the requesting clients by another FIFO.
The requesting clients also sent their PIDs so as to be signaled by the server.

Problems encountered:
1)Block on open.
2)Block on read.
3)Block on write.
4)Synchronization.

Remedy:
i implemented signals to sync the mechanism.

3.
Then i implemented MESSAGE QUEUE to get the requests from the requesting clients and everything else was same.
The requirement for synchronization was appreciately decreased as there was no need of the processes to be present all the time as was in the case of FIFOs.
The reader or the writer can anytime access the MESSAGE QUEUE to read or write the data along with their PIDs.

Problems encountered in MESSAGE QUEUEs:
1) Max size limited by data chunk of message queue.
2) Max size of queue is also system limited..
Remedy:
I implemented SHARED MEMORY and SEMAPHORES to achieve synchronization.

4.
Now i modified the above architecture and used SHARED MEMORY instead of resulting FIFOto achieve synchronization. Still sync was not apprecisble.
Problem encountered:
Synchronization while sending the results back to the requesting clients was not proper.

Remedy:
Use semaphores.

5.
Finally i implemented each of the above mentioned techniques to implement the project.
The requesting clients used MESSAGE QUEUE to send the requests to the server.
Server, after analysing the requests, invoked appropriate processing client to calculate the result.
Then server used SHARED MEMORY to sent results back to the requesting clients.
SEMAPHORES were implemented to synchronize shared memory access by various requesting clients.

Submitted By:
HARPREET SINGH
Batch no.:
20.02.36

2) Rahul Singh :: 11:00 a.m. to 7:00 p.m.

3) Puneet S. Bist :: 11:30 a.m. to 6:00p.m.

4) abhishek Bist :: 11:30 a.m. to 4:00 p.m.

5) Kamal :: 10:30 a.m. to 6:00 p.m.

6) Prabhjot Singh :: 10:45 a.m. to 6:00 p.m.

7) Harpreet Singh :: 11:10 a.m. to 6:00 p.m.

Total strength: 7.