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
|
// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "services/network/restricted_udp_socket.h"
#include "base/functional/bind.h"
#include "mojo/public/cpp/bindings/message.h"
#include "net/base/ip_address.h"
#include "net/base/ip_endpoint.h"
#include "net/base/net_errors.h"
#include "net/base/network_anonymization_key.h"
#include "services/network/public/cpp/simple_host_resolver.h"
#include "services/network/public/mojom/host_resolver.mojom.h"
#include "services/network/udp_socket.h"
namespace network {
RestrictedUDPSocket::RestrictedUDPSocket(
std::unique_ptr<UDPSocket> udp_socket,
net::MutableNetworkTrafficAnnotationTag traffic_annotation,
std::unique_ptr<SimpleHostResolver> resolver,
bool allow_multicast)
: udp_socket_(std::move(udp_socket)),
traffic_annotation_(std::move(traffic_annotation)),
resolver_(std::move(resolver)),
allow_multicast_(allow_multicast) {}
RestrictedUDPSocket::~RestrictedUDPSocket() = default;
void RestrictedUDPSocket::JoinGroup(const net::IPAddress& group_address,
JoinGroupCallback callback) {
if (!allow_multicast_) {
// Calling this method without the permission means that the renderer is
// sending faulty IPCs.
mojo::ReportBadMessage("no permission to use multicast");
return;
}
udp_socket_->JoinGroup(group_address, std::move(callback));
}
void RestrictedUDPSocket::LeaveGroup(const net::IPAddress& group_address,
LeaveGroupCallback callback) {
if (!allow_multicast_) {
// Calling this method without the permission means that the renderer is
// sending faulty IPCs.
mojo::ReportBadMessage("no permission to use multicast");
return;
}
udp_socket_->LeaveGroup(group_address, std::move(callback));
}
void RestrictedUDPSocket::ReceiveMore(uint32_t num_additional_datagrams) {
udp_socket_->ReceiveMore(num_additional_datagrams);
}
void RestrictedUDPSocket::Send(base::span<const uint8_t> data,
SendCallback callback) {
udp_socket_->Send(std::move(data), traffic_annotation_, std::move(callback));
}
void RestrictedUDPSocket::SendTo(base::span<const uint8_t> data,
const net::HostPortPair& dest_addr,
net::DnsQueryType dns_query_type,
SendToCallback callback) {
// If a raw IP address is supplied, call SendTo() immediately.
if (net::IPAddress address; address.AssignFromIPLiteral(dest_addr.host())) {
udp_socket_->SendTo(net::IPEndPoint(std::move(address), dest_addr.port()),
data, traffic_annotation_, std::move(callback));
return;
}
auto params = mojom::ResolveHostParameters::New();
params->dns_query_type = dns_query_type;
resolver_->ResolveHost(
mojom::HostResolverHost::NewHostPortPair(dest_addr),
net::NetworkAnonymizationKey::CreateTransient(), std::move(params),
base::BindOnce(&RestrictedUDPSocket::OnResolveCompleteForSendTo,
base::Unretained(this),
/*data=*/std::vector<uint8_t>(data.begin(), data.end()),
/*callback=*/std::move(callback)));
}
#if BUILDFLAG(IS_CHROMEOS)
void RestrictedUDPSocket::AttachConnectionTracker(
mojo::PendingRemote<mojom::SocketConnectionTracker> connection_tracker) {
connection_tracker_ = std::move(connection_tracker);
}
#endif // BUILDFLAG(IS_CHROMEOS)
void RestrictedUDPSocket::OnResolveCompleteForSendTo(
std::vector<uint8_t> data,
SendToCallback callback,
int result,
const net::ResolveErrorInfo&,
const net::AddressList& resolved_addresses,
const net::HostResolverEndpointResults&) {
if (result != net::OK) {
std::move(callback).Run(result);
return;
}
udp_socket_->SendTo(resolved_addresses.front(), std::move(data),
traffic_annotation_, std::move(callback));
}
} // namespace network
|
