// Copyright 2011 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "net/socket/udp_client_socket.h"

#include "base/task/single_thread_task_runner.h"
#include "build/build_config.h"
#include "net/base/net_errors.h"
#include "net/base/network_change_notifier.h"
#include "net/base/port_util.h"
#include "net/traffic_annotation/network_traffic_annotation.h"

namespace net {

namespace {

base::Value::Dict CreateNetLogUDPConnectParams(const IPEndPoint& address,
                                               int net_error) {
  DCHECK_NE(ERR_IO_PENDING, net_error);
  auto params = base::Value::Dict().Set("address", address.ToString());
  if (net_error < 0) {
    params.Set("net_error", net_error);
  }
  return params;
}

base::Value::Dict CreateNetLogUDPBindToNetworkParams(
    handles::NetworkHandle network,
    int net_error) {
  DCHECK_NE(ERR_IO_PENDING, net_error);
  auto params = base::Value::Dict().Set("network", static_cast<int>(network));
  if (net_error < 0) {
    params.Set("net_error", net_error);
  }
  return params;
}

}  // namespace

UDPClientSocket::UDPClientSocket(DatagramSocket::BindType bind_type,
                                 net::NetLog* net_log,
                                 const net::NetLogSource& source,
                                 handles::NetworkHandle network)
    : net_log_(
          NetLogWithSource::Make(net_log, NetLogSourceType::UDP_CLIENT_SOCKET)),
      socket_(bind_type, net_log, net_log_.source()),
      connect_using_network_(network) {
  net_log_.BeginEventReferencingSource(NetLogEventType::SOCKET_ALIVE, source);
}

UDPClientSocket::UDPClientSocket(DatagramSocket::BindType bind_type,
                                 NetLogWithSource source_net_log,
                                 handles::NetworkHandle network)
    : net_log_(NetLogWithSource::Make(source_net_log.net_log(),
                                      NetLogSourceType::UDP_CLIENT_SOCKET)),
      socket_(bind_type, net_log_),
      connect_using_network_(network) {
  net_log_.BeginEventReferencingSource(NetLogEventType::SOCKET_ALIVE,
                                       source_net_log.source());
}

UDPClientSocket::~UDPClientSocket() {
  net_log_.EndEvent(NetLogEventType::SOCKET_ALIVE);
}

int UDPClientSocket::Connect(const IPEndPoint& address) {
  CHECK(!connect_called_);
  if (!IsPortAllowedForIpEndpoint(address)) {
    return ERR_UNSAFE_PORT;
  }
  if (connect_using_network_ != handles::kInvalidNetworkHandle)
    return ConnectUsingNetwork(connect_using_network_, address);

  connect_called_ = true;
  int rv = OK;
  if (!adopted_opened_socket_) {
    rv = socket_.Open(address.GetFamily());
    net_log_.AddEventWithNetErrorCode(NetLogEventType::SOCKET_OPEN, rv);
  }
  if (rv != OK)
    return rv;
  rv = socket_.Connect(address);
  net_log_.AddEvent(NetLogEventType::SOCKET_CONNECT,
                    [&] { return CreateNetLogUDPConnectParams(address, rv); });
  return rv;
}

int UDPClientSocket::ConnectUsingNetwork(handles::NetworkHandle network,
                                         const IPEndPoint& address) {
  CHECK(!connect_called_);
  connect_called_ = true;
  if (!NetworkChangeNotifier::AreNetworkHandlesSupported())
    return ERR_NOT_IMPLEMENTED;
  int rv = OK;
  if (!adopted_opened_socket_) {
    rv = socket_.Open(address.GetFamily());
    net_log_.AddEventWithNetErrorCode(NetLogEventType::SOCKET_OPEN, rv);
  }
  if (rv != OK) {
    return rv;
  }
  rv = socket_.BindToNetwork(network);
  net_log_.AddEvent(NetLogEventType::SOCKET_BIND_TO_NETWORK, [&] {
    return CreateNetLogUDPBindToNetworkParams(network, rv);
  });
  if (rv != OK)
    return rv;
  network_ = network;
  rv = socket_.Connect(address);
  net_log_.AddEvent(NetLogEventType::SOCKET_CONNECT,
                    [&] { return CreateNetLogUDPConnectParams(address, rv); });
  return rv;
}

int UDPClientSocket::ConnectUsingDefaultNetwork(const IPEndPoint& address) {
  CHECK(!connect_called_);
  connect_called_ = true;
  if (!NetworkChangeNotifier::AreNetworkHandlesSupported())
    return ERR_NOT_IMPLEMENTED;
  int rv = OK;
  if (!adopted_opened_socket_) {
    rv = socket_.Open(address.GetFamily());
    net_log_.AddEventWithNetErrorCode(NetLogEventType::SOCKET_OPEN, rv);
  }
  if (rv != OK)
    return rv;
  // Calling connect() will bind a socket to the default network, however there
  // is no way to determine what network the socket got bound to.  The
  // alternative is to query what the default network is and bind the socket to
  // that network explicitly, however this is racy because the default network
  // can change in between when we query it and when we bind to it.  This is
  // rare but should be accounted for.  Since changes of the default network
  // should not come in quick succession, we can simply try again.
  handles::NetworkHandle network;
  for (int attempt = 0; attempt < 2; attempt++) {
    network = NetworkChangeNotifier::GetDefaultNetwork();
    if (network == handles::kInvalidNetworkHandle)
      return ERR_INTERNET_DISCONNECTED;
    rv = socket_.BindToNetwork(network);
    net_log_.AddEvent(NetLogEventType::SOCKET_BIND_TO_NETWORK, [&] {
      return CreateNetLogUDPBindToNetworkParams(network, rv);
    });
    // |network| may have disconnected between the call to GetDefaultNetwork()
    // and the call to BindToNetwork(). Loop only if this is the case (|rv| will
    // be ERR_NETWORK_CHANGED).
    if (rv != ERR_NETWORK_CHANGED)
      break;
  }
  if (rv != OK)
    return rv;
  network_ = network;
  rv = socket_.Connect(address);
  net_log_.AddEvent(NetLogEventType::SOCKET_CONNECT,
                    [&] { return CreateNetLogUDPConnectParams(address, rv); });
  return rv;
}

int UDPClientSocket::ConnectAsync(const IPEndPoint& address,
                                  CompletionOnceCallback callback) {
  DCHECK(callback);
  return Connect(address);
}

int UDPClientSocket::ConnectUsingNetworkAsync(handles::NetworkHandle network,
                                              const IPEndPoint& address,
                                              CompletionOnceCallback callback) {
  DCHECK(callback);
  return ConnectUsingNetwork(network, address);
}

int UDPClientSocket::ConnectUsingDefaultNetworkAsync(
    const IPEndPoint& address,
    CompletionOnceCallback callback) {
  DCHECK(callback);
  return ConnectUsingDefaultNetwork(address);
}

handles::NetworkHandle UDPClientSocket::GetBoundNetwork() const {
  return network_;
}

void UDPClientSocket::ApplySocketTag(const SocketTag& tag) {
  socket_.ApplySocketTag(tag);
}

int UDPClientSocket::Read(IOBuffer* buf,
                          int buf_len,
                          CompletionOnceCallback callback) {
  return socket_.Read(buf, buf_len, std::move(callback));
}

int UDPClientSocket::Write(
    IOBuffer* buf,
    int buf_len,
    CompletionOnceCallback callback,
    const NetworkTrafficAnnotationTag& traffic_annotation) {
  return socket_.Write(buf, buf_len, std::move(callback), traffic_annotation);
}

void UDPClientSocket::Close() {
  socket_.Close();
  adopted_opened_socket_ = false;
}

int UDPClientSocket::GetPeerAddress(IPEndPoint* address) const {
  return socket_.GetPeerAddress(address);
}

int UDPClientSocket::GetLocalAddress(IPEndPoint* address) const {
  return socket_.GetLocalAddress(address);
}

int UDPClientSocket::SetReceiveBufferSize(int32_t size) {
  return socket_.SetReceiveBufferSize(size);
}

int UDPClientSocket::SetSendBufferSize(int32_t size) {
  return socket_.SetSendBufferSize(size);
}

int UDPClientSocket::SetDoNotFragment() {
  return socket_.SetDoNotFragment();
}

int UDPClientSocket::SetRecvTos() {
  return socket_.SetRecvTos();
}

int UDPClientSocket::SetTos(DiffServCodePoint dscp, EcnCodePoint ecn) {
  return socket_.SetTos(dscp, ecn);
}

void UDPClientSocket::SetMsgConfirm(bool confirm) {
  socket_.SetMsgConfirm(confirm);
}

const NetLogWithSource& UDPClientSocket::NetLog() const {
  return socket_.NetLog();
}

void UDPClientSocket::UseNonBlockingIO() {
#if BUILDFLAG(IS_WIN)
  socket_.UseNonBlockingIO();
#endif
}

int UDPClientSocket::SetMulticastInterface(uint32_t interface_index) {
  return socket_.SetMulticastInterface(interface_index);
}

void UDPClientSocket::EnableRecvOptimization() {
#if BUILDFLAG(IS_POSIX)
  socket_.enable_experimental_recv_optimization();
#endif
}

void UDPClientSocket::SetIOSNetworkServiceType(int ios_network_service_type) {
#if BUILDFLAG(IS_POSIX)
  socket_.SetIOSNetworkServiceType(ios_network_service_type);
#endif
}

void UDPClientSocket::RegisterQuicConnectionClosePayload(
    base::span<uint8_t> payload) {
#if BUILDFLAG(IS_POSIX)
  socket_.RegisterQuicConnectionClosePayload(payload);
#endif
}

void UDPClientSocket::UnregisterQuicConnectionClosePayload() {
#if BUILDFLAG(IS_POSIX)
  socket_.UnregisterQuicConnectionClosePayload();
#endif
}

int UDPClientSocket::AdoptOpenedSocket(AddressFamily address_family,
                                       SocketDescriptor socket) {
  int rv = socket_.AdoptOpenedSocket(address_family, socket);
  if (rv == OK) {
    adopted_opened_socket_ = true;
  }
  return rv;
}

DscpAndEcn UDPClientSocket::GetLastTos() const {
  return socket_.GetLastTos();
}

}  // namespace net