path: root/test/security_tests/security_test_client.cpp

// Copyright (C) 2017 Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include "security_test_client.hpp"

static bool is_remote_test = false;
static bool remote_client_allowed = true;

security_test_client::security_test_client(bool _test_external_communication,
                                           bool _is_remote_client_allowed)
    : app_(vsomeip::runtime::get()->create_application()),
      is_available_(false),
      sender_(std::bind(&security_test_client::run, this)),
      received_responses_(0),
      received_allowed_events_(0),
      test_external_communication_(_test_external_communication),
      is_remote_client_allowed_(_is_remote_client_allowed) {

}

bool security_test_client::init() {
    if (!app_->init()) {
        ADD_FAILURE() << "Couldn't initialize application";
        return false;
    }

    app_->register_state_handler(
            std::bind(&security_test_client::on_state, this,
                    std::placeholders::_1));

    app_->register_message_handler(vsomeip::ANY_SERVICE,
            vsomeip_test::TEST_SERVICE_INSTANCE_ID, vsomeip::ANY_METHOD,
            std::bind(&security_test_client::on_message, this,
                    std::placeholders::_1));

    app_->register_availability_handler(vsomeip_test::TEST_SERVICE_SERVICE_ID,
            vsomeip_test::TEST_SERVICE_INSTANCE_ID,
            std::bind(&security_test_client::on_availability, this,
                    std::placeholders::_1, std::placeholders::_2,
                    std::placeholders::_3));

    app_->register_availability_handler(0x111,
            vsomeip_test::TEST_SERVICE_INSTANCE_ID,
            std::bind(&security_test_client::on_availability, this,
                    std::placeholders::_1, std::placeholders::_2,
                    std::placeholders::_3));

    app_->register_availability_handler(vsomeip_test::TEST_SERVICE_SERVICE_ID,
            0x02,
            std::bind(&security_test_client::on_availability, this,
                    std::placeholders::_1, std::placeholders::_2,
                    std::placeholders::_3));
    return true;
}

void security_test_client::start() {
    VSOMEIP_INFO << "Starting...";

    app_->start();
}

void security_test_client::stop() {
    VSOMEIP_INFO << "Stopping...";

    if (is_remote_client_allowed_) {
        shutdown_service();
    }

    std::this_thread::sleep_for(std::chrono::milliseconds(100));

    app_->clear_all_handler();
    app_->stop();
}

void security_test_client::on_state(vsomeip::state_type_e _state) {
    if(_state == vsomeip::state_type_e::ST_REGISTERED) {
        app_->request_service(vsomeip_test::TEST_SERVICE_SERVICE_ID,
                vsomeip_test::TEST_SERVICE_INSTANCE_ID, false);

        // request not allowed service ID
        app_->request_service(0x111,
                vsomeip_test::TEST_SERVICE_INSTANCE_ID, false);

        // request not allowed instance ID
        app_->request_service(vsomeip_test::TEST_SERVICE_SERVICE_ID,
                0x02, false);

        // request events of eventgroup 0x01 which holds events 0x8001 (allowed) and 0x8002 (denied)
        std::set<vsomeip::eventgroup_t> its_eventgroups;
        its_eventgroups.insert(0x01);
        app_->request_event(vsomeip_test::TEST_SERVICE_SERVICE_ID, vsomeip_test::TEST_SERVICE_INSTANCE_ID,
                static_cast<vsomeip::event_t>(0x8001),
                its_eventgroups, vsomeip::event_type_e::ET_FIELD,
                vsomeip::reliability_type_e::RT_UNRELIABLE);
        app_->request_event(vsomeip_test::TEST_SERVICE_SERVICE_ID, vsomeip_test::TEST_SERVICE_INSTANCE_ID,
                static_cast<vsomeip::event_t>(0x8002),
                its_eventgroups, vsomeip::event_type_e::ET_FIELD,
                vsomeip::reliability_type_e::RT_UNRELIABLE);

        app_->subscribe(vsomeip_test::TEST_SERVICE_SERVICE_ID, vsomeip_test::TEST_SERVICE_INSTANCE_ID, 0x01,
                vsomeip::DEFAULT_MAJOR, static_cast<vsomeip::event_t>(0x8001));

        app_->subscribe(vsomeip_test::TEST_SERVICE_SERVICE_ID, vsomeip_test::TEST_SERVICE_INSTANCE_ID, 0x01,
                vsomeip::DEFAULT_MAJOR, static_cast<vsomeip::event_t>(0x8002));
    }
}

void security_test_client::on_availability(vsomeip::service_t _service,
        vsomeip::instance_t _instance, bool _is_available) {

    VSOMEIP_INFO << std::hex << "Client 0x" << app_->get_client()
            << " : Service [" << std::setw(4) << std::setfill('0') << std::hex
            << _service << "." << _instance << "] is "
            << (_is_available ? "available." : "NOT available.");

    // check that only the allowed service / instance ID gets available
    if (_is_available) {
        EXPECT_EQ(vsomeip_test::TEST_SERVICE_SERVICE_ID, _service);
        EXPECT_EQ(vsomeip_test::TEST_SERVICE_INSTANCE_ID, _instance);
    }

    if(vsomeip_test::TEST_SERVICE_SERVICE_ID == _service
            && vsomeip_test::TEST_SERVICE_INSTANCE_ID == _instance) {
        std::unique_lock<std::mutex> its_lock(mutex_);
        if(is_available_ && !_is_available) {
            is_available_ = false;
        }
        else if(_is_available && !is_available_) {
            is_available_ = true;
            condition_.notify_one();
        }
    }
}

void security_test_client::on_message(const std::shared_ptr<vsomeip::message> &_response) {
    VSOMEIP_INFO << "Received a response from Service ["
                 << std::setw(4) << std::setfill('0') << std::hex << _response->get_service()
                 << "."
                 << std::setw(4) << std::setfill('0') << std::hex << _response->get_instance()
                 << "] to Client/Session ["
                 << std::setw(4) << std::setfill('0') << std::hex << _response->get_client()
                 << "/"
                 << std::setw(4) << std::setfill('0') << std::hex << _response->get_session()
                 << "]";

    if(_response->get_message_type() == vsomeip::message_type_e::MT_RESPONSE) {
        EXPECT_EQ(vsomeip_test::TEST_SERVICE_SERVICE_ID,  _response->get_service());
        EXPECT_EQ(vsomeip_test::TEST_SERVICE_INSTANCE_ID, _response->get_instance());
        EXPECT_EQ(vsomeip_test::TEST_SERVICE_METHOD_ID, _response->get_method());

        if (_response->get_service() == vsomeip_test::TEST_SERVICE_SERVICE_ID &&
                _response->get_instance() == vsomeip_test::TEST_SERVICE_INSTANCE_ID &&
                _response->get_method() == vsomeip_test::TEST_SERVICE_METHOD_ID) {
            received_responses_++;
            if (received_responses_ == vsomeip_test::NUMBER_OF_MESSAGES_TO_SEND_SECURITY_TESTS) {
                VSOMEIP_WARNING << std::hex << app_->get_client()
                        << ": Received all messages ~> going down!";
            }
        }
    } else if (_response->get_message_type() == vsomeip::message_type_e::MT_NOTIFICATION) {
        // check that only allowed event 0x8001 is received
        EXPECT_EQ(vsomeip_test::TEST_SERVICE_SERVICE_ID,  _response->get_service());
        EXPECT_EQ(vsomeip_test::TEST_SERVICE_INSTANCE_ID, _response->get_instance());
        EXPECT_EQ(0x8001, _response->get_method());
        received_allowed_events_++;
    }
}

void security_test_client::run() {
    for (uint32_t i = 0; i < vsomeip_test::NUMBER_OF_MESSAGES_TO_SEND_SECURITY_TESTS; ++i) {
        {
            std::unique_lock<std::mutex> its_lock(mutex_);
            while (!is_available_)
            {
                condition_.wait(its_lock);
            }
        }

        auto request = vsomeip::runtime::get()->create_request(false);
        request->set_service(vsomeip_test::TEST_SERVICE_SERVICE_ID);
        request->set_instance(vsomeip_test::TEST_SERVICE_INSTANCE_ID);
        request->set_method(vsomeip_test::TEST_SERVICE_METHOD_ID);

        // send a request which is allowed by policy -> expect answer
        app_->send(request);

        // send a request with a not allowed method ID -> expect no answer
        request->set_method(0x888);
        app_->send(request);

        std::this_thread::sleep_for(std::chrono::milliseconds(250));
    }

    std::this_thread::sleep_for(std::chrono::milliseconds(250));

    if (!test_external_communication_) {
        EXPECT_EQ(vsomeip_test::NUMBER_OF_MESSAGES_TO_SEND_SECURITY_TESTS,
                received_responses_);
        EXPECT_EQ(received_allowed_events_, (uint32_t) 0x01);
    } else if (test_external_communication_ && !is_remote_client_allowed_) {
        EXPECT_EQ((uint32_t)0, received_responses_);
        EXPECT_EQ((uint32_t)0, received_allowed_events_);
    } else if (test_external_communication_ && is_remote_client_allowed_) {
        EXPECT_EQ(vsomeip_test::NUMBER_OF_MESSAGES_TO_SEND_SECURITY_TESTS,
                received_responses_);
        EXPECT_EQ(received_allowed_events_, (uint32_t) 0x01);
    }
    stop();
}

void security_test_client::join_sender_thread()
{
    if (sender_.joinable()) {
        sender_.join();
    }
}

void security_test_client::shutdown_service() {
    auto request = vsomeip::runtime::get()->create_request(false);
    request->set_service(vsomeip_test::TEST_SERVICE_SERVICE_ID);
    request->set_instance(vsomeip_test::TEST_SERVICE_INSTANCE_ID);
    request->set_method(vsomeip_test::TEST_SERVICE_METHOD_ID_SHUTDOWN);
    app_->send(request);
}

TEST(someip_security_test, basic_subscribe_request_response)
{
    security_test_client test_client(is_remote_test, remote_client_allowed);
    if (test_client.init()) {
        test_client.start();
        test_client.join_sender_thread();
    }
}

int main(int argc, char** argv) {

    std::string test_remote("--remote");
    std::string test_local("--local");
    std::string test_allow_remote_client("--allow");
    std::string test_deny_remote_client("--deny");
    std::string help("--help");

    int i = 1;
    while (i < argc)
    {
        if(test_remote == argv[i])
        {
            is_remote_test = true;
        }
        else if(test_local == argv[i])
        {
            is_remote_test = false;
        }
        else if(test_allow_remote_client == argv[i])
        {
            remote_client_allowed = true;
        }
        else if(test_deny_remote_client == argv[i])
        {
            remote_client_allowed = false;
        }
        else if(help == argv[i])
        {
            VSOMEIP_INFO << "Parameters:\n"
            << "--remote: Run test between two hosts\n"
            << "--local: Run test locally\n"
            << "--allow: test is started with a policy that allows remote messages sent by this test client to the service\n"
            << "--deny: test is started with a policy that denies remote messages sent by this test client to the service\n"
            << "--help: print this help";
        }
        i++;
    }

    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}