chromium/net/quic/quic_proxy_datagram_client_socket.cc

// Copyright 2024 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/quic/quic_proxy_datagram_client_socket.h"

#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/strings/stringprintf.h"
#include "base/values.h"
#include "net/base/net_errors.h"
#include "net/base/proxy_chain.h"
#include "net/base/proxy_delegate.h"
#include "net/http/http_log_util.h"
#include "net/http/http_response_headers.h"
#include "net/log/net_log_source.h"
#include "net/log/net_log_source_type.h"
#include "net/spdy/spdy_http_utils.h"

namespace net {

QuicProxyDatagramClientSocket::QuicProxyDatagramClientSocket(
    const GURL& url,
    const ProxyChain& proxy_chain,
    const std::string& user_agent,
    const NetLogWithSource& source_net_log,
    ProxyDelegate* proxy_delegate)
    : … { … }

QuicProxyDatagramClientSocket::~QuicProxyDatagramClientSocket() { … }

const HttpResponseInfo* QuicProxyDatagramClientSocket::GetConnectResponseInfo()
    const { … }

bool QuicProxyDatagramClientSocket::IsConnected() const { … }

int QuicProxyDatagramClientSocket::ConnectViaStream(
    const IPEndPoint& local_address,
    const IPEndPoint& proxy_peer_address,
    std::unique_ptr<QuicChromiumClientStream::Handle> stream,
    CompletionOnceCallback callback) { … }

int QuicProxyDatagramClientSocket::Connect(const IPEndPoint& address) { … }

int QuicProxyDatagramClientSocket::ConnectAsync(
    const IPEndPoint& address,
    CompletionOnceCallback callback) { … }

int QuicProxyDatagramClientSocket::ConnectUsingDefaultNetworkAsync(
    const IPEndPoint& address,
    CompletionOnceCallback callback) { … }

int QuicProxyDatagramClientSocket::ConnectUsingNetwork(
    handles::NetworkHandle network,
    const IPEndPoint& address) { … }

int QuicProxyDatagramClientSocket::ConnectUsingDefaultNetwork(
    const IPEndPoint& address) { … }

int QuicProxyDatagramClientSocket::ConnectUsingNetworkAsync(
    handles::NetworkHandle network,
    const IPEndPoint& address,
    CompletionOnceCallback callback) { … }

void QuicProxyDatagramClientSocket::Close() { … }

int QuicProxyDatagramClientSocket::SetReceiveBufferSize(int32_t size) { … }

int QuicProxyDatagramClientSocket::SetSendBufferSize(int32_t size) { … }

void QuicProxyDatagramClientSocket::OnHttp3Datagram(
    quic::QuicStreamId stream_id,
    std::string_view payload) { … }

// Silently ignore unknown capsules.
void QuicProxyDatagramClientSocket::OnUnknownCapsule(
    quic::QuicStreamId stream_id,
    const quiche::UnknownCapsule& capsule) { … }

// Proxied connections are not on any specific network.
handles::NetworkHandle QuicProxyDatagramClientSocket::GetBoundNetwork() const { … }

// TODO(crbug.com/41497362): Implement method.
void QuicProxyDatagramClientSocket::ApplySocketTag(const SocketTag& tag) { … }

int QuicProxyDatagramClientSocket::SetMulticastInterface(
    uint32_t interface_index) { … }

void QuicProxyDatagramClientSocket::SetIOSNetworkServiceType(
    int ios_network_service_type) { … }

int QuicProxyDatagramClientSocket::GetPeerAddress(IPEndPoint* address) const { … }

int QuicProxyDatagramClientSocket::GetLocalAddress(IPEndPoint* address) const { … }

void QuicProxyDatagramClientSocket::UseNonBlockingIO() { … }

int QuicProxyDatagramClientSocket::SetDoNotFragment() { … }

int QuicProxyDatagramClientSocket::SetRecvTos() { … }

int QuicProxyDatagramClientSocket::SetTos(net::DiffServCodePoint dscp,
                                          net::EcnCodePoint ecn) { … }

void QuicProxyDatagramClientSocket::SetMsgConfirm(bool confirm) { … }

const NetLogWithSource& QuicProxyDatagramClientSocket::NetLog() const { … }

net::DscpAndEcn QuicProxyDatagramClientSocket::GetLastTos() const { … }

int QuicProxyDatagramClientSocket::Read(IOBuffer* buf,
                                        int buf_len,
                                        CompletionOnceCallback callback) { … }

int QuicProxyDatagramClientSocket::Write(
    IOBuffer* buf,
    int buf_len,
    CompletionOnceCallback callback,
    const NetworkTrafficAnnotationTag& traffic_annotation) { … }

void QuicProxyDatagramClientSocket::OnIOComplete(int result) { … }

int QuicProxyDatagramClientSocket::DoLoop(int last_io_result) { … }

int QuicProxyDatagramClientSocket::DoSendRequest() { … }

int QuicProxyDatagramClientSocket::DoSendRequestComplete(int result) { … }

int QuicProxyDatagramClientSocket::DoReadReply() { … }

int QuicProxyDatagramClientSocket::DoReadReplyComplete(int result) { … }

void QuicProxyDatagramClientSocket::OnReadResponseHeadersComplete(int result) { … }

int QuicProxyDatagramClientSocket::ProcessResponseHeaders(
    const quiche::HttpHeaderBlock& headers) { … }

}  // namespace net