Socket is often used in development programs. Novices and novices generally use functions such as select, recv, send, etc. In most cases, these functions are almost the same. Further development will find that the ready-made socket function does not provide the function of detecting whether the socket is healthy or not, and there is no ready-made method available for the usual data. This paper provides a scheme, which has been preliminarily tested under windows and linux, and the effect is good. It must be stated first that socket communication is duplex (if readers don't understand this, they can check the relevant information first). Therefore, the health status of socket is divided into two directions, one is the direction you send and the other is the direction you receive (recv). Only when both directions are closed can the socket be truly closed, and only when both directions are healthy can the socket be truly healthy. What is really hard to detect is actually this semi-healthy socket. Of course, we can also think that if we can clearly detect the status in two directions, then the health status of this socket will naturally be clear. Ok, let's understand the meaning of the return values of the three functions mentioned above. The function name returns a value of select 0: timeout-1:socket error >; 0: the data has reached send0: the sending buffer is full-1: socket error > 0: the number of bytes sent to the buffer this time recv0: the other party has actively closed this socket-1: socket error > 0: the number of bytes successfully received this time. It should be said that the health of your sending direction is controlled by you. As long as you don't actively call close or closesocket, it is healthy. If you close the socket in this direction, you can remember it in principle. If you really can't remember, getsockname/ getpeername can help you check its status, and they will return the IP address and port number of this socket. If they return-1, it means that you have actively closed the sending direction of this socket. Trouble actively turned off his sending direction at the other end. In your opinion, your receiving (recv) direction was turned off. Theoretically, this closing action at the other end can happen at any time, without prior notice or afterwards notice, so you can only try to detect it. Simply put, when your receiver (recv) is turned off, your select will return >; 0 (indicating that the other party has sent data), your recv will return to 0 (indicating that the other party has actively turned off your receiving recv direction). When these two values are combined, it means that the other party did send data to you after actively disconnecting, but unfortunately, the size of your connection is 0 bytes. There are a lot of information about several states of socket on the Internet, so you can check it yourself. The above method can be used in common practice, but if you want to detect the status of the socket in recv direction, you need another skill. Recv usually takes data from the buffer, so when you just want to check the status and don't want to take data, you should learn to use the fourth parameter of recv. Normally it is 0, but when it is MSG_PEEK, it means peeking, that is, looking at some bytes in front of the buffer, rather than taking them away from the buffer. In this scheme, just peek at 1 byte, and if it returns 0, it means that the other party has initiated the shutdown. Let's summarize the whole process of simply detecting the health status of socket.
1, use getsockname/ getpeername to check the status of your sending direction, if you don't know whether you have actively closed this direction;
2. Use select and RECV (,1, msg _ peek) to * * * detect the status of your recv direction. In particular, the state of socket is actually divided into several types.