Super detailed explanation of Socket communication principles and examples

We are well aware of the value of information exchange, but how do processes in the network communicate with each other? For example, when we open a browser to browse the web every day, how does the browser process communicate with the web server? When you chat with QQ, how does the QQ process communicate with the server or the QQ process where your friends are? All of these rely on sockets. So what is a socket? What are the types of sockets? And the basic functions of sockets, all of which are what this article wants to introduce. The main contents of this article are as follows:

• How do processes communicate in a network?
• What is a Socket?
• Basic operations of socket 3.1. socket() function 3.2. bind() function 3.3. listen(), connect() function 3.4. accept() function 3.5. read(), write() function, etc. 3.6. close() function
• Detailed explanation of TCP three-way handshake to establish connection in socket
• Detailed explanation of TCP's four-way handshake to release the connection in socket
• An example

[[287351]]

1. How do processes communicate in a network?

There are many ways of local inter-process communication (IPC), but they can be summarized into the following four categories:

• Message passing (pipes, FIFOs, message queues)
• Synchronization (mutexes, condition variables, read-write locks, file and write-record locks, semaphores)
• Shared memory (anonymous and named)
• Remote Procedure Call (Solaris Gate and Sun RPC)

But these are not the subject of this article! What we want to discuss is how do processes communicate in the network? The first problem to be solved is how to uniquely identify a process, otherwise there is no communication! Locally, a process can be uniquely identified by the process PID, but this does not work in the network. In fact, the TCP/IP protocol family has helped us solve this problem. The "ip address" of the network layer can uniquely identify the host in the network, and the "protocol + port" of the transport layer can uniquely identify the application (process) in the host. In this way, the process of the network can be identified by the triple (ip address, protocol, port), and the process communication in the network can use this mark to interact with other processes.

Applications using TCP/IP protocols usually use application programming interfaces: UNIX BSD sockets and UNIX System V TLI (which has been eliminated) to achieve communication between network processes. At present, almost all applications use sockets, and now is the Internet age, and process communication in the network is everywhere, which is why I say "everything is a socket".

2. What is a Socket?

We already know that processes in the network communicate through sockets, so what is a socket? Sockets originated from Unix, and one of the basic philosophies of Unix/Linux is "everything is a file", which can be operated using the "open -> read/write -> close" mode. My understanding is that Socket is an implementation of this mode, and socket is a special file. Some socket functions are operations on it (read/write IO, open, close), which we will introduce later.

The origin of the word socket:

3. Basic operations of socket

Since socket is an implementation of the "open-write/read-close" model, socket provides function interfaces corresponding to these operations. The following takes TCP as an example to introduce several basic socket interface functions.

(1) socket() function

 int socket(int domain, int type, int protocol);

The socket function corresponds to the opening operation of a common file. The opening operation of a common file returns a file descriptor, while socket() is used to create a socket descriptor, which uniquely identifies a socket. This socket descriptor is the same as the file descriptor. It is used in subsequent operations and is used as a parameter to perform some read and write operations.

Just as you can pass different parameter values ​​to fopen to open different files, you can also specify different parameters to create different socket descriptors when creating a socket. The three parameters of the socket function are:

• domain: protocol domain, also known as protocol family. Commonly used protocol families include AF_INET, AF_INET6, AF_LOCAL (or AF_UNIX, Unix domain socket), AF_ROUTE, etc. The protocol family determines the address type of the socket, and the corresponding address must be used in communication. For example, AF_INET determines the combination of ipv4 address (32 bits) and port number (16 bits), and AF_UNIX determines the use of an absolute path name as the address.
• type: specifies the socket type. Common socket types include SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, SOCK_PACKET, SOCK_SEQPACKET, etc. (What are the types of sockets?).
• protocol: As the name implies, it specifies the protocol. Commonly used protocols include IPPROTO_TCP, IPPTOTO_UDP, IPPROTO_SCTP, IPPROTO_TIPC, etc., which correspond to TCP transport protocol, UDP transport protocol, STCP transport protocol, TIPC transport protocol (I will discuss this protocol separately!).

Note: Not all types and protocols can be combined at will, for example, SOCK_STREAM cannot be combined with IPPROTO_UDP. When protocol is 0, the default protocol corresponding to type will be automatically selected.

When we call socket to create a socket, the returned socket descriptor exists in the protocol family (address family, AF_XXX) space, but does not have a specific address. If you want to assign an address to it, you must call the bind() function, otherwise the system will automatically assign a random port when calling connect() or listen().

(2) bind() function

As mentioned above, the bind() function assigns a specific address in an address family to the socket. For example, for AF_INET and AF_INET6, it assigns a combination of an IPv4 or IPv6 address and a port number to the socket.

 int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

The three parameters of the function are:

• sockfd: socket descriptor, which is created by the socket() function and uniquely identifies a socket. The bind() function is used to bind a name to this descriptor.
• addr: a const struct sockaddr * pointer, pointing to the protocol address to be bound to sockfd. This address structure varies depending on the address protocol family when the address creates the socket. For example, ipv4 corresponds to:

 struct sockaddr_in { sa_family_t sin_family; /* address family: AF_INET */ in_port_t sin_port; /* port in network byte order */ struct in_addr sin_addr; /* internet address */ }; /* Internet address. */ struct in_addr { uint32_t s_addr; /* address in network byte order */ };

The corresponding IPv6 is:

 struct sockaddr_in6 { sa_family_t sin6_family; /* AF_INET6 */ in_port_t sin6_port; /* port number */ uint32_t sin6_flowinfo; /* IPv6 flow information */ struct in6_addr sin6_addr; /* IPv6 address */ uint32_t sin6_scope_id; /* Scope ID (new in 2.4) */ }; struct in6_addr { unsigned char s6_addr[16]; /* IPv6 address */ }

The Unix domain corresponds to:

 #define UNIX_PATH_MAX 108 struct sockaddr_un { sa_family_t sun_family; /* AF_UNIX */ char sun_path[UNIX_PATH_MAX]; /* pathname */ }

• addrlen: corresponds to the length of the address.

Usually, when a server starts, it will bind a well-known address (such as IP address + port number) to provide services, and clients can use it to connect to the server; the client does not need to specify it, and the system automatically assigns a port number and its own IP address combination. This is why the server usually calls bind() before listening, but the client does not call it, but the system randomly generates one when connecting().

Network byte order and host byte order:

Host byte order is what we usually call big-endian and little-endian mode: different CPUs have different byte order types. These byte orders refer to the order in which integers are stored in memory. This is called host order. The definitions of Big-Endian and Little-Endian in the reference standard are as follows:

• Little-Endian means that the low-order bytes are arranged at the low-address end of the memory, and the high-order bytes are arranged at the high-address end of the memory.
• Big-Endian means that the high-order bytes are arranged at the low-address end of the memory, and the low-order bytes are arranged at the high-address end of the memory.

Network byte order: 32-bit values ​​of 4 bytes are transmitted in the following order: first 0 to 7 bits, then 8 to 15 bits, then 16 to 23 bits, and finally 24 to 31 bits. This transmission order is called big-endian byte order. Since all binary integers in the TCP/IP header are required to be transmitted in this order on the network, it is also called network byte order. Byte order, as the name implies, is the order of bytes, which is the order in which data larger than one byte is stored in memory. There is no order problem for one-byte data.

Therefore: when binding an address to a socket, please convert the host byte order to the network byte order first, and do not assume that the host byte order is the same as the network byte order, which is Big-Endian. This problem has caused a bloody incident! Due to this problem in the company's project code, many inexplicable problems have occurred, so please remember not to make any assumptions about the host byte order, and be sure to convert it to the network byte order before assigning it to the socket.

(3) listen(), connect() functions

If it is used as a server, after calling socket() and bind(), it will call listen() to listen to the socket. If the client calls connect() to send a connection request at this time, the server will receive the request.

 int listen(int sockfd, int backlog);int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

The first parameter of the listen function is the socket descriptor to be listened, and the second parameter is the maximum number of connections that the corresponding socket can queue. The socket created by the socket() function is an active type by default, and the listen function changes the socket to a passive type, waiting for the client's connection request.

The first parameter of the connect function is the client's socket description word, the second parameter is the server's socket address, and the third parameter is the length of the socket address. The client establishes a connection with the TCP server by calling the connect function.

(4) accept() function

After the TCP server calls socket(), bind(), and listen() in sequence, it will listen to the specified socket address. After the TCP client calls socket() and connect() in sequence, it sends a connection request to the TCP server. After the TCP server listens to this request, it will call the accept() function to receive the request, and the connection is established. After that, you can start network I/O operations, which are similar to the read and write I/O operations of ordinary files.

 int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

The first parameter of the accept function is the server's socket descriptor, the second parameter is a pointer to struct sockaddr *, which is used to return the client's protocol address, and the third parameter is the length of the protocol address. If accpet succeeds, the return value is a new descriptor automatically generated by the kernel, representing the TCP connection to the returning client.

Note: The first parameter of accept is the server's socket descriptor, which is generated when the server starts calling the socket() function, called the listening socket descriptor; and the accept function returns the connected socket descriptor. A server usually only creates one listening socket descriptor, which exists throughout the life cycle of the server. The kernel creates a connected socket descriptor for each client connection accepted by the server process. When the server completes the service for a client, the corresponding connected socket descriptor is closed.

(5) read(), write() and other functions

Everything is ready, and the connection between the server and the client has been established. You can call network I/O to perform read and write operations, which means that communication between different processes in the network is realized! There are several groups of network I/O operations:

• read()/write()
• recv()/send()
• readv()/writev()
• recvmsg()/sendmsg()
• recvfrom()/sendto()

I recommend using the recvmsg()/sendmsg() functions, which are the most common I/O functions. In fact, you can replace all the other functions above with these two functions. Their declarations are as follows:

 #include < unistd.h > ssize_t read(int fd, void *buf, size_t count); ssize_t write(int fd, const void *buf, size_t count); #include < sys /types.h > #include < sys /socket.h > ssize_t send(int sockfd, const void *buf, size_t len, int flags); ssize_t recv(int sockfd, void *buf, size_t len, int flags); ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen); ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);       ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags); ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

The read function is responsible for reading the contents from fd. When the read is successful, read returns the number of bytes actually read. If the returned value is 0, it means that the end of the file has been read. If it is less than 0, it means an error has occurred. If the error is EINTR, it means that the read is caused by an interrupt. If it is ECONNREST, it means that there is a problem with the network connection.

The write function writes the nbytes bytes in buf to the file descriptor fd. If successful, it returns the number of bytes written. If failed, it returns -1 and sets the errno variable. In a network program, there are two possibilities when we write to a socket file descriptor. 1) The return value of write is greater than 0, indicating that part or all of the data has been written. 2) The return value is less than 0, which means an error has occurred. We need to handle it according to the error type. If the error is EINTR, it means an interrupt error occurred during writing. If it is EPIPE, it means there is a problem with the network connection (the other party has closed the connection).

I will not introduce these I/O function pairs one by one. For details, please refer to the man document or Baidu or Google. The following example will use send/recv.

(6) close() function

After the server and the client establish a connection, some read and write operations will be performed. After the read and write operations are completed, the corresponding socket descriptor must be closed, just like calling fclose to close the open file after operating the open file.

 #include < unistd.h > int close(int fd);

The default behavior of close a TCP socket is to mark the socket as closed and then immediately return to the calling process. The descriptor can no longer be used by the calling process, that is, it can no longer be used as the first parameter of read or write.

Note: The close operation only reduces the reference count of the corresponding socket descriptor by 1. Only when the reference count reaches 0 will the TCP client be triggered to send a connection termination request to the server.

4. Detailed explanation of TCP three-way handshake to establish connection in socket

We know that TCP needs to perform a "three-way handshake" to establish a connection, that is, to exchange three packets. The general process is as follows:

• The client sends a SYN J to the server.
• The server responds to the client with a SYN K and confirms SYN J with ACK J+1
• The client then sends a confirmation ACK K+1 to the server

Only the three-way handshake is completed, but in which functions of the socket does this three-way handshake occur? Please see the following figure:

Figure 1. TCP three-way handshake sent in the socket

As can be seen from the figure, when the client calls connect, the connection request is triggered and a SYN J packet is sent to the server. At this time, connect enters a blocked state; the server monitors the connection request, that is, receives the SYN J packet, calls the accept function to receive the request and sends SYN K and ACK J+1 to the client. At this time, accept enters a blocked state; after the client receives SYN K and ACK J+1 from the server, connect returns and confirms SYN K; when the server receives ACK K+1, accept returns, and the three-way handshake is completed and the connection is established.

Summary: The client's connect is returned in the second of the three-way handshake, and the server's accept is returned in the third of the three-way handshake.

5. Detailed explanation of TCP's four-way handshake to release the connection in socket

The above introduces the process of establishing a TCP three-way handshake in a socket and the socket functions involved. Now let's introduce the process of releasing a connection in a socket using a four-way handshake. Please see the figure below:

Figure 2. TCP four-way handshake sent in the socket

The process is shown in the figure below:

• An application process first calls close to actively close the connection, and TCP sends a FIN M;
• After receiving FIN M, the other end performs a passive close and confirms the FIN. Its receipt is also passed to the application process as the end-of-file symbol, because the receipt of FIN means that the application process will no longer receive additional data on the corresponding connection;
• After a while, the application process that receives the end-of-file character calls close to close its socket. This causes its TCP to also send a FIN N;
• The source sending TCP that receives this FIN confirms it.

This way there is a FIN and ACK in each direction.

6. Here is an example of implementation

First, let's take a screenshot of the implementation.

The server-side code is as follows:

 #include "InitSock.h"
 #include < stdio.h >  
 #include < iostream >  
 using namespace std;
 CInitSock initSock; // Initialize the Winsock library
 int main()
 {
 // Create a socket string
 SOCKET sListen = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 //Used to specify the address format used by the socket, usually using AF_INET
 //Specify the socket type. If it is SOCK_DGRAM, UDP unreliable transmission is used
 //Used with the type parameter to specify the protocol type to use (when specifying the socket type, it can be set to 0 because the default is UDP or TCP)
 if( sListen == INVALID_SOCKET)
 {
 printf("Failed socket() \n");
 return 0;
 }
 // Fill in the sockaddr_in structure, which is a structure
 /* struct sockaddr_in {
 short sin_family; //Address family (specify address format), set to AF_INET
 u_short sin_port; //Port number
 struct in_addr sin_addr; //IP address
 char sin_zero[8]; //Empty subsection, set to empty
 } */
 sockaddr_in sin;
 sin.sin_family = AF_INET ;
 sin.sin_port = htons (4567); //1024 ~ 49151: port number registered by ordinary users
 sin.sin_addr.S_un.S_addr = INADDR_ANY ;
 // Bind this socket to a local address
 if(::bind(sListen, (LPSOCKADDR)&sin, sizeof(sin)) == SOCKET_ERROR)
 {
 printf("Failed bind() \n");
 return 0;
 }
 // Enter monitoring mode
 //2 refers to the maximum number of unprocessed connections allowed in the listening queue
 if(::listen(sListen, 2) == SOCKET_ERROR)
 {
 printf("Failed listen() \n");
 return 0;
 }
 // Loop to accept client connection requests
 sockaddr_in remoteAddr;
 int nAddrLen = sizeof (remoteAddr);
 SOCKET sClient = 0 ;
 char szText[] = "TCP Server Demo! \r\n";
 while( sClient == 0)
 {
 // Accept a new connection
 //(SOCKADDR*)&remoteAddr) A pointer to the sockaddr_in structure, used to obtain the other party's address
 sClient = ::accept(sListen, (SOCKADDR*)&remoteAddr, &nAddrLen);
 if( sClient == INVALID_SOCKET)
 {
 printf("Failed accept()");
 }
 printf("Received a connection: %s \r\n", inet_ntoa(remoteAddr.sin_addr));
 continue ;
 }
 while(TRUE)
 {
 // Send data to the client
 gets(szText);
 ::send(sClient, szText, strlen(szText), 0);
 // Receive data from the client
 char buff[256] ;
 int nRecv = ::recv(sClient, buff, 256, 0);
 if(nRecv > 0)
 {
 buff[nRecv] = '\0';
 printf("Received data: %s\n", buff);
 }
 }
 // Close the connection with the client
 ::closesocket(sClient);
 // Close the listening socket
 ::closesocket(sListen);
 return 0;
 }

Client code:

 #include "InitSock.h"
 #include < stdio.h >  
 #include < iostream >  
 using namespace std;
 CInitSock initSock; // Initialize the Winsock library
 int main()
 {
 // Create a socket string
 SOCKET s = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 if( s == INVALID_SOCKET)
 {
 printf(" Failed socket() \n");
 return 0;
 }
 // You can also call the bind function here to bind a local address
 // Otherwise the system will automatically arrange
 //Fill in the remote address information
 sockaddr_in servAddr;
 servAddr.sin_family = AF_INET ;
 servAddr.sin_port = htons (4567);
 // Note that you need to fill in the IP address of the machine where the server program (TCPServer program) is located.
 // If your computer is not connected to the Internet, just use 127.0.0.1
 servAddr.sin_addr.S_un.S_addr = inet_addr ("127.0.0.1");
 if(::connect(s, (sockaddr*)&servAddr, sizeof(servAddr)) == -1)
 {
 printf(" Failed connect() \n");
 return 0;
 }
 char buff[256];
 char szText[256] ;
 while(TRUE)
 {
 // Receive data from the server
 int nRecv = ::recv(s, buff, 256, 0);
 if(nRecv > 0)
 {
 buff[nRecv] = '\0';
 printf("Received data: %s\n", buff);
 }
 // Send data to the server
 gets(szText);
 szText[255] = '\0';
 ::send(s, szText, strlen(szText), 0);
 }
 // Close the socket
 ::closesocket(s);
 return 0;
 }

Encapsulated InitSock.h:

 #include < winsock2.h >  
 #include < stdlib.h >  
 #include < conio.h >  
 #include < stdio.h >  
 #pragma comment(lib, "WS2_32") // Link to WS2_32.lib
 class CInitSock
 {
 public:
 CInitSock(BYTE minorVer = 2 , BYTE majorVer = 2 )
 {
 // Initialize WS2_32.dll
 WSADATA wsaData;
 WORD sockVersion = MAKEWORD (minorVer, majorVer);
 if(::WSAStartup(sockVersion, &wsaData) != 0)
 {
 exit(0);
 }
 }
 ~CInitSock()
 {
 ::WSACleanup();
 }
 };