MySQL 8.3.0
Source Code Documentation
basic_protocol_splicer.h
Go to the documentation of this file.
1/*
2 Copyright (c) 2020, 2023, Oracle and/or its affiliates.
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License, version 2.0,
6 as published by the Free Software Foundation.
7
8 This program is also distributed with certain software (including
9 but not limited to OpenSSL) that is licensed under separate terms,
10 as designated in a particular file or component or in included license
11 documentation. The authors of MySQL hereby grant you an additional
12 permission to link the program and your derivative works with the
13 separately licensed software that they have included with MySQL.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
23*/
24
25#ifndef ROUTING_BASIC_PROTOCOL_SPLICER_INCLUDED
26#define ROUTING_BASIC_PROTOCOL_SPLICER_INCLUDED
27
28#include <cstdint> // size_t
29#include <cstdio>
30#include <functional> // function
31#include <sstream>
32#include <string>
33
34#ifdef _WIN32
35// include winsock2.h before openssl/ssl.h
36#include <windows.h>
37#include <winsock2.h>
38#include <ws2tcpip.h>
39#endif
40
41#include <openssl/ssl.h> // SSL_CTX
42
43#include "blocked_endpoints.h"
44#include "channel.h"
45#include "harness_assert.h"
49#include "mysql/harness/net_ts/internet.h" // net::ip::tcp
51#include "mysql/harness/net_ts/local.h" // local::stream_protocol
55#include "ssl_mode.h"
56
57enum class TlsContentType {
58 kChangeCipherSpec = 0x14,
59 kAlert,
63};
64
66 switch (v) {
68 return "change-cipher-spec";
70 return "alert";
72 return "handshake";
74 return "application";
76 return "heartbeat";
77 }
78
79 return "unknown-" + std::to_string(static_cast<int>(v));
80}
81
83 public:
84 using ssl_ctx_gettor_type = std::function<SSL_CTX *(const std::string &id)>;
85
87
88 [[nodiscard]] SslMode ssl_mode() const { return ssl_mode_; }
89
90 private:
92};
93
95 public:
96 virtual ~RoutingConnectionBase() = default;
97
98 [[nodiscard]] virtual std::vector<std::pair<std::string, std::string>>
100
101 virtual uint64_t reset_error_count(BlockedEndpoints &blocked_endpoints) = 0;
102 virtual uint64_t increment_error_count(
103 BlockedEndpoints &blocked_endpoints) = 0;
104};
105
106template <class Protocol>
107struct IsTransportSecure : std::false_type {};
108
109#ifdef NET_TS_HAS_UNIX_SOCKET
110template <>
111struct IsTransportSecure<local::stream_protocol> : std::true_type {};
112#endif
113
114/**
115 * basic connection which wraps a net-ts Protocol.
116 *
117 * knows about mysql-protocol specifics like:
118 *
119 * - session attributes
120 * - connection error-tracking.
121 *
122 * @tparam Protocol a protocol like net::ip::tcp or local::stream_protocol
123 */
124template <class Protocol>
126 public:
129 using endpoint_type = typename protocol_type::endpoint;
130
132
134 : sock_{std::move(sock)}, ep_{std::move(ep)} {}
135
136 net::io_context &io_ctx() override { return sock_.get_executor().context(); }
137
139 net::io_context &new_ctx) override {
140 // nothing to do.
141 if (sock_.get_executor() == new_ctx.get_executor()) return {};
142
143 return sock_.release().and_then(
144 [this, &new_ctx](
146 socket_type new_sock(new_ctx);
147
148 auto assign_res = new_sock.assign(ep_.protocol(), native_handle);
149 if (!assign_res) return assign_res;
150
151 std::swap(sock_, new_sock);
152
153 return {};
154 });
155 }
156
158 std::function<void(std::error_code ec, size_t transferred)>
159 completion) override {
161 std::move(completion));
162 }
163
165 std::function<void(std::error_code ec, size_t transferred)>
166 completion) override {
167 if (sock_.native_non_blocking()) {
168 // if the socket is non-blocking try to send directly as the send-buffer
169 // is usually empty
170 auto write_res = net::write(sock_, net::dynamic_buffer(buf),
172 if (write_res) {
173 net::defer(sock_.get_executor(), [completion = std::move(completion),
174 transferred = *write_res]() {
175 completion({}, transferred);
176 });
177 return;
178 }
179
180 const auto ec = write_res.error();
181
182 if (ec != make_error_condition(std::errc::operation_would_block) &&
183 ec !=
184 make_error_condition(std::errc::resource_unavailable_try_again)) {
185 net::defer(sock_.get_executor(), [completion = std::move(completion),
186 ec]() { completion(ec, 0); });
187 return;
188 }
189
190 // if it would-block, use the normal async-write.
191 }
192
194 std::move(completion));
195 }
196
198 std::function<void(std::error_code ec)> completion) override {
199 sock_.async_wait(net::socket_base::wait_write, std::move(completion));
200 }
201
203 std::function<void(std::error_code ec)> completion) override {
204 sock_.async_wait(net::socket_base::wait_read, std::move(completion));
205 }
206
208 std::function<void(std::error_code ec)> completion) override {
209 sock_.async_wait(net::socket_base::wait_error, std::move(completion));
210 }
211
212 [[nodiscard]] bool is_open() const override { return sock_.is_open(); }
213
215 const override {
216 return sock_.native_handle();
217 }
218
220 return sock_.close();
221 }
222
224 return sock_.cancel();
225 }
226
229 return sock_.shutdown(st);
230 }
231
232 [[nodiscard]] std::string endpoint() const override {
234
235 oss << ep_;
236
237 return oss.str();
238 }
239
240 template <class GettableSocketOption>
242 GettableSocketOption &opt) const {
243 return sock_.get_option(opt);
244 }
245
246 /**
247 * check if the underlying transport is secure.
248 *
249 * - unix-socket, shared-memory, ... are secure.
250 */
251 [[nodiscard]] bool is_secure_transport() const override {
253 }
254
255 protected:
258};
259
260template <class Protocol>
262 public:
264 using endpoint_type = typename protocol_type::endpoint;
265
267
268 [[nodiscard]] std::vector<std::pair<std::string, std::string>>
271 }
272
273 uint64_t reset_error_count(BlockedEndpoints &blocked_endpoints) override {
274 return blocked_endpoints.reset_error_count(ep_);
275 }
276
277 uint64_t increment_error_count(BlockedEndpoints &blocked_endpoints) override {
278 return blocked_endpoints.increment_error_count(ep_);
279 }
280
281 private:
283};
284
286#ifdef NET_TS_HAS_UNIX_SOCKET
287using UnixDomainConnection = BasicConnection<local::stream_protocol>;
288#endif
289
291 public:
292 virtual ~ProtocolStateBase() = default;
293};
294
295/**
296 * a Connection that can be switched to TLS.
297 *
298 * wraps
299 *
300 * - a low-level connections (conn)
301 * - a routing connection (endpoints, destinations, ...)
302 * - a tls switchable (a SSL_CTX * wrapper)
303 * - protocol state (classic, xproto)
304 */
306 public:
307 // 16kb per buffer
308 // 2 buffers per channel (send/recv)
309 // 2 channels per connection
310 // 10000 connections
311 // = 640MByte
312 static constexpr size_t kRecvBufferSize{16UL * 1024};
313
314 TlsSwitchableConnection(std::unique_ptr<ConnectionBase> conn,
315 std::unique_ptr<RoutingConnectionBase> routing_conn,
317 std::unique_ptr<ProtocolStateBase> state)
318 : conn_{std::move(conn)},
319 routing_conn_{std::move(routing_conn)},
320 ssl_mode_{std::move(ssl_mode)},
322 protocol_{std::move(state)} {
323 channel_->recv_buffer().reserve(kRecvBufferSize);
324 }
325
326 TlsSwitchableConnection(std::unique_ptr<ConnectionBase> conn,
327 std::unique_ptr<RoutingConnectionBase> routing_conn,
328 SslMode ssl_mode, std::unique_ptr<Channel> channel,
329 std::unique_ptr<ProtocolStateBase> state)
330 : conn_{std::move(conn)},
331 routing_conn_{std::move(routing_conn)},
332 ssl_mode_{std::move(ssl_mode)},
333 channel_{std::move(channel)},
334 protocol_{std::move(state)} {
335 channel_->recv_buffer().reserve(kRecvBufferSize);
336 }
337
338 [[nodiscard]] std::vector<std::pair<std::string, std::string>>
340 return routing_conn_->initial_connection_attributes();
341 }
342
343 /**
344 * assign a low-level connection.
345 */
346 void assign_connection(std::unique_ptr<ConnectionBase> conn) {
347 conn_ = std::move(conn);
348 }
349
350 /**
351 * async receive data from connection into the channel's receive buffer.
352 *
353 * calls func when async operation is completed.
354 */
355 template <class Func>
356 void async_recv(Func &&func) {
357 harness_assert(conn_ != nullptr);
358 harness_assert(channel_ != nullptr);
359
360 // discard everything that has been marked as 'consumed'
361 channel_->view_discard_raw();
362
363 conn_->async_recv(channel_->recv_buffer(),
364 [this, func = std::forward<Func>(func)](
365 std::error_code ec, size_t transferred) {
366 channel_->view_sync_raw();
367
368 func(ec, transferred);
369 });
370 }
371
372 /**
373 * async send data from the channel's send buffer to the connection.
374 *
375 * calls func when async operation is completed.
376 */
377 template <class Func>
378 void async_send(Func &&func) {
379 conn_->async_send(channel_->send_buffer(), std::forward<Func>(func));
380 }
381
382 /**
383 * async wait until connection allows to send data.
384 *
385 * calls func when async operation is completed.
386 */
387 template <class Func>
388 void async_wait_send(Func &&func) {
389 conn_->async_wait_send(std::forward<Func>(func));
390 }
391
392 template <class Func>
393 void async_wait_error(Func &&func) {
394 conn_->async_wait_error(std::forward<Func>(func));
395 }
396
397 [[nodiscard]] Channel *channel() { return channel_.get(); }
398
399 [[nodiscard]] const Channel *channel() const { return channel_.get(); }
400
401 [[nodiscard]] SslMode ssl_mode() const { return ssl_mode_; }
402
403 [[nodiscard]] bool is_open() const { return conn_ && conn_->is_open(); }
404
406 return conn_->native_handle();
407 }
408
410 if (!conn_) {
411 return stdx::make_unexpected(make_error_code(std::errc::not_connected));
412 }
413 return conn_->close();
414 }
415
418 if (!conn_) {
419 return stdx::make_unexpected(make_error_code(std::errc::not_connected));
420 }
421 return conn_->shutdown(st);
422 }
423
424 [[nodiscard]] std::string endpoint() const {
425 if (!is_open()) return "";
426
427 return conn_->endpoint();
428 }
429
430 [[nodiscard]] uint64_t reset_error_count(
431 BlockedEndpoints &blocked_endpoints) {
432 return routing_conn_->reset_error_count(blocked_endpoints);
433 }
434
435 [[nodiscard]] uint64_t increment_error_count(
436 BlockedEndpoints &blocked_endpoints) {
437 return routing_conn_->increment_error_count(blocked_endpoints);
438 }
439
441 if (!conn_) return {};
442
443 return conn_->cancel();
444 }
445
446 [[nodiscard]] ProtocolStateBase *protocol() { return protocol_.get(); }
447
448 [[nodiscard]] const ProtocolStateBase *protocol() const {
449 return protocol_.get();
450 }
451
452 std::unique_ptr<ConnectionBase> &connection() { return conn_; }
453
454 /**
455 * check if the channel is secure.
456 *
457 * - if TLS is enabled, it the transport is secure
458 * - if transport is secure, the channel is secure
459 */
460 [[nodiscard]] bool is_secure_transport() const {
461 return conn_->is_secure_transport() || channel_->ssl();
462 }
463
464 private:
465 // tcp/unix-socket
466 std::unique_ptr<ConnectionBase> conn_;
467 std::unique_ptr<RoutingConnectionBase> routing_conn_;
468
470
471 // socket buffers
472 std::unique_ptr<Channel> channel_;
473
474 // higher-level protocol
475 std::unique_ptr<ProtocolStateBase> protocol_;
476};
477
478/**
479 * splices two connections together.
480 */
482 public:
485 : client_conn_{std::move(client_conn)},
486 server_conn_{std::move(server_conn)} {}
487
488 template <class Func>
489 void async_wait_send_server(Func &&func) {
490 server_conn_.async_wait_send(std::forward<Func>(func));
491 }
492
493 template <class Func>
494 void async_recv_server(Func &&func) {
495 server_conn_.async_recv(std::forward<Func>(func));
496 }
497
498 template <class Func>
499 void async_send_server(Func &&func) {
500 server_conn_.async_send(std::forward<Func>(func));
501 }
502
503 template <class Func>
504 void async_recv_client(Func &&func) {
505 client_conn_.async_recv(std::forward<Func>(func));
506 }
507
508 template <class Func>
509 void async_send_client(Func &&func) {
510 client_conn_.async_send(std::forward<Func>(func));
511 }
512
513 template <class Func>
514 void async_client_wait_error(Func &&func) {
515 client_conn_.async_wait_error(std::forward<Func>(func));
516 }
517
519
520 [[nodiscard]] const TlsSwitchableConnection &client_conn() const {
521 return client_conn_;
522 }
523
525
526 [[nodiscard]] const TlsSwitchableConnection &server_conn() const {
527 return server_conn_;
528 }
529
530 [[nodiscard]] SslMode source_ssl_mode() const {
531 return client_conn().ssl_mode();
532 }
533
534 [[nodiscard]] SslMode dest_ssl_mode() const {
535 return server_conn().ssl_mode();
536 }
537
538 [[nodiscard]] Channel *client_channel() { return client_conn().channel(); }
539
540 [[nodiscard]] const Channel *client_channel() const {
541 return client_conn().channel();
542 }
543
544 [[nodiscard]] Channel *server_channel() { return server_conn().channel(); }
545
546 /**
547 * accept a TLS connection from the client_channel_.
548 */
550 // write socket data to SSL struct
551 auto *channel = client_conn_.channel();
552
553 {
554 const auto flush_res = channel->flush_from_recv_buf();
555 if (!flush_res) return flush_res.get_unexpected();
556 }
557
558 if (!channel->tls_init_is_finished()) {
559 const auto res = channel->tls_accept();
560
561 // flush the TLS message to the send-buffer.
562 {
563 const auto flush_res = channel->flush_to_send_buf();
564 if (!flush_res) {
565 const auto ec = flush_res.error();
566 if (ec != make_error_code(std::errc::operation_would_block)) {
567 return flush_res.get_unexpected();
568 }
569 }
570 }
571
572 if (!res) {
573 return res.get_unexpected();
574 }
575 }
576
577 return {};
578 }
579
580 protected:
583};
584
585#endif
std::string tls_content_type_to_string(TlsContentType v)
Definition: basic_protocol_splicer.h:65
TlsContentType
Definition: basic_protocol_splicer.h:57
basic connection which wraps a net-ts Protocol.
Definition: basic_protocol_splicer.h:125
stdx::expected< void, std::error_code > set_io_context(net::io_context &new_ctx) override
Definition: basic_protocol_splicer.h:138
stdx::expected< void, std::error_code > get_option(GettableSocketOption &opt) const
Definition: basic_protocol_splicer.h:241
stdx::expected< void, std::error_code > close() override
Definition: basic_protocol_splicer.h:219
void async_wait_error(std::function< void(std::error_code ec)> completion) override
Definition: basic_protocol_splicer.h:207
std::string endpoint() const override
Definition: basic_protocol_splicer.h:232
void async_wait_recv(std::function< void(std::error_code ec)> completion) override
Definition: basic_protocol_splicer.h:202
net::impl::socket::native_handle_type native_handle() const override
Definition: basic_protocol_splicer.h:214
void async_recv(recv_buffer_type &buf, std::function< void(std::error_code ec, size_t transferred)> completion) override
Definition: basic_protocol_splicer.h:157
stdx::expected< void, std::error_code > cancel() override
Definition: basic_protocol_splicer.h:223
bool is_open() const override
Definition: basic_protocol_splicer.h:212
socket_type sock_
Definition: basic_protocol_splicer.h:256
typename protocol_type::socket socket_type
Definition: basic_protocol_splicer.h:128
BasicConnection(socket_type sock, endpoint_type ep)
Definition: basic_protocol_splicer.h:133
bool is_secure_transport() const override
check if the underlying transport is secure.
Definition: basic_protocol_splicer.h:251
net::io_context & io_ctx() override
Definition: basic_protocol_splicer.h:136
endpoint_type ep_
Definition: basic_protocol_splicer.h:257
stdx::expected< void, std::error_code > shutdown(net::socket_base::shutdown_type st) override
Definition: basic_protocol_splicer.h:227
void async_send(recv_buffer_type &buf, std::function< void(std::error_code ec, size_t transferred)> completion) override
Definition: basic_protocol_splicer.h:164
void async_wait_send(std::function< void(std::error_code ec)> completion) override
Definition: basic_protocol_splicer.h:197
typename protocol_type::endpoint endpoint_type
Definition: basic_protocol_splicer.h:129
Definition: blocked_endpoints.h:33
uint64_t increment_error_count(const net::ip::tcp::endpoint &endpoint)
increments the error count of an endpoint.
Definition: blocked_endpoints.cc:44
uint64_t reset_error_count(const net::ip::tcp::endpoint &endpoint)
resets error counter for an endpoint.
Definition: blocked_endpoints.cc:57
SSL aware socket buffers.
Definition: channel.h:63
virtual base-class of BasicConnection.
Definition: connection_base.h:41
std::vector< uint8_t, default_init_allocator< uint8_t > > recv_buffer_type
Definition: connection_base.h:46
splices two connections together.
Definition: basic_protocol_splicer.h:481
void async_send_client(Func &&func)
Definition: basic_protocol_splicer.h:509
void async_client_wait_error(Func &&func)
Definition: basic_protocol_splicer.h:514
TlsSwitchableConnection client_conn_
Definition: basic_protocol_splicer.h:581
void async_send_server(Func &&func)
Definition: basic_protocol_splicer.h:499
const TlsSwitchableConnection & server_conn() const
Definition: basic_protocol_splicer.h:526
void async_wait_send_server(Func &&func)
Definition: basic_protocol_splicer.h:489
Channel * server_channel()
Definition: basic_protocol_splicer.h:544
void async_recv_server(Func &&func)
Definition: basic_protocol_splicer.h:494
const Channel * client_channel() const
Definition: basic_protocol_splicer.h:540
Channel * client_channel()
Definition: basic_protocol_splicer.h:538
void async_recv_client(Func &&func)
Definition: basic_protocol_splicer.h:504
stdx::expected< void, std::error_code > tls_accept()
accept a TLS connection from the client_channel_.
Definition: basic_protocol_splicer.h:549
TlsSwitchableConnection & client_conn()
Definition: basic_protocol_splicer.h:518
SslMode dest_ssl_mode() const
Definition: basic_protocol_splicer.h:534
SslMode source_ssl_mode() const
Definition: basic_protocol_splicer.h:530
ProtocolSplicerBase(TlsSwitchableConnection client_conn, TlsSwitchableConnection server_conn)
Definition: basic_protocol_splicer.h:483
TlsSwitchableConnection server_conn_
Definition: basic_protocol_splicer.h:582
TlsSwitchableConnection & server_conn()
Definition: basic_protocol_splicer.h:524
const TlsSwitchableConnection & client_conn() const
Definition: basic_protocol_splicer.h:520
Definition: basic_protocol_splicer.h:290
virtual ~ProtocolStateBase()=default
Definition: protocol.h:32
Definition: basic_protocol_splicer.h:94
virtual std::vector< std::pair< std::string, std::string > > initial_connection_attributes() const =0
virtual ~RoutingConnectionBase()=default
virtual uint64_t increment_error_count(BlockedEndpoints &blocked_endpoints)=0
virtual uint64_t reset_error_count(BlockedEndpoints &blocked_endpoints)=0
Definition: basic_protocol_splicer.h:261
typename protocol_type::endpoint endpoint_type
Definition: basic_protocol_splicer.h:264
std::vector< std::pair< std::string, std::string > > initial_connection_attributes() const override
Definition: basic_protocol_splicer.h:269
uint64_t increment_error_count(BlockedEndpoints &blocked_endpoints) override
Definition: basic_protocol_splicer.h:277
RoutingConnection(endpoint_type ep)
Definition: basic_protocol_splicer.h:266
endpoint_type ep_
Definition: basic_protocol_splicer.h:282
uint64_t reset_error_count(BlockedEndpoints &blocked_endpoints) override
Definition: basic_protocol_splicer.h:273
a Connection that can be switched to TLS.
Definition: basic_protocol_splicer.h:305
TlsSwitchableConnection(std::unique_ptr< ConnectionBase > conn, std::unique_ptr< RoutingConnectionBase > routing_conn, SslMode ssl_mode, std::unique_ptr< Channel > channel, std::unique_ptr< ProtocolStateBase > state)
Definition: basic_protocol_splicer.h:326
stdx::expected< void, std::error_code > shutdown(net::socket_base::shutdown_type st) const
Definition: basic_protocol_splicer.h:416
std::unique_ptr< ProtocolStateBase > protocol_
Definition: basic_protocol_splicer.h:475
TlsSwitchableConnection(std::unique_ptr< ConnectionBase > conn, std::unique_ptr< RoutingConnectionBase > routing_conn, SslMode ssl_mode, std::unique_ptr< ProtocolStateBase > state)
Definition: basic_protocol_splicer.h:314
void async_send(Func &&func)
async send data from the channel's send buffer to the connection.
Definition: basic_protocol_splicer.h:378
void assign_connection(std::unique_ptr< ConnectionBase > conn)
assign a low-level connection.
Definition: basic_protocol_splicer.h:346
std::unique_ptr< RoutingConnectionBase > routing_conn_
Definition: basic_protocol_splicer.h:467
bool is_secure_transport() const
check if the channel is secure.
Definition: basic_protocol_splicer.h:460
void async_wait_error(Func &&func)
Definition: basic_protocol_splicer.h:393
std::string endpoint() const
Definition: basic_protocol_splicer.h:424
stdx::expected< void, std::error_code > close() const
Definition: basic_protocol_splicer.h:409
const Channel * channel() const
Definition: basic_protocol_splicer.h:399
void async_recv(Func &&func)
async receive data from connection into the channel's receive buffer.
Definition: basic_protocol_splicer.h:356
SslMode ssl_mode_
Definition: basic_protocol_splicer.h:469
const ProtocolStateBase * protocol() const
Definition: basic_protocol_splicer.h:448
Channel * channel()
Definition: basic_protocol_splicer.h:397
void async_wait_send(Func &&func)
async wait until connection allows to send data.
Definition: basic_protocol_splicer.h:388
uint64_t reset_error_count(BlockedEndpoints &blocked_endpoints)
Definition: basic_protocol_splicer.h:430
std::vector< std::pair< std::string, std::string > > initial_connection_attributes() const
Definition: basic_protocol_splicer.h:339
std::unique_ptr< ConnectionBase > & connection()
Definition: basic_protocol_splicer.h:452
net::impl::socket::native_handle_type native_handle() const
Definition: basic_protocol_splicer.h:405
std::unique_ptr< Channel > channel_
Definition: basic_protocol_splicer.h:472
bool is_open() const
Definition: basic_protocol_splicer.h:403
uint64_t increment_error_count(BlockedEndpoints &blocked_endpoints)
Definition: basic_protocol_splicer.h:435
static constexpr size_t kRecvBufferSize
Definition: basic_protocol_splicer.h:312
ProtocolStateBase * protocol()
Definition: basic_protocol_splicer.h:446
std::unique_ptr< ConnectionBase > conn_
Definition: basic_protocol_splicer.h:466
SslMode ssl_mode() const
Definition: basic_protocol_splicer.h:401
stdx::expected< void, std::error_code > cancel()
Definition: basic_protocol_splicer.h:440
Definition: basic_protocol_splicer.h:82
SslMode ssl_mode() const
Definition: basic_protocol_splicer.h:88
SslMode ssl_mode_
Definition: basic_protocol_splicer.h:91
std::function< SSL_CTX *(const std::string &id)> ssl_ctx_gettor_type
Definition: basic_protocol_splicer.h:84
TlsSwitchable(SslMode ssl_mode)
Definition: basic_protocol_splicer.h:86
Definition: io_context.h:60
executor_type get_executor() noexcept
Definition: io_context.h:1079
static constexpr wait_type wait_read
Definition: socket.h:167
shutdown_type
Definition: socket.h:171
static constexpr wait_type wait_write
Definition: socket.h:168
static constexpr wait_type wait_error
Definition: socket.h:169
Definition: buffer.h:695
Definition: expected.h:943
#define harness_assert(COND)
Improved assert()
Definition: harness_assert.h:36
std::vector< std::pair< std::string, std::string > > initial_connection_attributes(const net::ip::tcp::endpoint &ep)
TCP/IP socket related connection attributes.
Definition: initial_connection_attributes.h:42
static std::string to_string(const LEX_STRING &str)
Definition: lex_string.h:49
static MYSQL * sock
Definition: mysqlcheck.cc:56
Definition: buf0block_hint.cc:29
Definition: local.h:59
Unique_ptr< T, std::nullptr_t > make_unique(size_t size)
In-place constructs a new unique pointer with no specific allocator and with array type T.
std::error_code make_error_code(DynamicLoaderErrc ec)
make error_code from a DynamicLoaderErrc.
Definition: dynamic_loader.cc:78
stdx::expected< native_handle_type, error_type > socket(int family, int sock_type, int protocol)
Definition: socket.h:62
int native_handle_type
Definition: socket_constants.h:50
dynamic_vector_buffer< T, Allocator > dynamic_buffer(std::vector< T, Allocator > &vec) noexcept
Definition: buffer.h:660
auto defer(CompletionToken &&token)
Definition: executor.h:786
std::enable_if_t< is_const_buffer_sequence_v< ConstBufferSequence >, stdx::expected< size_t, std::error_code > > write(SyncWriteStream &stream, const ConstBufferSequence &buffers)
Definition: buffer.h:990
std::enable_if_t< is_dynamic_buffer< DynamicBuffer >::value, void > async_read(AsyncReadStream &stream, DynamicBuffer &&b, CompletionCondition completion_condition, CompletionToken &&token)
Definition: buffer.h:926
std::enable_if_t< is_const_buffer_sequence_v< ConstBufferSequence >, void > async_write(AsyncWriteStream &stream, const ConstBufferSequence &buffers, CompletionCondition cond, CompletionToken &&token)
Definition: buffer.h:1073
std::error_condition make_error_condition(net::stream_errc e) noexcept
Definition: buffer.h:106
Definition: varlen_sort.h:174
constexpr auto make_unexpected(E &&e) -> unexpected< std::decay_t< E > >
Definition: expected.h:124
std::basic_ostringstream< char, std::char_traits< char >, ut::allocator< char > > ostringstream
Specialization of basic_ostringstream which uses ut::allocator.
Definition: ut0new.h:2869
SslMode
Definition: ssl_mode.h:28
Definition: basic_protocol_splicer.h:107
Definition: task.h:426
void swap(const varlen_element &a, const varlen_element &b)
Definition: varlen_sort.h:65
unsigned long id[MAX_DEAD]
Definition: xcom_base.cc:509