TestAndResetModule.cpp

Go to the documentation of this file.

/*
    Copyright (C) 2014-2016 Leosac

    This file is part of Leosac.

    Leosac is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Leosac is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

#include "TestAndResetModule.hpp"
#include "core/auth/Auth.hpp"
#include "tools/log.hpp"

using namespace Leosac::Module::TestAndReset;
using namespace Leosac::Hardware;

TestAndResetModule::~TestAndResetModule()
{
}

TestAndResetModule::TestAndResetModule(zmqpp::context &ctx, zmqpp::socket *pipe,
                                       const boost::property_tree::ptree &cfg,
                                       CoreUtilsPtr utils)
    : BaseModule(ctx, pipe, cfg, utils)
    , kernel_sock_(ctx, zmqpp::socket_type::req)
    , sub_(ctx, zmqpp::socket_type::sub)
    , test_led_(nullptr)
    , test_buzzer_(nullptr)
    , run_on_start_(true)
    , promisc_(false)
{
    sub_.connect("inproc://zmq-bus-pub");
    kernel_sock_.connect("inproc://leosac-kernel");

    process_config();
    reactor_.add(sub_, std::bind(&TestAndResetModule::handle_bus_msg, this));
    if (run_on_start_)
        run_test_sequence();
}

void TestAndResetModule::process_config()
{
    boost::property_tree::ptree module_config = config_.get_child("module_config");
    std::string test_device_led = module_config.get<std::string>("test_led", "");
    std::string test_device_buzzer =
        module_config.get<std::string>("test_buzzer", "");
    run_on_start_       = module_config.get<bool>("run_on_start", true);
    promisc_            = module_config.get<bool>("promisc", false);
    const auto &devices = module_config.get_child_optional("devices");

    if (!test_device_led.empty())
        test_led_ = std::unique_ptr<FLED>(new FLED(ctx_, test_device_led));
    if (!test_device_buzzer.empty())
        test_buzzer_ = std::unique_ptr<FLED>(new FLED(ctx_, test_device_buzzer));

    if (devices)
    {
        for (auto &node : module_config.get_child("devices"))
        {
            boost::property_tree::ptree device_cfg = node.second;

            std::string device_name = device_cfg.get_child("name").data();
            config_check(device_name);
            std::string reset_card = device_cfg.get<std::string>("reset_card", "");
            std::string test_card  = device_cfg.get<std::string>("test_card", "");

            sub_.subscribe("S_" + device_name);
            if (!reset_card.empty())
                device_reset_card_[device_name] = reset_card;
            if (!test_card.empty())
                device_test_card_[device_name] = test_card;
        }
    }

    if (promisc_)
    {
        std::string reset_card = module_config.get<std::string>("reset_card");
        device_reset_card_["__promisc"] = reset_card;
        sub_.subscribe("");
    }
}

void TestAndResetModule::handle_bus_msg()
{
    zmqpp::message msg;
    std::string src;
    Leosac::Auth::SourceType type;
    std::string card;

    sub_.receive(msg);

    if (msg.parts() < 4)
        return;
    msg >> src >> type >> card;

    if (type != Leosac::Auth::SourceType::SIMPLE_WIEGAND)
    {
        ERROR("Invalid auth source type ! Doing nothing.");
        return;
    }

    if (promisc_)
    {
        if (has_reset_card(card))
            kernel_sock_.send("RESET");
    }
    else
    {
        // remove "S_" from topic string
        src = src.substr(2, src.size());
        if (device_reset_card_.count(src) && device_reset_card_[src] == card)
        {
            kernel_sock_.send("RESET");
        }
    }

    if (device_test_card_.count(src) && device_test_card_[src] == card)
    {
        INFO("Test card read.");
        run_test_sequence();
    }
}

void TestAndResetModule::run_test_sequence()
{
    DEBUG("Running test sequence...");
    if (test_buzzer_)
    {
        test_buzzer_->blink(4000, 500);
    }
    if (test_led_)
    {
        test_led_->blink(4000, 500);
    }
    if (!test_led_ && !test_buzzer_)
    {
        NOTICE("Test sequence doing nothing...");
    }
}

bool TestAndResetModule::has_reset_card(const std::string &card_id) const
{
    return std::find_if(device_reset_card_.begin(), device_reset_card_.end(),
                        [&](std::pair<std::string, std::string> p) -> bool {
                            return p.second == card_id;
                        }) != device_reset_card_.end();
}