1 // Copyright 2011 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "net/socket/udp_client_socket.h"
6
7 #include "base/task/single_thread_task_runner.h"
8 #include "build/build_config.h"
9 #include "net/base/net_errors.h"
10 #include "net/base/network_change_notifier.h"
11 #include "net/traffic_annotation/network_traffic_annotation.h"
12
13 namespace net {
14
15 namespace {
16
CreateNetLogUDPConnectParams(const IPEndPoint & address,int net_error)17 base::Value::Dict CreateNetLogUDPConnectParams(const IPEndPoint& address,
18 int net_error) {
19 DCHECK_NE(ERR_IO_PENDING, net_error);
20 base::Value::Dict params;
21 params.Set("address", address.ToString());
22 if (net_error < 0) {
23 params.Set("net_error", net_error);
24 }
25 return params;
26 }
27
CreateNetLogUDPBindToNetworkParams(handles::NetworkHandle network,int net_error)28 base::Value::Dict CreateNetLogUDPBindToNetworkParams(
29 handles::NetworkHandle network,
30 int net_error) {
31 DCHECK_NE(ERR_IO_PENDING, net_error);
32 base::Value::Dict params;
33 params.Set("network", static_cast<int>(network));
34 if (net_error < 0) {
35 params.Set("net_error", net_error);
36 }
37 return params;
38 }
39
40 } // namespace
41
UDPClientSocket(DatagramSocket::BindType bind_type,net::NetLog * net_log,const net::NetLogSource & source,handles::NetworkHandle network)42 UDPClientSocket::UDPClientSocket(DatagramSocket::BindType bind_type,
43 net::NetLog* net_log,
44 const net::NetLogSource& source,
45 handles::NetworkHandle network)
46 : net_log_(
47 NetLogWithSource::Make(net_log, NetLogSourceType::UDP_CLIENT_SOCKET)),
48 socket_(bind_type, net_log, net_log_.source()),
49 connect_using_network_(network) {
50 net_log_.BeginEventReferencingSource(NetLogEventType::SOCKET_ALIVE, source);
51 }
52
UDPClientSocket(DatagramSocket::BindType bind_type,NetLogWithSource source_net_log,handles::NetworkHandle network)53 UDPClientSocket::UDPClientSocket(DatagramSocket::BindType bind_type,
54 NetLogWithSource source_net_log,
55 handles::NetworkHandle network)
56 : net_log_(NetLogWithSource::Make(source_net_log.net_log(),
57 NetLogSourceType::UDP_CLIENT_SOCKET)),
58 socket_(bind_type, net_log_),
59 connect_using_network_(network) {
60 net_log_.BeginEventReferencingSource(NetLogEventType::SOCKET_ALIVE,
61 source_net_log.source());
62 }
63
~UDPClientSocket()64 UDPClientSocket::~UDPClientSocket() {
65 net_log_.EndEvent(NetLogEventType::SOCKET_ALIVE);
66 }
67
Connect(const IPEndPoint & address)68 int UDPClientSocket::Connect(const IPEndPoint& address) {
69 CHECK(!connect_called_);
70 if (connect_using_network_ != handles::kInvalidNetworkHandle)
71 return ConnectUsingNetwork(connect_using_network_, address);
72
73 connect_called_ = true;
74 int rv = OK;
75 if (!adopted_opened_socket_) {
76 rv = socket_.Open(address.GetFamily());
77 net_log_.AddEventWithNetErrorCode(NetLogEventType::SOCKET_OPEN, rv);
78 }
79 if (rv != OK)
80 return rv;
81 rv = socket_.Connect(address);
82 net_log_.AddEvent(NetLogEventType::SOCKET_CONNECT,
83 [&] { return CreateNetLogUDPConnectParams(address, rv); });
84 return rv;
85 }
86
ConnectUsingNetwork(handles::NetworkHandle network,const IPEndPoint & address)87 int UDPClientSocket::ConnectUsingNetwork(handles::NetworkHandle network,
88 const IPEndPoint& address) {
89 CHECK(!connect_called_);
90 connect_called_ = true;
91 if (!NetworkChangeNotifier::AreNetworkHandlesSupported())
92 return ERR_NOT_IMPLEMENTED;
93 int rv = OK;
94 if (!adopted_opened_socket_) {
95 rv = socket_.Open(address.GetFamily());
96 net_log_.AddEventWithNetErrorCode(NetLogEventType::SOCKET_OPEN, rv);
97 }
98 if (rv != OK) {
99 return rv;
100 }
101 rv = socket_.BindToNetwork(network);
102 net_log_.AddEvent(NetLogEventType::SOCKET_BIND_TO_NETWORK, [&] {
103 return CreateNetLogUDPBindToNetworkParams(network, rv);
104 });
105 if (rv != OK)
106 return rv;
107 network_ = network;
108 rv = socket_.Connect(address);
109 net_log_.AddEvent(NetLogEventType::SOCKET_CONNECT,
110 [&] { return CreateNetLogUDPConnectParams(address, rv); });
111 return rv;
112 }
113
ConnectUsingDefaultNetwork(const IPEndPoint & address)114 int UDPClientSocket::ConnectUsingDefaultNetwork(const IPEndPoint& address) {
115 CHECK(!connect_called_);
116 connect_called_ = true;
117 if (!NetworkChangeNotifier::AreNetworkHandlesSupported())
118 return ERR_NOT_IMPLEMENTED;
119 int rv = OK;
120 if (!adopted_opened_socket_) {
121 rv = socket_.Open(address.GetFamily());
122 net_log_.AddEventWithNetErrorCode(NetLogEventType::SOCKET_OPEN, rv);
123 }
124 if (rv != OK)
125 return rv;
126 // Calling connect() will bind a socket to the default network, however there
127 // is no way to determine what network the socket got bound to. The
128 // alternative is to query what the default network is and bind the socket to
129 // that network explicitly, however this is racy because the default network
130 // can change in between when we query it and when we bind to it. This is
131 // rare but should be accounted for. Since changes of the default network
132 // should not come in quick succession, we can simply try again.
133 handles::NetworkHandle network;
134 for (int attempt = 0; attempt < 2; attempt++) {
135 network = NetworkChangeNotifier::GetDefaultNetwork();
136 if (network == handles::kInvalidNetworkHandle)
137 return ERR_INTERNET_DISCONNECTED;
138 rv = socket_.BindToNetwork(network);
139 net_log_.AddEvent(NetLogEventType::SOCKET_BIND_TO_NETWORK, [&] {
140 return CreateNetLogUDPBindToNetworkParams(network, rv);
141 });
142 // |network| may have disconnected between the call to GetDefaultNetwork()
143 // and the call to BindToNetwork(). Loop only if this is the case (|rv| will
144 // be ERR_NETWORK_CHANGED).
145 if (rv != ERR_NETWORK_CHANGED)
146 break;
147 }
148 if (rv != OK)
149 return rv;
150 network_ = network;
151 rv = socket_.Connect(address);
152 net_log_.AddEvent(NetLogEventType::SOCKET_CONNECT,
153 [&] { return CreateNetLogUDPConnectParams(address, rv); });
154 return rv;
155 }
156
ConnectAsync(const IPEndPoint & address,CompletionOnceCallback callback)157 int UDPClientSocket::ConnectAsync(const IPEndPoint& address,
158 CompletionOnceCallback callback) {
159 DCHECK(callback);
160 return Connect(address);
161 }
162
ConnectUsingNetworkAsync(handles::NetworkHandle network,const IPEndPoint & address,CompletionOnceCallback callback)163 int UDPClientSocket::ConnectUsingNetworkAsync(handles::NetworkHandle network,
164 const IPEndPoint& address,
165 CompletionOnceCallback callback) {
166 DCHECK(callback);
167 return ConnectUsingNetwork(network, address);
168 }
169
ConnectUsingDefaultNetworkAsync(const IPEndPoint & address,CompletionOnceCallback callback)170 int UDPClientSocket::ConnectUsingDefaultNetworkAsync(
171 const IPEndPoint& address,
172 CompletionOnceCallback callback) {
173 DCHECK(callback);
174 return ConnectUsingDefaultNetwork(address);
175 }
176
GetBoundNetwork() const177 handles::NetworkHandle UDPClientSocket::GetBoundNetwork() const {
178 return network_;
179 }
180
ApplySocketTag(const SocketTag & tag)181 void UDPClientSocket::ApplySocketTag(const SocketTag& tag) {
182 socket_.ApplySocketTag(tag);
183 }
184
Read(IOBuffer * buf,int buf_len,CompletionOnceCallback callback)185 int UDPClientSocket::Read(IOBuffer* buf,
186 int buf_len,
187 CompletionOnceCallback callback) {
188 return socket_.Read(buf, buf_len, std::move(callback));
189 }
190
Write(IOBuffer * buf,int buf_len,CompletionOnceCallback callback,const NetworkTrafficAnnotationTag & traffic_annotation)191 int UDPClientSocket::Write(
192 IOBuffer* buf,
193 int buf_len,
194 CompletionOnceCallback callback,
195 const NetworkTrafficAnnotationTag& traffic_annotation) {
196 return socket_.Write(buf, buf_len, std::move(callback), traffic_annotation);
197 }
198
Close()199 void UDPClientSocket::Close() {
200 socket_.Close();
201 adopted_opened_socket_ = false;
202 }
203
GetPeerAddress(IPEndPoint * address) const204 int UDPClientSocket::GetPeerAddress(IPEndPoint* address) const {
205 return socket_.GetPeerAddress(address);
206 }
207
GetLocalAddress(IPEndPoint * address) const208 int UDPClientSocket::GetLocalAddress(IPEndPoint* address) const {
209 return socket_.GetLocalAddress(address);
210 }
211
SetReceiveBufferSize(int32_t size)212 int UDPClientSocket::SetReceiveBufferSize(int32_t size) {
213 return socket_.SetReceiveBufferSize(size);
214 }
215
SetSendBufferSize(int32_t size)216 int UDPClientSocket::SetSendBufferSize(int32_t size) {
217 return socket_.SetSendBufferSize(size);
218 }
219
SetDoNotFragment()220 int UDPClientSocket::SetDoNotFragment() {
221 return socket_.SetDoNotFragment();
222 }
223
SetRecvEcn()224 int UDPClientSocket::SetRecvEcn() {
225 return socket_.SetRecvEcn();
226 }
227
SetMsgConfirm(bool confirm)228 void UDPClientSocket::SetMsgConfirm(bool confirm) {
229 socket_.SetMsgConfirm(confirm);
230 }
231
NetLog() const232 const NetLogWithSource& UDPClientSocket::NetLog() const {
233 return socket_.NetLog();
234 }
235
UseNonBlockingIO()236 void UDPClientSocket::UseNonBlockingIO() {
237 #if BUILDFLAG(IS_WIN)
238 socket_.UseNonBlockingIO();
239 #endif
240 }
241
SetMulticastInterface(uint32_t interface_index)242 int UDPClientSocket::SetMulticastInterface(uint32_t interface_index) {
243 return socket_.SetMulticastInterface(interface_index);
244 }
245
EnableRecvOptimization()246 void UDPClientSocket::EnableRecvOptimization() {
247 #if BUILDFLAG(IS_POSIX)
248 socket_.enable_experimental_recv_optimization();
249 #endif
250 }
251
SetIOSNetworkServiceType(int ios_network_service_type)252 void UDPClientSocket::SetIOSNetworkServiceType(int ios_network_service_type) {
253 #if BUILDFLAG(IS_POSIX)
254 socket_.SetIOSNetworkServiceType(ios_network_service_type);
255 #endif
256 }
257
AdoptOpenedSocket(AddressFamily address_family,SocketDescriptor socket)258 int UDPClientSocket::AdoptOpenedSocket(AddressFamily address_family,
259 SocketDescriptor socket) {
260 int rv = socket_.AdoptOpenedSocket(address_family, socket);
261 if (rv == OK) {
262 adopted_opened_socket_ = true;
263 }
264 return rv;
265 }
266
267 } // namespace net
268