admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename variables of type StunMessage* from request to message.

Browse Source 
This is just to reduce confusion since StunMessage and StunRequest
instances are frequently used together and message objects are often
configured from within request objects (which makes the name confusing).

Bug: none
Change-Id: I8bf5e774a5149239dd3023817614d411633bf583
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/258484
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Auto-Submit: Tomas Gunnarsson <tommi@webrtc.org>
Commit-Queue: Tomas Gunnarsson <tommi@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36533}
This commit is contained in:
Tommi 2022-04-12 14:03:40 +02:00 committed by WebRTC LUCI CQ
parent 2545257982
commit 278b19da38
12 changed files with 90 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
p2p/base/connection.cc
View File

@ -168,54 +168,54 @@ ConnectionRequest::ConnectionRequest(StunRequestManager& manager,
: StunRequest(manager, std::make_unique<IceMessage>()),
connection_(connection) {}
void ConnectionRequest::Prepare(StunMessage* request) {
void ConnectionRequest::Prepare(StunMessage* message) {
RTC_DCHECK_RUN_ON(connection_->network_thread_);
request->SetType(STUN_BINDING_REQUEST);
message->SetType(STUN_BINDING_REQUEST);
std::string username;
connection_->port()->CreateStunUsername(
connection_->remote_candidate().username(), &username);
// Note that the order of attributes does not impact the parsing on the
// receiver side. The attribute is retrieved then by iterating and matching
// over all parsed attributes. See StunMessage::GetAttribute.
request->AddAttribute(
message->AddAttribute(
std::make_unique<StunByteStringAttribute>(STUN_ATTR_USERNAME, username));
// connection_ already holds this ping, so subtract one from count.
if (connection_->port()->send_retransmit_count_attribute()) {
request->AddAttribute(std::make_unique<StunUInt32Attribute>(
message->AddAttribute(std::make_unique<StunUInt32Attribute>(
STUN_ATTR_RETRANSMIT_COUNT,
static_cast<uint32_t>(connection_->pings_since_last_response_.size() -
1)));
}
uint32_t network_info = connection_->port()->Network()->id();
network_info = (network_info << 16) | connection_->port()->network_cost();
request->AddAttribute(std::make_unique<StunUInt32Attribute>(
message->AddAttribute(std::make_unique<StunUInt32Attribute>(
STUN_ATTR_GOOG_NETWORK_INFO, network_info));
if (connection_->field_trials_->piggyback_ice_check_acknowledgement &&
connection_->last_ping_id_received()) {
request->AddAttribute(std::make_unique<StunByteStringAttribute>(
message->AddAttribute(std::make_unique<StunByteStringAttribute>(
STUN_ATTR_GOOG_LAST_ICE_CHECK_RECEIVED,
connection_->last_ping_id_received().value()));
}
// Adding ICE_CONTROLLED or ICE_CONTROLLING attribute based on the role.
if (connection_->port()->GetIceRole() == ICEROLE_CONTROLLING) {
request->AddAttribute(std::make_unique<StunUInt64Attribute>(
message->AddAttribute(std::make_unique<StunUInt64Attribute>(
STUN_ATTR_ICE_CONTROLLING, connection_->port()->IceTiebreaker()));
// We should have either USE_CANDIDATE attribute or ICE_NOMINATION
// attribute but not both. That was enforced in p2ptransportchannel.
if (connection_->use_candidate_attr()) {
request->AddAttribute(
message->AddAttribute(
std::make_unique<StunByteStringAttribute>(STUN_ATTR_USE_CANDIDATE));
}
if (connection_->nomination_ &&
connection_->nomination_ != connection_->acked_nomination()) {
request->AddAttribute(std::make_unique<StunUInt32Attribute>(
message->AddAttribute(std::make_unique<StunUInt32Attribute>(
STUN_ATTR_NOMINATION, connection_->nomination_));
}
} else if (connection_->port()->GetIceRole() == ICEROLE_CONTROLLED) {
request->AddAttribute(std::make_unique<StunUInt64Attribute>(
message->AddAttribute(std::make_unique<StunUInt64Attribute>(
STUN_ATTR_ICE_CONTROLLED, connection_->port()->IceTiebreaker()));
} else {
RTC_DCHECK_NOTREACHED();
@ -234,7 +234,7 @@ void ConnectionRequest::Prepare(StunMessage* request) {
uint32_t prflx_priority =
type_preference << 24 |
(connection_->local_candidate().priority() & 0x00FFFFFF);
request->AddAttribute(std::make_unique<StunUInt32Attribute>(
message->AddAttribute(std::make_unique<StunUInt32Attribute>(
STUN_ATTR_PRIORITY, prflx_priority));
if (connection_->field_trials_->enable_goog_ping &&
@ -245,16 +245,16 @@ void ConnectionRequest::Prepare(StunMessage* request) {
auto list =
StunAttribute::CreateUInt16ListAttribute(STUN_ATTR_GOOG_MISC_INFO);
list->AddTypeAtIndex(kSupportGoogPingVersionRequestIndex, kGoogPingVersion);
request->AddAttribute(std::move(list));
message->AddAttribute(std::move(list));
}
if (connection_->ShouldSendGoogPing(request)) {
request->SetType(GOOG_PING_REQUEST);
request->ClearAttributes();
request->AddMessageIntegrity32(connection_->remote_candidate().password());
if (connection_->ShouldSendGoogPing(message)) {
message->SetType(GOOG_PING_REQUEST);
message->ClearAttributes();
message->AddMessageIntegrity32(connection_->remote_candidate().password());
} else {
request->AddMessageIntegrity(connection_->remote_candidate().password());
request->AddFingerprint();
message->AddMessageIntegrity(connection_->remote_candidate().password());
message->AddFingerprint();
}
}
@ -576,7 +576,7 @@ void Connection::OnReadPacket(const char* data,
if (msg->IntegrityOk()) {
requests_.CheckResponse(msg.get());
}
// Otherwise silently discard the response message.
// Otherwise silently discard the response.
break;
// Remote end point sent an STUN indication instead of regular binding
@ -699,25 +699,25 @@ void Connection::HandleStunBindingOrGoogPingRequest(IceMessage* msg) {
}
}
void Connection::SendStunBindingResponse(const StunMessage* request) {
void Connection::SendStunBindingResponse(const StunMessage* message) {
RTC_DCHECK_RUN_ON(network_thread_);
RTC_DCHECK(request->type() == STUN_BINDING_REQUEST);
RTC_DCHECK_EQ(message->type(), STUN_BINDING_REQUEST);
// Retrieve the username from the request.
// Retrieve the username from the `message`.
const StunByteStringAttribute* username_attr =
request->GetByteString(STUN_ATTR_USERNAME);
message->GetByteString(STUN_ATTR_USERNAME);
RTC_DCHECK(username_attr != NULL);
if (username_attr == NULL) {
// No valid username, skip the response.
return;
}
// Fill in the response message.
// Fill in the response.
StunMessage response;
response.SetType(STUN_BINDING_RESPONSE);
response.SetTransactionID(request->transaction_id());
response.SetTransactionID(message->transaction_id());
const StunUInt32Attribute* retransmit_attr =
request->GetUInt32(STUN_ATTR_RETRANSMIT_COUNT);
message->GetUInt32(STUN_ATTR_RETRANSMIT_COUNT);
if (retransmit_attr) {
// Inherit the incoming retransmit value in the response so the other side
// can see our view of lost pings.
@ -736,8 +736,8 @@ void Connection::SendStunBindingResponse(const StunMessage* request) {
STUN_ATTR_XOR_MAPPED_ADDRESS, remote_candidate_.address()));
if (field_trials_->announce_goog_ping) {
// Check if request contains a announce-request.
auto goog_misc = request->GetUInt16List(STUN_ATTR_GOOG_MISC_INFO);
// Check if message contains a announce-request.
auto goog_misc = message->GetUInt16List(STUN_ATTR_GOOG_MISC_INFO);
if (goog_misc != nullptr &&
goog_misc->Size() >= kSupportGoogPingVersionRequestIndex &&
// Which version can we handle...currently any >= 1
@ -756,14 +756,14 @@ void Connection::SendStunBindingResponse(const StunMessage* request) {
SendResponseMessage(response);
}
void Connection::SendGoogPingResponse(const StunMessage* request) {
void Connection::SendGoogPingResponse(const StunMessage* message) {
RTC_DCHECK_RUN_ON(network_thread_);
RTC_DCHECK(request->type() == GOOG_PING_REQUEST);
RTC_DCHECK(message->type() == GOOG_PING_REQUEST);
// Fill in the response message.
// Fill in the response.
StunMessage response;
response.SetType(GOOG_PING_RESPONSE);
response.SetTransactionID(request->transaction_id());
response.SetTransactionID(message->transaction_id());
response.AddMessageIntegrity32(local_candidate().password());
SendResponseMessage(response);
}
@ -773,7 +773,7 @@ void Connection::SendResponseMessage(const StunMessage& response) {
// Where I send the response.
const rtc::SocketAddress& addr = remote_candidate_.address();
// Send the response message.
// Send the response.
rtc::ByteBufferWriter buf;
response.Write(&buf);
rtc::PacketOptions options(port_->StunDscpValue());

6
p2p/base/connection.h
View File

@ -58,7 +58,7 @@ struct CandidatePair final : public CandidatePairInterface {
class ConnectionRequest : public StunRequest {
public:
ConnectionRequest(StunRequestManager& manager, Connection* connection);
void Prepare(StunMessage* request) override;
void Prepare(StunMessage* message) override;
void OnResponse(StunMessage* response) override;
void OnErrorResponse(StunMessage* response) override;
void OnTimeout() override;
@ -306,8 +306,8 @@ class Connection : public CandidatePairInterface, public sigslot::has_slots<> {
// Does not trigger SignalStateChange
void ForgetLearnedState();
void SendStunBindingResponse(const StunMessage* request);
void SendGoogPingResponse(const StunMessage* request);
void SendStunBindingResponse(const StunMessage* message);
void SendGoogPingResponse(const StunMessage* message);
void SendResponseMessage(const StunMessage& response);
// An accessor for unit tests.

22
p2p/base/port.cc
View File

@ -739,21 +739,21 @@ bool Port::CanHandleIncomingPacketsFrom(const rtc::SocketAddress&) const {
return false;
}
void Port::SendBindingErrorResponse(StunMessage* request,
void Port::SendBindingErrorResponse(StunMessage* message,
const rtc::SocketAddress& addr,
int error_code,
const std::string& reason) {
RTC_DCHECK(request->type() == STUN_BINDING_REQUEST ||
request->type() == GOOG_PING_REQUEST);
RTC_DCHECK(message->type() == STUN_BINDING_REQUEST ||
message->type() == GOOG_PING_REQUEST);
// Fill in the response message.
StunMessage response;
if (request->type() == STUN_BINDING_REQUEST) {
if (message->type() == STUN_BINDING_REQUEST) {
response.SetType(STUN_BINDING_ERROR_RESPONSE);
} else {
response.SetType(GOOG_PING_ERROR_RESPONSE);
}
response.SetTransactionID(request->transaction_id());
response.SetTransactionID(message->transaction_id());
// When doing GICE, we need to write out the error code incorrectly to
// maintain backwards compatiblility.
@ -766,15 +766,15 @@ void Port::SendBindingErrorResponse(StunMessage* request,
// because we don't have enough information to determine the shared secret.
if (error_code != STUN_ERROR_BAD_REQUEST &&
error_code != STUN_ERROR_UNAUTHORIZED &&
request->type() != GOOG_PING_REQUEST) {
if (request->type() == STUN_BINDING_REQUEST) {
message->type() != GOOG_PING_REQUEST) {
if (message->type() == STUN_BINDING_REQUEST) {
response.AddMessageIntegrity(password_);
} else {
response.AddMessageIntegrity32(password_);
}
}
if (request->type() == STUN_BINDING_REQUEST) {
if (message->type() == STUN_BINDING_REQUEST) {
response.AddFingerprint();
}
@ -792,15 +792,15 @@ void Port::SendBindingErrorResponse(StunMessage* request,
}
void Port::SendUnknownAttributesErrorResponse(
StunMessage* request,
StunMessage* message,
const rtc::SocketAddress& addr,
const std::vector<uint16_t>& unknown_types) {
RTC_DCHECK(request->type() == STUN_BINDING_REQUEST);
RTC_DCHECK(message->type() == STUN_BINDING_REQUEST);
// Fill in the response message.
StunMessage response;
response.SetType(STUN_BINDING_ERROR_RESPONSE);
response.SetTransactionID(request->transaction_id());
response.SetTransactionID(message->transaction_id());
auto error_attr = StunAttribute::CreateErrorCode();
error_attr->SetCode(STUN_ERROR_UNKNOWN_ATTRIBUTE);

4
p2p/base/port.h
View File

@ -312,12 +312,12 @@ class Port : public PortInterface,
const rtc::SocketAddress& remote_addr) const;
// Sends a response error to the given request.
void SendBindingErrorResponse(StunMessage* request,
void SendBindingErrorResponse(StunMessage* message,
const rtc::SocketAddress& addr,
int error_code,
const std::string& reason) override;
void SendUnknownAttributesErrorResponse(
StunMessage* request,
StunMessage* message,
const rtc::SocketAddress& addr,
const std::vector<uint16_t>& unknown_types);

2
p2p/base/port_interface.h
View File

@ -107,7 +107,7 @@ class PortInterface {
// Sends a response message (normal or error) to the given request. One of
// these methods should be called as a response to SignalUnknownAddress.
virtual void SendBindingErrorResponse(StunMessage* request,
virtual void SendBindingErrorResponse(StunMessage* message,
const rtc::SocketAddress& addr,
int error_code,
const std::string& reason) = 0;

4
p2p/base/stun_port.cc
View File

@ -47,8 +47,8 @@ class StunBindingRequest : public StunRequest {
const rtc::SocketAddress& server_addr() const { return server_addr_; }
void Prepare(StunMessage* request) override {
request->SetType(STUN_BINDING_REQUEST);
void Prepare(StunMessage* message) override {
message->SetType(STUN_BINDING_REQUEST);
}
void OnResponse(StunMessage* response) override {

4
p2p/base/stun_request.cc
View File

@ -191,9 +191,9 @@ StunRequest::StunRequest(StunRequestManager& manager)
}
StunRequest::StunRequest(StunRequestManager& manager,
std::unique_ptr<StunMessage> request)
std::unique_ptr<StunMessage> message)
: manager_(manager),
msg_(std::move(request)),
msg_(std::move(message)),
tstamp_(0),
count_(0),
timeout_(false) {

4
p2p/base/stun_request.h
View File

@ -86,7 +86,7 @@ class StunRequest : public rtc::MessageHandler {
public:
explicit StunRequest(StunRequestManager& manager);
StunRequest(StunRequestManager& manager,
std::unique_ptr<StunMessage> request);
std::unique_ptr<StunMessage> message);
~StunRequest() override;
// Causes our wrapped StunMessage to be Prepared
@ -117,7 +117,7 @@ class StunRequest : public rtc::MessageHandler {
// Fills in a request object to be sent. Note that request's transaction ID
// will already be set and cannot be changed.
virtual void Prepare(StunMessage* request) {}
virtual void Prepare(StunMessage* message) {}
// Called when the message receives a response or times out.
virtual void OnResponse(StunMessage* response) {}

4
p2p/base/stun_request_unittest.cc
View File

@ -99,8 +99,8 @@ class StunRequestThunker : public StunRequest {
}
virtual void OnTimeout() { test_->OnTimeout(); }
virtual void Prepare(StunMessage* request) {
request->SetType(STUN_BINDING_REQUEST);
virtual void Prepare(StunMessage* message) {
message->SetType(STUN_BINDING_REQUEST);
}
StunRequestTest* test_;

8
p2p/base/stun_server.cc
View File

@ -83,15 +83,15 @@ void StunServer::SendResponse(const StunMessage& msg,
RTC_LOG_ERR(LS_ERROR) << "sendto";
}
void StunServer::GetStunBindResponse(StunMessage* request,
void StunServer::GetStunBindResponse(StunMessage* message,
const rtc::SocketAddress& remote_addr,
StunMessage* response) const {
response->SetType(STUN_BINDING_RESPONSE);
response->SetTransactionID(request->transaction_id());
response->SetTransactionID(message->transaction_id());
// Tell the user the address that we received their request from.
// Tell the user the address that we received their message from.
std::unique_ptr<StunAddressAttribute> mapped_addr;
if (request->IsLegacy()) {
if (message->IsLegacy()) {
mapped_addr = StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
} else {
mapped_addr = StunAttribute::CreateXorAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);

2
p2p/base/stun_server.h
View File

@ -58,7 +58,7 @@ class StunServer : public sigslot::has_slots<> {
void SendResponse(const StunMessage& msg, const rtc::SocketAddress& addr);
// A helper method to compose a STUN binding response.
void GetStunBindResponse(StunMessage* request,
void GetStunBindResponse(StunMessage* message,
const rtc::SocketAddress& remote_addr,
StunMessage* response) const;

54
p2p/base/turn_port.cc
View File

@ -73,7 +73,7 @@ static int GetRelayPreference(cricket::ProtocolType proto) {
class TurnAllocateRequest : public StunRequest {
public:
explicit TurnAllocateRequest(TurnPort* port);
void Prepare(StunMessage* request) override;
void Prepare(StunMessage* message) override;
void OnSent() override;
void OnResponse(StunMessage* response) override;
void OnErrorResponse(StunMessage* response) override;
@ -91,7 +91,7 @@ class TurnAllocateRequest : public StunRequest {
class TurnRefreshRequest : public StunRequest {
public:
explicit TurnRefreshRequest(TurnPort* port);
void Prepare(StunMessage* request) override;
void Prepare(StunMessage* message) override;
void OnSent() override;
void OnResponse(StunMessage* response) override;
void OnErrorResponse(StunMessage* response) override;
@ -110,7 +110,7 @@ class TurnCreatePermissionRequest : public StunRequest,
TurnEntry* entry,
const rtc::SocketAddress& ext_addr,
const std::string& remote_ufrag);
void Prepare(StunMessage* request) override;
void Prepare(StunMessage* message) override;
void OnSent() override;
void OnResponse(StunMessage* response) override;
void OnErrorResponse(StunMessage* response) override;
@ -131,7 +131,7 @@ class TurnChannelBindRequest : public StunRequest, public sigslot::has_slots<> {
TurnEntry* entry,
int channel_id,
const rtc::SocketAddress& ext_addr);
void Prepare(StunMessage* request) override;
void Prepare(StunMessage* message) override;
void OnSent() override;
void OnResponse(StunMessage* response) override;
void OnErrorResponse(StunMessage* response) override;
@ -1364,18 +1364,18 @@ TurnAllocateRequest::TurnAllocateRequest(TurnPort* port)
: StunRequest(port->request_manager(), std::make_unique<TurnMessage>()),
port_(port) {}
void TurnAllocateRequest::Prepare(StunMessage* request) {
void TurnAllocateRequest::Prepare(StunMessage* message) {
// Create the request as indicated in RFC 5766, Section 6.1.
request->SetType(TURN_ALLOCATE_REQUEST);
message->SetType(TURN_ALLOCATE_REQUEST);
auto transport_attr =
StunAttribute::CreateUInt32(STUN_ATTR_REQUESTED_TRANSPORT);
transport_attr->SetValue(IPPROTO_UDP << 24);
request->AddAttribute(std::move(transport_attr));
message->AddAttribute(std::move(transport_attr));
if (!port_->hash().empty()) {
port_->AddRequestAuthInfo(request);
port_->AddRequestAuthInfo(message);
}
port_->MaybeAddTurnLoggingId(request);
port_->TurnCustomizerMaybeModifyOutgoingStunMessage(request);
port_->MaybeAddTurnLoggingId(message);
port_->TurnCustomizerMaybeModifyOutgoingStunMessage(message);
}
void TurnAllocateRequest::OnSent() {
@ -1554,17 +1554,17 @@ TurnRefreshRequest::TurnRefreshRequest(TurnPort* port)
port_(port),
lifetime_(-1) {}
void TurnRefreshRequest::Prepare(StunMessage* request) {
void TurnRefreshRequest::Prepare(StunMessage* message) {
// Create the request as indicated in RFC 5766, Section 7.1.
// No attributes need to be included.
request->SetType(TURN_REFRESH_REQUEST);
message->SetType(TURN_REFRESH_REQUEST);
if (lifetime_ > -1) {
request->AddAttribute(
message->AddAttribute(
std::make_unique<StunUInt32Attribute>(STUN_ATTR_LIFETIME, lifetime_));
}
port_->AddRequestAuthInfo(request);
port_->TurnCustomizerMaybeModifyOutgoingStunMessage(request);
port_->AddRequestAuthInfo(message);
port_->TurnCustomizerMaybeModifyOutgoingStunMessage(message);
}
void TurnRefreshRequest::OnSent() {
@ -1642,18 +1642,18 @@ TurnCreatePermissionRequest::TurnCreatePermissionRequest(
this, &TurnCreatePermissionRequest::OnEntryDestroyed);
}
void TurnCreatePermissionRequest::Prepare(StunMessage* request) {
void TurnCreatePermissionRequest::Prepare(StunMessage* message) {
// Create the request as indicated in RFC5766, Section 9.1.
request->SetType(TURN_CREATE_PERMISSION_REQUEST);
request->AddAttribute(std::make_unique<StunXorAddressAttribute>(
message->SetType(TURN_CREATE_PERMISSION_REQUEST);
message->AddAttribute(std::make_unique<StunXorAddressAttribute>(
STUN_ATTR_XOR_PEER_ADDRESS, ext_addr_));
if (port_->field_trials_ &&
port_->field_trials_->IsEnabled("WebRTC-TurnAddMultiMapping")) {
request->AddAttribute(std::make_unique<cricket::StunByteStringAttribute>(
message->AddAttribute(std::make_unique<cricket::StunByteStringAttribute>(
STUN_ATTR_MULTI_MAPPING, remote_ufrag_));
}
port_->AddRequestAuthInfo(request);
port_->TurnCustomizerMaybeModifyOutgoingStunMessage(request);
port_->AddRequestAuthInfo(message);
port_->TurnCustomizerMaybeModifyOutgoingStunMessage(message);
}
void TurnCreatePermissionRequest::OnSent() {
@ -1715,15 +1715,15 @@ TurnChannelBindRequest::TurnChannelBindRequest(
&TurnChannelBindRequest::OnEntryDestroyed);
}
void TurnChannelBindRequest::Prepare(StunMessage* request) {
void TurnChannelBindRequest::Prepare(StunMessage* message) {
// Create the request as indicated in RFC5766, Section 11.1.
request->SetType(TURN_CHANNEL_BIND_REQUEST);
request->AddAttribute(std::make_unique<StunUInt32Attribute>(
message->SetType(TURN_CHANNEL_BIND_REQUEST);
message->AddAttribute(std::make_unique<StunUInt32Attribute>(
STUN_ATTR_CHANNEL_NUMBER, channel_id_ << 16));
request->AddAttribute(std::make_unique<StunXorAddressAttribute>(
message->AddAttribute(std::make_unique<StunXorAddressAttribute>(
STUN_ATTR_XOR_PEER_ADDRESS, ext_addr_));
port_->AddRequestAuthInfo(request);
port_->TurnCustomizerMaybeModifyOutgoingStunMessage(request);
port_->AddRequestAuthInfo(message);
port_->TurnCustomizerMaybeModifyOutgoingStunMessage(message);
}
void TurnChannelBindRequest::OnSent() {