WebServiceNotifier.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 "WebServiceNotifier.hpp"
#include "core/auth/Auth.hpp"
#include "core/credentials/RFIDCard.hpp"
#include <curl/curl.h>

using namespace Leosac;
using namespace Leosac::Module;
using namespace Leosac::Module::WSNotifier;

WebServiceNotifier::WebServiceNotifier(zmqpp::context &ctx, zmqpp::socket *pipe,
                                       const boost::property_tree::ptree &cfg,
                                       CoreUtilsPtr utils)
    : BaseModule(ctx, pipe, cfg, utils)
    , bus_sub_(ctx, zmqpp::socket_type::sub)
{
    int ret;
    long flags = 0;

    if (config_.get<bool>("module_config.want_ssl", true))
        flags |= CURL_GLOBAL_SSL;
    if ((ret = curl_global_init(flags)) != 0)
    {
        throw std::runtime_error("Failed to initialize curl: return code: " +
                                 std::to_string(ret));
    }
    bus_sub_.connect("inproc://zmq-bus-pub");
    process_config();
    reactor_.add(bus_sub_, std::bind(&WebServiceNotifier::handle_msg_bus, this));
}

WebServiceNotifier::~WebServiceNotifier()
{
    curl_global_cleanup();
}

void WebServiceNotifier::handle_msg_bus()
{
    zmqpp::message msg;
    std::string src;
    Leosac::Auth::SourceType type;
    std::string card;
    int bits;

    bus_sub_.receive(msg);
    if (msg.parts() < 4)
    {
        WARN("Unexpected message content.");
        return;
    }
    msg >> src >> type >> card >> bits;
    if (type != Leosac::Auth::SourceType::SIMPLE_WIEGAND)
    {
        INFO("WS-Notifier cannot handle this type of credential yet.");
        return;
    }

    send_card_info_to_remote(src, card, bits);
}

void WebServiceNotifier::process_config()
{
    for (auto &&itr : config_.get_child("module_config.sources"))
    {
        auto name = itr.second.get<std::string>("");
        bus_sub_.subscribe("S_" + name);
    }

    for (auto &&itr : config_.get_child("module_config.targets"))
    {
        TargetInfo target;
        target.url_             = itr.second.get<std::string>("url");
        target.connect_timeout_ = itr.second.get<int>("connect_timeout", 7000);
        target.request_timeout_ = itr.second.get<int>("request_timeout", 7000);
        target.verify_host_     = itr.second.get<bool>("verify_host", true);
        target.verify_peer_     = itr.second.get<bool>("verify_peer", true);
        target.CA_info_file_    = itr.second.get<std::string>("ca_file", "");

        INFO("WS-Notifier remote target: "
             << Colorize::green(target.url_)
             << " (connect_timeout: " << Colorize::green(target.connect_timeout_)
             << ", request_timeout: " << Colorize::green(target.request_timeout_)
             << ", verify_host: " << Colorize::green(target.verify_host_)
             << ", verify_peer: " << Colorize::green(target.verify_peer_)
             << ", ca_info: " << Colorize::green(target.CA_info_file_) << ")");
        targets_.push_back(std::move(target));
    }
}

void WebServiceNotifier::send_card_info_to_remote(const std::string &auth_source,
                                                  const std::string &card_hex,
                                                  int nb_bits)
{
    auto card = Cred::RFIDCard();
    card.card_id(card_hex);
    card.nb_bits(nb_bits);

    for (const auto &target : targets_)
    {
        auto curl = curl_easy_init();
        if (curl)
        {
            if (!target.CA_info_file_.empty())
                curl_easy_setopt(curl, CURLOPT_CAINFO, target.CA_info_file_.c_str());
            if (!target.verify_host_)
                curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
            if (!target.verify_peer_)
                curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
            send_to_target(curl, auth_source, card, target);
            curl_easy_cleanup(curl);
        }
        else
        {
            ERROR("Cannot initialize curl_easy.");
        }
    }
}

static size_t write_callback(char * /*ptr*/, size_t size, size_t nmemb,
                             void * /*userdata*/)
{
    return size * nmemb;
}

void WebServiceNotifier::send_to_target(
    void *curl, const std::string &auth_source, const Cred::RFIDCard &card,
    const WebServiceNotifier::TargetInfo &target) noexcept
{
    assert(curl);

    std::string post_fields =
        fmt::format("card_id={}&auth_source={}&card_id_raw={}", card.to_int(),
                    auth_source, card.to_raw_int());

    curl_easy_setopt(curl, CURLOPT_URL, target.url_.c_str());
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, post_fields.c_str());

    // timeouts
    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT_MS, target.connect_timeout_);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, target.request_timeout_);

    curl_easy_setopt(curl, CURLOPT_WRITEDATA, nullptr);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &write_callback);

    auto res = curl_easy_perform(curl);
    if (res != CURLE_OK)
    {
        WARN("curl_easy_perform() failed: " << curl_easy_strerror(res));
    }
}