mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-13 05:40:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Convert ByteBufferWriter to be type uint8_t

Browse source 
and make follow-on changes.

Bug: webrtc:15665
Change-Id: Ice646f88ba5a09d6a8d9ce70415d8a14d7050d3c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/329781
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#41393}
This commit is contained in:
Harald Alvestrand 2023-12-12 12:05:20 +00:00 committed by WebRTC LUCI CQ
parent c30fb63f95
commit f0ddae8c22
15 changed files with 107 additions and 73 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
api/transport/stun.cc
View file

@ -814,7 +814,7 @@ void StunAttribute::ConsumePadding(ByteBufferReader* buf) const {
void StunAttribute::WritePadding(ByteBufferWriter* buf) const { void StunAttribute::WritePadding(ByteBufferWriter* buf) const {
int remainder = length_ % 4; int remainder = length_ % 4;
if (remainder > 0) { if (remainder > 0) {
char zeroes[4] = {0}; uint8_t zeroes[4] = {0};
buf->WriteBytes(zeroes, 4 - remainder); buf->WriteBytes(zeroes, 4 - remainder);
} }
} }
@ -949,12 +949,12 @@ bool StunAddressAttribute::Write(ByteBufferWriter* buf) const {
switch (address_.family()) { switch (address_.family()) {
case AF_INET: { case AF_INET: {
in_addr v4addr = address_.ipaddr().ipv4_address(); in_addr v4addr = address_.ipaddr().ipv4_address();
buf->WriteBytes(reinterpret_cast<char*>(&v4addr), sizeof(v4addr)); buf->WriteBytes(reinterpret_cast<uint8_t*>(&v4addr), sizeof(v4addr));
break; break;
} }
case AF_INET6: { case AF_INET6: {
in6_addr v6addr = address_.ipaddr().ipv6_address(); in6_addr v6addr = address_.ipaddr().ipv6_address();
buf->WriteBytes(reinterpret_cast<char*>(&v6addr), sizeof(v6addr)); buf->WriteBytes(reinterpret_cast<uint8_t*>(&v6addr), sizeof(v6addr));
break; break;
} }
} }
@ -1039,12 +1039,14 @@ bool StunXorAddressAttribute::Write(ByteBufferWriter* buf) const {
switch (xored_ip.family()) { switch (xored_ip.family()) {
case AF_INET: { case AF_INET: {
in_addr v4addr = xored_ip.ipv4_address(); in_addr v4addr = xored_ip.ipv4_address();
buf->WriteBytes(reinterpret_cast<const char*>(&v4addr), sizeof(v4addr)); buf->WriteBytes(reinterpret_cast<const uint8_t*>(&v4addr),
sizeof(v4addr));
break; break;
} }
case AF_INET6: { case AF_INET6: {
in6_addr v6addr = xored_ip.ipv6_address(); in6_addr v6addr = xored_ip.ipv6_address();
buf->WriteBytes(reinterpret_cast<const char*>(&v6addr), sizeof(v6addr)); buf->WriteBytes(reinterpret_cast<const uint8_t*>(&v6addr),
sizeof(v6addr));
break; break;
} }
} }
@ -1170,7 +1172,7 @@ bool StunByteStringAttribute::Write(ByteBufferWriter* buf) const {
if (!LengthValid(type(), length())) { if (!LengthValid(type(), length())) {
return false; return false;
} }
buf->WriteBytes(reinterpret_cast<const char*>(bytes_), length()); buf->WriteBytes(bytes_, length());
WritePadding(buf); WritePadding(buf);
return true; return true;
} }

3
p2p/base/p2p_transport_channel_unittest.cc
View file

@ -3601,7 +3601,8 @@ class P2PTransportChannelPingTest : public ::testing::Test,
rtc::ByteBufferWriter buf; rtc::ByteBufferWriter buf;
msg.Write(&buf); msg.Write(&buf);
conn->OnReadPacket(rtc::ReceivedPacket::CreateFromLegacy( conn->OnReadPacket(rtc::ReceivedPacket::CreateFromLegacy(
buf.Data(), buf.Length(), rtc::TimeMicros())); reinterpret_cast<const char*>(buf.Data()), buf.Length(),
rtc::TimeMicros()));
} }
void ReceivePingOnConnection(Connection* conn, void ReceivePingOnConnection(Connection* conn,

87
p2p/base/port_unittest.cc
View file

@ -257,6 +257,15 @@ class TestPort : public Port {
int type_preference_ = 0; int type_preference_ = 0;
}; };
bool GetStunMessageFromBufferWriter(TestPort* port,
ByteBufferWriter* buf,
const rtc::SocketAddress& addr,
std::unique_ptr<IceMessage>* out_msg,
std::string* out_username) {
return port->GetStunMessage(reinterpret_cast<const char*>(buf->Data()),
buf->Length(), addr, out_msg, out_username);
}
static void SendPingAndReceiveResponse(Connection* lconn, static void SendPingAndReceiveResponse(Connection* lconn,
TestPort* lport, TestPort* lport,
Connection* rconn, Connection* rconn,
@ -1529,7 +1538,8 @@ TEST_F(PortTest, TestLoopbackCall) {
auto buf = std::make_unique<ByteBufferWriter>(); auto buf = std::make_unique<ByteBufferWriter>();
WriteStunMessage(*modified_req, buf.get()); WriteStunMessage(*modified_req, buf.get());
conn1->OnReadPacket(rtc::ReceivedPacket::CreateFromLegacy( conn1->OnReadPacket(rtc::ReceivedPacket::CreateFromLegacy(
buf->Data(), buf->Length(), /*packet_time_us=*/-1)); reinterpret_cast<const char*>(buf->Data()), buf->Length(),
/*packet_time_us=*/-1));
ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout); ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
msg = lport->last_stun_msg(); msg = lport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, msg->type()); EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, msg->type());
@ -2247,8 +2257,8 @@ TEST_F(PortTest, TestHandleStunMessage) {
in_msg->AddMessageIntegrity("rpass"); in_msg->AddMessageIntegrity("rpass");
in_msg->AddFingerprint(); in_msg->AddFingerprint();
WriteStunMessage(*in_msg, buf.get()); WriteStunMessage(*in_msg, buf.get());
EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg, EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
&username)); &out_msg, &username));
EXPECT_TRUE(out_msg.get() != NULL); EXPECT_TRUE(out_msg.get() != NULL);
EXPECT_EQ("lfrag", username); EXPECT_EQ("lfrag", username);
@ -2259,8 +2269,8 @@ TEST_F(PortTest, TestHandleStunMessage) {
in_msg->AddMessageIntegrity("rpass"); in_msg->AddMessageIntegrity("rpass");
in_msg->AddFingerprint(); in_msg->AddFingerprint();
WriteStunMessage(*in_msg, buf.get()); WriteStunMessage(*in_msg, buf.get());
EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg, EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
&username)); &out_msg, &username));
EXPECT_TRUE(out_msg.get() != NULL); EXPECT_TRUE(out_msg.get() != NULL);
EXPECT_EQ("", username); EXPECT_EQ("", username);
@ -2271,8 +2281,8 @@ TEST_F(PortTest, TestHandleStunMessage) {
STUN_ERROR_REASON_SERVER_ERROR)); STUN_ERROR_REASON_SERVER_ERROR));
in_msg->AddFingerprint(); in_msg->AddFingerprint();
WriteStunMessage(*in_msg, buf.get()); WriteStunMessage(*in_msg, buf.get());
EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg, EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
&username)); &out_msg, &username));
EXPECT_TRUE(out_msg.get() != NULL); EXPECT_TRUE(out_msg.get() != NULL);
EXPECT_EQ("", username); EXPECT_EQ("", username);
ASSERT_TRUE(out_msg->GetErrorCode() != NULL); ASSERT_TRUE(out_msg->GetErrorCode() != NULL);
@ -2295,8 +2305,8 @@ TEST_F(PortTest, TestHandleStunMessageBadUsername) {
in_msg->AddMessageIntegrity("rpass"); in_msg->AddMessageIntegrity("rpass");
in_msg->AddFingerprint(); in_msg->AddFingerprint();
WriteStunMessage(*in_msg, buf.get()); WriteStunMessage(*in_msg, buf.get());
EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg, EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
&username)); &out_msg, &username));
EXPECT_TRUE(out_msg.get() == NULL); EXPECT_TRUE(out_msg.get() == NULL);
EXPECT_EQ("", username); EXPECT_EQ("", username);
EXPECT_EQ(STUN_ERROR_BAD_REQUEST, port->last_stun_error_code()); EXPECT_EQ(STUN_ERROR_BAD_REQUEST, port->last_stun_error_code());
@ -2306,8 +2316,8 @@ TEST_F(PortTest, TestHandleStunMessageBadUsername) {
in_msg->AddMessageIntegrity("rpass"); in_msg->AddMessageIntegrity("rpass");
in_msg->AddFingerprint(); in_msg->AddFingerprint();
WriteStunMessage(*in_msg, buf.get()); WriteStunMessage(*in_msg, buf.get());
EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg, EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
&username)); &out_msg, &username));
EXPECT_TRUE(out_msg.get() == NULL); EXPECT_TRUE(out_msg.get() == NULL);
EXPECT_EQ("", username); EXPECT_EQ("", username);
EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code()); EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code());
@ -2317,8 +2327,8 @@ TEST_F(PortTest, TestHandleStunMessageBadUsername) {
in_msg->AddMessageIntegrity("rpass"); in_msg->AddMessageIntegrity("rpass");
in_msg->AddFingerprint(); in_msg->AddFingerprint();
WriteStunMessage(*in_msg, buf.get()); WriteStunMessage(*in_msg, buf.get());
EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg, EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
&username)); &out_msg, &username));
EXPECT_TRUE(out_msg.get() == NULL); EXPECT_TRUE(out_msg.get() == NULL);
EXPECT_EQ("", username); EXPECT_EQ("", username);
EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code()); EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code());
@ -2328,8 +2338,8 @@ TEST_F(PortTest, TestHandleStunMessageBadUsername) {
in_msg->AddMessageIntegrity("rpass"); in_msg->AddMessageIntegrity("rpass");
in_msg->AddFingerprint(); in_msg->AddFingerprint();
WriteStunMessage(*in_msg, buf.get()); WriteStunMessage(*in_msg, buf.get());
EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg, EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
&username)); &out_msg, &username));
EXPECT_TRUE(out_msg.get() == NULL); EXPECT_TRUE(out_msg.get() == NULL);
EXPECT_EQ("", username); EXPECT_EQ("", username);
EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code()); EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code());
@ -2339,8 +2349,8 @@ TEST_F(PortTest, TestHandleStunMessageBadUsername) {
in_msg->AddMessageIntegrity("rpass"); in_msg->AddMessageIntegrity("rpass");
in_msg->AddFingerprint(); in_msg->AddFingerprint();
WriteStunMessage(*in_msg, buf.get()); WriteStunMessage(*in_msg, buf.get());
EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg, EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
&username)); &out_msg, &username));
EXPECT_TRUE(out_msg.get() == NULL); EXPECT_TRUE(out_msg.get() == NULL);
EXPECT_EQ("", username); EXPECT_EQ("", username);
EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code()); EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code());
@ -2361,8 +2371,8 @@ TEST_F(PortTest, TestHandleStunMessageBadMessageIntegrity) {
in_msg = CreateStunMessageWithUsername(STUN_BINDING_REQUEST, "rfrag:lfrag"); in_msg = CreateStunMessageWithUsername(STUN_BINDING_REQUEST, "rfrag:lfrag");
in_msg->AddFingerprint(); in_msg->AddFingerprint();
WriteStunMessage(*in_msg, buf.get()); WriteStunMessage(*in_msg, buf.get());
EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg, EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
&username)); &out_msg, &username));
EXPECT_TRUE(out_msg.get() == NULL); EXPECT_TRUE(out_msg.get() == NULL);
EXPECT_EQ("", username); EXPECT_EQ("", username);
EXPECT_EQ(STUN_ERROR_BAD_REQUEST, port->last_stun_error_code()); EXPECT_EQ(STUN_ERROR_BAD_REQUEST, port->last_stun_error_code());
@ -2373,8 +2383,8 @@ TEST_F(PortTest, TestHandleStunMessageBadMessageIntegrity) {
in_msg->AddMessageIntegrity("invalid"); in_msg->AddMessageIntegrity("invalid");
in_msg->AddFingerprint(); in_msg->AddFingerprint();
WriteStunMessage(*in_msg, buf.get()); WriteStunMessage(*in_msg, buf.get());
EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg, EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
&username)); &out_msg, &username));
EXPECT_TRUE(out_msg.get() == NULL); EXPECT_TRUE(out_msg.get() == NULL);
EXPECT_EQ("", username); EXPECT_EQ("", username);
EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code()); EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code());
@ -2399,16 +2409,16 @@ TEST_F(PortTest, TestHandleStunMessageBadFingerprint) {
in_msg = CreateStunMessageWithUsername(STUN_BINDING_REQUEST, "rfrag:lfrag"); in_msg = CreateStunMessageWithUsername(STUN_BINDING_REQUEST, "rfrag:lfrag");
in_msg->AddMessageIntegrity("rpass"); in_msg->AddMessageIntegrity("rpass");
WriteStunMessage(*in_msg, buf.get()); WriteStunMessage(*in_msg, buf.get());
EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg, EXPECT_FALSE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
&username)); &out_msg, &username));
EXPECT_EQ(0, port->last_stun_error_code()); EXPECT_EQ(0, port->last_stun_error_code());
// Now, add a fingerprint, but munge the message so it's not valid. // Now, add a fingerprint, but munge the message so it's not valid.
in_msg->AddFingerprint(); in_msg->AddFingerprint();
in_msg->SetTransactionIdForTesting("TESTTESTBADD"); in_msg->SetTransactionIdForTesting("TESTTESTBADD");
WriteStunMessage(*in_msg, buf.get()); WriteStunMessage(*in_msg, buf.get());
EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg, EXPECT_FALSE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
&username)); &out_msg, &username));
EXPECT_EQ(0, port->last_stun_error_code()); EXPECT_EQ(0, port->last_stun_error_code());
// Valid BINDING-RESPONSE, except no FINGERPRINT. // Valid BINDING-RESPONSE, except no FINGERPRINT.
@ -2417,16 +2427,16 @@ TEST_F(PortTest, TestHandleStunMessageBadFingerprint) {
STUN_ATTR_XOR_MAPPED_ADDRESS, kLocalAddr2)); STUN_ATTR_XOR_MAPPED_ADDRESS, kLocalAddr2));
in_msg->AddMessageIntegrity("rpass"); in_msg->AddMessageIntegrity("rpass");
WriteStunMessage(*in_msg, buf.get()); WriteStunMessage(*in_msg, buf.get());
EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg, EXPECT_FALSE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
&username)); &out_msg, &username));
EXPECT_EQ(0, port->last_stun_error_code()); EXPECT_EQ(0, port->last_stun_error_code());
// Now, add a fingerprint, but munge the message so it's not valid. // Now, add a fingerprint, but munge the message so it's not valid.
in_msg->AddFingerprint(); in_msg->AddFingerprint();
in_msg->SetTransactionIdForTesting("TESTTESTBADD"); in_msg->SetTransactionIdForTesting("TESTTESTBADD");
WriteStunMessage(*in_msg, buf.get()); WriteStunMessage(*in_msg, buf.get());
EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg, EXPECT_FALSE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
&username)); &out_msg, &username));
EXPECT_EQ(0, port->last_stun_error_code()); EXPECT_EQ(0, port->last_stun_error_code());
// Valid BINDING-ERROR-RESPONSE, except no FINGERPRINT. // Valid BINDING-ERROR-RESPONSE, except no FINGERPRINT.
@ -2436,16 +2446,16 @@ TEST_F(PortTest, TestHandleStunMessageBadFingerprint) {
STUN_ERROR_REASON_SERVER_ERROR)); STUN_ERROR_REASON_SERVER_ERROR));
in_msg->AddMessageIntegrity("rpass"); in_msg->AddMessageIntegrity("rpass");
WriteStunMessage(*in_msg, buf.get()); WriteStunMessage(*in_msg, buf.get());
EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg, EXPECT_FALSE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
&username)); &out_msg, &username));
EXPECT_EQ(0, port->last_stun_error_code()); EXPECT_EQ(0, port->last_stun_error_code());
// Now, add a fingerprint, but munge the message so it's not valid. // Now, add a fingerprint, but munge the message so it's not valid.
in_msg->AddFingerprint(); in_msg->AddFingerprint();
in_msg->SetTransactionIdForTesting("TESTTESTBADD"); in_msg->SetTransactionIdForTesting("TESTTESTBADD");
WriteStunMessage(*in_msg, buf.get()); WriteStunMessage(*in_msg, buf.get());
EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg, EXPECT_FALSE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
&username)); &out_msg, &username));
EXPECT_EQ(0, port->last_stun_error_code()); EXPECT_EQ(0, port->last_stun_error_code());
} }
@ -2472,8 +2482,8 @@ TEST_F(PortTest,
in_msg->AddAttribute(StunAttribute::CreateUInt32(0xdead)); in_msg->AddAttribute(StunAttribute::CreateUInt32(0xdead));
in_msg->AddFingerprint(); in_msg->AddFingerprint();
WriteStunMessage(*in_msg, buf.get()); WriteStunMessage(*in_msg, buf.get());
ASSERT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg, ASSERT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
&username)); &out_msg, &username));
IceMessage* error_response = port->last_stun_msg(); IceMessage* error_response = port->last_stun_msg();
ASSERT_NE(nullptr, error_response); ASSERT_NE(nullptr, error_response);
@ -2522,7 +2532,8 @@ TEST_F(PortTest,
ByteBufferWriter buf; ByteBufferWriter buf;
WriteStunMessage(*modified_response, &buf); WriteStunMessage(*modified_response, &buf);
lconn->OnReadPacket(rtc::ReceivedPacket::CreateFromLegacy( lconn->OnReadPacket(rtc::ReceivedPacket::CreateFromLegacy(
buf.Data(), buf.Length(), /*packet_time_us=*/-1)); reinterpret_cast<const char*>(buf.Data()), buf.Length(),
/*packet_time_us=*/-1));
// Response should have been ignored, leaving us unwritable still. // Response should have been ignored, leaving us unwritable still.
EXPECT_FALSE(lconn->writable()); EXPECT_FALSE(lconn->writable());
} }
@ -2570,8 +2581,8 @@ TEST_F(PortTest, TestHandleStunBindingIndication) {
in_msg = CreateStunMessage(STUN_BINDING_INDICATION); in_msg = CreateStunMessage(STUN_BINDING_INDICATION);
in_msg->AddFingerprint(); in_msg->AddFingerprint();
WriteStunMessage(*in_msg, buf.get()); WriteStunMessage(*in_msg, buf.get());
EXPECT_TRUE(lport->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg, EXPECT_TRUE(GetStunMessageFromBufferWriter(lport.get(), buf.get(), addr,
&username)); &out_msg, &username));
EXPECT_TRUE(out_msg.get() != NULL); EXPECT_TRUE(out_msg.get() != NULL);
EXPECT_EQ(out_msg->type(), STUN_BINDING_INDICATION); EXPECT_EQ(out_msg->type(), STUN_BINDING_INDICATION);
EXPECT_EQ("", username); EXPECT_EQ("", username);

3
p2p/base/pseudo_tcp.cc
View file

@ -1183,7 +1183,8 @@ void PseudoTcp::queueConnectMessage() {
buf.WriteUInt8(m_rwnd_scale); buf.WriteUInt8(m_rwnd_scale);
} }
m_snd_wnd = static_cast<uint32_t>(buf.Length()); m_snd_wnd = static_cast<uint32_t>(buf.Length());
queue(buf.Data(), static_cast<uint32_t>(buf.Length()), true); queue(reinterpret_cast<const char*>(buf.Data()),
static_cast<uint32_t>(buf.Length()), true);
} }
void PseudoTcp::parseOptions(const char* data, uint32_t len) { void PseudoTcp::parseOptions(const char* data, uint32_t len) {

3
p2p/base/stun_server_unittest.cc
View file

@ -44,7 +44,8 @@ class StunServerTest : public ::testing::Test {
void Send(const StunMessage& msg) { void Send(const StunMessage& msg) {
rtc::ByteBufferWriter buf; rtc::ByteBufferWriter buf;
msg.Write(&buf); msg.Write(&buf);
Send(buf.Data(), static_cast<int>(buf.Length())); Send(reinterpret_cast<const char*>(buf.Data()),
static_cast<int>(buf.Length()));
} }
void Send(const char* buf, int len) { void Send(const char* buf, int len) {
client_->SendTo(buf, len, server_addr); client_->SendTo(buf, len, server_addr);

2
p2p/base/turn_port.cc
View file

@ -1802,7 +1802,7 @@ int TurnEntry::Send(const void* data,
// If the channel is bound, we can send the data as a Channel Message. // If the channel is bound, we can send the data as a Channel Message.
buf.WriteUInt16(channel_id_); buf.WriteUInt16(channel_id_);
buf.WriteUInt16(static_cast<uint16_t>(size)); buf.WriteUInt16(static_cast<uint16_t>(size));
buf.WriteBytes(reinterpret_cast<const char*>(data), size); buf.WriteBytes(reinterpret_cast<const uint8_t*>(data), size);
} }
rtc::PacketOptions modified_options(options); rtc::PacketOptions modified_options(options);
modified_options.info_signaled_after_sent.turn_overhead_bytes = modified_options.info_signaled_after_sent.turn_overhead_bytes =

3
p2p/base/turn_server.cc
View file

@ -784,8 +784,7 @@ void TurnServerAllocation::OnExternalPacket(rtc::AsyncPacketSocket* socket,
rtc::ByteBufferWriter buf; rtc::ByteBufferWriter buf;
buf.WriteUInt16(channel->id); buf.WriteUInt16(channel->id);
buf.WriteUInt16(static_cast<uint16_t>(packet.payload().size())); buf.WriteUInt16(static_cast<uint16_t>(packet.payload().size()));
buf.WriteBytes(reinterpret_cast<const char*>(packet.payload().data()), buf.WriteBytes(packet.payload().data(), packet.payload().size());
packet.payload().size());
server_->Send(&conn_, buf); server_->Send(&conn_, buf);
} else if (!server_->enable_permission_checks_ || } else if (!server_->enable_permission_checks_ ||
HasPermission(packet.source_address().ipaddr())) { HasPermission(packet.source_address().ipaddr())) {

4
p2p/stunprober/stun_prober.cc
View file

@ -156,8 +156,8 @@ void StunProber::Requester::SendStunRequest() {
// request timing could become too complicated. Callback is ignored by passing // request timing could become too complicated. Callback is ignored by passing
// empty AsyncCallback. // empty AsyncCallback.
rtc::PacketOptions options; rtc::PacketOptions options;
int rv = socket_->SendTo(const_cast<char*>(request_packet->Data()), int rv = socket_->SendTo(request_packet->Data(), request_packet->Length(),
request_packet->Length(), addr, options); addr, options);
if (rv < 0) { if (rv < 0) {
prober_->ReportOnFinished(WRITE_FAILED); prober_->ReportOnFinished(WRITE_FAILED);
return; return;

2
rtc_base/byte_buffer.cc
View file

@ -16,7 +16,7 @@ namespace rtc {
ByteBufferWriter::ByteBufferWriter() : ByteBufferWriterT() {} ByteBufferWriter::ByteBufferWriter() : ByteBufferWriterT() {}
ByteBufferWriter::ByteBufferWriter(const char* bytes, size_t len) ByteBufferWriter::ByteBufferWriter(const uint8_t* bytes, size_t len)
: ByteBufferWriterT(bytes, len) {} : ByteBufferWriterT(bytes, len) {}
ByteBufferReader::ByteBufferReader(rtc::ArrayView<const uint8_t> bytes) { ByteBufferReader::ByteBufferReader(rtc::ArrayView<const uint8_t> bytes) {

36
rtc_base/byte_buffer.h
View file

@ -58,25 +58,25 @@ class ByteBufferWriterT {
// Write value to the buffer. Resizes the buffer when it is // Write value to the buffer. Resizes the buffer when it is
// neccessary. // neccessary.
void WriteUInt8(uint8_t val) { void WriteUInt8(uint8_t val) {
WriteBytes(reinterpret_cast<const value_type*>(&val), 1); WriteBytesInternal(reinterpret_cast<const value_type*>(&val), 1);
} }
void WriteUInt16(uint16_t val) { void WriteUInt16(uint16_t val) {
uint16_t v = HostToNetwork16(val); uint16_t v = HostToNetwork16(val);
WriteBytes(reinterpret_cast<const value_type*>(&v), 2); WriteBytesInternal(reinterpret_cast<const value_type*>(&v), 2);
} }
void WriteUInt24(uint32_t val) { void WriteUInt24(uint32_t val) {
uint32_t v = HostToNetwork32(val); uint32_t v = HostToNetwork32(val);
value_type* start = reinterpret_cast<value_type*>(&v); value_type* start = reinterpret_cast<value_type*>(&v);
++start; ++start;
WriteBytes(start, 3); WriteBytesInternal(start, 3);
} }
void WriteUInt32(uint32_t val) { void WriteUInt32(uint32_t val) {
uint32_t v = HostToNetwork32(val); uint32_t v = HostToNetwork32(val);
WriteBytes(reinterpret_cast<const value_type*>(&v), 4); WriteBytesInternal(reinterpret_cast<const value_type*>(&v), 4);
} }
void WriteUInt64(uint64_t val) { void WriteUInt64(uint64_t val) {
uint64_t v = HostToNetwork64(val); uint64_t v = HostToNetwork64(val);
WriteBytes(reinterpret_cast<const value_type*>(&v), 8); WriteBytesInternal(reinterpret_cast<const value_type*>(&v), 8);
} }
// Serializes an unsigned varint in the format described by // Serializes an unsigned varint in the format described by
// https://developers.google.com/protocol-buffers/docs/encoding#varints // https://developers.google.com/protocol-buffers/docs/encoding#varints
@ -86,17 +86,25 @@ class ByteBufferWriterT {
// Write 7 bits at a time, then set the msb to a continuation byte // Write 7 bits at a time, then set the msb to a continuation byte
// (msb=1). // (msb=1).
value_type byte = static_cast<value_type>(val) | 0x80; value_type byte = static_cast<value_type>(val) | 0x80;
WriteBytes(&byte, 1); WriteBytesInternal(&byte, 1);
val >>= 7; val >>= 7;
} }
value_type last_byte = static_cast<value_type>(val); value_type last_byte = static_cast<value_type>(val);
WriteBytes(&last_byte, 1); WriteBytesInternal(&last_byte, 1);
} }
void WriteString(absl::string_view val) { void WriteString(absl::string_view val) {
WriteBytes(reinterpret_cast<const value_type*>(val.data()), val.size()); WriteBytesInternal(reinterpret_cast<const value_type*>(val.data()),
val.size());
} }
void WriteBytes(const value_type* val, size_t len) { // Write an array of bytes (uint8_t)
buffer_.AppendData(val, len); void WriteBytes(const uint8_t* val, size_t len) {
WriteBytesInternal(reinterpret_cast<const value_type*>(val), len);
}
// For backwards compatibility: Write an array of char
// TODO(bugs.webrtc.org/15665): Remove when users converted
[[deprecated("Use WriteString")]] void WriteBytes(const char* val,
size_t len) {
WriteBytesInternal(reinterpret_cast<const value_type*>(val), len);
} }
// Reserves the given number of bytes and returns a value_type* that can be // Reserves the given number of bytes and returns a value_type* that can be
@ -124,16 +132,20 @@ class ByteBufferWriterT {
} }
} }
void WriteBytesInternal(const value_type* val, size_t len) {
buffer_.AppendData(val, len);
}
BufferClassT buffer_; BufferClassT buffer_;
// There are sensible ways to define these, but they aren't needed in our code // There are sensible ways to define these, but they aren't needed in our code
// base. // base.
}; };
class ByteBufferWriter : public ByteBufferWriterT<BufferT<char>> { class ByteBufferWriter : public ByteBufferWriterT<BufferT<uint8_t>> {
public: public:
ByteBufferWriter(); ByteBufferWriter();
ByteBufferWriter(const char* bytes, size_t len); ByteBufferWriter(const uint8_t* bytes, size_t len);
ByteBufferWriter(const ByteBufferWriter&) = delete; ByteBufferWriter(const ByteBufferWriter&) = delete;
ByteBufferWriter& operator=(const ByteBufferWriter&) = delete; ByteBufferWriter& operator=(const ByteBufferWriter&) = delete;

4
rtc_base/byte_buffer_unittest.cc
View file

@ -166,7 +166,7 @@ TEST(ByteBufferTest, TestReadWriteBuffer) {
buffer.Clear(); buffer.Clear();
// Write and read bytes // Write and read bytes
char write_bytes[] = "foo"; uint8_t write_bytes[] = "foo";
buffer.WriteBytes(write_bytes, 3); buffer.WriteBytes(write_bytes, 3);
ByteBufferReader read_buf7(buffer); ByteBufferReader read_buf7(buffer);
uint8_t read_bytes[3]; uint8_t read_bytes[3];
@ -178,7 +178,7 @@ TEST(ByteBufferTest, TestReadWriteBuffer) {
buffer.Clear(); buffer.Clear();
// Write and read reserved buffer space // Write and read reserved buffer space
char* write_dst = buffer.ReserveWriteBuffer(3); uint8_t* write_dst = buffer.ReserveWriteBuffer(3);
memcpy(write_dst, write_bytes, 3); memcpy(write_dst, write_bytes, 3);
ByteBufferReader read_buf8(buffer); ByteBufferReader read_buf8(buffer);
memset(read_bytes, 0, 3); memset(read_bytes, 0, 3);

6
rtc_base/network/received_packet.cc
View file

@ -25,14 +25,12 @@ ReceivedPacket::ReceivedPacket(rtc::ArrayView<const uint8_t> payload,
// static // static
ReceivedPacket ReceivedPacket::CreateFromLegacy( ReceivedPacket ReceivedPacket::CreateFromLegacy(
const char* data, const uint8_t* data,
size_t size, size_t size,
int64_t packet_time_us, int64_t packet_time_us,
const rtc::SocketAddress& source_address) { const rtc::SocketAddress& source_address) {
RTC_DCHECK(packet_time_us == -1 || packet_time_us >= 0); RTC_DCHECK(packet_time_us == -1 || packet_time_us >= 0);
return ReceivedPacket(rtc::reinterpret_array_view<const uint8_t>( return ReceivedPacket(rtc::MakeArrayView(data, size), source_address,
rtc::MakeArrayView(data, size)),
source_address,
(packet_time_us >= 0) (packet_time_us >= 0)
? absl::optional<webrtc::Timestamp>( ? absl::optional<webrtc::Timestamp>(
webrtc::Timestamp::Micros(packet_time_us)) webrtc::Timestamp::Micros(packet_time_us))

9
rtc_base/network/received_packet.h
View file

@ -47,6 +47,15 @@ class RTC_EXPORT ReceivedPacket {
const char* data, const char* data,
size_t size, size_t size,
int64_t packet_time_us, int64_t packet_time_us,
const rtc::SocketAddress& addr = rtc::SocketAddress()) {
return CreateFromLegacy(reinterpret_cast<const uint8_t*>(data), size,
packet_time_us, addr);
}
static ReceivedPacket CreateFromLegacy(
const uint8_t* data,
size_t size,
int64_t packet_time_us,
const rtc::SocketAddress& = rtc::SocketAddress()); const rtc::SocketAddress& = rtc::SocketAddress());
private: private:

2
rtc_base/socket_adapters.cc
View file

@ -629,7 +629,7 @@ void AsyncSocksProxySocket::SendAuth() {
size_t len = pass_.GetLength() + 1; size_t len = pass_.GetLength() + 1;
char* sensitive = new char[len]; char* sensitive = new char[len];
pass_.CopyTo(sensitive, true); pass_.CopyTo(sensitive, true);
request.WriteBytes(sensitive, pass_.GetLength()); // Password request.WriteString(std::string(sensitive, pass_.GetLength())); // Password
ExplicitZeroMemory(sensitive, len); ExplicitZeroMemory(sensitive, len);
delete[] sensitive; delete[] sensitive;
DirectSend(request.Data(), request.Length()); DirectSend(request.Data(), request.Length());

2
video/rtp_video_stream_receiver2_unittest.cc
View file

@ -118,7 +118,7 @@ class MockOnCompleteFrameCallback
void AppendExpectedBitstream(const uint8_t data[], size_t size_in_bytes) { void AppendExpectedBitstream(const uint8_t data[], size_t size_in_bytes) {
// TODO(Johan): Let rtc::ByteBuffer handle uint8_t* instead of char*. // TODO(Johan): Let rtc::ByteBuffer handle uint8_t* instead of char*.
buffer_.WriteBytes(reinterpret_cast<const char*>(data), size_in_bytes); buffer_.WriteBytes(data, size_in_bytes);
} }
rtc::ByteBufferWriter buffer_; rtc::ByteBufferWriter buffer_;
}; };