[cleanup] Update pointer alignment style in masque code
This change aligns the masque code with the rest of QUICHE and with current
Google style guide.
This change was generated using `clang-format`.
#cleanup
PiperOrigin-RevId: 825611970
diff --git a/quiche/quic/masque/masque_connection_pool.cc b/quiche/quic/masque/masque_connection_pool.cc
index 5413c27..8481f98 100644
--- a/quiche/quic/masque/masque_connection_pool.cc
+++ b/quiche/quic/masque/masque_connection_pool.cc
@@ -35,40 +35,41 @@
namespace quic {
MasqueConnectionPool::MasqueConnectionPool(
- QuicEventLoop *event_loop, SSL_CTX *ssl_ctx,
+ QuicEventLoop* event_loop, SSL_CTX* ssl_ctx,
bool disable_certificate_verification, int address_family_for_lookup,
- Visitor *visitor)
+ Visitor* visitor)
: event_loop_(event_loop),
ssl_ctx_(ssl_ctx),
disable_certificate_verification_(disable_certificate_verification),
address_family_for_lookup_(address_family_for_lookup),
visitor_(visitor) {}
-void MasqueConnectionPool::OnConnectionReady(MasqueH2Connection *connection) {
+void MasqueConnectionPool::OnConnectionReady(MasqueH2Connection* connection) {
SendPendingRequests(connection);
}
void MasqueConnectionPool::OnConnectionFinished(
- MasqueH2Connection *connection) {
+ MasqueH2Connection* connection) {
FailPendingRequests(
connection,
absl::InternalError("Connection finished before receiving request"));
}
-void MasqueConnectionPool::OnRequest(
- MasqueH2Connection * /*connection*/, int32_t /*stream_id*/,
- const quiche::HttpHeaderBlock & /*headers*/, const std::string & /*body*/) {
+void MasqueConnectionPool::OnRequest(MasqueH2Connection* /*connection*/,
+ int32_t /*stream_id*/,
+ const quiche::HttpHeaderBlock& /*headers*/,
+ const std::string& /*body*/) {
QUICHE_LOG(FATAL) << "Client cannot receive requests";
}
-void MasqueConnectionPool::OnResponse(MasqueH2Connection *connection,
+void MasqueConnectionPool::OnResponse(MasqueH2Connection* connection,
int32_t stream_id,
- const quiche::HttpHeaderBlock &headers,
- const std::string &body) {
+ const quiche::HttpHeaderBlock& headers,
+ const std::string& body) {
bool found = false;
for (auto it = pending_requests_.begin(); it != pending_requests_.end();) {
RequestId request_id = it->first;
- PendingRequest &pending_request = *it->second;
+ PendingRequest& pending_request = *it->second;
if (pending_request.connection == connection &&
pending_request.stream_id == stream_id) {
pending_requests_.erase(it++);
@@ -88,12 +89,12 @@
}
absl::StatusOr<MasqueConnectionPool::RequestId>
-MasqueConnectionPool::SendRequest(const Message &request) {
+MasqueConnectionPool::SendRequest(const Message& request) {
auto authority = request.headers.find(":authority");
if (authority == request.headers.end()) {
return absl::InvalidArgumentError("Request missing :authority header");
}
- ConnectionState *connection =
+ ConnectionState* connection =
GetOrCreateConnectionState(std::string(authority->second));
if (connection == nullptr) {
return absl::InternalError(
@@ -116,8 +117,8 @@
return request_id;
}
-MasqueConnectionPool::ConnectionState *
-MasqueConnectionPool::GetOrCreateConnectionState(const std::string &authority) {
+MasqueConnectionPool::ConnectionState*
+MasqueConnectionPool::GetOrCreateConnectionState(const std::string& authority) {
auto connection_state_it = connections_.find(authority);
if (connection_state_it != connections_.end()) {
return connection_state_it->second.get();
@@ -134,10 +135,10 @@
}
void MasqueConnectionPool::AttachConnectionToPendingRequests(
- const std::string &authority, MasqueH2Connection *connection) {
+ const std::string& authority, MasqueH2Connection* connection) {
for (auto it = pending_requests_.begin(); it != pending_requests_.end();
++it) {
- PendingRequest &pending_request = *it->second;
+ PendingRequest& pending_request = *it->second;
auto authority_header = pending_request.request.headers.find(":authority");
if (authority_header == pending_request.request.headers.end()) {
QUICHE_LOG(ERROR) << "Request missing :authority header";
@@ -150,10 +151,10 @@
}
}
-void MasqueConnectionPool::SendPendingRequests(MasqueH2Connection *connection) {
+void MasqueConnectionPool::SendPendingRequests(MasqueH2Connection* connection) {
for (auto it = pending_requests_.begin(); it != pending_requests_.end();) {
RequestId request_id = it->first;
- PendingRequest &pending_request = *it->second;
+ PendingRequest& pending_request = *it->second;
if (pending_request.connection != connection) {
++it;
continue;
@@ -172,11 +173,11 @@
}
}
-void MasqueConnectionPool::FailPendingRequests(MasqueH2Connection *connection,
- const absl::Status &error) {
+void MasqueConnectionPool::FailPendingRequests(MasqueH2Connection* connection,
+ const absl::Status& error) {
for (auto it = pending_requests_.begin(); it != pending_requests_.end();) {
RequestId request_id = it->first;
- PendingRequest &pending_request = *it->second;
+ PendingRequest& pending_request = *it->second;
if (pending_request.connection != connection) {
++it;
continue;
@@ -187,7 +188,7 @@
}
MasqueConnectionPool::ConnectionState::ConnectionState(
- MasqueConnectionPool *connection_pool)
+ MasqueConnectionPool* connection_pool)
: connection_pool_(connection_pool) {}
MasqueConnectionPool::ConnectionState::~ConnectionState() {
@@ -203,7 +204,7 @@
}
bool MasqueConnectionPool::ConnectionState::SetupSocket(
- const std::string &authority, bool disable_certificate_verification,
+ const std::string& authority, bool disable_certificate_verification,
int address_family_for_lookup) {
authority_ = authority;
std::vector<std::string> authority_split =
@@ -249,7 +250,7 @@
}
void MasqueConnectionPool::ConnectionState::OnSocketEvent(
- QuicEventLoop * /*event_loop*/, SocketFd fd, QuicSocketEventMask events) {
+ QuicEventLoop* /*event_loop*/, SocketFd fd, QuicSocketEventMask events) {
if (fd != socket_) {
return;
}
@@ -277,7 +278,7 @@
sizeof(kAlpnProtocols)) != 0) {
QUICHE_LOG(FATAL) << "SSL_set_alpn_protos failed";
}
- BIO *bio = BIO_new_socket(socket_, BIO_CLOSE);
+ BIO* bio = BIO_new_socket(socket_, BIO_CLOSE);
SSL_set_bio(ssl_.get(), bio, bio);
// `SSL_set_bio` causes `ssl_` to take ownership of `bio`.
connection_ = std::make_unique<MasqueH2Connection>(
@@ -292,36 +293,36 @@
// static
enum ssl_verify_result_t MasqueConnectionPool::ConnectionState::VerifyCallback(
- SSL *ssl, uint8_t *out_alert) {
- return static_cast<MasqueConnectionPool::ConnectionState *>(
+ SSL* ssl, uint8_t* out_alert) {
+ return static_cast<MasqueConnectionPool::ConnectionState*>(
SSL_get_app_data(ssl))
->VerifyCertificate(ssl, out_alert);
}
enum ssl_verify_result_t
-MasqueConnectionPool::ConnectionState::VerifyCertificate(SSL *ssl,
- uint8_t *out_alert) {
- const STACK_OF(CRYPTO_BUFFER) *cert_chain = SSL_get0_peer_certificates(ssl);
+MasqueConnectionPool::ConnectionState::VerifyCertificate(SSL* ssl,
+ uint8_t* out_alert) {
+ const STACK_OF(CRYPTO_BUFFER)* cert_chain = SSL_get0_peer_certificates(ssl);
if (cert_chain == nullptr) {
QUICHE_LOG(ERROR) << "No certificate chain";
*out_alert = SSL_AD_INTERNAL_ERROR;
return ssl_verify_invalid;
}
std::vector<std::string> certs;
- for (CRYPTO_BUFFER *cert : cert_chain) {
+ for (CRYPTO_BUFFER* cert : cert_chain) {
certs.push_back(
- std::string(reinterpret_cast<const char *>(CRYPTO_BUFFER_data(cert)),
+ std::string(reinterpret_cast<const char*>(CRYPTO_BUFFER_data(cert)),
CRYPTO_BUFFER_len(cert)));
}
- const uint8_t *ocsp_response_raw;
+ const uint8_t* ocsp_response_raw;
size_t ocsp_response_len;
SSL_get0_ocsp_response(ssl, &ocsp_response_raw, &ocsp_response_len);
- std::string ocsp_response(reinterpret_cast<const char *>(ocsp_response_raw),
+ std::string ocsp_response(reinterpret_cast<const char*>(ocsp_response_raw),
ocsp_response_len);
- const uint8_t *sct_list_raw;
+ const uint8_t* sct_list_raw;
size_t sct_list_len;
SSL_get0_signed_cert_timestamp_list(ssl, &sct_list_raw, &sct_list_len);
- std::string cert_sct(reinterpret_cast<const char *>(sct_list_raw),
+ std::string cert_sct(reinterpret_cast<const char*>(sct_list_raw),
sct_list_len);
std::string error_details;
std::unique_ptr<ProofVerifyDetails> details;
@@ -342,8 +343,8 @@
// static
absl::StatusOr<bssl::UniquePtr<SSL_CTX>> MasqueConnectionPool::CreateSslCtx(
- const std::string &client_cert_file,
- const std::string &client_cert_key_file) {
+ const std::string& client_cert_file,
+ const std::string& client_cert_key_file) {
if (client_cert_file.empty() != client_cert_key_file.empty()) {
return absl::InvalidArgumentError(
"Both private key and certificate chain are required when using client "
diff --git a/quiche/quic/masque/masque_connection_pool.h b/quiche/quic/masque/masque_connection_pool.h
index 7b61bea..b70c391 100644
--- a/quiche/quic/masque/masque_connection_pool.h
+++ b/quiche/quic/masque/masque_connection_pool.h
@@ -34,57 +34,57 @@
class QUIC_NO_EXPORT Visitor {
public:
virtual ~Visitor() = default;
- virtual void OnResponse(MasqueConnectionPool *pool, RequestId request_id,
- const absl::StatusOr<Message> &response) = 0;
+ virtual void OnResponse(MasqueConnectionPool* pool, RequestId request_id,
+ const absl::StatusOr<Message>& response) = 0;
};
// If the request fails immediately, the error will be returned. Otherwise, a
// request ID will be returned and the result (the response or an error) will
// be delivered later with that same request ID via Visitor::OnResponse.
- absl::StatusOr<RequestId> SendRequest(const Message &request);
+ absl::StatusOr<RequestId> SendRequest(const Message& request);
// `event_loop`, `ssl_ctx`, and `visitor` must outlive this object.
- explicit MasqueConnectionPool(QuicEventLoop *event_loop, SSL_CTX *ssl_ctx,
+ explicit MasqueConnectionPool(QuicEventLoop* event_loop, SSL_CTX* ssl_ctx,
bool disable_certificate_verification,
int address_family_for_lookup,
- Visitor *visitor);
+ Visitor* visitor);
- QuicEventLoop *event_loop() { return event_loop_; }
- SSL_CTX *ssl_ctx() { return ssl_ctx_; }
+ QuicEventLoop* event_loop() { return event_loop_; }
+ SSL_CTX* ssl_ctx() { return ssl_ctx_; }
// From MasqueH2Connection::Visitor:
- void OnConnectionReady(MasqueH2Connection *connection) override;
- void OnConnectionFinished(MasqueH2Connection *connection) override;
- void OnRequest(MasqueH2Connection *connection, int32_t stream_id,
- const quiche::HttpHeaderBlock &headers,
- const std::string &body) override;
- void OnResponse(MasqueH2Connection *connection, int32_t stream_id,
- const quiche::HttpHeaderBlock &headers,
- const std::string &body) override;
+ void OnConnectionReady(MasqueH2Connection* connection) override;
+ void OnConnectionFinished(MasqueH2Connection* connection) override;
+ void OnRequest(MasqueH2Connection* connection, int32_t stream_id,
+ const quiche::HttpHeaderBlock& headers,
+ const std::string& body) override;
+ void OnResponse(MasqueH2Connection* connection, int32_t stream_id,
+ const quiche::HttpHeaderBlock& headers,
+ const std::string& body) override;
static absl::StatusOr<bssl::UniquePtr<SSL_CTX>> CreateSslCtx(
- const std::string &client_cert_file,
- const std::string &client_cert_key_file);
+ const std::string& client_cert_file,
+ const std::string& client_cert_key_file);
private:
class ConnectionState : public QuicSocketEventListener {
public:
- explicit ConnectionState(MasqueConnectionPool *connection_pool);
+ explicit ConnectionState(MasqueConnectionPool* connection_pool);
~ConnectionState() override;
- bool SetupSocket(const std::string &authority,
+ bool SetupSocket(const std::string& authority,
bool disable_certificate_verification,
int address_family_for_lookup);
// From QuicSocketEventListener.
- void OnSocketEvent(QuicEventLoop *event_loop, SocketFd fd,
+ void OnSocketEvent(QuicEventLoop* event_loop, SocketFd fd,
QuicSocketEventMask events) override;
- MasqueH2Connection *connection() { return connection_.get(); }
+ MasqueH2Connection* connection() { return connection_.get(); }
private:
- static enum ssl_verify_result_t VerifyCallback(SSL *ssl,
- uint8_t *out_alert);
- enum ssl_verify_result_t VerifyCertificate(SSL *ssl, uint8_t *out_alert);
- MasqueConnectionPool *connection_pool_; // Not owned.
+ static enum ssl_verify_result_t VerifyCallback(SSL* ssl,
+ uint8_t* out_alert);
+ enum ssl_verify_result_t VerifyCertificate(SSL* ssl, uint8_t* out_alert);
+ MasqueConnectionPool* connection_pool_; // Not owned.
std::string authority_;
std::string host_;
std::unique_ptr<ProofVerifier> proof_verifier_;
@@ -94,22 +94,22 @@
};
struct PendingRequest {
Message request;
- MasqueH2Connection *connection = nullptr; // Not owned.
+ MasqueH2Connection* connection = nullptr; // Not owned.
int32_t stream_id = -1;
};
- ConnectionState *GetOrCreateConnectionState(const std::string &authority);
- void AttachConnectionToPendingRequests(const std::string &authority,
- MasqueH2Connection *connection);
- void SendPendingRequests(MasqueH2Connection *connection);
- void FailPendingRequests(MasqueH2Connection *connection,
- const absl::Status &error);
+ ConnectionState* GetOrCreateConnectionState(const std::string& authority);
+ void AttachConnectionToPendingRequests(const std::string& authority,
+ MasqueH2Connection* connection);
+ void SendPendingRequests(MasqueH2Connection* connection);
+ void FailPendingRequests(MasqueH2Connection* connection,
+ const absl::Status& error);
- QuicEventLoop *event_loop_; // Not owned.
- SSL_CTX *ssl_ctx_; // Not owned.
+ QuicEventLoop* event_loop_; // Not owned.
+ SSL_CTX* ssl_ctx_; // Not owned.
const bool disable_certificate_verification_;
const int address_family_for_lookup_;
- Visitor *visitor_; // Not owned.
+ Visitor* visitor_; // Not owned.
absl::flat_hash_map<std::string, std::unique_ptr<ConnectionState>>
connections_;
absl::flat_hash_map<RequestId, std::unique_ptr<PendingRequest>>
diff --git a/quiche/quic/masque/masque_h2_connection.cc b/quiche/quic/masque/masque_h2_connection.cc
index 2feaa2c..11bdfb1 100644
--- a/quiche/quic/masque/masque_h2_connection.cc
+++ b/quiche/quic/masque/masque_h2_connection.cc
@@ -32,8 +32,8 @@
namespace quic {
-MasqueH2Connection::MasqueH2Connection(SSL *ssl, bool is_server,
- Visitor *visitor)
+MasqueH2Connection::MasqueH2Connection(SSL* ssl, bool is_server,
+ Visitor* visitor)
: ssl_(ssl), is_server_(is_server), visitor_(visitor) {}
void MasqueH2Connection::OnTransportReadable() {
@@ -110,9 +110,9 @@
QUICHE_DVLOG(1) << "Read " << ssl_read_ret << " bytes from TLS";
QUICHE_DVLOG(2) << "Read TLS bytes:" << std::endl
<< quiche::QuicheTextUtils::HexDump(absl::string_view(
- reinterpret_cast<const char *>(buffer), ssl_read_ret));
+ reinterpret_cast<const char*>(buffer), ssl_read_ret));
h2_adapter_->ProcessBytes(
- absl::string_view(reinterpret_cast<const char *>(buffer), ssl_read_ret));
+ absl::string_view(reinterpret_cast<const char*>(buffer), ssl_read_ret));
return AttemptToSend();
}
@@ -149,7 +149,7 @@
MasqueH2Connection::DataFrameHeaderInfo
MasqueH2Connection::OnReadyToSendDataForStream(Http2StreamId stream_id,
size_t max_length) {
- MasqueH2Stream *stream = GetOrCreateH2Stream(stream_id);
+ MasqueH2Stream* stream = GetOrCreateH2Stream(stream_id);
DataFrameHeaderInfo info;
if (max_length < stream->body_to_send.size()) {
info.payload_length = max_length;
@@ -168,7 +168,7 @@
if (!WriteDataToTls(frame_header)) {
return false;
}
- MasqueH2Stream *stream = GetOrCreateH2Stream(stream_id);
+ MasqueH2Stream* stream = GetOrCreateH2Stream(stream_id);
size_t length_to_write = std::min(payload_bytes, stream->body_to_send.size());
int length_written =
WriteDataToTls(stream->body_to_send.substr(0, length_to_write));
@@ -230,16 +230,16 @@
}
bool MasqueH2Connection::OnEndHeadersForStream(Http2StreamId stream_id) {
- MasqueH2Stream *stream = GetOrCreateH2Stream(stream_id);
+ MasqueH2Stream* stream = GetOrCreateH2Stream(stream_id);
QUICHE_LOG(INFO) << "OnEndHeadersForStream " << stream_id
<< " headers: " << stream->received_headers.DebugString();
return true;
}
void MasqueH2Connection::SendResponse(int32_t stream_id,
- const quiche::HttpHeaderBlock &headers,
- const std::string &body) {
- MasqueH2Stream *stream = GetOrCreateH2Stream(stream_id);
+ const quiche::HttpHeaderBlock& headers,
+ const std::string& body) {
+ MasqueH2Stream* stream = GetOrCreateH2Stream(stream_id);
std::vector<Header> h2_headers = ConvertHeaders(headers);
stream->body_to_send = body;
if (h2_adapter_->SubmitResponse(
@@ -250,8 +250,8 @@
}
}
-int32_t MasqueH2Connection::SendRequest(const quiche::HttpHeaderBlock &headers,
- const std::string &body) {
+int32_t MasqueH2Connection::SendRequest(const quiche::HttpHeaderBlock& headers,
+ const std::string& body) {
if (is_server_) {
QUICHE_LOG(FATAL) << "Server cannot send requests";
}
@@ -275,9 +275,9 @@
}
std::vector<Header> MasqueH2Connection::ConvertHeaders(
- const quiche::HttpHeaderBlock &headers) {
+ const quiche::HttpHeaderBlock& headers) {
std::vector<Header> h2_headers;
- for (const auto &[key, value] : headers) {
+ for (const auto& [key, value] : headers) {
h2_headers.push_back({http2::adapter::HeaderRep(std::string(key)),
http2::adapter::HeaderRep(std::string(value))});
}
@@ -307,7 +307,7 @@
}
bool MasqueH2Connection::OnEndStream(Http2StreamId stream_id) {
- MasqueH2Stream *stream = GetOrCreateH2Stream(stream_id);
+ MasqueH2Stream* stream = GetOrCreateH2Stream(stream_id);
QUICHE_LOG(INFO) << "Received END_STREAM for stream " << stream_id
<< " body length: " << stream->received_body.size()
<< std::endl
@@ -420,7 +420,7 @@
QUICHE_LOG(ERROR) << "OnErrorDebug: " << message;
}
-MasqueH2Connection::MasqueH2Stream *MasqueH2Connection::GetOrCreateH2Stream(
+MasqueH2Connection::MasqueH2Stream* MasqueH2Connection::GetOrCreateH2Stream(
Http2StreamId stream_id) {
auto it = h2_streams_.find(stream_id);
if (it != h2_streams_.end()) {
@@ -430,7 +430,7 @@
.first->second.get();
}
-void PrintSSLError(const char *msg, int ssl_err, int ret) {
+void PrintSSLError(const char* msg, int ssl_err, int ret) {
switch (ssl_err) {
case SSL_ERROR_SSL:
QUICHE_LOG(ERROR) << msg << ": "
diff --git a/quiche/quic/masque/masque_h2_connection.h b/quiche/quic/masque/masque_h2_connection.h
index 58c8159..91f883c 100644
--- a/quiche/quic/masque/masque_h2_connection.h
+++ b/quiche/quic/masque/masque_h2_connection.h
@@ -37,23 +37,23 @@
class QUICHE_NO_EXPORT Visitor {
public:
virtual ~Visitor() = default;
- virtual void OnConnectionReady(MasqueH2Connection *connection) = 0;
- virtual void OnConnectionFinished(MasqueH2Connection *connection) = 0;
- virtual void OnRequest(MasqueH2Connection *connection, int32_t stream_id,
- const quiche::HttpHeaderBlock &headers,
- const std::string &body) = 0;
- virtual void OnResponse(MasqueH2Connection *connection, int32_t stream_id,
- const quiche::HttpHeaderBlock &headers,
- const std::string &body) = 0;
+ virtual void OnConnectionReady(MasqueH2Connection* connection) = 0;
+ virtual void OnConnectionFinished(MasqueH2Connection* connection) = 0;
+ virtual void OnRequest(MasqueH2Connection* connection, int32_t stream_id,
+ const quiche::HttpHeaderBlock& headers,
+ const std::string& body) = 0;
+ virtual void OnResponse(MasqueH2Connection* connection, int32_t stream_id,
+ const quiche::HttpHeaderBlock& headers,
+ const std::string& body) = 0;
};
// `ssl` and `visitor` must outlive this object.
- explicit MasqueH2Connection(SSL *ssl, bool is_server, Visitor *visitor);
+ explicit MasqueH2Connection(SSL* ssl, bool is_server, Visitor* visitor);
- MasqueH2Connection(const MasqueH2Connection &) = delete;
- MasqueH2Connection(MasqueH2Connection &&) = delete;
- MasqueH2Connection &operator=(const MasqueH2Connection &) = delete;
- MasqueH2Connection &operator=(MasqueH2Connection &&) = delete;
+ MasqueH2Connection(const MasqueH2Connection&) = delete;
+ MasqueH2Connection(MasqueH2Connection&&) = delete;
+ MasqueH2Connection& operator=(const MasqueH2Connection&) = delete;
+ MasqueH2Connection& operator=(MasqueH2Connection&&) = delete;
~MasqueH2Connection();
@@ -62,10 +62,10 @@
void OnTransportReadable();
// Call when there is more data to be written to SSL.
bool AttemptToSend();
- int32_t SendRequest(const quiche::HttpHeaderBlock &headers,
- const std::string &body);
- void SendResponse(int32_t stream_id, const quiche::HttpHeaderBlock &headers,
- const std::string &body);
+ int32_t SendRequest(const quiche::HttpHeaderBlock& headers,
+ const std::string& body);
+ void SendResponse(int32_t stream_id, const quiche::HttpHeaderBlock& headers,
+ const std::string& body);
private:
struct MasqueH2Stream {
@@ -77,9 +77,9 @@
void Abort();
void StartH2();
bool TryRead();
- MasqueH2Stream *GetOrCreateH2Stream(Http2StreamId stream_id);
+ MasqueH2Stream* GetOrCreateH2Stream(Http2StreamId stream_id);
std::vector<http2::adapter::Header> ConvertHeaders(
- const quiche::HttpHeaderBlock &headers);
+ const quiche::HttpHeaderBlock& headers);
int WriteDataToTls(absl::string_view data);
@@ -132,18 +132,18 @@
bool OnMetadataEndForStream(Http2StreamId stream_id) override;
void OnErrorDebug(absl::string_view message) override;
- SSL *ssl_;
+ SSL* ssl_;
std::unique_ptr<http2::adapter::OgHttp2Adapter> h2_adapter_;
const bool is_server_;
bool tls_connected_ = false;
bool aborted_ = false;
absl::flat_hash_map<Http2StreamId, std::unique_ptr<MasqueH2Stream>>
h2_streams_;
- Visitor *visitor_;
+ Visitor* visitor_;
};
// Logs an SSL error that was provided by BoringSSL.
-void PrintSSLError(const char *msg, int ssl_err, int ret);
+void PrintSSLError(const char* msg, int ssl_err, int ret);
} // namespace quic
diff --git a/quiche/quic/masque/masque_ohttp_client_bin.cc b/quiche/quic/masque/masque_ohttp_client_bin.cc
index 9fa7868..eaa3822 100644
--- a/quiche/quic/masque/masque_ohttp_client_bin.cc
+++ b/quiche/quic/masque/masque_ohttp_client_bin.cc
@@ -67,11 +67,11 @@
public:
using RequestId = MasqueConnectionPool::RequestId;
using Message = MasqueConnectionPool::Message;
- explicit MasqueOhttpClient(QuicEventLoop *event_loop, SSL_CTX *ssl_ctx,
+ explicit MasqueOhttpClient(QuicEventLoop* event_loop, SSL_CTX* ssl_ctx,
std::vector<std::string> urls,
bool disable_certificate_verification,
int address_family_for_lookup,
- const std::string &post_data)
+ const std::string& post_data)
: urls_(urls),
post_data_(post_data),
connection_pool_(event_loop, ssl_ctx, disable_certificate_verification,
@@ -101,8 +101,8 @@
}
// From MasqueConnectionPool::Visitor.
- void OnResponse(MasqueConnectionPool * /*pool*/, RequestId request_id,
- const absl::StatusOr<Message> &response) override {
+ void OnResponse(MasqueConnectionPool* /*pool*/, RequestId request_id,
+ const absl::StatusOr<Message>& response) override {
if (key_fetch_request_id_.has_value() &&
*key_fetch_request_id_ == request_id) {
key_fetch_request_id_ = std::nullopt;
@@ -152,7 +152,7 @@
}
private:
- bool StartKeyFetch(const std::string &url_string) {
+ bool StartKeyFetch(const std::string& url_string) {
QuicUrl url(url_string, "https");
if (url.host().empty() && !absl::StrContains(url_string, "://")) {
url = QuicUrl(absl::StrCat("https://", url_string));
@@ -178,7 +178,7 @@
return true;
}
- void HandleKeyResponse(const absl::StatusOr<Message> &response) {
+ void HandleKeyResponse(const absl::StatusOr<Message>& response) {
if (!response.ok()) {
QUICHE_LOG(ERROR) << "Failed to fetch key: " << response.status();
return;
@@ -230,7 +230,7 @@
}
}
- void SendOhttpRequestForUrl(const std::string &url_string) {
+ void SendOhttpRequestForUrl(const std::string& url_string) {
QuicUrl url(url_string, "https");
if (url.host().empty() && !absl::StrContains(url_string, "://")) {
url = QuicUrl(absl::StrCat("https://", url_string));
@@ -297,8 +297,8 @@
pending_ohttp_requests_;
};
-int RunMasqueOhttpClient(int argc, char *argv[]) {
- const char *usage =
+int RunMasqueOhttpClient(int argc, char* argv[]) {
+ const char* usage =
"Usage: masque_ohttp_client <key-url> <relay-url> <url>...";
std::vector<std::string> urls =
quiche::QuicheParseCommandLineFlags(usage, argc, argv);
@@ -348,6 +348,6 @@
} // namespace
} // namespace quic
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
return quic::RunMasqueOhttpClient(argc, argv);
}
diff --git a/quiche/quic/masque/masque_tcp_client_bin.cc b/quiche/quic/masque/masque_tcp_client_bin.cc
index fc57693..5a0b4fd 100644
--- a/quiche/quic/masque/masque_tcp_client_bin.cc
+++ b/quiche/quic/masque/masque_tcp_client_bin.cc
@@ -73,8 +73,8 @@
namespace {
std::optional<bssl::UniquePtr<SSL_CTX>> CreateSslCtx(
- const std::string &client_cert_file,
- const std::string &client_cert_key_file) {
+ const std::string& client_cert_file,
+ const std::string& client_cert_key_file) {
if (client_cert_file.empty() != client_cert_key_file.empty()) {
QUICHE_LOG(ERROR) << "Both private key and certificate chain are required "
"when using client certificates";
@@ -105,7 +105,7 @@
class MasqueTlsTcpClientHandler : public ConnectingClientSocket::AsyncVisitor,
public MasqueH2Connection::Visitor {
public:
- explicit MasqueTlsTcpClientHandler(QuicEventLoop *event_loop, SSL_CTX *ctx,
+ explicit MasqueTlsTcpClientHandler(QuicEventLoop* event_loop, SSL_CTX* ctx,
QuicUrl url,
bool disable_certificate_verification,
int address_family_for_lookup)
@@ -149,13 +149,13 @@
return true;
}
- static enum ssl_verify_result_t VerifyCallback(SSL *ssl, uint8_t *out_alert) {
- return static_cast<MasqueTlsTcpClientHandler *>(SSL_get_app_data(ssl))
+ static enum ssl_verify_result_t VerifyCallback(SSL* ssl, uint8_t* out_alert) {
+ return static_cast<MasqueTlsTcpClientHandler*>(SSL_get_app_data(ssl))
->VerifyCertificate(out_alert);
}
- enum ssl_verify_result_t VerifyCertificate(uint8_t *out_alert) {
- const STACK_OF(CRYPTO_BUFFER) *cert_chain =
+ enum ssl_verify_result_t VerifyCertificate(uint8_t* out_alert) {
+ const STACK_OF(CRYPTO_BUFFER)* cert_chain =
SSL_get0_peer_certificates(ssl_.get());
if (cert_chain == nullptr) {
QUICHE_LOG(ERROR) << "No certificate chain";
@@ -163,21 +163,21 @@
return ssl_verify_invalid;
}
std::vector<std::string> certs;
- for (CRYPTO_BUFFER *cert : cert_chain) {
+ for (CRYPTO_BUFFER* cert : cert_chain) {
certs.push_back(
- std::string(reinterpret_cast<const char *>(CRYPTO_BUFFER_data(cert)),
+ std::string(reinterpret_cast<const char*>(CRYPTO_BUFFER_data(cert)),
CRYPTO_BUFFER_len(cert)));
}
- const uint8_t *ocsp_response_raw;
+ const uint8_t* ocsp_response_raw;
size_t ocsp_response_len;
SSL_get0_ocsp_response(ssl_.get(), &ocsp_response_raw, &ocsp_response_len);
- std::string ocsp_response(reinterpret_cast<const char *>(ocsp_response_raw),
+ std::string ocsp_response(reinterpret_cast<const char*>(ocsp_response_raw),
ocsp_response_len);
- const uint8_t *sct_list_raw;
+ const uint8_t* sct_list_raw;
size_t sct_list_len;
SSL_get0_signed_cert_timestamp_list(ssl_.get(), &sct_list_raw,
&sct_list_len);
- std::string cert_sct(reinterpret_cast<const char *>(sct_list_raw),
+ std::string cert_sct(reinterpret_cast<const char*>(sct_list_raw),
sct_list_len);
std::string error_details;
std::unique_ptr<ProofVerifyDetails> details;
@@ -230,7 +230,7 @@
return;
}
- BIO *tls_io = nullptr;
+ BIO* tls_io = nullptr;
if (BIO_new_bio_pair(&transport_io_, kBioBufferSize, &tls_io,
kBioBufferSize) != 1) {
QUICHE_LOG(FATAL) << "BIO_new_bio_pair failed";
@@ -350,20 +350,20 @@
bool IsDone() const { return done_; }
// From MasqueH2Connection::Visitor.
- void OnConnectionReady(MasqueH2Connection * /*connection*/) override {}
- void OnConnectionFinished(MasqueH2Connection * /*connection*/) override {
+ void OnConnectionReady(MasqueH2Connection* /*connection*/) override {}
+ void OnConnectionFinished(MasqueH2Connection* /*connection*/) override {
done_ = true;
}
- void OnRequest(MasqueH2Connection * /*connection*/, int32_t /*stream_id*/,
- const quiche::HttpHeaderBlock & /*headers*/,
- const std::string & /*body*/) override {
+ void OnRequest(MasqueH2Connection* /*connection*/, int32_t /*stream_id*/,
+ const quiche::HttpHeaderBlock& /*headers*/,
+ const std::string& /*body*/) override {
QUICHE_LOG(FATAL) << "Client cannot receive requests";
}
- void OnResponse(MasqueH2Connection *connection, int32_t stream_id,
- const quiche::HttpHeaderBlock &headers,
- const std::string &body) override {
+ void OnResponse(MasqueH2Connection* connection, int32_t stream_id,
+ const quiche::HttpHeaderBlock& headers,
+ const std::string& body) override {
if (connection != h2_connection_.get()) {
QUICHE_LOG(FATAL) << "Unexpected connection";
}
@@ -380,16 +380,16 @@
if (request_sent_ || done_ || !tls_connected_) {
return;
}
- const uint8_t *alpn_data;
+ const uint8_t* alpn_data;
unsigned alpn_len;
SSL_get0_alpn_selected(ssl_.get(), &alpn_data, &alpn_len);
if (alpn_len != 0) {
- std::string alpn(reinterpret_cast<const char *>(alpn_data), alpn_len);
+ std::string alpn(reinterpret_cast<const char*>(alpn_data), alpn_len);
if (alpn == "h2") {
h2_selected_ = true;
}
QUICHE_DVLOG(1) << "ALPN selected: "
- << std::string(reinterpret_cast<const char *>(alpn_data),
+ << std::string(reinterpret_cast<const char*>(alpn_data),
alpn_len);
} else {
QUICHE_DVLOG(1) << "No ALPN selected";
@@ -489,8 +489,8 @@
}
static constexpr size_t kBioBufferSize = 16384;
- QuicEventLoop *event_loop_; // Not owned.
- SSL_CTX *ctx_; // Not owned.
+ QuicEventLoop* event_loop_; // Not owned.
+ SSL_CTX* ctx_; // Not owned.
std::unique_ptr<EventLoopSocketFactory> socket_factory_;
QuicUrl url_;
bool disable_certificate_verification_;
@@ -498,7 +498,7 @@
std::unique_ptr<ProofVerifier> proof_verifier_;
QuicSocketAddress socket_address_;
std::unique_ptr<ConnectingClientSocket> socket_;
- BIO *transport_io_ = nullptr;
+ BIO* transport_io_ = nullptr;
bssl::UniquePtr<SSL> ssl_;
bool tls_connected_ = false;
bool h2_selected_ = false;
@@ -508,8 +508,8 @@
std::unique_ptr<MasqueH2Connection> h2_connection_;
};
-int RunMasqueTcpClient(int argc, char *argv[]) {
- const char *usage = "Usage: masque_tcp_client <url>";
+int RunMasqueTcpClient(int argc, char* argv[]) {
+ const char* usage = "Usage: masque_tcp_client <url>";
std::vector<std::string> urls =
quiche::QuicheParseCommandLineFlags(usage, argc, argv);
if (urls.size() != 1) {
@@ -570,6 +570,6 @@
} // namespace quic
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
return quic::RunMasqueTcpClient(argc, argv);
}
diff --git a/quiche/quic/masque/masque_tcp_server_bin.cc b/quiche/quic/masque/masque_tcp_server_bin.cc
index db52903..1f33213 100644
--- a/quiche/quic/masque/masque_tcp_server_bin.cc
+++ b/quiche/quic/masque/masque_tcp_server_bin.cc
@@ -79,7 +79,7 @@
public:
MasqueOhttpGateway() {}
- bool Setup(const std::string &ohttp_key) {
+ bool Setup(const std::string& ohttp_key) {
hpke_key_.reset(EVP_HPKE_KEY_new());
if (!ohttp_key.empty()) {
if (!absl::HexStringToBytes(ohttp_key, &hpke_private_key_)) {
@@ -88,7 +88,7 @@
}
if (EVP_HPKE_KEY_init(
hpke_key_.get(), kem_,
- reinterpret_cast<const uint8_t *>(hpke_private_key_.data()),
+ reinterpret_cast<const uint8_t*>(hpke_private_key_.data()),
hpke_private_key_.size()) != 1) {
QUICHE_LOG(ERROR) << "Failed to ingest HPKE key";
return false;
@@ -102,7 +102,7 @@
hpke_private_key_ = std::string(private_key_len, '0');
if (EVP_HPKE_KEY_private_key(
hpke_key_.get(),
- reinterpret_cast<uint8_t *>(hpke_private_key_.data()),
+ reinterpret_cast<uint8_t*>(hpke_private_key_.data()),
&private_key_len, private_key_len) != 1 ||
private_key_len != hpke_private_key_.size()) {
QUICHE_LOG(ERROR) << "Failed to extract new HPKE private key";
@@ -115,7 +115,7 @@
hpke_public_key_ = std::string(public_key_len, '0');
if (EVP_HPKE_KEY_public_key(
hpke_key_.get(),
- reinterpret_cast<uint8_t *>(hpke_public_key_.data()),
+ reinterpret_cast<uint8_t*>(hpke_public_key_.data()),
&public_key_len, public_key_len) != 1 ||
public_key_len != hpke_public_key_.size()) {
QUICHE_LOG(ERROR) << "Failed to extract new HPKE public key";
@@ -165,8 +165,8 @@
return true;
}
- bool HandleRequest(MasqueH2Connection *connection, int32_t stream_id,
- const std::string &encapsulated_request) {
+ bool HandleRequest(MasqueH2Connection* connection, int32_t stream_id,
+ const std::string& encapsulated_request) {
if (!ohttp_gateway_.has_value()) {
QUICHE_LOG(ERROR) << "Not ready to handle OHTTP request";
return false;
@@ -185,7 +185,7 @@
<< binary_request.status();
return false;
}
- const BinaryHttpRequest::ControlData &control_data =
+ const BinaryHttpRequest::ControlData& control_data =
binary_request->control_data();
// TODO(dschinazi): Send the decapsulated request to the authority instead
// of replying with a fake local response.
@@ -230,15 +230,15 @@
private:
std::string hpke_private_key_;
std::string hpke_public_key_;
- const EVP_HPKE_KEM *kem_ = EVP_hpke_x25519_hkdf_sha256();
+ const EVP_HPKE_KEM* kem_ = EVP_hpke_x25519_hkdf_sha256();
bssl::UniquePtr<EVP_HPKE_KEY> hpke_key_;
std::string concatenated_keys_;
std::optional<ObliviousHttpGateway> ohttp_gateway_;
};
-static int SelectAlpnCallback(SSL * /*ssl*/, const uint8_t **out,
- uint8_t *out_len, const uint8_t *in,
- unsigned in_len, void * /*arg*/) {
+static int SelectAlpnCallback(SSL* /*ssl*/, const uint8_t** out,
+ uint8_t* out_len, const uint8_t* in,
+ unsigned in_len, void* /*arg*/) {
unsigned i = 0;
while (i < in_len) {
uint8_t alpn_length = in[i];
@@ -262,9 +262,9 @@
class MasqueH2SocketConnection : public QuicSocketEventListener {
public:
explicit MasqueH2SocketConnection(SocketFd connected_socket,
- QuicEventLoop *event_loop, SSL_CTX *ctx,
+ QuicEventLoop* event_loop, SSL_CTX* ctx,
bool is_server,
- MasqueH2Connection::Visitor *visitor)
+ MasqueH2Connection::Visitor* visitor)
: socket_(connected_socket),
event_loop_(event_loop),
connection_(CreateSsl(ctx), is_server, visitor) {
@@ -290,7 +290,7 @@
}
// From QuicSocketEventListener.
- void OnSocketEvent(QuicEventLoop * /*event_loop*/, SocketFd fd,
+ void OnSocketEvent(QuicEventLoop* /*event_loop*/, SocketFd fd,
QuicSocketEventMask events) {
if (fd != socket_ || ((events & kSocketEventReadable) == 0)) {
return;
@@ -298,13 +298,13 @@
connection_.OnTransportReadable();
}
- MasqueH2Connection *connection() { return &connection_; }
+ MasqueH2Connection* connection() { return &connection_; }
private:
- SSL *CreateSsl(SSL_CTX *ctx) {
+ SSL* CreateSsl(SSL_CTX* ctx) {
ssl_.reset(SSL_new(ctx));
SSL_set_accept_state(ssl_.get());
- BIO *bio = BIO_new_socket(socket_, BIO_CLOSE);
+ BIO* bio = BIO_new_socket(socket_, BIO_CLOSE);
SSL_set_bio(ssl_.get(), bio, bio);
// `SSL_set_bio` causes `ssl_` to take ownership of `bio`.
return ssl_.get();
@@ -312,21 +312,21 @@
SocketFd socket_;
bssl::UniquePtr<SSL> ssl_;
- QuicEventLoop *event_loop_; // Unowned.
+ QuicEventLoop* event_loop_; // Unowned.
MasqueH2Connection connection_;
};
class MasqueTcpServer : public QuicSocketEventListener,
public MasqueH2Connection::Visitor {
public:
- explicit MasqueTcpServer(MasqueOhttpGateway *masque_ohttp_gateway)
+ explicit MasqueTcpServer(MasqueOhttpGateway* masque_ohttp_gateway)
: event_loop_(GetDefaultEventLoop()->Create(QuicDefaultClock::Get())),
masque_ohttp_gateway_(masque_ohttp_gateway) {}
- MasqueTcpServer(const MasqueTcpServer &) = delete;
- MasqueTcpServer(MasqueTcpServer &&) = delete;
- MasqueTcpServer &operator=(const MasqueTcpServer &) = delete;
- MasqueTcpServer &operator=(MasqueTcpServer &&) = delete;
+ MasqueTcpServer(const MasqueTcpServer&) = delete;
+ MasqueTcpServer(MasqueTcpServer&&) = delete;
+ MasqueTcpServer& operator=(const MasqueTcpServer&) = delete;
+ MasqueTcpServer& operator=(MasqueTcpServer&&) = delete;
~MasqueTcpServer() {
if (server_socket_ != kInvalidSocketFd) {
@@ -338,9 +338,9 @@
}
}
- bool SetupSslCtx(const std::string &certificate_file,
- const std::string &key_file,
- const std::string &client_root_ca_file) {
+ bool SetupSslCtx(const std::string& certificate_file,
+ const std::string& key_file,
+ const std::string& client_root_ca_file) {
ctx_.reset(SSL_CTX_new(TLS_method()));
if (!SSL_CTX_use_PrivateKey_file(ctx_.get(), key_file.c_str(),
@@ -354,7 +354,7 @@
return false;
}
if (!client_root_ca_file.empty()) {
- X509_STORE *store = SSL_CTX_get_cert_store(ctx_.get());
+ X509_STORE* store = SSL_CTX_get_cert_store(ctx_.get());
if (store == nullptr) {
QUICHE_LOG(ERROR) << "Failed to get certificate store";
return false;
@@ -396,7 +396,7 @@
const int enable = 1;
if (setsockopt(server_socket_, SOL_SOCKET, SO_REUSEADDR,
- (const char *)&enable, sizeof(enable)) < 0) {
+ (const char*)&enable, sizeof(enable)) < 0) {
QUICHE_LOG(ERROR) << "Failed to set SO_REUSEADDR on socket";
return false;
}
@@ -431,7 +431,7 @@
}
}
- void OnSocketEvent(QuicEventLoop * /*event_loop*/, SocketFd fd,
+ void OnSocketEvent(QuicEventLoop* /*event_loop*/, SocketFd fd,
QuicSocketEventMask events) override {
if (fd != server_socket_ || ((events & kSocketEventReadable) == 0)) {
return;
@@ -440,25 +440,25 @@
}
// From MasqueH2Connection::Visitor.
- void OnConnectionReady(MasqueH2Connection * /*connection*/) override {}
- void OnConnectionFinished(MasqueH2Connection *connection) override {
+ void OnConnectionReady(MasqueH2Connection* /*connection*/) override {}
+ void OnConnectionFinished(MasqueH2Connection* connection) override {
connections_.erase(
std::remove_if(connections_.begin(), connections_.end(),
- [connection](const auto &socket_connection) {
+ [connection](const auto& socket_connection) {
return socket_connection->connection() == connection;
}),
connections_.end());
}
- bool HandleOhttpRequest(MasqueH2Connection *connection, int32_t stream_id,
- const std::string &encapsulated_request) {
+ bool HandleOhttpRequest(MasqueH2Connection* connection, int32_t stream_id,
+ const std::string& encapsulated_request) {
return masque_ohttp_gateway_->HandleRequest(connection, stream_id,
encapsulated_request);
}
- void OnRequest(MasqueH2Connection *connection, int32_t stream_id,
- const quiche::HttpHeaderBlock &headers,
- const std::string &body) override {
+ void OnRequest(MasqueH2Connection* connection, int32_t stream_id,
+ const quiche::HttpHeaderBlock& headers,
+ const std::string& body) override {
quiche::HttpHeaderBlock response_headers;
std::string response_body;
auto path_pair = headers.find(":path");
@@ -494,9 +494,9 @@
connection->SendResponse(stream_id, response_headers, response_body);
}
- void OnResponse(MasqueH2Connection * /*connection*/, int32_t /*stream_id*/,
- const quiche::HttpHeaderBlock & /*headers*/,
- const std::string & /*body*/) override {
+ void OnResponse(MasqueH2Connection* /*connection*/, int32_t /*stream_id*/,
+ const quiche::HttpHeaderBlock& /*headers*/,
+ const std::string& /*body*/) override {
QUICHE_LOG(FATAL) << "Server cannot receive responses";
}
@@ -528,13 +528,13 @@
std::unique_ptr<QuicEventLoop> event_loop_;
bssl::UniquePtr<SSL_CTX> ctx_;
- MasqueOhttpGateway *masque_ohttp_gateway_; // Unowned.
+ MasqueOhttpGateway* masque_ohttp_gateway_; // Unowned.
SocketFd server_socket_ = kInvalidSocketFd;
std::vector<std::unique_ptr<MasqueH2SocketConnection>> connections_;
};
-int RunMasqueTcpServer(int argc, char *argv[]) {
- const char *usage = "Usage: masque_server [options]";
+int RunMasqueTcpServer(int argc, char* argv[]) {
+ const char* usage = "Usage: masque_server [options]";
std::vector<std::string> non_option_args =
quiche::QuicheParseCommandLineFlags(usage, argc, argv);
if (!non_option_args.empty()) {
@@ -582,6 +582,6 @@
} // namespace
} // namespace quic
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
return quic::RunMasqueTcpServer(argc, argv);
}
