fixed sockets not selected

includes/Env.hpp

@@ -1,12 +1,10 @@
 #pragma once
 #include "webserv.hpp"
 
-
-class JSONNode;
-class Server;
-
 class Env {
-    std::vector<Server> _servers;
+    std::vector<Server *> _servers;
   public:
     Env(JSONNode *conf);
+	void listen();
+	void answer();
 };

includes/Nodes.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include "webserv.hpp"
 
 class JSONNode {
   public:

includes/Parser.hpp

@@ -1,5 +1,7 @@
+#pragma once
 #include "webserv.hpp"
 
+
 class JSONParser {
     std::fstream file;
     Tokenizer tokenizer;

includes/Route.hpp

@@ -9,5 +9,4 @@ class Route {
   public:
 	Route();
 	~Route();
-
 };

includes/Server.hpp

@@ -1,13 +1,14 @@
 #pragma once
 #include "webserv.hpp"
 
-
 class Server {
 	string				_name;
-	std::vector<Socket>	_sockets;
+	std::vector<Socket *>	_sockets;
 	std::map<string, Route *> _routes;
 
   public:
 	Server(JSONNode *server);
+	~Server();
 	void check();
+	void answer();
 };

includes/Socket.hpp

@@ -9,8 +9,15 @@ class Socket {
 	int 				_max_clients;
 	int 				_client_socket[30];
   public:
+	static fd_set _readfds;
+	static int _max_sd;
+	static int _min_sd;
+	static int _amount;
 	Socket(string def);
+	~Socket();
+	int launch();
 	void check();
+	void answer();
 	/*
 	Socket& operator=(Socket &src) {
 		_ip = src._ip;

includes/Token.hpp

@@ -1,3 +1,4 @@
+#pragma once
 #include "webserv.hpp"
 
 enum TOKEN {

includes/webserv.hpp

@@ -10,6 +10,7 @@
 
 #include <cctype>
 #include <cerrno>
+#include <climits>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
@@ -26,19 +27,23 @@ using std::cout;
 using std::strerror;
 using std::string;
 
+class Env;
+class Server;
+class Socket;
+class Route;
 class JSONNode;
+
 typedef std::map<string, JSONNode *> JSONObject;
 typedef std::vector<JSONNode *> JSONList;
 
 void *ft_memset(void *b, int c, size_t len);
 bool isInt(string str);
 
+#include "Nodes.hpp"
 #include "Token.hpp"
 #include "Parser.hpp"
-#include "Nodes.hpp"
 
-#include "Env.hpp"
 #include "Route.hpp"
 #include "Socket.hpp"
 #include "Server.hpp"
-
+#include "Env.hpp"

srcs/load/Env.cpp

@@ -1,23 +1,33 @@
 #include "webserv.hpp"
 
 Env::Env(JSONNode *conf) {
-        JSONList servers = conf->obj()["servers"]->lst();
+    JSONList servers = conf->obj()["servers"]->lst();
-        int i = 0;
+    int i = 0;
-        string th[8] = {"first", "second", "third",   "fourth",
+    string th[8] = {"first", "second", "third",   "fourth",
-                        "fifth", "sixth",  "seventh", "eigth"};
+                    "fifth", "sixth",  "seventh", "eigth"};
-        for (std::vector<JSONNode *>::iterator it = servers.begin();
+    for (std::vector<JSONNode *>::iterator it = servers.begin();
-             it < servers.end(); it++) {
+         it < servers.end(); it++) {
-            Server server(*it);
+        Server *server = new Server(*it);
-            _servers.push_back(server);
+        _servers.push_back(server);
-            // delete *it;
+        // delete *it;
-            cout << th[i] << " server launched.\n";
+        cout << th[i] << " server launched.\n";
-            i++;
+        i++;
-        }
+    }
-        while (1) {
+    // delete conf;
-            for (std::vector<Server>::iterator it = _servers.begin();
+}
-                 it < _servers.end(); it++) {
+void Env::listen() {
-                (*it).check();
+    for (std::vector<Server *>::iterator it = _servers.begin();
-            }
+         it < _servers.end(); it++) {
-        }
+        (*it)->check();
-        // delete conf;
+    }
+	cout << "finished env listen\n";
+}
+
+void Env::answer() {
+	cout << "env start answer\n";
+    for (std::vector<Server *>::iterator it = _servers.begin();
+         it < _servers.end(); it++) {
+        (*it)->answer();
+    }
+	cout << "finished env answer\n";
 }

srcs/load/Server.cpp

@@ -7,19 +7,33 @@ Server::Server(JSONNode *server) {
     if (datas["listens"]) {
         JSONList listens = datas["listens"]->lst();
         for (JSONList::iterator i = listens.begin(); i < listens.end(); i++) {
-            //_listens.push_back((*i)->str());
+            Socket *sock = new Socket((*i)->str());
-            Socket sock((*i)->str());
+			if (sock->launch() == EXIT_SUCCESS) 
-            _sockets.push_back(sock);
+            	_sockets.push_back(sock);
+			else
+				delete sock;
         }
-        //_port = std::atoi(_listens.front().c_str());
     }
     //_routes["default"] = new Route(datas["root"], datas["return"],
-    //datas["index"], datas["autoindex"]);
+    // datas["index"], datas["autoindex"]);
+}
+
+Server::~Server() {
+	cout << "Server destroyed!\n";
 }
 
 void Server::check() {
-    for (std::vector<Socket>::iterator it = _sockets.begin();
+    for (std::vector<Socket *>::iterator it = _sockets.begin();
+         it < _sockets.end(); it++) {
+        (*it)->check();
+    }
+	cout << "finished serv listen\n";
+}
+
+void Server::answer() {
+    for (std::vector<Socket *>::iterator it = _sockets.begin();
          it < _sockets.end(); it++) {
-        (*it).check();
+        (*it)->answer();
     }
+	cout << "finished serv answer\n";
 }

srcs/load/Socket.cpp

@@ -4,74 +4,85 @@
 Socket::Socket(string def) {
     size_t split = def.rfind(':');
 
-    string tmp = def.substr(0, split - 1);
+    string tmp = def.substr(0, split);
-    _ip = isInt(tmp) ? "localhost" : tmp;
+    _ip = isInt(tmp)  || tmp == "localhost" ? "127.0.0.1" : tmp;
     tmp = def.substr(split + 1, def.length() - split - 1).c_str();
     _port = !isInt(tmp) ? 80 : std::atoi(tmp.c_str());
 
     _max_clients = 30;
+    for (int i = 0; i < _max_clients; i++)
+        _client_socket[i] = 0;
+}
+Socket::~Socket() {
+	close(_master_socket);
+	cout << "Socket destroyed!\n";
+}
 
+int Socket::launch() {
     int opt = 1;
     _master_socket = socket(AF_INET, SOCK_STREAM, 0);
     if (_master_socket == 0) {
         cout << "Socket creation: " << strerror(errno) << "\n";
-        exit(EXIT_FAILURE);
+        return (EXIT_FAILURE);
     }
     int opt_ret = setsockopt(_master_socket, SOL_SOCKET, SO_REUSEADDR,
                              (char *)&opt, sizeof(opt));
     if (opt_ret < 0) {
         cout << "Sockopt: " << strerror(errno) << "\n";
-        exit(EXIT_FAILURE);
+        return (EXIT_FAILURE);
     }
 
     _address.sin_family = AF_INET;
-    _address.sin_addr.s_addr = INADDR_ANY;
+    _address.sin_addr.s_addr = inet_addr(_ip.c_str());
     _address.sin_port = htons(_port);
 
     if (bind(_master_socket, (struct sockaddr *)&_address, sizeof(_address)) <
         0) {
         cout << "Bind: " << strerror(errno) << "\n";
-        cout << "Socket destroyed!\n";
+        return (EXIT_FAILURE);
-        return;
-        exit(EXIT_FAILURE);
     }
-    cout << "Listener on port " << _port << "\n";
+    cout << "Listener " << _ip << " on port " << _port << "\n";
 
     if (listen(_master_socket, 3) < 0) {
         cout << "Listen: " << strerror(errno) << "\n";
-        exit(EXIT_FAILURE);
+        return (EXIT_FAILURE);
     }
-    for (int i = 0; i < _max_clients; i++)
+	cout << "Socket::_master_socket: " << _master_socket << "\n";
-        _client_socket[i] = 0;
+	if (_master_socket < _min_sd)
+		_min_sd = _master_socket;
+	_amount++;
+	return (EXIT_SUCCESS);
 }
-void Socket::check() {
-    int new_socket, activity, i, valread, sd;
-    char buffer[1024];
-    char r404[72] =
-        "HTTP/1.1 200 OK\nContent-Type: text/plain\nContent-Length: 4\n\n404!";
 
-    fd_set readfds;
+void Socket::check() {
-    int max_sd = _master_socket;
+    int sd;
 
-    int addrlen = sizeof(_address);
+    FD_SET(_master_socket, &_readfds);
-    FD_ZERO(&readfds);
+	cout << "sd_set " << _master_socket << "\n";
-    FD_SET(_master_socket, &readfds);
 
-    for (i = 0; i < _max_clients; i++) {
+    for (int i = 0; i < _max_clients; i++) {
         sd = _client_socket[i];
+		//cout << "id: " << i << " -> sd: " << sd << "\n";
         if (sd > 0)
-            FD_SET(sd, &readfds);
+		{
-        if (sd > max_sd)
+            FD_SET(sd, &_readfds);
-            max_sd = sd;
+			cout << "fd_set " << sd << "\n";
+		}
+        if (sd > _max_sd)
+            _max_sd = sd;
     }
+	cout << "Socket checked\n";
+}
 
-    activity = select(max_sd + 1, &readfds, NULL, NULL, NULL);
-
-    if ((activity < 0) && (errno != EINTR))
-        cout << "Select: " << strerror(errno) << "\n";
 
-    if (FD_ISSET(_master_socket, &readfds)) {
+void Socket::answer() {
-        new_socket = accept(_master_socket, (struct sockaddr *)&_address,
+	int i, sd, valread;
+    int addrlen = sizeof(_address);
+    char buffer[1024];
+    char r404[72] =
+        "HTTP/1.1 200 OK\nContent-Type: text/plain\nContent-Length: 4\n\n404!";
+    if (FD_ISSET(_master_socket, &_readfds)) {
+        int new_socket = accept(_master_socket, (struct sockaddr *)&_address,
                             (socklen_t *)&addrlen);
         if (new_socket < 0) {
             cout << "Accept: " << strerror(errno) << "\n";
@@ -94,7 +105,7 @@ void Socket::check() {
     cout << "Socket: " << _ip << ":" << _port << "\n";
     for (i = 0; i < _max_clients; i++) {
         sd = _client_socket[i];
-        if (FD_ISSET(sd, &readfds)) {
+        if (FD_ISSET(sd, &_readfds)) {
             cout << "Client " << i << ": set\n";
             valread = read(sd, buffer, 1024);
             if (valread == 0) {
@@ -114,4 +125,5 @@ void Socket::check() {
             }
         }
     }
+	cout << "Socket answered\n";
 }

srcs/webserv.cpp

@@ -1,4 +1,10 @@
 #include "webserv.hpp"
+#include <time.h>
+
+fd_set Socket::_readfds;
+int Socket::_max_sd;
+int Socket::_min_sd = INT_MAX;
+int Socket::_amount = 0;
 
 int main(int ac, char **av) {
 
@@ -11,6 +17,17 @@ int main(int ac, char **av) {
 
         cout << "Setting environment...\n";
         Env env(conf);
-    }
+        while (1) {
+			cout << "Cycling...\n";
+			FD_ZERO(&Socket::_readfds);
+			Socket::_max_sd = Socket::_min_sd;
+            env.listen();
+			cout << "Socket::_max_sd " << Socket::_max_sd << "\n";
+			int activity = select(Socket::_max_sd + Socket::_amount, &(Socket::_readfds), NULL, NULL, NULL);
+			if ((activity < 0) && (errno != EINTR))
+				cout << "Select: " << strerror(errno) << "\n";
+			env.answer();
+		}
+	}
     return (0);
 }