1 // Copyright 2014 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/tools/quic/quic_simple_server_packet_writer.h"
6
7 #include <utility>
8
9 #include "base/check_op.h"
10 #include "base/functional/bind.h"
11 #include "base/location.h"
12 #include "base/metrics/histogram_functions.h"
13 #include "net/base/io_buffer.h"
14 #include "net/base/net_errors.h"
15 #include "net/quic/address_utils.h"
16 #include "net/socket/udp_server_socket.h"
17 #include "net/third_party/quiche/src/quiche/quic/core/quic_dispatcher.h"
18
19 namespace net {
20
QuicSimpleServerPacketWriter(UDPServerSocket * socket,quic::QuicDispatcher * dispatcher)21 QuicSimpleServerPacketWriter::QuicSimpleServerPacketWriter(
22 UDPServerSocket* socket,
23 quic::QuicDispatcher* dispatcher)
24 : socket_(socket), dispatcher_(dispatcher) {}
25
26 QuicSimpleServerPacketWriter::~QuicSimpleServerPacketWriter() = default;
27
OnWriteComplete(int rv)28 void QuicSimpleServerPacketWriter::OnWriteComplete(int rv) {
29 DCHECK_NE(rv, ERR_IO_PENDING);
30 write_blocked_ = false;
31 quic::WriteResult result(
32 rv < 0 ? quic::WRITE_STATUS_ERROR : quic::WRITE_STATUS_OK, rv);
33 dispatcher_->OnCanWrite();
34 }
35
IsWriteBlocked() const36 bool QuicSimpleServerPacketWriter::IsWriteBlocked() const {
37 return write_blocked_;
38 }
39
SetWritable()40 void QuicSimpleServerPacketWriter::SetWritable() {
41 write_blocked_ = false;
42 }
43
MessageTooBigErrorCode() const44 std::optional<int> QuicSimpleServerPacketWriter::MessageTooBigErrorCode()
45 const {
46 return ERR_MSG_TOO_BIG;
47 }
48
WritePacket(const char * buffer,size_t buf_len,const quic::QuicIpAddress & self_address,const quic::QuicSocketAddress & peer_address,quic::PerPacketOptions * options,const quic::QuicPacketWriterParams & params)49 quic::WriteResult QuicSimpleServerPacketWriter::WritePacket(
50 const char* buffer,
51 size_t buf_len,
52 const quic::QuicIpAddress& self_address,
53 const quic::QuicSocketAddress& peer_address,
54 quic::PerPacketOptions* options,
55 const quic::QuicPacketWriterParams& params) {
56 scoped_refptr<StringIOBuffer> buf =
57 base::MakeRefCounted<StringIOBuffer>(std::string(buffer, buf_len));
58 DCHECK(!IsWriteBlocked());
59 int rv;
60 if (buf_len <= static_cast<size_t>(std::numeric_limits<int>::max())) {
61 rv = socket_->SendTo(
62 buf.get(), static_cast<int>(buf_len), ToIPEndPoint(peer_address),
63 base::BindOnce(&QuicSimpleServerPacketWriter::OnWriteComplete,
64 weak_factory_.GetWeakPtr()));
65 } else {
66 rv = ERR_MSG_TOO_BIG;
67 }
68 quic::WriteStatus status = quic::WRITE_STATUS_OK;
69 if (rv < 0) {
70 if (rv != ERR_IO_PENDING) {
71 base::UmaHistogramSparse("Net.quic::QuicSession.WriteError", -rv);
72 status = quic::WRITE_STATUS_ERROR;
73 } else {
74 status = quic::WRITE_STATUS_BLOCKED_DATA_BUFFERED;
75 write_blocked_ = true;
76 }
77 }
78 return quic::WriteResult(status, rv);
79 }
80
GetMaxPacketSize(const quic::QuicSocketAddress & peer_address) const81 quic::QuicByteCount QuicSimpleServerPacketWriter::GetMaxPacketSize(
82 const quic::QuicSocketAddress& peer_address) const {
83 return quic::kMaxOutgoingPacketSize;
84 }
85
SupportsReleaseTime() const86 bool QuicSimpleServerPacketWriter::SupportsReleaseTime() const {
87 return false;
88 }
89
IsBatchMode() const90 bool QuicSimpleServerPacketWriter::IsBatchMode() const {
91 return false;
92 }
93
SupportsEcn() const94 bool QuicSimpleServerPacketWriter::SupportsEcn() const {
95 return false;
96 }
97
GetNextWriteLocation(const quic::QuicIpAddress & self_address,const quic::QuicSocketAddress & peer_address)98 quic::QuicPacketBuffer QuicSimpleServerPacketWriter::GetNextWriteLocation(
99 const quic::QuicIpAddress& self_address,
100 const quic::QuicSocketAddress& peer_address) {
101 return {nullptr, nullptr};
102 }
103
Flush()104 quic::WriteResult QuicSimpleServerPacketWriter::Flush() {
105 return quic::WriteResult(quic::WRITE_STATUS_OK, 0);
106 }
107
108 } // namespace net
109