socket.hpp

Go to the documentation of this file.

/*
 * Copyright © 2018 Max Mazurov (fox.cpp) <fox.cpp [at] disroot [dot] org>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#pragma once

#include <cstdint>
#include <tuple>
#include <system_error>
#include <vector>
#include <libwire/error.hpp>
#include "libwire/internal/bsdsocket.hpp"

/*
 * If you had to open this file to find answer for your question - we are so
 * sorry. Please open issue with your question so we can update documentation
 * to answer it.
 */

namespace libwire::tcp {
    class socket {
    public:
        socket() noexcept = default;

        socket(internal_::socket&& i) noexcept;

        socket(const socket&) = delete;
        socket(socket&&) noexcept = default;

        socket& operator=(const socket&) = delete;
        socket& operator=(socket&&) noexcept = default;

        ~socket();

        internal_::socket::native_handle_t native_handle() const noexcept;

        bool is_open() const;


        template<typename Option>
        auto option(const Option& /* tag */) const noexcept {
            return Option::get(*this);
        }

        template<typename Option, typename... Args>
        void set_option(const Option& /* tag */, Args&&... args) noexcept {
            Option::set(*this, std::forward<Args>(args)...);
        }


        endpoint local_endpoint() const noexcept;

        endpoint remote_endpoint() const noexcept;


        void connect(endpoint target, std::error_code& ec) noexcept;

        void shutdown(bool read = true, bool write = true) noexcept;

        void close() noexcept;


        template<typename Buffer = std::vector<uint8_t>>
        Buffer& read(size_t bytes_count, Buffer&, std::error_code&) noexcept;

        template<typename Buffer = std::vector<uint8_t>>
        Buffer read(size_t bytes_count, std::error_code&) noexcept;

        template<typename Buffer = std::vector<uint8_t>>
        Buffer& read_until(uint8_t delimiter, Buffer& buf, std::error_code&, size_t max_size = 0) noexcept;

        template<typename Buffer = std::vector<uint8_t>>
        Buffer read_until(uint8_t delimiter, std::error_code&, size_t max_size = 0) noexcept;

        template<typename Buffer = std::vector<uint8_t>>
        size_t write(const Buffer&, std::error_code&) noexcept;

#ifdef __cpp_exceptions

        void connect(endpoint target);

        template<typename Buffer = std::vector<uint8_t>>
        Buffer& read(size_t bytes_count, Buffer&);

        template<typename Buffer = std::vector<uint8_t>>
        Buffer read(size_t bytes_count);

        template<typename Buffer = std::vector<uint8_t>>
        size_t write(const Buffer&);

        template<typename Buffer = std::vector<uint8_t>>
        Buffer& read_until(uint8_t delimiter, Buffer& buf, size_t max_size = 0);

        template<typename Buffer = std::vector<uint8_t>>
        Buffer read_until(uint8_t delimiter, size_t max_size = 0);
#endif // ifdef __cpp_exceptions

    private:
        internal_::socket implementation;

        // Used as internal socket state tracker.
        bool open = false;
    };

    template<typename Buffer>
    Buffer& socket::read(size_t bytes_count, Buffer& output, std::error_code& ec) noexcept {
        static_assert(sizeof(std::remove_pointer_t<decltype(output.data())>) == sizeof(uint8_t),
                      "socket::read can't be used with container with non-byte elements");

        output.resize(bytes_count);
        size_t total_received = 0;
        // FIXME: Needs to be improved for non-blocking I/O.
        // Read exactly bytes_count bytes, retrying when needed.
        while (total_received < bytes_count) {
            size_t bytes_received =
                implementation.read(output.data() + total_received, bytes_count - total_received, ec);
            if (ec) {
                if (ec != error::interrupted) {
                    return output;
                }
            };
            total_received += bytes_received;
        }
        open = (ec != error::generic::disconnected);

        return output;
    }

    template<typename Buffer>
    Buffer socket::read(size_t bytes_count, std::error_code& ec) noexcept {
        Buffer buffer{};
        return read(bytes_count, buffer, ec);
    }

    extern template std::vector<uint8_t> socket::read(size_t, std::error_code&);
    extern template std::string socket::read(size_t, std::error_code&);

    extern template std::vector<uint8_t>& socket::read(size_t, std::vector<uint8_t>&, std::error_code&);
    extern template std::string& socket::read(size_t, std::string&, std::error_code&);

    template<typename Buffer>
    size_t socket::write(const Buffer& input, std::error_code& ec) noexcept {
        static_assert(sizeof(std::remove_pointer_t<decltype(input.data())>) == sizeof(uint8_t),
                      "socket::write can't be used with container with non-byte elements");

        auto res = implementation.write(input.data(), input.size(), ec);
        open = (ec != error::generic::disconnected);
        return res;
    }

    extern template size_t socket::write(const std::vector<uint8_t>&, std::error_code&);
    extern template size_t socket::write(const std::string&, std::error_code&);

    template<typename Buffer>
    Buffer& socket::read_until(uint8_t delimiter, Buffer& buf, std::error_code& ec, size_t max_size) noexcept {
        uint8_t byte;
        memory_view view{&byte, 1};
        buf.clear();
        while (read(1, view, ec), !ec) {
            if (byte == delimiter) break;
            if (max_size != 0 && buf.size() == max_size) break;
            buf.push_back(byte);
        }
        return buf;
    }

    template<typename Buffer>
    Buffer socket::read_until(uint8_t delimiter, std::error_code& ec, size_t max_size) noexcept {
        Buffer buffer{};
        read_until(delimiter, buffer, ec, max_size);
        return buffer;
    }

    extern template std::vector<uint8_t> socket::read_until(uint8_t, std::error_code&, size_t);
    extern template std::string socket::read_until(uint8_t, std::error_code&, size_t);

    extern template std::vector<uint8_t>& socket::read_until(uint8_t, std::vector<uint8_t>&, std::error_code&, size_t);
    extern template std::string& socket::read_until(uint8_t, std::string&, std::error_code&, size_t);

#ifdef __cpp_exceptions
    template<typename Buffer>
    Buffer& socket::read(size_t bytes_count, Buffer& output) {
        std::error_code ec;
        auto res = read<Buffer>(bytes_count, output, ec);
        if (ec) throw std::system_error(ec);
        return output;
    }

    template<typename Buffer>
    Buffer socket::read(size_t bytes_count) {
        Buffer buffer{};
        return read(bytes_count, buffer);
    }

    extern template std::vector<uint8_t>& socket::read(size_t, std::vector<uint8_t>&);
    extern template std::string& socket::read(size_t, std::string&);

    extern template std::vector<uint8_t> socket::read(size_t);
    extern template std::string socket::read(size_t);

    template<typename Buffer>
    size_t socket::write(const Buffer& input) {
        std::error_code ec;
        size_t res = write<Buffer>(input, ec);
        if (ec) throw std::system_error(ec);
        return res;
    }

    extern template size_t socket::write(const std::vector<uint8_t>&);
    extern template size_t socket::write(const std::string&);

    template<typename Buffer>
    Buffer& socket::read_until(uint8_t delimiter, Buffer& buf, size_t max_size) {
        std::error_code ec;
        read_until<Buffer>(delimiter, buf, ec, max_size);
        if (ec) throw std::system_error(ec);
        return buf;
    }

    template<typename Buffer>
    Buffer socket::read_until(uint8_t delimiter, size_t max_size) {
        std::error_code ec;
        auto res = read_until<Buffer>(delimiter, ec, max_size);
        if (ec) throw std::system_error(ec);
        return res;
    }

    extern template std::vector<uint8_t>& socket::read_until(uint8_t, std::vector<uint8_t>&, size_t);
    extern template std::string& socket::read_until(uint8_t, std::string&, size_t);

    extern template std::vector<uint8_t> socket::read_until(uint8_t, size_t);
    extern template std::string socket::read_until(uint8_t, size_t);
#endif // ifdef __cpp_exceptions
} // namespace libwire::tcp