Skip to content

Implementation of a Network module

fxnabes edited this page Mar 2, 2019 · 7 revisions

Network module implementation

Description

The following module filters connection based on a list of allowed IP addresses.

IpWhiteListModule.hpp

#pragma once

#include "zia/api/IModuleDescriptor.hpp"
#include "zia/api/INetworkModule.hpp"
#include "zia/net/Address.hpp"

class IpWhiteListModule : public zia::api::INetworkModule {
public:
    IpWhiteListModule();

    zia::api::HookResult onAccept(
        const zia::net::Connection &connection) override;

    zia::api::HookResult doRead(const zia::net::Connection &connection,
                                zia::net::Buffer &buffer) override;

    zia::api::HookResult onRead(const zia::net::Connection &connection,
                                zia::net::Buffer &buffer) override;

    zia::api::HookResult doWrite(const zia::net::Connection &connection,
                                 zia::net::Buffer &buffer) override;

    zia::api::HookResult onWrite(const zia::net::Connection &connection,
                                 zia::net::Buffer &buffer) override;

    zia::api::HookResult onClose(
        const zia::net::Connection &connection) override;

    void loadConfiguration(
        std::unordered_map<std::string, std::string> const &config) override;

private:
    std::vector<zia::net::Address> parseIpList(std::string const &ipList);

private:
    std::vector<zia::net::Address> _ipList;
};

class IpWhiteListModuleDescriptor : public zia::api::IModuleDescriptor {
public:
    IpWhiteListModuleDescriptor() = default;

    zia::api::ModuleType getType() const override
    {
        return _type;
    }

    const std::string &getName() const override
    {
        return _name;
    }

    const std::vector<zia::api::ConfigKey> &getConfigKeys() const override
    {
        return _configKey;
    }

    std::unique_ptr<zia::api::IModule> create() override
    {
        return std::make_unique<IpWhiteListModule>();
    }

private:
    static const zia::api::ModuleType _type = zia::api::ModuleType::Network;
    static const std::string _name;
    static const std::vector<zia::api::ConfigKey> _configKey;
};

IpWhitelistModule.cpp

#include <arpa/inet.h>
#include <netinet/in.h>
#include "IpWhiteListModule.hpp"
#include "zia/api/ConfigurationError.hpp"

IpWhiteListModule::IpWhiteListModule() : _ipList() {}

void IpWhiteListModule::loadConfiguration(
    std::unordered_map<std::string, std::string> const &config)
{
    _ipList = parseIpList(config.at("WhiteListedIps"));
}

zia::api::HookResult IpWhiteListModule::onAccept(
    const zia::net::Connection &connection)
{
    for (auto const &addr : _ipList) {
        if (connection.endpoint.address == addr) {
            return zia::api::HookResult::Ok;
        }
    }
    return zia::api::HookResult::Abort;
}

zia::api::HookResult IpWhiteListModule::doRead(const zia::net::Connection &,
                                               zia::net::Buffer &)
{
    return zia::api::HookResult::Declined;
}

zia::api::HookResult IpWhiteListModule::onRead(const zia::net::Connection &,
                                               zia::net::Buffer &)
{
    return zia::api::HookResult::Declined;
}

zia::api::HookResult IpWhiteListModule::doWrite(const zia::net::Connection &,
                                                zia::net::Buffer &)
{
    return zia::api::HookResult::Declined;
}

zia::api::HookResult IpWhiteListModule::onWrite(const zia::net::Connection &,
                                                zia::net::Buffer &)
{
    return zia::api::HookResult::Declined;
}

zia::api::HookResult IpWhiteListModule::onClose(const zia::net::Connection &)
{
    return zia::api::HookResult::Declined;
}

std::vector<zia::net::Address> IpWhiteListModule::parseIpList(
    std::string const &ipList)
{
    std::size_t it = 0;
    std::string substr;
    std::string cpy(ipList);
    std::vector<std::uint32_t> vec;
    in_addr addr;

    while (it < cpy.length()) {
        substr = cpy.substr(it, cpy.find(','));
        cpy = cpy.substr(it);
        it = cpy.find(',') + 1;
        if (it == 0) {
            it = cpy.length();
        }
        if (inet_aton(substr.c_str(), &addr) == 0) {
            throw zia::api::ConfigurationError(
                "IpWhiteListModule : error in ip list");
        }
        vec.push_back(ntohl(addr.s_addr));
    }
    return vec;
}

const std::string IpWhiteListModuleDescriptor::_name =
    std::string("IpWhiteList");

const std::vector<zia::api::ConfigKey> IpWhiteListModuleDescriptor::_configKey =
    {zia::api::ConfigKey{"whiteListedIps", ""}};

extern "C" {

IpWhiteListModuleDescriptor descriptor;

}

Clone this wiki locally