This project implements a client application, which communicates with the server using given protocol. The application implements communication using two protocols: UDP and TCP.
UDP (or User Datagram Procotol) is communication protocol, that is very common in internet communication.
This protocol uses connectionless model with a minimum of other protocol mechanisms. This means that, for example, it doesn't require connection set up prior the communication (no handshake), which can lead to some unreliablity, such as lost packets, wrong packet ordering (might be received in different order than they were send), duplicate messages and more.
In order to detect errors, UDP uses checksum, which is a small block of data in the message, that contains sum of all bits. To address different functions, UDP uses port numbers.
On the other hand, because UDP doesn't implement all of the mentioned mechanims, it is fast (low latency). Some services need to be as fast as possible and don't care about some lost packets, such as streaming, and so UDP is perfect for this.
TCP (or Transmission Control Protocol) is also very common protocol for internet communication.
This protocol, as opposed to UDP, provides reliable, ordered and error-checked communication. TCP is connection-oriented, which means the connection is established prior of sending messages. Some of the mechanisms TCP uses are handshake, rentransmission of the messages and error detection.
Because TCP is reliable, it is used in services, that don't have to be that fast (can have longer latency), but rather reliable and correct, such as World Wide Web, e-mail, file transfer and more.
From the programmer point of view, TCP is far easier. It is only needed to send and receive messages and you don't have to care about all the protocol mechanisms to aim for better reliability.
UDP on the other hand doesn't implement any of these and so to make UDP more reliable, we're implementing some mechanisms, such as message confirmation and automatic retransmission after certain time, in order to prevent packet losses.
Class diagram above shows basic overview of how I implemented the communication and each network protocol.
I created it in order to abstract TCP and UDP functionality. This way I
don't have to create Client for both TCP and UDP. This interface contains
method definitions for each message (Auth, Join,...), that Client will be
able to send.
It also defines method for receiving (Recv) and for parsing received
message (ParseRecv). Both UDP and TCP have to implement received messages
parsing, because they are in different formats.
There are also methods for closing the connection (Close) and for checking
whether communication can end (CanEnd).
They implement defined methods by IComm interface.
When Client is being constructed, it is given parsed arguments and based on
that, Client desides whether to create TCP or UDP object.
Client contains only one public method and that is Start. This starts the
main loop of the client app. In the loop it handles user input and receives
messages by calling Recv method. When return value of Recv is not empty
array, it calls ParseRecv to handle the received message.
Client also implements user input parsing, because this is same for both TCP
and UDP. If the input is command that interacts with server, Client calls
corresponding IComm method.
I created few tests inside of tests directory:
- File:
tests/ArgsTests.cs - Tests correct program arguments parsing:
- Mandatory arguments are actually mandatory
- Allowed values of arguments
- File:
tests/ValidatorTests.cs - Tests required format of command arguments
- Maximum length of the argument
- File:
tests/UDPTests.cs - Tests required UDP message format
- Had to create class that inherits from UDP class and overrides
Sendmethod in order to be able to test this
- File:
tests/TCPTests.cs - Tests required TCP message format
- Had to create class that inherits from TCP class and overrides
Sendmethod in order to be able to test this
Then I also tested using Wireshark, where I inspected sent message format, but also messages, that were received, whether they're parced correctly.
I also tested by running the program:
To test this I stopped passing CONFIRM messages to UDP and replaced sending
to server with printing. This tested, whether maximum number of rentrasmits
work and whether the confirmation timeout works. I tested both with different
values and messages as well.
I also connected to provided server and every command user can execute. I tried with multiple values as well. I also inspected whether all messages are received and shown.
/clear- Locally executed command for clearing the chat screen