One 、 What is Non blocking connect？

The only non blocking we've used before socket The file descriptor is in Server , Using non blocking methods can greatly improve the efficiency of server programs .

Now imagine , We put Client program socket Set to non blocking , So what should I do socket File descriptors connect The connection is easy to report errors . Why? ？ because , Non blocking , The call to the file descriptor directly returns the result , and socket It's hard to connect so fast , So it's easy to call and fail , This will set errno The value of is ：EINPROGRESS. This error type occurs in , For non blocking socket call connect, When the connection is not established . So when connect return -1 when , It doesn't have to be a mistake , Maybe the connection is still in progress ！

The solution to this matter is , call select 、poll Wait for the function to listen for the connection failure socket Writable events on . When select or poll When the function returns , recycling getsockopt Read the error code . If the error code is 0, Just now connect There was no mistake , Connection established successfully , If the error code is 1, Indicates that an error has indeed occurred .

So troublesome to use non blocking connect Is there any benefit ？

By using non blocking connect, We will Can initiate multiple connections at the same time and wait together .

2、 Non blocking connect Example program

The following is a client program , It uses a non blocking socket Connect to server .

#include<sys/socket.h>
#include<sys/types.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<stdio.h>
#include<assert.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>
#include<time.h>
#include<sys/ioctl.h>

#define BUFFER_SIZE 1023

int setnonblocking(int fd)
{
    
	int old_option = fcntl(fd, F_GETFL);
	int new_option = old_option | O_NONBLOCK;
	fcntl(fd, F_SETFL, new_option);
	return old_option;
}

/*  Timeout connection function , The parameters are IP Address , Port number , And overtime ( millisecond ). Successful return of connection status  socket, Failure to return -1 */
int unblock_connect(const char* ip, int port, int time)
{
    
	int ret = 0;
	struct sockaddr_in address;
	bzero(&address, sizeof(address));
	address.sin_family = AF_INET;
	address.sin_port = htons(port);
	inet_pton(AF_INET, ip, &address);

	int sockfd = socket(PF_INET, SOCK_STREAM, 0);
	int fdopt = setnonblocking(sockfd);
	ret = connect(sockfd, (struct sockaddr*)&address, sizeof(address));
	if (ret == 0)										/*  The connection is successful  */
	{
    
		/*  If the connection is successful , Then recover  sockfd  Properties of , And return immediately  */
		printf("connect whit server immediately\n");
		fcntl(sockfd, F_SETFL, fdopt);
		return sockfd;
	}
	else if (errno != EINPROGRESS)		/*  If the error type is not  EINPROGRESS, Indicates that other errors have occurred , Return immediately  */
	{
    
		/*  If the connection is not established immediately , Then only when  errno  yes  EINPROGRESS  The connection is still in progress , Otherwise, an error is returned  */
		printf("unblock connect not support\n");
		return -1;
	}

	fd_set readfds;
	fd_set writefds;
	struct timeval timeout;

	FD_ZERO(&readfds);
	FD_SET(sockfd, &writefds);

	timeout.tv_sec = time;
	timeout.tv_usec = 0;

	ret = select(sockfd + 1, NULL, &writefds, NULL, &timeout);
	if (ret <= 0)
	{
    
		/* select  Timeout or error , Return immediately  */
		printf("connection time out\n");
		close(sockfd);
		return -1;
	}

	if (!FD_ISSET(sockfd, &writefds))	/*  If  sockfd  Don't write , Indicates that the connection failed , Return immediately  */
	{
    
		printf("no events on sockfd found\n");
		close(sockfd);
		return -1;
	}

	int error = 0;
	socklen_t length = sizeof(error);
	/*  call  getsockopt  To get and clear  sockfd  Mistakes on  */
	if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &length) < 0)
	{
    
		printf("connection failed after select with the error: %d\n", error);
		close(sockfd);
		return -1;
	}
	/*  Error number is not  0  Indicates a connection error  */
	if (error != 0)
	{
    
		printf("connection failed after select with the error: %d\n", error);
		close(sockfd);
		return -1;
	}
	/*  Successful connection  */
	printf("connection ready after select with the socket: %d\n", sockfd);
	fcntl(sockfd, F_SETFL, fdopt);
	return sockfd;
}

int main(int argc, char* argv[])
{
    
	if (argc <= 2)
	{
    
		return 1;
	}
	const char* ip = argv[1];
	int port = atoi(argv[2]);

	int sockfd = unblock_connect(ip, port, 10);
	if (sockfd < 0)
	{
    
		return 1;
	}
	close(sockfd);
	return 0;
}