add Socket class

includes/Header.hpp

@@ -9,10 +9,8 @@ private:
 	int		_type;
 	int		_row;
 	char	*_buff;
-	// std::string	_respons;
 	std::string _fileName;
-	std::vector<std::string> _request;
-
+	std::map<std::string, std::string> _request;
 
 public:
 	enum REQ
@@ -23,17 +21,14 @@ public:
 	};
 
 public:
-	std::vector<std::string>	getRequest(void);
-	// std::string				getRespons(void);
+	std::map<std::string, std::string>	getRequest(void);
 	int							getType(void);
 	std::string					getFileName(void);
-	void				setFile(std::string);
-	void				setRequest(char *);
-	// void	generateRespons(void);
-
-	void	parseBuff(void);
-	void	identifyType(std::string);
-	void	printHeaderInfo(void);
+	void						setFile(std::string);
+	void						setRequest(char *);
+	void						identifyType(std::string);
+	void						printHeaderInfo(void);
+	void						parseRequest(void);
 	Header();
 	Header(char *);
 	~Header();

includes/Socket.hpp

@@ -0,0 +1,33 @@
+#ifndef SOCKET
+#define SOCKET
+
+#include "webserv.hpp"
+class Socket
+{
+private:
+    int                 _socketFd;
+    socklen_t           _addrlen;
+	struct sockaddr_in  _addres;
+
+    
+public:
+    Socket();
+    Socket(int domain, int type, int protocol, int port);
+    int getSocketFd(void);
+    struct sockaddr_in getAddres(void);
+    socklen_t getAddlen(void);
+    struct sockaddr *getSockaddr(void);
+    socklen_t *getSocklen(void);
+    void setSocketFd(int);
+    void setAddres(struct sockaddr_in);
+    int bindingSocket(void);
+    int listeningSocket(int nbr);
+    int init(int nbr);
+    void checkError(int fd, std::string str);
+
+    ~Socket();
+};
+
+
+
+#endif

includes/webserv.hpp

@@ -26,6 +26,8 @@
 #include <fstream>
 #include <vector>
 #include <sstream>
+#include <map>
+#include "Socket.hpp"
 #include "Server.hpp"
 #include "Header.hpp"
 

src/Header.cpp

@@ -9,16 +9,14 @@ Header::Header(char *str)
 {
 	this->_row = 0;
 	this->_buff = str;
+	parseRequest();
 }
 //-------------------------------------------------GET/SET---------------------------------------
-std::vector<std::string>	Header::getRequest(void)
+std::map<std::string, std::string>	Header::getRequest(void)
 {
 	return (this->_request);
 }
-// std::string	Header::getRespons(void)
-// {
-// 	return (this->_respons);
-// }
+
 int	Header::getType(void)
 {
 	return (this->_type);
@@ -43,7 +41,10 @@ void	Header::setFile(std::string str)
 	pos = str.find(del);
 	str.erase(0, pos + del.length());
 	_fileName = str.substr(0, str.find(del));
-	_fileName.insert(0, HOME);
+	if (_fileName == "/")
+		_fileName = "www/index2.html";
+	else
+		_fileName.insert(0, HOME);
 }
 
 void	Header::identifyType(std::string str)
@@ -56,12 +57,15 @@ void	Header::identifyType(std::string str)
 		_type = DELETE;
 }
 
-void	Header::parseBuff(void)
+void	Header::parseRequest(void)
 {
 	std::string			line;
+	std::string			key;
+	int					distance;
 	std::stringstream	buffStream;
 	
 	buffStream << _buff;
+	distance = 0;
 	while (std::getline(buffStream, line, '\n'))
 	{
 		if (_row == 0)
@@ -69,17 +73,41 @@ void	Header::parseBuff(void)
 			identifyType(line);
 			setFile(line);
 		}
-		_request.push_back(line);
+		else
+		{
+			distance = line.find(":");
+			key = line.substr(0, distance);
+			line = line.erase(0, distance + 1);
+			if (_request.find(key) != _request.end())
+			{
+				std::cout << RED << "ERROR: double header-field" << ZERO_C << std::endl;
+			}
+			else
+				_request[key] = line;
+		}
 		_row++;
 	}
 }
 
 void	Header::printHeaderInfo(void)
 {
+	std::map<std::string, std::string>::iterator it;
+
 	std::cout << YELLOW << "request type = " << _type << ZERO_C << std::endl;
 	std::cout << YELLOW << "request rows = " << _row << ZERO_C << std::endl;
 	std::cout << YELLOW << "request fileName = " << _fileName << ZERO_C << std::endl;
 	std::cout << YELLOW << "request header:\n" << _buff << ZERO_C << std::endl;
+	
+	// std::cout << TURGUOISE << "HEADER MAP" << ZERO_C << std::endl;
+	// for ( it = _request.begin(); it != _request.end(); it++)
+	// {
+	// 	std::cout << PINK << it->first << ZERO_C << std::endl;
+	// }
+	// for ( it = _request.begin(); it != _request.end(); it++)
+	// {
+	// 	std::cout << PINK << it->second << ZERO_C << std::endl;
+	// }
+	
 }
 
 Header::~Header()

src/Server.cpp

@@ -10,7 +10,7 @@ Server::Server(std::string path)
 	(void)path;
 }
 
-//---------------------------------------------Send--------------------------------------------------------------------------------------------
+//----------------------------------------------Send--------------------------------------------------------------------------------------------
 
 void	Server::sendHeader(Header head)
 {
@@ -40,9 +40,10 @@ void	Server::sendRespons(Header head)
 		file.read(buff, BUFFSIZE);
 		send(_clientSocket, buff, file.gcount(), 0);
 	}
+	(void)path;
 }
 
-//---------------------------------------------Configuration-----------------------------------------------------------------------------------
+//----------------------------------------------Configuration-----------------------------------------------------------------------------------
 void	Server::readConfig(void)
 {
 
@@ -54,6 +55,33 @@ void	Server::setupConfig(void)
 	this->_port = 8080;
 }
 
+
+void	Server::start(void)
+{
+	Socket		serverSocket(AF_INET, SOCK_STREAM, 0, _port);
+ 	char		buff[BUFFSIZE + 1] = {0};
+	Header		header;
+
+	checkError(serverSocket.init(3), "Socket init");
+	_clientSocket = accept(serverSocket.getSocketFd(),
+		serverSocket.getSockaddr(), serverSocket.getSocklen());
+	checkError(_clientSocket, "Initialize client socket");
+	checkError(recv(_clientSocket, buff, BUFFSIZE, 0), "Receive msg from client");
+	std::cout << TURGUOISE << "Receive Header" << ZERO_C << std::endl;
+	header.setRequest(buff);
+	header.parseRequest();
+	header.printHeaderInfo();
+	sendRespons(header);
+	close(_clientSocket);
+	close(serverSocket.getSocketFd());
+
+}
+
+void	Server::end(void)
+{
+
+}
+//----------------------------------------------Other------------------------------------------------------------------------------------------------
 void	Server::checkError(int fd, std::string str)
 {
 	if (fd < 0)
@@ -65,40 +93,6 @@ void	Server::checkError(int fd, std::string str)
 		std::cout << GREEN << "Server SUCCESS: " << str << ZERO_C << std::endl;
 }
 
-void	Server::start(void)
-{
-	char	buff[BUFFSIZE + 1] = {0};
-	int		opt	= 1;
-	socklen_t	addrlen;
-	Header		header;
-
-	_serverSocket = socket(AF_INET, SOCK_STREAM, 0);
-	checkError(_serverSocket, "Initialize Server socket");
-	checkError(setsockopt(_serverSocket, SOL_SOCKET, SO_REUSEADDR
-		| SO_REUSEPORT, &opt, sizeof(opt)), "Set socket options");
-	_addres.sin_family = AF_INET;
-	_addres.sin_addr.s_addr = INADDR_ANY;
-	_addres.sin_port = htons(_port);
-	checkError(bind(_serverSocket, (struct sockaddr *)&_addres, sizeof(_addres)), "Bind socket");
-	checkError(listen(_serverSocket, 3), "Listen socket");
-	addrlen = sizeof(_addres);
-	_clientSocket = accept(_serverSocket, (struct sockaddr *)&_addres, (socklen_t *)&addrlen);
-	checkError(_clientSocket, "Initialize Client socket");
-	checkError(recv(_clientSocket, buff, BUFFSIZE, 0), "Receive msg from client");
-	std::cout << TURGUOISE << "Receive Header" << ZERO_C << std::endl;
-	header.setRequest(buff);
-	header.parseBuff();
-	header.printHeaderInfo();
-	sendRespons(header);
-	close(_clientSocket);
-	close(_serverSocket);
-}
-
-void	Server::end(void)
-{
-
-}
-
 Server::~Server()
 {
 }

src/Socket.cpp

@@ -0,0 +1,101 @@
+#include "webserv.hpp"
+
+Socket::Socket()
+{
+
+}
+Socket::Socket(int domain, int type, int protocol, int port)
+{
+    int opt = 1;
+    _socketFd = socket(domain, type, protocol);
+    checkError(_socketFd, "Initialize Server socket");
+    checkError(setsockopt(_socketFd, SOL_SOCKET, SO_REUSEADDR
+        | SO_REUSEPORT, &opt, sizeof(opt)), "Set socket options");
+    _addres.sin_family = domain;
+    _addres.sin_port = htons(port);
+    _addres.sin_addr.s_addr = INADDR_ANY;
+    _addrlen = sizeof(_addres);
+}
+
+Socket::~Socket()
+{
+
+}
+
+//-----------------------------------------------------------------GET/SET----------------------------
+int Socket::getSocketFd(void)
+{
+    return _socketFd;
+}
+
+struct sockaddr_in Socket::getAddres(void)
+{
+    return _addres;
+}
+
+struct sockaddr *Socket::getSockaddr(void)
+{
+    return((struct sockaddr *)&_addres);
+}
+
+socklen_t   *Socket::getSocklen(void)
+{
+    return((socklen_t *)&_addrlen);
+}
+
+
+void    Socket::setAddres(struct sockaddr_in addr)
+{
+    _addres = addr;
+    _addrlen = sizeof(_addres);
+}
+
+socklen_t   Socket::getAddlen(void)
+{
+    return (_addrlen);
+}
+
+void    Socket::setSocketFd(int fd)
+{
+    _socketFd = fd;
+}
+//----------------------------------------------------------------Setting-------------------------------
+int Socket::bindingSocket(void)
+{
+    int res;
+
+    res = bind(_socketFd, (struct sockaddr *)&_addres, sizeof(_addres));
+    checkError(res, "Bind Socket");
+    return (res);
+}
+
+int Socket::listeningSocket(int nbr)
+{
+    int res;
+
+    res = listen(_socketFd, nbr);
+    checkError(res, "Listen Socket");
+    return (res);
+}
+
+int Socket::init(int nbr)
+{
+    if (bindingSocket() < 0)
+        return (-1);
+    if (listeningSocket(nbr) < 0)
+        return (-1);
+    return (0);
+}
+
+//---------------------------------------------------------------ERROR----------------------------------
+
+void	Socket::checkError(int fd, std::string str)
+{
+	if (fd < 0)
+	{
+		std::cout << RED << "Socket ERROR: " << str << ZERO_C << std::endl;
+		exit(1);
+	}
+	else
+		std::cout << GREEN << "Socket SUCCESS: " << str << ZERO_C << std::endl;
+}