io_fetch.h

Go to the documentation of this file.

// Copyright (C) 2010-2024 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>
 
// We want to use coroutine.hpp from the system's boost headers if possible.
// However, very old Boost versions (provided by RHEL 7 or CentOS 7) didn't have
// this header. So we can resort to our bundled version, but only if necessary.
#ifdef HAVE_BOOST_ASIO_COROUTINE_HPP
#include <boost/asio/coroutine.hpp>
#else
#include <ext/coroutine/coroutine.hpp>
#endif
 
#include <asiolink/io_address.h>
#include <asiolink/io_service.h>
#include <dns/message.h>
#include <dns/question.h>
#include <util/buffer.h>
 
#include <boost/shared_array.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/date_time/posix_time/posix_time_types.hpp>
#include <boost/system/error_code.hpp>
 
namespace isc {
namespace asiodns {
 
// Forward declarations
struct IOFetchData;
 
class IOFetch : public boost::asio::coroutine {
public:
    enum Protocol {
        UDP = 0,
        TCP = 1
    };
 
    enum Origin {
        NONE = 0,          // No asynchronous call outstanding
        OPEN = 1,
        SEND = 2,
        RECEIVE = 3,
        CLOSE = 4
    };
 
    enum Result {
        SUCCESS = 0,       // Success, fetch completed
        TIME_OUT = 1,      // Failure, fetch timed out
        STOPPED = 2,       // Control code, fetch has been stopped
        NOTSET = 3         // For testing, indicates value not set
    };
 
 
    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