1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "remoting/protocol/stun_tcp_packet_processor.h"
#include "base/compiler_specific.h"
#include "base/containers/span.h"
#include "base/no_destructor.h"
#include "base/notreached.h"
#include "base/numerics/byte_conversions.h"
#include "net/base/io_buffer.h"
#include "third_party/webrtc/media/base/rtp_utils.h"
#include "third_party/webrtc/rtc_base/time_utils.h"
namespace remoting::protocol {
namespace {
using PacketLength = uint16_t;
constexpr size_t kPacketHeaderSize = sizeof(PacketLength);
constexpr size_t kStunHeaderSize = 20;
constexpr size_t kTurnChannelDataHeaderSize = 4;
constexpr size_t kPacketLengthOffset = 2;
int GetExpectedStunPacketSize(const uint8_t* data_ptr,
size_t len,
size_t* pad_bytes) {
// TODO(crbug.com/40284755): GetExpectedStunPacketSize() should receive a
// span.
auto data = UNSAFE_TODO(base::span(data_ptr, len));
DCHECK_LE(kTurnChannelDataHeaderSize, data.size());
// Get packet type (STUN or TURN).
uint16_t msg_type = base::U16FromBigEndian(data.subspan<0u, 2u>());
// Both stun and turn had length at offset 2.
size_t packet_size =
base::U16FromBigEndian(data.subspan<kPacketLengthOffset, 2u>());
*pad_bytes = 0;
// Add header length to packet length.
if ((msg_type & 0xC000) == 0) {
packet_size += kStunHeaderSize;
} else {
packet_size += kTurnChannelDataHeaderSize;
// Calculate any padding if present.
if (packet_size % 4) {
*pad_bytes = 4 - packet_size % 4;
}
}
return packet_size;
}
} // namespace
StunTcpPacketProcessor::StunTcpPacketProcessor() = default;
StunTcpPacketProcessor::~StunTcpPacketProcessor() = default;
// static
StunTcpPacketProcessor* StunTcpPacketProcessor::GetInstance() {
static base::NoDestructor<StunTcpPacketProcessor> instance;
return instance.get();
}
scoped_refptr<net::IOBufferWithSize> StunTcpPacketProcessor::Pack(
const uint8_t* data,
size_t data_size) const {
// Each packet is expected to have header (STUN/TURN ChannelData), where
// header contains message type and and length of message.
if (data_size < kPacketHeaderSize + kPacketLengthOffset) {
NOTREACHED();
}
size_t pad_bytes;
size_t expected_len = GetExpectedStunPacketSize(data, data_size, &pad_bytes);
// Accepts only complete STUN/TURN packets.
if (data_size != expected_len) {
NOTREACHED();
}
// Add any pad bytes to the total size.
size_t size = data_size + pad_bytes;
auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(size);
UNSAFE_TODO(memcpy(buffer->data(), data, data_size));
if (pad_bytes) {
char padding[4] = {};
DCHECK_LE(pad_bytes, 4u);
UNSAFE_TODO(memcpy(buffer->data() + data_size, padding, pad_bytes));
}
return buffer;
}
scoped_refptr<net::IOBufferWithSize> StunTcpPacketProcessor::Unpack(
const uint8_t* data,
size_t data_size,
size_t* bytes_consumed) const {
*bytes_consumed = 0;
if (data_size < kPacketHeaderSize + kPacketLengthOffset) {
return nullptr;
}
size_t pad_bytes;
size_t packet_size = GetExpectedStunPacketSize(data, data_size, &pad_bytes);
if (data_size < packet_size + pad_bytes) {
return nullptr;
}
// We have a complete packet.
const uint8_t* cur = data;
*bytes_consumed = packet_size + pad_bytes;
auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(packet_size);
UNSAFE_TODO(memcpy(buffer->data(), cur, packet_size));
return buffer;
}
void StunTcpPacketProcessor::ApplyPacketOptions(
uint8_t* data,
size_t data_size,
const webrtc::PacketTimeUpdateParams& packet_time_params) const {
webrtc::ApplyPacketOptions(webrtc::ArrayView<uint8_t>(data, data_size),
packet_time_params, webrtc::TimeMicros());
}
} // namespace remoting::protocol
|
