Lector: Aliyev H.U.

Lecture №6 Design of client-server communication

software.TCP-based network programming

TASHKENT UNIVERSITY OF INFORMATION TECHNOLOGIES

THE DEPARTMENT OFDATA COMMUNICATION NETWORKS AND SYSTEMS

Introduction

• In this lesson, we will look in detail at the higher-level network classes provided in the .NET Framework. We'll start with client-server architecture, general introduction to TCP, and its architecture and data structures.

• Next, we'll explore the TcpClient and TcpListener classes provided in the .NET Framework for working with TCP. Finally, we'll discuss using the TCP channel with .NET Remoting.

Client-server communication architecture(connection-oriented)

Overview of TCP

• TCP, or Transmission Control Protocol, is used as a reliable protocol to communicate across an interconnected network of computers. TCP verifies that the data is properly delivered to the destination in the correct sequence. We'll look briefly at how TCP achieves this in a moment.

• TCP is a connection-oriented protocol designed to provide reliable transmission of data from one process to another process running on the same or different computers. The term 'connection-oriented' means that the two processes or applications must establish a TCP connection prior to exchanging any data. This is in contrast to UDP (which we'll look at in the next chapter), which is a 'connection-less' protocol, allowing data to be broadcast to an unknown number of clients.

Encapsulation

• When an application sends data using TCP, it travels down the protocol stack. The data is passed through each of the layers and finally transferred across the network as stream of bits.

• Each layer in the TCP/IP protocol suite adds some information in the form of headers and/or trailers:

When the packet arrives on the other side of the network, it is again passed through each layer from bottom to top. Each layer strips out its header/trailer information to verify the data and finally it reaches the server application in the same form as it left the client application.

TCP Terminology

• Before looking at how TCP establishes a connection with another TCP host, there are a number of terms that we need to define:

• Segment• The unit of data that TCP sends to IP is called a TCP segment.• Datagram• The unit of data that IP sends to the Network Interface Layer is

called an IP datagram.• Sequence Number• Every TCP segment sent over a connection has a number

assigned to it, which is called the 'Sequence Number'. This is used to ensure that the data arrives in the correct order.

TCP Headers• To understand how TCP works, we also need to look

quickly at the structure of a TCP header:

The sequence and acknowledgement of TCP

• The sequence and acknowledgement numbers are used by TCP to ensure that all the data arrives in the correct order, and the control bits contain various flags to indicate the status of the data. There are six of these control bits (usually represented by three-letter abbreviations):

• URG-indicates that the segment contains urgent data• ACK-indicates that the segment contains an acknowledgement

number• PSH-indicates the data is to be pushed through to the receiving user• RST-resets the connection• SYN-used to synchronize sequence numbers• FIN-indicates the end of data

TCP Connections

TCP Operations

Flow Control • TCP governs the amount of data sent to it by returning a 'window size' with every

acknowledgement. A 'window' is the amount of data that the receiver can accept. A data buffer is placed between the application program and the network data flow. The 'window size' is actually the difference between the size of the buffer and the amount of data stored in it. This number is sent to inform the remote host about the current window size. This is called a 'Sliding Window'. The Sliding Window algorithms control the flow for network data transfers:

TCP in .NET programming• .NET support for TCP sockets is a great improvement on the previous

programming model. Previously, most developers using Visual C++ have either employed the CSocket and CAsyncSocket classes for manipulating all types of socket communication, or used third-party programming libraries. There was almost no built-in support for higher-level TCP programming. In .NET, there is a separate namespace provided for working with sockets-the System.Net.Sockets namespace (as discussed in the previous chapter). This namespace contains low-level classes such as Socket as well as higher-level classes such as TcpClient and TcpListener to offer simple interfaces to TCP communication.

• The TcpClient and TcpListener classes follow the stream model for sending and receiving data, as opposed to the Socket class, which employs the byte-level approach. In these classes, all communication between the client and the socket is based on a stream, using the NetworkStream class. However, we can also work with bytes where necessary.

TCP based programming

TCP Socket Functions

The TcpClient Class

• The TcpClient class provides client-side connections for TCP services. It is built upon the Socket class to provide TCP Services at a higher level-TcpClient has a private data member called m_ClientSocket, which is used to communicate with the TCP server. The TcpClient class provides simple methods for connecting to another socket application over the network, and for sending and receiving data to it

Public Methods of TcpClient Class

Name Description

Close() Closes the TCP connection.

Connect() Connects to a remote TCP host.

GetStream() Returns the NetworkStream used for transferring data between the client and the remote host.

The TcpListener Class

• Typically, a server-side application starts by binding to the local endpoint and listening to incoming requests from clients. As soon as a client is found knocking on the port, the application activates by accepting the request and then creating a channel that is then responsible for communicating with the client.

• The application continues to listen for more incoming client requests on the main thread. The TcpListener class does exactly that-it listens to the client's request, accepts it, and then creates a new instance of the Socket class or the TcpClient class that we can use to communicate with the client. Just like the TcpClient, the TcpListener also encapsulates a private Socket object, m_ServerSocket, available only to derived classes.

The TcpListener Class

• Public Methods

Name Description AcceptSocket() Accepts a pending connection request and returns a

Socket object to use to communicate with the clientAcceptTcpClient() Accepts a pending connection request and returns a

TcpClient object to use to communicate with the clientPending() Indicates whether there are any connection requests

pendingStart() Causes the TcpListener to start listening for connection

requestsStop() Closes the listener

The server application diagram in TCP

Primer on the TcpClient

• 1. Passing in an IPEndPoint object representing the remote endpoint we want to connect to:

• // Create a new instance of the TcpClient class TcpClient newClient = new TcpClient();

• // Establish a connection with, the IPEndPoint • IPAddress ipAddr = IPAddress.Parse("127.0.0.1");

IPEndPoint endPoint = new IPEndPoint(ipAddr, 80); • // Connect with the host using IPEndPoint

newClient.Connect(endPoint);

Primer on the TcpClient

• 2.Passing in an IPAddress object and a port number:

• // Create a new instance of the TcpClient class • TcpClient newClient = new TcpClient(); • // Establish a connection with the IPEndPoint• IPAddress ipAddr = IPAddress.Parse("127.0.0.1");• // Connect with the host using IPAddress and port number

newClient.Connect(ipAddr, 80);

Primer on the TcpClient

• Passing in a hostname and port number: • // Create a new instance of the TcpClient class

TcpClient newClient = new TcpClient();• // Connect with the host using hostname as

string and port newClient.Connect("127.0.0.1", 80);

Primer on the TcpClient• If there is a connection failure or other problem, a SocketException will

be thrown:• try • { • TcpClient newClient = new TcpClient();• // Connect to the server newClient.Connect("192.168.0.1", 80); • // Socket raises exception here // if there is some problem with the //

connection• } • catch(SocketException se) • { • Console.WriteLine("Exception: " + se);• }

Primer on the TcpClient

• The NetworkStream class is used for stream-level processing as a communication channel between two connected applications.

• NetworkStream tcpStream = newClient,GetStream(); • After getting the stream, we can use the Read() and Write()

methods of NetworkStream to actually read from the host application and write to it.

• The Write() method takes three parameters-a byte array containing the data we want to send to the host, the position in the stream where we want to start writing, and the length of the data:

• byte[] sendBytes = Encoding.ASCII.GetBytes("This is a Test<EOF>"); tcpStream.Write(sendBytes, 0, sendBytes.Length);

Primer on the TcpClient• The Read() method has exactly the same set of parameters-a byte array

to store the data that we read from the stream, the position to start reading, and the number of bytes to read:

• byte[] bytes = new byte[newClient.ReceiveBufferSize]; int bytesRead = tcpStream.Read(bytes, 0, newClient.ReceiveBufferSize);

• // Convert from bytes to string • // returnData will contain the incoming data from socket string

returnData = Encoding.ASCII.GetString(bytes);

• The TcpClient's ReceiveBufferSize property allows us to get or set the size of the receive buffer (in bytes), so we use it as the size of the byte array. Note that setting this property doesn't restrict the number of bytes we can read in each operation, as the buffer will be dynamically resized if necessary, but it does reduce overhead if we specify a buffer size.

Primer on the TcpClient

• Closing a TCP Socket• After communicating with the client, the

Close() method should be called to free all resources:

• // Close client socket• newClient.Close();

Q&A?