1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "net/tools/quic/quic_client.h"
8 #include <netinet/in.h>
10 #include <sys/epoll.h>
11 #include <sys/socket.h>
14 #include "base/logging.h"
15 #include "net/quic/crypto/quic_random.h"
16 #include "net/quic/quic_connection.h"
17 #include "net/quic/quic_data_reader.h"
18 #include "net/quic/quic_protocol.h"
19 #include "net/quic/quic_server_id.h"
20 #include "net/tools/balsa/balsa_headers.h"
21 #include "net/tools/epoll_server/epoll_server.h"
22 #include "net/tools/quic/quic_epoll_connection_helper.h"
23 #include "net/tools/quic/quic_socket_utils.h"
24 #include "net/tools/quic/quic_spdy_client_stream.h"
25 #include "net/tools/quic/spdy_utils.h"
28 #define SO_RXQ_OVFL 40
37 const int kEpollFlags
= EPOLLIN
| EPOLLOUT
| EPOLLET
;
39 QuicClient::QuicClient(IPEndPoint server_address
,
40 const QuicServerId
& server_id
,
41 const QuicVersionVector
& supported_versions
,
42 EpollServer
* epoll_server
)
43 : server_address_(server_address
),
44 server_id_(server_id
),
46 epoll_server_(epoll_server
),
48 helper_(CreateQuicConnectionHelper()),
51 overflow_supported_(false),
52 supported_versions_(supported_versions
),
53 store_response_(false),
54 latest_response_code_(-1) {
57 QuicClient::QuicClient(IPEndPoint server_address
,
58 const QuicServerId
& server_id
,
59 const QuicVersionVector
& supported_versions
,
60 const QuicConfig
& config
,
61 EpollServer
* epoll_server
)
62 : server_address_(server_address
),
63 server_id_(server_id
),
66 epoll_server_(epoll_server
),
68 helper_(CreateQuicConnectionHelper()),
71 overflow_supported_(false),
72 supported_versions_(supported_versions
),
73 store_response_(false),
74 latest_response_code_(-1) {
77 QuicClient::~QuicClient() {
79 session()->connection()->SendConnectionClosePacket(
80 QUIC_PEER_GOING_AWAY
, "");
86 bool QuicClient::Initialize() {
87 DCHECK(!initialized_
);
89 // If an initial flow control window has not explicitly been set, then use the
90 // same value that Chrome uses: 10 Mb.
91 const uint32 kInitialFlowControlWindow
= 10 * 1024 * 1024; // 10 Mb
92 if (config_
.GetInitialStreamFlowControlWindowToSend() ==
93 kMinimumFlowControlSendWindow
) {
94 config_
.SetInitialStreamFlowControlWindowToSend(kInitialFlowControlWindow
);
96 if (config_
.GetInitialSessionFlowControlWindowToSend() ==
97 kMinimumFlowControlSendWindow
) {
98 config_
.SetInitialSessionFlowControlWindowToSend(kInitialFlowControlWindow
);
101 epoll_server_
->set_timeout_in_us(50 * 1000);
103 if (!CreateUDPSocket()) {
107 epoll_server_
->RegisterFD(fd_
, this, kEpollFlags
);
112 QuicClient::DummyPacketWriterFactory::DummyPacketWriterFactory(
113 QuicPacketWriter
* writer
)
116 QuicClient::DummyPacketWriterFactory::~DummyPacketWriterFactory() {}
118 QuicPacketWriter
* QuicClient::DummyPacketWriterFactory::Create(
119 QuicConnection
* /*connection*/) const {
124 bool QuicClient::CreateUDPSocket() {
125 int address_family
= server_address_
.GetSockAddrFamily();
126 fd_
= socket(address_family
, SOCK_DGRAM
| SOCK_NONBLOCK
, IPPROTO_UDP
);
128 LOG(ERROR
) << "CreateSocket() failed: " << strerror(errno
);
132 int get_overflow
= 1;
133 int rc
= setsockopt(fd_
, SOL_SOCKET
, SO_RXQ_OVFL
, &get_overflow
,
134 sizeof(get_overflow
));
136 DLOG(WARNING
) << "Socket overflow detection not supported";
138 overflow_supported_
= true;
141 if (!QuicSocketUtils::SetReceiveBufferSize(fd_
,
142 kDefaultSocketReceiveBuffer
)) {
146 if (!QuicSocketUtils::SetSendBufferSize(fd_
, kDefaultSocketReceiveBuffer
)) {
150 rc
= QuicSocketUtils::SetGetAddressInfo(fd_
, address_family
);
152 LOG(ERROR
) << "IP detection not supported" << strerror(errno
);
156 if (bind_to_address_
.size() != 0) {
157 client_address_
= IPEndPoint(bind_to_address_
, local_port_
);
158 } else if (address_family
== AF_INET
) {
159 IPAddressNumber any4
;
160 CHECK(net::ParseIPLiteralToNumber("0.0.0.0", &any4
));
161 client_address_
= IPEndPoint(any4
, local_port_
);
163 IPAddressNumber any6
;
164 CHECK(net::ParseIPLiteralToNumber("::", &any6
));
165 client_address_
= IPEndPoint(any6
, local_port_
);
168 sockaddr_storage raw_addr
;
169 socklen_t raw_addr_len
= sizeof(raw_addr
);
170 CHECK(client_address_
.ToSockAddr(reinterpret_cast<sockaddr
*>(&raw_addr
),
173 reinterpret_cast<const sockaddr
*>(&raw_addr
),
176 LOG(ERROR
) << "Bind failed: " << strerror(errno
);
180 SockaddrStorage storage
;
181 if (getsockname(fd_
, storage
.addr
, &storage
.addr_len
) != 0 ||
182 !client_address_
.FromSockAddr(storage
.addr
, storage
.addr_len
)) {
183 LOG(ERROR
) << "Unable to get self address. Error: " << strerror(errno
);
189 bool QuicClient::Connect() {
191 while (EncryptionBeingEstablished()) {
194 return session_
->connection()->connected();
197 void QuicClient::StartConnect() {
198 DCHECK(initialized_
);
199 DCHECK(!connected());
201 QuicPacketWriter
* writer
= CreateQuicPacketWriter();
203 DummyPacketWriterFactory
factory(writer
);
205 session_
.reset(new QuicClientSession(
207 new QuicConnection(GenerateConnectionId(), server_address_
, helper_
.get(),
209 /* owns_writer= */ false, Perspective::IS_CLIENT
,
210 server_id_
.is_https(), supported_versions_
)));
212 // Reset |writer_| after |session_| so that the old writer outlives the old
214 if (writer_
.get() != writer
) {
215 writer_
.reset(writer
);
217 session_
->InitializeSession(server_id_
, &crypto_config_
);
218 session_
->CryptoConnect();
221 bool QuicClient::EncryptionBeingEstablished() {
222 return !session_
->IsEncryptionEstablished() &&
223 session_
->connection()->connected();
226 void QuicClient::Disconnect() {
227 DCHECK(initialized_
);
230 session()->connection()->SendConnectionClose(QUIC_PEER_GOING_AWAY
);
235 initialized_
= false;
238 void QuicClient::CleanUpUDPSocket() {
240 epoll_server_
->UnregisterFD(fd_
);
246 void QuicClient::SendRequest(const BalsaHeaders
& headers
,
249 QuicSpdyClientStream
* stream
= CreateReliableClientStream();
250 if (stream
== nullptr) {
251 LOG(DFATAL
) << "stream creation failed!";
255 SpdyUtils::RequestHeadersToSpdyHeaders(headers
), body
, fin
);
256 stream
->set_visitor(this);
259 void QuicClient::SendRequestAndWaitForResponse(
260 const BalsaHeaders
& headers
,
263 SendRequest(headers
, body
, fin
);
264 while (WaitForEvents()) {}
267 void QuicClient::SendRequestsAndWaitForResponse(
268 const vector
<string
>& url_list
) {
269 for (size_t i
= 0; i
< url_list
.size(); ++i
) {
270 BalsaHeaders headers
;
271 headers
.SetRequestFirstlineFromStringPieces("GET", url_list
[i
], "HTTP/1.1");
272 SendRequest(headers
, "", true);
274 while (WaitForEvents()) {}
277 QuicSpdyClientStream
* QuicClient::CreateReliableClientStream() {
282 return session_
->CreateOutgoingDataStream();
285 void QuicClient::WaitForStreamToClose(QuicStreamId id
) {
288 while (connected() && !session_
->IsClosedStream(id
)) {
293 void QuicClient::WaitForCryptoHandshakeConfirmed() {
296 while (connected() && !session_
->IsCryptoHandshakeConfirmed()) {
301 bool QuicClient::WaitForEvents() {
304 epoll_server_
->WaitForEventsAndExecuteCallbacks();
305 return session_
->num_active_requests() != 0;
308 void QuicClient::OnEvent(int fd
, EpollEvent
* event
) {
311 if (event
->in_events
& EPOLLIN
) {
312 while (connected() && ReadAndProcessPacket()) {
315 if (connected() && (event
->in_events
& EPOLLOUT
)) {
316 writer_
->SetWritable();
317 session_
->connection()->OnCanWrite();
319 if (event
->in_events
& EPOLLERR
) {
320 DVLOG(1) << "Epollerr";
324 void QuicClient::OnClose(QuicDataStream
* stream
) {
325 QuicSpdyClientStream
* client_stream
=
326 static_cast<QuicSpdyClientStream
*>(stream
);
327 BalsaHeaders headers
;
328 SpdyUtils::FillBalsaResponseHeaders(client_stream
->headers(), &headers
);
330 if (response_listener_
.get() != nullptr) {
331 response_listener_
->OnCompleteResponse(
332 stream
->id(), headers
, client_stream
->data());
335 // Store response headers and body.
336 if (store_response_
) {
337 latest_response_code_
= headers
.parsed_response_code();
338 headers
.DumpHeadersToString(&latest_response_headers_
);
339 latest_response_body_
= client_stream
->data();
343 bool QuicClient::connected() const {
344 return session_
.get() && session_
->connection() &&
345 session_
->connection()->connected();
348 bool QuicClient::goaway_received() const {
349 return session_
!= nullptr && session_
->goaway_received();
352 size_t QuicClient::latest_response_code() const {
353 LOG_IF(DFATAL
, !store_response_
) << "Response not stored!";
354 return latest_response_code_
;
357 const string
& QuicClient::latest_response_headers() const {
358 LOG_IF(DFATAL
, !store_response_
) << "Response not stored!";
359 return latest_response_headers_
;
362 const string
& QuicClient::latest_response_body() const {
363 LOG_IF(DFATAL
, !store_response_
) << "Response not stored!";
364 return latest_response_body_
;
367 QuicConnectionId
QuicClient::GenerateConnectionId() {
368 return QuicRandom::GetInstance()->RandUint64();
371 QuicEpollConnectionHelper
* QuicClient::CreateQuicConnectionHelper() {
372 return new QuicEpollConnectionHelper(epoll_server_
);
375 QuicPacketWriter
* QuicClient::CreateQuicPacketWriter() {
376 return new QuicDefaultPacketWriter(fd_
);
379 int QuicClient::ReadPacket(char* buffer
,
381 IPEndPoint
* server_address
,
382 IPAddressNumber
* client_ip
) {
383 return QuicSocketUtils::ReadPacket(
384 fd_
, buffer
, buffer_len
,
385 overflow_supported_
? &packets_dropped_
: nullptr, client_ip
,
389 bool QuicClient::ReadAndProcessPacket() {
390 // Allocate some extra space so we can send an error if the server goes over
392 char buf
[2 * kMaxPacketSize
];
394 IPEndPoint server_address
;
395 IPAddressNumber client_ip
;
397 int bytes_read
= ReadPacket(buf
, arraysize(buf
), &server_address
, &client_ip
);
399 if (bytes_read
< 0) {
403 QuicEncryptedPacket
packet(buf
, bytes_read
, false);
405 IPEndPoint
client_address(client_ip
, client_address_
.port());
406 session_
->connection()->ProcessUdpPacket(
407 client_address
, server_address
, packet
);