io_fetch.h

Go to the documentation of this file.

// Copyright (C) 2010-2026 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 IO_FETCH_H
#define IO_FETCH_H
 
#include <config.h>
 
#include <asiolink/io_address.h>
#include <asiolink/io_service.h>
#include <dns/message.h>
#include <dns/question.h>
#include <util/buffer.h>
 
#include <cstdint>
 
#include <boost/asio/coroutine.hpp>
#include <boost/asio/system_timer.hpp>
#include <boost/date_time/posix_time/posix_time_types.hpp>
#include <boost/shared_array.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/system/error_code.hpp>
 
namespace isc {
namespace asiodns {
 
// Forward declarations
struct IOFetchData;

class IOFetch : public boost::asio::coroutine {
public:
    enum Protocol : uint16_t {
        UDP = 0,
        TCP = 1
    };

    enum Origin : uint16_t {
        NONE = 0,          // No asynchronous call outstanding
        OPEN = 1,
        SEND = 2,
        RECEIVE = 3,
        CLOSE = 4
    };

    enum Result : uint16_t {
        SUCCESS = 0,       // Success, fetch completed
        TIME_OUT = 1,      // Failure, fetch timed out
        STOPPED = 2,       // Control code, fetch has been stopped
        IO_ERROR = 3,      // Failure, asynchronous I/O returned an error
        NOTSET = 4         // For testing, indicates value not set
    };

    static std::string const& resultToText(Result const& result) {
        static std::vector<std::string> const text_vector {
            "SUCCESS",
            "TIME_OUT",
            "STOPPED",
            "IO_ERROR",
            "NOTSET",
        };
        static std::string const unknown("UNKNOWN");
        return (result < text_vector.size() ? text_vector[result] : unknown);
    }


    enum {
        STAGING_LENGTH = 8192   // Size of staging buffer
    };

    class Callback {
    public:
        Callback() = default;

        virtual ~Callback() = default;

        virtual void operator()(Result result) = 0;
    };

    IOFetch(Protocol protocol,
            const isc::asiolink::IOServicePtr& service,
            const isc::dns::Question& question,
            const isc::asiolink::IOAddress& address,
            uint16_t port,
            isc::util::OutputBufferPtr& buff,
            Callback* cb,
            int wait = -1,
            bool edns = true);

    IOFetch(Protocol protocol,
            const isc::asiolink::IOServicePtr& service,
            isc::dns::ConstMessagePtr query_message,
            const isc::asiolink::IOAddress& address,
            uint16_t port,
            isc::util::OutputBufferPtr& buff,
            Callback* cb,
            int wait = -1);

    IOFetch(Protocol protocol,
            const isc::asiolink::IOServicePtr& service,
            isc::util::OutputBufferPtr& outpkt,
            const isc::asiolink::IOAddress& address,
            uint16_t port,
            isc::util::OutputBufferPtr& buff,
            Callback* cb,
            int wait = -1);

    Protocol getProtocol() const;

    void operator()(boost::system::error_code ec = boost::system::error_code(),
                    size_t length = 0);

    void stop(Result reason = STOPPED);
 
private:
    void initIOFetch(isc::dns::MessagePtr& query_message,
                     Protocol protocol,
                     const isc::asiolink::IOServicePtr& service,
                     const isc::dns::Question& question,
                     const isc::asiolink::IOAddress& address,
                     uint16_t port,
                     isc::util::OutputBufferPtr& buff,
                     Callback* cb, int wait,
                     bool edns = true);

    void logIOFailure(boost::system::error_code ec);

    boost::shared_ptr<IOFetchData> data_;   
};

typedef boost::shared_ptr<IOFetch> IOFetchPtr;
 
}  // namespace asiodns
}  // namespace isc
 
#endif // IO_FETCH_H