separate main tests in differents files and added comparison in readme
This commit is contained in:
hugogogo
308
srcs/main_poll.cpp
Normal file
308
srcs/main_poll.cpp
Normal file
@@ -0,0 +1,308 @@
|
||||
|
||||
// https://www.ibm.com/docs/en/i/7.2?topic=designs-using-poll-instead-select
|
||||
|
||||
# include <unistd.h> // close
|
||||
# include <stdlib.h> // exit
|
||||
# include <iostream> // cout, cin
|
||||
# include <cerrno> // errno
|
||||
# include <cstdio> // perror
|
||||
# include <string.h> // memset
|
||||
# include <sys/socket.h> // socket, accept, listen, send, recv, bind, connect, setsockopt, getsockname
|
||||
# include <netinet/in.h> // sockaddr_in
|
||||
# include <arpa/inet.h> // inet_ntoa, inet_addr, htonl, htons, ntohl, ntohs
|
||||
# include <poll.h> // poll
|
||||
# include <fcntl.h> // fcntl
|
||||
# include <sys/ioctl.h> // ioctl
|
||||
|
||||
# define FALSE 0
|
||||
# define TRUE 1
|
||||
# define SERVER_PORT 4040
|
||||
|
||||
int main ()
|
||||
{
|
||||
int len, rc, on = 1;
|
||||
int listen_sd = -1, new_sd = -1;
|
||||
int end_server = FALSE, compress_array = FALSE;
|
||||
int close_conn;
|
||||
char buffer[80];
|
||||
struct sockaddr_in addr;
|
||||
struct pollfd fds[200];
|
||||
// struct pollfd fds[1];
|
||||
// struct pollfd fds;
|
||||
int nfds = 1, current_size = 0, i, j;
|
||||
|
||||
// *************************************************************
|
||||
// * Create an AF_INET stream socket to receive incoming *
|
||||
// * connections on *
|
||||
// *************************************************************
|
||||
listen_sd = socket(AF_INET, SOCK_STREAM, 0);
|
||||
if (listen_sd < 0)
|
||||
{
|
||||
perror("socket() failed");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
// *************************************************************
|
||||
// * Allow socket descriptor to be reuseable *
|
||||
// *************************************************************
|
||||
rc = setsockopt(listen_sd, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on));
|
||||
if (rc < 0)
|
||||
{
|
||||
perror("setsockopt() failed");
|
||||
close(listen_sd);
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
// *************************************************************
|
||||
// * Set socket to be nonblocking. All of the sockets for *
|
||||
// * the incoming connections will also be nonblocking since *
|
||||
// * they will inherit that state from the listening socket. *
|
||||
// *************************************************************
|
||||
rc = ioctl(listen_sd, FIONBIO, (char *)&on);
|
||||
if (rc < 0)
|
||||
{
|
||||
perror("ioctl() failed");
|
||||
close(listen_sd);
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
// *************************************************************
|
||||
// * Bind the socket *
|
||||
// *************************************************************
|
||||
memset(&addr, 0, sizeof(addr));
|
||||
addr.sin_family = AF_INET;
|
||||
// memcpy(&addr.sin_addr, &inaddr_any, sizeof(inaddr_any));
|
||||
addr.sin_addr.s_addr = htonl(INADDR_ANY);
|
||||
addr.sin_port = htons(SERVER_PORT);
|
||||
rc = bind(listen_sd, (struct sockaddr *)&addr, sizeof(addr));
|
||||
if (rc < 0)
|
||||
{
|
||||
perror("bind() failed");
|
||||
close(listen_sd);
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
// *************************************************************
|
||||
// * Set the listen back log *
|
||||
// *************************************************************
|
||||
rc = listen(listen_sd, 32);
|
||||
if (rc < 0)
|
||||
{
|
||||
perror("listen() failed");
|
||||
close(listen_sd);
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
// *************************************************************
|
||||
// * Initialize the pollfd structure *
|
||||
// *************************************************************
|
||||
memset(fds, 0 , sizeof(fds));
|
||||
|
||||
// *************************************************************
|
||||
// * Set up the initial listening socket *
|
||||
// *************************************************************
|
||||
fds[0].fd = listen_sd;
|
||||
fds[0].events = POLLIN;
|
||||
|
||||
// *************************************************************
|
||||
// * Loop waiting for incoming connects or for incoming data *
|
||||
// * on any of the connected sockets. *
|
||||
// *************************************************************
|
||||
do
|
||||
{
|
||||
// ***********************************************************
|
||||
// * Call poll() *
|
||||
// ***********************************************************
|
||||
poll(fds, nfds, -1);
|
||||
|
||||
// ***********************************************************
|
||||
// * One or more descriptors are readable. Need to *
|
||||
// * determine which ones they are. *
|
||||
// ***********************************************************
|
||||
current_size = nfds;
|
||||
for (i = 0; i < current_size; i++)
|
||||
{
|
||||
// *********************************************************
|
||||
// * Loop through to find the descriptors that returned *
|
||||
// * POLLIN and determine whether it's the listening *
|
||||
// * or the active connection. *
|
||||
// *********************************************************
|
||||
if(fds[i].revents == 0)
|
||||
continue;
|
||||
|
||||
// *********************************************************
|
||||
// * If revents is not POLLIN, it's an unexpected result, *
|
||||
// * log and end the server. *
|
||||
// *********************************************************
|
||||
if(fds[i].revents != POLLIN)
|
||||
{
|
||||
printf(" Error! revents = %d\n", fds[i].revents);
|
||||
end_server = TRUE;
|
||||
break;
|
||||
|
||||
}
|
||||
if (fds[i].fd == listen_sd)
|
||||
{
|
||||
// *******************************************************
|
||||
// * Listening descriptor is readable. *
|
||||
// *******************************************************
|
||||
printf(" Listening socket is readable\n");
|
||||
|
||||
// *******************************************************
|
||||
// * Accept all incoming connections that are *
|
||||
// * queued up on the listening socket before we *
|
||||
// * loop back and call poll again. *
|
||||
// *******************************************************
|
||||
do
|
||||
{
|
||||
// *****************************************************
|
||||
// * Accept each incoming connection. If *
|
||||
// * accept fails with EWOULDBLOCK, then we *
|
||||
// * have accepted all of them. Any other *
|
||||
// * failure on accept will cause us to end the *
|
||||
// * server. *
|
||||
// *****************************************************
|
||||
new_sd = accept(listen_sd, NULL, NULL);
|
||||
if (new_sd < 0)
|
||||
{
|
||||
if (errno != EWOULDBLOCK)
|
||||
{
|
||||
perror(" accept() failed");
|
||||
end_server = TRUE;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
// *****************************************************
|
||||
// * Add the new incoming connection to the *
|
||||
// * pollfd structure *
|
||||
// *****************************************************
|
||||
printf(" New incoming connection - %d\n", new_sd);
|
||||
fds[nfds].fd = new_sd;
|
||||
fds[nfds].events = POLLIN;
|
||||
nfds++;
|
||||
|
||||
// *****************************************************
|
||||
// * Loop back up and accept another incoming *
|
||||
// * connection *
|
||||
// *****************************************************
|
||||
} while (new_sd != -1);
|
||||
}
|
||||
|
||||
// *********************************************************
|
||||
// * This is not the listening socket, therefore an *
|
||||
// * existing connection must be readable *
|
||||
// *********************************************************
|
||||
|
||||
else
|
||||
{
|
||||
printf(" Descriptor %d is readable\n", fds[i].fd);
|
||||
close_conn = FALSE;
|
||||
// *******************************************************
|
||||
// * Receive all incoming data on this socket *
|
||||
// * before we loop back and call poll again. *
|
||||
// *******************************************************
|
||||
|
||||
do
|
||||
{
|
||||
// *****************************************************
|
||||
// * Receive data on this connection until the *
|
||||
// * recv fails with EWOULDBLOCK. If any other *
|
||||
// * failure occurs, we will close the *
|
||||
// * connection. *
|
||||
// *****************************************************
|
||||
rc = recv(fds[i].fd, buffer, sizeof(buffer), 0);
|
||||
if (rc < 0)
|
||||
{
|
||||
if (errno != EWOULDBLOCK)
|
||||
{
|
||||
perror(" recv() failed");
|
||||
close_conn = TRUE;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
// *****************************************************
|
||||
// * Check to see if the connection has been *
|
||||
// * closed by the client *
|
||||
// *****************************************************
|
||||
if (rc == 0)
|
||||
{
|
||||
printf(" Connection closed\n");
|
||||
close_conn = TRUE;
|
||||
break;
|
||||
}
|
||||
|
||||
// *****************************************************
|
||||
// * Data was received *
|
||||
// *****************************************************
|
||||
len = rc;
|
||||
printf(" %d bytes received\n", len);
|
||||
|
||||
// *****************************************************
|
||||
// * Echo the data back to the client *
|
||||
// *****************************************************
|
||||
rc = send(fds[i].fd, buffer, len, 0);
|
||||
if (rc < 0)
|
||||
{
|
||||
perror(" send() failed");
|
||||
close_conn = TRUE;
|
||||
break;
|
||||
}
|
||||
|
||||
} while(TRUE);
|
||||
|
||||
// *******************************************************
|
||||
// * If the close_conn flag was turned on, we need *
|
||||
// * to clean up this active connection. This *
|
||||
// * clean up process includes removing the *
|
||||
// * descriptor. *
|
||||
// *******************************************************
|
||||
if (close_conn)
|
||||
{
|
||||
close(fds[i].fd);
|
||||
fds[i].fd = -1;
|
||||
compress_array = TRUE;
|
||||
}
|
||||
|
||||
|
||||
} // End of existing connection is readable
|
||||
} // End of loop through pollable descriptors
|
||||
|
||||
// ***********************************************************
|
||||
// * If the compress_array flag was turned on, we need *
|
||||
// * to squeeze together the array and decrement the number *
|
||||
// * of file descriptors. We do not need to move back the *
|
||||
// * events and revents fields because the events will always*
|
||||
// * be POLLIN in this case, and revents is output. *
|
||||
// ***********************************************************
|
||||
if (compress_array)
|
||||
{
|
||||
compress_array = FALSE;
|
||||
for (i = 0; i < nfds; i++)
|
||||
{
|
||||
if (fds[i].fd == -1)
|
||||
{
|
||||
for(j = i; j < nfds; j++)
|
||||
{
|
||||
fds[j].fd = fds[j+1].fd;
|
||||
}
|
||||
i--;
|
||||
nfds--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} while (end_server == FALSE); // End of serving running.
|
||||
|
||||
// *************************************************************
|
||||
// * Clean up all of the sockets that are open *
|
||||
// *************************************************************
|
||||
for (i = 0; i < nfds; i++)
|
||||
{
|
||||
if(fds[i].fd >= 0)
|
||||
close(fds[i].fd);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user