tcp_client.h

Go to the documentation of this file.

// Copyright (C) 2018-2025 Internet Systems Consortium, Inc. ("ISC")
//
// 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/.
 
#ifndef TCP_CLIENT_H
#define TCP_CLIENT_H
 
#include <asiolink/io_address.h>
#include <asiolink/io_service.h>
#include <asiolink/tls_socket.h>
#include <exceptions/exceptions.h>
#include <tcp/wire_data.h>
#include <boost/shared_ptr.hpp>
#include <functional>
#include <string>
#include <thread>
#include <vector>
 
namespace isc {
namespace tcp {

class TcpClientError : public Exception {
public:
    TcpClientError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};
 
class TcpClientImpl;

class TcpClient {
public:
    struct RequestTimeout {
        explicit RequestTimeout(long value)
            : value_(value) {
        }
        long value_; 
    };

    typedef std::function<void(const boost::system::error_code&,
                               const WireDataPtr&,
                               const std::string&)> RequestHandler;

    typedef std::function<int(const WireDataPtr&,
                              std::string&)> CompleteCheck;

    typedef std::function<bool(const boost::system::error_code&,
                               const int)> ConnectHandler;

    typedef std::function<bool(const boost::system::error_code&,
                               const int)> HandshakeHandler;

    typedef std::function<void(const int)> CloseHandler;

    explicit TcpClient(const asiolink::IOServicePtr& io_service,
                        bool multi_threading_enabled,
                        size_t thread_pool_size = 0,
                        bool defer_thread_start = false);

    ~TcpClient();

    void asyncSendRequest(const asiolink::IOAddress& address,
                          const uint16_t port,
                          const asiolink::TlsContextPtr& tls_context,
                          const WireDataPtr& request,
                          const WireDataPtr& response,
                          const bool persistent,
                          const CompleteCheck& complete_check,
                          const RequestHandler& request_callback,
                          const RequestTimeout& request_timeout =
                          RequestTimeout(10000),
                          const ConnectHandler& connect_callback =
                          ConnectHandler(),
                          const HandshakeHandler& handshake_callback =
                          HandshakeHandler(),
                          const CloseHandler& close_callback =
                          CloseHandler());

    void checkPermissions();

    void start();

    void pause();

    void resume();

    void stop();

    void closeIfOutOfBand(int socket_fd);

    const asiolink::IOServicePtr getThreadIOService() const;

    uint16_t getThreadPoolSize() const;

    uint16_t getThreadCount() const;

    bool isRunning();

    bool isStopped();

    bool isPaused();
 
private:

    boost::shared_ptr<TcpClientImpl> impl_;
};

typedef boost::shared_ptr<TcpClient> TcpClientPtr;
 
} // end of namespace isc::tcp
} // end of namespace isc
 
#endif