api.hh

/*
 * This file is open source software, licensed to you under the terms
 * of the Apache License, Version 2.0 (the "License").  See the NOTICE file
 * distributed with this work for additional information regarding copyright
 * ownership.  You may not use this file except in compliance with the License.
 *
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
/*
 * Copyright (C) 2014 Cloudius Systems, Ltd.
 */
 
#pragma once
 
#ifndef SEASTAR_MODULE
#include <chrono>
#include <memory>
#include <vector>
#include <cstring>
#include <sys/types.h>
#endif
 
#include <seastar/core/future.hh>
#include <seastar/net/byteorder.hh>
#include <seastar/net/socket_defs.hh>
#include <seastar/net/packet.hh>
#include <seastar/core/internal/api-level.hh>
#include <seastar/core/temporary_buffer.hh>
#include <seastar/core/file-types.hh>
#include <seastar/core/iostream.hh>
#include <seastar/util/std-compat.hh>
#include <seastar/util/program-options.hh>
#include <seastar/util/modules.hh>
 
namespace seastar {
 
inline
bool is_ip_unspecified(const ipv4_addr& addr) noexcept {
    return addr.is_ip_unspecified();
}
 
inline
bool is_port_unspecified(const ipv4_addr& addr) noexcept {
    return addr.is_port_unspecified();
}
 
inline
socket_address make_ipv4_address(const ipv4_addr& addr) noexcept {
    return socket_address(addr);
}
 
inline
socket_address make_ipv4_address(uint32_t ip, uint16_t port) noexcept {
    return make_ipv4_address(ipv4_addr(ip, port));
}
 
namespace net {
 
// see linux tcp(7) for parameter explanation
struct tcp_keepalive_params {
    std::chrono::seconds idle; // TCP_KEEPIDLE
    std::chrono::seconds interval; // TCP_KEEPINTVL
    unsigned count; // TCP_KEEPCNT
};
 
// see linux sctp(7) for parameter explanation
struct sctp_keepalive_params {
    std::chrono::seconds interval; // spp_hbinterval
    unsigned count; // spp_pathmaxrt
};
 
using keepalive_params = std::variant<tcp_keepalive_params, sctp_keepalive_params>;
 
class connected_socket_impl;
class socket_impl;
 
class server_socket_impl;
class datagram_channel_impl;
class get_impl;
 
class datagram_impl {
public:
    virtual ~datagram_impl() {};
    virtual socket_address get_src() = 0;
    virtual socket_address get_dst() = 0;
    virtual uint16_t get_dst_port() = 0;
    virtual packet& get_data() = 0;
};
 
using udp_datagram_impl = datagram_impl;
 
class datagram final {
private:
    std::unique_ptr<datagram_impl> _impl;
public:
    datagram(std::unique_ptr<datagram_impl>&& impl) noexcept : _impl(std::move(impl)) {};
    socket_address get_src() { return _impl->get_src(); }
    socket_address get_dst() { return _impl->get_dst(); }
    uint16_t get_dst_port() { return _impl->get_dst_port(); }
    packet& get_data() { return _impl->get_data(); }
};
 
using udp_datagram = datagram;
 
class datagram_channel {
private:
    std::unique_ptr<datagram_channel_impl> _impl;
public:
    datagram_channel() noexcept;
    datagram_channel(std::unique_ptr<datagram_channel_impl>) noexcept;
    ~datagram_channel();
 
    datagram_channel(datagram_channel&&) noexcept;
    datagram_channel& operator=(datagram_channel&&) noexcept;
 
    socket_address local_address() const;
 
    future<datagram> receive();
    future<> send(const socket_address& dst, const char* msg);
    future<> send(const socket_address& dst, packet p);
    bool is_closed() const;
    void shutdown_input();
    void shutdown_output();
    void close();
};
 
using udp_channel = datagram_channel;
 
class network_interface_impl;
 
} /* namespace net */
 
 
struct connected_socket_input_stream_config final {
    unsigned buffer_size = 8192;
    unsigned min_buffer_size = 512;
    unsigned max_buffer_size = 128 * 1024;
};
 
struct session_dn {
    sstring subject;
    sstring issuer;
};
 
class connected_socket {
    friend class net::get_impl;
    std::unique_ptr<net::connected_socket_impl> _csi;
public:
    connected_socket() noexcept;
    ~connected_socket();
 
    explicit connected_socket(std::unique_ptr<net::connected_socket_impl> csi) noexcept;
    connected_socket(connected_socket&& cs) noexcept;
    connected_socket& operator=(connected_socket&& cs) noexcept;
    input_stream<char> input(connected_socket_input_stream_config csisc = {});
    output_stream<char> output(size_t buffer_size = 8192);
    void set_nodelay(bool nodelay);
    bool get_nodelay() const;
    void set_keepalive(bool keepalive);
    bool get_keepalive() const;
    void set_keepalive_parameters(const net::keepalive_params& p);
    net::keepalive_params get_keepalive_parameters() const;
    void set_sockopt(int level, int optname, const void* data, size_t len);
    int get_sockopt(int level, int optname, void* data, size_t len) const;
    socket_address local_address() const noexcept;
    socket_address remote_address() const noexcept;
 
    void shutdown_output();
    void shutdown_input();
    explicit operator bool() const noexcept {
        return static_cast<bool>(_csi);
    }
    future<> wait_input_shutdown();
};
 
 
class socket {
    std::unique_ptr<net::socket_impl> _si;
public:
    socket() noexcept = default;
    ~socket();
 
    explicit socket(std::unique_ptr<net::socket_impl> si) noexcept;
    socket(socket&&) noexcept;
    socket& operator=(socket&&) noexcept;
 
    future<connected_socket> connect(socket_address sa, socket_address local = {}, transport proto = transport::TCP);
 
    void set_reuseaddr(bool reuseaddr);
    bool get_reuseaddr() const;
    void shutdown();
};
 
 
 
struct accept_result {
    connected_socket connection;  
    socket_address remote_address;  
};
 
class server_socket {
    std::unique_ptr<net::server_socket_impl> _ssi;
    bool _aborted = false;
public:
    enum class load_balancing_algorithm {
        // This algorithm tries to distribute all connections equally between all shards.
        // It does this by sending new connections to a shard with smallest amount of connections.
        connection_distribution,
        // This algorithm distributes new connection based on peer's tcp port. Destination shard
        // is calculated as a port number modulo number of shards. This allows a client to connect
        // to a specific shard in a server given it knows how many shards server has by choosing
        // src port number accordingly.
        port,
        // This algorithm distributes all new connections to listen_options::fixed_cpu shard only.
        fixed,
        default_ = connection_distribution
    };
    server_socket() noexcept;
    explicit server_socket(std::unique_ptr<net::server_socket_impl> ssi) noexcept;
    server_socket(server_socket&& ss) noexcept;
    ~server_socket();
    server_socket& operator=(server_socket&& cs) noexcept;
 
    future<accept_result> accept();
 
    void abort_accept();
 
    socket_address local_address() const noexcept;
 
    explicit operator bool() const noexcept {
        return static_cast<bool>(_ssi);
    }
};
 
 
struct listen_options {
    bool reuse_address = false;
    server_socket::load_balancing_algorithm lba = server_socket::load_balancing_algorithm::default_;
    transport proto = transport::TCP;
    int listen_backlog = 100;
    unsigned fixed_cpu = 0u;
    std::optional<file_permissions> unix_domain_socket_permissions;
    void set_fixed_cpu(unsigned cpu) {
        lba = server_socket::load_balancing_algorithm::fixed;
        fixed_cpu = cpu;
    }
};
 
class network_interface {
private:
    shared_ptr<net::network_interface_impl> _impl;
public:
    network_interface() = delete;
    network_interface(shared_ptr<net::network_interface_impl>) noexcept;
    network_interface(network_interface&&) noexcept;
 
    network_interface& operator=(network_interface&&) noexcept;
 
    uint32_t index() const;
    uint32_t mtu() const;
 
    const sstring& name() const;
    const sstring& display_name() const;
    const std::vector<net::inet_address>& addresses() const;
    const std::vector<uint8_t> hardware_address() const;
 
    bool is_loopback() const;
    bool is_virtual() const;
    bool is_up() const;
    bool supports_ipv6() const;
};
 
class network_stack {
public:
    virtual ~network_stack() {}
    virtual server_socket listen(socket_address sa, listen_options opts) = 0;
    // FIXME: local parameter assumes ipv4 for now, fix when adding other AF
    future<connected_socket> connect(socket_address sa, socket_address = {}, transport proto = transport::TCP);
    virtual ::seastar::socket socket() = 0;
 
    [[deprecated("Use `make_[un]bound_datagram_channel` instead")]]
    virtual net::udp_channel make_udp_channel(const socket_address& = {}) = 0;
 
    virtual net::datagram_channel make_unbound_datagram_channel(sa_family_t) = 0;
    virtual net::datagram_channel make_bound_datagram_channel(const socket_address& local) = 0;
    virtual future<> initialize() {
        return make_ready_future();
    }
    virtual bool has_per_core_namespace() = 0;
    // NOTE: this is not a correct query approach.
    // This question should be per NIC, but we have no such
    // abstraction, so for now this is "stack-wide"
    virtual bool supports_ipv6() const {
        return false;
    }
 
    virtual std::vector<network_interface> network_interfaces();
};
 
struct network_stack_entry {
    using factory_func = noncopyable_function<future<std::unique_ptr<network_stack>> (const program_options::option_group&)>;
 
    sstring name;
    std::unique_ptr<program_options::option_group> opts;
    factory_func factory;
    bool is_default;
};
 
}