English
English
When operating network sockets in PHP, error handling has always been a headache. PHP provides a function socket_clear_error() , but the official documentation explains its usage scenarios very briefly, which makes many developers unclear when to use this function.
This article will combine actual cases to help you sort out the applicable scenarios of socket_clear_error() , and give examples of how to use it to handle socket errors more elegantly.
socket_clear_error() is a function in PHP's socket extension that is specifically used to clean up the current socket connection error status. Simply put, it can "reset" the error flag of the socket connection.
In the official document, socket_clear_error() only writes the function signature and a sentence description:
bool socket_clear_error ( resource $socket )
Clear the socket error status.
But it does not specify when it needs to be called, or what effect it will bring.
During the network transmission process, various errors may occur, such as disconnection, failure to send data, and network blockage. The socket function in PHP usually returns false and sets an error code. We use socket_last_error() to get the error code, and then use socket_strerror() to convert it into readable information.
However, these error messages will "continue" until manually cleaned up, otherwise subsequent socket operations may be affected by the previous error, resulting in misjudgment.
To give a simple example:
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
socket_connect($socket, 'm66.net', 80);
socket_write($socket, "GET / HTTP/1.1\r\nHost: m66.net\r\n\r\n");
$errorCode = socket_last_error($socket);
if ($errorCode !== 0) {
echo "An error occurred：" . socket_strerror($errorCode) . PHP_EOL;
socket_clear_error($socket); // Clean up the error status，Avoid affecting subsequent operations
}
// Continue to use $socket Do something else
If socket_clear_error() is not called, subsequent calls to socket_last_error() may also return the previous error code, causing confusion in logical judgment.
In non-blocking mode, the socket operation will not wait for completion, and sometimes the error code EAGAIN or EWOULDBLOCK is returned to indicate that the data is temporarily unavailable. This error is not a real failure, it just tells the program to try again later.
If the error state is not cleaned, the program will mistakenly think that there is a problem with the connection, causing the connection to be closed in advance.
socket_set_nonblock($socket);
while (true) {
$data = socket_read($socket, 2048);
if ($data === false) {
$err = socket_last_error($socket);
if ($err === SOCKET_EAGAIN || $err === SOCKET_EWOULDBLOCK) {
socket_clear_error($socket);
// No data at the moment，Try again later
usleep(100000);
continue;
} else {
// Other errors，Process or exit
break;
}
}
echo $data;
}
A socket connection held for a long time may encounter temporary errors multiple times. In order to ensure that subsequent operations will not fail due to previous error status, it is a good habit to call socket_clear_error() after the operation is completed.
socket_clear_error() is a function to clean up the current error state of the socket.
It is often used in non-blocking socket programming to avoid misjudgment caused by temporary unavailability (EAGAIN/EWOULDBLOCK).
In connection multiplexing or long connection scenarios, it can also be used to ensure that the error status is reset and subsequent operations are normal.
If it is not called, the error status will be retained, causing socket_last_error() to return an expired error code, affecting the business logic.
<?php
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
if (!$socket) {
die("Unable to create socket: " . socket_strerror(socket_last_error()) . PHP_EOL);
}
if (!socket_connect($socket, 'm66.net', 80)) {
die("Connection failed: " . socket_strerror(socket_last_error($socket)) . PHP_EOL);
}
socket_set_nonblock($socket);
$request = "GET / HTTP/1.1\r\nHost: m66.net\r\nConnection: close\r\n\r\n";
socket_write($socket, $request);
while (true) {
$data = socket_read($socket, 2048);
if ($data === false) {
$err = socket_last_error($socket);
if ($err === SOCKET_EAGAIN || $err === SOCKET_EWOULDBLOCK) {
socket_clear_error($socket);
usleep(100000); // wait 0.1 Read again in seconds
continue;
} else {
echo "Read error：" . socket_strerror($err) . PHP_EOL;
break;
}
} elseif ($data === '') {
// Connection closes
break;
}
echo $data;
}
socket_close($socket);
This code demonstrates how to use socket_clear_error() to ignore temporary data-free errors in non-blocking mode and successfully read the HTTP response.
In this way, the role and usage of socket_clear_error() will be clear. Remember to clean up the error status in a timely manner in non-blocking, long connection and other scenarios, which can make your socket program more robust.
