stop.hpp

Go to the documentation of this file.

//    OpenVPN -- An application to securely tunnel IP networks
//               over a single port, with support for SSL/TLS-based
//               session authentication and key exchange,
//               packet encryption, packet authentication, and
//               packet compression.
//
//    Copyright (C) 2012- OpenVPN Inc.
//
//    SPDX-License-Identifier: MPL-2.0 OR AGPL-3.0-only WITH openvpn3-openssl-exception
//
 
#ifndef OPENVPN_COMMON_STOP_H
#define OPENVPN_COMMON_STOP_H
 
#include <vector>
#include <functional>
#include <utility>
#include <mutex>
 
#include <openvpn/common/exception.hpp>
 
OPENVPN_EXCEPTION_INHERIT(std::range_error, openvpn_stop_limit);
 
namespace openvpn {
 
class Stop
{
  public:
    class Scope
    {
        friend Stop;
 
      public:
        Scope(Stop *stop_arg, std::function<void()> &&method_arg)
            : stop(stop_arg),
              method(std::move(method_arg)),
              index(-1)
        {
            constexpr int stop_index_limit = 1000;
            if (stop)
            {
                const std::lock_guard<std::recursive_mutex> lock(stop->mutex);
                if (stop->stop_called)
                {
                    // stop already called, call method immediately
                    method();
                }
                else
                {
                    if (index > stop_index_limit)
                        throw openvpn_stop_limit("Stop count limit exceeded");
 
                    index = static_cast<decltype(index)>(stop->scopes.size());
                    stop->scopes.push_back(this);
                }
            }
        }
 
        ~Scope()
        {
            if (stop)
            {
                const std::lock_guard<std::recursive_mutex> lock(stop->mutex);
                if (index >= 0 && index < static_cast<int>(stop->scopes.size()) && stop->scopes[index] == this)
                {
                    stop->scopes[index] = nullptr;
                    stop->prune();
                }
            }
        }
 
      private:
        Scope(const Scope &) = delete;
        Scope &operator=(const Scope &) = delete;
 
        Stop *const stop;
        const std::function<void()> method;
        int index;
    };
 
    Stop() = default;
 
    void stop()
    {
        const std::lock_guard<std::recursive_mutex> lock(mutex);
        stop_called = true;
        while (!scopes.empty())
        {
            Scope *scope = scopes.back();
            scopes.pop_back();
            if (scope)
            {
                scope->index = -1;
                scope->method();
            }
        }
    }
 
    static bool is_triggered(const Stop *stop)
    {
        return stop && stop->stop_called;
    }
 
    Stop(const Stop &) = delete;
    Stop &operator=(const Stop &) = delete;
 
  private:
    void prune()
    {
        while (!scopes.empty() && !scopes.back())
            scopes.pop_back();
    }
 
    std::recursive_mutex mutex;
    std::vector<Scope *> scopes;
    volatile bool stop_called = false;
};
 
} // namespace openvpn
 
#endif