refactor: removed ip blacklist exception

araujo88 · araujo88 · commit 363fd500b7a9 · 2024-03-29T00:50:27.000-03:00
diff --git a/include/base_exceptions.hpp b/include/base_exceptions.hpp
@@ -54,15 +54,6 @@ namespace tpt
             : BaseException(message, errorCode) {}
     };
 
-    class IPBlackListedException : public BaseException
-    {
-    public:
-        IPBlackListedException(
-            const std::string &message = "IP is blacklisted",
-            int errorCode = -1)
-            : BaseException(message, errorCode) {}
-    };
-
     class SocketCreationException : public BaseException
     {
     public:
diff --git a/include/socket.hpp b/include/socket.hpp
@@ -15,7 +15,7 @@ namespace tpt
     public:
         virtual void bindSocket() = 0;
         virtual void listenToConnections() = 0;
-        virtual void acceptConnection(SOCKET &client_socket, void *client_address) = 0;
+        virtual bool acceptConnection(SOCKET &client_socket, void *client_address) = 0;
         virtual ssize_t receiveData(SOCKET client_socket, char *buffer, unsigned int buffer_size) = 0;
         virtual void sendData(SOCKET client_socket, const void *buffer, unsigned int buffer_size, int flags) = 0;
         virtual void closeSocket() = 0;
diff --git a/include/unix_socket.hpp b/include/unix_socket.hpp
@@ -42,7 +42,7 @@ namespace tpt
         std::string getClientIp();
         virtual void bindSocket() override;
         virtual void listenToConnections() override;
-        virtual void acceptConnection(SOCKET &client_socket, void *client_address) override;
+        virtual bool acceptConnection(SOCKET &client_socket, void *client_address) override;
         virtual ssize_t receiveData(SOCKET client_socket, char *buffer, unsigned int buffer_size) override;
         virtual void sendData(SOCKET client_socket, const void *buffer, unsigned int buffer_size, int flags) override;
         virtual void closeSocket() override;
diff --git a/include/win_socket.hpp b/include/win_socket.hpp
@@ -46,7 +46,7 @@ namespace tpt
         std::string getClientIp();
         virtual void bindSocket() override;
         virtual void listenToConnections() override;
-        virtual void acceptConnection(SOCKET &client_socket, void *client_address) override;
+        virtual bool acceptConnection(SOCKET &client_socket, void *client_address) override;
         virtual ssize_t receiveData(SOCKET client_socket, char *buffer, unsigned int buffer_size) override;
         virtual void sendData(SOCKET client_socket, const void *buffer, unsigned int buffer_size, int flags) override;
         virtual void closeSocket() override;
diff --git a/src/teapot.cpp b/src/teapot.cpp
@@ -195,7 +195,7 @@ Teapot::Teapot(std::string ip_address, unsigned int port, unsigned int max_conne
     this->cors_middleware = CORSMiddleware();
     this->security_middleware = SecurityMiddleware();
     this->logger = ConsoleLogger();
-    // Conditional compilation based on the operating system
+
 #ifdef __linux__
     this->socket = tpt::UnixSocket(this->logger, this->ip_address, this->port, this->max_connections);
 #endif
@@ -229,14 +229,14 @@ void Teapot::run()
 
         try
         {
-            socket.acceptConnection(client_socket, client_addr);
-            auto res = std::async(std::launch::async, &Teapot::requestHandler, this, client_socket);
-            // std::jthread th(&Teapot::requestHandler, this, client_socket);
-        }
-        catch (IPBlackListedException &e)
-        {
-            std::cout << e.what();
-            this->socket.closeSocket(client_socket);
+            if (socket.acceptConnection(client_socket, client_addr))
+            {
+                auto res = std::async(std::launch::async, &Teapot::requestHandler, this, client_socket);
+            }
+            else
+            {
+                this->socket.closeSocket(client_socket);
+            }
         }
         catch (SocketAcceptException &)
         {
diff --git a/src/unix_socket.cpp b/src/unix_socket.cpp
@@ -52,7 +52,7 @@ void UnixSocket::listenToConnections()
     }
 }
 
-void UnixSocket::acceptConnection(SOCKET &client_socket, void *client_address)
+bool UnixSocket::acceptConnection(SOCKET &client_socket, void *client_address)
 {
     struct sockaddr_storage client_addr_storage;
     socklen_t client_addr_size = sizeof(client_addr_storage);
@@ -64,22 +64,19 @@ void UnixSocket::acceptConnection(SOCKET &client_socket, void *client_address)
         throw SocketAcceptException();
     }
 
-    // Assuming client_address is meant to store the result
     if (client_address != nullptr)
     {
         std::memcpy(client_address, &client_addr_storage, client_addr_size);
     }
 
-    char ip_str[INET6_ADDRSTRLEN] = {0}; // Large enough for both IPv4 and IPv6
+    char ip_str[INET6_ADDRSTRLEN] = {0};
     if (client_addr_storage.ss_family == AF_INET)
     {
-        // IPv4
         struct sockaddr_in *addr_in = (struct sockaddr_in *)&client_addr_storage;
         inet_ntop(AF_INET, &addr_in->sin_addr, ip_str, INET_ADDRSTRLEN);
     }
     else if (client_addr_storage.ss_family == AF_INET6)
     {
-        // IPv6
         struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *)&client_addr_storage;
         inet_ntop(AF_INET6, &addr_in6->sin6_addr, ip_str, INET6_ADDRSTRLEN);
     }
@@ -90,11 +87,13 @@ void UnixSocket::acceptConnection(SOCKET &client_socket, void *client_address)
     {
         if (this->client_ip == it)
         {
-            throw IPBlackListedException();
+            return false;
         }
     }
 
     this->client_sockets.push_back(client_socket);
+
+    return true;
 }
 
 ssize_t UnixSocket::receiveData(SOCKET client_socket, char *buffer, unsigned int buffer_size)
diff --git a/src/win_socket.cpp b/src/win_socket.cpp
@@ -56,7 +56,7 @@ void WinSocket::listenToConnections()
     }
 }
 
-void WinSocket::acceptConnection(SOCKET &client_socket, void *client_address)
+bool WinSocket::acceptConnection(SOCKET &client_socket, void *client_address)
 {
     struct sockaddr_storage client_addr_storage;
     int client_addr_size = sizeof(client_addr_storage);
@@ -68,22 +68,19 @@ void WinSocket::acceptConnection(SOCKET &client_socket, void *client_address)
         throw SocketAcceptException("error accepting connections", WSAGetLastError());
     }
 
-    // Assuming client_address is meant to store the result
     if (client_address != nullptr)
     {
         std::memcpy(client_address, &client_addr_storage, client_addr_size);
     }
 
-    char ip_str[INET6_ADDRSTRLEN] = {0}; // Large enough for both IPv4 and IPv6
+    char ip_str[INET6_ADDRSTRLEN] = {0};
     if (client_addr_storage.ss_family == AF_INET)
     {
-        // IPv4
         struct sockaddr_in *addr_in = (struct sockaddr_in *)&client_addr_storage;
         inet_ntop(AF_INET, &addr_in->sin_addr, ip_str, INET_ADDRSTRLEN);
     }
     else if (client_addr_storage.ss_family == AF_INET6)
     {
-        // IPv6
         struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *)&client_addr_storage;
         inet_ntop(AF_INET6, &addr_in6->sin6_addr, ip_str, INET6_ADDRSTRLEN);
     }
@@ -94,9 +91,13 @@ void WinSocket::acceptConnection(SOCKET &client_socket, void *client_address)
     {
         if (this->client_ip == it)
         {
-            throw IPBlackListedException();
+            return false;
         }
     }
+
+    this->client_sockets.push_back(client_socket);
+
+    return true;
 }
 
 ssize_t WinSocket::receiveData(SOCKET client_socket, char *buffer, unsigned int buffer_size)

Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ void UnixSocket::listenToConnections()`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`
`55`		`-void UnixSocket::acceptConnection(SOCKET &client_socket, void *client_address)`
	`55`	`+bool UnixSocket::acceptConnection(SOCKET &client_socket, void *client_address)`
`56`	`56`	`{`
`57`	`57`	`struct sockaddr_storage client_addr_storage;`
`58`	`58`	`socklen_t client_addr_size = sizeof(client_addr_storage);`
`@@ -64,22 +64,19 @@ void UnixSocket::acceptConnection(SOCKET &client_socket, void *client_address)`
`64`	`64`	`throw SocketAcceptException();`
`65`	`65`	`}`
`66`	`66`
`67`		`- // Assuming client_address is meant to store the result`
`68`	`67`	`if (client_address != nullptr)`
`69`	`68`	`{`
`70`	`69`	`std::memcpy(client_address, &client_addr_storage, client_addr_size);`
`71`	`70`	`}`
`72`	`71`
`73`		`- char ip_str[INET6_ADDRSTRLEN] = {0}; // Large enough for both IPv4 and IPv6`
	`72`	`+ char ip_str[INET6_ADDRSTRLEN] = {0};`
`74`	`73`	`if (client_addr_storage.ss_family == AF_INET)`
`75`	`74`	`{`
`76`		`- // IPv4`
`77`	`75`	`struct sockaddr_in addr_in = (struct sockaddr_in )&client_addr_storage;`
`78`	`76`	`inet_ntop(AF_INET, &addr_in->sin_addr, ip_str, INET_ADDRSTRLEN);`
`79`	`77`	`}`
`80`	`78`	`else if (client_addr_storage.ss_family == AF_INET6)`
`81`	`79`	`{`
`82`		`- // IPv6`
`83`	`80`	`struct sockaddr_in6 addr_in6 = (struct sockaddr_in6 )&client_addr_storage;`
`84`	`81`	`inet_ntop(AF_INET6, &addr_in6->sin6_addr, ip_str, INET6_ADDRSTRLEN);`
`85`	`82`	`}`
`@@ -90,11 +87,13 @@ void UnixSocket::acceptConnection(SOCKET &client_socket, void *client_address)`
`90`	`87`	`{`
`91`	`88`	`if (this->client_ip == it)`
`92`	`89`	`{`
`93`		`- throw IPBlackListedException();`
	`90`	`+ return false;`
`94`	`91`	`}`
`95`	`92`	`}`
`96`	`93`
`97`	`94`	`this->client_sockets.push_back(client_socket);`
	`95`	`+`
	`96`	`+ return true;`
`98`	`97`	`}`
`99`	`98`
`100`	`99`	`ssize_t UnixSocket::receiveData(SOCKET client_socket, char *buffer, unsigned int buffer_size)`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ void WinSocket::listenToConnections()`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`59`		`-void WinSocket::acceptConnection(SOCKET &client_socket, void *client_address)`
	`59`	`+bool WinSocket::acceptConnection(SOCKET &client_socket, void *client_address)`
`60`	`60`	`{`
`61`	`61`	`struct sockaddr_storage client_addr_storage;`
`62`	`62`	`int client_addr_size = sizeof(client_addr_storage);`
`@@ -68,22 +68,19 @@ void WinSocket::acceptConnection(SOCKET &client_socket, void *client_address)`
`68`	`68`	`throw SocketAcceptException("error accepting connections", WSAGetLastError());`
`69`	`69`	`}`
`70`	`70`
`71`		`- // Assuming client_address is meant to store the result`
`72`	`71`	`if (client_address != nullptr)`
`73`	`72`	`{`
`74`	`73`	`std::memcpy(client_address, &client_addr_storage, client_addr_size);`
`75`	`74`	`}`
`76`	`75`
`77`		`- char ip_str[INET6_ADDRSTRLEN] = {0}; // Large enough for both IPv4 and IPv6`
	`76`	`+ char ip_str[INET6_ADDRSTRLEN] = {0};`
`78`	`77`	`if (client_addr_storage.ss_family == AF_INET)`
`79`	`78`	`{`
`80`		`- // IPv4`
`81`	`79`	`struct sockaddr_in addr_in = (struct sockaddr_in )&client_addr_storage;`
`82`	`80`	`inet_ntop(AF_INET, &addr_in->sin_addr, ip_str, INET_ADDRSTRLEN);`
`83`	`81`	`}`
`84`	`82`	`else if (client_addr_storage.ss_family == AF_INET6)`
`85`	`83`	`{`
`86`		`- // IPv6`
`87`	`84`	`struct sockaddr_in6 addr_in6 = (struct sockaddr_in6 )&client_addr_storage;`
`88`	`85`	`inet_ntop(AF_INET6, &addr_in6->sin6_addr, ip_str, INET6_ADDRSTRLEN);`
`89`	`86`	`}`
`@@ -94,9 +91,13 @@ void WinSocket::acceptConnection(SOCKET &client_socket, void *client_address)`
`94`	`91`	`{`
`95`	`92`	`if (this->client_ip == it)`
`96`	`93`	`{`
`97`		`- throw IPBlackListedException();`
	`94`	`+ return false;`
`98`	`95`	`}`
`99`	`96`	`}`
	`97`	`+`
	`98`	`+ this->client_sockets.push_back(client_socket);`
	`99`	`+`
	`100`	`+ return true;`
`100`	`101`	`}`
`101`	`102`
`102`	`103`	`ssize_t WinSocket::receiveData(SOCKET client_socket, char *buffer, unsigned int buffer_size)`