Firewall.cpp

Go to the documentation of this file.

 
#include "Firewall.h"
 
#include <cctype>
 
bool Firewall::parseIpv4(const std::string& text, std::uint32_t& value) {
    std::uint32_t result = 0;
    int octets = 0;
    std::size_t position = 0;
    while (octets < 4) {
        if (position >= text.size() || !std::isdigit(static_cast<unsigned char>(text[position]))) {
            return false;
        }
        unsigned int octet = 0;
        int digits = 0;
        while (position < text.size() && std::isdigit(static_cast<unsigned char>(text[position]))) {
            octet = octet * 10 + static_cast<unsigned int>(text[position] - '0');
            ++position;
            if (++digits > 3 || octet > 255) {
                return false;
            }
        }
        result = (result << 8) | octet;
        ++octets;
        if (octets < 4) {
            if (position >= text.size() || text[position] != '.') {
                return false;
            }
            ++position;
        }
    }
    if (position != text.size()) {
        return false;
    }
    value = result;
    return true;
}
 
bool Firewall::addRange(const std::string& cidr) {
    std::string address = cidr;
    unsigned int prefix = 32;
    const std::size_t slash = cidr.find('/');
    if (slash != std::string::npos) {
        address = cidr.substr(0, slash);
        const std::string prefixText = cidr.substr(slash + 1);
        if (prefixText.empty() || prefixText.size() > 2) {
            return false;
        }
        prefix = 0;
        for (char c : prefixText) {
            if (!std::isdigit(static_cast<unsigned char>(c))) {
                return false;
            }
            prefix = prefix * 10 + static_cast<unsigned int>(c - '0');
        }
        if (prefix > 32) {
            return false;
        }
    }
    std::uint32_t network = 0;
    if (!parseIpv4(address, network)) {
        return false;
    }
    const std::uint32_t mask = prefix == 0 ? 0u : 0xFFFFFFFFu << (32 - prefix);
    ranges_.push_back(Range{network & mask, mask, cidr});
    return true;
}
 
bool Firewall::isBlocked(const std::string& ip) const {
    std::uint32_t value = 0;
    if (!parseIpv4(ip, value)) {
        return true;
    }
    for (const Range& range : ranges_) {
        if ((value & range.mask) == range.network) {
            return true;
        }
    }
    return false;
}
 
std::vector<std::string> Firewall::ranges() const {
    std::vector<std::string> result;
    result.reserve(ranges_.size());
    for (const Range& range : ranges_) {
        result.push_back(range.text);
    }
    return result;
}