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);
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());
}
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
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);
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()
{
// 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_block_t&>(*preamble.c_str());
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();
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;
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;
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);
}
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);
}
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()
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;
<< 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);
}
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;
}
}
- 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()
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="
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;
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;
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__
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="
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();
}
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;
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()
}
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() << ")"
<< ", 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);
}
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();
}
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
{
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);
}
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()
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);
}
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:"
// 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);
}
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);
}
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);
}
<< " 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:
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);
}
<< " 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);
<< " 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);
}
<< " 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
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);
}
// 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);
}
}
}
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()
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;
}
}
-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<T *>(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 <class C, typename... Args>
-struct PayloadFrame : public Frame<C> {
+class PayloadFrame : public Frame<C> {
protected:
// this tuple is only used when decoding values from a payload buffer
std::tuple<Args...> _values;
}
} else if constexpr (std::is_same<T, ceph_msg_header2 const>()) {
this->payload.append((char *)&t, sizeof(t));
- } else if constexpr (std::is_same<T, dummy_ctor_conflict_helper const>()) {
- /* NOP, only to discriminate ctors for decode/encode. FIXME. */
} else {
encode(t, this->payload, features);
}
auto ptr = ti.get_current_ptr();
ti.advance(sizeof(T));
t = *(T *)ptr.raw_c_str();
- } else if constexpr (std::is_same<T, dummy_ctor_conflict_helper>()) {
- /* NOP, only to discriminate ctors for decode/encode. FIXME. */
} else {
decode(t, ti);
}
return std::get<N>(_values);
}
-public:
- PayloadFrame(const Args &... args) { (_encode_payload_each(args), ...); }
+ PayloadFrame() : Frame<C>() {}
- 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<Args...>());
uint8_t, // entity type
entity_addr_t> { // 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<AuthRequestFrame,
vector<uint32_t>, // 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<uint32_t> &preferred_modes() { return get_val<1>(); }
inline bufferlist &auth_payload() { return get_val<2>(); }
+
+protected:
+ using PayloadFrame::PayloadFrame;
};
struct AuthBadMethodFrame : public PayloadFrame<AuthBadMethodFrame,
std::vector<uint32_t>, // allowed methods
std::vector<uint32_t>> { // 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<uint32_t> &allowed_methods() { return get_val<2>(); }
inline std::vector<uint32_t> &allowed_modes() { return get_val<3>(); }
+
+protected:
+ using PayloadFrame::PayloadFrame;
};
struct AuthReplyMoreFrame : public PayloadFrame<AuthReplyMoreFrame,
- dummy_ctor_conflict_helper,
bufferlist> { // 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<AuthRequestMoreFrame,
- dummy_ctor_conflict_helper,
bufferlist> { // 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<AuthDoneFrame,
uint32_t, // connection mode
bufferlist> { // 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 <class T, typename... Args>
return this->payload;
}
- SignedEncryptedFrame(ceph::crypto::onwire::rxtx_t &session_stream_handlers,
- const Args &... args)
- : PayloadFrame<T, Args...>(args...) {
+ static T Encode(ceph::crypto::onwire::rxtx_t &session_stream_handlers,
+ const Args &... args) {
+ T c = PayloadFrame<T, Args...>::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<T, Args...>(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<T, Args...>::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<T, Args...>() {}
};
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>(); }
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
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>(); }
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
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>(); }
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<ResetFrame,
bool> { // 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<RetryFrame,
uint64_t> { // 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<RetryGlobalFrame,
uint64_t> { // 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<WaitFrame> {
static const Tag tag = Tag::WAIT;
+ using SignedEncryptedFrame::Encode;
+ using SignedEncryptedFrame::Decode;
+
+protected:
using SignedEncryptedFrame::SignedEncryptedFrame;
};
struct ReconnectOkFrame : public SignedEncryptedFrame<ReconnectOkFrame,
uint64_t> { // 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<IdentMissingFeaturesFrame,
uint64_t> { // 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<KeepAliveFrame,
utime_t> { // 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<KeepAliveFrameAck,
utime_t> { // 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<AckFrame,
uint64_t> { // 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.
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<MessageHeaderFrame, ceph_msg_header2>(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<MessageHeaderFrame, ceph_msg_header2>::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<MessageHeaderFrame, ceph_msg_header2>(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
projects / ceph.git / commitdiff