diff --git a/p2p/base/connection.cc b/p2p/base/connection.cc index 38a186da98..67e1a5ea29 100644 --- a/p2p/base/connection.cc +++ b/p2p/base/connection.cc @@ -168,54 +168,54 @@ ConnectionRequest::ConnectionRequest(StunRequestManager& manager, : StunRequest(manager, std::make_unique()), 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(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( + message->AddAttribute(std::make_unique( STUN_ATTR_RETRANSMIT_COUNT, static_cast(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( + message->AddAttribute(std::make_unique( 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( + message->AddAttribute(std::make_unique( 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( + message->AddAttribute(std::make_unique( 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(STUN_ATTR_USE_CANDIDATE)); } if (connection_->nomination_ && connection_->nomination_ != connection_->acked_nomination()) { - request->AddAttribute(std::make_unique( + message->AddAttribute(std::make_unique( STUN_ATTR_NOMINATION, connection_->nomination_)); } } else if (connection_->port()->GetIceRole() == ICEROLE_CONTROLLED) { - request->AddAttribute(std::make_unique( + message->AddAttribute(std::make_unique( 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( + message->AddAttribute(std::make_unique( 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()); diff --git a/p2p/base/connection.h b/p2p/base/connection.h index d871bc4ceb..c60616069d 100644 --- a/p2p/base/connection.h +++ b/p2p/base/connection.h @@ -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. diff --git a/p2p/base/port.cc b/p2p/base/port.cc index 74db59de9d..4a7daaffec 100644 --- a/p2p/base/port.cc +++ b/p2p/base/port.cc @@ -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& 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); diff --git a/p2p/base/port.h b/p2p/base/port.h index 56f551d7be..b2aa9b243f 100644 --- a/p2p/base/port.h +++ b/p2p/base/port.h @@ -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& unknown_types); diff --git a/p2p/base/port_interface.h b/p2p/base/port_interface.h index 02fd97993a..babe27d85d 100644 --- a/p2p/base/port_interface.h +++ b/p2p/base/port_interface.h @@ -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; diff --git a/p2p/base/stun_port.cc b/p2p/base/stun_port.cc index 5d7c426d45..6d16b9cf33 100644 --- a/p2p/base/stun_port.cc +++ b/p2p/base/stun_port.cc @@ -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 { diff --git a/p2p/base/stun_request.cc b/p2p/base/stun_request.cc index 0131779755..eebdd07716 100644 --- a/p2p/base/stun_request.cc +++ b/p2p/base/stun_request.cc @@ -191,9 +191,9 @@ StunRequest::StunRequest(StunRequestManager& manager) } StunRequest::StunRequest(StunRequestManager& manager, - std::unique_ptr request) + std::unique_ptr message) : manager_(manager), - msg_(std::move(request)), + msg_(std::move(message)), tstamp_(0), count_(0), timeout_(false) { diff --git a/p2p/base/stun_request.h b/p2p/base/stun_request.h index e75804d4b9..f4d6b2b0a8 100644 --- a/p2p/base/stun_request.h +++ b/p2p/base/stun_request.h @@ -86,7 +86,7 @@ class StunRequest : public rtc::MessageHandler { public: explicit StunRequest(StunRequestManager& manager); StunRequest(StunRequestManager& manager, - std::unique_ptr request); + std::unique_ptr 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) {} diff --git a/p2p/base/stun_request_unittest.cc b/p2p/base/stun_request_unittest.cc index b551c342c1..125bb47963 100644 --- a/p2p/base/stun_request_unittest.cc +++ b/p2p/base/stun_request_unittest.cc @@ -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_; diff --git a/p2p/base/stun_server.cc b/p2p/base/stun_server.cc index 382b787951..25f0634b05 100644 --- a/p2p/base/stun_server.cc +++ b/p2p/base/stun_server.cc @@ -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 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); diff --git a/p2p/base/stun_server.h b/p2p/base/stun_server.h index f2126db191..54d8d9083c 100644 --- a/p2p/base/stun_server.h +++ b/p2p/base/stun_server.h @@ -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; diff --git a/p2p/base/turn_port.cc b/p2p/base/turn_port.cc index 8729a8277e..e15f35211b 100644 --- a/p2p/base/turn_port.cc +++ b/p2p/base/turn_port.cc @@ -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()), 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(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( + message->SetType(TURN_CREATE_PERMISSION_REQUEST); + message->AddAttribute(std::make_unique( STUN_ATTR_XOR_PEER_ADDRESS, ext_addr_)); if (port_->field_trials_ && port_->field_trials_->IsEnabled("WebRTC-TurnAddMultiMapping")) { - request->AddAttribute(std::make_unique( + message->AddAttribute(std::make_unique( 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( + message->SetType(TURN_CHANNEL_BIND_REQUEST); + message->AddAttribute(std::make_unique( STUN_ATTR_CHANNEL_NUMBER, channel_id_ << 16)); - request->AddAttribute(std::make_unique( + message->AddAttribute(std::make_unique( STUN_ATTR_XOR_PEER_ADDRESS, ext_addr_)); - port_->AddRequestAuthInfo(request); - port_->TurnCustomizerMaybeModifyOutgoingStunMessage(request); + port_->AddRequestAuthInfo(message); + port_->TurnCustomizerMaybeModifyOutgoingStunMessage(message); } void TurnChannelBindRequest::OnSent() {