io_fetch.h

Go to the documentation of this file.

// Copyright (C) 2010-2018 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 1

#include <config.h>

#include <boost/shared_array.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/date_time/posix_time/posix_time_types.hpp>

// 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 <boost/system/error_code.hpp>
#include <asiolink/io_address.h>
#include <asiolink/io_service.h>

#include <util/buffer.h>
#include <dns/question.h>
#include <dns/message.h>

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,           
        OPEN = 1,
        SEND = 2,
        RECEIVE = 3,
        CLOSE = 4
    };

    enum Result {
        SUCCESS = 0,        
        TIME_OUT = 1,       
        STOPPED = 2,        
        NOTSET = 3          
    };

    // The next enum is a "trick" to allow constants to be defined in a class
    // declaration.

    enum {
        STAGING_LENGTH = 8192   
    };

    class Callback {
    public:
        Callback()
        {}

        virtual ~Callback()
        {}

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

    IOFetch(Protocol protocol, isc::asiolink::IOService& 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, isc::asiolink::IOService& 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, isc::asiolink::IOService& 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,
            isc::asiolink::IOService& 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);

    // Member variables.  All data is in a structure pointed to by a shared
    // pointer.  The IOFetch object is copied a number of times during its
    // life, and only requiring a pointer to be copied reduces overhead.
    boost::shared_ptr<IOFetchData>  data_;   

};

} // namespace asiodns
} // namespace isc

#endif // IO_FETCH_H