Shulou(Shulou.com)06/02 Report--

In TCP/IP protocol, "IP address + TCP or UDP port number" can uniquely identify a process in network communication. "IP address + port number" is called socket. Taking a simple TCP protocol as an example, this paper introduces how to create a network program based on TCP protocol.

TCP protocol communication flow

The following figure describes the communication flow of the TCP protocol (this figure is from the Internet):

The following figure describes the process of establishing a connection for TCP (this figure is from the Internet):

After the server calls socket (), bind () and listen () functions to complete initialization, it calls accept () to block waiting and is in the state of listening port. After the client calls socket () initialization, the call connect () sends out a SYN segment and blocks waiting for the server to reply. The server answers a SYN-ACK segment, and the client receives it and returns from connect (). At the same time, the server answers an ACK segment, and the server receives it and returns from accept ().

The process of data transfer after the establishment of a TCP connection:

After establishing the connection, the TCP protocol provides full-duplex communication services, but the general process of the client / server program is that the client initiates the request actively, and the server passively processes the request, asking and answering. Therefore, the server calls read () as soon as the server returns from accept (). Reading socket is like reading the pipeline. If no data arrives, the client blocks the wait, then the client calls write () to send the request to the server, and the server receives it and returns from read () to process the client's request. During this period, the client calls read () to block waiting for the server's reply. The server calls write () to send the processing result back to the client, and again calls read () blocking to wait for the next request. The client receives it and returns from read (), sends the next request, and so on.

The following figure depicts the process of closing a TCP connection:

If the client has no more requests, it calls close () to close the connection, just like the pipe closed by the writer, and the server's read () returns 0, so the server knows that the client closes the connection and also calls close () to close the connection. Note that after either party calls close (), both transmission directions of the connection are closed and data can no longer be sent. If one party calls shutdown (), the connection is half-closed and the data sent by the other party can still be received.

When learning socket programming, pay attention to how the application and the TCP protocol layer interact:

What action does the TCP protocol layer accomplish when an application calls a socket function? for example, calling connect () sends out how the SYN segment application knows the state change of the TCP protocol layer. For example, returning from a blocked socket function indicates that the TCP protocol has received certain segments, and for example, a return of 0 from read () indicates that a FIN segment has been received.

The following is a simple TCP network program to understand the relevant concepts. The program is divided into two parts: the server side and the client side, which communicate with each other through socket.

Server-side program

Here is a very simple server-side program that reads characters from the client, converts each character to uppercase and sends it back to the client:

# include # define MAXLINE 80#define SERV_PORT 8000int main (void) {struct sockaddr_in servaddr, cliaddr; socklen_t cliaddr_len; int listenfd, connfd; char buf [MAXLINE]; char stre [INET _ ADDRSTRLEN]; int I, n / / socket () opens a network communication port, and if successful, / / returns a file descriptor just like open (), and / / the application can send and receive data on the network using read/write just like reading and writing files. Listenfd = socket (AF_INET, SOCK_STREAM, 0); bzero (& servaddr, sizeof (servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr = htonl (INADDR_ANY); servaddr.sin_port = htons (SERV_PORT); / / bind () is used to bind the parameters listenfd and servaddr together, / / to make listenfd, the file descriptor used for network communication, listen to the address and port number described by servaddr. Bind (listenfd, (struct sockaddr *) & servaddr, sizeof (servaddr)) / / listen () declares that listenfd is listening, / / and allows up to 20 clients to be connected to the host state, and will be ignored if more connection requests are received. Listen (listenfd, 20); printf ("Accepting connections...\ n"); while (1) {cliaddr_len = sizeof (cliaddr) / / A typical server program can serve multiple clients at the same time. / / when a client initiates a connection, the accept () called by the server returns and accepts the connection. / / if a large number of clients initiate a connection and the server does not have time to process it, the client that has not yet accept is in a connection waiting state. Connfd = accept (listenfd, (struct sockaddr *) & cliaddr, & cliaddr_len); n = read (connfd, buf, MAXLINE); printf ("received from% s at PORT% d\ n", inet_ntop (AF_INET, & cliaddr.sin_addr, str, sizeof (str)), ntohs (cliaddr.sin_port); for (I = 0; I < n; iBUF +) {buf [I] = toupper (buf [I]) } write (connfd, buf, n); close (connfd);}}

Save the above code to the file server.c file and execute the following command to compile:

$gcc server.c-o server

Then run the compiled server program:

$. / server

At this point, we can check the port snooping on the host through the ss command:

As shown in the figure above, the server program has begun to listen on port 8000 of the host.

Let's introduce the socket-related API used in this program.

Int socket (int family, int type, int protocol)

Socket () opens a network communication port and, if successful, returns a file descriptor just like open (), and the application can use read/write to send and receive data over the network just like reading and writing files. Specify AF_INET for the IPv4,family parameter. For the TCP protocol, the type parameter is specified as SOCK_STREAM, which represents the stream-oriented transport protocol. In the case of the UDP protocol, the type parameter is specified as SOCK_DGRAM, which represents the Datagram-oriented transport protocol. Protocol can be specified as 0.

Int bind (int sockfd, const struct sockaddr * myaddr, socklen_t addrlen)

The server needs to call the bind function to bind a fixed network address and port number. The purpose of bind () is to bind the parameters sockfd and myaddr together so that sockfd, the file descriptor used for network communication, listens for the address and port number described by myaddr. Struct sockaddr * is a generic pointer type, and the myaddr parameter can actually accept sockaddr structures of multiple protocols, each of which has different lengths, so a third parameter, addrlen, is required to specify the length of the structure.

Initialization of the myaddr parameter in the program is as follows:

Bzero (& servaddr, sizeof (servaddr)); servaddr.sin_family = AF_INET;servaddr.sin_addr.s_addr = htonl (INADDR_ANY); servaddr.sin_port = htons (SERV_PORT)

First, zero the whole structure, and then set the address type to AF_INET and the network address to INADDR_ANY. This macro represents any local IP address, because the server may have multiple network cards, and each network card may also be bound to multiple IP addresses. This setting can listen on all IP addresses, and it is not until you establish a connection with a client that you determine which IP address to use and the port number is SERV_PORT. We define it as 8000.

Int listen (int sockfd, int backlog)

Listen () declares that sockfd is in the listening state and that a maximum of backlog clients are allowed to be in the continuous reception state, and will be ignored if more connection requests are received.

Int accept (int sockfd, struct sockaddr * cliaddr, socklen_t * addrlen)

After the three-party handshake is complete, the server calls accept () to accept the connection. If the server calls accept () without a connection request from the client, it blocks waiting until the client connection comes up. Cliaddr is an outgoing parameter, and when accept () returns, it sends out the address and port number of the client. The addrlen parameter is an incoming and outgoing parameter (value-result argument) that passes in the length of the buffer cliaddr provided by the caller to avoid buffer overflow problems, and the actual length of the client address structure (which may not fill the buffer provided by the caller). If you pass NULL to the cliaddr parameter, you don't care about the address of the client.

The main structure of the server program is as follows:

While (1) {cliaddr_len = sizeof (cliaddr); connfd = accept (listenfd, (struct sockaddr *) & cliaddr, & cliaddr_len); n = read (connfd, buf, MAXLINE);. Close (connfd);}

The whole while loop is an endless loop that handles one client connection at a time. Because cliaddr_len is an incoming and outgoing parameter, the initial value should be re-assigned before each call to accept (). The parameter listenfd of accept () is the previous listening file descriptor, while the return value of accept () is another file descriptor, connfd, and then communicates with the client through this connfd, and finally closes the connfd disconnection without closing listenfd, and goes back to the beginning of the loop where listenfd is still used as the parameter of accept.

Client program

Here is the client program, which takes a string from the command line argument and sends it to the server, then receives the string returned by the server and prints it:

# include # define MAXLINE 80#define SERV_PORT 8000int main (int argc, char * argv []) {struct sockaddr_in servaddr; char buf [MAXLINE]; int sockfd, n; char * str; if (argc! = 2) {fputs ("usage:. / client message\ n", stderr); exit (1);} str = argv [1]; sockfd = socket (AF_INET, SOCK_STREAM, 0) Bzero (& servaddr, sizeof (servaddr)); servaddr.sin_family = AF_INET; inet_pton (AF_INET, "127.0.0.1", & servaddr.sin_addr); servaddr.sin_port = htons (SERV_PORT); / / since the client does not need a fixed port number, there is no need to call bind (), which is automatically assigned by the kernel. / / Note that the client is not allowed to call bind (), but it is not necessary to call bind () to fix a port number, and / / the server does not have to call bind (), but if the server does not call bind (), the kernel will automatically assign a listening port to the server. / / the port number will be different every time you start the server, and the client will have trouble connecting to the server. Connect (sockfd, (struct sockaddr *) & servaddr, sizeof (servaddr)); write (sockfd, str, strlen (str)); n = read (sockfd, buf, MAXLINE); printf ("Response from server:\ n"); write (STDOUT_FILENO, buf, n); printf ("\ n"); close (sockfd); return 0;}

Save the above code to the file client.c file and execute the following command to compile:

$gcc client.c-o client

Then run the compiled client program:

$. / client hello

At this point, the server receives the request and returns the string converted to uppercase, and outputs the corresponding information:

The client receives the converted string after sending the request:

There are two points to note in the client-side code:

1. Since the client does not need a fixed port number, there is no need to call bind (); the client's port number is automatically assigned by the kernel.

two。 The client needs to call connect () to connect to the server. The parameters of connect and bind are the same, except that the parameter of bind is its own address, while the parameter of connect is the address of the other party.

So far, we have used socket technology to complete the simplest client-server program, although it is still very far away from the actual application, but it is enough for learning.

Improve the responsiveness of the server

Although our server program can respond to client requests, it is too inefficient. In general, server programs need to be able to process requests from multiple clients at the same time. Each request can be processed by creating a child process through the fork system call. Here are the general implementation ideas:

Listenfd = socket (...); bind (listenfd,...); listen (listenfd,...); while (1) {connfd = accept (listenfd,...); n = fork (); if (n = =-1) {perror ("call to fork"); exit (1);} else if (n = 0) {/ / processes client requests in child processes. Close (listenfd); while (1) {read (connfd,...); Write (connfd,...);} close (connfd); exit (0);} else {close (connfd);}}

At this time, the task of the parent process is to constantly create the child process, and it is up to the child process to respond to the specific request of the client. In this way, the response ability of the server can be greatly improved.

Summary

This paper introduces the basic concepts of linux socket programming through a simple network program based on TCP protocol. Through it, we can understand the basic principle of socket program work, and some ideas to solve performance problems.

The above is the whole content of this article, I hope it will be helpful to your study, and I also hope that you will support it.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.