Test dynamic IPv4 + Subnet masks

include/columnlynx/common/net/session_registry.hpp

@@ -8,6 +8,7 @@
 #include <memory>
 #include <chrono>
 #include <array>
+#include <cmath>
 #include <sodium.h>
 #include <columnlynx/common/utils.hpp>
 #include <columnlynx/common/libsodium_wrapper.hpp>
@@ -109,22 +110,23 @@ namespace ColumnLynx::Net {
                 return static_cast<int>(mSessions.size());
             }
 
-            // IP management (simple for /24 subnet)
+            // IP management
 
             // Get the lowest available IPv4 address; Returns 0 if none available
-            uint32_t getFirstAvailableIP() const {
+            uint32_t getFirstAvailableIP(uint32_t baseIP, uint8_t mask) const {
                 std::shared_lock lock(mMutex);
-                uint32_t baseIP = 0x0A0A0002; // 10.10.0.2
+                
+                uint32_t hostSpace = (1u << (32 - mask)) - 2; // Usable hosts
 
-                // TODO: Expand to support larger subnets
-                for (uint32_t offset = 0; offset < 254; offset++) {
+                // Skip 0 (network) and 1 (server reserved), start at 2
+                for (uint32_t offset = 2; offset <= hostSpace; offset++) {
                     uint32_t candidateIP = baseIP + offset;
                     if (mSessionIPs.find(candidateIP) == mSessionIPs.end()) {
                         return candidateIP;
                     }
                 }
-
-                return 0; // Unavailable
+            
+                return 0; // No available IPs
             }
 
             // Lock an IP as assigned to a specific session

include/columnlynx/common/net/virtual_interface.hpp

@@ -60,6 +60,16 @@ namespace ColumnLynx::Net {
                 return std::string(buf);
             }
 
+            static inline uint32_t stringToIpv4(const std::string &ipStr) {
+                struct in_addr addr;
+                
+                if (inet_pton(AF_INET, ipStr.c_str(), &addr) != 1) {
+                    return 0; // "0.0.0.0"
+                }
+            
+                return ntohl(addr.s_addr);
+            }
+
             static inline uint32_t prefixLengthToNetmask(uint8_t prefixLen) {
                 if (prefixLen == 0) return 0;
                 uint32_t mask = (0xFFFFFFFF << (32 - prefixLen)) & 0xFFFFFFFF;

include/columnlynx/common/utils.hpp

@@ -13,6 +13,7 @@
 #include <fstream>
 #include <chrono>
 #include <unordered_map>
+#include <unordered_set>
 #include <algorithm>
 
 #ifdef _WIN32
@@ -94,5 +95,5 @@ namespace ColumnLynx::Utils {
     }
 
     // Returns the config file in an unordered_map format. This purely reads the config file, you still need to parse it manually.
-    std::unordered_map<std::string, std::string> getConfigMap(std::string path);
+    std::unordered_map<std::string, std::string> getConfigMap(std::string path, std::vector<std::string> requiredKeys = {});
 };

include/columnlynx/server/net/tcp/tcp_connection.hpp

@@ -17,6 +17,7 @@
 #include <columnlynx/common/libsodium_wrapper.hpp>
 #include <columnlynx/common/net/session_registry.hpp>
 #include <columnlynx/common/net/protocol_structs.hpp>
+#include <columnlynx/common/net/virtual_interface.hpp>
 
 namespace ColumnLynx::Net::TCP {
     class TCPConnection : public std::enable_shared_from_this<TCPConnection> {
@@ -26,9 +27,10 @@ namespace ColumnLynx::Net::TCP {
             static pointer create(
                 asio::ip::tcp::socket socket,
                 std::shared_ptr<Utils::LibSodiumWrapper> sodiumWrapper,
+                std::unordered_map<std::string, std::string>* serverConfig,
                 std::function<void(pointer)> onDisconnect)
             {
-                auto conn = pointer(new TCPConnection(std::move(socket), sodiumWrapper));
+                auto conn = pointer(new TCPConnection(std::move(socket), sodiumWrapper, serverConfig));
                 conn->mOnDisconnect = std::move(onDisconnect);
                 return conn;
             }
@@ -48,10 +50,11 @@ namespace ColumnLynx::Net::TCP {
             std::array<uint8_t, 32> getAESKey() const;
         
         private:
-            TCPConnection(asio::ip::tcp::socket socket, std::shared_ptr<Utils::LibSodiumWrapper> sodiumWrapper)
+            TCPConnection(asio::ip::tcp::socket socket, std::shared_ptr<Utils::LibSodiumWrapper> sodiumWrapper, std::unordered_map<std::string, std::string>* serverConfig)
                 :
                 mHandler(std::make_shared<MessageHandler>(std::move(socket))),
                 mLibSodiumWrapper(sodiumWrapper),
+                mRawServerConfig(serverConfig),
                 mHeartbeatTimer(mHandler->socket().get_executor()),
                 mLastHeartbeatReceived(std::chrono::steady_clock::now()),
                 mLastHeartbeatSent(std::chrono::steady_clock::now())
@@ -65,6 +68,7 @@ namespace ColumnLynx::Net::TCP {
             std::shared_ptr<MessageHandler> mHandler;
             std::function<void(std::shared_ptr<TCPConnection>)> mOnDisconnect;
             std::shared_ptr<Utils::LibSodiumWrapper> mLibSodiumWrapper;
+            std::unordered_map<std::string, std::string>* mRawServerConfig;
             std::array<uint8_t, 32> mConnectionAESKey;
             uint64_t mConnectionSessionID;
             AsymPublicKey mConnectionPublicKey;

include/columnlynx/server/net/tcp/tcp_server.hpp

@@ -32,7 +32,7 @@ namespace ColumnLynx::Net::TCP {
                   mHostRunning(hostRunning)
             {
                 // Preload the config map
-                mRawServerConfig = Utils::getConfigMap("server_config");
+                mRawServerConfig = Utils::getConfigMap("server_config", {"NETWORK", "SUBNET_MASK"});
 
                 asio::error_code ec;