Basic knowledge of socket simple network communication program

Time:2021-1-27

1. What is socket

 Socket, simply speaking, is the combination of IP address and port, which can communicate with the application of remote hostA host can be determined by IP address, and an application can be determined by port. IP + port can completely determine an application of a host. Socket originated from UNIX, similar to a special file, can be opened, closed, read and write operations. In a word, with socket, we can communicate with the host on the network.

2. TCP / UDP protocol

  To carry out network communication, it is necessary to carry out certain rules. TCP / UDP is such a protocol, which stipulates the rules of communication.

 TCP is a reliable, connection oriented two-way data transfer protocol.Reliability means that data will not be repeated or lost. Whenever the sender sends a data to the receiver, if the receiver receives the data, it will send a confirmation message to the sender, saying “I have received the data, you can send the next data”. After receiving the confirmation message, the sender will send the next data. In this way, the accuracy of the information can be determined. Two way transmission means that both sides can act as sender or receiver.

 UDP is an unreliable, connectionless two-way transport protocol. UDP protocolJust send data, will not confirm whether you have received, only responsible for sending, not responsible for confirmation, so it is not reliable. UDP is suitable for the transmission of video and the like. Even if the video loses one or two frames, it will not have much impact.

Socket can be based on TCP or UDP, which can be selected according to the demand.

 

3. A simple communication program

  Use a simple example to illustrate the usage of socket. Socket program is generally divided into two parts, one is the server, the other is the client

The following describes the server-side creation process

 1) First of all, there must be a socket to communicate. The function to create a socket is

 

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

AF: refers to the address family. AF is commonly used_ INET means to use IPv4 address, AF_ Inet6 indicates using IPv6 address

Type: the common transmission type is sock_ STREAM ,SOCK_ Dgram, streaming transmission, message transmission

Protocol: the commonly used protocol to use is “ipproto”_ TCP and ipptoto_ UDP refers to TCP and UDP protocol respectively

Returns a socket descriptor, which is an integer.

  2) Using bind() function to determine various socket attributes

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

Socket: socket to bind

Addr: SOCKADDR address structure, which contains the protocol used, IP address, port, etc. Set your own

Addrlen: the size of SOCKADDR, which can be obtained by sizeof()

The following code shows the process of creating a socket and binding

//Use IPv4 address, TCP protocol
 serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 SOCKADDR_IN addr;
 addr.sin_ addr.S_ un.S_ addr = htonl(ADDR_ Any); // indicates that any IP connection will be accepted
 addr.sin_ family = AF_ INET; // use IPv4 address
 addr.sin_ Port = htons (6666); // use port 6666
 Bind (ServerSocket, & addr, sizeof (SOCKADDR)); // bind the socket to port 6666 and set the IP to be received

 3) . listen function listen

After setting the properties, the server can start listening to monitor whether there is a client request connection.

Function prototype

 int listen(int sock, int backlog); 

Socket: socket

Backlog: how many customer service connections are allowed

 4) The. Accept function waits for a connection

Accept is a blocking function. If there is no client clearing, the connection will wait here all the time

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

Socket: socket,

addr:SOCKADDR structural morphology

addrlen:addr The length of can be obtained by sizeof

  Pay attention to the return value of this function. It will return a new socket. This new socket is used to communicate with the client. The previous socket is a listening socket. You should distinguish it clearly.

5) . send / recv send / receive information

  After successful connection with the client, you can communicate. The functions that can communicate include write / read, send / recv, etc. Here we introduce send / recv

 int send(int sockfd, const char *buf, size_t len, int flags);
 
 int recv(int sockfd, char*buf, size_t len, int flags);

Sockfd: socket

BUF: buffer for sending data

Len: length of sent data

Flags: flag, usually zero

  6) The. Closesocket function closes the socket

  Closesocket() closes the socket

  Here is a complete server-side code

#include
 #include
 #pragma comment (lib,"ws2_32.lib")
 int main()
 {
     Socket ServerSocket; // monitored socket
     Socket newsocket; // socket used for communication
     SOCKADDR_ In newaddr; // saves the socket address information of the client
     SOCKADDR_ In addr; // address structure, including IP port
 
     WSADATA data;    
     Word version; // socket version
     int info;
     Char buf [32]; // data buffer
     /*
        Before using socket, we need to set and initialize the version
        Don't worry if you don't understand
     */
     Version = makeword (2,2); // set version
     info = WSAStartup(version, &data);
     /*An application or DLL can only run after a successful wsastartup() call
            To call further Windows Sockets API functions.
         Initialize windows socket according to the version, and return 0 to indicate success
     */
 
     if (info != 0)
     {
         Printf ("initialization failed";
         return -1;
     }
     if (LOBYTE(data.wVersion) != 2 || HIBYTE(data.wVersion) != 2)
     {    
         Printf ("load failed";
         WSACleanup();
         return 0;
     }
      //Create socket, use TCP protocol
     serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
     addr.sin_ addr.S_ un.S_ addr = htonl(ADDR_ Any); // indicates that any IP connection will be accepted
     addr.sin_ family = AF_ INET; // use the IPv4 address
     addr.sin_ Port = htons (6666); // set the port occupied by the application
     Bind (ServerSocket, & addr, sizeof (SOCKADDR)); // bind the socket to the IP received on port 6666
     Listen (ServerSocket, 3); // start listening. Is there a connection request from the customer service
     Printf ("start listening, wait for connection......";
     int len = sizeof(SOCKADDR);
     newSocket=accept(serverSocket, (SOCKADDR*)&newAddr,&len);
     Sprintf (buf, "welcome user connection for% s", INET_ ntoa( newAddr.sin_ addr));
     Send (newsocket, buf, 32, 0); // send message
     Printf ("connection successful, start sending message......";
     Recv (newsocket, buf, 32, 0); // receive information
     Printf ("received information is% s / N", buf));
     Closesocket (newsocket); // close socket
 }

 

Running results

  

 

  Client example

  The client is different from the server. The server is waiting for the connection, while the client is actively connecting, so the client does not listen or accept.

The client has a connect function to actively connect to the server. The rest is about the same

 int connect(int sock, struct sockaddr *serv_addr, socklen_t addrlen);

Socket: socket

serv_ addr:SOCKADDR structural morphology

addrlen:serv_ The length of addr can be obtained by sizeof

 Client code

  

#include
 #include
 #pragma comment(lib,"Ws2_32.lib")
 
 int main()
 {
     SOCKET clientSocket;
     SOCKADDR_IN addr;
     int len;
     char buf[32];
     int info;
     WSADATA data;
     WORD version;
     //Setting version and initialization
     version = MAKEWORD(2, 2);
     info = WSAStartup(version, &data);
     if (info != 0)
     {
         Printf ("initialization failed";
         return -1;
     }
     if (LOBYTE(data.wVersion) != 2 || HIBYTE(data.wVersion) != 2)
     {
         Printf ("load failed";
         WSACleanup();
         return 0;
     }
     
     clientSocket = socket(AF_ INET, SOCK_ Stream, 0); // create socket
     //The IP of the server to be connected, because the server is the local machine now, so write the local IP
     //127.0.0.1 a special IP address, which means the IP address of the machine
     addr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
     //The port should be the same as the server, otherwise it cannot be found
     addr.sin_port = htons(6666);
     //Use IPv4 address
     addr.sin_family = AF_INET;
     //Active connection server
     connect(clientSocket,(SOCKADDR*)&addr,sizeof(SOCKADDR));
     //Receive data sent by service
     Recv (ClientSocket, buf, 32, 0); // receive data
     Printf ("the message sent by the server is% s / N", buf));
     Sprintf (buf, '% s','Hello, server');
     //Send data
     send(clientSocket, buf, 32, 0);
     //Close socket
     closesocket(clientSocket);
     return 0;
 
 }

 

 

 

 

Start the server first, then the client. A simple communication is done

      

 

 

 

Do this simple example, for socket should have a preliminary understanding, at least should learn how to use.

Next time use socket to write a simple chat program to further deepen the understanding of socket.

 

Recommended Today

Don’t be a tool man. Touching hands teaches you Jenkins!

Hello everyone, I’m a piece of cake, a piece of cake eager to be Cai Bucai in the Internet industry. Soft or hard, praise is soft, white whoring is just!Ghost ~ remember to give me a third company after watching it! This article mainly introducesJenkins If necessary, please refer to If it helps, don’t forgetgive […]