]>
Commit | Line | Data |
---|---|---|
11fdf7f2 TL |
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> | |
9f95a23c | 23 | #include <seastar/net/inet_address.hh> |
11fdf7f2 TL |
24 | |
25 | namespace seastar { | |
26 | ||
f67539c2 TL |
27 | static_assert(std::is_nothrow_default_constructible_v<connected_socket>); |
28 | static_assert(std::is_nothrow_move_constructible_v<connected_socket>); | |
29 | ||
30 | static_assert(std::is_nothrow_default_constructible_v<socket>); | |
31 | static_assert(std::is_nothrow_move_constructible_v<socket>); | |
32 | ||
33 | static_assert(std::is_nothrow_default_constructible_v<server_socket>); | |
34 | static_assert(std::is_nothrow_move_constructible_v<server_socket>); | |
35 | ||
36 | net::udp_channel::udp_channel() noexcept | |
11fdf7f2 TL |
37 | {} |
38 | ||
f67539c2 | 39 | net::udp_channel::udp_channel(std::unique_ptr<udp_channel_impl> impl) noexcept : _impl(std::move(impl)) |
11fdf7f2 TL |
40 | {} |
41 | ||
42 | net::udp_channel::~udp_channel() | |
43 | {} | |
44 | ||
f67539c2 TL |
45 | net::udp_channel::udp_channel(udp_channel&&) noexcept = default; |
46 | net::udp_channel& net::udp_channel::operator=(udp_channel&&) noexcept = default; | |
11fdf7f2 | 47 | |
9f95a23c | 48 | socket_address net::udp_channel::local_address() const { |
1e59de90 TL |
49 | if (_impl) { |
50 | return _impl->local_address(); | |
51 | } else { | |
52 | return {}; | |
53 | } | |
9f95a23c TL |
54 | } |
55 | ||
11fdf7f2 TL |
56 | future<net::udp_datagram> net::udp_channel::receive() { |
57 | return _impl->receive(); | |
58 | } | |
59 | ||
9f95a23c TL |
60 | future<> net::udp_channel::send(const socket_address& dst, const char* msg) { |
61 | return _impl->send(dst, msg); | |
11fdf7f2 TL |
62 | } |
63 | ||
9f95a23c TL |
64 | future<> net::udp_channel::send(const socket_address& dst, packet p) { |
65 | return _impl->send(dst, std::move(p)); | |
11fdf7f2 TL |
66 | } |
67 | ||
68 | bool net::udp_channel::is_closed() const { | |
69 | return _impl->is_closed(); | |
70 | } | |
71 | ||
72 | void net::udp_channel::shutdown_input() { | |
73 | _impl->shutdown_input(); | |
74 | } | |
75 | ||
76 | void net::udp_channel::shutdown_output() { | |
77 | _impl->shutdown_output(); | |
78 | } | |
79 | ||
80 | ||
81 | void net::udp_channel::close() { | |
82 | return _impl->close(); | |
83 | } | |
84 | ||
f67539c2 | 85 | connected_socket::connected_socket() noexcept |
11fdf7f2 TL |
86 | {} |
87 | ||
88 | connected_socket::connected_socket( | |
f67539c2 | 89 | std::unique_ptr<net::connected_socket_impl> csi) noexcept |
11fdf7f2 TL |
90 | : _csi(std::move(csi)) { |
91 | } | |
92 | ||
93 | connected_socket::connected_socket(connected_socket&& cs) noexcept = default; | |
94 | connected_socket& connected_socket::operator=(connected_socket&& cs) noexcept = default; | |
95 | ||
96 | connected_socket::~connected_socket() | |
97 | {} | |
98 | ||
f67539c2 TL |
99 | input_stream<char> connected_socket::input(connected_socket_input_stream_config csisc) { |
100 | return input_stream<char>(_csi->source(csisc)); | |
11fdf7f2 TL |
101 | } |
102 | ||
103 | output_stream<char> connected_socket::output(size_t buffer_size) { | |
20effc67 TL |
104 | output_stream_options opts; |
105 | opts.batch_flushes = true; | |
11fdf7f2 | 106 | // TODO: allow user to determine buffer size etc |
20effc67 | 107 | return output_stream<char>(_csi->sink(), buffer_size, opts); |
11fdf7f2 TL |
108 | } |
109 | ||
110 | void connected_socket::set_nodelay(bool nodelay) { | |
111 | _csi->set_nodelay(nodelay); | |
112 | } | |
113 | ||
114 | bool connected_socket::get_nodelay() const { | |
115 | return _csi->get_nodelay(); | |
116 | } | |
117 | void connected_socket::set_keepalive(bool keepalive) { | |
118 | _csi->set_keepalive(keepalive); | |
119 | } | |
120 | bool connected_socket::get_keepalive() const { | |
121 | return _csi->get_keepalive(); | |
122 | } | |
123 | void connected_socket::set_keepalive_parameters(const net::keepalive_params& p) { | |
124 | _csi->set_keepalive_parameters(p); | |
125 | } | |
126 | net::keepalive_params connected_socket::get_keepalive_parameters() const { | |
127 | return _csi->get_keepalive_parameters(); | |
128 | } | |
f67539c2 TL |
129 | void connected_socket::set_sockopt(int level, int optname, const void* data, size_t len) { |
130 | _csi->set_sockopt(level, optname, data, len); | |
131 | } | |
132 | int connected_socket::get_sockopt(int level, int optname, void* data, size_t len) const { | |
133 | return _csi->get_sockopt(level, optname, data, len); | |
134 | } | |
11fdf7f2 | 135 | |
20effc67 TL |
136 | socket_address connected_socket::local_address() const noexcept { |
137 | return _csi->local_address(); | |
138 | } | |
139 | ||
11fdf7f2 TL |
140 | void connected_socket::shutdown_output() { |
141 | _csi->shutdown_output(); | |
142 | } | |
143 | ||
144 | void connected_socket::shutdown_input() { | |
145 | _csi->shutdown_input(); | |
146 | } | |
147 | ||
1e59de90 TL |
148 | future<> connected_socket::wait_input_shutdown() { |
149 | return _csi->wait_input_shutdown(); | |
150 | } | |
151 | ||
f67539c2 TL |
152 | data_source |
153 | net::connected_socket_impl::source(connected_socket_input_stream_config csisc) { | |
154 | // Default implementation falls back to non-parameterized data_source | |
155 | return source(); | |
156 | } | |
157 | ||
11fdf7f2 TL |
158 | socket::~socket() |
159 | {} | |
160 | ||
161 | socket::socket( | |
f67539c2 | 162 | std::unique_ptr<net::socket_impl> si) noexcept |
11fdf7f2 TL |
163 | : _si(std::move(si)) { |
164 | } | |
165 | ||
166 | socket::socket(socket&&) noexcept = default; | |
167 | socket& socket::operator=(socket&&) noexcept = default; | |
168 | ||
169 | future<connected_socket> socket::connect(socket_address sa, socket_address local, transport proto) { | |
170 | return _si->connect(sa, local, proto); | |
171 | } | |
172 | ||
9f95a23c TL |
173 | void socket::set_reuseaddr(bool reuseaddr) { |
174 | _si->set_reuseaddr(reuseaddr); | |
175 | } | |
176 | ||
177 | bool socket::get_reuseaddr() const { | |
178 | return _si->get_reuseaddr(); | |
179 | } | |
180 | ||
11fdf7f2 TL |
181 | void socket::shutdown() { |
182 | _si->shutdown(); | |
183 | } | |
184 | ||
f67539c2 | 185 | server_socket::server_socket() noexcept { |
11fdf7f2 TL |
186 | } |
187 | ||
f67539c2 | 188 | server_socket::server_socket(std::unique_ptr<net::server_socket_impl> ssi) noexcept |
11fdf7f2 TL |
189 | : _ssi(std::move(ssi)) { |
190 | } | |
191 | server_socket::server_socket(server_socket&& ss) noexcept = default; | |
192 | server_socket& server_socket::operator=(server_socket&& cs) noexcept = default; | |
193 | ||
194 | server_socket::~server_socket() { | |
195 | } | |
196 | ||
9f95a23c | 197 | future<accept_result> server_socket::accept() { |
11fdf7f2 | 198 | if (_aborted) { |
9f95a23c | 199 | return make_exception_future<accept_result>(std::system_error(ECONNABORTED, std::system_category())); |
11fdf7f2 TL |
200 | } |
201 | return _ssi->accept(); | |
202 | } | |
203 | ||
204 | void server_socket::abort_accept() { | |
205 | _ssi->abort_accept(); | |
206 | _aborted = true; | |
207 | } | |
208 | ||
f67539c2 | 209 | socket_address server_socket::local_address() const noexcept { |
9f95a23c TL |
210 | return _ssi->local_address(); |
211 | } | |
212 | ||
f67539c2 | 213 | network_interface::network_interface(shared_ptr<net::network_interface_impl> impl) noexcept |
9f95a23c TL |
214 | : _impl(std::move(impl)) |
215 | {} | |
216 | ||
f67539c2 TL |
217 | network_interface::network_interface(network_interface&&) noexcept = default; |
218 | network_interface& network_interface::operator=(network_interface&&) noexcept = default; | |
9f95a23c TL |
219 | |
220 | uint32_t network_interface::index() const { | |
221 | return _impl->index(); | |
222 | } | |
223 | ||
224 | uint32_t network_interface::mtu() const { | |
225 | return _impl->mtu(); | |
226 | } | |
227 | ||
228 | const sstring& network_interface::name() const { | |
229 | return _impl->name(); | |
230 | } | |
231 | ||
232 | const sstring& network_interface::display_name() const { | |
233 | return _impl->display_name(); | |
234 | } | |
235 | ||
236 | const std::vector<net::inet_address>& network_interface::addresses() const { | |
237 | return _impl->addresses(); | |
238 | } | |
239 | ||
240 | const std::vector<uint8_t> network_interface::hardware_address() const { | |
241 | return _impl->hardware_address(); | |
242 | } | |
243 | ||
244 | bool network_interface::is_loopback() const { | |
245 | return _impl->is_loopback(); | |
246 | } | |
247 | ||
248 | bool network_interface::is_virtual() const { | |
249 | return _impl->is_virtual(); | |
250 | } | |
251 | ||
252 | bool network_interface::is_up() const { | |
253 | return _impl->is_up(); | |
254 | } | |
255 | ||
256 | bool network_interface::supports_ipv6() const { | |
257 | return _impl->supports_ipv6(); | |
258 | } | |
259 | ||
260 | ||
261 | future<connected_socket> | |
262 | network_stack::connect(socket_address sa, socket_address local, transport proto) { | |
263 | return do_with(socket(), [sa, local, proto](::seastar::socket& s) { | |
264 | return s.connect(sa, local, proto); | |
265 | }); | |
266 | } | |
267 | ||
268 | std::vector<network_interface> network_stack::network_interfaces() { | |
269 | return {}; | |
11fdf7f2 TL |
270 | } |
271 | ||
272 | } |