From 45f232703a4c3a25da790885a0b8eae3c0c2e3ff Mon Sep 17 00:00:00 2001 From: Ricardo Dias Date: Tue, 26 Feb 2019 11:52:27 +0000 Subject: [PATCH] msg/async: msgr2: cleanup frame classes hacks Signed-off-by: Ricardo Dias --- src/msg/async/ProtocolV2.cc | 154 +++++++++++++----------- src/msg/async/frames_v2.h | 228 ++++++++++++++++++++++++------------ 2 files changed, 243 insertions(+), 139 deletions(-) diff --git a/src/msg/async/ProtocolV2.cc b/src/msg/async/ProtocolV2.cc index 19fb065cc653..cf700b601d70 100644 --- a/src/msg/async/ProtocolV2.cc +++ b/src/msg/async/ProtocolV2.cc @@ -520,10 +520,10 @@ ssize_t ProtocolV2::write_message(Message *m, bool more) { sizeof(header2) - sizeof(header2.header_crc)); } - MessageHeaderFrame message(header2, - m->get_payload().length(), - m->get_middle().length(), - m->get_data().length()); + auto message = MessageHeaderFrame::Encode(header2, + m->get_payload().length(), + m->get_middle().length(), + m->get_data().length()); if (auth_meta->is_mode_secure()) { ceph_assert(session_stream_handlers.tx); @@ -597,12 +597,13 @@ ssize_t ProtocolV2::write_message(Message *m, bool more) { void ProtocolV2::append_keepalive() { ldout(cct, 10) << __func__ << dendl; - KeepAliveFrame keepalive_frame(session_stream_handlers); + auto keepalive_frame = KeepAliveFrame::Encode(session_stream_handlers); connection->outcoming_bl.claim_append(keepalive_frame.get_buffer()); } void ProtocolV2::append_keepalive_ack(utime_t ×tamp) { - KeepAliveFrameAck keepalive_ack_frame(session_stream_handlers, timestamp); + auto keepalive_ack_frame = KeepAliveFrameAck::Encode(session_stream_handlers, + timestamp); connection->outcoming_bl.claim_append(keepalive_ack_frame.get_buffer()); } @@ -682,7 +683,7 @@ void ProtocolV2::write_event() { if (left) { ceph_le64 s; s = in_seq; - AckFrame ack(session_stream_handlers, in_seq); + auto ack = AckFrame::Encode(session_stream_handlers, in_seq); connection->outcoming_bl.claim_append(ack.get_buffer()); sent_tag = ack.tag; ldout(cct, 10) << __func__ << " try send msg ack, acked " << left @@ -911,7 +912,8 @@ CtPtr ProtocolV2::_handle_peer_banner_payload(char *buffer, int r) { this->connection_features = msgr2_required; } - HelloFrame hello(messenger->get_mytype(), connection->target_addr); + auto hello = HelloFrame::Encode(messenger->get_mytype(), + connection->target_addr); INTERCEPT(state == CONNECTING ? 7 : 8); @@ -923,7 +925,7 @@ CtPtr ProtocolV2::handle_hello(ceph::bufferlist &payload) ldout(cct, 20) << __func__ << " payload.length()=" << payload.length() << dendl; - HelloFrame hello(payload); + auto hello = HelloFrame::Decode(payload); ldout(cct, 5) << __func__ << " received hello:" << " peer_type=" << (int)hello.entity_type() @@ -1061,7 +1063,7 @@ CtPtr ProtocolV2::handle_read_frame_preamble_main(char *buffer, int r) { { // I expect ceph_le32 will make the endian conversion for me. Passing - // everything through ::decode is unnecessary. + // everything through ::Decode is unnecessary. const auto& main_preamble = \ reinterpret_cast(*preamble.c_str()); @@ -1326,7 +1328,7 @@ CtPtr ProtocolV2::handle_message() { std::move(rx_segments_data[SegmentIndex::Msg::HEADER]), segment_t::DEFAULT_ALIGNMENT); } - MessageHeaderFrame header_frame( + auto header_frame = MessageHeaderFrame::Decode( std::move(rx_segments_data[SegmentIndex::Msg::HEADER])); ceph_msg_header2 &header = header_frame.header(); @@ -1761,7 +1763,8 @@ CtPtr ProtocolV2::handle_keepalive2(ceph::bufferlist &payload) ldout(cct, 20) << __func__ << " payload.length()=" << payload.length() << dendl; - KeepAliveFrame keepalive_frame(session_stream_handlers, payload); + auto keepalive_frame = KeepAliveFrame::Decode(session_stream_handlers, + payload); ldout(cct, 30) << __func__ << " got KEEPALIVE2 tag ..." << dendl; @@ -1785,7 +1788,8 @@ CtPtr ProtocolV2::handle_keepalive2_ack(ceph::bufferlist &payload) ldout(cct, 20) << __func__ << " payload.length()=" << payload.length() << dendl; - KeepAliveFrameAck keepalive_ack_frame(session_stream_handlers, payload); + auto keepalive_ack_frame = KeepAliveFrameAck::Decode(session_stream_handlers, + payload); connection->set_last_keepalive_ack(keepalive_ack_frame.timestamp()); ldout(cct, 20) << __func__ << " got KEEPALIVE_ACK" << dendl; @@ -1797,7 +1801,7 @@ CtPtr ProtocolV2::handle_message_ack(ceph::bufferlist &payload) ldout(cct, 20) << __func__ << " payload.length()=" << payload.length() << dendl; - AckFrame ack(session_stream_handlers, payload); + auto ack = AckFrame::Decode(session_stream_handlers, payload); handle_message_ack(ack.seq()); return CONTINUE(read_frame); } @@ -1851,7 +1855,8 @@ CtPtr ProtocolV2::send_auth_request(std::vector &allowed_methods) { INTERCEPT(9); - AuthRequestFrame frame(auth_meta->auth_method, preferred_modes, bl); + auto frame = AuthRequestFrame::Encode(auth_meta->auth_method, preferred_modes, + bl); return WRITE(frame, "auth request", read_frame); } @@ -1859,7 +1864,7 @@ CtPtr ProtocolV2::handle_auth_bad_method(ceph::bufferlist &payload) { ldout(cct, 20) << __func__ << " payload.length()=" << payload.length() << dendl; - AuthBadMethodFrame bad_method(payload); + auto bad_method = AuthBadMethodFrame::Decode(payload); ldout(cct, 1) << __func__ << " method=" << bad_method.method() << " result " << cpp_strerror(bad_method.result()) << ", allowed methods=" << bad_method.allowed_methods() @@ -1886,7 +1891,7 @@ CtPtr ProtocolV2::handle_auth_reply_more(ceph::bufferlist &payload) ldout(cct, 20) << __func__ << " payload.length()=" << payload.length() << dendl; - AuthReplyMoreFrame auth_more(payload); + auto auth_more = AuthReplyMoreFrame::Decode(payload); ldout(cct, 5) << __func__ << " auth reply more len=" << auth_more.auth_payload().length() << dendl; @@ -1905,7 +1910,7 @@ CtPtr ProtocolV2::handle_auth_reply_more(ceph::bufferlist &payload) << r << dendl; return _fault(); } - AuthRequestMoreFrame more_reply(dummy_ctor_conflict_helper{}, reply); + auto more_reply = AuthRequestMoreFrame::Encode(reply); return WRITE(more_reply, "auth request more", read_frame); } @@ -1914,7 +1919,7 @@ CtPtr ProtocolV2::handle_auth_done(ceph::bufferlist &payload) ldout(cct, 20) << __func__ << " payload.length()=" << payload.length() << dendl; - AuthDoneFrame auth_done(payload); + auto auth_done = AuthDoneFrame::Decode(payload); ceph_assert(messenger->auth_client); auto am = auth_meta; @@ -1991,12 +1996,12 @@ CtPtr ProtocolV2::send_client_ident() { } } - ClientIdentFrame client_ident(session_stream_handlers, messenger->get_myaddrs(), - connection->target_addr, - messenger->get_myname().num(), global_seq, - connection->policy.features_supported, - connection->policy.features_required | msgr2_required, - flags, client_cookie); + auto client_ident = ClientIdentFrame::Encode( + session_stream_handlers, messenger->get_myaddrs(), + connection->target_addr, messenger->get_myname().num(), global_seq, + connection->policy.features_supported, + connection->policy.features_required | msgr2_required, flags, + client_cookie); ldout(cct, 5) << __func__ << " sending identification: " << "addrs=" << messenger->get_myaddrs() @@ -2018,12 +2023,13 @@ CtPtr ProtocolV2::send_client_ident() { CtPtr ProtocolV2::send_reconnect() { ldout(cct, 20) << __func__ << dendl; - ReconnectFrame reconnect(session_stream_handlers, messenger->get_myaddrs(), - client_cookie, - server_cookie, - global_seq, - connect_seq, - in_seq); + auto reconnect = ReconnectFrame::Encode(session_stream_handlers, + messenger->get_myaddrs(), + client_cookie, + server_cookie, + global_seq, + connect_seq, + in_seq); ldout(cct, 5) << __func__ << " reconnect to session: client_cookie=" << std::hex << client_cookie << " server_cookie=" @@ -2041,7 +2047,8 @@ CtPtr ProtocolV2::handle_ident_missing_features(ceph::bufferlist &payload) ldout(cct, 20) << __func__ << " payload.length()=" << payload.length() << dendl; - IdentMissingFeaturesFrame ident_missing(session_stream_handlers, payload); + auto ident_missing = + IdentMissingFeaturesFrame::Decode(session_stream_handlers, payload); lderr(cct) << __func__ << " client does not support all server features: " << std::hex << ident_missing.features() << std::dec << dendl; @@ -2054,7 +2061,7 @@ CtPtr ProtocolV2::handle_session_reset(ceph::bufferlist &payload) ldout(cct, 20) << __func__ << " payload.length()=" << payload.length() << dendl; - ResetFrame reset(session_stream_handlers, payload); + auto reset = ResetFrame::Decode(session_stream_handlers, payload); ldout(cct, 1) << __func__ << " received session reset full=" << reset.full() << dendl; @@ -2074,7 +2081,7 @@ CtPtr ProtocolV2::handle_session_retry(ceph::bufferlist &payload) ldout(cct, 20) << __func__ << " payload.length()=" << payload.length() << dendl; - RetryFrame retry(session_stream_handlers, payload); + auto retry = RetryFrame::Decode(session_stream_handlers, payload); connect_seq = retry.connect_seq() + 1; ldout(cct, 1) << __func__ @@ -2089,7 +2096,7 @@ CtPtr ProtocolV2::handle_session_retry_global(ceph::bufferlist &payload) ldout(cct, 20) << __func__ << " payload.length()=" << payload.length() << dendl; - RetryGlobalFrame retry(session_stream_handlers, payload); + auto retry = RetryGlobalFrame::Decode(session_stream_handlers, payload); global_seq = messenger->get_global_seq(retry.global_seq()); ldout(cct, 1) << __func__ << " received session retry global global_seq=" @@ -2105,7 +2112,8 @@ CtPtr ProtocolV2::handle_wait() { state = WAIT; ceph_assert(rx_segments_data.size() == 1); ceph_assert(rx_segments_desc.size() == 1); - WaitFrame(session_stream_handlers, rx_segments_data[SegmentIndex::Frame::PAYLOAD]); + WaitFrame::Decode(session_stream_handlers, + rx_segments_data[SegmentIndex::Frame::PAYLOAD]); return _fault(); } @@ -2114,7 +2122,8 @@ CtPtr ProtocolV2::handle_reconnect_ok(ceph::bufferlist &payload) ldout(cct, 20) << __func__ << " payload.length()=" << payload.length() << dendl; - ReconnectOkFrame reconnect_ok(session_stream_handlers, payload); + auto reconnect_ok = ReconnectOkFrame::Decode(session_stream_handlers, + payload); ldout(cct, 5) << __func__ << " reconnect accepted: sms=" << reconnect_ok.msg_seq() << dendl; @@ -2141,7 +2150,8 @@ CtPtr ProtocolV2::handle_server_ident(ceph::bufferlist &payload) ldout(cct, 20) << __func__ << " payload.length()=" << payload.length() << dendl; - ServerIdentFrame server_ident(session_stream_handlers, payload); + auto server_ident = ServerIdentFrame::Decode(session_stream_handlers, + payload); ldout(cct, 5) << __func__ << " received server identification:" << " addrs=" << server_ident.addrs() << " gid=" << server_ident.gid() @@ -2208,7 +2218,7 @@ CtPtr ProtocolV2::post_server_banner_exchange() { } CtPtr ProtocolV2::handle_auth_request(ceph::bufferlist &payload) { - AuthRequestFrame request(payload); + auto request = AuthRequestFrame::Decode(payload); ldout(cct, 10) << __func__ << " AuthRequest(method=" << request.method() << ", preferred_modes=" << request.preferred_modes() << ", payload_len=" << request.auth_payload().length() << ")" @@ -2235,8 +2245,8 @@ CtPtr ProtocolV2::_auth_bad_method(int r) << ", allowed_methods " << allowed_methods << ", allowed_modes " << allowed_modes << dendl; - AuthBadMethodFrame bad_method(auth_meta->auth_method, r, allowed_methods, - allowed_modes); + auto bad_method = AuthBadMethodFrame::Encode(auth_meta->auth_method, r, + allowed_methods, allowed_modes); return WRITE(bad_method, "bad auth method", read_frame); } @@ -2255,8 +2265,8 @@ CtPtr ProtocolV2::_handle_auth_request(bufferlist& auth_payload, bool more) connection->lock.lock(); if (state != ACCEPTING) { ldout(cct, 1) << __func__ - << " state changed while accept, it must be mark_down" - << dendl; + << " state changed while accept, it must be mark_down" + << dendl; ceph_assert(state == CLOSED); return _fault(); } @@ -2266,11 +2276,12 @@ CtPtr ProtocolV2::_handle_auth_request(bufferlist& auth_payload, bool more) ceph_assert(auth_meta); session_stream_handlers = \ ceph::crypto::onwire::rxtx_t::create_handler_pair(cct, *auth_meta, true); - AuthDoneFrame auth_done(connection->peer_global_id, auth_meta->con_mode, - reply); + auto auth_done = AuthDoneFrame::Encode(connection->peer_global_id, + auth_meta->con_mode, + reply); return WRITE(auth_done, "auth done", read_frame); } else if (r == 0) { - AuthReplyMoreFrame more(dummy_ctor_conflict_helper{}, reply); + auto more = AuthReplyMoreFrame::Encode(reply); return WRITE(more, "auth reply more", read_frame); } else if (r == -EBUSY) { // kick the client and maybe they'll come back later @@ -2284,7 +2295,7 @@ CtPtr ProtocolV2::handle_auth_request_more(ceph::bufferlist &payload) { ldout(cct, 20) << __func__ << " payload.length()=" << payload.length() << dendl; - AuthRequestMoreFrame auth_more(payload); + auto auth_more = AuthRequestMoreFrame::Decode(payload); return _handle_auth_request(auth_more.auth_payload(), true); } @@ -2293,7 +2304,8 @@ CtPtr ProtocolV2::handle_client_ident(ceph::bufferlist &payload) ldout(cct, 20) << __func__ << " payload.length()=" << payload.length() << dendl; - ClientIdentFrame client_ident(session_stream_handlers, payload); + auto client_ident = ClientIdentFrame::Decode(session_stream_handlers, + payload); ldout(cct, 5) << __func__ << " received client identification:" << " addrs=" << client_ident.addrs() @@ -2333,7 +2345,8 @@ CtPtr ProtocolV2::handle_client_ident(ceph::bufferlist &payload) if (feat_missing) { ldout(cct, 1) << __func__ << " peer missing required features " << std::hex << feat_missing << std::dec << dendl; - IdentMissingFeaturesFrame ident_missing_features(session_stream_handlers, feat_missing); + auto ident_missing_features = IdentMissingFeaturesFrame::Encode( + session_stream_handlers, feat_missing); return WRITE(ident_missing_features, "ident missing features", read_frame); } @@ -2383,7 +2396,7 @@ CtPtr ProtocolV2::handle_reconnect(ceph::bufferlist &payload) ldout(cct, 20) << __func__ << " payload.length()=" << payload.length() << dendl; - ReconnectFrame reconnect(session_stream_handlers, payload); + auto reconnect = ReconnectFrame::Decode(session_stream_handlers, payload); ldout(cct, 5) << __func__ << " received reconnect:" @@ -2428,7 +2441,7 @@ CtPtr ProtocolV2::handle_reconnect(ceph::bufferlist &payload) // session ldout(cct, 0) << __func__ << " no existing connection exists, reseting client" << dendl; - ResetFrame reset(session_stream_handlers, true); + auto reset = ResetFrame::Encode(session_stream_handlers, true); return WRITE(reset, "session reset", read_frame); } @@ -2443,7 +2456,7 @@ CtPtr ProtocolV2::handle_reconnect(ceph::bufferlist &payload) if (exproto->state == CLOSED) { ldout(cct, 5) << __func__ << " existing " << existing << " already closed. Reseting client" << dendl; - ResetFrame reset(session_stream_handlers, true); + auto reset = ResetFrame::Encode(session_stream_handlers, true); return WRITE(reset, "session reset", read_frame); } @@ -2451,7 +2464,8 @@ CtPtr ProtocolV2::handle_reconnect(ceph::bufferlist &payload) ldout(cct, 1) << __func__ << " existing racing replace happened while replacing." << " existing=" << existing << dendl; - RetryGlobalFrame retry(session_stream_handlers, exproto->peer_global_seq); + auto retry = RetryGlobalFrame::Encode(session_stream_handlers, + exproto->peer_global_seq); return WRITE(retry, "session retry", read_frame); } @@ -2462,7 +2476,8 @@ CtPtr ProtocolV2::handle_reconnect(ceph::bufferlist &payload) << " rcc=" << reconnect.client_cookie() << ", reseting client." << dendl; - ResetFrame reset(session_stream_handlers, connection->policy.resetcheck); + auto reset = ResetFrame::Encode(session_stream_handlers, + connection->policy.resetcheck); return WRITE(reset, "session reset", read_frame); } else if (exproto->server_cookie == 0) { // this happens when: @@ -2475,7 +2490,7 @@ CtPtr ProtocolV2::handle_reconnect(ceph::bufferlist &payload) ldout(cct, 1) << __func__ << " I was a client and didn't received the" << " server_ident. Asking peer to resume session" << " establishment" << dendl; - ResetFrame reset(session_stream_handlers, false); + auto reset = ResetFrame::Encode(session_stream_handlers, false); return WRITE(reset, "session reset", read_frame); } @@ -2484,7 +2499,8 @@ CtPtr ProtocolV2::handle_reconnect(ceph::bufferlist &payload) << " stale global_seq: sgs=" << exproto->peer_global_seq << " cgs=" << reconnect.global_seq() << ", ask client to retry global" << dendl; - RetryGlobalFrame retry(session_stream_handlers, exproto->peer_global_seq); + auto retry = RetryGlobalFrame::Encode(session_stream_handlers, + exproto->peer_global_seq); INTERCEPT(18); @@ -2496,7 +2512,8 @@ CtPtr ProtocolV2::handle_reconnect(ceph::bufferlist &payload) << " stale connect_seq scs=" << exproto->connect_seq << " ccs=" << reconnect.connect_seq() << " , ask client to retry" << dendl; - RetryFrame retry(session_stream_handlers, exproto->connect_seq); + auto retry = RetryFrame::Encode(session_stream_handlers, + exproto->connect_seq); return WRITE(retry, "session retry", read_frame); } @@ -2511,7 +2528,7 @@ CtPtr ProtocolV2::handle_reconnect(ceph::bufferlist &payload) << " reconnect race detected, this connection loses to existing=" << existing << dendl; - WaitFrame wait(session_stream_handlers); + auto wait = WaitFrame::Encode(session_stream_handlers); return WRITE(wait, "wait", read_frame); } else { // this connection wins @@ -2554,7 +2571,7 @@ CtPtr ProtocolV2::handle_existing_connection(AsyncConnectionRef existing) { ldout(cct, 1) << __func__ << " existing racing replace happened while replacing." << " existing=" << existing << dendl; - WaitFrame wait(session_stream_handlers); + auto wait = WaitFrame::Encode(session_stream_handlers); return WRITE(wait, "wait", read_frame); } @@ -2631,7 +2648,7 @@ CtPtr ProtocolV2::handle_existing_connection(AsyncConnectionRef existing) { // has something to send to us. existing->send_keepalive(); existing->lock.lock(); - WaitFrame wait(session_stream_handlers); + auto wait = WaitFrame::Encode(session_stream_handlers); return WRITE(wait, "wait", read_frame); } } @@ -2768,12 +2785,15 @@ CtPtr ProtocolV2::send_server_ident() { } uint64_t gs = messenger->get_global_seq(); - ServerIdentFrame server_ident( - session_stream_handlers, messenger->get_myaddrs(), messenger->get_myname().num(), gs, - connection->policy.features_supported, - connection->policy.features_required | msgr2_required, - flags, - server_cookie); + auto server_ident = ServerIdentFrame::Encode( + session_stream_handlers, + messenger->get_myaddrs(), + messenger->get_myname().num(), + gs, + connection->policy.features_supported, + connection->policy.features_required | msgr2_required, + flags, + server_cookie); ldout(cct, 5) << __func__ << " sending identification:" << " addrs=" << messenger->get_myaddrs() @@ -2838,7 +2858,7 @@ CtPtr ProtocolV2::send_reconnect_ok() { out_seq = discard_requeued_up_to(out_seq, message_seq); uint64_t ms = in_seq; - ReconnectOkFrame reconnect_ok(session_stream_handlers, ms); + auto reconnect_ok = ReconnectOkFrame::Encode(session_stream_handlers, ms); ldout(cct, 5) << __func__ << " sending reconnect_ok: msg_seq=" << ms << dendl; diff --git a/src/msg/async/frames_v2.h b/src/msg/async/frames_v2.h index 5b9257734d3e..112b755345ed 100644 --- a/src/msg/async/frames_v2.h +++ b/src/msg/async/frames_v2.h @@ -128,29 +128,25 @@ protected: } } -public: Frame() : preamble_filler(payload.append_hole(FRAME_PREAMBLE_SIZE)) {} - ceph::bufferlist &get_buffer() { - fill_preamble({segment_t{payload.length() - FRAME_PREAMBLE_SIZE, - segment_t::DEFAULT_ALIGNMENT}}); - return payload; - } - void decode_frame(const ceph::bufferlist &bl) { auto ti = bl.cbegin(); static_cast(this)->decode_payload(ti); } void decode_payload(bufferlist::const_iterator &ti) {} -}; -// TODO, FIXME: fix this altogether with the Frame hierarchy rework -struct do_not_encode_tag_t {}; -struct dummy_ctor_conflict_helper {}; +public: + ceph::bufferlist &get_buffer() { + fill_preamble({segment_t{payload.length() - FRAME_PREAMBLE_SIZE, + segment_t::DEFAULT_ALIGNMENT}}); + return payload; + } +}; template -struct PayloadFrame : public Frame { +class PayloadFrame : public Frame { protected: // this tuple is only used when decoding values from a payload buffer std::tuple _values; @@ -170,8 +166,6 @@ protected: } } else if constexpr (std::is_same()) { this->payload.append((char *)&t, sizeof(t)); - } else if constexpr (std::is_same()) { - /* NOP, only to discriminate ctors for decode/encode. FIXME. */ } else { encode(t, this->payload, features); } @@ -194,8 +188,6 @@ protected: auto ptr = ti.get_current_ptr(); ti.advance(sizeof(T)); t = *(T *)ptr.raw_c_str(); - } else if constexpr (std::is_same()) { - /* NOP, only to discriminate ctors for decode/encode. FIXME. */ } else { decode(t, ti); } @@ -212,12 +204,24 @@ protected: return std::get(_values); } -public: - PayloadFrame(const Args &... args) { (_encode_payload_each(args), ...); } + PayloadFrame() : Frame() {} - PayloadFrame(do_not_encode_tag_t) {} + void _encode(const Args &... args) { + (_encode_payload_each(args), ...); + } + +public: + static C Encode(const Args &... args) { + C c; + c._encode(args...); + return c; + } - PayloadFrame(const ceph::bufferlist &payload) { this->decode_frame(payload); } + static C Decode(const ceph::bufferlist &payload) { + C c; + c.decode_frame(payload); + return c; + } void decode_payload(bufferlist::const_iterator &ti) { _decode_payload(ti, std::index_sequence_for()); @@ -228,10 +232,14 @@ struct HelloFrame : public PayloadFrame { // peer address static const Tag tag = Tag::HELLO; - using PayloadFrame::PayloadFrame; + using PayloadFrame::Encode; + using PayloadFrame::Decode; inline uint8_t &entity_type() { return get_val<0>(); } inline entity_addr_t &peer_addr() { return get_val<1>(); } + +protected: + using PayloadFrame::PayloadFrame; }; struct AuthRequestFrame : public PayloadFrame, // preferred modes bufferlist> { // auth payload static const Tag tag = Tag::AUTH_REQUEST; - using PayloadFrame::PayloadFrame; + using PayloadFrame::Encode; + using PayloadFrame::Decode; inline uint32_t &method() { return get_val<0>(); } inline vector &preferred_modes() { return get_val<1>(); } inline bufferlist &auth_payload() { return get_val<2>(); } + +protected: + using PayloadFrame::PayloadFrame; }; struct AuthBadMethodFrame : public PayloadFrame, // allowed methods std::vector> { // allowed modes static const Tag tag = Tag::AUTH_BAD_METHOD; - using PayloadFrame::PayloadFrame; + using PayloadFrame::Encode; + using PayloadFrame::Decode; inline uint32_t &method() { return get_val<0>(); } inline int32_t &result() { return get_val<1>(); } inline std::vector &allowed_methods() { return get_val<2>(); } inline std::vector &allowed_modes() { return get_val<3>(); } + +protected: + using PayloadFrame::PayloadFrame; }; struct AuthReplyMoreFrame : public PayloadFrame { // auth payload static const Tag tag = Tag::AUTH_REPLY_MORE; - using PayloadFrame::PayloadFrame; + using PayloadFrame::Encode; + using PayloadFrame::Decode; - inline bufferlist &auth_payload() { return get_val<1>(); } + inline bufferlist &auth_payload() { return get_val<0>(); } + +protected: + using PayloadFrame::PayloadFrame; }; struct AuthRequestMoreFrame : public PayloadFrame { // auth payload static const Tag tag = Tag::AUTH_REQUEST_MORE; - using PayloadFrame::PayloadFrame; + using PayloadFrame::Encode; + using PayloadFrame::Decode; + + inline bufferlist &auth_payload() { return get_val<0>(); } - inline bufferlist &auth_payload() { return get_val<1>(); } +protected: + using PayloadFrame::PayloadFrame; }; struct AuthDoneFrame : public PayloadFrame { // auth method payload static const Tag tag = Tag::AUTH_DONE; - using PayloadFrame::PayloadFrame; + using PayloadFrame::Encode; + using PayloadFrame::Decode; inline uint64_t &global_id() { return get_val<0>(); } inline uint32_t &con_mode() { return get_val<1>(); } inline bufferlist &auth_payload() { return get_val<2>(); } + +protected: + using PayloadFrame::PayloadFrame; }; template @@ -297,40 +323,44 @@ struct SignedEncryptedFrame : public PayloadFrame { return this->payload; } - SignedEncryptedFrame(ceph::crypto::onwire::rxtx_t &session_stream_handlers, - const Args &... args) - : PayloadFrame(args...) { + static T Encode(ceph::crypto::onwire::rxtx_t &session_stream_handlers, + const Args &... args) { + T c = PayloadFrame::Encode(args...); // FIXME: plainsize -> ciphersize; for AES-GCM they are equall apart // from auth tag size - this->fill_preamble({segment_t{this->payload.length() - FRAME_PREAMBLE_SIZE, - segment_t::DEFAULT_ALIGNMENT}}); + c.fill_preamble({segment_t{c.payload.length() - FRAME_PREAMBLE_SIZE, + segment_t::DEFAULT_ALIGNMENT}}); if (session_stream_handlers.tx) { ceph_assert(session_stream_handlers.tx); - session_stream_handlers.tx->reset_tx_handler({this->payload.length()}); + session_stream_handlers.tx->reset_tx_handler({c.payload.length()}); session_stream_handlers.tx->authenticated_encrypt_update( - std::move(this->payload)); - this->payload = session_stream_handlers.tx->authenticated_encrypt_final(); + std::move(c.payload)); + c.payload = session_stream_handlers.tx->authenticated_encrypt_final(); } + return c; } - SignedEncryptedFrame(ceph::crypto::onwire::rxtx_t &session_stream_handlers, - ceph::bufferlist &bl) - : PayloadFrame(do_not_encode_tag_t{}) { + static T Decode(ceph::crypto::onwire::rxtx_t &session_stream_handlers, + ceph::bufferlist &payload) { if (!session_stream_handlers.rx) { - this->decode_frame(bl); - return; + return PayloadFrame::Decode(payload); } - const auto length = bl.length(); + T c; + const auto length = payload.length(); ceph::bufferlist plain_bl = session_stream_handlers.rx->authenticated_decrypt_update_final( - std::move(bl), segment_t::DEFAULT_ALIGNMENT); + std::move(payload), segment_t::DEFAULT_ALIGNMENT); ceph_assert(plain_bl.length() == length - session_stream_handlers.rx->get_extra_size_at_final()); - this->decode_frame(plain_bl); + c.decode_frame(plain_bl); + return c; } + +protected: + SignedEncryptedFrame() : PayloadFrame() {} }; struct ClientIdentFrame @@ -344,7 +374,8 @@ struct ClientIdentFrame uint64_t, // flags uint64_t> { // client cookie static const Tag tag = Tag::CLIENT_IDENT; - using SignedEncryptedFrame::SignedEncryptedFrame; + using SignedEncryptedFrame::Encode; + using SignedEncryptedFrame::Decode; inline entity_addrvec_t &addrs() { return get_val<0>(); } inline entity_addr_t &target_addr() { return get_val<1>(); } @@ -354,6 +385,9 @@ struct ClientIdentFrame inline uint64_t &required_features() { return get_val<5>(); } inline uint64_t &flags() { return get_val<6>(); } inline uint64_t &cookie() { return get_val<7>(); } + +protected: + using SignedEncryptedFrame::SignedEncryptedFrame; }; struct ServerIdentFrame @@ -366,7 +400,8 @@ struct ServerIdentFrame uint64_t, // flags uint64_t> { // server cookie static const Tag tag = Tag::SERVER_IDENT; - using SignedEncryptedFrame::SignedEncryptedFrame; + using SignedEncryptedFrame::Encode; + using SignedEncryptedFrame::Decode; inline entity_addrvec_t &addrs() { return get_val<0>(); } inline int64_t &gid() { return get_val<1>(); } @@ -375,6 +410,9 @@ struct ServerIdentFrame inline uint64_t &required_features() { return get_val<4>(); } inline uint64_t &flags() { return get_val<5>(); } inline uint64_t &cookie() { return get_val<6>(); } + +protected: + using SignedEncryptedFrame::SignedEncryptedFrame; }; struct ReconnectFrame @@ -386,7 +424,8 @@ struct ReconnectFrame uint64_t, // connect sequence uint64_t> { // message sequence static const Tag tag = Tag::SESSION_RECONNECT; - using SignedEncryptedFrame::SignedEncryptedFrame; + using SignedEncryptedFrame::Encode; + using SignedEncryptedFrame::Decode; inline entity_addrvec_t &addrs() { return get_val<0>(); } inline uint64_t &client_cookie() { return get_val<1>(); } @@ -394,79 +433,120 @@ struct ReconnectFrame inline uint64_t &global_seq() { return get_val<3>(); } inline uint64_t &connect_seq() { return get_val<4>(); } inline uint64_t &msg_seq() { return get_val<5>(); } + +protected: + using SignedEncryptedFrame::SignedEncryptedFrame; }; struct ResetFrame : public SignedEncryptedFrame { // full reset static const Tag tag = Tag::SESSION_RESET; - using SignedEncryptedFrame::SignedEncryptedFrame; + using SignedEncryptedFrame::Encode; + using SignedEncryptedFrame::Decode; inline bool &full() { return get_val<0>(); } + +protected: + using SignedEncryptedFrame::SignedEncryptedFrame; }; struct RetryFrame : public SignedEncryptedFrame { // connection seq static const Tag tag = Tag::SESSION_RETRY; - using SignedEncryptedFrame::SignedEncryptedFrame; + using SignedEncryptedFrame::Encode; + using SignedEncryptedFrame::Decode; inline uint64_t &connect_seq() { return get_val<0>(); } + +protected: + using SignedEncryptedFrame::SignedEncryptedFrame; }; struct RetryGlobalFrame : public SignedEncryptedFrame { // global seq static const Tag tag = Tag::SESSION_RETRY_GLOBAL; - using SignedEncryptedFrame::SignedEncryptedFrame; + using SignedEncryptedFrame::Encode; + using SignedEncryptedFrame::Decode; inline uint64_t &global_seq() { return get_val<0>(); } + +protected: + using SignedEncryptedFrame::SignedEncryptedFrame; }; struct WaitFrame : public SignedEncryptedFrame { static const Tag tag = Tag::WAIT; + using SignedEncryptedFrame::Encode; + using SignedEncryptedFrame::Decode; + +protected: using SignedEncryptedFrame::SignedEncryptedFrame; }; struct ReconnectOkFrame : public SignedEncryptedFrame { // message seq static const Tag tag = Tag::SESSION_RECONNECT_OK; - using SignedEncryptedFrame::SignedEncryptedFrame; + using SignedEncryptedFrame::Encode; + using SignedEncryptedFrame::Decode; inline uint64_t &msg_seq() { return get_val<0>(); } + +protected: + using SignedEncryptedFrame::SignedEncryptedFrame; }; struct IdentMissingFeaturesFrame : public SignedEncryptedFrame { // missing features mask static const Tag tag = Tag::IDENT_MISSING_FEATURES; - using SignedEncryptedFrame::SignedEncryptedFrame; + using SignedEncryptedFrame::Encode; + using SignedEncryptedFrame::Decode; inline uint64_t &features() { return get_val<0>(); } + +protected: + using SignedEncryptedFrame::SignedEncryptedFrame; }; struct KeepAliveFrame : public SignedEncryptedFrame { // timestamp static const Tag tag = Tag::KEEPALIVE2; - using SignedEncryptedFrame::SignedEncryptedFrame; + using SignedEncryptedFrame::Encode; + using SignedEncryptedFrame::Decode; - KeepAliveFrame(ceph::crypto::onwire::rxtx_t &session_stream_handlers) - : KeepAliveFrame(session_stream_handlers, ceph_clock_now()) {} + static KeepAliveFrame Encode( + ceph::crypto::onwire::rxtx_t &session_stream_handlers) { + return KeepAliveFrame::Encode(session_stream_handlers, ceph_clock_now()); + } inline utime_t ×tamp() { return get_val<0>(); } + +protected: + using SignedEncryptedFrame::SignedEncryptedFrame; }; struct KeepAliveFrameAck : public SignedEncryptedFrame { // ack timestamp static const Tag tag = Tag::KEEPALIVE2_ACK; - using SignedEncryptedFrame::SignedEncryptedFrame; + using SignedEncryptedFrame::Encode; + using SignedEncryptedFrame::Decode; inline utime_t ×tamp() { return get_val<0>(); } + +protected: + using SignedEncryptedFrame::SignedEncryptedFrame; }; struct AckFrame : public SignedEncryptedFrame { // message sequence static const Tag tag = Tag::ACK; - using SignedEncryptedFrame::SignedEncryptedFrame; + using SignedEncryptedFrame::Encode; + using SignedEncryptedFrame::Decode; inline uint64_t &seq() { return get_val<0>(); } + +protected: + using SignedEncryptedFrame::SignedEncryptedFrame; }; // This class is used for encoding/decoding header of the message frame. @@ -481,29 +561,33 @@ struct MessageHeaderFrame return this->payload; } - MessageHeaderFrame(const ceph_msg_header2 &msghdr, - const uint32_t front_len, - const uint32_t middle_len, - const uint32_t data_len) - : PayloadFrame(msghdr) - { + static MessageHeaderFrame Encode(const ceph_msg_header2 &msg_header, + const uint32_t front_len, + const uint32_t middle_len, + const uint32_t data_len) { + MessageHeaderFrame f = + PayloadFrame::Encode(msg_header); // FIXME: plainsize -> ciphersize; for AES-GCM they are equall apart from auth tag size - fill_preamble({ - segment_t{ this->payload.length() - FRAME_PREAMBLE_SIZE, - segment_t::DEFAULT_ALIGNMENT }, + f.fill_preamble({ + segment_t{ f.payload.length() - FRAME_PREAMBLE_SIZE, + segment_t::DEFAULT_ALIGNMENT }, segment_t{ front_len, segment_t::DEFAULT_ALIGNMENT }, segment_t{ middle_len, segment_t::DEFAULT_ALIGNMENT }, segment_t{ data_len, segment_t::DEFERRED_ALLOCATION }, }); + return f; } - MessageHeaderFrame(ceph::bufferlist&& text) - : PayloadFrame(do_not_encode_tag_t{}) - { - this->decode_frame(text); + static MessageHeaderFrame Decode(ceph::bufferlist&& text) { + MessageHeaderFrame f; + f.decode_frame(text); + return f; } inline ceph_msg_header2 &header() { return get_val<0>(); } + +protected: + using PayloadFrame::PayloadFrame; }; } // namespace ceph::msgr::v2 -- 2.47.3