wip put poll version inside luke version

README.md

@@ -81,12 +81,15 @@
 
 
 ```
+  functions action in this scenario :
        ______
   sd = SOCKET()     : create a listening socket descriptor
   __________
   SETSOCKOPT(sd)    : allow socket descriptor to be reuseable
   _____
   IOCTL(sd)         : set listening socket and all incoming socket to be non-blocking
+  _____
+  FCNTL(sd)         : set listening socket and all incoming socket to be non-blocking
   ____
   BIND(port)        : associate listening socket to a port
   ______
@@ -138,6 +141,7 @@ compare architectures :
   .                   |  .  loop through fds[]      |  .  loop i++ < max_fd
   .                   |  .  .                       |  .  .
   .                   |  .  .  POLLIN && lstn_sd ?  |  .  .  FD_ISSET(i) & lstn_fd ?
+  .                   |  .  .  loop                 |  .  .  loop
   .  ______           |  .  .  .           ______   |  .  .  .           ______
   .  ACCEPT()         |  .  .  .  new_sd = ACCEPT() |  .  .  .  new_sd = ACCEPT()
   .                   |  .  .  .                    |  .  .  .
@@ -145,7 +149,8 @@ compare architectures :
   .                   |  .  .                       |  .  .  .
   .                   |  .  .                       |  .  .  .  max_sd = new_sd
   .                   |  .  .                       |  .  .
-  .                   |  .  .  POLLIN ?             |  .  .  FD_ISSET ?
+  .                   |  .  .  or POLLIN ?          |  .  .  or FD_ISSET ?
+  .                   |  .  .  loop                 |  .  .  loop
   .  ____             |  .  .  .  ____              |  .  .  .  ____
   .  RECV()           |  .  .  .  RECV()            |  .  .  .  RECV()
   .  ____             |  .  .  .  ____              |  .  .  .  ____
@@ -156,5 +161,10 @@ compare architectures :
   .  CLOSE(fds[])     |  .  CLOSE(fds[])            |  .  CLOSE(fds[])   
 
 
+first, create the socket, add some options, bind it, and listen to it.
+then, do a loop starting with POLL or SELECT
+  if it's incomming connexions, accept and add them all to the list
+  if it's accepted connexions, read their datas and write new datas
+
 ```
 

srcs/Webserv.cpp

@@ -3,30 +3,41 @@
 
 Webserv::Webserv()
 {
+	int	on = 1;
+
 	std::cout << "Server init\n";
-	// _socket_fd = ::socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
+
-	_socket_fd = ::socket(AF_INET, SOCK_STREAM, 0);
+	//_socket_fd = ::socket(AF_INET, SOCK_STREAM, 0);
+	_socket_fd = ::socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
 	if (_socket_fd == -1)
 	{
-		::perror("err socket(): ");
+		::perror("err socket()");
 		throw std::runtime_error("Socket init");
 	}
+
+	// allow socket descriptor to be reuseable
+	if (setsockopt(_socket_fd, SOL_SOCKET,  SO_REUSEADDR, (char *)&on, sizeof(on)) < 0)
+	{
+		::perror("setsockopt() failed");
+		throw std::runtime_error("Socket init");
 	}
 
-/* Webserv::Webserv(Webserv const &src)
+}
-{
 
-} */
+//Webserv::Webserv(Webserv const &src)
+//{
+//	
+//}
 
 Webserv::~Webserv()
 {
 	std::cout << "Server destroyed\n";
 }
 
-/* Webserv &	Webserv::operator=(Webserv const &rhs)
+//Webserv &	Webserv::operator=(Webserv const &rhs)
-{
+//{
-	
+//	
-} */
+//}
 
 
   ///////////////
@@ -34,13 +45,10 @@ Webserv::~Webserv()
 
 void	Webserv::bind(in_port_t port)
 {
-	// cast invalid ? how to ?
-	// const struct sockaddr* cast_test = static_cast<const struct sockaddr*>(addr);
-
 	struct sockaddr_in	addr;
 	addr.sin_family = AF_INET;
 	addr.sin_port = ::htons(port);
-	addr.sin_addr.s_addr = ::htonl(INADDR_ANY); // htonl useless with 0 value (INADDR_ANY)
+	addr.sin_addr.s_addr = ::htonl(INADDR_ANY);
 
 	if (::bind(_socket_fd, (const sockaddr*)&addr, sizeof addr) == -1)
 	{
@@ -61,9 +69,214 @@ void	Webserv::listen(unsigned int max_connections)
 #define BUFSIZE 8192
 #define MSG_TEST "Le Webserv / 20 =D\n"
 #define MSG_BOUNCE "bounced properly ;)\n" // placeholder
+#define TRUE 1
+#define FALSE 0
 
 void	Webserv::start()
 {
+	int					len, rc;
+	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];
+	int					nfds = 1, current_size = 0, i, j;
+
+	memset(fds, 0 , sizeof(fds));
+	fds[0].fd = listen_sd;
+	fds[0].events = POLLIN;
+
+	std::cout << "Server started\n";
+	while (end_server == FALSE)
+	{
+		// ***********************************************************
+		// * 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--;
+				}
+			}
+		}
+	}
+
+
+/*
+
 		struct sockaddr_in	addr;
 		socklen_t 			addr_len;
 		int					accepted_fd;
@@ -71,9 +284,6 @@ void	Webserv::start()
 		char				buf[BUFSIZE]; // WIP buffer. need to try with std::vector or std::string.
 		int					ret;
 
-	std::cout << "Server started\n";
-	while (1)
-	{
 		std::cout << "----------\n";
 		std::cout << "accept()\n";
 		addr_len = sizeof addr;
@@ -102,10 +312,6 @@ void	Webserv::start()
 			::close(accepted_fd);
 			continue;
 		}
-		/*
-		if (ret == BUFSIZE)
-			// send error like "request too long" to client
-		*/
 		buf[ret] = '\0';
 		
 		std::cout << "send()\n";
@@ -115,5 +321,6 @@ void	Webserv::start()
 			::perror("err send(): ");
 
 		::close(accepted_fd);
+*/
 	}
 }

srcs/Webserv.hpp

@@ -4,8 +4,6 @@
 
 # include <string>
 # include <map>
-# include <cerrno> // errno
-# include <cstdio> // perror
 # include <exception>
 # include <stdexcept>
 # include <unistd.h> // close
@@ -19,6 +17,19 @@
 # include <poll.h> // poll
 # include <fcntl.h> // fcntl
 
+# 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
+
 class Webserv
 {
 	public:

srcs/main.cpp

@@ -12,7 +12,7 @@ int	main(void)
 
 		// https://security.stackexchange.com/questions/169213/how-to-chose-a-port-to-run-an-application-on-localhost
 		serv.bind(4040);
-		serv.listen(512); // 512 max connections arbitrary
+		serv.listen(20);
 		serv.start();
 	}
 	catch (std::exception& e)
@@ -22,45 +22,3 @@ int	main(void)
 	return (0);
 }
 
-/*
-
-
-              ______
-  listen_fd = SOCKET() : create a listening socket
-  __________
-  SETSOCKOPT() : Allow socket descriptor to be reuseable
-  _____
-  IOCTL() : set listen_fd and all incoming socket to be non-blocking
-  ____
-  BIND(port) : associate listen_fd to a port
-  ______
-  LISTEN(nb_queue) : queue the incoming connections to listen_fd, up to a chosen number
-
-  fds[1] = listen_fd
-
-  loop
-  .  ____
-  .  POLL(fds[]) : 
-  .
-  .  loop through fds[]
-  .  .
-  .  .  POLLIN && listen_fd ? : readable socket and this is the listening one
-  .  .  .           ______
-  .  .  .  new_fd = ACCEPT() : extract first connection request in queue of listen_fd
-  .  .  .                      and creates a new socket that is connected
-  .  .  .
-  .  .  .  fds[] += new_fd
-  .  .
-  .  .  POLLIN ? : readable socket and this is an active one
-  .  .  .  ____
-  .  .  .  RECV() : read data in socket created by accept()
-  .  .  .  ____
-  .  .  .  SEND() : write data in socket created by accept()
-
-  loop through fds[] :
-  .  _____
-  .  CLOSE(fds[])
-
-
-*/
-

srcs/main_select.cpp

@@ -1,4 +1,6 @@
 
+// https://www.ibm.com/docs/en/i/7.2?topic=designs-example-nonblocking-io-select
+
 # include <unistd.h>		// close
 # include <string.h>
 # include <stdio.h>
@@ -16,7 +18,8 @@
 
 int main ()
 {
-   int    i, len, rc, on = 1;
+	int    i, len, rc;
+	int    on = 1;
 	int    listen_sd, max_sd, new_sd;
 	int    desc_ready, end_server = FALSE;
 	int    close_conn;
@@ -30,6 +33,7 @@ int main ()
 	/* connections on                                            */
 	/*************************************************************/
 	listen_sd = socket(AF_INET6, SOCK_STREAM, 0);
+//	listen_sd = socket(AF_INET6, SOCK_STREAM | SOCK_NONBLOCK, 0);
 	if (listen_sd < 0)
 	{
 		perror("socket() failed");
@@ -39,8 +43,7 @@ int main ()
 	/*************************************************************/
 	/* Allow socket descriptor to be reuseable                   */
 	/*************************************************************/
-   rc = setsockopt(listen_sd, SOL_SOCKET,  SO_REUSEADDR,
+	rc = setsockopt(listen_sd, SOL_SOCKET,  SO_REUSEADDR, (char *)&on, sizeof(on));
-                   (char *)&on, sizeof(on));
 	if (rc < 0)
 	{
 		perror("setsockopt() failed");
@@ -116,7 +119,7 @@ int main ()
 		/**********************************************************/
 		/* Call select() and wait 3 minutes for it to complete.   */
 		/**********************************************************/
-      printf("Waiting on select()...\n");
+		printf("\nWaiting on select()...\n");
 		rc = select(max_sd + 1, &working_set, NULL, NULL, &timeout);
 
 		/**********************************************************/
@@ -163,7 +166,7 @@ int main ()
 				/****************************************************/
 				if (i == listen_sd)
 				{
-               printf("  Listening socket is readable\n");
+					printf("\n  Listening socket is readable\n");
 					/*************************************************/
 					/* Accept all incoming connections that are      */
 					/* queued up on the listening socket before we   */
@@ -211,7 +214,7 @@ int main ()
 				/****************************************************/
 				else
 				{
-               printf("  Descriptor %d is readable\n", i);
+					printf("\n  Descriptor %d is readable\n", i);
 					close_conn = FALSE;
 					/*************************************************/
 					/* Receive all incoming data on this socket      */