merge master

Makefile

@@ -9,10 +9,14 @@ CXXFLAGS	+=	-g
 CXXFLAGS	+=	-MMD -MP #header dependencie
 #CXXFLAGS	+=	-O3
 
+#SHELL		 =	/bin/zsh
 VPATH		 =	$(SRCS_D)
 
 HEADERS		 =	$(HEADERS_D:%=-I%)
-HEADERS_D	 =	headers
+HEADERS_D	 =	srcs
+#HEADERS	 =	Webserv.hpp \
+				Client.hpp \
+				Server.hpp
 
 SRCS_D		 =	srcs
 SRCS		 =	main.cpp \

headers/Webserv.hpp

@@ -2,12 +2,14 @@
 #ifndef WEBSERV_HPP
 # define WEBSERV_HPP
 
-# include <string>
 # include <map>
-# include <cerrno>			// errno
+# include <vector>
-# include <cstdio>			// perror
 # include <exception>
 # include <stdexcept>
+# include <string>
+# include <sstream>			// stringstream
+# include <cerrno>			// errno
+# include <cstdio>			// perror
 # include <unistd.h>		// close
 # include <iostream>		// cout, cin
 # include <cstring>			// memset
@@ -17,13 +19,15 @@
 # include <sys/epoll.h>		// epoll
 # include <fcntl.h>			// fcntl
 # include <sys/wait.h>		// waitpid
-# include <sstream>			// stringstream
+# include <csignal>			// signal
+
+# include "Client.hpp"
+# include "Server.hpp"
 
 # define BUFSIZE 8192
 # define TIMEOUT 10 * 1000
 # define MAX_EVENTS 42 // arbitrary
 # define MSG_TEST "Le Webserv / 20 =D\n"
-#define MSG_BOUNCE "bounced properly ;)\n" // placeholder
 
 class Webserv
 {
@@ -37,20 +41,26 @@ class Webserv
 		void	start();
 
 	private:
-		int	_socket_fd; // TODO: replace with vector of "Server" struct
 		int	_epfd;
+		int	_socket_fd; // temp, to replace with std::vector<Server>
+		// std::vector<Server>	_servers;
+		std::vector<Client>	_clients;
 
-		// WIP global buffer. Need one variable set per "Client"
+		void	_accept_connection(int fd);
-		char	_buf[BUFSIZE+1];
+		void	_read_request(Client *client);
-		ssize_t	_read_ret;
+		void	_send_response(Client *client);
-		std::map<std::string, std::string>	_request;
+
-		std::map<std::string, std::string>	_response;
+		int		_epoll_update(int fd, uint32_t events, int op);
+		int		_epoll_update(int fd, uint32_t events, int op, void *ptr);
+
+		void	_handle_last_signal();
+		// void	_signal_handler(int signum); // invalide dans une class
+		Client*	_actual_client;
+		void	_close_client(int fd);
+		void	_close_all_clients();
 
 		void	_bind(int socket_fd, in_port_t port);
 		void	_listen(int socket_fd, unsigned int max_connections);
-		void	_accept_connection(int fd);
-		void	_read_request(int fd);
-		void	_send_response(int fd);
 
 		// TMP HUGO TEST CGI
 		void	_serve_file(int fd, std::string page);

srcs/Client.hpp

@@ -0,0 +1,27 @@
+
+#ifndef CLIENT_HPP
+# define CLIENT_HPP
+
+# include <iostream>
+# include <string>
+# include <map>
+
+class Client
+{
+	public:
+		// Client(Placeholder);
+		// Client();
+		// Client(Client const &src);
+		// ~Client();
+		// Client &operator=(Client const &rhs);
+
+		int	fd;
+		std::string	raw_request;
+		std::map<std::string, std::string>	request;
+		std::map<std::string, std::string>	response;
+
+	private:
+
+};
+
+#endif

srcs/Server.hpp

@@ -0,0 +1,32 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   Server.hpp                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: lperrey <lperrey@student.42.fr>            +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2022/07/24 12:11:07 by lperrey           #+#    #+#             */
+/*   Updated: 2022/07/24 12:11:13 by lperrey          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef SERVER_HPP
+# define SERVER_HPP
+
+# include <iostream>
+# include <string>
+
+class Server
+{
+	public:
+		// Server(Placeholder);
+		// Server();
+		// Server(Server const &src);
+		// ~Server();
+		// Server &operator=(Server const &rhs);
+
+	private:
+
+};
+
+#endif

srcs/Webserv.cpp

@@ -1,9 +1,16 @@
 
 #include "Webserv.hpp"
 
+int	g_last_signal;
+bool	g_run;
+void	signal_handler(int signum)
+{
+	g_last_signal = signum;
+}
+
 Webserv::Webserv()
 {
-	std::cout << "Server init\n";
+	std::cerr << "Server init\n";
 
 	_epfd = ::epoll_create1(0); // (EPOLL_CLOEXEC) for CGI fork ?
 	if (_epfd == -1)
@@ -11,6 +18,9 @@ Webserv::Webserv()
 		std::perror("err epoll_create1()");
 		throw std::runtime_error("Epoll init");
 	}
+
+	std::signal(SIGPIPE, signal_handler);
+	std::signal(SIGINT, signal_handler);
 }
 
 /* Webserv::Webserv(Webserv const &src)
@@ -22,7 +32,8 @@ Webserv::~Webserv()
 {
 	close(_socket_fd);
 	close(_epfd);
-	std::cout << "Server destroyed\n";
+	_close_all_clients();
+	std::cerr << "Server destroyed\n";
 }
 
 /* Webserv &	Webserv::operator=(Webserv const &rhs)
@@ -54,51 +65,49 @@ void	Webserv::init_virtual_servers() // ADD config param
 	_bind(_socket_fd, 4040);
 	_listen(_socket_fd, 512); // 512 arbitrary
 
-	struct epoll_event	ev;
+	if (_epoll_update(_socket_fd, EPOLLIN, EPOLL_CTL_ADD) == -1)
-	std::memset(&ev, 0, sizeof ev);
-	ev.events = EPOLLIN;
-	ev.data.fd = _socket_fd;
-	if (::epoll_ctl(_epfd, EPOLL_CTL_ADD, _socket_fd, &ev) == -1)
-	{
-		std::perror("err epoll_ctl()");
 		throw std::runtime_error("Socket init");
 }
-}
 
 void	Webserv::start()
 {
-	std::cout << "Server started\n";
+	std::cerr << "Server started\n";
 	struct epoll_event	events[MAX_EVENTS];
 	int	nfds;
 	int	i;
 	int	count_loop = 0;
-	std::cout << ++count_loop << "----loop epoll()\n";
 
-	while ( (nfds = ::epoll_wait(_epfd, events, MAX_EVENTS, TIMEOUT)) != -1)
+	g_run = true;
+	while (g_run)
 	{
-		if (nfds == 0)
+		std::cerr << ++count_loop << "----loop epoll()\n";
+		nfds = ::epoll_wait(_epfd, events, MAX_EVENTS, TIMEOUT);
+		if (nfds == -1)
 		{
-			(void)0;
+			std::perror("err epoll_wait(): ");
-			// TODO : parcourir les "Clients" encore ouvert et les close() tous
+			throw std::runtime_error("Epoll wait");
+		}
+		else if (nfds == 0)
+		{
+			if (!_clients.empty())
+			{
+				std::cerr << "Timeout " << TIMEOUT << "ms\n";
+				_close_all_clients();
+			}
 		}
 		i = 0;
 		while (i < nfds)
 		{
+			// if ((events[i].data.u32 == SERVER_FD) && (events[i].events & EPOLLIN)) // Dont work, see "SERVER_FD" define
 			if ((events[i].data.fd == _socket_fd) && (events[i].events & EPOLLIN))
 				_accept_connection(events[i].data.fd);
 			else if (events[i].events & EPOLLIN)
-				_read_request(events[i].data.fd);
+				_read_request(static_cast<Client*>(events[i].data.ptr));
 			else if (events[i].events & EPOLLOUT)
-				_send_response(events[i].data.fd);
+				_send_response(static_cast<Client*>(events[i].data.ptr));
 			++i;
+			_actual_client = NULL;
 		}
-		std::cout << ++count_loop << "----loop epoll()\n";
-	}
-
-	if (nfds == -1)
-	{
-		std::perror("err epoll_wait()");
-		throw std::runtime_error("Epoll wait");
 	}
 }
 
@@ -106,84 +115,121 @@ void	Webserv::start()
   ///////////////////////
  // Private Functions //
 
-void	Webserv::_bind(int socket_fd, in_port_t port)
-{
-	// cast invalid ? how to ?
-	// const struct sockaddr* cast_test = static_cast<const struct sockaddr*>(addr);
-
-	struct sockaddr_in	addr;
-	std::memset(&addr, 0, sizeof 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) ?
-
-	if (::bind(socket_fd, (const sockaddr*)&addr, sizeof addr) == -1)
-	{
-		std::perror("err bind()");
-		throw std::runtime_error("Socket bind");		
-	}
-}
-
-void	Webserv::_listen(int socket_fd, unsigned int max_connections)
-{
-	if (::listen(socket_fd, max_connections) == -1)
-	{
-		std::perror("err listen()");
-		throw std::runtime_error("Socket listen");
-	}
-}
-
 void	Webserv::_accept_connection(int fd)
 {
 	struct sockaddr_in	addr;
 	socklen_t 			addr_len;
 	int					accepted_fd;
 
-	std::cout << "accept()\n";
+	std::cerr << "accept()\n";
 	addr_len = sizeof addr;
 	accepted_fd = ::accept(fd, (sockaddr*)&addr, &addr_len);
 	if (accepted_fd == -1)
 	{
-		std::perror("err accept()");
+		std::perror("err accept(): ");
 		return ;
 	}
 	::fcntl(accepted_fd, F_SETFL, O_NONBLOCK);
 
-	struct epoll_event	ev;
+	_clients.push_back(Client());
-	std::memset(&ev, 0, sizeof ev);
+	_clients.back().fd = accepted_fd;
-	ev.events = EPOLLIN;
+
-	ev.data.fd = accepted_fd;
+	_epoll_update(accepted_fd, EPOLLIN, EPOLL_CTL_ADD, &_clients.back());
-	if (::epoll_ctl(_epfd, EPOLL_CTL_ADD, accepted_fd, &ev) == -1)
-		std::perror("err accept() epoll_ctl()");
 }
 
-void	Webserv::_read_request(int fd)
+	 //////////
+	// READ //
+void	Webserv::_read_request(Client *client)
 {
-	std::cout << "recv()\n";
+	char	buf[BUFSIZE+1];
-	_read_ret = ::recv(fd, _buf, BUFSIZE, 0);
+	ssize_t	ret;
-	if (_read_ret == -1)
+	_actual_client = client;
-	{
-		std::perror("err recv()");
-		if (::send(fd, MSG_BOUNCE, sizeof MSG_BOUNCE - 1, 0) == -1)
-			std::perror("err send()");
 
-		::close(fd);
+	std::cerr << "recv()\n";
+	ret = ::recv(client->fd, buf, BUFSIZE, 0);
+	if (ret == -1)
+	{
+		std::perror("err recv(): ");
+		// if (g_last_signal)
+			// _handle_last_signal();
+		// else
+			// _close_client(client->fd);
+		
+		std::cerr << "client ptr =" << client << "\n"; // DEBUG
+		std::cerr << "client.fd =" << client->fd << "\n"; // DEBUG
 		return ;
 	}
 	/*
-	if (_read_ret == BUFSIZE)
+	if (ret == BUFSIZE)
 		// send error like "request too long" to client
 	*/
-	_buf[_read_ret] = '\0';
 
-	struct epoll_event	ev;
+	buf[ret] = '\0';
-	std::memset(&ev, 0, sizeof ev);
+	client->raw_request.append(buf);
-	ev.events = EPOLLOUT;
+
-	ev.data.fd = fd;
+	_epoll_update(client->fd, EPOLLOUT, EPOLL_CTL_MOD, client);
-	if (::epoll_ctl(_epfd, EPOLL_CTL_MOD, fd, &ev) == -1)
-		std::perror("err accept() epoll_ctl(): ");
 }
 
+	 ///////////
+	// WRITE //
+void	Webserv::_send_response(Client *client)
+{
+	ssize_t	ret;
+	_actual_client = client;
+
+	std::cerr << "send()\n";
+	std::cerr << "RAW_REQUEST\n|\n" << client->raw_request << "|\n";
+
+
+	// TMP HUGO test cgi
+		// if "POST" found in _buf, execve a cgi
+		if (std::string(_buf).find("POST") != std::string::npos)
+			_exec_cgi_script(fd);
+		// if "index.html" found in _buf, send the page
+		if (std::string(_buf).find("index.html") != std::string::npos)
+			_serve_file(fd, "index.html");
+	// TMP HUGO end test cgi
+
+
+	ret = ::send(client->fd, MSG_TEST, sizeof MSG_TEST - 1, 0);
+	if (ret == -1)
+	{
+		std::perror("err send(): ");
+		if (g_last_signal)
+			_handle_last_signal();
+		// else
+			// _close_client(client->fd);		
+		return ;
+	}
+
+	_close_client(client->fd);
+	// if (client->raw_request.find("Connection: keep-alive") == std::string::npos)
+		// _close_client(client->fd);
+	// else
+		// _epoll_update(client->fd, EPOLLIN, EPOLL_CTL_MOD, client);
+
+	client->raw_request.clear();
+}
+
+
+	 ////////////////////
+	// Misc functions //
+
+int	Webserv::_epoll_update(int fd, uint32_t events, int op)
+{
+	struct epoll_event	ev;
+	std::memset(&ev, 0, sizeof ev);
+	ev.events = events;
+	ev.data.fd = fd;
+	if (::epoll_ctl(_epfd, op, fd, &ev) == -1)
+	{
+		std::perror("err _epoll_update(): ");
+		return (-1);
+	}
+	return (0);
+}
+
+// TMP HUGO
 void	Webserv::_serve_file(int fd, std::string page)
 {
 	int	page_fd;
@@ -236,24 +282,99 @@ void	Webserv::_exec_cgi_script(int fd)
 	// restore stdout
 	dup2(save_stdout, STDOUT_FILENO);
 }
+// END TMP HUGO
 
-void	Webserv::_send_response(int fd)
+int	Webserv::_epoll_update(int fd, uint32_t events, int op, void *ptr)
 {
-	// TMP HUGO test cgi
+	struct epoll_event	ev;
-		// if "POST" found in _buf, execve a cgi
+	std::memset(&ev, 0, sizeof ev);
-		if (std::string(_buf).find("POST") != std::string::npos)
+	ev.events = events;
-			_exec_cgi_script(fd);
+	ev.data.ptr = ptr;
-		// if "index.html" found in _buf, send the page
+	if (::epoll_ctl(_epfd, op, fd, &ev) == -1)
-		if (std::string(_buf).find("index.html") != std::string::npos)
+	{
-			_serve_file(fd, "index.html");
+		std::perror("err _epoll_update(): ");
-	// TMP HUGO end test cgi
+		return (-1);
-
+	}
-	std::cout << "send()\n";
+	return (0);
-	std::cout << "buf size: " << strlen(_buf) << "\n";
+}
-	std::cout << "_buf: " << _buf << "\n";
+
-	if (::send(fd, _buf, _read_ret, 0) == -1)
+void	Webserv::_handle_last_signal()
-		std::perror("err send()");
+{
-	if (::send(fd, MSG_TEST, sizeof MSG_TEST - 1, 0) == -1)
+	if (g_last_signal == SIGPIPE)
-		std::perror("err send()");
+	{
-	::close(fd);
+		std::cerr << "SIGPIPE\n";
+		if (_actual_client)
+		{
+			_close_client(_actual_client->fd);
+			_actual_client = NULL;
+		}
+	}
+	else if (g_last_signal == SIGINT)
+	{
+		g_run = false;
+	}
+	g_last_signal = 0;
+}
+
+void	Webserv::_close_client(int fd)
+{
+	std::vector<Client>::iterator	it = _clients.begin();
+	while (it != _clients.end())
+	{
+		if (it->fd == fd)
+		{
+			// _epoll_update(fd, 0, EPOLL_CTL_DEL); // normalement superflu, DEBUG
+			if (::close(fd) == -1)
+				std::perror("err close(): ");
+			else
+				std::cerr << "close fd " << fd << "\n";
+			_clients.erase(it);
+			break;
+		}
+		++it;
+	}
+}
+
+void	Webserv::_close_all_clients()
+{
+	while (!_clients.empty())
+	{
+		// _epoll_update(_clients.back().fd, 0, EPOLL_CTL_DEL); // normalement superflu, DEBUG
+		if (::close(_clients.back().fd) == -1)
+			std::perror("err close(): ");
+		else
+			std::cerr << "close fd " << _clients.back().fd << "\n";
+		_clients.pop_back();
+	}
+}
+
+
+	 ////////////////////
+	// Init functions //
+
+void	Webserv::_bind(int socket_fd, in_port_t port)
+{
+	// cast invalid ? how to ?
+	// const struct sockaddr* cast_test = static_cast<const struct sockaddr*>(addr);
+
+	struct sockaddr_in	addr;
+	std::memset(&addr, 0, sizeof 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) ?
+
+	if (::bind(socket_fd, (const sockaddr*)&addr, sizeof addr) == -1)
+	{
+		std::perror("err bind(): ");
+		throw std::runtime_error("Socket bind");		
+	}
+}
+
+void	Webserv::_listen(int socket_fd, unsigned int max_connections)
+{
+	if (::listen(socket_fd, max_connections) == -1)
+	{
+		std::perror("err listen(): ");
+		throw std::runtime_error("Socket listen");
+	}
 }

srcs/main.cpp

@@ -2,7 +2,7 @@
 #include <iostream>
 #include <exception>
 #include <stdexcept>
-#include <Webserv.hpp>
+#include "Webserv.hpp"
 
 int	main(void)
 {