ceph/src/seastar/src/net/stack.cc

   1 /*
   2  * This file is open source software, licensed to you under the terms
   3  * of the Apache License, Version 2.0 (the "License").  See the NOTICE file
   4  * distributed with this work for additional information regarding copyright
   5  * ownership.  You may not use this file except in compliance with the License.
   6  *
   7  * You may obtain a copy of the License at
   8  *
   9  *   http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing,
  12  * software distributed under the License is distributed on an
  13  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  14  * KIND, either express or implied.  See the License for the
  15  * specific language governing permissions and limitations
  16  * under the License.
  17  */
  18 /*
  19  * Copyright 2015 Cloudius Systems
  20  */
  21
  22 #include <seastar/net/stack.hh>
  23 #include <seastar/core/reactor.hh>
  24
  25 namespace seastar {
  26
  27 net::udp_channel::udp_channel()
  28 {}
  29
  30 net::udp_channel::udp_channel(std::unique_ptr<udp_channel_impl> impl) : _impl(std::move(impl))
  31 {}
  32
  33 net::udp_channel::~udp_channel()
  34 {}
  35
  36 net::udp_channel::udp_channel(udp_channel&&) = default;
  37 net::udp_channel& net::udp_channel::operator=(udp_channel&&) = default;
  38
  39 future<net::udp_datagram> net::udp_channel::receive() {
  40     return _impl->receive();
  41 }
  42
  43 future<> net::udp_channel::send(ipv4_addr dst, const char* msg) {
  44     return _impl->send(std::move(dst), msg);
  45 }
  46
  47 future<> net::udp_channel::send(ipv4_addr dst, packet p) {
  48     return _impl->send(std::move(dst), std::move(p));
  49 }
  50
  51 bool net::udp_channel::is_closed() const {
  52     return _impl->is_closed();
  53 }
  54
  55 void net::udp_channel::shutdown_input() {
  56     _impl->shutdown_input();
  57 }
  58
  59 void net::udp_channel::shutdown_output() {
  60     _impl->shutdown_output();
  61 }
  62
  63
  64 void net::udp_channel::close() {
  65     return _impl->close();
  66 }
  67
  68 connected_socket::connected_socket()
  69 {}
  70
  71 connected_socket::connected_socket(
  72         std::unique_ptr<net::connected_socket_impl> csi)
  73         : _csi(std::move(csi)) {
  74 }
  75
  76 connected_socket::connected_socket(connected_socket&& cs) noexcept = default;
  77 connected_socket& connected_socket::operator=(connected_socket&& cs) noexcept = default;
  78
  79 connected_socket::~connected_socket()
  80 {}
  81
  82 input_stream<char> connected_socket::input() {
  83     return input_stream<char>(_csi->source());
  84 }
  85
  86 output_stream<char> connected_socket::output(size_t buffer_size) {
  87     // TODO: allow user to determine buffer size etc
  88     return output_stream<char>(_csi->sink(), buffer_size, false, true);
  89 }
  90
  91 void connected_socket::set_nodelay(bool nodelay) {
  92     _csi->set_nodelay(nodelay);
  93 }
  94
  95 bool connected_socket::get_nodelay() const {
  96     return _csi->get_nodelay();
  97 }
  98 void connected_socket::set_keepalive(bool keepalive) {
  99     _csi->set_keepalive(keepalive);
 100 }
 101 bool connected_socket::get_keepalive() const {
 102     return _csi->get_keepalive();
 103 }
 104 void connected_socket::set_keepalive_parameters(const net::keepalive_params& p) {
 105     _csi->set_keepalive_parameters(p);
 106 }
 107 net::keepalive_params connected_socket::get_keepalive_parameters() const {
 108     return _csi->get_keepalive_parameters();
 109 }
 110
 111 void connected_socket::shutdown_output() {
 112     _csi->shutdown_output();
 113 }
 114
 115 void connected_socket::shutdown_input() {
 116     _csi->shutdown_input();
 117 }
 118
 119 socket::~socket()
 120 {}
 121
 122 socket::socket(
 123         std::unique_ptr<net::socket_impl> si)
 124         : _si(std::move(si)) {
 125 }
 126
 127 socket::socket(socket&&) noexcept = default;
 128 socket& socket::operator=(socket&&) noexcept = default;
 129
 130 future<connected_socket> socket::connect(socket_address sa, socket_address local, transport proto) {
 131     return _si->connect(sa, local, proto);
 132 }
 133
 134 void socket::shutdown() {
 135     _si->shutdown();
 136 }
 137
 138 server_socket::server_socket() {
 139 }
 140
 141 server_socket::server_socket(std::unique_ptr<net::server_socket_impl> ssi)
 142         : _ssi(std::move(ssi)) {
 143 }
 144 server_socket::server_socket(server_socket&& ss) noexcept = default;
 145 server_socket& server_socket::operator=(server_socket&& cs) noexcept = default;
 146
 147 server_socket::~server_socket() {
 148 }
 149
 150 future<connected_socket, socket_address> server_socket::accept() {
 151     if (_aborted) {
 152         return make_exception_future<connected_socket, socket_address>(std::system_error(ECONNABORTED, std::system_category()));
 153     }
 154     return _ssi->accept();
 155 }
 156
 157 void server_socket::abort_accept() {
 158     _ssi->abort_accept();
 159     _aborted = true;
 160 }
 161
 162 socket_address::socket_address(ipv4_addr addr)
 163     : socket_address(make_ipv4_address(addr))
 164 {}
 165
 166
 167 bool socket_address::operator==(const socket_address& a) const {
 168     // TODO: handle ipv6
 169     return std::tie(u.in.sin_family, u.in.sin_port, u.in.sin_addr.s_addr)
 170                     == std::tie(a.u.in.sin_family, a.u.in.sin_port,
 171                                     a.u.in.sin_addr.s_addr);
 172 }
 173
 174 }